From a562eb32922bb6dbd3f630f76f64172e12909c23 Mon Sep 17 00:00:00 2001 From: ocrampal Date: Thu, 2 Jul 2026 12:16:27 +0200 Subject: [PATCH] Update 2026-06-29-tripartite-synapse_v17.md --- .../2026-06-29-tripartite-synapse_v17.md | 302 +++++++++--------- 1 file changed, 153 insertions(+), 149 deletions(-) diff --git a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md index 8db3905..993f080 100644 --- a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -148,7 +148,28 @@ ceiling was raised, not because its transient occupancy was spared. ## Conventions ``` -SCOPE = {DAY, NIGHT} CONTEXT = {AP, NOT_AP, bAP, NOT_bAP, CONTINUOUS} +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 @@ -282,11 +303,13 @@ recycled material). // 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: ACTION (lateral, punctate — the AP) → EVALUATION (local, trace fresh — climb to tag) -// → PREPARATION (vertical, trace decaying — ready next release). Phase edges are -// event/decay-timed, not clocked: AP ends preparation; fast-trace decay ends evaluation. +// 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 · ACTION | AP: // lateral: release into the cleft +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) @@ -300,23 +323,26 @@ DAY · ACTION | AP: // lateral: release glutamate += NT_flux·Δt // EMIT glutamate → POST, ASTRO if glutamate > spillover: drive *= brake // own-cleft autobrake -DAY · EVALUATION | after AP, fast trace fresh: // local: climb the ladder toward the tag - if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt // MEDIUM · accumulate - if dopamine > dop_thr and pre_possible_tag > tag_thr: // SLOW · accumulate - pre_tag += dopamine × pre_possible_tag·Δt // the inert token minted for NIGHT +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 · PREPARATION | fast trace decaying: // vertical: ready the next action - retro_NO_local = retro_NO; retro_eCB_local = retro_eCB // latch descended/arrived signals - // short-term potentiation: eligibility → coupling readiness (NO dopamine; drifts back) +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 - // refill BOTH pools TOWARD next demand (forward-facing, not restoration) + 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)) - RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget) - // decay times the phase edges (fast clears evaluation; medium/slow settle; persistent waits for NIGHT) - pre_fast_trace *= decay(100ms) // FAST + // 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) @@ -359,30 +385,30 @@ NIGHT · PREPARATION | make room: // vertical: take co 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. +validation (three coincidences) before committing. -**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. +**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. -**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. +**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). -**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. +**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 @@ -396,57 +422,44 @@ ceilings drift down. // 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 | NOT_bAP: - // ADJUST (AMPA drive from arrived glutamate) +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) - // 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) + AMPA_current = a × AMPA_surface; Vm += AMPA_current; post_budget -= AMPA_cost // SOURCE 1 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 > 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 - post_fast_trace *= decay(ms) - // BEHAVE (STP fill slots from private reserve ; else STD drift = consequence) + 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 (own Ca was climbing toward a tag) + 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 already at slot_ceiling → structure-limited (not endurance) + // else: surface 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) + 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)) - // 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) + 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 -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) +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) @@ -510,7 +523,9 @@ ceilings drift down. // NOTE DEND endurance fires only on FUEL-limited propagation, not structural attenuation; // own-state proxy (strong branch activity); no arrived feedback term. -DAY | bAP: +// 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: @@ -522,23 +537,20 @@ DAY | bAP: 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 + // 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: - // TRACE (strength) +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 - // ADJUST (commit threshold lowered by attention) + 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) - // 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_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) @@ -616,55 +628,52 @@ downstream components receive depends on the soma having been tagged. // NOTE SOMA endurance fires only on FUEL shortfall (budget < ap_cost); // refractory / sub-threshold are timing limits, not endurance. Own-state proxy. -DAY | AP: +// 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 - // BEHAVE (fire if able) + // 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 - // 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) + 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 - // 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 + soma_emitted_activity += 1; soma_emitted_structure = soma_structure // NEURON sums these -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) +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 - // EMIT (ship downstream into transit; demand = propagated tags) + // 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) - // 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) + // 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) - // (signals) - dopamine *= decay(ms) - // (PERSISTENT: soma_structure, soma_budget_ceiling — no DAY decay; NIGHT only) + soma_tag *= decay(hr); dopamine *= decay(ms) NIGHT | cycle: // ROOT (neuronal material) — produces each cycle // RECEIVE = PRODUCTION: synthesize this cycle's batch, gated by own tag, capped externally @@ -726,27 +735,25 @@ ceilings drift down. // 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: +// 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 - // 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) + 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: - // TRACE (strength) +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 - // EMIT (ship to boutons; demand = pre tag) + // PREP: ship to boutons, refill toward next demand, settle 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) @@ -755,7 +762,6 @@ DAY | NOT_AP: 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 @@ -823,41 +829,37 @@ directions, so it amplifies whatever trajectory the synapse is already on. // material/precursor-limited synthesis is a material limit, not endurance. Own-state proxy. // EMERGENCY emits shockwave_lockdown on overload +// RING × CONTEXT: CONTINUOUS — no spike, so ACTION (clear/gate), EVALUATION (tag climb), +// and PREPARATION (allocate/refill/settle) all run each step in the graded flow. The ring +// turns continuously rather than being delimited by discrete events. + DAY | CONTINUOUS: // per astrosynapse i - // RECEIVE (root production, capped by glucose) + // PREP: root production, demand weights, lactate allocation (ready the territory) astro_central_budget += glycolysis(glucose)·Δt - // ADJUST (demand weights across territory) for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff - for each i: astro_territory_demand[i] += demand[i]·Δt // TRACE: territory-level aggregator (by DAY) + for each i: astro_territory_demand[i] += demand[i]·Δt // territory-level aggregator (by DAY) factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε)) - // EMIT (demand-weighted lactate to all components) for each i: astro_lactate[i] = demand[i] × factor; astro_central_budget -= astro_lactate[i]·lactate_cost - // BEHAVE (clear glutamate ; supply tonic D-serine) + // ACTION: clear glutamate, supply tonic D-serine, gate on demand (the defining act) glutamate[i] -= astro_structure[i].EAAT × glutamate[i]·Δt; astro_central_budget -= clearance·EAAT_cost astro_Dserine[i] += astro_structure[i].Dserine_tonic·Δt if glutamate[i] > spillover: - // TRACE - astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s) - // ADJUST (D-serine demand from 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) - // 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) + 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) - // TRACE (strength) + 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 - // FAST (ms–s) — astro_fast_trace already decayed above (intra-step) + // DECAY (settle) // 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) @@ -1050,26 +1052,28 @@ discharges its fatigue and wakes; an overloaded one wakes with tags unspent (the ## One-view summary ``` -SEVEN-GROUP GRAMMAR · EIGHT ACTORS · ONE FATIGUE LOOP - RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY +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 template; higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in + same ring; higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in -DAY (per-component state: own_activity high) behave locally, evidence ascends leaves→roots +DAY (per-component state: own_activity high) ring turned OUTWARD against the world 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 + 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 the two phases of one homeostatic loop the system runs on itself, per component (local sleep). + 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 - (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). -``` + (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 +LOCAL only own state + arrived signals; ACTION/EMIT are the crossings; nothing is a pure sink ```