ocrampal/organism
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9a3d75af042aa3c2c98d282761375ebf411ed0c3
organism/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md
T

1310 lines
86 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Tripartite Synapse — Pseudocode v17
> Companion: `tripartite_synapse_v17_biology.md` · principle: `logic_principles_v3`.
> Changes from v16 — NIGHT is no longer an external driver; it is an EMERGENT, per-component
> state driven by a fatigue→sleep-pressure loop. Actors at every scale are written as peers.
> (1) EIGHT actors in one uniform template:
> LOCAL components — SOMA · PRE · POST · DEND · AXON · ASTROSYNAPSE (behave by DAY)
> CELL actors — NEURON (over soma/pre/post/dend/axon) · ASTROCYTE (over astrosynapses)
> SYSTEM actor — HYPOTHALAMUS (integrates fatigue, emits sleep-pressure)
> (2) DAY/NIGHT are PER-COMPONENT emergent states, not a global clock: a component is in NIGHT
> when its OWN activity is low AND sleep-pressure is high; back to DAY when pressure falls.
> (transition rule stated once in Conventions). The HYPOTHALAMUS alone is CONTINUOUS.
> (3) the external NIGHT driver is REMOVED. Restructuring is gated by local low-activity
> (behavior and restructuring are mutually exclusive at the substrate).
> (4) higher actors INTEGRATE constituents' emitted activity by their day and BROADCAST
> permission / renormalization / reallocation by their night — they never reach in;
> each component restructures ITSELF in response to arrived signals (locality holds).
> (5) governing rule: NO actor authorizes its own restructuring — each is PUT IN THE POSITION
> to restructure by the actor above it (which holds an aggregate it cannot see and opens a
> quiet window it cannot open). The system acts locally and consolidates hierarchically.
> Carried: cyclic/phased NIGHT, occupancy reset, tag-as-fuel, transit, two-resource metabolism.
---
## Functional groups (seven-group grammar)
```
RECEIVE take in resources + signals that arrived from outside (boundary: in)
TRACE maintain the trace hierarchy — deposit fast trace; accumulate
possible_tag + endurance_need; stabilize tag on coincidence
ADJUST compute local operating parameters from structure + traces + modulators
BEHAVE the component's defining action, within both ceilings
EMIT send out — signals (messages) + resources (shipments) (boundary: out)
RECOVER refill own private pools consumed by behaving
DECAY let traces recede, closing their windows
```
EVALUATE merged into TRACE: judging a behavior is always maintaining a trace, whether or not
a trace is written. BEHAVE and EMIT stay separate — EMIT is the output half of the locality
interface (RECEIVE/EMIT are the only boundary crossings). TRACE spans all timescales: the
soma's inactivation, adaptation, and nuclear-Ca deposits are all TRACE. Order within a context
follows data dependencies; TRACE reads/writes whatever trace state is current.
EVERY FLOW HAS A TIMESCALE. Decay relaxes toward 0 over τ; creation/arrival relaxes toward a
target over τ — the same first-order operator. Within-step writes are the special case τ ≪ Δt.
Rate-limited inflows (fill/refill/flux·Δt) carry their τ implicitly; shipment carries an
explicit transit delay (see `transit`).
THE GROUPS MOVE BETWEEN TIERS (the ladder; see logic_principles "The Timescale Ladder").
Four tiers: FAST (ms–s) · MEDIUM (s–min) · SLOW (hr) · PERSISTENT (NIGHT-written). The groups
move evidence UP the ladder and read capacity DOWN it:
```
ADJUST reads PERSISTENT ceiling + FAST trace → sets this step's operating point (down)
BEHAVE acts at FAST, bounded by the PERSISTENT ceiling (down)
TRACE deposits FAST, accumulates FAST→MEDIUM evidence, stabilizes MEDIUM→SLOW tag (up)
RECOVER refills toward the PERSISTENT ceiling (down)
DECAY relaxes FAST · MEDIUM · SLOW (PERSISTENT never decays in DAY)
NIGHT commits SLOW tag + MEDIUM endurance_need → PERSISTENT ceilings (up)
```
Capacity flows downward (slow sets the ceiling for fast); evidence flows upward (fast
accumulates toward slow). Each component's DECAY group below is banded by tier to show this.
NIGHT IS THE SAME GRAMMAR, ITERATED, WITH THE FLOW REVERSED. NIGHT is not a separate section —
each component carries a `NIGHT |` block, and a driver loops all blocks for cycle = 1,2,3…
until the night ends. DAY runs bottom-up (consumers act first, evidence ascends leaves→roots);
NIGHT runs top-down (producers act first, capacity descends roots→leaves). Per cycle, each
component:
```
RECEIVE take in the material + energy batch that arrived from my producer this cycle
TRACE read my own tag / endurance_need (the standing demand)
ADJUST size this cycle's commit from material + energy actually on hand
BEHAVE commit a BATCH: structure += Δ (from tag) ; budget_ceiling += Δ' (from need)
spend material + energy ; SPEND the tag/need by the committed amount (tag-as-fuel)
EMIT ship a batch of material + energy one hop down to my consumers (demand-weighted)
RECOVER reclaim material from any ceiling that decayed this cycle (energy is NOT recovered)
DECAY unmaintained ceilings drift down a little; tags decay a little
```
Roots (SOMA, ASTRO cell body) PRODUCE the batch each cycle (RECEIVE = production, capped by
glucose / CREB). The night ends when DEMAND is exhausted (no tag stands above tag_expiry,
system-wide) OR SUPPLY is spent (the night's energy throughput is used up) — whichever first.
Unspent tags are NOT cleared; they carry to the next DAY and compete again next NIGHT. The
top-down order needs no schedule: iterating the local cycle delivers capacity to distal sites
over successive cycles, as transport physically does.
DAY AND NIGHT ARE PER-COMPONENT EMERGENT STATES, NOT A GLOBAL CLOCK. There is no global SCOPE
variable. Each component is in its own DAY or NIGHT, decided locally from its own activity and
the arrived sleep-pressure signal. The labels `DAY | …` and `NIGHT | …` below denote these
LOCAL states. One transition rule governs every component (stated once here, not repeated):
```
TRANSITION (evaluated per component, from local state + the arrived signal):
enter NIGHT when own_activity < rest_thr AND sleep_pressure > sleep_thr
enter DAY when sleep_pressure < wake_thr
own_activity = the component's own running activity trace (it cannot restructure while busy:
behavior and restructuring compete for the same substrate — mutual exclusion).
sleep_pressure = arrived signal broadcast by the HYPOTHALAMUS (see below).
```
Components therefore cross into NIGHT at different times — a wave, not a switch (local sleep).
THE FATIGUE LOOP REPLACES THE EXTERNAL DRIVER. The system has no scheduler. Activity generates
fatigue; the hypothalamus integrates fatigue and broadcasts sleep-pressure; high pressure (plus
a component's own quiet) opens the restructuring window; restructuring discharges fatigue;
discharge lowers pressure; components re-enter DAY. DAY and NIGHT are the two phases of one
homeostatic loop the system runs on itself.
```
every component → emits fatigue (metabolic debt, unspent demand) ↑
HYPOTHALAMUS → integrates fatigue, emits sleep_pressure ↓ (CONTINUOUS — never sleeps)
every component → reads sleep_pressure + own activity → enters DAY or NIGHT locally
```
ACTORS ARE PEERS AT EVERY SCALE; EACH IS PUT IN POSITION BY THE ONE ABOVE. No actor authorizes
its own restructuring. Each holds an aggregate its constituents cannot see and opens a window
they cannot open, then BROADCASTS — it never reaches into a constituent's interior.
```
HYPOTHALAMUS integrates fatigue from all → broadcasts sleep_pressure (system, CONTINUOUS)
↓ signal
NEURON integrates its components' activity/weight → broadcasts (cell actor)
ASTROCYTE rest-permission + renormalization / reallocation (cell actor)
↓ signal (NEURON over soma/pre/post/dend/axon ; ASTROCYTE over astrosynapses)
COMPONENTS soma · pre · post · dend · axon · astrosynapse — each restructures ITSELF
when its own DAY/NIGHT transition (above) grants the window
[ ASSEMBLY / NETWORK ] replay is INTERNALLY generated (spontaneous firing, below); the external
replay_reweight only BIASES which internal patterns are favored (cross-neuron
coordination), arriving like dopamine/glucose — it is not the replay itself
```
The two cell actors are structurally identical — same integrate-and-broadcast role, different
constituents and conserved quantity: NEURON conserves activity/weight, ASTROCYTE conserves
territory demand/load. Both have their own DAY (integrate, allocate in the gaps) and NIGHT
(broadcast the restructuring window). The HYPOTHALAMUS alone has no night: it runs CONTINUOUS,
always integrating fatigue and emitting sleep-pressure, spanning every other actor's day and
night — the clock that never sleeps.
EVERY SCOPE RUNS THE SAME THREE CATEGORIES: (ACTION ⇄ RECOVERY) × many, then PREPARATION.
ACTION the scope's defining deed (DAY: release/fire/respond/propagate — the cleft exchange;
NIGHT: change structure — the irreversible build).
RECOVERY the fast alter-ego of the action — restore the ability to act again (DAY: vesicle
refill, refractory de-inactivation, Ca clearance; NIGHT: import material/energy, prime).
PREPARATION shape what comes next — faces BOTH the next same-scope action AND the other scope.
This is where what earlier drafts called "evaluation" lives: depositing a trace is not
judging, it is provisioning. DAY-preparation stocks the tag (for NIGHT) and sets
occupancy/thresholds (for the next action). NIGHT-preparation REPLAYS the action —
re-runs the SAME machinery as DAY ACTION (same capacity/vesicle checks, same endurance
deposit into the SAME trace), but with NO dopamine and the release as a PROBE, read as
participation, not transmitted.
NIGHT IS A SEQUENCE OF REPLAY CYCLES (dual of DAY). DAY loops until energy/material is exhausted;
NIGHT loops until the tag is exhausted. The rotation across scopes: the SAME physical release/fire
is ACTION by DAY (the deed) and PREPARATION by NIGHT (the probe that replays it); the structural
change is only MARKED by day (the inert tag) and ENACTED by night (its action). SOMA is the ignition
point: its night-PREPARATION replay-fire propagates a replay_AP through the DAY PATHWAYS
(soma→axon→pre→glutamate→post→dend→soma), self-igniting the tagged pattern.
COHERENCE IS MECHANICAL, not a checked flag: a pattern re-evokes only where EVERY link in its
recurrent loop is primed (each component's own tag lowered its own threshold in RECOVERY); one
un-primed link breaks the loop at the gap, so only patterns significant all the way around carry.
The assembly that replays is NOT an actor — it is the coincidence of many components' own lowered
thresholds propagating through recurrent coupling.
WHAT PERSISTS MUST HAVE EARNED PERSISTENCE. Night-RECOVERY drives occupancy (VGCC_active,
AMPA_surface, possible_tag) toward baseline; night-ACTION's homeostatic lowering trims all
structure; only what is rebuilt from a still-standing tag with confirmed participation carries
forward. NIGHT ends when the tag is exhausted (well-rested — every significant pattern replayed and
its structure rebuilt) OR energy is spent (overloaded — unspent tags carry to the next night).
---
## Conventions
```
SCOPE = {DAY, NIGHT} CONTEXT = {AP, NOT_AP, NOT_SPIKE_TRAIN, bAP, NOT_bAP, CONTINUOUS}
THE RING (see logic_principles "The Three-Phase Ring"): ACTION → EVALUATION → PREPARATION
ACTION lateral, punctate — the component's defining act; deposits the fast trace.
ALWAYS LOCAL to the acting component (cannot be done on another's behalf).
EVALUATION local — read the fresh trace, climb the ladder toward the tag (the token for NIGHT).
PREPARATION vertical — settle pools/gates forward, read what descended, ready the next action.
Phase edges are event/decay-timed, not clocked. EVALUATION and PREPARATION may be LOCAL or
CONTEXTUAL (supplied by a neighbor/higher component); ACTION is always local. A near-pure-action
component (e.g. a channel) is written ACTION-only, its eval/prep noted as contextual.
CONTEXT LICENSES PHASE (context = the imposed condition; phase = the work it permits).
The context is what other components impose (a spike delivered or not, a train present or not);
the phase annotation says which ring-work runs. Contexts can NEST, and nested contexts run
ON TOP of their parent — a behavior is written in exactly ONE context, so nothing double-runs:
AP spike this step → ACTION
NOT_AP no spike this step → FAST eval + FAST prep (in-train gaps AND quiet)
NOT_SPIKE_TRAIN no spike AND no train ⊂ NOT_AP → adds SLOW eval + SLOW prep (runs on top of NOT_AP)
A process runs in the SHORTEST quiet its timescale fits: fast-trace decay and partial pool refill
in NOT_AP (they ride the train and set short-term depression); tag formation, full refill, and
occupancy read-out in NOT_SPIKE_TRAIN. (Components without trains use only their ACTION / quiet
contexts, e.g. bAP / NOT_bAP, or continuous graded activity.)
VARIABLE TIERS (timescale = meaning; see logic_principles "The Timescale Ladder")
FAST (ms–s) immediate response fast_trace
MEDIUM (s–min) occupancy + evidence possible_tag · endurance_need · VGCC_active · AMPA_surface · RRP
SLOW (hr) consolidation bridge tag
─────────────────────────────────────────────────────────────────────────────
PERSISTENT (NIGHT) capacity (the ceilings) structure · budget_ceiling
energy (not recoverable) · material (recoverable)
THE DAY STRENGTH CLIMB (same three-tier averaging in every component):
1. each ACTION leaves a fast_trace (FAST).
2. the running AVERAGE of fast_traces over SECONDS fills occupancy → short-term strength
(VGCC_active in PRE, AMPA_surface in POST, …); a LOW average lets occupancy drift back (STD).
3. the AVERAGE-OF-THE-AVERAGE over MINUTES (possible_tag), in coincidence with dopamine, raises
the TAG (SLOW) — the token passed to NIGHT. At night the tag is spent to modify structure
(the persistent version of the same strength the occupancy held transiently).
So occupancy is the fast/medium memory of participation; the tag is its dopamine-validated,
night-consolidatable distillate. Same climb, same three tiers, in all six components.
DAY budget · fast_trace · possible_tag · endurance_need
BRIDGE tag (POST: CANDIDATE→STABLE)
NIGHT energy (not recoverable) · material (recoverable) · structure · budget_ceiling
LOCALITY only local state + arrived signals; no component reads another's internal state.
CLEFT MESSAGE CHANNELS SHIPMENT CHANNELS (transit-delayed)
glutamate PRE → POST, ASTRO soma_ship_dend SOMA→DEND
astro_Dserine ASTRO → POST soma_ship_axon SOMA→AXON
retro_NO POST → PRE (+) dend_ship_post DEND→POST
retro_eCB POST → PRE (−) axon_ship_pre AXON→PRE
```
---
## Primitives (return the increment; caller applies it)
```
sat(x, K) = x / (K + x)
fill(pool, ceiling, rate, cost, budget) -> amount: // PRIVATE reserve, rate-limited (implicit τ)
amount = min(rate, ceiling - pool)·Δt; budget -= amount·cost; return amount
refill(c from supply S) -> amount: // CONTESTED supply, gap-bounded
demand = c.budget_ceiling - c.budget
factor = min(1, S / (Σ demand over components on S + ε)); S -= demand·factor
return demand·factor
ship(from_budget, demand_sig, frac, cost) -> amount: // emit into transit (not to target directly)
amount = min(from_budget·frac, demand_sig); from_budget -= amount·(1+ship_cost); return amount
transit(channel, τ_transport) -> arrival: // delivers in-transit cargo over τ
arrival = channel·(Δt/τ_transport); channel -= arrival; return arrival
```
---
## SHARED parameters
```
dopamine NE ACh // organism broadcasts (external)
replay_reweight[·] // assembly/network replay re-weighting (external, NIGHT)
glucose geometry // physical (external)
sleep_pressure // emitted by HYPOTHALAMUS, read by all (the day/night signal)
rest_thr sleep_thr wake_thr // per-component DAY↔NIGHT transition thresholds
elig dop_thr tag_thr tag_expiry // strength gates (universal)
traj_thr endur_thr // endurance gates (universal)
ship_cost // transport overhead (all shipments)
{dend,axon,pre,post}_ship_frac // DAY budget-shipment fractions
τ_transport_{dend,axon,spine,bouton} // shipment transit times (distance-dependent)
ε
```
## NIGHT parameters (consolidation only)
```
slot_batch cap_batch f_cap // per-CYCLE commit/allocation sizes / endurance fraction
night_energy_ceiling // total energy a single night can spend (supply bound)
Δt_cycle // duration of one NIGHT cycle (recovery→preparation→action)
maint_frac cap_frac // maintenance allocation
decay_rate capacity_decay_rate recycle // passive ceiling decay + material recovery
homeostatic_ceiling assembly_cost biogenesis_cost maint_cost
f_dend f_axon f_spine f_bouton // per-cycle material/energy ship fractions (down the chain)
downscale_factor // per-cycle multiplicative occupancy reset (<1), night RECOVERY
neuron_weight_ceiling // renormalization target (broadcast constraint)
// ── NIGHT (RECOVERY = import/prime · PREPARATION = replay probe · ACTION = restructure) ──
spont_thr_base thr_gain // spontaneous threshold = base − gain×own_tag (night RECOVERY prime)
prime_thr prime_gain // tag threshold to raise VGCC, and the gain (night RECOVERY)
release_rate homeostatic_floor // night RELEASE: shed rate + floor structure never pruned below
intrinsic_fluctuation() // intrinsic sub-threshold noise (the night's ignition source)
mini_flux mini_Ca() // spontaneous mini release size + its Ca deposit (REM probe)
level(·) → {LOW, MEDIUM, HIGH} // reads fast_trace as circuit participation (REM, no dopamine)
replay_AP // propagated re-evocation spike (soma → axon/dend, self-igniting)
```
---
---
# LOCAL COMPONENTS
> Each behaves by its DAY and restructures by its NIGHT — per-component emergent states
> (see Conventions: the transition rule). `DAY | …` / `NIGHT | …` label local states, not a clock.
---
## PRE
The presynaptic bouton releases neurotransmitter and gathers evidence about whether that
release was worth strengthening and worth sustaining. Like every component it turns one ring —
ACTION → EVALUATION → PREPARATION — in two directions: outward by DAY (against the cleft), inward
by NIGHT (against the economy).
**DAY · ACTION (the AP) — the bouton releases.** The amount released depends on residual
**calcium** (the fast trace, set by this spike), the current **VGCC coupling occupancy** (how
tightly channels are coupled right now, bounded by structure), the two **retrograde messages**
(`retro_eCB` brakes, `retro_NO` confirms release reached a responsive target), and the
availability of **fuel and vesicles**. The action deposits the fast trace the rest of the turn
reads. Two shortfalls read differently: a fuel shortfall on a succeeding release is *endurance*
evidence; an empty pool with fuel to spare is ordinary short-term depression.
**DAY · EVALUATION (after the AP, trace fresh) — climb toward the tag.** Reading the fast trace,
the bouton accumulates eligibility (`possible_tag`) and, on the dopamine coincidence, the `tag` —
the inert token minted for the night. It never acts here; it lays down evidence.
**DAY · PREPARATION (trace decaying) — ready the next release.** The bouton latches the retrograde
messages, tightens its VGCC coupling from accumulated eligibility (reversible short-term
potentiation, no dopamine, bounded by structure — readiness, not evidence), refills budget and
vesicles *toward the next demand* (not a restoration — forward-facing), and lets its traces decay.
Preparation is the sole gateway to the next action.
**NIGHT — the same three categories as DAY, at a slower timescale, turned inward.** Every scope
runs the same shape: an alternation of ACTION ⇄ RECOVERY (many times), then PREPARATION. By DAY
that is (release ⇄ vesicle-refill) × many spikes, then preparation (climb the tag, set VGCC,
refill, thresholds). By NIGHT it is (restructure ⇄ material-import) × many cycles, then preparation
(the probe-release that measures participation to shape the next restructuring). ACTION is the
scope's defining deed; RECOVERY is its fast alter-ego, restoring the capacity to act again;
PREPARATION follows the alternation to shape what comes next — and faces both the next same-scope
action and the OTHER scope (which is where what earlier drafts called "evaluation" lives: stocking
the tag is preparing for night, not judging the present). Note the rotation: NT release is ACTION
by day and PREPARATION by night; the structural change is only marked by day (the tag) and enacted
by night. The bouton is not a sink — by night it emits inward and upward.
```
// PARAMETERS K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake
// stp_thr · coupling_gain · coupling_drift · VGCC_baseline
// INTERFACE
// EMIT glutamate → POST, ASTRO
// RECEIVE retro_NO, retro_eCB ← POST (signals latched in EVALUATION/PREPARATION; pools refill in PREPARATION)
// READ glutamate (own cleft, autobrake) ; dopamine (gates tag)
// OWN pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
// VGCC_active (occupancy: current coupling, filled toward VGCC_coupling ceiling)
// SUPPLY astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
// EMERGENCY shockwave_lockdown ← ASTRO
//
// TRACE CREATION MODES (every trace: trace += input·Δt − trace·(Δt/τ_decay))
// impulse input = quantum·δ(event) — a point event; no rise time, τ = decay only (FAST)
// accumulate input = rate(condition)·Δt — ramps while a condition holds; τ = rise AND decay (MEDIUM/SLOW)
//
// THE THREE CATEGORIES (same at DAY and NIGHT; here at the DAY timescale, subject = the cleft):
// ACTION release NT (the defining deed) — context AP
// RECOVERY restore the ability to release again: vesicle refill — the fast alter-ego of AP,
// runs in the inter-spike gaps (NOT_AP), riding the train, setting STD depth
// PREPARATION shape what comes next — climb the tag (for NIGHT), set VGCC, refill budget,
// thresholds, decay — runs once the train subsides (NOT_SPIKE_TRAIN ⊂ NOT_AP)
// Pattern per scope: (ACTION ⇄ RECOVERY) × many spikes, then PREPARATION.
// Contexts nest (NOT_SPIKE_TRAIN ⊂ NOT_AP); each behavior in exactly ONE block.
// ===== ACTION =====
DAY | AP: // release into the cleft (the defining deed)
// deposit the fast trace THIS action leaves (FAST · impulse)
pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike)
drive = sat(pre_fast_trace × VGCC_active, K_release) × (1 - retro_eCB_local)
if pre_budget < release_cost: // FUEL shortfall → endurance evidence
suppress(NT_flux)
if pre_fast_trace > traj_thr: // MEDIUM · accumulate (a PREPARATION deposit)
pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)·Δt
exit
if RRP == 0: suppress(NT_flux); exit // OCCUPANCY shortfall → STD (not endurance)
NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost
glutamate += NT_flux·Δt // EMIT glutamate → POST, ASTRO
if glutamate > spillover: drive *= brake // own-cleft autobrake
// ===== RECOVERY (alter-ego of ACTION; runs in the inter-spike gaps, rides the train) =====
DAY | NOT_AP: // restore the ability to release again
RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
pre_fast_trace *= decay(100ms) // FAST — the trace relaxes between spikes
// (partial refill vs release is the STD race — this is recovery keeping pace with action)
// ===== PREPARATION (shape what comes next; faces the next train AND the NIGHT) =====
DAY | NOT_SPIKE_TRAIN: // sustained quiet; ⊂ NOT_AP
retro_NO_local = retro_NO; retro_eCB_local = retro_eCB // latch arrived signals
// for NIGHT: climb the tag (stock the token the night-action will spend) (MEDIUM→SLOW accumulate)
if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt
if dopamine > dop_thr and pre_possible_tag > tag_thr:
pre_tag += dopamine × pre_possible_tag·Δt
// for the NEXT TRAIN: STP read-out (eligibility → coupling readiness; NO dopamine; drifts back)
if pre_possible_tag > stp_thr:
VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling)
else:
VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline) // STD = un-honored decay
// for the NEXT TRAIN: full budget refill toward next demand (forward-facing)
pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
// settle the medium/slow stocks (fast-trace decay already ran in RECOVERY; not repeated)
pre_possible_tag *= decay(s); pre_endurance_need *= decay(min) // MEDIUM
pre_tag *= decay(hr) // SLOW
dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s)
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. The rhythm is
// (ACTION ⇄ RECOVERY) × many, then PREPARATION, then again — like DAY's (release ⇄ refill) × many
// → prep. Two competitions at two loci: WITHIN action, build vs release contend over the
// component's own structure (participation is the arbiter); WITHIN recovery, THIS component vs
// OTHERS contend for shared material/energy. A category spans all THREE timescales (fast/med/slow).
// ACTION change structure — BUILD (participation high + tag stands; tag funds it, a slice
// per cycle so the tag persists across cycles) ⇄ RELEASE (participation LOW; frees
// material; tag untouched). Both always possible; participation selects direction.
// RECOVERY restore the ability to build: acquire material/energy from the shared pool AND
// receive freed material — in CONTENTION with other components.
// PREPARATION replay the release as a probe (SAME machinery as day ACTION) to measure
// participation; itself multi-timescale: probe⇄restock (fast), VGCC/threshold
// prime from the tag (medium), tag settle (slow).
// Two independent forgettings: structural pruning ← low participation (release); intention decay
// ← tag decaying unspent. Loops until the tag is spent.
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
NIGHT | build or release: // the night's defining deed (both directions)
// BUILD (participation confirmed AND tag stands): spend a SLICE of the tag — persists next cycle
if rest_permission and pre_tag > tag_expiry and pre_participation ≥ MEDIUM:
Δ = min(slot_batch, pre_material, pre_energy·f_cap, pre_tag) × pre_participation
pre_structure += Δ; pre_material -= Δ; pre_energy -= Δ·assembly_cost
pre_tag -= Δ // SLICE only — tag survives for successive cycles
if pre_endurance_need > endur_thr: // endurance capacity builds on the same act
Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap)
pre_budget_ceiling += Δ'; pre_material -= Δ'; pre_energy -= Δ'·biogenesis_cost
pre_endurance_need -= Δ'
// RELEASE (participation LOW): shed structure, FREE material back to the shared pool; tag untouched
else if pre_participation == LOW:
shed = release_rate × max(pre_structure - homeostatic_floor, 0)
pre_structure -= shed; pre_freed_material += shed·recycle // freed → contested pool (RECOVERY)
pre_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else (tag present but participation not confirmed this cycle): HOLD — tag waits for its pattern
// ===== RECOVERY (acquire material/energy in CONTENTION with other components; receive freed material) =====
NIGHT | import + free: // alter-ego of the night ACTION (inter-component)
pre_material += transit(pre_material_ship, τ_transport_bouton) // import build material (contested pool)
pre_energy += transit(pre_energy_ship, τ_transport_bouton) // import build energy (contested pool)
pre_material += pre_freed_material; pre_freed_material = 0 // reclaim what release freed
if renorm_signal arrived: // descended constraint → free structure
freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal
emit(freed → recycled material pool) // freed material re-enters contention
pre_material += pre_ceiling_shrinkage·recycle // energy NOT recovered
pre_maintain: pre_structure += min(pre_maint, maint_cost) // hold up what is used
// ===== PREPARATION (REPLAY the release as a probe — SAME machinery as day ACTION; multi-timescale) =====
// Replay re-runs the release exactly as by day: same drive, same capacity + vesicle checks, same
// endurance deposit into the SAME pre_endurance_need trace. Differs from DAY ACTION: no dopamine,
// and the glutamate is a PROBE — drives the pattern onward and its own trace is read as participation.
NIGHT | replay + measure + prime: // release here is PREPARATION, not the deed
// FAST: probe-release ⇄ restock (the replay, run repeatedly to measure participation)
spont = intrinsic_fluctuation()
if spont > pre_spont_thr or arrived_replay_AP: // ignite: spontaneous, or recruited by the pattern
pre_fast_trace += mini_Ca(VGCC_active)·δ(replay) // SAME trace deposit as DAY ACTION
drive = sat(pre_fast_trace × VGCC_active, K_release)
if pre_budget < release_cost: // SAME capacity check → endurance evidence
suppress(replay_flux)
if pre_fast_trace > traj_thr:
pre_endurance_need += pre_fast_trace·Δt // SAME trace, fed by replay too
else if RRP > 0: // SAME vesicle check
replay_flux = RRP × drive; RRP -= replay_flux·Δt; pre_budget -= replay_flux·fusion_cost
glutamate += replay_flux·Δt // real glutamate → POST: carries the pattern onward
RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget) // restock
pre_participation = level(pre_fast_trace) // read the replayed response as participation
// MEDIUM: prime excitability + VGCC from the standing tag (readies the next probe AND next build)
pre_spont_thr = spont_thr_base − thr_gain × pre_tag
if pre_tag > prime_thr:
VGCC_active = min(VGCC_active + prime_gain × pre_tag, pre_structure.VGCC_coupling)
pre_possible_tag *= occupancy_downscale // apply descended constraint to self
// SLOW: settle
pre_fast_trace *= decay(100ms); pre_tag *= decay(hr); pre_endurance_need *= decay(slow)
emit(pre_fatigue, pre_demand → upward) // not a sink: emits inward/upward by night
```
---
## POST
The postsynaptic spine is the synapse's primary memory locus: it detects coincident input,
runs the calcium dynamics that decide potentiation versus depression, and requires the most
validation (three coincidences) before committing.
**POST's ACTION is the synaptic event (context NOT_bAP).** Integration is graded and ongoing
rather than spike-punctate, so POST's action-context is "glutamate present, no bAP": three calcium
sources feed the fast trace — AMPA current (small Ca, begins ejecting the NMDA Mg block) and NMDA
(large Ca, only on the local coincidence of depolarization + astrocyte D-serine + glutamate). The
action deposits the calcium trace and emits the two retrograde messages. Because POST's receptors
are physical coincidence detectors, two of its three tag-coincidences (astro D-serine, and the bAP
below) are detected *in the action*; only the organism's dopamine coincidence is left to evaluation.
**bAP is a second, vertical action-context.** The soma's back-propagating spike arrives, adds
depolarization and calcium, and supralinearly amplifies an existing candidate — the soma's
confirmation that it fired, detected in the action-moment (instantaneous coincidence).
**EVALUATION FOLDS INTO PREPARATION.** POST runs the same three categories as every component.
ACTION is the synaptic response (integrate glutamate, detect the instantaneous coincidences, emit
the retrogrades). RECOVERY restores the ability to respond again — calcium extrusion and NMDA
Mg-block re-establishment, the fast alter-ego of the response. PREPARATION shapes what comes next:
fills AMPA surface toward the slot ceiling from accumulated calcium (short-term potentiation, no
dopamine — for the next response), climbs the tag on the dopamine coincidence (for the night),
refills budget, and settles. A fuel shortfall while calcium was climbing toward a tag is endurance
evidence (a preparation deposit made during action); a surface already at its ceiling is a
structural limit, not endurance.
**During NIGHT — the same three categories, turned inward.** RECOVERY imports material/energy and
primes AMPA responsiveness from the standing tag. PREPARATION replays: POST responds to the
re-evoked glutamate exactly as it responds by day (same AMPA/NMDA machinery, same endurance
deposit into the same trace), reading the response as participation rather than transmitting — no
dopamine. ACTION is the structural change: general homeostatic lowering, then rebuild where the tag
stands and participation was confirmed, consuming the tag. Both ceilings draw the same finite pool
and compete; unmaintained ceilings drift down.
```
// PARAMETERS K_AMPA · AMPA_Ca · AMPA_cost · NMDA_cost · bAP_cost · pka_cost · traffic_cost
// req_cost · Mg_eject · Dserine_thr · Ca_STP · Ca_TAG · eCB_thr · drift · baseline
// NO_synth_cost · eCB_synth_cost
// INTERFACE
// EMIT retro_NO (+), retro_eCB (−) → PRE
// RECEIVE (signals) glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP ← DEND/SOMA ; dopamine
// READ glutamate ; astro_Dserine ; bAP (dend_structure.bAP_fidelity) ; dopamine
// OWN post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
// SUPPLY astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
// EMERGENCY shockwave_lockdown ← ASTRO
// NOTE POST endurance is own-state only (own Ca climbing); no arrived feedback term.
// coincidences sort by timescale: D-serine/bAP detected IN ACTION (instantaneous); dopamine in PREPARATION.
// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = arrived glutamate / bAP):
// ACTION respond: integrate glutamate, detect instantaneous coincidences, emit retro (NOT_bAP);
// bAP is a second, vertical action-context (soma's spike confirms)
// RECOVERY restore the ability to respond: Ca extrusion + NMDA Mg-block re-establish
// PREPARATION shape what comes next: AMPA fill (next response) + tag climb (NIGHT) + refill + settle
// Coincidences sort by timescale: D-serine/bAP detected IN ACTION (instantaneous); dopamine in PREPARATION.
// ===== ACTION =====
DAY | bAP: // second action-context (vertical): soma confirms
Vm += bAP_depol × dend_structure.bAP_fidelity; post_budget -= bAP_cost
if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost() // amplify only if candidate present
DAY | NOT_bAP: // respond to arrived input (the defining deed)
a = sat(glutamate, K_AMPA)
AMPA_current = a × AMPA_surface; Vm += AMPA_current; post_budget -= AMPA_cost // SOURCE 1 AMPA
post_fast_trace += AMPA_Ca·AMPA_current
if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0: // SOURCE 2 NMDA
post_fast_trace += NMDA_Ca(glutamate)·rise_speed(); post_budget -= NMDA_cost // coincidence #1,2 here
retro_NO += NO_emit(post_fast_trace); post_budget -= NO_synth_cost // EMIT + "responsive target"
if Vm > eCB_thr:
retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost // EMIT − brake
// ===== RECOVERY (restore the ability to respond; alter-ego of the response) =====
DAY | NOT_bAP · recovered: // Ca extrusion + Mg-block re-establish
post_fast_trace *= decay(ms) // FAST — Ca extruded, trace relaxes
// (NMDA Mg-block re-establishes as Vm falls — implicit in the Vm>Mg_eject gate next response)
// ===== PREPARATION (shape the next response AND the NIGHT) =====
DAY | quiet: // sustained quiet
// for NIGHT: climb the tag; dopamine is the integrable coincidence (#3)
if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace; post_budget -= pka_cost
if dopamine > dop_thr and post_possible_tag > tag_thr:
post_tag += dopamine × post_possible_tag // token minted for NIGHT
// for the NEXT RESPONSE: STP fill / STD drift
if post_fast_trace > Ca_STP:
if post_budget < traffic_cost: // FUEL shortfall → endurance (a PREPARATION deposit)
if post_fast_trace > traj_thr and post_fast_trace_rising:
post_endurance_need += post_fast_trace
else if AMPA_surface < post_structure.slot_ceiling:
AMPA_surface += Ca_insert(post_fast_trace); post_budget -= traffic_cost
// else: surface at slot_ceiling → structure-limited (not endurance)
else:
AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = un-honored decay
post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
post_possible_tag *= decay(min); post_endurance_need *= decay(min) // MEDIUM
post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern.
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release contend WITHIN (participation
// arbitrates); material contends BETWEEN components (recovery). Night PREPARATION replays the DAY
// ACTION (same AMPA/NMDA machinery, same endurance trace), read for participation not significance.
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
NIGHT | build or release:
if rest_permission and post_tag > tag_expiry and post_participation ≥ MEDIUM: // BUILD (slice)
Δ = min(slot_batch, post_material, post_energy·f_cap, post_tag) × post_participation
post_structure += Δ; post_material -= Δ; post_energy -= Δ·assembly_cost
post_tag -= Δ // SLICE — tag persists across cycles
if post_endurance_need > endur_thr:
Δ' = min(cap_batch, post_material·f_cap, post_energy·f_cap)
post_budget_ceiling += Δ'; post_material -= Δ'; post_energy -= Δ'·biogenesis_cost
post_endurance_need -= Δ'
else if post_participation == LOW: // RELEASE: shed, free material; tag untouched
shed = release_rate × max(post_structure - homeostatic_floor, 0)
post_structure -= shed; post_freed_material += shed·recycle
post_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else: HOLD — tag waits for its pattern
// ===== RECOVERY (acquire material/energy in CONTENTION with other components; receive freed material) =====
NIGHT | import + free:
post_material += transit(post_material_ship, τ_transport_spine) // import (contested pool)
post_energy += transit(post_energy_ship, τ_transport_spine)
post_material += post_freed_material; post_freed_material = 0 // reclaim what release freed
if renorm_signal arrived:
freed = post_structure × (1 - renorm_signal); post_structure *= renorm_signal
emit(freed → recycled material pool)
post_material += post_ceiling_shrinkage·recycle // energy NOT recovered
post_structure += min(post_maint, maint_cost) // hold up what is used
// ===== PREPARATION (REPLAY the response — SAME machinery as day ACTION; multi-timescale) =====
NIGHT | replay + measure + prime:
// FAST: replay the response to the re-evoked input (probe)
if arrived_glutamate_replay or arrived_replay_AP:
a = sat(glutamate, K_AMPA)
post_fast_trace += AMPA_Ca·(a × AMPA_surface) // SAME AMPA machinery as DAY ACTION
if Vm > Mg_eject and astro_Dserine > Dserine_thr:
post_fast_trace += NMDA_Ca(glutamate) // SAME NMDA machinery
if post_budget < traffic_cost: // SAME capacity check → endurance evidence
if post_fast_trace > traj_thr: post_endurance_need += post_fast_trace // SAME trace, fed by replay
post_participation = level(post_fast_trace) // read replayed response as participation
// MEDIUM: prime responsiveness (AMPA occupancy) from the standing tag
post_spont_thr = spont_thr_base − thr_gain × post_tag
if post_tag > prime_thr:
AMPA_surface = min(AMPA_surface + prime_gain × post_tag, post_structure.slot_ceiling)
post_possible_tag *= occupancy_downscale
// SLOW: settle
post_fast_trace *= decay(ms); post_tag *= decay(hr); post_endurance_need *= decay(slow)
emit(post_fatigue, post_demand → upward) // not a sink: emits inward/upward by night
```
---
## DEND
The dendritic branch is the postsynapse's supply line and the neuron's input integrator. It
carries the back-propagating spike out to its spines, integrates their voltages toward the
soma, and ships material and budget to the spines it supports.
**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the
branch propagates the back-propagating spike toward its spines, with a fidelity that attenuates
with distance (distal spines get weaker confirmation, are harder to potentiate). It deposits
branch calcium and integrates its spines' voltages into a single branch signal sent on to the
soma. A fuel shortfall that cuts propagation short while the branch was strongly active is
endurance evidence; propagation that simply attenuates with distance is a structural limit, not
endurance.
**During DAY, during NOT_bAP — the branch consolidates, supplies, and recovers.** It maintains
its tag toward consolidation, lowers its commit threshold under acetylcholine (attention),
ships budget down to its spines (demand-weighted by their tags), runs local translation if
tagged, refills its own budget from astrocytic lactate and somatic shipment, and lets its
traces decay.
**During NIGHT — the branch's ceilings are rewritten.** NIGHT raises **structure** (bAP
fidelity, translation capacity) where a validated tag accumulated and **budget capacity** where
fuel interrupted strong branch activity, both from the shared pool, both competing; unmaintained
ceilings drift down.
```
// PARAMETERS prop_cost · branch_Ca_cost · integrate_cost · translate_cost · ACh_gain
// INTERFACE
// EMIT bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST
// RECEIVE (signals) SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
// READ SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
// OWN dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
// SUPPLY astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
// NOTE DEND endurance fires only on FUEL-limited propagation, not structural attenuation;
// own-state proxy (strong branch activity); no arrived feedback term.
// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = soma's bAP / spine input):
// ACTION propagate the bAP to spines + integrate spine voltage to soma (context bAP)
// RECOVERY restore branch excitability: Ca clearance (fast alter-ego of propagation)
// PREPARATION shape the next: tag climb (NIGHT), attention threshold, ship to spines, refill, settle
// ONE fuel shortfall that cuts propagation short = endurance; distance attenuation = structural limit.
// ===== ACTION =====
DAY | bAP: // propagate + integrate (the defining deed)
if dend_budget < prop_cost:
if dend_fast_trace > traj_thr: // FUEL shortfall → endurance (a PREPARATION deposit)
dend_endurance_need += dend_fast_trace
bAP_local, reached = propagate_partial(dend_budget)
else:
bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry)
// reached < full here is structural attenuation (distance), NOT endurance
dend_budget -= prop_cost × reached
dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost
branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost // EMIT integrated Vm → SOMA
// ===== RECOVERY (restore branch excitability; alter-ego of propagation) =====
DAY | NOT_bAP · recovered: // Ca clearance
dend_fast_trace *= decay(300ms) // FAST — branch Ca relaxes
// ===== PREPARATION (shape the next propagation AND the NIGHT) =====
DAY | NOT_bAP:
// for NIGHT: strength climb
if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
if dopamine > dop_thr and dend_possible_tag > tag_thr:
dend_tag += dopamine × dend_possible_tag // token minted for NIGHT
// for the next: attention lowers commit threshold; local translation; ship to spines; refill
commit_threshold *= 1/(1 + ACh·ACh_gain)
if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost) // EMIT down to spines
dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
dend_possible_tag *= decay(s); dend_endurance_need *= decay(min) // MEDIUM
dend_tag *= decay(hr) // SLOW
// ── NIGHT: SAME three categories, subject = the pattern. DEND is an intermediate RELAY: its
// PREPARATION replay relays replay_AP onward to spines IF primed (carrying SOMA→DEND→POST).
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release WITHIN; material BETWEEN.
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists) =====
NIGHT | build or release:
if dend_tag > tag_expiry and dend_participation ≥ MEDIUM: // BUILD (slice)
Δ = min(slot_batch, dend_material, dend_energy·f_cap, dend_tag) × dend_participation
dend_structure += Δ; dend_material -= Δ; dend_energy -= Δ·assembly_cost; dend_tag -= Δ
if dend_endurance_need > endur_thr:
Δ' = min(cap_batch, dend_material·f_cap, dend_energy·f_cap)
dend_budget_ceiling += Δ'; dend_material -= Δ'; dend_energy -= Δ'·biogenesis_cost
dend_endurance_need -= Δ'
else if dend_participation == LOW: // RELEASE: shed, free material; tag untouched
shed = release_rate × max(dend_structure - homeostatic_floor, 0)
dend_structure -= shed; dend_freed_material += shed·recycle
dend_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else: HOLD
// ===== RECOVERY (acquire/free material in CONTENTION; ship down to feed spine links) =====
NIGHT | import + free:
dend_material += transit(soma_material_to_dend, τ_transport_dend)
dend_energy += transit(soma_energy_to_dend, τ_transport_dend)
dend_material += dend_freed_material; dend_freed_material = 0 // reclaim what release freed
if renorm_signal arrived:
freed = dend_structure × (1 - renorm_signal); dend_structure *= renorm_signal
emit(freed → recycled material pool)
dend_material += dend_ceiling_shrinkage·recycle // energy NOT recovered
dend_structure += min(dend_maint, maint_cost) // hold up what is used
post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost) // ship to feed spine links
post_energy_ship += ship(dend_energy, post_demand, f_spine, ship_cost)
// ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) =====
NIGHT | replay + measure + prime:
// FAST: relay the replay_AP onward to spines IF primed (probe)
if arrived_replay_AP and dend_spont_thr < recruit_thr:
bAP_local = propagate(replay_AP, dend_structure.bAP_fidelity, geometry) // SAME propagate machinery
emit(bAP_local → POST) // carries the pattern to the spines
dend_fast_trace += bAP_Ca(bAP_local)
if dend_budget < prop_cost and dend_fast_trace > traj_thr: // SAME capacity check → endurance
dend_endurance_need += dend_fast_trace // SAME trace, fed by replay
dend_participation = level(dend_fast_trace) // read replayed response as participation
// MEDIUM: prime bAP-relay excitability from the standing tag
dend_spont_thr = spont_thr_base − thr_gain × dend_tag
// SLOW: settle
dend_fast_trace *= decay(300ms); dend_tag *= decay(hr); dend_endurance_need *= decay(slow)
emit(dend_fatigue, dend_demand → upward)
```
---
## SOMA
The soma is the neuron's integrating center and the root of its structural material. It sums
the branch inputs, fires when they exceed a threshold it sets from its own adaptation and the
neuromodulators, and ships material and budget out to the dendrites and axon. Its timing —
refractoriness, adaptation, rhythm alignment — emerges bottom-up from local traces, never from
a represented clock.
**During DAY, during AP — the soma integrates and fires.** It computes its firing threshold
from its baseline (structure), its accumulated adaptation, and the neuromodulators, and checks
its refractory state; if the integrated branch input clears the threshold and fuel allows, it
fires. One spike deposits three traces at three timescales — sodium inactivation (refractory),
slow-potassium adaptation (threshold rise), and nuclear calcium (toward CREB and the tag). A
fuel shortfall while nuclear calcium was climbing is endurance evidence; being refractory or
sub-threshold is a timing limit, not endurance.
**During DAY, during NOT_AP — the soma recovers, aligns, and supplies.** It self-replenishes
from its own mitochondria (its private root), integrates the latest branch inputs, deposits a
refractory-alignment trace when suprathreshold input arrived during its refractory period (so it
aligns to its input rhythm bottom-up), ships budget to dendrites and axon (demand-weighted by
their tags), recovers from refractoriness at a rate its alignment trace speeds up, and lets its
traces decay.
**During NIGHT — the soma's ceilings are rewritten, and it gates the whole neuron's material.**
NIGHT raises **structure** (excitability, synthesis capacity) and **budget capacity** from the
shared pool; crucially the soma's own tag gates CREB-driven synthesis, so how much material all
downstream components receive depends on the soma having been tagged.
```
// PARAMETERS ap_cost · nuclear_cost · creb_cost · mito_output · inactivation · ap_amp · ap_contrib
// base_recovery · τ_Na · τ_adapt · τ_nuclear · τ_align
// INTERFACE
// EMIT fired → AXON (propagate) + DEND (bAP) ; soma_ship_dend → DEND ; soma_ship_axon → AXON
// RECEIVE (signals) branch_Vm ← DEND ; dopamine ; NE ; ACh
// READ dopamine ; NE ; ACh
// OWN soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling
// SUPPLY self (mitochondria, ROOT — private)
// NOTE SOMA endurance fires only on FUEL shortfall (budget < ap_cost);
// refractory / sub-threshold are timing limits, not endurance. Own-state proxy.
// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = the branch input / spike):
// ACTION fire (the defining deed) — context AP
// RECOVERY restore the ability to fire again: refractory de-inactivation + mito replenish —
// the alter-ego of the spike, runs in NOT_AP
// PREPARATION shape the next spike: alignment, adaptation, tag-climb (for NIGHT), ship, decay
// Pattern: (ACTION ⇄ RECOVERY) × many spikes, then PREPARATION.
// ONE spike's fast trace feeds TWO preparation destinations: nuclear-Ca → tag (for NIGHT),
// inactivation/adaptation/alignment → next-spike timing (this scope).
// ===== ACTION =====
DAY | AP: // integrate + fire (the defining deed)
threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh)
can_fire = soma_Na_inactivation < inactivation
if branch_Vm > threshold and can_fire:
if soma_budget < ap_cost: // FUEL shortfall → endurance (a PREPARATION deposit)
if soma_fast_trace > traj_thr and soma_fast_trace_rising:
soma_endurance_need += soma_fast_trace
exit
fired = True; soma_budget -= ap_cost // EMIT fired → AXON, DEND
// deposit the THREE traces from one AP (all PREPARATION content, deposited in the action):
soma_Na_inactivation += ap_amp // → refractory (recovery will undo this)
soma_adaptation += ap_contrib // → threshold rise (next-spike timing)
soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // → tag (for NIGHT)
if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
if dopamine > dop_thr and soma_possible_tag > tag_thr:
soma_tag += dopamine × soma_possible_tag
soma_budget -= creb_cost
soma_emitted_activity += 1; soma_emitted_structure = soma_structure // NEURON sums these
// ===== RECOVERY (restore the ability to fire; alter-ego of AP; runs in NOT_AP) =====
DAY | NOT_AP: // de-inactivate + replenish
soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget) // mito replenish
recovery = base_recovery × (1 + soma_refractory_alignment)
soma_Na_inactivation *= decay(τ_Na / recovery) // refractory recovery (sped by alignment)
soma_fast_trace *= decay(τ_nuclear) // FAST — nuclear-Ca relaxes
// ===== PREPARATION (shape the next spike AND the NIGHT; ⊂ NOT_AP, sustained quiet) =====
DAY | NOT_SPIKE_TRAIN:
branch_Vm = integrate(DEND.branch_Vm, branches) // RECEIVE latest branch input
// for next-spike timing: refractory alignment (suprathreshold input during refractory)
if branch_Vm > threshold and soma_Na_inactivation > inactivation:
soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
// for downstream: ship budget to dendrites + axon (demand-weighted)
soma_ship_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost)
soma_ship_axon = ship(soma_budget, axon_demand, axon_ship_frac, ship_cost)
// settle medium/slow stocks
soma_refractory_alignment *= decay(τ_align); soma_adaptation *= decay(τ_adapt)
soma_possible_tag *= decay(s); soma_endurance_need *= decay(min)
soma_tag *= decay(hr); dopamine *= decay(ms)
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. SOMA is a ROOT
// (produces material each cycle) AND the IGNITION POINT: its PREPARATION replay-fire propagates a
// replay_AP down axon + dendrites. Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release
// contend WITHIN (participation arbitrates); material contends BETWEEN components (recovery).
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
NIGHT | build or release:
if soma_tag > tag_expiry and soma_participation ≥ MEDIUM: // BUILD (slice)
Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag) × soma_participation
soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost
soma_tag -= Δ // SLICE — tag persists across cycles
if soma_endurance_need > endur_thr:
Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap)
soma_budget_ceiling += Δ'; soma_material -= Δ'; soma_energy -= Δ'·biogenesis_cost
soma_endurance_need -= Δ'
else if soma_participation == LOW: // RELEASE: shed, free material; tag untouched
shed = release_rate × max(soma_structure - homeostatic_floor, 0)
soma_structure -= shed; soma_freed_material += shed·recycle
soma_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else: HOLD — tag waits for its pattern
// ===== RECOVERY (ROOT production + acquire/free material in CONTENTION; ship to feed the pattern) =====
NIGHT | produce + import + free:
soma_material += CREB_synth(soma_tag)·Δt_cycle // ROOT: produce material — recoverable
soma_energy += mito_synth()·Δt_cycle // ROOT: produce energy — NOT recoverable
night_energy_spent += mito_synth()·Δt_cycle
soma_material += soma_freed_material; soma_freed_material = 0 // reclaim what release freed
soma_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost) // ship to feed pattern links
soma_material_to_axon += ship(soma_material, axon_demand, f_axon, ship_cost)
soma_energy_to_dend += ship(soma_energy, dend_demand, f_dend, ship_cost)
soma_energy_to_axon += ship(soma_energy, axon_demand, f_axon, ship_cost)
soma_material += soma_ceiling_shrinkage·recycle
soma_structure += min(soma_maint, maint_cost) // hold up what is used
// ===== PREPARATION (REPLAY the fire — SAME machinery as day ACTION; ignites the pattern; multi-timescale) =====
NIGHT | replay-fire + measure + prime:
// FAST: replay-fire (probe); ignites the pattern down the day pathway
spont = intrinsic_fluctuation()
if spont > soma_spont_thr: // ignite (SAME threshold logic as day fire)
replay_AP = TRUE
soma_fast_trace += nuclear_Ca()·δ(replay) // SAME trace deposit as DAY ACTION
if soma_budget < ap_cost: // SAME capacity check → endurance evidence
if soma_fast_trace > traj_thr: soma_endurance_need += soma_fast_trace // SAME trace, fed by replay
else:
soma_budget -= ap_cost
emit(replay_AP → AXON, DEND) // propagate: AXON/DEND relay onward IF primed
// pattern carries link by link, primed→primed (mechanical coherence):
// SOMA →[replay_AP]→ AXON →→ PRE →[glutamate]→ POST →→ DEND →→ SOMA ; one un-primed link breaks it
soma_participation = level(soma_fast_trace) // read replayed response as participation
// MEDIUM: prime firing excitability from the standing tag
soma_spont_thr = spont_thr_base − thr_gain × soma_tag
// SLOW: settle
soma_fast_trace *= decay(τ_nuclear); soma_tag *= decay(hr); soma_endurance_need *= decay(slow)
```
---
## AXON
The axon carries the soma's spike out to its boutons and is the presynapse's supply line. It
propagates reliably or not depending on its myelination and its recent load, and ships material
and budget to the boutons.
**During DAY, during AP — the axon propagates the spike.** Reliability is set by structure
(myelination) and degraded by recent high-frequency load (sodium inactivation at branch points —
axonal short-term depression). A fuel shortfall while carrying a strong train is endurance
evidence; load-driven failure is short-term depression, a consequence, not endurance.
**During DAY, during NOT_AP — the axon supplies and recovers.** It maintains its tag, ships
budget to its boutons (demand-weighted by their tags), refills its own budget from somatic
shipment and astrocytic lactate, and lets its traces decay.
**During NIGHT — the axon's ceilings are rewritten.** NIGHT raises **structure** (myelination,
transport capacity) and **budget capacity** from the shared pool, both competing; unmaintained
ceilings drift down.
```
// PARAMETERS prop_cost · budget_factor
// INTERFACE
// EMIT APs_delivered → PRE (propagation) ; axon_ship_pre → PRE
// RECEIVE (signals) SOMA.fired ; dopamine
// READ SOMA.fired ; dopamine
// OWN axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling
// SUPPLY soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
// NOTE AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace)
// is axonal STD (a consequence), not endurance. Own-state proxy.
// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = soma's spike):
// ACTION propagate the delivered spike to boutons (context AP)
// RECOVERY restore axon excitability: ionic re-equilibration (fast alter-ego of propagation)
// PREPARATION shape the next: tag climb (NIGHT), ship to boutons, refill, settle
// fail(fast_trace) is load-driven axonal STD (a consequence); FUEL shortfall is endurance.
// ===== ACTION =====
DAY | AP: // propagate the spike (the defining deed)
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance
if axon_budget < prop_cost:
reliability *= budget_factor
if axon_fast_trace > traj_thr: // FUEL-limited → endurance (a PREPARATION deposit)
axon_endurance_need += axon_fast_trace
delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT delivered → boutons
axon_fast_trace += delivered // deposit fast trace
// ===== RECOVERY (restore axon excitability; alter-ego of propagation) =====
DAY | NOT_AP · recovered: // ionic re-equilibration
axon_fast_trace *= decay(s) // FAST — shaft relaxes
// ===== PREPARATION (shape the next propagation AND the NIGHT) =====
DAY | NOT_AP:
// for NIGHT: strength climb → token for NIGHT
if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
if dopamine > dop_thr and axon_possible_tag > tag_thr:
axon_tag += dopamine × axon_possible_tag
// for the next: ship to boutons, refill toward next demand
axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
axon_possible_tag *= decay(s); axon_endurance_need *= decay(min) // MEDIUM
axon_tag *= decay(hr) // SLOW
// ── NIGHT: SAME three categories, subject = the pattern. AXON is an intermediate RELAY: its
// PREPARATION replay relays replay_AP onward to boutons IF primed (carrying SOMA→AXON→PRE).
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release WITHIN; material BETWEEN.
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists) =====
NIGHT | build or release:
if axon_tag > tag_expiry and axon_participation ≥ MEDIUM: // BUILD (slice)
Δ = min(slot_batch, axon_material, axon_energy·f_cap, axon_tag) × axon_participation
axon_structure += Δ; axon_material -= Δ; axon_energy -= Δ·assembly_cost; axon_tag -= Δ
if axon_endurance_need > endur_thr:
Δ' = min(cap_batch, axon_material·f_cap, axon_energy·f_cap)
axon_budget_ceiling += Δ'; axon_material -= Δ'; axon_energy -= Δ'·biogenesis_cost
axon_endurance_need -= Δ'
else if axon_participation == LOW: // RELEASE: shed, free material; tag untouched
shed = release_rate × max(axon_structure - homeostatic_floor, 0)
axon_structure -= shed; axon_freed_material += shed·recycle
axon_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else: HOLD
// ===== RECOVERY (acquire/free material in CONTENTION; ship down to feed bouton links) =====
NIGHT | import + free:
axon_material += transit(soma_material_to_axon, τ_transport_dend)
axon_energy += transit(soma_energy_to_axon, τ_transport_dend)
axon_material += axon_freed_material; axon_freed_material = 0 // reclaim what release freed
if renorm_signal arrived:
freed = axon_structure × (1 - renorm_signal); axon_structure *= renorm_signal
emit(freed → recycled material pool)
axon_material += axon_ceiling_shrinkage·recycle // energy NOT recovered
axon_structure += min(axon_maint, maint_cost) // hold up what is used
pre_material_ship += ship(axon_material, pre_demand, f_bouton, ship_cost) // ship to feed bouton links
pre_energy_ship += ship(axon_energy, pre_demand, f_bouton, ship_cost)
// ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) =====
NIGHT | replay + measure + prime:
// FAST: relay the replay_AP onward to boutons IF primed (probe)
if arrived_replay_AP and axon_spont_thr < recruit_thr:
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // SAME reliability machinery
delivered = reliability × axon_structure.propagation
emit(replay_AP → PRE) // carries the pattern to the boutons
axon_fast_trace += delivered
if axon_budget < prop_cost and axon_fast_trace > traj_thr: // SAME capacity check → endurance
axon_endurance_need += axon_fast_trace // SAME trace, fed by replay
axon_participation = level(axon_fast_trace) // read replayed response as participation
// MEDIUM: prime relay excitability from the standing tag
axon_spont_thr = spont_thr_base − thr_gain × axon_tag
// SLOW: settle
axon_fast_trace *= decay(s); axon_tag *= decay(hr); axon_endurance_need *= decay(slow)
emit(axon_fatigue, axon_demand → upward)
```
---
## ASTROSYNAPSE
> The astrosynapse is the perisynaptic astrocytic process — the LOCAL component at one synapse,
> the astroglial peer of pre/post and a constituent of the ASTROCYTE actor (which integrates
> across all of them, just as the NEURON integrates over the soma). The astrosynapse behaves
> locally here; the astrocyte integrates and broadcasts (see CELL ACTORS).
The astrosynapse is the synapse's gatekeeper and energy hub. It clears glutamate, supplies the
D-serine that gates postsynaptic NMDA, and distributes lactate across its territory by demand.
Unlike the others it runs in a single continuous context rather than spiking, and its structure
reshapes the synapse's operating point rather than just its range.
**During DAY, continuously — the astrosynapse clears, gates, and fuels.** It produces energy at
its cell body (glycolysis from glucose, the system's energy root), then allocates lactate across
its astrosynapses weighted by each one's clearance demand. At each astrosynapse it clears
spillover glutamate (EAAT) and supplies tonic D-serine; when spillover is high it adds a
demand-driven D-serine pulse, brakes nothing of the presynapse directly (the presynaptic brake
is PRE reading its own cleft), deposits its calcium trace, and accumulates a dopamine-gated tag.
A D-serine pulse cut short by low budget while demand was high is endurance evidence; one cut
short by precursor/material exhaustion is a material limit, not endurance. Excess overflow
triggers the protective shockwave lockdown.
**During NIGHT — the astrosynapse's ceilings are rewritten.** NIGHT raises **structure**
(perisynaptic wrap, EAAT density, tonic D-serine) where a validated tag accumulated and **budget
capacity** where budget-limited synthesis recurred; astro_structure is self-reinforcing in both
directions, so it amplifies whatever trajectory the synapse is already on.
```
// PARAMETERS K_Dserine · Ds_max · Ds_frac · Ds_cost · EAAT_cost · lactate_cost · spillover · overload
// INTERFACE
// EMIT astro_lactate[i] → pre/post/dend budgets ; astro_Dserine[i] → POST (gate)
// RECEIVE (signals) glutamate ← PRE (clearance + spillover) ; dopamine
// READ glutamate ; dopamine
// OWN astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling
// SUPPLY glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
// NOTE ASTRO endurance fires on BUDGET-limited synthesis (got<want via low budget);
// material/precursor-limited synthesis is a material limit, not endurance. Own-state proxy.
// EMERGENCY emits shockwave_lockdown on overload
// RING × CONTEXT: CONTINUOUS — no spike, so ACTION (clear/gate), EVALUATION (tag climb),
// and PREPARATION (allocate/refill/settle) all run each step in the graded flow. The ring
// turns continuously rather than being delimited by discrete events.
DAY | CONTINUOUS: // per astrosynapse i
// PREP: root production, demand weights, lactate allocation (ready the territory)
astro_central_budget += glycolysis(glucose)·Δt
for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
for each i: astro_territory_demand[i] += demand[i]·Δt // territory-level aggregator (by DAY)
factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
for each i:
astro_lactate[i] = demand[i] × factor; astro_central_budget -= astro_lactate[i]·lactate_cost
// ACTION: clear glutamate, supply tonic D-serine, gate on demand (the defining act)
glutamate[i] -= astro_structure[i].EAAT × glutamate[i]·Δt; astro_central_budget -= clearance·EAAT_cost
astro_Dserine[i] += astro_structure[i].Dserine_tonic·Δt
if glutamate[i] > spillover:
astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s) // deposit fast trace
want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
got = min(want, astro_central_budget × Ds_frac)
astro_Dserine[i] += got; astro_central_budget -= got·Ds_cost // D-serine pulse → POST gate
if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
astro_endurance_need[i] += (want - got) // FUEL-limited synthesis → endurance
// EVAL: strength climb → token for NIGHT
if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i]
if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
astro_tag[i] += dopamine × astro_possible_tag[i]
// DECAY (settle)
// MEDIUM (s–min)
astro_possible_tag[i] *= decay(s); astro_endurance_need[i] *= decay(min)
// SLOW (hr)
astro_tag[i] *= decay(hr)
// EMERGENCY
if astro_fast_trace[i] > overload: emit(shockwave_lockdown)
NIGHT · NON_REM_1 = PREPARATION | produce + distribute + prime: // ROOT: energy production + priming
// PRODUCTION (root): glycolysis + ECM synthesis this cycle, capped by glucose
astro_central_energy += overnight_glycolysis(glucose)·Δt_cycle // energy — NOT recoverable
astro_central_material += astro_cellbody_synth()·Δt_cycle // material — recoverable
night_energy_spent += overnight_glycolysis(glucose)·Δt_cycle
// distribute this cycle's batch across the territory, tag-weighted
W = Σ astro_tag[i] over astro_tag[i] > tag_expiry
for each i with astro_tag[i] > tag_expiry:
w = astro_tag[i]/W
astro_energy[i] += astro_central_energy·w; astro_material[i] += astro_central_material·w
astro_spont_thr[i] = spont_thr_base − thr_gain × astro_tag[i] // prime own responsiveness from own tag
astro_central_material += astro_ceiling_shrinkage·recycle // recycle
NIGHT · REM = EVALUATION | respond to re-evoked glutamate, MEASURE participation (NO dopamine):
for each astrosynapse i:
// when its synapse's pattern re-evokes, spillover glutamate arrives → mGluR Ca response (a PROBE)
if arrived_glutamate_replay[i]:
astro_fast_trace[i] += mGluR_Ca()
astro_participation[i] = level(astro_fast_trace[i]) // high/medium/low = centrality
astro_fast_trace[i] *= decay(s)
NIGHT · NON_REM_2 = ACTION | change the structure (per astrosynapse): // the night's defining deed
for each astrosynapse i:
astro_structure[i] -= decay_rate·Δt_cycle; astro_structure[i] += min(astro_maint[i], maint_cost) // lowering
if astro_tag[i] > tag_expiry and astro_participation[i] ≥ MEDIUM:
Δ = min(slot_batch, astro_material[i], astro_energy[i]·f_cap, astro_tag[i]) × astro_participation[i]
astro_structure[i] += Δ // self-reinforcing both directions
astro_material[i] -= Δ; astro_energy[i] -= Δ·assembly_cost; astro_tag[i] -= Δ
if astro_endurance_need[i] > endur_thr:
Δ' = min(cap_batch, astro_material[i]·f_cap, astro_energy[i]·f_cap)
astro_budget_ceiling[i] += Δ'; astro_material[i] -= Δ'
astro_energy[i] -= Δ'·biogenesis_cost; astro_endurance_need[i] -= Δ'
else:
astro_budget_ceiling[i] -= capacity_decay_rate·Δt_cycle; astro_budget_ceiling[i] += min(astro_cap_maint[i], cap_cost)
astro_endurance_need[i] *= decay(slow)
emit(astro_fatigue, astro_demand → upward)
```
---
## Special — Shockwave Lockdown
```
DAY or NIGHT | OVERLOAD:
Vm = HYPERPOLARIZED; AMPA_surface = mass_internalize() → post reserve
axon_fast_trace += overdrive(); astro_central_budget -= emergency_cost
```
---
---
> NIGHT-BLOCK UNIFORMITY (three categories). PRE, SOMA, POST, DEND, AXON now run both DAY and NIGHT
> chunked as (ACTION ⇄ RECOVERY) × many, then PREPARATION, under explicit `// ===== =====` separators:
> (a) NIGHT-RECOVERY imports/produces supply, primes its OWN threshold from its OWN standing tag,
> applies the descended constraint to itself, recycles, and — for intermediate nodes AXON/DEND —
> ships downstream so the pattern's links are fed; (b) NIGHT-PREPARATION REPLAYS the day action —
> re-runs the SAME release/fire/respond/propagate machinery (same capacity/vesicle checks, same
> endurance deposit into the SAME trace), read as participation (level: high/medium/low), NO dopamine;
> AXON/DEND/SOMA also propagate the replay_AP onward IF primed (carrying SOMA→AXON→PRE and
> SOMA→DEND→POST); (c) NIGHT-ACTION lowers structure homeostatically, then rebuilds where the tag
> still stands AND participation ≥ medium, consuming the tag. Roots (SOMA material) additionally
> PRODUCE each cycle. The replay pattern propagates entirely through the DAY PATHWAYS, self-igniting,
> carrying only where every link is primed.
> [ASTROSYNAPSE still shows the earlier NON_REM/REM form — pending its own pass (it is continuous and
> under-described; the three-category cut will be verified there separately).]
---
---
# CELL ACTORS — NEURON and ASTROCYTE
Two structurally identical peers. Each integrates its constituents' EMITTED activity by its DAY
(never reading their interiors), detects when its aggregate has gone quiet, and BROADCASTS the
restructuring window + renormalization/reallocation by its NIGHT. Each component then restructures
ITSELF in response. The cell actor's own DAY/NIGHT follows the same transition rule, on its own
aggregate activity.
## NEURON
The neuron is the whole-cell actor over soma, pre, post, dend, axon. It cannot fire or release —
it integrates what its components emit and grants them the restructuring window none of them can
grant itself. The soma is one of its constituents, a peer of the bouton; the neuron is not the soma.
```
// PARAMETERS neuron_weight_ceiling · downscale_factor · rest_thr
// INTERFACE
// EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast)
// neuron_fatigue → HYPOTHALAMUS
// RECEIVE (signals) component activity emissions (summed) ; sleep_pressure ← HYPOTHALAMUS
// replay_reweight ← assembly/network (external)
// OWN neuron_activity · neuron_total_weight (aggregates aggregated from emissions)
// NOTE never reads a component interior; sums emitted activity, broadcasts signals only.
DAY | active: // (own_activity high → integrate only)
// TRACE integrate the cell's emitted activity + committed weight (aggregators)
neuron_activity += Σ component emitted_activity·Δt
neuron_total_weight = Σ component emitted_structure // from emissions, not interiors
// EMIT fatigue upward (metabolic debt of the whole cell)
neuron_fatigue = f(neuron_activity, unspent demand)
// (no restructuring permission while the cell is active — components are busy)
NIGHT | cycle: // (own_activity low AND sleep_pressure high)
// the neuron acts ONLY by signalling; components prime/measure/rebuild themselves. Each
// component's cycle is RECOVERY→PREPARATION→ACTION; the neuron just supplies the constraint.
occupancy_downscale = downscale_factor // → components reset own occupancy (in RECOVERY)
if neuron_total_weight > neuron_weight_ceiling:
renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure
rest_permission = TRUE // → components may restructure this cycle
// RECOVER reclaim material returned by components' renormalization (arrives as recycled pool)
// DECAY neuron_activity relaxes as the cell stays quiet
CODA | on waking (sleep_pressure < wake_thr):
neuron_activity = 0; neuron_total_weight = recomputed from surviving emissions
```
## ASTROCYTE
The astrocyte is the territory actor over its astrosynapses — the exact parallel of the neuron.
It integrates its astrosynapses' emitted demand/load, and reallocates its produced energy and
material across the territory. The astrosynapse is one of its constituents; the astrocyte is not
the astrosynapse.
```
// PARAMETERS (territory reallocation) · rest_thr
// INTERFACE
// EMIT astro_alloc[·] (reallocation), rest_permission → own astrosynapses (broadcast)
// astro_fatigue → HYPOTHALAMUS ; produced energy+material → territory (roots)
// RECEIVE (signals) astrosynapse demand emissions (summed) ; sleep_pressure ; replay_reweight
// OWN astro_territory_demand[·] (aggregated from emissions) ; astro_central_{energy,material}
// NOTE ROOT of synaptic energy + ECM material; integrate-and-broadcast like the neuron.
DAY | active:
// TRACE integrate territory-wide emitted demand (aggregator)
for each astrosynapse i: astro_territory_demand[i] += emitted_demand[i]·Δt
// BEHAVE DAY metabolic support already runs per-astrosynapse (lactate allocation, see ASTROSYNAPSE)
// EMIT fatigue upward
astro_fatigue = f(territory load, unmet demand)
NIGHT | cycle: // (territory quiet AND sleep_pressure high)
// RECEIVE = PRODUCTION (root): this cycle's energy + ECM batch, capped by glucose
astro_central_energy += overnight_glycolysis(glucose)·Δt_cycle // NOT recoverable
astro_central_material += astro_cellbody_synth()·Δt_cycle // recoverable
night_energy_spent += overnight_glycolysis(glucose)·Δt_cycle
// ADJUST reallocation weights across the territory (demand × replay)
for each i: astro_alloc[i] = (astro_territory_demand[i] × replay_reweight[i])
/ Σ(astro_territory_demand × replay_reweight)
// EMIT (broadcast) distribute this cycle's batch + grant restructuring window
for each i:
astro_energy[i] += astro_central_energy·astro_alloc[i]
astro_material[i] += astro_central_material·astro_alloc[i]
rest_permission[i] = TRUE // → each astrosynapse commits itself
// RECOVER reclaim material from decayed astrosynapse ceilings (returned to central pool)
astro_central_material += astro_ceiling_shrinkage·recycle
CODA | on waking:
astro_territory_demand[·] = 0
```
## HYPOTHALAMUS
The system actor. Unlike every other actor it has NO night: it runs CONTINUOUS, always
integrating fatigue from all components and emitting the single sleep-pressure signal that opens
everyone else's restructuring window. It is the clock that never sleeps — if it stopped, nothing
would track fatigue and the system could never transition.
```
// PARAMETERS fatigue_gain · pressure_decay · discharge_gain
// INTERFACE
// EMIT sleep_pressure → ALL actors (broadcast; the day/night signal)
// RECEIVE (signals) fatigue from all components + cell actors (summed)
// discharge signal (restructuring done → fatigue falling)
// OWN sleep_pressure
// NOTE single fatigue channel up, single sleep_pressure channel down. No DAY/NIGHT of its own.
CONTINUOUS: // spans every other actor's day and night
// RECEIVE integrate all incoming fatigue (rising with activity, falling with consolidation)
total_fatigue = Σ component_fatigue + neuron_fatigue + astro_fatigue
// TRACE accumulate sleep pressure from fatigue; discharge as restructuring proceeds
sleep_pressure += fatigue_gain × total_fatigue·Δt
sleep_pressure -= discharge_gain × consolidation_progress·Δt
sleep_pressure *= decay(pressure_decay)
// EMIT broadcast the current level — each actor reads it and sets its own DAY/NIGHT
broadcast(sleep_pressure)
// (rising pressure tips quiet components into NIGHT; falling pressure wakes them — emergently)
```
How it runs without a driver. There is no loop that orchestrates the actors. The hypothalamus
continuously emits sleep-pressure; each component and cell actor continuously reads it and its own
activity and sets its own DAY/NIGHT per the transition rule. As components quiet and cross into
NIGHT they restructure, which discharges fatigue, which lowers pressure, which eventually wakes
them. The "loop of NIGHT cycles" is simply what happens while a component remains in its NIGHT
state — it runs its `NIGHT | cycle` block repeatedly until its transition rule flips it back to
DAY. Termination (waking) is emergent from the fatigue loop, not a `break`: a rested system
discharges its fatigue and wakes; an overloaded one wakes with tags unspent (they carry forward).
---
## One-view summary
```
THE THREE-PHASE RING · EIGHT ACTORS · ONE FATIGUE LOOP
ACTION (lateral, deposits fast trace) → EVALUATION (local, climbs to tag) → PREPARATION (vertical, readies next)
action is always LOCAL; evaluation & preparation may be local or CONTEXTUAL (a neighbor supplies them)
CONTEXT licenses PHASE: AP→action · NOT_AP→fast eval+prep · NOT_SPIKE_TRAIN(⊂NOT_AP)→slow eval+prep
phase edges are event/decay-timed, not clocked; RECOVER folded into PREPARATION (ready ≠ restore)
ACTORS local: soma·pre·post·dend·axon·astrosynapse cell: neuron·astrocyte system: hypothalamus
same ring; higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in
DAY (per-component state: own_activity high) ring turned OUTWARD against the world
fast_trace + dopamine → tag (strength) ; FUEL shortfall + interrupted success → endurance_need
currency: information ; token minted by evaluation: the TAG (for NIGHT) ; emit fatigue upward
NIGHT (per-component state: own_activity low AND sleep_pressure high) ring turned INWARD against the economy
ACTION=coherence check · EVALUATION=draw & commit (only if coherent) · PREPARATION=make room
currency: resource ; token minted by evaluation: STRUCTURE (for next DAY) ; deferral if not coherent
what persists must EARN it: occupancy resets, only CEILINGS carry; unspent tags carry forward
LOOP no driver/scheduler. HYPOTHALAMUS runs CONTINUOUS: integrates fatigue → emits sleep_pressure.
activity→fatigue→pressure→quiet grants restructuring→discharge→pressure falls→wake. DAY/NIGHT
are two turnings of one ring per component (local sleep), stitched by evaluation's tokens.
RULE no actor authorizes its own restructuring — each is PUT IN POSITION by the actor above
(holds an aggregate it can't see, opens a window it can't open). Acts locally, consolidates
hierarchically. Material recycles; ENERGY does not (the arrow of time).
FLOWS every flow has a timescale; shipment is transit-delayed (distal fills over cycles)
LOCAL only own state + arrived signals; ACTION/EMIT are the crossings; nothing is a pure sink
```
Reference in New Issue View Git Blame Copy Permalink