ocrampal/organism
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update 2026-06-29-tripartite-synapse_v17.md

Browse Source
This commit is contained in:
ocrampal
2026-07-02 12:16:27 +02:00
parent 8d8d2f74e7
commit a562eb3292
1 changed files with 153 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files
elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md
+153 -149
View File
@@ -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
```