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 ## 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") VARIABLE TIERS (timescale = meaning; see logic_principles "The Timescale Ladder")
FAST (ms–s) immediate response fast_trace 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) // 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) // 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) // THE RING × CONTEXT (Option B: organize by imposed context, annotate with phase):
// → PREPARATION (vertical, trace decaying — ready next release). Phase edges are // AP → ACTION (release; deposit fast trace)
// event/decay-timed, not clocked: AP ends preparation; fast-trace decay ends evaluation. // 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) // deposit the fast trace THIS action leaves (FAST · impulse)
pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike) pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike)
drive = sat(pre_fast_trace × VGCC_active, K_release) × (1 - retro_eCB_local) 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 glutamate += NT_flux·Δt // EMIT glutamate → POST, ASTRO
if glutamate > spillover: drive *= brake // own-cleft autobrake if glutamate > spillover: drive *= brake // own-cleft autobrake
DAY · EVALUATION | after AP, fast trace fresh: // local: climb the ladder toward the tag DAY | NOT_AP: // FAST eval + FAST prep (in-train gaps AND quiet)
if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt // MEDIUM · accumulate retro_NO_local = retro_NO; retro_eCB_local = retro_eCB // latch arrived signals
if dopamine > dop_thr and pre_possible_tag > tag_thr: // SLOW · accumulate // FAST EVAL: eligibility climbs from the fresh trace (MEDIUM · accumulate)
pre_tag += dopamine × pre_possible_tag·Δt // the inert token minted for NIGHT 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 DAY | NOT_SPIKE_TRAIN: // SLOW eval + SLOW prep (sustained quiet; ⊂ NOT_AP)
retro_NO_local = retro_NO; retro_eCB_local = retro_eCB // latch descended/arrived signals // SLOW EVAL: dopamine-gated tag — the inert token minted for NIGHT (SLOW · accumulate)
// short-term potentiation: eligibility → coupling readiness (NO dopamine; drifts back) 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: if pre_possible_tag > stp_thr:
VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling) VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling)
else: else:
VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline) // STD = un-honored decay VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline) // STD = un-honored decay
// refill BOTH pools TOWARD next demand (forward-facing, not restoration) // 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)) 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) // medium/slow settle (fast-trace decay already ran in NOT_AP; not repeated here)
// decay times the phase edges (fast clears evaluation; medium/slow settle; persistent waits for NIGHT)
pre_fast_trace *= decay(100ms) // FAST
pre_possible_tag *= decay(s); pre_endurance_need *= decay(min) // MEDIUM pre_possible_tag *= decay(s); pre_endurance_need *= decay(min) // MEDIUM
pre_tag *= decay(hr) // SLOW pre_tag *= decay(hr) // SLOW
dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s) 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, 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 runs the calcium dynamics that decide potentiation versus depression, and requires the most
validation (three coincidences) before committing. Its behavior unfolds across two DAY validation (three coincidences) before committing.
contexts and the NIGHT scope.
**During DAY, during NOT_bAP — the spine integrates input and decides plasticity.** Three **POST's ACTION is the synaptic event (context NOT_bAP).** Integration is graded and ongoing
calcium sources feed its fast trace: AMPA current (small Ca, begins ejecting the NMDA Mg block), rather than spike-punctate, so POST's action-context is "glutamate present, no bAP": three calcium
NMDA (large Ca, but only on the local coincidence of depolarization + astrocyte D-serine + sources feed the fast trace — AMPA current (small Ca, begins ejecting the NMDA Mg block) and NMDA
glutamate), and — in the bAP context — the back-propagating spike. High calcium drives AMPA (large Ca, only on the local coincidence of depolarization + astrocyte D-serine + glutamate). The
receptors to the surface (short-term potentiation, occupancy filled toward the slot ceiling, no action deposits the calcium trace and emits the two retrograde messages. Because POST's receptors
dopamine); when calcium falls, they drift back (short-term depression as a consequence). The are physical coincidence detectors, two of its three tag-coincidences (astro D-serine, and the bAP
spine also emits two retrograde messages from its own state — NO when it responded, an below) are detected *in the action*; only the organism's dopamine coincidence is left to evaluation.
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 **bAP is a second, vertical action-context.** The soma's back-propagating spike arrives, adds
arrives at the spine, adds depolarization and calcium, and supralinearly amplifies an existing depolarization and calcium, and supralinearly amplifies an existing candidate — the soma's
candidate — the soma's confirmation that it fired, one of the three coincidences the spine confirmation that it fired, detected in the action-moment (instantaneous coincidence).
requires.
**During NIGHT — the spine's ceilings are rewritten.** NIGHT raises **structure** (the AMPA **EVALUATION and PREPARATION share the quiet.** Evaluation reads the calcium trace and, on the
slot ceiling, spine volume) where a validated tag accumulated — with a coherence bonus when pre, dopamine coincidence, climbs to the tag. Preparation fills AMPA surface toward the slot ceiling
post, and astro all tagged the same synapse — and **budget capacity** where fuel interrupted a from accumulated calcium (short-term potentiation, no dopamine), refills budget toward next demand,
climbing calcium trajectory. Both draw the same finite pool, so they compete; unmaintained and lets traces settle. A fuel shortfall while calcium was climbing toward a tag is endurance
ceilings drift down. 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 // 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) // SUPPLY astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
// EMERGENCY shockwave_lockdown ← ASTRO // EMERGENCY shockwave_lockdown ← ASTRO
// NOTE POST endurance is own-state only (own Ca climbing); no arrived feedback term. // 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: DAY | bAP: // ACTION (vertical): soma's spike confirms
// ADJUST (AMPA drive from arrived glutamate) 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) 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 // SOURCE 1 AMPA
AMPA_current = a × AMPA_surface; Vm += AMPA_current; post_budget -= AMPA_cost
// TRACE (Ca deposited by AMPA)
post_fast_trace += AMPA_Ca·AMPA_current 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: // SOURCE 2 NMDA
if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0: post_fast_trace += NMDA_Ca(glutamate)·rise_speed(); post_budget -= NMDA_cost // (coincidence #1,2 here)
post_fast_trace += NMDA_Ca(glutamate)·rise_speed(); post_budget -= NMDA_cost retro_NO += NO_emit(post_fast_trace); post_budget -= NO_synth_cost // EMIT + "responsive target"
// 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: if Vm > eCB_thr:
retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost // EMIT − brake
post_fast_trace *= decay(ms) // ── EVALUATION (local): climb toward the tag; dopamine is the integrable coincidence (#3) ──
// BEHAVE (STP fill slots from private reserve ; else STD drift = consequence) 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_fast_trace > Ca_STP:
if post_budget < traffic_cost: if post_budget < traffic_cost: // FUEL shortfall → endurance
// FUEL shortfall → endurance (own Ca was climbing toward a tag)
if post_fast_trace > traj_thr and post_fast_trace_rising: if post_fast_trace > traj_thr and post_fast_trace_rising:
post_endurance_need += post_fast_trace post_endurance_need += post_fast_trace
else if AMPA_surface < post_structure.slot_ceiling: else if AMPA_surface < post_structure.slot_ceiling:
AMPA_surface += Ca_insert(post_fast_trace); post_budget -= traffic_cost 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: else:
AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = consequence AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = un-honored decay
// 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)) post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
// DECAY post_fast_trace *= decay(ms) // FAST
// FAST (ms–s) — post_fast_trace already decayed above (intra-step, pre-tagging) post_possible_tag *= decay(min); post_endurance_need *= decay(min) // MEDIUM
// MEDIUM (s–min) post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals
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: NIGHT | cycle: // leaf of DAY chain, but emits inward/upward by NIGHT
// 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 // RECEIVE batch arrived from DEND (material) + SOMA (energy) this cycle
post_material += transit(post_material_ship, τ_transport_spine) post_material += transit(post_material_ship, τ_transport_spine)
post_energy += transit(post_energy_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; // NOTE DEND endurance fires only on FUEL-limited propagation, not structural attenuation;
// own-state proxy (strong branch activity); no arrived feedback term. // 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()) // ADJUST (propagation strength from structure — inside propagate())
// BEHAVE (propagate bAP; distinguish fuel-limited vs structure-limited shortfall) // BEHAVE (propagate bAP; distinguish fuel-limited vs structure-limited shortfall)
if dend_budget < prop_cost: if dend_budget < prop_cost:
@@ -522,23 +537,20 @@ DAY | bAP:
bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry) bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry)
// reached < full here is structural attenuation (distance), NOT endurance // reached < full here is structural attenuation (distance), NOT endurance
dend_budget -= prop_cost × reached 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 dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost
// EMIT (integrated voltage to soma ; propagated bAP already reached spines) // EMIT (integrated voltage to soma ; propagated bAP already reached spines)
branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost
DAY | NOT_bAP: DAY | NOT_bAP: // EVALUATION (climb to tag) + PREPARATION (ship/refill/settle)
// TRACE (strength) // EVAL: strength climb
if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
if dopamine > dop_thr and dend_possible_tag > tag_thr: if dopamine > dop_thr and dend_possible_tag > tag_thr:
dend_tag += dopamine × dend_possible_tag dend_tag += dopamine × dend_possible_tag // token minted for NIGHT
// ADJUST (commit threshold lowered by attention) // PREP: attention lowers commit threshold; local translation; ship to spines; refill; settle
commit_threshold *= 1/(1 + ACh·ACh_gain) 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 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) // EMIT down to spines
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)) dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
// DECAY // DECAY
// FAST (ms–s) // 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); // NOTE SOMA endurance fires only on FUEL shortfall (budget < ap_cost);
// refractory / sub-threshold are timing limits, not endurance. Own-state proxy. // 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) // ADJUST (threshold from structure + adaptation + neuromodulators ; refractory gate)
threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh) threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh)
can_fire = soma_Na_inactivation < inactivation can_fire = soma_Na_inactivation < inactivation
// BEHAVE (fire if able) // ACTION (fire if able)
if branch_Vm > threshold and can_fire: if branch_Vm > threshold and can_fire:
if soma_budget < ap_cost: if soma_budget < ap_cost:
// FUEL shortfall → endurance (firing was approaching CREB) // FUEL shortfall → endurance (firing was approaching CREB)
if soma_fast_trace > traj_thr and soma_fast_trace_rising: if soma_fast_trace > traj_thr and soma_fast_trace_rising:
soma_endurance_need += soma_fast_trace soma_endurance_need += soma_fast_trace
exit exit
// EMIT (fired → AXON, DEND) fired = True; soma_budget -= ap_cost // EMIT fired → AXON, DEND
fired = True; soma_budget -= ap_cost // deposit the THREE traces from one AP: nuclear-Ca (→EVAL) + adaptation/inactivation (→PREP)
// TRACE (three traces from one AP — FAST nuclear-Ca, MEDIUM adaptation, refractory) soma_Na_inactivation += ap_amp // PREP seed: refractory (emergent)
soma_Na_inactivation += ap_amp // → refractory (emergent) soma_adaptation += ap_contrib // PREP seed: threshold rise
soma_adaptation += ap_contrib // → threshold rise soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // EVAL seed
soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // EVALUATION: strength climb toward the tag (cross-scope token for NIGHT)
// TRACE (strength)
if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
if dopamine > dop_thr and soma_possible_tag > tag_thr: if dopamine > dop_thr and soma_possible_tag > tag_thr:
soma_tag += dopamine × soma_possible_tag soma_tag += dopamine × soma_possible_tag
soma_budget -= creb_cost 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 // NEURON sums these
soma_emitted_activity += 1; soma_emitted_structure = soma_structure
DAY | NOT_AP: DAY | NOT_AP: // EVAL (align) + PREP (recover timing, ship, refill)
// RECEIVE (integrate latest branch input — signal) branch_Vm = integrate(DEND.branch_Vm, branches) // RECEIVE latest branch input
branch_Vm = integrate(DEND.branch_Vm, branches) // PREP seed: refractory alignment (suprathreshold input during refractory → tune next-spike timing)
// TRACE (bottom-up refractory alignment: suprathreshold input during refractory)
if branch_Vm > threshold and soma_Na_inactivation > inactivation: if branch_Vm > threshold and soma_Na_inactivation > inactivation:
soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_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_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost)
soma_ship_axon = ship(soma_budget, axon_demand, axon_ship_frac, ship_cost) soma_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) soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
recovery = base_recovery × (1 + soma_refractory_alignment) recovery = base_recovery × (1 + soma_refractory_alignment)
soma_Na_inactivation *= decay(τ_Na / recovery) soma_Na_inactivation *= decay(τ_Na / recovery)
// DECAY // 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 soma_fast_trace *= decay(τ_nuclear); soma_refractory_alignment *= decay(τ_align) // self-limiting
// MEDIUM (s–min) — adaptation + tagging evidence // MEDIUM (s–min) — adaptation + tagging evidence
soma_adaptation *= decay(τ_adapt) soma_adaptation *= decay(τ_adapt)
soma_possible_tag *= decay(s); soma_endurance_need *= decay(min) soma_possible_tag *= decay(s); soma_endurance_need *= decay(min)
// SLOW (hr) // SLOW (hr)
soma_tag *= decay(hr) soma_tag *= decay(hr); dopamine *= decay(ms)
// (signals)
dopamine *= decay(ms)
// (PERSISTENT: soma_structure, soma_budget_ceiling — no DAY decay; NIGHT only)
NIGHT | cycle: // ROOT (neuronal material) — produces each cycle NIGHT | cycle: // ROOT (neuronal material) — produces each cycle
// RECEIVE = PRODUCTION: synthesize this cycle's batch, gated by own tag, capped externally // 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) // NOTE AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace)
// is axonal STD (a consequence), not endurance. Own-state proxy. // 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) // ADJUST (reliability from structure − load-driven failure)
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance 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: if axon_budget < prop_cost:
reliability *= budget_factor reliability *= budget_factor
if axon_fast_trace > traj_thr: // FUEL-limited → endurance if axon_fast_trace > traj_thr: // FUEL-limited → endurance
axon_endurance_need += axon_fast_trace axon_endurance_need += axon_fast_trace
delivered = fired × reliability; axon_budget -= prop_cost × delivered delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT delivered → boutons
// EMIT (delivered APs reach boutons) axon_fast_trace += delivered; axon_fast_trace *= decay(s) // deposit fast trace
// TRACE
axon_fast_trace += delivered; axon_fast_trace *= decay(s)
DAY | NOT_AP: DAY | NOT_AP: // EVALUATION (climb to tag) + PREPARATION
// TRACE (strength) // EVAL: strength climb → token for NIGHT
if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
if dopamine > dop_thr and axon_possible_tag > tag_thr: if dopamine > dop_thr and axon_possible_tag > tag_thr:
axon_tag += dopamine × axon_possible_tag 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) 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]) axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
// DECAY // DECAY
// FAST (ms–s) // FAST (ms–s)
@@ -755,7 +762,6 @@ DAY | NOT_AP:
axon_possible_tag *= decay(s); axon_endurance_need *= decay(min) axon_possible_tag *= decay(s); axon_endurance_need *= decay(min)
// SLOW (hr) // SLOW (hr)
axon_tag *= decay(hr) axon_tag *= decay(hr)
// (PERSISTENT: axon_structure, axon_budget_ceiling — no DAY decay; NIGHT only)
NIGHT | cycle: // intermediate node (relays down to PRE) NIGHT | cycle: // intermediate node (relays down to PRE)
// RECEIVE batch arrived from SOMA this cycle // 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. // material/precursor-limited synthesis is a material limit, not endurance. Own-state proxy.
// EMERGENCY emits shockwave_lockdown on overload // 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 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 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: 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 + ε)) factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
// EMIT (demand-weighted lactate to all components)
for each i: for each i:
astro_lactate[i] = demand[i] × factor; astro_central_budget -= astro_lactate[i]·lactate_cost 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 glutamate[i] -= astro_structure[i].EAAT × glutamate[i]·Δt; astro_central_budget -= clearance·EAAT_cost
astro_Dserine[i] += astro_structure[i].Dserine_tonic·Δt astro_Dserine[i] += astro_structure[i].Dserine_tonic·Δt
if glutamate[i] > spillover: if glutamate[i] > spillover:
// TRACE astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s) // deposit fast 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 want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
got = min(want, astro_central_budget × Ds_frac) 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 // D-serine pulse → 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: if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
astro_endurance_need[i] += (want - got) astro_endurance_need[i] += (want - got) // FUEL-limited synthesis → endurance
// TRACE (strength) // EVAL: strength climb → token for NIGHT
if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i] 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: if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
astro_tag[i] += dopamine × astro_possible_tag[i] astro_tag[i] += dopamine × astro_possible_tag[i]
// DECAY // DECAY (settle)
// FAST (ms–s) — astro_fast_trace already decayed above (intra-step)
// MEDIUM (s–min) // MEDIUM (s–min)
astro_possible_tag[i] *= decay(s); astro_endurance_need[i] *= decay(min) astro_possible_tag[i] *= decay(s); astro_endurance_need[i] *= decay(min)
// SLOW (hr) // SLOW (hr)
astro_tag[i] *= decay(hr) astro_tag[i] *= decay(hr)
// (PERSISTENT: astro_structure, astro_budget_ceiling — no DAY decay; NIGHT only)
// EMERGENCY // EMERGENCY
if astro_fast_trace[i] > overload: emit(shockwave_lockdown) 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 ## One-view summary
``` ```
SEVEN-GROUP GRAMMAR · EIGHT ACTORS · ONE FATIGUE LOOP THE THREE-PHASE RING · EIGHT ACTORS · ONE FATIGUE LOOP
RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY 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 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 fast_trace + dopamine → tag (strength) ; FUEL shortfall + interrupted success → endurance_need
emit fatigue upward as metabolic debt accumulates currency: information ; token minted by evaluation: the TAG (for NIGHT) ; emit fatigue upward
NIGHT (per-component state: own_activity low AND sleep_pressure high) restructure, capacity descends NIGHT (per-component state: own_activity low AND sleep_pressure high) ring turned INWARD against the economy
phased: early DOWNSCALE (self-reset occupancy + self-renorm structure on broadcast signals), ACTION=coherence check · EVALUATION=draw & commit (only if coherent) · PREPARATION=make room
late COMMIT (tag→structure, need→budget_ceiling, spend tag-as-fuel) — only with rest_permission 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 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. LOOP no driver/scheduler. HYPOTHALAMUS runs CONTINUOUS: integrates fatigue → emits sleep_pressure.
activity→fatigue→pressure→quiet grants restructuring→discharge→pressure falls→wake. DAY/NIGHT 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 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, (holds an aggregate it can't see, opens a window it can't open). Acts locally, consolidates
consolidates hierarchically. Material recycles; ENERGY does not (the arrow of time). hierarchically. Material recycles; ENERGY does not (the arrow of time).
```
FLOWS every flow has a timescale; shipment is transit-delayed (distal fills over cycles) 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
``` ```