57 KiB
Tripartite Synapse — Pseudocode v16
Companion:
tripartite_synapse_v16_biology.md· principle:logic_principles_v3. Changes from v15 — NIGHT gains HIGHER-SCALE ACTORS and a PHASED structure: (1) NIGHT is enacted by a hierarchy of homeostatic actors, NOT the DAY components alone: COMPONENT (commits own ceilings) → ASTROCYTE territory (reallocates across its synapses) → NEURON (renormalizes total weight) → [assembly/network replay: external arrived signal] (2) the NEURON and ASTROCYTE-territory actors ACCUMULATE aggregate traces by DAY (total weight/activity; territory demand) and ACT by NIGHT (renormalize; reallocate) (3) OCCUPANCY is reset each NIGHT: multiplicative-global downscaling drives VGCC_active, AMPA_surface, possible_tag back toward baseline — only CEILINGS persist across a night (4) NIGHT is PHASED: early cycles DOWNSCALE (subtractive, reset occupancy, make room), late cycles COMMIT (additive, build ceilings for the survivors) (5) governing rule: what persists across a night must have EARNED persistence — occupancy that earned no tag returns to baseline; the system acts locally, consolidates hierarchically Carried: cyclic NIGHT, tag-as-fuel, emergent termination, DAY-up/NIGHT-down, seven-group grammar.
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.
NIGHT'S ACTORS ARE NOT DAY'S ACTORS — THE SYSTEM ACTS LOCALLY, CONSOLIDATES HIERARCHICALLY. DAY is enacted by the six local components. NIGHT is enacted by a HIERARCHY of homeostatic actors, each conserving a quantity at its own scale and constraining the scale below:
[ ASSEMBLY / NETWORK ] replay re-presents the day across neurons (EXTERNAL signal)
↓ constrains → arrives as replay_reweight[·] (like dopamine/glucose: external)
NEURON (the whole cell) conserves TOTAL synaptic weight; renormalizes so no synapse
↓ constrains grows beyond the cell's global budget; drives occupancy downscaling
ASTROCYTE territory conserves total metabolic output; reallocates energy/material
↓ constrains across ALL synapses it wraps, by accumulated territory demand
COMPONENT commits its own ceilings within the allocation handed down
These higher actors are DORMANT-BUT-ACCUMULATING by DAY and ACTIVE-AND-CONSTRAINING by NIGHT.
By DAY they only integrate an aggregate trace of the components' emitted activity (they sum
what was emitted, never read a component's interior — locality holds): the NEURON accumulates
neuron_total_weight and neuron_activity; the ASTROCYTE territory accumulates
astro_territory_demand[·]. By NIGHT they act on those aggregates: the astrocyte reallocates,
the neuron renormalizes. The assembly/network tier is not modelled here; its effect enters as
an external arrived signal replay_reweight, exactly as dopamine and glucose do.
NIGHT IS PHASED. Early cycles DOWNSCALE (subtractive): occupancy filled during the day — VGCC_active, AMPA_surface, possible_tag — is driven back toward baseline by multiplicative-global scaling, and total weight is renormalized. Late cycles COMMIT (additive): the survivors' tags build ceilings. The rule the phasing enforces: WHAT PERSISTS ACROSS A NIGHT MUST HAVE EARNED PERSISTENCE. Occupancy that earned no tag returns to baseline; only ceilings carry forward. The relative potentiation of a tagged synapse survives because it was written into its ceiling, not because its transient occupancy was spared.
Conventions
SCOPE = {DAY, NIGHT} CONTEXT = {AP, NOT_AP, bAP, NOT_bAP, CONTINUOUS}
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)
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)
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 sizes / endurance fraction
night_energy_ceiling // total energy a single night can spend (supply bound)
Δt_cycle // duration of one NIGHT cycle
maint_frac cap_frac // maintenance allocation
decay_rate capacity_decay_rate recycle // passive ceiling decay + material recovery
homeostatic_ceiling coherence_factor 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-early-cycle multiplicative occupancy reset (<1)
neuron_weight_ceiling // the cell's total-weight budget (renormalization target)
early_phase_frac // fraction of night cycles that are DOWNSCALE phase
DAY
PRE
The presynaptic bouton releases neurotransmitter and gathers evidence about whether that release was worth strengthening and worth sustaining. Its behavior unfolds across two DAY contexts and the NIGHT scope.
During DAY, during AP — the bouton releases neurotransmitter. The amount released depends on
residual calcium from recent spikes (the fast trace, setting the drive), the current
VGCC coupling occupancy (how tightly calcium channels are coupled to docking slots right
now — filled short-term, bounded by structure), the two retrograde messages from the
postsynapse (retro_eCB brakes the drive; retro_NO will confirm release reached a responsive
target), and the availability of both fuel and vesicles. Two shortfalls are read
differently: a fuel shortfall on a succeeding release is evidence the bouton needs more
endurance; an empty pool with fuel to spare is ordinary short-term depression.
During DAY, during NOT_AP — the bouton consolidates, potentiates short-term, and recovers. With no spike to release, it latches the retrograde messages (RECEIVE); maintains its traces — accumulating eligibility toward a dopamine-gated tag (TRACE); transiently tightens its VGCC coupling from accumulated eligibility, with no dopamine, a reversible short-term potentiation bounded by the structural ceiling (BEHAVE); refills both its budget (contested supply) and its vesicle pool (private reserve) (RECOVER); and lets its traces decay, closing the windows (DECAY).
During NIGHT — the bouton's ceilings are rewritten. NIGHT raises the bouton's structure (active-zone capacity, including the VGCC-coupling ceiling) where a validated tag accumulated, and its budget capacity (mitochondrial endurance) where fuel repeatedly interrupted a succeeding release. Both draw on the same finite material and energy shipped down the axon, so the two kinds of growth compete — and whatever is not maintained drifts back down.
// 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; resources refill in RECOVER)
// 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)
// A trace's tier is set by BOTH its creation mode and its decay: the fast trace is impulse-created
// and fast-decaying; possible_tag/endurance_need are slowly accumulated and medium-decaying.
DAY | AP:
// TRACE FAST · impulse (Ca²⁺ bolus from THIS spike — a point event; no rise time,
// decay alone sets its τ; frequency is emergent from impulse-rate vs decay)
pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike)
// ADJUST (release drive from residual Ca²⁺ × current coupling occupancy, + DSE brake)
drive = sat(pre_fast_trace × VGCC_active, K_release) × (1 - retro_eCB_local)
// BEHAVE (release; two distinct failure modes)
if pre_budget < release_cost:
// FUEL shortfall → endurance evidence (retro_NO-confirmed local success)
suppress(NT_flux)
// TRACE MEDIUM · accumulate (ramps while fuel keeps interrupting a succeeding release)
if pre_fast_trace > traj_thr:
pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)·Δt
exit
if RRP == 0:
// OCCUPANCY shortfall → short-term depression (NOT endurance; fuel was fine)
suppress(NT_flux)
exit
NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost
// EMIT (glutamate into cleft)
glutamate += NT_flux·Δt
if glutamate > spillover: drive *= brake // own-cleft autobrake
DAY | NOT_AP:
// RECEIVE (latch backward messages — signals only)
retro_NO_local = retro_NO; retro_eCB_local = retro_eCB
// TRACE (strength pathway — evidence climbs the ladder)
// MEDIUM · accumulate (ramps while fast_trace stays eligible; rise-rate is its τ_rise)
if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt
// SLOW · accumulate (ramps only on dopamine coincidence; rise gated by validation)
if dopamine > dop_thr and pre_possible_tag > tag_thr:
pre_tag += dopamine × pre_possible_tag·Δt
// BEHAVE (short-term potentiation: eligibility tightens coupling, 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 = consequence
// RECOVER (refill BOTH pools: contested budget + private RRP)
pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
// DECAY
// FAST (ms–s)
pre_fast_trace *= decay(100ms)
// MEDIUM (s–min)
pre_possible_tag *= decay(s); pre_endurance_need *= decay(min)
// SLOW (hr)
pre_tag *= decay(hr)
// (signals) arrived channels fade
dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s)
// (PERSISTENT: pre_structure, pre_budget_ceiling — no DAY decay; NIGHT only)
NIGHT | cycle: // leaf consumer (no downstream emit)
// RECEIVE batch arrived from AXON (material) + SOMA (energy) this cycle
pre_material += transit(pre_material_ship, τ_transport_bouton)
pre_energy += transit(pre_energy_ship, τ_transport_bouton)
// TRACE read standing demand
// (pre_tag → structure ; pre_endurance_need → budget_ceiling)
// ADJUST size commits from material + energy on hand
coh = coherence_signal // arrived: pre+post+astro tags aligned
// BEHAVE commit batches; spend tag/need as fuel
if pre_tag > tag_expiry:
Δ = min(slot_batch, pre_material, pre_energy·f_cap)
pre_structure += Δ × coh; pre_material -= Δ; pre_energy -= Δ·assembly_cost
pre_tag -= Δ // tag-as-fuel
if pre_endurance_need > endur_thr:
Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap)
pre_budget_ceiling += Δ'; pre_material -= Δ'; pre_energy -= Δ'·biogenesis_cost
pre_endurance_need -= Δ'
// EMIT (none — bouton is a leaf; nothing downstream)
// RECOVER reclaim material from any ceiling that decayed this cycle
pre_material += pre_ceiling_shrinkage·recycle // energy NOT recovered
// DECAY unmaintained ceilings + tags drift down a little
pre_structure -= decay_rate·Δt_cycle; pre_budget_ceiling -= capacity_decay_rate·Δt_cycle
pre_structure += min(pre_maint, maint_cost); pre_budget_ceiling += min(pre_cap_maint, cap_cost)
pre_tag *= decay(slow); pre_endurance_need *= decay(slow)
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. Its behavior unfolds across two DAY contexts and the NIGHT scope.
During DAY, during NOT_bAP — the spine integrates input and decides plasticity. Three calcium sources feed its fast trace: AMPA current (small Ca, begins ejecting the NMDA Mg block), NMDA (large Ca, but only on the local coincidence of depolarization + astrocyte D-serine + glutamate), and — in the bAP context — the back-propagating spike. High calcium drives AMPA receptors to the surface (short-term potentiation, occupancy filled toward the slot ceiling, no dopamine); when calcium falls, they drift back (short-term depression as a consequence). The spine also emits two retrograde messages from its own state — NO when it responded, an endocannabinoid brake when over-driven — and accumulates a dopamine-gated tag toward consolidation. A fuel shortfall while calcium was climbing toward a tag is endurance evidence; a surface already at its ceiling is a structural limit, not endurance.
During DAY, during bAP — the back-propagating spike confirms coincidence. The somatic spike arrives at the spine, adds depolarization and calcium, and supralinearly amplifies an existing candidate — the soma's confirmation that it fired, one of the three coincidences the spine requires.
During NIGHT — the spine's ceilings are rewritten. NIGHT raises structure (the AMPA slot ceiling, spine volume) where a validated tag accumulated — with a coherence bonus when pre, post, and astro all tagged the same synapse — and budget capacity where fuel interrupted a climbing calcium trajectory. Both draw the same finite pool, so they 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.
DAY | NOT_bAP:
// ADJUST (AMPA drive from arrived glutamate)
a = sat(glutamate, K_AMPA)
// BEHAVE (SOURCE 1 AMPA: current + small Ca + begins Mg ejection)
AMPA_current = a × AMPA_surface; Vm += AMPA_current; post_budget -= AMPA_cost
// TRACE (Ca deposited by AMPA)
post_fast_trace += AMPA_Ca·AMPA_current
// BEHAVE (SOURCE 2 NMDA: large Ca on local coincidence)
if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:
post_fast_trace += NMDA_Ca(glutamate)·rise_speed(); post_budget -= NMDA_cost
// EMIT (+ NO/BDNF: "release reached a responsive target")
retro_NO += NO_emit(post_fast_trace); post_budget -= NO_synth_cost
// EMIT (− endocannabinoid / DSE when over-driven)
if Vm > eCB_thr:
retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost
post_fast_trace *= decay(ms)
// BEHAVE (STP fill slots from private reserve ; else STD drift = consequence)
if post_fast_trace > Ca_STP:
if post_budget < traffic_cost:
// FUEL shortfall → endurance (own Ca was climbing toward a tag)
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 already at slot_ceiling → structure-limited (not endurance)
else:
AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = consequence
// TRACE (strength: CANDIDATE then STABLE via dopamine)
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
// RECOVER (refill budget from contested supply)
post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
// DECAY
// FAST (ms–s) — post_fast_trace already decayed above (intra-step, pre-tagging)
// MEDIUM (s–min)
post_possible_tag *= decay(min); post_endurance_need *= decay(min)
// SLOW (hr)
post_tag *= decay(hr)
// (signals)
dopamine *= decay(ms)
// (PERSISTENT: post_structure, post_budget_ceiling — no DAY decay; NIGHT only)
DAY | bAP:
// BEHAVE (SOURCE 3 bAP: depolarization + Ca, amplifies existing signal)
Vm += bAP_depol × dend_structure.bAP_fidelity; post_budget -= bAP_cost
// TRACE (supralinear boost only if a CANDIDATE is present)
if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost()
NIGHT | cycle: // leaf consumer (no downstream emit)
// RECEIVE batch arrived from DEND (material) + SOMA (energy) this cycle
post_material += transit(post_material_ship, τ_transport_spine)
post_energy += transit(post_energy_ship, τ_transport_spine)
// TRACE read standing demand (post_tag → structure ; post_endurance_need → budget_ceiling)
// ADJUST coherence applies to POST (synaptic component)
coh = coherence_signal
// BEHAVE commit batches; spend tag/need as fuel
if post_tag > tag_expiry:
Δ = min(slot_batch, post_material, post_energy·f_cap)
post_structure += Δ × coh; post_material -= Δ; post_energy -= Δ·assembly_cost
post_tag -= Δ
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 -= Δ'
// EMIT (none — spine is a leaf)
// RECOVER reclaim material from decayed ceilings
post_material += post_ceiling_shrinkage·recycle // energy NOT recovered
// DECAY
post_structure -= decay_rate·Δt_cycle; post_budget_ceiling -= capacity_decay_rate·Δt_cycle
post_structure += min(post_maint, maint_cost); post_budget_ceiling += min(post_cap_maint, cap_cost)
post_tag *= decay(slow); post_endurance_need *= decay(slow)
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. Its behavior unfolds across two DAY contexts and the NIGHT scope.
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.
DAY | bAP:
// ADJUST (propagation strength from structure — inside propagate())
// BEHAVE (propagate bAP; distinguish fuel-limited vs structure-limited shortfall)
if dend_budget < prop_cost:
// FUEL shortfall → endurance (branch was strongly active)
if dend_fast_trace > traj_thr:
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
// TRACE
dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost
// EMIT (integrated voltage to soma ; propagated bAP already reached spines)
branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost
DAY | NOT_bAP:
// TRACE (strength)
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
// ADJUST (commit threshold lowered by attention)
commit_threshold *= 1/(1 + ACh·ACh_gain)
// BEHAVE (local translation if tagged — fills dend capacity faster)
if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
// EMIT (ship budget to spines; demand = post tag)
dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
// RECOVER (refill budget from contested supply)
dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
// DECAY
// FAST (ms–s)
dend_fast_trace *= decay(300ms)
// MEDIUM (s–min)
dend_possible_tag *= decay(s); dend_endurance_need *= decay(min)
// SLOW (hr)
dend_tag *= decay(hr)
// (PERSISTENT: dend_structure, dend_budget_ceiling — no DAY decay; NIGHT only)
NIGHT | cycle: // intermediate node (relays down to POST)
// RECEIVE batch arrived from SOMA this cycle
dend_material += transit(soma_material_to_dend, τ_transport_dend)
dend_energy += transit(soma_energy_to_dend, τ_transport_dend)
// TRACE read standing demand (dend_tag → structure ; dend_endurance_need → budget_ceiling)
// ADJUST (no coherence — DEND is not a synaptic component)
// BEHAVE commit batches; spend tag/need as fuel
if dend_tag > tag_expiry:
Δ = min(slot_batch, dend_material, dend_energy·f_cap)
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 -= Δ'
// EMIT ship remaining batch one hop down to POST (demand = post tag)
post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost)
post_energy_ship += ship(dend_energy, post_demand, f_spine, ship_cost)
// RECOVER reclaim material from decayed ceilings
dend_material += dend_ceiling_shrinkage·recycle // energy NOT recovered
// DECAY
dend_structure -= decay_rate·Δt_cycle; dend_budget_ceiling -= capacity_decay_rate·Δt_cycle
dend_structure += min(dend_maint, maint_cost); dend_budget_ceiling += min(dend_cap_maint, cap_cost)
dend_tag *= decay(slow); dend_endurance_need *= decay(slow)
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. Its behavior unfolds across two DAY contexts and the NIGHT scope.
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.
DAY | AP:
// ADJUST (threshold from structure + adaptation + neuromodulators ; refractory gate)
threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh)
can_fire = soma_Na_inactivation < inactivation
// BEHAVE (fire if able)
if branch_Vm > threshold and can_fire:
if soma_budget < ap_cost:
// FUEL shortfall → endurance (firing was approaching CREB)
if soma_fast_trace > traj_thr and soma_fast_trace_rising:
soma_endurance_need += soma_fast_trace
exit
// EMIT (fired → AXON, DEND)
fired = True; soma_budget -= ap_cost
// TRACE (three traces from one AP — FAST nuclear-Ca, MEDIUM adaptation, refractory)
soma_Na_inactivation += ap_amp // → refractory (emergent)
soma_adaptation += ap_contrib // → threshold rise
soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost
// TRACE (strength)
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
// TRACE (NEURON-level aggregator — the cell sums what its components emit, by DAY)
neuron_activity += 1 // total firing this day
neuron_total_weight += Σ all component structure across the cell // running weight tally
DAY | NOT_AP:
// RECEIVE (integrate latest branch input — signal)
branch_Vm = integrate(DEND.branch_Vm, branches)
// TRACE (bottom-up refractory alignment: suprathreshold input during refractory)
if branch_Vm > threshold and soma_Na_inactivation > inactivation:
soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
// EMIT (ship downstream into transit; demand = propagated tags)
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)
// RECOVER (self-replenish from private root ; inactivation recovery sped by alignment)
soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
recovery = base_recovery × (1 + soma_refractory_alignment)
soma_Na_inactivation *= decay(τ_Na / recovery)
// DECAY
// FAST (ms–s) — refractory + nuclear-Ca + alignment (sub-second to seconds)
soma_fast_trace *= decay(τ_nuclear); soma_refractory_alignment *= decay(τ_align) // self-limiting
// MEDIUM (s–min) — adaptation + tagging evidence
soma_adaptation *= decay(τ_adapt)
soma_possible_tag *= decay(s); soma_endurance_need *= decay(min)
// SLOW (hr)
soma_tag *= decay(hr)
// (signals)
dopamine *= decay(ms)
// (PERSISTENT: soma_structure, soma_budget_ceiling — no DAY decay; NIGHT only)
NIGHT | cycle: // ROOT (neuronal material) — produces each cycle
// RECEIVE = PRODUCTION: synthesize this cycle's batch, gated by own tag, capped externally
soma_material += CREB_synth(soma_tag)·Δt_cycle // material — recoverable
soma_energy += mito_synth()·Δt_cycle // energy — NOT recoverable, bounded by night budget
night_energy_spent += mito_synth()·Δt_cycle // track against night supply ceiling
// TRACE read standing demand (soma_tag → structure ; soma_endurance_need → budget_ceiling)
// ADJUST (no coherence — SOMA is not a synaptic component)
// BEHAVE commit own batches
if soma_tag > tag_expiry:
Δ = min(slot_batch, soma_material, soma_energy·f_cap)
soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost; soma_tag -= Δ
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 -= Δ'
// EMIT ship batches one hop down to DEND and AXON (demand = propagated tags)
soma_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost)
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)
// RECOVER reclaim material from decayed ceilings (own + returned from downstream)
soma_material += soma_ceiling_shrinkage·recycle
// DECAY
soma_structure -= decay_rate·Δt_cycle; soma_budget_ceiling -= capacity_decay_rate·Δt_cycle
soma_structure += min(soma_maint, maint_cost); soma_budget_ceiling += min(soma_cap_maint, cap_cost)
soma_tag *= decay(slow); 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. Its behavior unfolds across two DAY contexts and the NIGHT scope.
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.
DAY | AP:
// ADJUST (reliability from structure − load-driven failure)
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance
// BEHAVE (propagate; FUEL shortfall degrades + flags endurance)
if axon_budget < prop_cost:
reliability *= budget_factor
if axon_fast_trace > traj_thr: // FUEL-limited → endurance
axon_endurance_need += axon_fast_trace
delivered = fired × reliability; axon_budget -= prop_cost × delivered
// EMIT (delivered APs reach boutons)
// TRACE
axon_fast_trace += delivered; axon_fast_trace *= decay(s)
DAY | NOT_AP:
// TRACE (strength)
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
// EMIT (ship to boutons; demand = pre tag)
axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
// RECOVER (refill budget from contested supply)
axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
// DECAY
// FAST (ms–s)
axon_fast_trace *= decay(s)
// MEDIUM (s–min)
axon_possible_tag *= decay(s); axon_endurance_need *= decay(min)
// SLOW (hr)
axon_tag *= decay(hr)
// (PERSISTENT: axon_structure, axon_budget_ceiling — no DAY decay; NIGHT only)
NIGHT | cycle: // intermediate node (relays down to PRE)
// RECEIVE batch arrived from SOMA this cycle
axon_material += transit(soma_material_to_axon, τ_transport_dend)
axon_energy += transit(soma_energy_to_axon, τ_transport_dend)
// TRACE read standing demand (axon_tag → structure ; axon_endurance_need → budget_ceiling)
// ADJUST (no coherence — AXON is not a synaptic component)
// BEHAVE commit batches; spend tag/need as fuel
if axon_tag > tag_expiry:
Δ = min(slot_batch, axon_material, axon_energy·f_cap)
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 -= Δ'
// EMIT ship remaining batch one hop down to PRE (demand = pre tag)
pre_material_ship += ship(axon_material, pre_demand, f_bouton, ship_cost)
pre_energy_ship += ship(axon_energy, pre_demand, f_bouton, ship_cost)
// RECOVER reclaim material from decayed ceilings
axon_material += axon_ceiling_shrinkage·recycle // energy NOT recovered
// DECAY
axon_structure -= decay_rate·Δt_cycle; axon_budget_ceiling -= capacity_decay_rate·Δt_cycle
axon_structure += min(axon_maint, maint_cost); axon_budget_ceiling += min(axon_cap_maint, cap_cost)
axon_tag *= decay(slow); axon_endurance_need *= decay(slow)
ASTRO
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
DAY | CONTINUOUS: // per astrosynapse i
// RECEIVE (root production, capped by glucose)
astro_central_budget += glycolysis(glucose)·Δt
// ADJUST (demand weights across territory)
for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
for each i: astro_territory_demand[i] += demand[i]·Δt // TRACE: territory-level aggregator (by DAY)
factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
// EMIT (demand-weighted lactate to all components)
for each i:
astro_lactate[i] = demand[i] × factor; astro_central_budget -= astro_lactate[i]·lactate_cost
// BEHAVE (clear glutamate ; supply tonic D-serine)
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:
// TRACE
astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s)
// ADJUST (D-serine demand from spillover)
want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
got = min(want, astro_central_budget × Ds_frac)
// BEHAVE + EMIT (D-serine pulse to POST gate)
astro_Dserine[i] += got; astro_central_budget -= got·Ds_cost
// TRACE (endurance: BUDGET-limited synthesis under high own demand)
if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
astro_endurance_need[i] += (want - got)
// TRACE (strength)
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
// FAST (ms–s) — astro_fast_trace already decayed above (intra-step)
// MEDIUM (s–min)
astro_possible_tag[i] *= decay(s); astro_endurance_need[i] *= decay(min)
// SLOW (hr)
astro_tag[i] *= decay(hr)
// (PERSISTENT: astro_structure, astro_budget_ceiling — no DAY decay; NIGHT only)
// EMERGENCY
if astro_fast_trace[i] > overload: emit(shockwave_lockdown)
NIGHT | cycle: // ROOT (synaptic energy + ECM) — produces each cycle
// RECEIVE = PRODUCTION: 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
// ADJUST tag-weighted shares across the territory
W = Σ astro_tag[i] over astro_tag[i] > tag_expiry
// EMIT distribute this cycle's batch to astrosynapses (demand = own tag)
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
// BEHAVE each astrosynapse commits; spend tag/need as fuel (coherence applies — synaptic)
for each astrosynapse i:
coh = coherence_signal[i]
if astro_tag[i] > tag_expiry:
Δ = min(slot_batch, astro_material[i], astro_energy[i]·f_cap)
astro_structure[i] += Δ × coh // 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] -= Δ'
// RECOVER reclaim material from decayed ceilings
astro_central_material += astro_ceiling_shrinkage·recycle // energy NOT recovered
// DECAY
for each i:
astro_structure[i] -= decay_rate·Δt_cycle; astro_budget_ceiling[i] -= capacity_decay_rate·Δt_cycle
astro_structure[i] += min(astro_maint[i], maint_cost)
astro_budget_ceiling[i] += min(astro_cap_maint[i], cap_cost)
astro_tag[i] *= decay(slow); astro_endurance_need[i] *= decay(slow)
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 — the driver (a hierarchy of actors, phased)
NIGHT runs a loop of cycles. Each cycle has FOUR actor tiers acting in order from the top of the hierarchy down: the external replay signal arrives, the NEURON renormalizes, the ASTROCYTE territory reallocates, then the COMPONENTS commit within what they were handed. The night is PHASED: early cycles DOWNSCALE (reset occupancy, renormalize weight — subtractive, make room), later cycles COMMIT (build ceilings for the survivors — additive). It ends emergently.
NIGHT driver:
night_energy_spent = 0
N_cycles_early = early_phase_frac × estimated_cycles
repeat cycle = 1, 2, 3, …:
phase = (cycle ≤ N_cycles_early) ? DOWNSCALE : COMMIT
// ── TIER 0: ASSEMBLY/NETWORK (external) ───────────────────────────────
// replay_reweight[s] arrives this cycle: re-presents the day's patterns and
// re-weights which synapses the assembly found significant (external signal).
// ── TIER 1: NEURON (renormalize total weight; drive occupancy downscaling) ──
if phase == DOWNSCALE:
// multiplicative-global occupancy reset — only CEILINGS will persist
for each synapse s:
VGCC_active[s] *= downscale_factor
AMPA_surface[s] *= downscale_factor
possible_tag[s] *= downscale_factor // medium evidence renormalized too
// renormalize total committed weight toward the cell's budget (Tononi-style)
if neuron_total_weight > neuron_weight_ceiling:
g = neuron_weight_ceiling / neuron_total_weight
for each component c in cell: c_structure *= g
soma_material += Σ reduction·recycle // freed material returns to pool
// ── TIER 2: ASTROCYTE territory (reallocate metabolic support) ─────────
// reallocate this cycle's energy/material across the territory by accumulated demand,
// re-weighted by replay — the astrocyte is the metabolic arbiter of its synapses
for each astrosynapse i:
astro_alloc[i] = (astro_territory_demand[i] × replay_reweight[i])
/ Σ(astro_territory_demand × replay_reweight)
// (astro_alloc biases each synapse's share of the astrocyte's produced batch this cycle)
// ── TIER 3: COMPONENTS (commit within the allocation handed down) ──────
// coherence signal (cross-component) from this cycle's standing tags
for each synapse s:
coherence_signal[s] = (pre_tag[s], post_tag[s], astro_tag[s] all > tag_expiry)
? coherence_factor : 1
if phase == COMMIT:
run PRE, POST, DEND, SOMA, AXON, ASTRO NIGHT | cycle // build ceilings
else:
run SOMA, ASTRO NIGHT | cycle (PRODUCE + EMIT only) // pre-stage material downstream
// ── termination — emergent, OR of two conditions ──────────────────────
night_energy_spent updated by the roots' production this cycle
demand_left = Σ all tags > tag_expiry (system-wide)
if demand_left ≈ 0: break // DEMAND exhausted (rested)
if night_energy_spent ≥ night_energy_ceiling: break // SUPPLY spent (overloaded)
// ── CODA (once at end of night) ────────────────────────────────────────────
// clear DAY traces and the DAY aggregators; occupancy already reset by downscaling
all fast_trace, possible_tag, endurance_need = 0
soma_Na_inactivation = soma_adaptation = soma_refractory_alignment = 0
neuron_activity = 0; neuron_total_weight = recomputed from surviving structure
astro_territory_demand[·] = 0
// tags are NOT cleared — unspent tags carry forward, decaying on their slow τ
// structure and budget_ceiling PERSIST as the next DAY's ceilings
// VGCC_active / AMPA_surface have been returned to baseline by downscaling
Notes. (1) The phasing makes cycles genuinely different: an early cycle reshapes the landscape (reset occupancy, renormalize weight, pre-stage material), a late cycle builds on the reshaped landscape — so what gets committed depends on the order, and could not be computed in one shot. (2) Higher actors never read a component's interior: the neuron renormalizes a sum it accumulated from emitted activity; the astrocyte reallocates by demand it accumulated; coherence and replay arrive as signals. Locality holds — the system acts locally and consolidates hierarchically. (3) Occupancy is reset every night, so each DAY starts from baseline occupancy against whatever ceilings persisted: the only thing that carries a day forward is what earned a ceiling.
One-view summary
SEVEN-GROUP GRAMMAR, TWO SCOPES, ONE LADDER
RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY
DAY grammar on OCCUPANCY within two ceilings (structure=strength, budget_ceiling=endurance)
bottom-up: consumers act, evidence ascends leaves→roots
TRACE yields two evidence streams from local state + arrived signals:
fast_trace + dopamine → tag (strength)
FUEL shortfall + interrupted LOCAL success → endurance_need (endurance)
OCCUPANCY/structure/timing shortfalls → short-term depression (NOT endurance)
NIGHT enacted by a HIERARCHY of actors (not the DAY components alone), PHASED:
assembly/network replay (external) → NEURON renormalize total weight + downscale occupancy
→ ASTROCYTE territory reallocate → COMPONENTS commit ceilings within what's handed down
early cycles DOWNSCALE (reset occupancy multiplicatively-global, make room),
late cycles COMMIT (build ceilings for survivors)
higher actors ACCUMULATE aggregate traces by DAY, ACT by NIGHT (locality holds)
ends when DEMAND exhausted (no tag stands) OR SUPPLY spent (night energy used)
what persists must EARN it: occupancy resets to baseline, only CEILINGS carry;
unspent tags carry to next night; material recycles, ENERGY does not (arrow of time)
RULE the system ACTS LOCALLY (DAY, local components) and CONSOLIDATES HIERARCHICALLY (NIGHT)
FLOWS every flow has a timescale; shipment is transit-delayed (distal fills over cycles)
LOCAL every group uses only own state + arrived signals; RECEIVE/EMIT are the only crossings