# 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. NIGHT IS A SEQUENCE OF REPLAY CYCLES (dual of DAY). DAY loops action-steps until energy/material is exhausted; NIGHT loops NON_REM_1 → REM → NON_REM_2 cycles until the tag is exhausted. It is the SAME three-phase ring as DAY (PREPARATION · ACTION · EVALUATION) — only the subjects and the assignment of which phase is ACTION vs EVALUATION rotate: NON_REM_1 = PREPARATION import material/energy; PRIME the threshold/VGCC from the standing tag REM = EVALUATION release NT as a PROBE to MEASURE participation (fast_trace level); NO dopamine — significance is settled; this reads circuit centrality only NON_REM_2 = ACTION the structural change itself (the night's defining deed): general homeostatic lowering, then increase where tag stands AND REM measured high/medium participation, consuming the tag on the build The SAME physical NT release is ACTION by DAY (transmit) and EVALUATION by NIGHT (probe to measure). The structural change is only MARKED by day (the inert tag) and ENACTED by night. SOMA is the ignition point: its REM firing 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 NON_REM_1); 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. NON_REM_1 drives occupancy (VGCC_active, AMPA_surface, possible_tag) toward baseline; NON_REM_2'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) 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 (NON_REM_1→REM→NON_REM_2) 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), NON_REM_1 neuron_weight_ceiling // renormalization target (broadcast constraint) // ── NIGHT RING (NON_REM_1 = PREPARATION · REM = EVALUATION · NON_REM_2 = ACTION) ── spont_thr_base thr_gain // spontaneous threshold = base − gain×own_tag (NON_REM_1 prime) prime_thr prime_gain // tag threshold to raise VGCC, and the gain (NON_REM_1) 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 ring turned inward.** ACTION is the coherence check (does post and astro concur this **NIGHT — the same ring, rotated; release becomes a probe, structure-change becomes the act.** The night runs the SAME three phases as the day (PREPARATION · ACTION · EVALUATION) — only the subjects and the assignment of which phase is which rotate. NON_REM_1 = PREPARATION imports material and energy and primes the threshold/VGCC from the standing tag. REM = EVALUATION releases NT — but as a PROBE, to measure its own fast_trace as *participation* in the re-evoked circuit (no dopamine; significance is settled). NON_REM_2 = ACTION is the structural change itself — the night's defining deed: general homeostatic lowering, then increase where the tag still stands AND REM measured high/medium participation, consuming the tag on the build. The same NT release is ACTION by day (transmit) and EVALUATION by night (measure); the structural change is only marked by day (the inert 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 RING × CONTEXT (Option B: organize by imposed context, annotate with phase): // AP → ACTION (release; deposit fast trace) // NOT_AP → FAST eval + FAST prep (rides the train; sets short-term depression) // NOT_SPIKE_TRAIN → SLOW eval + SLOW prep ⊂ NOT_AP (runs ON TOP of NOT_AP in sustained quiet) // nested, not exclusive: each behavior in exactly ONE block, so nothing double-runs. DAY | AP: // ACTION (lateral): release into cleft // 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 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 DAY | NOT_AP: // FAST eval + FAST prep (in-train gaps AND quiet) retro_NO_local = retro_NO; retro_eCB_local = retro_eCB // latch arrived signals // FAST EVAL: eligibility climbs from the fresh trace (MEDIUM · accumulate) if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt // FAST PREP: partial vesicle refill (release-vs-refill race → sets STD depth) + fast-trace decay RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget) pre_fast_trace *= decay(100ms) // FAST — rides the train DAY | NOT_SPIKE_TRAIN: // SLOW eval + SLOW prep (sustained quiet; ⊂ NOT_AP) // SLOW EVAL: dopamine-gated tag — the inert token minted for NIGHT (SLOW · accumulate) if dopamine > dop_thr and pre_possible_tag > tag_thr: pre_tag += dopamine × pre_possible_tag·Δt // SLOW PREP: 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 // SLOW PREP: full budget refill toward next demand (forward-facing, not restoration) pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton)) // medium/slow settle (fast-trace decay already ran in NOT_AP; not repeated here) 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: a cycle of NON_REM_1 → REM → NON_REM_2, repeated until the tag is spent (dual of DAY, // which loops until energy is spent). SAME RING as DAY, only the SUBJECTS and the assignment of // ACTION/EVALUATION rotate — the same physical NT release is ACTION by DAY (transmit) and // EVALUATION by NIGHT (probe to measure participation). One TAG, three roles: (day) significance // bridge; (NON_REM_1) primes threshold/VGCC; (NON_REM_2) gates + fuels the build, then consumed. // NON_REM_1 = PREPARATION (import + prime) — vertical // REM = EVALUATION (release to MEASURE participation; NO dopamine) — local/measuring // NON_REM_2 = ACTION (the structural change itself — the night's defining deed) — the act NIGHT · NON_REM_1 = PREPARATION | import + prime: // vertical: supply + set excitability // import this cycle's material + energy (forward-facing) pre_material += transit(pre_material_ship, τ_transport_bouton) pre_energy += transit(pre_energy_ship, τ_transport_bouton) // prime from the STANDING tag: high tag lowers threshold → raises VGCC (else leave unchanged) 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) // apply descended constraint to MYSELF (broadcast only); recycle pre_possible_tag *= occupancy_downscale if renorm_signal arrived: freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal emit(freed → recycled material pool) pre_material += pre_ceiling_shrinkage·recycle // energy NOT recovered NIGHT · REM = EVALUATION | release to MEASURE participation (NO dopamine): // local: probe, not transmit // release using the primed VGCC — a PROBE, deposits fast trace (same channel as DAY, different purpose) spont = intrinsic_fluctuation() if spont > pre_spont_thr or arrived_replay_AP: // spontaneous, or recruited by the propagating pattern pre_fast_trace += mini_Ca(VGCC_active); glutamate += mini_flux·Δt // READ the fast trace as PARTICIPATION in the re-evoked circuit — no dopamine, no tag accumulation pre_participation = level(pre_fast_trace) // high / medium / low = circuit centrality pre_fast_trace *= decay(100ms) NIGHT · NON_REM_2 = ACTION | change the structure (the night's defining deed): // the irreversible act // (1) general homeostatic lowering of structure — the subtractive baseline pre_structure -= decay_rate·Δt_cycle pre_structure += min(pre_maint, maint_cost) // maintenance holds up what is used // (2) increase structure where the tag STILL STANDS and REM measured high/medium participation 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 -= Δ // (3) CONSUME tag on build → threshold rises next cycle // endurance capacity (fuel-limited succeeding release) builds on the same act 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 -= Δ' else: pre_budget_ceiling -= capacity_decay_rate·Δt_cycle; pre_budget_ceiling += min(pre_cap_maint, cap_cost) // if tag low or participation low: no build — the change was never worth the spend (forgotten) 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 and PREPARATION share the quiet.** Evaluation reads the calcium trace and, on the dopamine coincidence, climbs to the tag. Preparation fills AMPA surface toward the slot ceiling from accumulated calcium (short-term potentiation, no dopamine), refills budget toward next demand, and lets traces settle. 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 NIGHT — the spine's ceilings are rewritten.** The ring turned inward: coherence check, draw-and-commit (structure where a validated tag stood — with a coherence bonus when pre, post, and astro all tagged the same synapse — or budget capacity where fuel interrupted a climbing trajectory), make-room. 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. // RING × CONTEXT: NOT_bAP → ACTION(integrate) + EVAL + PREP | bAP → second ACTION (vertical amplify) // coincidences sort by timescale: D-serine/bAP detected IN ACTION (instantaneous), // dopamine detected IN EVALUATION (integrable). DAY | bAP: // ACTION (vertical): soma's spike 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: // ACTION(integrate) then EVAL + PREP // ── ACTION (lateral): integrate arrived input, detect instantaneous coincidences, emit retro ── 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 // ── EVALUATION (local): climb toward 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 // ── PREPARATION (vertical): STP fill / STD drift, refill toward next demand, settle ── if post_fast_trace > Ca_STP: if post_budget < traffic_cost: // FUEL shortfall → endurance 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_fast_trace *= decay(ms) // FAST post_possible_tag *= decay(min); post_endurance_need *= decay(min) // MEDIUM post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals NIGHT | cycle: // leaf of DAY chain, but emits inward/upward by NIGHT // 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. // RING × CONTEXT: bAP → ACTION(propagate+integrate) + EVAL | NOT_bAP → EVAL + PREP (ship/refill/settle) DAY | bAP: // ACTION (lateral/vertical): propagate + integrate // 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 (deposit fast trace THIS action leaves) 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: // EVALUATION (climb to tag) + PREPARATION (ship/refill/settle) // EVAL: 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 // PREP: attention lowers commit threshold; local translation; ship to spines; refill; settle 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)) // 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. // RING × CONTEXT: AP → ACTION(fire) + EVAL(nuclear Ca→tag) | NOT_AP → EVAL + PREP // the ONE spike's fast trace feeds TWO destinations: nuclear-Ca → tag (EVALUATION, cross-scope), // and inactivation/adaptation/alignment → next-spike timing (PREPARATION, this scope). DAY | AP: // ACTION (lateral): fire; then EVAL climbs to tag // 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 // ACTION (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 fired = True; soma_budget -= ap_cost // EMIT fired → AXON, DEND // deposit the THREE traces from one AP: nuclear-Ca (→EVAL) + adaptation/inactivation (→PREP) soma_Na_inactivation += ap_amp // PREP seed: refractory (emergent) soma_adaptation += ap_contrib // PREP seed: threshold rise soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // EVAL seed // EVALUATION: strength climb toward the tag (cross-scope token 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 DAY | NOT_AP: // EVAL (align) + PREP (recover timing, ship, refill) branch_Vm = integrate(DEND.branch_Vm, branches) // RECEIVE latest branch input // PREP seed: refractory alignment (suprathreshold input during refractory → tune next-spike timing) if branch_Vm > threshold and soma_Na_inactivation > inactivation: soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation // PREP: ship downstream, self-replenish from root, recover refractoriness (sped by alignment) 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) 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 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); dopamine *= decay(ms) // ── NIGHT: NON_REM_1 → REM → NON_REM_2, until tag spent (same ring as PRE, rotated). SOMA is a // ROOT (produces material each cycle) AND the IGNITION POINT: its REM firing propagates a replay // AP down axon + dendrites, re-evoking the pattern through the DAY PATHWAY. A pattern carries only // if every link is primed (each component's own tag lowered its own threshold). SOMA's own // firing/participation is measured the way PRE measures release; NON_REM_2 is its structural act. NIGHT · NON_REM_1 = PREPARATION | produce + prime: // vertical: production + excitability + supply // PRODUCTION (root): this cycle's material + energy 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 night_energy_spent += mito_synth()·Δt_cycle // prime OWN spontaneous-firing threshold from OWN standing tag (high tag → easier to ignite) soma_spont_thr = spont_thr_base − thr_gain × soma_tag // ship this cycle's batch down to DEND and AXON (feeds the pattern's downstream links) 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) soma_material += soma_ceiling_shrinkage·recycle // recycle NIGHT · REM = EVALUATION | fire to ignite + MEASURE participation (NO dopamine): // ignition + probe spont = intrinsic_fluctuation() if spont > soma_spont_thr: replay_AP = TRUE soma_fast_trace += nuclear_Ca() // deposit trace (the measurement) // propagate down the DAY PATHWAY (self-igniting): AP → axon → boutons ; bAP → dendrites/spines emit(replay_AP → AXON, DEND) // AXON/DEND relay onward IF primed // pattern carries link by link, each relaying only if primed (mechanical coherence): // SOMA →[replay_AP]→ AXON(primed?) →→ PRE(primed?) →[glutamate]→ POST(primed?) →→ DEND →→ SOMA // a single un-primed link breaks the loop — only all-primed patterns re-evoke. soma_participation = level(soma_fast_trace) // high/medium/low = circuit centrality (no dopamine) soma_fast_trace *= decay(τ_nuclear) NIGHT · NON_REM_2 = ACTION | change the structure: // the night's defining deed soma_structure -= decay_rate·Δt_cycle; soma_structure += min(soma_maint, maint_cost) // homeostatic lowering if soma_tag > tag_expiry and soma_participation ≥ MEDIUM: Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag) × soma_participation soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost soma_tag -= Δ // CONSUME on build → threshold rises next cycle 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 -= Δ' // if tag low or participation low: no build — never worth the spend (forgotten) 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. // RING × CONTEXT: AP → ACTION(propagate) | NOT_AP → EVAL(climb to tag) + PREP(ship/refill/settle) DAY | AP: // ACTION (lateral): propagate the spike // ADJUST (reliability from structure − load-driven failure) 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 axon_endurance_need += axon_fast_trace delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT delivered → boutons axon_fast_trace += delivered; axon_fast_trace *= decay(s) // deposit fast trace DAY | NOT_AP: // EVALUATION (climb to tag) + PREPARATION // EVAL: 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 // PREP: ship to boutons, refill toward next demand, settle axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost) 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) 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) ``` --- ## 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 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 | 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-BLOCK UNIFORMITY. PRE and SOMA above are the worked exemplars of the NIGHT ring > (NON_REM_1 = PREPARATION · REM = EVALUATION · NON_REM_2 = ACTION). POST, DEND, AXON, and > ASTROSYNAPSE follow the identical pattern: (a) NON_REM_1 imports supply, primes each one's OWN > threshold from its OWN standing tag (→ occupancy), applies the descended constraint to itself, > recycles, and — for intermediate nodes AXON/DEND — relays the arrived `replay_AP` onward IF primed > (this carries the pattern SOMA→PRE and SOMA→POST); (b) REM releases/fires as a PROBE and reads its > own fast_trace as participation (level: high/medium/low), NO dopamine; (c) NON_REM_2 lowers > structure homeostatically, then rebuilds where the tag still stands AND participation ≥ medium, > consuming the tag on the build. Roots (SOMA material, ASTROCYTE energy) additionally PRODUCE each > cycle and track `night_energy_spent`. > [The POST/DEND/AXON/ASTROSYNAPSE night blocks below still show the earlier commit form and are > pending conversion to NON_REM_1/REM/NON_REM_2 — the mechanism is defined by PRE + SOMA.] --- --- # 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 NON_REM_1→REM→NON_REM_2; the neuron just supplies the constraint. occupancy_downscale = downscale_factor // → components reset own occupancy (in NON_REM_1) 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 ```