1283 lines
86 KiB
Markdown
1283 lines
86 KiB
Markdown
# Tripartite Synapse — Pseudocode v17
|
||
|
||
> Companion: `tripartite_synapse_v17_biology.md` · principle: `logic_principles_v5`.
|
||
> Model — every component runs the SAME THREE CATEGORIES in two directions:
|
||
> (ACTION ⇄ RECOVERY) × many, then PREPARATION — outward by DAY (world), inward by NIGHT (economy).
|
||
> ACTION = the defining deed (day: release/fire/respond/propagate ; night: build ⇄ release structure).
|
||
> RECOVERY = fast alter-ego, restore the ability to act (day: refill ; night: import + free material).
|
||
> PREPARATION = shape what's next, facing this scope AND the other; night PREPARATION REPLAYS the day
|
||
> ACTION (same machinery, no dopamine) to measure PARTICIPATION. "Evaluation" retired — a trace is a
|
||
> provision, not a judgment. Each category spans FAST · MEDIUM · SLOW.
|
||
> (1) EIGHT actors: LOCAL components (soma·pre·post·dend·axon·astrosynapse) · CELL actors (neuron over
|
||
> soma/pre/post/dend/axon ; astrocyte over astrosynapses) · SYSTEM actor (hypothalamus).
|
||
> (2) DAY/NIGHT is a TOP-DOWN context BROADCAST by the hypothalamus, which integrates FATIGUE
|
||
> (astrocyte-reported metabolic debt) ⇄ REST and emits the scope. Earned, not clocked; not local.
|
||
> (3) NIGHT ACTION is BUILD ⇄ RELEASE, participation-arbitrated: build (tag stands + participation ≥
|
||
> MEDIUM; tag funds a slice, persists across cycles) vs release (participation LOW; frees material;
|
||
> tag untouched). Build/release compete WITHIN a component; material competes BETWEEN components.
|
||
> Two forgettings: structural pruning (low participation) · intention decay (tag unspent).
|
||
> (4) DAY collaborates (non-rival information; each acts so the next can act); NIGHT competes (rival
|
||
> conserved material) — but the competition is ADJUDICATED by collaborative replay (participation).
|
||
> (5) ASTROCYTE is the metabolic sensor (drives the switch, permits waking) and DAY primer (alpha-driven
|
||
> localized neuromodulation). Higher actors INTEGRATE emissions and BROADCAST — never reach in.
|
||
> (6) governing rule: NO actor authorizes its own restructuring — each is PUT IN POSITION by the actor
|
||
> above (holds an aggregate it cannot see, opens a window it cannot open). Act locally, consolidate
|
||
> hierarchically. Material recycles; ENERGY does not (the arrow of time).
|
||
> PENDING: ASTROSYNAPSE night still in the earlier NON_REM/REM form (its own pass — continuous case).
|
||
|
||
---
|
||
|
||
## The three categories and the ladder
|
||
|
||
Every component runs the SAME three categories — ACTION, RECOVERY, PREPARATION — at DAY and at
|
||
NIGHT, chunked under `// ===== =====` separators in each block below. The rhythm is
|
||
(ACTION ⇄ RECOVERY) × many, then PREPARATION, then again. A category names a KIND of work, not a
|
||
timescale: each spans FAST · MEDIUM · SLOW. Evidence ascends the timescale ladder by day (fast
|
||
trace → occupancy → tag); capacity descends it by night (tag → structure). For the full logic of
|
||
the ring, the ladder, and the two turnings, see logic_principles.
|
||
|
||
DAY AND NIGHT ARE A TOP-DOWN CONTEXT, BROADCAST BY THE HYPOTHALAMUS. The alternation is NOT a local
|
||
per-component decision — it is a single context signal emitted from above and received by every
|
||
component, the way the neuron's renormalization or the astrocyte's priming is broadcast. The
|
||
hypothalamus integrates two competing drives — FATIGUE (metabolic debt, reported chiefly by the
|
||
ASTROCYTE, which runs the energy economy) and REST (restoration accumulated during quiet) — and
|
||
emits the DAY/NIGHT context according to which dominates:
|
||
|
||
```
|
||
SCOPE CONTEXT (computed by HYPOTHALAMUS, broadcast to all; CONTINUOUS — the one actor that never sleeps):
|
||
fatigue ← integrate metabolic debt + unspent demand emitted by components (astrocyte-reported)
|
||
rest ← integrate restoration accumulated while quiet
|
||
emit DAY while rest dominates fatigue (behave outward)
|
||
emit NIGHT while fatigue dominates rest (restructure inward)
|
||
The context is EARNED, not clocked: it is the integrated outcome of the fatigue⇄rest competition,
|
||
not a wall-clock schedule. Components do not each decide when to cross; they receive the context.
|
||
```
|
||
|
||
Why top-down and not local: behaving and restructuring compete for the same substrate (a component
|
||
cannot restructure while busy), so the crossing must be coordinated across the coupled components —
|
||
a pattern can only replay at night if its whole loop is in NIGHT together. A per-component local
|
||
crossing could not guarantee that coherence; a broadcast context does. The switch is top-down; what
|
||
each component DOES within the context (behave / replay / build) remains fully local.
|
||
|
||
THE FATIGUE⇄REST LOOP. Activity generates fatigue (the astrocyte accrues and reports metabolic
|
||
debt); rising fatigue tips the hypothalamus to broadcast NIGHT; restructuring discharges debt and
|
||
accrues rest; rising rest tips it back to DAY. DAY and NIGHT are the two phases of one homeostatic
|
||
competition the hypothalamus integrates and broadcasts — the astrocyte is the metabolic sensor that
|
||
feeds it, and (see ASTROCYTE) the discharge of debt during night is what permits waking.
|
||
|
||
```
|
||
every component → emits fatigue (metabolic debt, unspent demand) ↑
|
||
ASTROCYTE → integrates territory energy debt → reports fatigue ↑ (the metabolic sensor)
|
||
HYPOTHALAMUS → integrates fatigue ⇄ rest → BROADCASTS DAY/NIGHT ↓ (CONTINUOUS)
|
||
every component → receives the DAY/NIGHT context (top-down)
|
||
```
|
||
|
||
ACTORS ARE PEERS AT EVERY SCALE; EACH IS PUT IN POSITION BY THE ONE ABOVE. No actor authorizes
|
||
its own restructuring. Each holds an aggregate its constituents cannot see and opens a window
|
||
they cannot open, then BROADCASTS — it never reaches into a constituent's interior.
|
||
|
||
```
|
||
HYPOTHALAMUS integrates fatigue ⇄ rest → broadcasts DAY/NIGHT context (system, CONTINUOUS)
|
||
↓ signal
|
||
NEURON integrates its components' activity/weight → broadcasts (cell actor)
|
||
ASTROCYTE reports fatigue upward ; primes (day) + reallocates (night) (cell actor)
|
||
↓ signal (NEURON over soma/pre/post/dend/axon ; ASTROCYTE over astrosynapses)
|
||
COMPONENTS soma · pre · post · dend · axon · astrosynapse — each restructures ITSELF
|
||
within the broadcast DAY/NIGHT context
|
||
[ ASSEMBLY / NETWORK ] replay is INTERNALLY generated (spontaneous firing, below); the external
|
||
replay_reweight only BIASES which internal patterns are favored (cross-neuron
|
||
coordination), arriving like dopamine/glucose — it is not the replay itself
|
||
```
|
||
|
||
The two cell actors are structurally identical — same integrate-and-broadcast role, different
|
||
constituents and conserved quantity: NEURON conserves activity/weight, ASTROCYTE conserves
|
||
territory demand/load. Both have their own DAY (integrate, allocate in the gaps) and NIGHT
|
||
(broadcast the restructuring window). The HYPOTHALAMUS alone has no night: it runs CONTINUOUS,
|
||
always integrating fatigue and emitting sleep-pressure, spanning every other actor's day and
|
||
night — the clock that never sleeps.
|
||
|
||
EVERY SCOPE RUNS THE SAME THREE CATEGORIES: (ACTION ⇄ RECOVERY) × many, then PREPARATION.
|
||
ACTION the scope's defining deed (DAY: release/fire/respond/propagate — the cleft exchange;
|
||
NIGHT: change structure — the irreversible build).
|
||
RECOVERY the fast alter-ego of the action — restore the ability to act again (DAY: vesicle
|
||
refill, refractory de-inactivation, Ca clearance; NIGHT: import material/energy, prime).
|
||
PREPARATION shape what comes next — faces BOTH the next same-scope action AND the other scope.
|
||
This is where what earlier drafts called "evaluation" lives: depositing a trace is not
|
||
judging, it is provisioning. DAY-preparation stocks the tag (for NIGHT) and sets
|
||
occupancy/thresholds (for the next action). NIGHT-preparation REPLAYS the action —
|
||
re-runs the SAME machinery as DAY ACTION (same capacity/vesicle checks, same endurance
|
||
deposit into the SAME trace), but with NO dopamine and the release as a PROBE, read as
|
||
participation, not transmitted.
|
||
|
||
NIGHT IS A SEQUENCE OF REPLAY CYCLES (dual of DAY). DAY loops until energy/material is exhausted;
|
||
NIGHT loops until the tag is exhausted. The rotation across scopes: the SAME physical release/fire
|
||
is ACTION by DAY (the deed) and PREPARATION by NIGHT (the probe that replays it); the structural
|
||
change is only MARKED by day (the inert tag) and ENACTED by night (its action). SOMA is the ignition
|
||
point: its night-PREPARATION replay-fire propagates a replay_AP through the DAY PATHWAYS
|
||
(soma→axon→pre→glutamate→post→dend→soma), self-igniting the tagged pattern.
|
||
|
||
COHERENCE IS MECHANICAL, not a checked flag: a pattern re-evokes only where EVERY link in its
|
||
recurrent loop is primed (each component's own tag lowered its own threshold in RECOVERY); one
|
||
un-primed link breaks the loop at the gap, so only patterns significant all the way around carry.
|
||
The assembly that replays is NOT an actor — it is the coincidence of many components' own lowered
|
||
thresholds propagating through recurrent coupling.
|
||
|
||
WHAT PERSISTS MUST HAVE EARNED PERSISTENCE. Night-RECOVERY drives occupancy (VGCC_active,
|
||
AMPA_surface, possible_tag) toward baseline; night-ACTION's homeostatic lowering trims all
|
||
structure; only what is rebuilt from a still-standing tag with confirmed participation carries
|
||
forward. NIGHT ends when the tag is exhausted (well-rested — every significant pattern replayed and
|
||
its structure rebuilt) OR energy is spent (overloaded — unspent tags carry to the next night).
|
||
|
||
---
|
||
|
||
## Conventions
|
||
|
||
```
|
||
SCOPE = {DAY, NIGHT} CONTEXT = {AP, NOT_AP, NOT_SPIKE_TRAIN, bAP, NOT_bAP, CONTINUOUS}
|
||
|
||
THE THREE CATEGORIES (see logic_principles "The Ring"): (ACTION ⇄ RECOVERY) × many, then PREPARATION
|
||
ACTION the component's defining deed; deposits the fast trace. ALWAYS LOCAL to the acting
|
||
component (cannot be done on another's behalf — that would be signalling, not acting).
|
||
RECOVERY the fast alter-ego of action — restore the ability to act again (refill, de-inactivate,
|
||
clear). Day: restock private pools. Night: import material/energy, free trimmed material.
|
||
PREPARATION shape what comes next; faces BOTH the next same-scope action AND the other scope.
|
||
Stocks the tag (for NIGHT) and tunes occupancy/thresholds (for the next action). What
|
||
earlier drafts called "evaluation" is here: depositing a trace is provisioning, not
|
||
judging. RECOVERY and PREPARATION may be LOCAL or CONTEXTUAL (a neighbor supplies them);
|
||
ACTION is always local. A near-pure-action component (e.g. a channel) is ACTION-only.
|
||
A category names a KIND of work, not a timescale: each spans FAST · MEDIUM · SLOW.
|
||
|
||
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 category annotation says which 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 → RECOVERY (restock) (in-train gaps AND quiet)
|
||
NOT_SPIKE_TRAIN no spike AND no train ⊂ NOT_AP → adds PREPARATION (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 bAP / NOT_bAP, or continuous.)
|
||
|
||
VARIABLE TIERS (timescale = meaning; see logic_principles "The Timescale Ladder")
|
||
FAST (ms–s) immediate response fast_trace
|
||
MEDIUM (s–min) occupancy + evidence possible_tag · endurance_need · VGCC_active · AMPA_surface · RRP
|
||
SLOW (hr) consolidation bridge tag
|
||
─────────────────────────────────────────────────────────────────────────────
|
||
PERSISTENT (NIGHT) capacity (the ceilings) structure · budget_ceiling
|
||
energy (not recoverable) · material (recoverable)
|
||
|
||
THE DAY STRENGTH CLIMB (same three-tier averaging in every component):
|
||
1. each ACTION leaves a fast_trace (FAST).
|
||
2. the running AVERAGE of fast_traces over SECONDS fills occupancy → short-term strength
|
||
(VGCC_active in PRE, AMPA_surface in POST, …); a LOW average lets occupancy drift back (STD).
|
||
3. the AVERAGE-OF-THE-AVERAGE over MINUTES (possible_tag), in coincidence with dopamine, raises
|
||
the TAG (SLOW) — the token passed to NIGHT. At night the tag is spent to modify structure
|
||
(the persistent version of the same strength the occupancy held transiently).
|
||
So occupancy is the fast/medium memory of participation; the tag is its dopamine-validated,
|
||
night-consolidatable distillate. Same climb, same three tiers, in all six components.
|
||
|
||
DAY budget · fast_trace · possible_tag · endurance_need
|
||
BRIDGE tag (POST: CANDIDATE→STABLE)
|
||
NIGHT energy (not recoverable) · material (recoverable) · structure · budget_ceiling
|
||
|
||
LOCALITY only local state + arrived signals; no component reads another's internal state.
|
||
|
||
CLEFT MESSAGE CHANNELS SHIPMENT CHANNELS (transit-delayed)
|
||
glutamate PRE → POST, ASTRO soma_ship_dend SOMA→DEND
|
||
astro_Dserine ASTRO → POST soma_ship_axon SOMA→AXON
|
||
retro_NO POST → PRE (+) dend_ship_post DEND→POST
|
||
retro_eCB POST → PRE (−) axon_ship_pre AXON→PRE
|
||
```
|
||
|
||
---
|
||
|
||
## Primitives (return the increment; caller applies it)
|
||
|
||
```
|
||
sat(x, K) = x / (K + x)
|
||
|
||
fill(pool, ceiling, rate, cost, budget) -> amount: // PRIVATE reserve, rate-limited (implicit τ)
|
||
amount = min(rate, ceiling - pool)·Δt; budget -= amount·cost; return amount
|
||
|
||
refill(c from supply S) -> amount: // CONTESTED supply, gap-bounded
|
||
demand = c.budget_ceiling - c.budget
|
||
factor = min(1, S / (Σ demand over components on S + ε)); S -= demand·factor
|
||
return demand·factor
|
||
|
||
ship(from_budget, demand_sig, frac, cost) -> amount: // emit into transit (not to target directly)
|
||
amount = min(from_budget·frac, demand_sig); from_budget -= amount·(1+ship_cost); return amount
|
||
|
||
transit(channel, τ_transport) -> arrival: // delivers in-transit cargo over τ
|
||
arrival = channel·(Δt/τ_transport); channel -= arrival; return arrival
|
||
```
|
||
|
||
---
|
||
|
||
## SHARED parameters
|
||
|
||
```
|
||
dopamine NE ACh // organism broadcasts (external)
|
||
replay_reweight[·] // assembly/network replay re-weighting (external, NIGHT)
|
||
glucose geometry // physical (external)
|
||
scope_context ∈ {DAY, NIGHT} // BROADCAST by HYPOTHALAMUS (top-down; the switch, read by all)
|
||
fatigue_gain rest_gain // hypothalamus fatigue⇄rest integration weights
|
||
elig dop_thr tag_thr tag_expiry // strength gates (universal)
|
||
traj_thr endur_thr // endurance gates (universal)
|
||
ship_cost // transport overhead (all shipments)
|
||
{dend,axon,pre,post}_ship_frac // DAY budget-shipment fractions
|
||
τ_transport_{dend,axon,spine,bouton} // shipment transit times (distance-dependent)
|
||
ε
|
||
```
|
||
|
||
## NIGHT parameters (consolidation only)
|
||
|
||
```
|
||
slot_batch cap_batch f_cap // per-CYCLE commit/allocation sizes / endurance fraction
|
||
night_energy_ceiling // total energy a single night can spend (supply bound)
|
||
Δt_cycle // duration of one NIGHT cycle (recovery→preparation→action)
|
||
maint_frac cap_frac // maintenance allocation
|
||
decay_rate capacity_decay_rate recycle // passive ceiling decay + material recovery
|
||
homeostatic_ceiling assembly_cost biogenesis_cost maint_cost
|
||
f_dend f_axon f_spine f_bouton // per-cycle material/energy ship fractions (down the chain)
|
||
downscale_factor // per-cycle multiplicative occupancy reset (<1), night RECOVERY
|
||
neuron_weight_ceiling // renormalization target (broadcast constraint)
|
||
// ── NIGHT (RECOVERY = import/prime · PREPARATION = replay probe · ACTION = restructure) ──
|
||
spont_thr_base thr_gain // spontaneous threshold = base − gain×own_tag (night RECOVERY prime)
|
||
prime_thr prime_gain // tag threshold to raise VGCC, and the gain (night RECOVERY)
|
||
release_rate homeostatic_floor // night RELEASE: shed rate + floor structure never pruned below
|
||
intrinsic_fluctuation() // intrinsic sub-threshold noise (the night's ignition source)
|
||
mini_flux mini_Ca() // spontaneous mini release size + its Ca deposit (REM probe)
|
||
level(·) → {LOW, MEDIUM, HIGH} // reads fast_trace as circuit participation (REM, no dopamine)
|
||
replay_AP // propagated re-evocation spike (soma → axon/dend, self-igniting)
|
||
```
|
||
|
||
---
|
||
---
|
||
# LOCAL COMPONENTS
|
||
> Each behaves within the broadcast DAY context and restructures within the broadcast NIGHT context
|
||
> (see Conventions: the transition rule). `DAY | …` / `NIGHT | …` label local states, not a clock.
|
||
---
|
||
|
||
## PRE
|
||
|
||
The presynaptic bouton releases neurotransmitter and gathers evidence about whether that
|
||
release was worth strengthening and worth sustaining. Like every component it runs the three
|
||
categories — (ACTION ⇄ RECOVERY) × many, then PREPARATION — in two directions: outward by DAY
|
||
(against the cleft), inward by NIGHT (against the economy).
|
||
|
||
**DAY · ACTION (the AP) — the bouton releases.** The amount released depends on residual
|
||
**calcium** (the fast trace, set by this spike), the current **VGCC coupling occupancy** (how
|
||
tightly channels are coupled right now, bounded by structure), the two **retrograde messages**
|
||
(`retro_eCB` brakes, `retro_NO` confirms release reached a responsive target), and the
|
||
availability of **fuel and vesicles**. The action deposits the fast trace the rest of the turn
|
||
reads. Two shortfalls read differently: a fuel shortfall on a succeeding release is *endurance*
|
||
evidence; an empty pool with fuel to spare is ordinary short-term depression.
|
||
|
||
**DAY · RECOVERY (between spikes) — restock to release again.** In the inter-spike gaps the bouton
|
||
refills its vesicle pool and lets the fast trace relax — the fast alter-ego of release, riding the
|
||
train, and the release-vs-refill race is what sets short-term depression.
|
||
|
||
**DAY · PREPARATION (train passed) — shape the next release AND the night.** Reading the accumulated
|
||
fast trace, the bouton climbs eligibility (`possible_tag`) and, on the dopamine coincidence, the
|
||
`tag` — the token stocked for the night (this is provisioning, not judging). It also latches the
|
||
retrograde messages, tightens its VGCC coupling from eligibility (reversible short-term potentiation,
|
||
no dopamine, bounded by structure), and refills budget toward the next demand.
|
||
|
||
**NIGHT — the same three categories as DAY, at a slower timescale, turned inward.** Every scope
|
||
runs the same shape: an alternation of ACTION ⇄ RECOVERY (many times), then PREPARATION. By DAY
|
||
that is (release ⇄ vesicle-refill) × many spikes, then preparation (climb the tag, set VGCC,
|
||
refill, thresholds). By NIGHT it is (restructure ⇄ material-import) × many cycles, then preparation
|
||
(the probe-release that measures participation to shape the next restructuring). ACTION is the
|
||
scope's defining deed; RECOVERY is its fast alter-ego, restoring the capacity to act again;
|
||
PREPARATION follows the alternation to shape what comes next — and faces both the next same-scope
|
||
action and the OTHER scope (which is where what earlier drafts called "evaluation" lives: stocking
|
||
the tag is preparing for night, not judging the present). Note the rotation: NT release is ACTION
|
||
by day and PREPARATION by night; the structural change is only marked by day (the tag) and enacted
|
||
by night. The bouton is not a sink — by night it emits inward and upward.
|
||
|
||
```
|
||
// PARAMETERS K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake
|
||
// stp_thr · coupling_gain · coupling_drift · VGCC_baseline
|
||
// INTERFACE
|
||
// EMIT glutamate → POST, ASTRO
|
||
// RECEIVE retro_NO, retro_eCB ← POST (signals latched in PREPARATION; pools refill in RECOVERY/PREPARATION)
|
||
// READ glutamate (own cleft, autobrake) ; dopamine (gates tag)
|
||
// OWN pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling
|
||
// VGCC_active (occupancy: current coupling, filled toward VGCC_coupling ceiling)
|
||
// SUPPLY astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT)
|
||
// EMERGENCY shockwave_lockdown ← ASTRO
|
||
//
|
||
// TRACE CREATION MODES (every trace: trace += input·Δt − trace·(Δt/τ_decay))
|
||
// impulse input = quantum·δ(event) — a point event; no rise time, τ = decay only (FAST)
|
||
// accumulate input = rate(condition)·Δt — ramps while a condition holds; τ = rise AND decay (MEDIUM/SLOW)
|
||
//
|
||
// THE THREE CATEGORIES (same at DAY and NIGHT; here at the DAY timescale, subject = the cleft):
|
||
// ACTION release NT (the defining deed) — context AP
|
||
// RECOVERY restore the ability to release again: vesicle refill — the fast alter-ego of AP,
|
||
// runs in the inter-spike gaps (NOT_AP), riding the train, setting STD depth
|
||
// PREPARATION shape what comes next — climb the tag (for NIGHT), set VGCC, refill budget,
|
||
// thresholds, decay — runs once the train subsides (NOT_SPIKE_TRAIN ⊂ NOT_AP)
|
||
// Pattern per scope: (ACTION ⇄ RECOVERY) × many spikes, then PREPARATION.
|
||
// Contexts nest (NOT_SPIKE_TRAIN ⊂ NOT_AP); each behavior in exactly ONE block.
|
||
|
||
// ===== ACTION =====
|
||
DAY | AP: // release into the cleft (the defining deed)
|
||
// deposit the fast trace THIS action leaves (FAST · impulse)
|
||
pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike)
|
||
drive = sat(pre_fast_trace × VGCC_active, K_release) × (1 - retro_eCB_local)
|
||
if pre_budget < release_cost: // FUEL shortfall → endurance evidence
|
||
suppress(NT_flux)
|
||
if pre_fast_trace > traj_thr: // MEDIUM · accumulate (a PREPARATION deposit)
|
||
pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)·Δt
|
||
exit
|
||
if RRP == 0: suppress(NT_flux); exit // OCCUPANCY shortfall → STD (not endurance)
|
||
NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost
|
||
glutamate += NT_flux·Δt // EMIT glutamate → POST, ASTRO
|
||
if glutamate > spillover: drive *= brake // own-cleft autobrake
|
||
|
||
// ===== RECOVERY (alter-ego of ACTION; runs in the inter-spike gaps, rides the train) =====
|
||
DAY | NOT_AP: // restore the ability to release again
|
||
RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
|
||
pre_fast_trace *= decay(100ms) // FAST — the trace relaxes between spikes
|
||
// (partial refill vs release is the STD race — this is recovery keeping pace with action)
|
||
|
||
// ===== PREPARATION (shape what comes next; faces the next train AND the NIGHT) =====
|
||
DAY | NOT_SPIKE_TRAIN: // sustained quiet; ⊂ NOT_AP
|
||
retro_NO_local = retro_NO; retro_eCB_local = retro_eCB // latch arrived signals
|
||
// for NIGHT: climb the tag (stock the token the night-action will spend) (MEDIUM→SLOW accumulate)
|
||
if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt
|
||
if dopamine > dop_thr and pre_possible_tag > tag_thr:
|
||
pre_tag += dopamine × pre_possible_tag·Δt
|
||
// for the NEXT TRAIN: 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
|
||
// for the NEXT TRAIN: full budget refill toward next demand (forward-facing)
|
||
pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
|
||
// settle the medium/slow stocks (fast-trace decay already ran in RECOVERY; not repeated)
|
||
pre_possible_tag *= decay(s); pre_endurance_need *= decay(min) // MEDIUM
|
||
pre_tag *= decay(hr) // SLOW
|
||
dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s)
|
||
|
||
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. The rhythm is
|
||
// (ACTION ⇄ RECOVERY) × many, then PREPARATION, then again — like DAY's (release ⇄ refill) × many
|
||
// → prep. Two competitions at two loci: WITHIN action, build vs release contend over the
|
||
// component's own structure (participation is the arbiter); WITHIN recovery, THIS component vs
|
||
// OTHERS contend for shared material/energy. A category spans all THREE timescales (fast/med/slow).
|
||
// ACTION change structure — BUILD (participation high + tag stands; tag funds it, a slice
|
||
// per cycle so the tag persists across cycles) ⇄ RELEASE (participation LOW; frees
|
||
// material; tag untouched). Both always possible; participation selects direction.
|
||
// RECOVERY restore the ability to build: acquire material/energy from the shared pool AND
|
||
// receive freed material — in CONTENTION with other components.
|
||
// PREPARATION replay the release as a probe (SAME machinery as day ACTION) to measure
|
||
// participation; itself multi-timescale: probe⇄restock (fast), VGCC/threshold
|
||
// prime from the tag (medium), tag settle (slow).
|
||
// Two independent forgettings: structural pruning ← low participation (release); intention decay
|
||
// ← tag decaying unspent. Loops until the tag is spent.
|
||
|
||
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
|
||
NIGHT | build or release: // the night's defining deed (both directions)
|
||
// BUILD (participation confirmed AND tag stands): spend a SLICE of the tag — persists next cycle
|
||
if rest_permission and pre_tag > tag_expiry and pre_participation ≥ MEDIUM:
|
||
Δ = min(slot_batch, pre_material, pre_energy·f_cap, pre_tag) × pre_participation
|
||
pre_structure += Δ; pre_material -= Δ; pre_energy -= Δ·assembly_cost
|
||
pre_tag -= Δ // SLICE only — tag survives for successive cycles
|
||
if pre_endurance_need > endur_thr: // endurance capacity builds on the same act
|
||
Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap)
|
||
pre_budget_ceiling += Δ'; pre_material -= Δ'; pre_energy -= Δ'·biogenesis_cost
|
||
pre_endurance_need -= Δ'
|
||
// RELEASE (participation LOW): shed structure, FREE material back to the shared pool; tag untouched
|
||
else if pre_participation == LOW:
|
||
shed = release_rate × max(pre_structure - homeostatic_floor, 0)
|
||
pre_structure -= shed; pre_freed_material += shed·recycle // freed → contested pool (RECOVERY)
|
||
pre_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
// else (tag present but participation not confirmed this cycle): HOLD — tag waits for its pattern
|
||
|
||
// ===== RECOVERY (acquire material/energy in CONTENTION with other components; receive freed material) =====
|
||
NIGHT | import + free: // alter-ego of the night ACTION (inter-component)
|
||
pre_material += transit(pre_material_ship, τ_transport_bouton) // import build material (contested pool)
|
||
pre_energy += transit(pre_energy_ship, τ_transport_bouton) // import build energy (contested pool)
|
||
pre_material += pre_freed_material; pre_freed_material = 0 // reclaim what release freed
|
||
if renorm_signal arrived: // descended constraint → free structure
|
||
freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal
|
||
emit(freed → recycled material pool) // freed material re-enters contention
|
||
pre_material += pre_ceiling_shrinkage·recycle // energy NOT recovered
|
||
pre_maintain: pre_structure += min(pre_maint, maint_cost) // hold up what is used
|
||
|
||
// ===== PREPARATION (REPLAY the release as a probe — SAME machinery as day ACTION; multi-timescale) =====
|
||
// Replay re-runs the release exactly as by day: same drive, same capacity + vesicle checks, same
|
||
// endurance deposit into the SAME pre_endurance_need trace. Differs from DAY ACTION: no dopamine,
|
||
// and the glutamate is a PROBE — drives the pattern onward and its own trace is read as participation.
|
||
NIGHT | replay + measure + prime: // release here is PREPARATION, not the deed
|
||
// FAST: probe-release ⇄ restock (the replay, run repeatedly to measure participation)
|
||
spont = intrinsic_fluctuation()
|
||
if spont > pre_spont_thr or arrived_replay_AP: // ignite: spontaneous, or recruited by the pattern
|
||
pre_fast_trace += mini_Ca(VGCC_active)·δ(replay) // SAME trace deposit as DAY ACTION
|
||
drive = sat(pre_fast_trace × VGCC_active, K_release)
|
||
if pre_budget < release_cost: // SAME capacity check → endurance evidence
|
||
suppress(replay_flux)
|
||
if pre_fast_trace > traj_thr:
|
||
pre_endurance_need += pre_fast_trace·Δt // SAME trace, fed by replay too
|
||
else if RRP > 0: // SAME vesicle check
|
||
replay_flux = RRP × drive; RRP -= replay_flux·Δt; pre_budget -= replay_flux·fusion_cost
|
||
glutamate += replay_flux·Δt // real glutamate → POST: carries the pattern onward
|
||
RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget) // restock
|
||
pre_participation = level(pre_fast_trace) // read the replayed response as participation
|
||
// MEDIUM: prime excitability + VGCC from the standing tag (readies the next probe AND next build)
|
||
pre_spont_thr = spont_thr_base − thr_gain × pre_tag
|
||
if pre_tag > prime_thr:
|
||
VGCC_active = min(VGCC_active + prime_gain × pre_tag, pre_structure.VGCC_coupling)
|
||
pre_possible_tag *= occupancy_downscale // apply descended constraint to self
|
||
// SLOW: settle
|
||
pre_fast_trace *= decay(100ms); pre_tag *= decay(hr); pre_endurance_need *= decay(slow)
|
||
emit(pre_fatigue, pre_demand → upward) // not a sink: emits inward/upward by night
|
||
```
|
||
|
||
---
|
||
|
||
## POST
|
||
|
||
The postsynaptic spine is the synapse's primary memory locus: it detects coincident input,
|
||
runs the calcium dynamics that decide potentiation versus depression, and requires the most
|
||
validation (three coincidences) before committing.
|
||
|
||
**POST's ACTION is the synaptic event (context NOT_bAP).** Integration is graded and ongoing
|
||
rather than spike-punctate, so POST's action-context is "glutamate present, no bAP": three calcium
|
||
sources feed the fast trace — AMPA current (small Ca, begins ejecting the NMDA Mg block) and NMDA
|
||
(large Ca, only on the local coincidence of depolarization + astrocyte D-serine + glutamate). The
|
||
action deposits the calcium trace and emits the two retrograde messages. Because POST's receptors
|
||
are physical coincidence detectors, two of its three tag-coincidences (astro D-serine, and the bAP
|
||
below) are detected *in the action*; only the organism's dopamine coincidence is left to evaluation.
|
||
|
||
**bAP is a second, vertical action-context.** The soma's back-propagating spike arrives, adds
|
||
depolarization and calcium, and supralinearly amplifies an existing candidate — the soma's
|
||
confirmation that it fired, detected in the action-moment (instantaneous coincidence).
|
||
|
||
**EVALUATION FOLDS INTO PREPARATION.** POST runs the same three categories as every component.
|
||
ACTION is the synaptic response (integrate glutamate, detect the instantaneous coincidences, emit
|
||
the retrogrades). RECOVERY restores the ability to respond again — calcium extrusion and NMDA
|
||
Mg-block re-establishment, the fast alter-ego of the response. PREPARATION shapes what comes next:
|
||
fills AMPA surface toward the slot ceiling from accumulated calcium (short-term potentiation, no
|
||
dopamine — for the next response), climbs the tag on the dopamine coincidence (for the night),
|
||
refills budget, and settles. A fuel shortfall while calcium was climbing toward a tag is endurance
|
||
evidence (a preparation deposit made during action); a surface already at its ceiling is a
|
||
structural limit, not endurance.
|
||
|
||
**During NIGHT — the same three categories, turned inward.** RECOVERY imports material/energy and
|
||
primes AMPA responsiveness from the standing tag. PREPARATION replays: POST responds to the
|
||
re-evoked glutamate exactly as it responds by day (same AMPA/NMDA machinery, same endurance
|
||
deposit into the same trace), reading the response as participation rather than transmitting — no
|
||
dopamine. ACTION is the structural change: general homeostatic lowering, then rebuild where the tag
|
||
stands and participation was confirmed, consuming the tag. Both ceilings draw the same finite pool
|
||
and compete; unmaintained ceilings drift down.
|
||
|
||
```
|
||
// PARAMETERS K_AMPA · AMPA_Ca · AMPA_cost · NMDA_cost · bAP_cost · pka_cost · traffic_cost
|
||
// req_cost · Mg_eject · Dserine_thr · Ca_STP · Ca_TAG · eCB_thr · drift · baseline
|
||
// NO_synth_cost · eCB_synth_cost
|
||
// INTERFACE
|
||
// EMIT retro_NO (+), retro_eCB (−) → PRE
|
||
// RECEIVE (signals) glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP ← DEND/SOMA ; dopamine
|
||
// READ glutamate ; astro_Dserine ; bAP (dend_structure.bAP_fidelity) ; dopamine
|
||
// OWN post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
|
||
// SUPPLY astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
|
||
// EMERGENCY shockwave_lockdown ← ASTRO
|
||
// NOTE POST endurance is own-state only (own Ca climbing); no arrived feedback term.
|
||
// coincidences sort by timescale: D-serine/bAP detected IN ACTION (instantaneous); dopamine in PREPARATION.
|
||
|
||
// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = arrived glutamate / bAP):
|
||
// ACTION respond: integrate glutamate, detect instantaneous coincidences, emit retro (NOT_bAP);
|
||
// bAP is a second, vertical action-context (soma's spike confirms)
|
||
// RECOVERY restore the ability to respond: Ca extrusion + NMDA Mg-block re-establish
|
||
// PREPARATION shape what comes next: AMPA fill (next response) + tag climb (NIGHT) + refill + settle
|
||
// Coincidences sort by timescale: D-serine/bAP detected IN ACTION (instantaneous); dopamine in PREPARATION.
|
||
|
||
// ===== ACTION =====
|
||
DAY | bAP: // second action-context (vertical): soma 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: // respond to arrived input (the defining deed)
|
||
a = sat(glutamate, K_AMPA)
|
||
AMPA_current = a × AMPA_surface; Vm += AMPA_current; post_budget -= AMPA_cost // SOURCE 1 AMPA
|
||
post_fast_trace += AMPA_Ca·AMPA_current
|
||
if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0: // SOURCE 2 NMDA
|
||
post_fast_trace += NMDA_Ca(glutamate)·rise_speed(); post_budget -= NMDA_cost // coincidence #1,2 here
|
||
retro_NO += NO_emit(post_fast_trace); post_budget -= NO_synth_cost // EMIT + "responsive target"
|
||
if Vm > eCB_thr:
|
||
retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost // EMIT − brake
|
||
|
||
// ===== RECOVERY (restore the ability to respond; alter-ego of the response) =====
|
||
DAY | NOT_bAP · recovered: // Ca extrusion + Mg-block re-establish
|
||
post_fast_trace *= decay(ms) // FAST — Ca extruded, trace relaxes
|
||
// (NMDA Mg-block re-establishes as Vm falls — implicit in the Vm>Mg_eject gate next response)
|
||
|
||
// ===== PREPARATION (shape the next response AND the NIGHT) =====
|
||
DAY | quiet: // sustained quiet
|
||
// for NIGHT: climb 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
|
||
// for the NEXT RESPONSE: STP fill / STD drift
|
||
if post_fast_trace > Ca_STP:
|
||
if post_budget < traffic_cost: // FUEL shortfall → endurance (a PREPARATION deposit)
|
||
if post_fast_trace > traj_thr and post_fast_trace_rising:
|
||
post_endurance_need += post_fast_trace
|
||
else if AMPA_surface < post_structure.slot_ceiling:
|
||
AMPA_surface += Ca_insert(post_fast_trace); post_budget -= traffic_cost
|
||
// else: surface at slot_ceiling → structure-limited (not endurance)
|
||
else:
|
||
AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = un-honored decay
|
||
post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
|
||
post_possible_tag *= decay(min); post_endurance_need *= decay(min) // MEDIUM
|
||
post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals
|
||
|
||
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern.
|
||
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release contend WITHIN (participation
|
||
// arbitrates); material contends BETWEEN components (recovery). Night PREPARATION replays the DAY
|
||
// ACTION (same AMPA/NMDA machinery, same endurance trace), read for participation not significance.
|
||
|
||
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
|
||
NIGHT | build or release:
|
||
if rest_permission and post_tag > tag_expiry and post_participation ≥ MEDIUM: // BUILD (slice)
|
||
Δ = min(slot_batch, post_material, post_energy·f_cap, post_tag) × post_participation
|
||
post_structure += Δ; post_material -= Δ; post_energy -= Δ·assembly_cost
|
||
post_tag -= Δ // SLICE — tag persists across cycles
|
||
if post_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, post_material·f_cap, post_energy·f_cap)
|
||
post_budget_ceiling += Δ'; post_material -= Δ'; post_energy -= Δ'·biogenesis_cost
|
||
post_endurance_need -= Δ'
|
||
else if post_participation == LOW: // RELEASE: shed, free material; tag untouched
|
||
shed = release_rate × max(post_structure - homeostatic_floor, 0)
|
||
post_structure -= shed; post_freed_material += shed·recycle
|
||
post_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
// else: HOLD — tag waits for its pattern
|
||
|
||
// ===== RECOVERY (acquire material/energy in CONTENTION with other components; receive freed material) =====
|
||
NIGHT | import + free:
|
||
post_material += transit(post_material_ship, τ_transport_spine) // import (contested pool)
|
||
post_energy += transit(post_energy_ship, τ_transport_spine)
|
||
post_material += post_freed_material; post_freed_material = 0 // reclaim what release freed
|
||
if renorm_signal arrived:
|
||
freed = post_structure × (1 - renorm_signal); post_structure *= renorm_signal
|
||
emit(freed → recycled material pool)
|
||
post_material += post_ceiling_shrinkage·recycle // energy NOT recovered
|
||
post_structure += min(post_maint, maint_cost) // hold up what is used
|
||
|
||
// ===== PREPARATION (REPLAY the response — SAME machinery as day ACTION; multi-timescale) =====
|
||
NIGHT | replay + measure + prime:
|
||
// FAST: replay the response to the re-evoked input (probe)
|
||
if arrived_glutamate_replay or arrived_replay_AP:
|
||
a = sat(glutamate, K_AMPA)
|
||
post_fast_trace += AMPA_Ca·(a × AMPA_surface) // SAME AMPA machinery as DAY ACTION
|
||
if Vm > Mg_eject and astro_Dserine > Dserine_thr:
|
||
post_fast_trace += NMDA_Ca(glutamate) // SAME NMDA machinery
|
||
if post_budget < traffic_cost: // SAME capacity check → endurance evidence
|
||
if post_fast_trace > traj_thr: post_endurance_need += post_fast_trace // SAME trace, fed by replay
|
||
post_participation = level(post_fast_trace) // read replayed response as participation
|
||
// MEDIUM: prime responsiveness (AMPA occupancy) from the standing tag
|
||
post_spont_thr = spont_thr_base − thr_gain × post_tag
|
||
if post_tag > prime_thr:
|
||
AMPA_surface = min(AMPA_surface + prime_gain × post_tag, post_structure.slot_ceiling)
|
||
post_possible_tag *= occupancy_downscale
|
||
// SLOW: settle
|
||
post_fast_trace *= decay(ms); post_tag *= decay(hr); post_endurance_need *= decay(slow)
|
||
emit(post_fatigue, post_demand → upward) // not a sink: emits inward/upward by night
|
||
```
|
||
|
||
---
|
||
|
||
## DEND
|
||
|
||
The dendritic branch is the postsynapse's supply line and the neuron's input integrator. It
|
||
carries the back-propagating spike out to its spines, integrates their voltages toward the
|
||
soma, and ships material and budget to the spines it supports.
|
||
|
||
**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the
|
||
branch propagates the back-propagating spike toward its spines, with a fidelity that attenuates
|
||
with distance (distal spines get weaker confirmation, are harder to potentiate). It deposits
|
||
branch calcium and integrates its spines' voltages into a single branch signal sent on to the
|
||
soma. A fuel shortfall that cuts propagation short while the branch was strongly active is
|
||
endurance evidence; propagation that simply attenuates with distance is a structural limit, not
|
||
endurance.
|
||
|
||
**During DAY, during NOT_bAP — the branch consolidates, supplies, and recovers.** It maintains
|
||
its tag toward consolidation, lowers its commit threshold under acetylcholine (attention),
|
||
ships budget down to its spines (demand-weighted by their tags), runs local translation if
|
||
tagged, refills its own budget from astrocytic lactate and somatic shipment, and lets its
|
||
traces decay.
|
||
|
||
**During NIGHT — the branch's ceilings are rewritten.** NIGHT raises **structure** (bAP
|
||
fidelity, translation capacity) where a validated tag accumulated and **budget capacity** where
|
||
fuel interrupted strong branch activity, both from the shared pool, both competing; unmaintained
|
||
ceilings drift down.
|
||
|
||
```
|
||
// PARAMETERS prop_cost · branch_Ca_cost · integrate_cost · translate_cost · ACh_gain
|
||
// INTERFACE
|
||
// EMIT bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST
|
||
// RECEIVE (signals) SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
|
||
// READ SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
|
||
// OWN dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
|
||
// SUPPLY astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
|
||
// NOTE DEND endurance fires only on FUEL-limited propagation, not structural attenuation;
|
||
// own-state proxy (strong branch activity); no arrived feedback term.
|
||
|
||
// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = soma's bAP / spine input):
|
||
// ACTION propagate the bAP to spines + integrate spine voltage to soma (context bAP)
|
||
// RECOVERY restore branch excitability: Ca clearance (fast alter-ego of propagation)
|
||
// PREPARATION shape the next: tag climb (NIGHT), attention threshold, ship to spines, refill, settle
|
||
// ONE fuel shortfall that cuts propagation short = endurance; distance attenuation = structural limit.
|
||
|
||
// ===== ACTION =====
|
||
DAY | bAP: // propagate + integrate (the defining deed)
|
||
if dend_budget < prop_cost:
|
||
if dend_fast_trace > traj_thr: // FUEL shortfall → endurance (a PREPARATION deposit)
|
||
dend_endurance_need += dend_fast_trace
|
||
bAP_local, reached = propagate_partial(dend_budget)
|
||
else:
|
||
bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry)
|
||
// reached < full here is structural attenuation (distance), NOT endurance
|
||
dend_budget -= prop_cost × reached
|
||
dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost
|
||
branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost // EMIT integrated Vm → SOMA
|
||
|
||
// ===== RECOVERY (restore branch excitability; alter-ego of propagation) =====
|
||
DAY | NOT_bAP · recovered: // Ca clearance
|
||
dend_fast_trace *= decay(300ms) // FAST — branch Ca relaxes
|
||
|
||
// ===== PREPARATION (shape the next propagation AND the NIGHT) =====
|
||
DAY | NOT_bAP:
|
||
// for NIGHT: strength climb
|
||
if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
|
||
if dopamine > dop_thr and dend_possible_tag > tag_thr:
|
||
dend_tag += dopamine × dend_possible_tag // token minted for NIGHT
|
||
// for the next: attention lowers commit threshold; local translation; ship to spines; refill
|
||
commit_threshold *= 1/(1 + ACh·ACh_gain)
|
||
if dend_tag > tag_expiry and dend_budget > translate_cost: dend_budget -= translate_cost
|
||
dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost) // EMIT down to spines
|
||
dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
|
||
dend_possible_tag *= decay(s); dend_endurance_need *= decay(min) // MEDIUM
|
||
dend_tag *= decay(hr) // SLOW
|
||
|
||
// ── NIGHT: SAME three categories, subject = the pattern. DEND is an intermediate RELAY: its
|
||
// PREPARATION replay relays replay_AP onward to spines IF primed (carrying SOMA→DEND→POST).
|
||
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release WITHIN; material BETWEEN.
|
||
|
||
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists) =====
|
||
NIGHT | build or release:
|
||
if dend_tag > tag_expiry and dend_participation ≥ MEDIUM: // BUILD (slice)
|
||
Δ = min(slot_batch, dend_material, dend_energy·f_cap, dend_tag) × dend_participation
|
||
dend_structure += Δ; dend_material -= Δ; dend_energy -= Δ·assembly_cost; dend_tag -= Δ
|
||
if dend_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, dend_material·f_cap, dend_energy·f_cap)
|
||
dend_budget_ceiling += Δ'; dend_material -= Δ'; dend_energy -= Δ'·biogenesis_cost
|
||
dend_endurance_need -= Δ'
|
||
else if dend_participation == LOW: // RELEASE: shed, free material; tag untouched
|
||
shed = release_rate × max(dend_structure - homeostatic_floor, 0)
|
||
dend_structure -= shed; dend_freed_material += shed·recycle
|
||
dend_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
// else: HOLD
|
||
|
||
// ===== RECOVERY (acquire/free material in CONTENTION; ship down to feed spine links) =====
|
||
NIGHT | import + free:
|
||
dend_material += transit(soma_material_to_dend, τ_transport_dend)
|
||
dend_energy += transit(soma_energy_to_dend, τ_transport_dend)
|
||
dend_material += dend_freed_material; dend_freed_material = 0 // reclaim what release freed
|
||
if renorm_signal arrived:
|
||
freed = dend_structure × (1 - renorm_signal); dend_structure *= renorm_signal
|
||
emit(freed → recycled material pool)
|
||
dend_material += dend_ceiling_shrinkage·recycle // energy NOT recovered
|
||
dend_structure += min(dend_maint, maint_cost) // hold up what is used
|
||
post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost) // ship to feed spine links
|
||
post_energy_ship += ship(dend_energy, post_demand, f_spine, ship_cost)
|
||
|
||
// ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) =====
|
||
NIGHT | replay + measure + prime:
|
||
// FAST: relay the replay_AP onward to spines IF primed (probe)
|
||
if arrived_replay_AP and dend_spont_thr < recruit_thr:
|
||
bAP_local = propagate(replay_AP, dend_structure.bAP_fidelity, geometry) // SAME propagate machinery
|
||
emit(bAP_local → POST) // carries the pattern to the spines
|
||
dend_fast_trace += bAP_Ca(bAP_local)
|
||
if dend_budget < prop_cost and dend_fast_trace > traj_thr: // SAME capacity check → endurance
|
||
dend_endurance_need += dend_fast_trace // SAME trace, fed by replay
|
||
dend_participation = level(dend_fast_trace) // read replayed response as participation
|
||
// MEDIUM: prime bAP-relay excitability from the standing tag
|
||
dend_spont_thr = spont_thr_base − thr_gain × dend_tag
|
||
// SLOW: settle
|
||
dend_fast_trace *= decay(300ms); dend_tag *= decay(hr); dend_endurance_need *= decay(slow)
|
||
emit(dend_fatigue, dend_demand → upward)
|
||
```
|
||
|
||
---
|
||
|
||
## SOMA
|
||
|
||
The soma is the neuron's integrating center and the root of its structural material. It sums
|
||
the branch inputs, fires when they exceed a threshold it sets from its own adaptation and the
|
||
neuromodulators, and ships material and budget out to the dendrites and axon. Its timing —
|
||
refractoriness, adaptation, rhythm alignment — emerges bottom-up from local traces, never from
|
||
a represented clock.
|
||
|
||
**During DAY, during AP — the soma integrates and fires.** It computes its firing threshold
|
||
from its baseline (structure), its accumulated adaptation, and the neuromodulators, and checks
|
||
its refractory state; if the integrated branch input clears the threshold and fuel allows, it
|
||
fires. One spike deposits three traces at three timescales — sodium inactivation (refractory),
|
||
slow-potassium adaptation (threshold rise), and nuclear calcium (toward CREB and the tag). A
|
||
fuel shortfall while nuclear calcium was climbing is endurance evidence; being refractory or
|
||
sub-threshold is a timing limit, not endurance.
|
||
|
||
**During DAY, during NOT_AP — the soma recovers, aligns, and supplies.** It self-replenishes
|
||
from its own mitochondria (its private root), integrates the latest branch inputs, deposits a
|
||
refractory-alignment trace when suprathreshold input arrived during its refractory period (so it
|
||
aligns to its input rhythm bottom-up), ships budget to dendrites and axon (demand-weighted by
|
||
their tags), recovers from refractoriness at a rate its alignment trace speeds up, and lets its
|
||
traces decay.
|
||
|
||
**During NIGHT — the soma's ceilings are rewritten, and it gates the whole neuron's material.**
|
||
NIGHT raises **structure** (excitability, synthesis capacity) and **budget capacity** from the
|
||
shared pool; crucially the soma's own tag gates CREB-driven synthesis, so how much material all
|
||
downstream components receive depends on the soma having been tagged.
|
||
|
||
```
|
||
// PARAMETERS ap_cost · nuclear_cost · creb_cost · mito_output · inactivation · ap_amp · ap_contrib
|
||
// base_recovery · τ_Na · τ_adapt · τ_nuclear · τ_align
|
||
// INTERFACE
|
||
// EMIT fired → AXON (propagate) + DEND (bAP) ; soma_ship_dend → DEND ; soma_ship_axon → AXON
|
||
// RECEIVE (signals) branch_Vm ← DEND ; dopamine ; NE ; ACh
|
||
// READ dopamine ; NE ; ACh
|
||
// OWN soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling
|
||
// SUPPLY self (mitochondria, ROOT — private)
|
||
// NOTE SOMA endurance fires only on FUEL shortfall (budget < ap_cost);
|
||
// refractory / sub-threshold are timing limits, not endurance. Own-state proxy.
|
||
|
||
// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = the branch input / spike):
|
||
// ACTION fire (the defining deed) — context AP
|
||
// RECOVERY restore the ability to fire again: refractory de-inactivation + mito replenish —
|
||
// the alter-ego of the spike, runs in NOT_AP
|
||
// PREPARATION shape the next spike: alignment, adaptation, tag-climb (for NIGHT), ship, decay
|
||
// Pattern: (ACTION ⇄ RECOVERY) × many spikes, then PREPARATION.
|
||
// ONE spike's fast trace feeds TWO preparation destinations: nuclear-Ca → tag (for NIGHT),
|
||
// inactivation/adaptation/alignment → next-spike timing (this scope).
|
||
|
||
// ===== ACTION =====
|
||
DAY | AP: // integrate + fire (the defining deed)
|
||
threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh)
|
||
can_fire = soma_Na_inactivation < inactivation
|
||
if branch_Vm > threshold and can_fire:
|
||
if soma_budget < ap_cost: // FUEL shortfall → endurance (a PREPARATION deposit)
|
||
if soma_fast_trace > traj_thr and soma_fast_trace_rising:
|
||
soma_endurance_need += soma_fast_trace
|
||
exit
|
||
fired = True; soma_budget -= ap_cost // EMIT fired → AXON, DEND
|
||
// deposit the THREE traces from one AP (all PREPARATION content, deposited in the action):
|
||
soma_Na_inactivation += ap_amp // → refractory (recovery will undo this)
|
||
soma_adaptation += ap_contrib // → threshold rise (next-spike timing)
|
||
soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // → tag (for NIGHT)
|
||
if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
|
||
if dopamine > dop_thr and soma_possible_tag > tag_thr:
|
||
soma_tag += dopamine × soma_possible_tag
|
||
soma_budget -= creb_cost
|
||
soma_emitted_activity += 1; soma_emitted_structure = soma_structure // NEURON sums these
|
||
|
||
// ===== RECOVERY (restore the ability to fire; alter-ego of AP; runs in NOT_AP) =====
|
||
DAY | NOT_AP: // de-inactivate + replenish
|
||
soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget) // mito replenish
|
||
recovery = base_recovery × (1 + soma_refractory_alignment)
|
||
soma_Na_inactivation *= decay(τ_Na / recovery) // refractory recovery (sped by alignment)
|
||
soma_fast_trace *= decay(τ_nuclear) // FAST — nuclear-Ca relaxes
|
||
|
||
// ===== PREPARATION (shape the next spike AND the NIGHT; ⊂ NOT_AP, sustained quiet) =====
|
||
DAY | NOT_SPIKE_TRAIN:
|
||
branch_Vm = integrate(DEND.branch_Vm, branches) // RECEIVE latest branch input
|
||
// for next-spike timing: refractory alignment (suprathreshold input during refractory)
|
||
if branch_Vm > threshold and soma_Na_inactivation > inactivation:
|
||
soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
|
||
// for downstream: ship budget to dendrites + axon (demand-weighted)
|
||
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)
|
||
// settle medium/slow stocks
|
||
soma_refractory_alignment *= decay(τ_align); soma_adaptation *= decay(τ_adapt)
|
||
soma_possible_tag *= decay(s); soma_endurance_need *= decay(min)
|
||
soma_tag *= decay(hr); dopamine *= decay(ms)
|
||
|
||
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. SOMA is a ROOT
|
||
// (produces material each cycle) AND the IGNITION POINT: its PREPARATION replay-fire propagates a
|
||
// replay_AP down axon + dendrites. Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release
|
||
// contend WITHIN (participation arbitrates); material contends BETWEEN components (recovery).
|
||
|
||
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
|
||
NIGHT | build or release:
|
||
if soma_tag > tag_expiry and soma_participation ≥ MEDIUM: // BUILD (slice)
|
||
Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag) × soma_participation
|
||
soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost
|
||
soma_tag -= Δ // SLICE — tag persists across cycles
|
||
if soma_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap)
|
||
soma_budget_ceiling += Δ'; soma_material -= Δ'; soma_energy -= Δ'·biogenesis_cost
|
||
soma_endurance_need -= Δ'
|
||
else if soma_participation == LOW: // RELEASE: shed, free material; tag untouched
|
||
shed = release_rate × max(soma_structure - homeostatic_floor, 0)
|
||
soma_structure -= shed; soma_freed_material += shed·recycle
|
||
soma_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
// else: HOLD — tag waits for its pattern
|
||
|
||
// ===== RECOVERY (ROOT production + acquire/free material in CONTENTION; ship to feed the pattern) =====
|
||
NIGHT | produce + import + free:
|
||
soma_material += CREB_synth(soma_tag)·Δt_cycle // ROOT: produce material — recoverable
|
||
soma_energy += mito_synth()·Δt_cycle // ROOT: produce energy — NOT recoverable
|
||
night_energy_spent += mito_synth()·Δt_cycle
|
||
soma_material += soma_freed_material; soma_freed_material = 0 // reclaim what release freed
|
||
soma_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost) // ship to feed pattern links
|
||
soma_material_to_axon += ship(soma_material, axon_demand, f_axon, ship_cost)
|
||
soma_energy_to_dend += ship(soma_energy, dend_demand, f_dend, ship_cost)
|
||
soma_energy_to_axon += ship(soma_energy, axon_demand, f_axon, ship_cost)
|
||
soma_material += soma_ceiling_shrinkage·recycle
|
||
soma_structure += min(soma_maint, maint_cost) // hold up what is used
|
||
|
||
// ===== PREPARATION (REPLAY the fire — SAME machinery as day ACTION; ignites the pattern; multi-timescale) =====
|
||
NIGHT | replay-fire + measure + prime:
|
||
// FAST: replay-fire (probe); ignites the pattern down the day pathway
|
||
spont = intrinsic_fluctuation()
|
||
if spont > soma_spont_thr: // ignite (SAME threshold logic as day fire)
|
||
replay_AP = TRUE
|
||
soma_fast_trace += nuclear_Ca()·δ(replay) // SAME trace deposit as DAY ACTION
|
||
if soma_budget < ap_cost: // SAME capacity check → endurance evidence
|
||
if soma_fast_trace > traj_thr: soma_endurance_need += soma_fast_trace // SAME trace, fed by replay
|
||
else:
|
||
soma_budget -= ap_cost
|
||
emit(replay_AP → AXON, DEND) // propagate: AXON/DEND relay onward IF primed
|
||
// pattern carries link by link, primed→primed (mechanical coherence):
|
||
// SOMA →[replay_AP]→ AXON →→ PRE →[glutamate]→ POST →→ DEND →→ SOMA ; one un-primed link breaks it
|
||
soma_participation = level(soma_fast_trace) // read replayed response as participation
|
||
// MEDIUM: prime firing excitability from the standing tag
|
||
soma_spont_thr = spont_thr_base − thr_gain × soma_tag
|
||
// SLOW: settle
|
||
soma_fast_trace *= decay(τ_nuclear); soma_tag *= decay(hr); soma_endurance_need *= decay(slow)
|
||
```
|
||
|
||
---
|
||
|
||
## AXON
|
||
|
||
The axon carries the soma's spike out to its boutons and is the presynapse's supply line. It
|
||
propagates reliably or not depending on its myelination and its recent load, and ships material
|
||
and budget to the boutons.
|
||
|
||
**During DAY, during AP — the axon propagates the spike.** Reliability is set by structure
|
||
(myelination) and degraded by recent high-frequency load (sodium inactivation at branch points —
|
||
axonal short-term depression). A fuel shortfall while carrying a strong train is endurance
|
||
evidence; load-driven failure is short-term depression, a consequence, not endurance.
|
||
|
||
**During DAY, during NOT_AP — the axon supplies and recovers.** It maintains its tag, ships
|
||
budget to its boutons (demand-weighted by their tags), refills its own budget from somatic
|
||
shipment and astrocytic lactate, and lets its traces decay.
|
||
|
||
**During NIGHT — the axon's ceilings are rewritten.** NIGHT raises **structure** (myelination,
|
||
transport capacity) and **budget capacity** from the shared pool, both competing; unmaintained
|
||
ceilings drift down.
|
||
|
||
```
|
||
// PARAMETERS prop_cost · budget_factor
|
||
// INTERFACE
|
||
// EMIT APs_delivered → PRE (propagation) ; axon_ship_pre → PRE
|
||
// RECEIVE (signals) SOMA.fired ; dopamine
|
||
// READ SOMA.fired ; dopamine
|
||
// OWN axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling
|
||
// SUPPLY soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
|
||
// NOTE AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace)
|
||
// is axonal STD (a consequence), not endurance. Own-state proxy.
|
||
|
||
// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = soma's spike):
|
||
// ACTION propagate the delivered spike to boutons (context AP)
|
||
// RECOVERY restore axon excitability: ionic re-equilibration (fast alter-ego of propagation)
|
||
// PREPARATION shape the next: tag climb (NIGHT), ship to boutons, refill, settle
|
||
// fail(fast_trace) is load-driven axonal STD (a consequence); FUEL shortfall is endurance.
|
||
|
||
// ===== ACTION =====
|
||
DAY | AP: // propagate the spike (the defining deed)
|
||
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance
|
||
if axon_budget < prop_cost:
|
||
reliability *= budget_factor
|
||
if axon_fast_trace > traj_thr: // FUEL-limited → endurance (a PREPARATION deposit)
|
||
axon_endurance_need += axon_fast_trace
|
||
delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT delivered → boutons
|
||
axon_fast_trace += delivered // deposit fast trace
|
||
|
||
// ===== RECOVERY (restore axon excitability; alter-ego of propagation) =====
|
||
DAY | NOT_AP · recovered: // ionic re-equilibration
|
||
axon_fast_trace *= decay(s) // FAST — shaft relaxes
|
||
|
||
// ===== PREPARATION (shape the next propagation AND the NIGHT) =====
|
||
DAY | NOT_AP:
|
||
// for NIGHT: 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
|
||
// for the next: ship to boutons, refill toward next demand
|
||
axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
|
||
axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
|
||
axon_possible_tag *= decay(s); axon_endurance_need *= decay(min) // MEDIUM
|
||
axon_tag *= decay(hr) // SLOW
|
||
|
||
// ── NIGHT: SAME three categories, subject = the pattern. AXON is an intermediate RELAY: its
|
||
// PREPARATION replay relays replay_AP onward to boutons IF primed (carrying SOMA→AXON→PRE).
|
||
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release WITHIN; material BETWEEN.
|
||
|
||
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists) =====
|
||
NIGHT | build or release:
|
||
if axon_tag > tag_expiry and axon_participation ≥ MEDIUM: // BUILD (slice)
|
||
Δ = min(slot_batch, axon_material, axon_energy·f_cap, axon_tag) × axon_participation
|
||
axon_structure += Δ; axon_material -= Δ; axon_energy -= Δ·assembly_cost; axon_tag -= Δ
|
||
if axon_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, axon_material·f_cap, axon_energy·f_cap)
|
||
axon_budget_ceiling += Δ'; axon_material -= Δ'; axon_energy -= Δ'·biogenesis_cost
|
||
axon_endurance_need -= Δ'
|
||
else if axon_participation == LOW: // RELEASE: shed, free material; tag untouched
|
||
shed = release_rate × max(axon_structure - homeostatic_floor, 0)
|
||
axon_structure -= shed; axon_freed_material += shed·recycle
|
||
axon_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
// else: HOLD
|
||
|
||
// ===== RECOVERY (acquire/free material in CONTENTION; ship down to feed bouton links) =====
|
||
NIGHT | import + free:
|
||
axon_material += transit(soma_material_to_axon, τ_transport_dend)
|
||
axon_energy += transit(soma_energy_to_axon, τ_transport_dend)
|
||
axon_material += axon_freed_material; axon_freed_material = 0 // reclaim what release freed
|
||
if renorm_signal arrived:
|
||
freed = axon_structure × (1 - renorm_signal); axon_structure *= renorm_signal
|
||
emit(freed → recycled material pool)
|
||
axon_material += axon_ceiling_shrinkage·recycle // energy NOT recovered
|
||
axon_structure += min(axon_maint, maint_cost) // hold up what is used
|
||
pre_material_ship += ship(axon_material, pre_demand, f_bouton, ship_cost) // ship to feed bouton links
|
||
pre_energy_ship += ship(axon_energy, pre_demand, f_bouton, ship_cost)
|
||
|
||
// ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) =====
|
||
NIGHT | replay + measure + prime:
|
||
// FAST: relay the replay_AP onward to boutons IF primed (probe)
|
||
if arrived_replay_AP and axon_spont_thr < recruit_thr:
|
||
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // SAME reliability machinery
|
||
delivered = reliability × axon_structure.propagation
|
||
emit(replay_AP → PRE) // carries the pattern to the boutons
|
||
axon_fast_trace += delivered
|
||
if axon_budget < prop_cost and axon_fast_trace > traj_thr: // SAME capacity check → endurance
|
||
axon_endurance_need += axon_fast_trace // SAME trace, fed by replay
|
||
axon_participation = level(axon_fast_trace) // read replayed response as participation
|
||
// MEDIUM: prime relay excitability from the standing tag
|
||
axon_spont_thr = spont_thr_base − thr_gain × axon_tag
|
||
// SLOW: settle
|
||
axon_fast_trace *= decay(s); axon_tag *= decay(hr); axon_endurance_need *= decay(slow)
|
||
emit(axon_fatigue, axon_demand → upward)
|
||
```
|
||
|
||
---
|
||
|
||
## ASTROSYNAPSE
|
||
|
||
> The astrosynapse is the perisynaptic astrocytic process — the LOCAL component at one synapse,
|
||
> the astroglial peer of pre/post and a constituent of the ASTROCYTE actor (which integrates
|
||
> across all of them, just as the NEURON integrates over the soma). The astrosynapse behaves
|
||
> locally here; the astrocyte integrates and broadcasts (see CELL ACTORS).
|
||
|
||
The astrosynapse is the synapse's gatekeeper and energy hub. It clears glutamate, supplies the
|
||
D-serine that gates postsynaptic NMDA, and distributes lactate across its territory by demand.
|
||
Unlike the others it runs in a single continuous context rather than spiking, and its structure
|
||
reshapes the synapse's operating point rather than just its range.
|
||
|
||
**During DAY, continuously — the astrosynapse clears, gates, and fuels.** It produces energy at
|
||
its cell body (glycolysis from glucose, the system's energy root), then allocates lactate across
|
||
its astrosynapses weighted by each one's clearance demand. At each astrosynapse it clears
|
||
spillover glutamate (EAAT) and supplies tonic D-serine; when spillover is high it adds a
|
||
demand-driven D-serine pulse, brakes nothing of the presynapse directly (the presynaptic brake
|
||
is PRE reading its own cleft), deposits its calcium trace, and accumulates a dopamine-gated tag.
|
||
A D-serine pulse cut short by low budget while demand was high is endurance evidence; one cut
|
||
short by precursor/material exhaustion is a material limit, not endurance. Excess overflow
|
||
triggers the protective shockwave lockdown.
|
||
|
||
**During NIGHT — the astrosynapse's ceilings are rewritten.** NIGHT raises **structure**
|
||
(perisynaptic wrap, EAAT density, tonic D-serine) where a validated tag accumulated and **budget
|
||
capacity** where budget-limited synthesis recurred; astro_structure is self-reinforcing in both
|
||
directions, so it amplifies whatever trajectory the synapse is already on.
|
||
|
||
```
|
||
// PARAMETERS K_Dserine · Ds_max · Ds_frac · Ds_cost · EAAT_cost · lactate_cost · spillover · overload
|
||
// INTERFACE
|
||
// EMIT astro_lactate[i] → pre/post/dend budgets ; astro_Dserine[i] → POST (gate)
|
||
// RECEIVE (signals) glutamate ← PRE (clearance + spillover) ; dopamine
|
||
// READ glutamate ; dopamine
|
||
// OWN astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling
|
||
// SUPPLY glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
|
||
// NOTE ASTRO endurance fires on BUDGET-limited synthesis (got<want via low budget);
|
||
// 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
|
||
// PREP: root production, demand weights, lactate allocation (ready the territory)
|
||
astro_central_budget += glycolysis(glucose)·Δt
|
||
for each i: demand[i] = clearance_load[i] × astro_structure[i].delivery_eff
|
||
for each i: astro_territory_demand[i] += demand[i]·Δt // territory-level aggregator (by DAY)
|
||
factor = min(1, astro_central_budget / (Σ demand·lactate_cost + ε))
|
||
for each i:
|
||
astro_lactate[i] = demand[i] × factor; astro_central_budget -= astro_lactate[i]·lactate_cost
|
||
// 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 × astro_prime[i]·Δt // priming biases the gate (alpha-driven)
|
||
if glutamate[i] > spillover:
|
||
astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s) // deposit fast trace
|
||
want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
|
||
got = min(want, astro_central_budget × Ds_frac)
|
||
astro_Dserine[i] += got; astro_central_budget -= got·Ds_cost // D-serine pulse → POST gate
|
||
if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
|
||
astro_endurance_need[i] += (want - got) // FUEL-limited synthesis → endurance
|
||
// EVAL: strength climb → token for NIGHT
|
||
if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i]
|
||
if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
|
||
astro_tag[i] += dopamine × astro_possible_tag[i]
|
||
// DECAY (settle)
|
||
// MEDIUM (s–min)
|
||
astro_possible_tag[i] *= decay(s); astro_endurance_need[i] *= decay(min)
|
||
// SLOW (hr)
|
||
astro_tag[i] *= decay(hr)
|
||
// EMERGENCY
|
||
if astro_fast_trace[i] > overload: emit(shockwave_lockdown)
|
||
|
||
NIGHT · NON_REM_1 = PREPARATION | produce + distribute + prime: // ROOT: energy production + priming
|
||
// PRODUCTION (root): glycolysis + ECM synthesis this cycle, capped by glucose
|
||
astro_central_energy += overnight_glycolysis(glucose)·Δt_cycle // energy — NOT recoverable
|
||
astro_central_material += astro_cellbody_synth()·Δt_cycle // material — recoverable
|
||
night_energy_spent += overnight_glycolysis(glucose)·Δt_cycle
|
||
// distribute this cycle's batch across the territory, tag-weighted
|
||
W = Σ astro_tag[i] over astro_tag[i] > tag_expiry
|
||
for each i with astro_tag[i] > tag_expiry:
|
||
w = astro_tag[i]/W
|
||
astro_energy[i] += astro_central_energy·w; astro_material[i] += astro_central_material·w
|
||
astro_spont_thr[i] = spont_thr_base − thr_gain × astro_tag[i] // prime own responsiveness from own tag
|
||
astro_central_material += astro_ceiling_shrinkage·recycle // recycle
|
||
|
||
NIGHT · REM = EVALUATION | respond to re-evoked glutamate, MEASURE participation (NO dopamine):
|
||
for each astrosynapse i:
|
||
// when its synapse's pattern re-evokes, spillover glutamate arrives → mGluR Ca response (a PROBE)
|
||
if arrived_glutamate_replay[i]:
|
||
astro_fast_trace[i] += mGluR_Ca()
|
||
astro_participation[i] = level(astro_fast_trace[i]) // high/medium/low = centrality
|
||
astro_fast_trace[i] *= decay(s)
|
||
|
||
NIGHT · NON_REM_2 = ACTION | change the structure (per astrosynapse): // the night's defining deed
|
||
for each astrosynapse i:
|
||
astro_structure[i] -= decay_rate·Δt_cycle; astro_structure[i] += min(astro_maint[i], maint_cost) // lowering
|
||
if astro_tag[i] > tag_expiry and astro_participation[i] ≥ MEDIUM:
|
||
Δ = min(slot_batch, astro_material[i], astro_energy[i]·f_cap, astro_tag[i]) × astro_participation[i]
|
||
astro_structure[i] += Δ // self-reinforcing both directions
|
||
astro_material[i] -= Δ; astro_energy[i] -= Δ·assembly_cost; astro_tag[i] -= Δ
|
||
if astro_endurance_need[i] > endur_thr:
|
||
Δ' = min(cap_batch, astro_material[i]·f_cap, astro_energy[i]·f_cap)
|
||
astro_budget_ceiling[i] += Δ'; astro_material[i] -= Δ'
|
||
astro_energy[i] -= Δ'·biogenesis_cost; astro_endurance_need[i] -= Δ'
|
||
else:
|
||
astro_budget_ceiling[i] -= capacity_decay_rate·Δt_cycle; astro_budget_ceiling[i] += min(astro_cap_maint[i], cap_cost)
|
||
astro_endurance_need[i] *= decay(slow)
|
||
emit(astro_fatigue, astro_demand → upward)
|
||
```
|
||
|
||
---
|
||
|
||
## Special — Shockwave Lockdown
|
||
|
||
```
|
||
DAY or NIGHT | OVERLOAD:
|
||
Vm = HYPERPOLARIZED; AMPA_surface = mass_internalize() → post reserve
|
||
axon_fast_trace += overdrive(); astro_central_budget -= emergency_cost
|
||
```
|
||
|
||
---
|
||
---
|
||
> NIGHT-BLOCK UNIFORMITY (three categories). PRE, SOMA, POST, DEND, AXON now run both DAY and NIGHT
|
||
> chunked as (ACTION ⇄ RECOVERY) × many, then PREPARATION, under explicit `// ===== =====` separators:
|
||
> (a) NIGHT-RECOVERY imports/produces supply, primes its OWN threshold from its OWN standing tag,
|
||
> applies the descended constraint to itself, recycles, and — for intermediate nodes AXON/DEND —
|
||
> ships downstream so the pattern's links are fed; (b) NIGHT-PREPARATION REPLAYS the day action —
|
||
> re-runs the SAME release/fire/respond/propagate machinery (same capacity/vesicle checks, same
|
||
> endurance deposit into the SAME trace), read as participation (level: high/medium/low), NO dopamine;
|
||
> AXON/DEND/SOMA also propagate the replay_AP onward IF primed (carrying SOMA→AXON→PRE and
|
||
> SOMA→DEND→POST); (c) NIGHT-ACTION lowers structure homeostatically, then rebuilds where the tag
|
||
> still stands AND participation ≥ medium, consuming the tag. Roots (SOMA material) additionally
|
||
> PRODUCE each cycle. The replay pattern propagates entirely through the DAY PATHWAYS, self-igniting,
|
||
> carrying only where every link is primed.
|
||
> [ASTROSYNAPSE still shows the earlier NON_REM/REM form — pending its own pass (it is continuous and
|
||
> under-described; the three-category cut will be verified there separately).]
|
||
|
||
---
|
||
---
|
||
# CELL ACTORS — NEURON and ASTROCYTE
|
||
Two structurally identical peers. Each integrates its constituents' EMITTED activity by its DAY
|
||
(never reading their interiors), detects when its aggregate has gone quiet, and BROADCASTS the
|
||
restructuring window + renormalization/reallocation by its NIGHT. Each component then restructures
|
||
ITSELF in response. The cell actor's own DAY/NIGHT follows the same transition rule, on its own
|
||
aggregate activity.
|
||
|
||
## NEURON
|
||
|
||
The neuron is the whole-cell actor over soma, pre, post, dend, axon. It cannot fire or release —
|
||
it integrates what its components emit and grants them the restructuring window none of them can
|
||
grant itself. The soma is one of its constituents, a peer of the bouton; the neuron is not the soma.
|
||
|
||
```
|
||
// PARAMETERS neuron_weight_ceiling · downscale_factor
|
||
// INTERFACE
|
||
// EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast)
|
||
// neuron_fatigue → HYPOTHALAMUS
|
||
// RECEIVE (signals) component activity emissions (summed) ; scope_context ← HYPOTHALAMUS
|
||
// replay_reweight ← assembly/network (external)
|
||
// OWN neuron_activity · neuron_total_weight (aggregates aggregated from emissions)
|
||
// NOTE never reads a component interior; sums emitted activity, broadcasts signals only.
|
||
|
||
DAY | active: // (within broadcast DAY context → integrate only)
|
||
// TRACE integrate the cell's emitted activity + committed weight (aggregators)
|
||
neuron_activity += Σ component emitted_activity·Δt
|
||
neuron_total_weight = Σ component emitted_structure // from emissions, not interiors
|
||
// EMIT fatigue upward (metabolic debt of the whole cell)
|
||
neuron_fatigue = f(neuron_activity, unspent demand)
|
||
// (no restructuring permission while the cell is active — components are busy)
|
||
|
||
NIGHT | cycle: // (within broadcast NIGHT context)
|
||
// the neuron acts ONLY by signalling; components prime/measure/rebuild themselves. Each
|
||
// component's cycle is RECOVERY→PREPARATION→ACTION; the neuron just supplies the constraint.
|
||
occupancy_downscale = downscale_factor // → components reset own occupancy (in RECOVERY)
|
||
if neuron_total_weight > neuron_weight_ceiling:
|
||
renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure
|
||
rest_permission = TRUE // → components may restructure this cycle
|
||
// RECOVER reclaim material returned by components' renormalization (arrives as recycled pool)
|
||
// DECAY neuron_activity relaxes as the cell stays quiet
|
||
|
||
CODA | on waking (scope_context → DAY):
|
||
neuron_activity = 0; neuron_total_weight = recomputed from surviving emissions
|
||
```
|
||
|
||
## ASTROCYTE
|
||
|
||
The astrocyte is the territory actor over its astrosynapses — the exact parallel of the neuron,
|
||
with two roles the neuron lacks. First, it is the ROOT of synaptic energy and ECM material, and
|
||
therefore the system's METABOLIC SENSOR: it accrues territory energy debt and reports it upward as
|
||
the fatigue that drives the hypothalamus's DAY/NIGHT switch, and its discharge of that debt during
|
||
night is what permits waking. Second, by DAY it PRIMES its territory: reading its own slow calcium
|
||
wave (alpha-band), it raises or lowers the D-serine gate and fuel delivery across a field of
|
||
synapses — a localized, slow, neuromodulator-like gain signal, biasing which synapses can potentiate.
|
||
|
||
```
|
||
// PARAMETERS (territory reallocation) · alpha_gain
|
||
// INTERFACE
|
||
// EMIT astro_prime[·] (DAY gain field), astro_alloc[·] + rest_permission (NIGHT) → astrosynapses
|
||
// astro_fatigue → HYPOTHALAMUS (metabolic debt — the switch driver) ; energy+material → territory
|
||
// RECEIVE (signals) astrosynapse demand emissions (summed) ; scope_context ; replay_reweight ; glucose
|
||
// OWN astro_territory_demand[·] ; astro_slow_Ca (alpha wave) ; astro_central_{energy,material}
|
||
// NOTE ROOT of synaptic energy + ECM material; integrate-and-broadcast like the neuron, PLUS
|
||
// day-priming (localized neuromodulation) and metabolic sensing (drives the day/night switch).
|
||
|
||
DAY | active:
|
||
// TRACE integrate territory-wide emitted demand (aggregator) + own slow Ca wave
|
||
for each astrosynapse i: astro_territory_demand[i] += emitted_demand[i]·Δt
|
||
astro_slow_Ca = integrate_slow(territory activity) // alpha-band astrocytic calcium
|
||
// BEHAVE/EMIT PRIME the territory: alpha-driven localized gain (like neuromodulation, but local)
|
||
for each astrosynapse i:
|
||
astro_prime[i] = 1 + alpha_gain × astro_slow_Ca // → biases i's D-serine gate + fuel (see ASTROSYNAPSE)
|
||
// EMIT report metabolic debt upward — this is the fatigue that drives the DAY/NIGHT switch
|
||
astro_fatigue = f(territory energy debt, unmet demand)
|
||
|
||
NIGHT | cycle: // (within broadcast NIGHT context)
|
||
// PRODUCTION (root): this cycle's energy + ECM batch, capped by glucose
|
||
astro_central_energy += overnight_glycolysis(glucose)·Δt_cycle // NOT recoverable
|
||
astro_central_material += astro_cellbody_synth()·Δt_cycle // recoverable
|
||
night_energy_spent += overnight_glycolysis(glucose)·Δt_cycle
|
||
// ADJUST reallocation weights across the territory (demand × replay)
|
||
for each i: astro_alloc[i] = (astro_territory_demand[i] × replay_reweight[i])
|
||
/ Σ(astro_territory_demand × replay_reweight)
|
||
// EMIT (broadcast) distribute this cycle's batch + grant restructuring window
|
||
for each i:
|
||
astro_energy[i] += astro_central_energy·astro_alloc[i]
|
||
astro_material[i] += astro_central_material·astro_alloc[i]
|
||
rest_permission[i] = TRUE // → each astrosynapse commits itself
|
||
// RECOVER reclaim material from decayed astrosynapse ceilings (returned to central pool)
|
||
astro_central_material += astro_ceiling_shrinkage·recycle
|
||
// discharge: producing + distributing energy repays territory debt → astro_fatigue falls → wake permitted
|
||
astro_fatigue -= discharge × astro_central_energy·Δt_cycle
|
||
|
||
CODA | on waking:
|
||
astro_territory_demand[·] = 0
|
||
```
|
||
|
||
## HYPOTHALAMUS
|
||
|
||
The system actor. Unlike every other actor it has NO night: it runs CONTINUOUS, integrating the
|
||
FATIGUE⇄REST competition and BROADCASTING the DAY/NIGHT context that every other actor receives. It
|
||
is the clock that never sleeps — but not a wall-clock: the context it emits is the earned outcome of
|
||
the competition, not a schedule. Fatigue is reported chiefly by the ASTROCYTE (the metabolic sensor
|
||
that runs the energy economy); rest accrues while quiet. If the hypothalamus stopped, nothing would
|
||
integrate the competition and the scope could never switch.
|
||
|
||
```
|
||
// PARAMETERS fatigue_gain · rest_gain · hysteresis
|
||
// INTERFACE
|
||
// EMIT scope_context ∈ {DAY, NIGHT} → ALL actors (broadcast; the switch)
|
||
// RECEIVE (signals) fatigue from components + ASTROCYTE (metabolic debt) ; rest (restoration)
|
||
// OWN fatigue · rest · scope_context
|
||
// NOTE the switch is TOP-DOWN: components receive the context, they do not each decide it.
|
||
|
||
CONTINUOUS: // spans every other actor's day and night
|
||
// integrate the two competing drives
|
||
fatigue += fatigue_gain × (Σ component_fatigue + astro_fatigue)·Δt // rises with activity (astrocyte-reported)
|
||
fatigue -= discharge × consolidation_progress·Δt // night restructuring discharges debt
|
||
rest += rest_gain × quiet·Δt // restoration accrues while quiet
|
||
rest -= rest_drain × activity·Δt
|
||
// BROADCAST the context according to which drive dominates (hysteresis avoids chatter)
|
||
if fatigue > rest + hysteresis: scope_context = NIGHT
|
||
if rest > fatigue + hysteresis: scope_context = DAY
|
||
broadcast(scope_context) // every actor behaves/restructures within it
|
||
```
|
||
|
||
How it runs without a driver. There is no loop that orchestrates the actors. The hypothalamus
|
||
continuously integrates fatigue (astrocyte-reported metabolic debt) against rest and broadcasts the
|
||
DAY/NIGHT context; every component and cell actor receives it and behaves or restructures within it.
|
||
Night restructuring discharges debt (fatigue falls) while quiet accrues rest — so a rested system's
|
||
context flips back to DAY (waking) and an overloaded one wakes with tags unspent (they carry
|
||
forward). The astrocyte is the sensor that makes this loop turn: it accrues and reports the debt
|
||
that drives the switch, and its discharge during night is what permits waking.
|
||
|
||
---
|
||
|
||
## One-view summary
|
||
|
||
```
|
||
THREE CATEGORIES · EIGHT ACTORS · ONE FATIGUE⇄REST SWITCH
|
||
Every component runs (ACTION ⇄ RECOVERY) × many, then PREPARATION — same shape at DAY and NIGHT.
|
||
ACTION the defining deed (day: release/fire/respond/propagate ; night: change structure)
|
||
RECOVERY the fast alter-ego — restore the ability to act (day: refill ; night: import + free material)
|
||
PREPARATION shape what's next; faces this scope AND the other. "Evaluation" was preparation all along:
|
||
depositing a trace is provisioning, not judging. Each category spans FAST·MEDIUM·SLOW.
|
||
|
||
ACTORS local: soma·pre·post·dend·axon·astrosynapse cell: neuron·astrocyte system: hypothalamus
|
||
higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in
|
||
|
||
DAY (broadcast context: rest dominates) ring turned OUTWARD against the world — COLLABORATION
|
||
each acts so the next can act (pre→post→dend→soma→axon→pre) ; currency: information (non-rival)
|
||
fast_trace → (avg/seconds) occupancy → (avg/minutes + dopamine) TAG, passed to NIGHT
|
||
NIGHT (broadcast context: fatigue dominates) ring turned INWARD against the economy — COMPETITION
|
||
PREPARATION replays the day ACTION (same machinery, no dopamine) → measures PARTICIPATION
|
||
ACTION = BUILD (participation high + tag stands; tag funds a slice, persists) ⇄ RELEASE
|
||
(participation LOW; frees material; tag untouched) — build vs release compete WITHIN
|
||
RECOVERY = contend WITH OTHER components for shared material/energy ; currency: material (rival)
|
||
competition is ADJUDICATED BY COLLABORATION: you build in proportion to replay participation
|
||
two forgettings: structural pruning (low participation) ; intention decay (tag decays unspent)
|
||
SWITCH DAY/NIGHT is a TOP-DOWN context. HYPOTHALAMUS integrates FATIGUE (astrocyte-reported metabolic
|
||
debt) ⇄ REST (restoration) and BROADCASTS the context. Earned, not clocked. Astrocyte is the
|
||
metabolic sensor: it drives the switch and its night discharge permits waking.
|
||
RULE no actor authorizes its own restructuring — each is PUT IN POSITION by the actor above
|
||
(holds an aggregate it can't see, opens a window it can't open). Material recycles; ENERGY
|
||
does not (the arrow of time). Coherence is mechanical: a pattern replays only if every link primed.
|
||
LOCAL only own state + arrived signals; ACTION/EMIT are the crossings; nothing is a pure sink
|
||
```
|