diff --git a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md new file mode 100644 index 0000000..a807347 --- /dev/null +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -0,0 +1,1083 @@ +# 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_reweight arrives as an EXTERNAL signal (like dopamine/glucose) +``` + +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 PHASED, AND OCCUPANCY RESETS. When a component is in NIGHT, early cycles DOWNSCALE +(occupancy filled during its day — VGCC_active, AMPA_surface, possible_tag — driven toward +baseline by multiplicative-global scaling broadcast by the neuron; total weight renormalized), +later cycles COMMIT (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. A tagged synapse starts the next day strong because its +ceiling was raised, 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) +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 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 +``` + +--- +--- +# 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. 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) + neuron broadcasts + pre_material += transit(pre_material_ship, τ_transport_bouton) + pre_energy += transit(pre_energy_ship, τ_transport_bouton) + // BEHAVE (DOWNSCALE phase) — reset OWN occupancy / renorm OWN structure on arrived signals + if occupancy_downscale arrived: + VGCC_active *= occupancy_downscale; pre_possible_tag *= occupancy_downscale + if renorm_signal arrived: + freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal + emit(freed → recycled material pool) // I scale myself; neuron only signalled + // 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 phase) — build ceilings; spend tag/need as fuel + if rest_permission and 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 rest_permission and 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 downstream — bouton is a leaf) ; pre_fatigue → HYPOTHALAMUS + // 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 + // EMIT (soma emits its own activity; the NEURON sums it — soma does NOT aggregate the cell) + soma_emitted_activity += 1; soma_emitted_structure = soma_structure + +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) +``` + +--- + +## 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: + // 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-BLOCK UNIFORMITY. PRE's `NIGHT | cycle` above is the worked exemplar. POST, DEND, SOMA, +> AXON, and ASTROSYNAPSE follow the identical pattern, shown in their blocks in abbreviated form: +> (a) all commits are gated by `rest_permission` (arrived from the cell actor); (b) on a +> DOWNSCALE-phase signal each self-resets its own occupancy (`*_occupancy *= occupancy_downscale`) +> and self-renormalizes its own structure (`*_structure *= renorm_signal`, emitting the freed +> material) — the cell actor only broadcasts, the component scales itself; (c) each emits its own +> fatigue upward. Roots (SOMA material, ASTROSYNAPSE/ASTROCYTE energy) additionally PRODUCE their +> batch each cycle and track `night_energy_spent`. Only the occupancy-holders (PRE: VGCC_active, +> POST: AMPA_surface) carry the self-downscale line; the rest carry only the structure renorm. + +--- +--- +# 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 · early_phase_frac · 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) + phase = (cycle ≤ early_phase_frac × est_cycles) ? DOWNSCALE : COMMIT + // ADJUST read replay (external) + own aggregate + // EMIT (broadcast) — the neuron acts ONLY by signalling; components scale themselves + if phase == DOWNSCALE: + occupancy_downscale = downscale_factor // → components reset own occupancy + 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) · early_phase_frac · 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 + +``` +SEVEN-GROUP GRAMMAR · EIGHT ACTORS · ONE FATIGUE LOOP + RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY + +ACTORS local: soma·pre·post·dend·axon·astrosynapse cell: neuron·astrocyte system: hypothalamus + same template; higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in + +DAY (per-component state: own_activity high) behave locally, evidence ascends leaves→roots + fast_trace + dopamine → tag (strength) ; FUEL shortfall + interrupted success → endurance_need + emit fatigue upward as metabolic debt accumulates +NIGHT (per-component state: own_activity low AND sleep_pressure high) restructure, capacity descends + phased: early DOWNSCALE (self-reset occupancy + self-renorm structure on broadcast signals), + late COMMIT (tag→structure, need→budget_ceiling, spend tag-as-fuel) — only with rest_permission + 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 the two phases of one homeostatic loop the system runs on itself, per component (local sleep). +RULE no actor authorizes its own restructuring — each is PUT IN POSITION by the actor above + (which 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 every group uses only own state + arrived signals; RECEIVE/EMIT are the only crossings +``` diff --git a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v16.md b/elements/neuron/appunti/old/2026-06-29-tripartite-synapse_v16.md similarity index 100% rename from elements/neuron/appunti/2026-06-29-tripartite-synapse_v16.md rename to elements/neuron/appunti/old/2026-06-29-tripartite-synapse_v16.md