1080 lines
67 KiB
Markdown
1080 lines
67 KiB
Markdown
# Tripartite Synapse — Pseudocode v17
|
||
|
||
> Companion: `tripartite_synapse_v17_biology.md` · principle: `logic_principles_v3`.
|
||
> Changes from v16 — NIGHT is no longer an external driver; it is an EMERGENT, per-component
|
||
> state driven by a fatigue→sleep-pressure loop. Actors at every scale are written as peers.
|
||
> (1) EIGHT actors in one uniform template:
|
||
> LOCAL components — SOMA · PRE · POST · DEND · AXON · ASTROSYNAPSE (behave by DAY)
|
||
> CELL actors — NEURON (over soma/pre/post/dend/axon) · ASTROCYTE (over astrosynapses)
|
||
> SYSTEM actor — HYPOTHALAMUS (integrates fatigue, emits sleep-pressure)
|
||
> (2) DAY/NIGHT are PER-COMPONENT emergent states, not a global clock: a component is in NIGHT
|
||
> when its OWN activity is low AND sleep-pressure is high; back to DAY when pressure falls.
|
||
> (transition rule stated once in Conventions). The HYPOTHALAMUS alone is CONTINUOUS.
|
||
> (3) the external NIGHT driver is REMOVED. Restructuring is gated by local low-activity
|
||
> (behavior and restructuring are mutually exclusive at the substrate).
|
||
> (4) higher actors INTEGRATE constituents' emitted activity by their day and BROADCAST
|
||
> permission / renormalization / reallocation by their night — they never reach in;
|
||
> each component restructures ITSELF in response to arrived signals (locality holds).
|
||
> (5) governing rule: NO actor authorizes its own restructuring — each is PUT IN THE POSITION
|
||
> to restructure by the actor above it (which holds an aggregate it cannot see and opens a
|
||
> quiet window it cannot open). The system acts locally and consolidates hierarchically.
|
||
> Carried: cyclic/phased NIGHT, occupancy reset, tag-as-fuel, transit, two-resource metabolism.
|
||
|
||
---
|
||
|
||
## Functional groups (seven-group grammar)
|
||
|
||
```
|
||
RECEIVE take in resources + signals that arrived from outside (boundary: in)
|
||
TRACE maintain the trace hierarchy — deposit fast trace; accumulate
|
||
possible_tag + endurance_need; stabilize tag on coincidence
|
||
ADJUST compute local operating parameters from structure + traces + modulators
|
||
BEHAVE the component's defining action, within both ceilings
|
||
EMIT send out — signals (messages) + resources (shipments) (boundary: out)
|
||
RECOVER refill own private pools consumed by behaving
|
||
DECAY let traces recede, closing their windows
|
||
```
|
||
|
||
EVALUATE merged into TRACE: judging a behavior is always maintaining a trace, whether or not
|
||
a trace is written. BEHAVE and EMIT stay separate — EMIT is the output half of the locality
|
||
interface (RECEIVE/EMIT are the only boundary crossings). TRACE spans all timescales: the
|
||
soma's inactivation, adaptation, and nuclear-Ca deposits are all TRACE. Order within a context
|
||
follows data dependencies; TRACE reads/writes whatever trace state is current.
|
||
|
||
EVERY FLOW HAS A TIMESCALE. Decay relaxes toward 0 over τ; creation/arrival relaxes toward a
|
||
target over τ — the same first-order operator. Within-step writes are the special case τ ≪ Δt.
|
||
Rate-limited inflows (fill/refill/flux·Δt) carry their τ implicitly; shipment carries an
|
||
explicit transit delay (see `transit`).
|
||
|
||
THE GROUPS MOVE BETWEEN TIERS (the ladder; see logic_principles "The Timescale Ladder").
|
||
Four tiers: FAST (ms–s) · MEDIUM (s–min) · SLOW (hr) · PERSISTENT (NIGHT-written). The groups
|
||
move evidence UP the ladder and read capacity DOWN it:
|
||
|
||
```
|
||
ADJUST reads PERSISTENT ceiling + FAST trace → sets this step's operating point (down)
|
||
BEHAVE acts at FAST, bounded by the PERSISTENT ceiling (down)
|
||
TRACE deposits FAST, accumulates FAST→MEDIUM evidence, stabilizes MEDIUM→SLOW tag (up)
|
||
RECOVER refills toward the PERSISTENT ceiling (down)
|
||
DECAY relaxes FAST · MEDIUM · SLOW (PERSISTENT never decays in DAY)
|
||
NIGHT commits SLOW tag + MEDIUM endurance_need → PERSISTENT ceilings (up)
|
||
```
|
||
|
||
Capacity flows downward (slow sets the ceiling for fast); evidence flows upward (fast
|
||
accumulates toward slow). Each component's DECAY group below is banded by tier to show this.
|
||
|
||
NIGHT IS THE SAME GRAMMAR, ITERATED, WITH THE FLOW REVERSED. NIGHT is not a separate section —
|
||
each component carries a `NIGHT |` block, and a driver loops all blocks for cycle = 1,2,3…
|
||
until the night ends. DAY runs bottom-up (consumers act first, evidence ascends leaves→roots);
|
||
NIGHT runs top-down (producers act first, capacity descends roots→leaves). Per cycle, each
|
||
component:
|
||
|
||
```
|
||
RECEIVE take in the material + energy batch that arrived from my producer this cycle
|
||
TRACE read my own tag / endurance_need (the standing demand)
|
||
ADJUST size this cycle's commit from material + energy actually on hand
|
||
BEHAVE commit a BATCH: structure += Δ (from tag) ; budget_ceiling += Δ' (from need)
|
||
spend material + energy ; SPEND the tag/need by the committed amount (tag-as-fuel)
|
||
EMIT ship a batch of material + energy one hop down to my consumers (demand-weighted)
|
||
RECOVER reclaim material from any ceiling that decayed this cycle (energy is NOT recovered)
|
||
DECAY unmaintained ceilings drift down a little; tags decay a little
|
||
```
|
||
|
||
Roots (SOMA, ASTRO cell body) PRODUCE the batch each cycle (RECEIVE = production, capped by
|
||
glucose / CREB). The night ends when DEMAND is exhausted (no tag stands above tag_expiry,
|
||
system-wide) OR SUPPLY is spent (the night's energy throughput is used up) — whichever first.
|
||
Unspent tags are NOT cleared; they carry to the next DAY and compete again next NIGHT. The
|
||
top-down order needs no schedule: iterating the local cycle delivers capacity to distal sites
|
||
over successive cycles, as transport physically does.
|
||
|
||
DAY AND NIGHT ARE PER-COMPONENT EMERGENT STATES, NOT A GLOBAL CLOCK. There is no global SCOPE
|
||
variable. Each component is in its own DAY or NIGHT, decided locally from its own activity and
|
||
the arrived sleep-pressure signal. The labels `DAY | …` and `NIGHT | …` below denote these
|
||
LOCAL states. One transition rule governs every component (stated once here, not repeated):
|
||
|
||
```
|
||
TRANSITION (evaluated per component, from local state + the arrived signal):
|
||
enter NIGHT when own_activity < rest_thr AND sleep_pressure > sleep_thr
|
||
enter DAY when sleep_pressure < wake_thr
|
||
own_activity = the component's own running activity trace (it cannot restructure while busy:
|
||
behavior and restructuring compete for the same substrate — mutual exclusion).
|
||
sleep_pressure = arrived signal broadcast by the HYPOTHALAMUS (see below).
|
||
```
|
||
Components therefore cross into NIGHT at different times — a wave, not a switch (local sleep).
|
||
|
||
THE FATIGUE LOOP REPLACES THE EXTERNAL DRIVER. The system has no scheduler. Activity generates
|
||
fatigue; the hypothalamus integrates fatigue and broadcasts sleep-pressure; high pressure (plus
|
||
a component's own quiet) opens the restructuring window; restructuring discharges fatigue;
|
||
discharge lowers pressure; components re-enter DAY. DAY and NIGHT are the two phases of one
|
||
homeostatic loop the system runs on itself.
|
||
|
||
```
|
||
every component → emits fatigue (metabolic debt, unspent demand) ↑
|
||
HYPOTHALAMUS → integrates fatigue, emits sleep_pressure ↓ (CONTINUOUS — never sleeps)
|
||
every component → reads sleep_pressure + own activity → enters DAY or NIGHT locally
|
||
```
|
||
|
||
ACTORS ARE PEERS AT EVERY SCALE; EACH IS PUT IN POSITION BY THE ONE ABOVE. No actor authorizes
|
||
its own restructuring. Each holds an aggregate its constituents cannot see and opens a window
|
||
they cannot open, then BROADCASTS — it never reaches into a constituent's interior.
|
||
|
||
```
|
||
HYPOTHALAMUS integrates fatigue from all → broadcasts sleep_pressure (system, CONTINUOUS)
|
||
↓ signal
|
||
NEURON integrates its components' activity/weight → broadcasts (cell actor)
|
||
ASTROCYTE rest-permission + renormalization / reallocation (cell actor)
|
||
↓ signal (NEURON over soma/pre/post/dend/axon ; ASTROCYTE over astrosynapses)
|
||
COMPONENTS soma · pre · post · dend · axon · astrosynapse — each restructures ITSELF
|
||
when its own DAY/NIGHT transition (above) grants the window
|
||
[ ASSEMBLY / NETWORK ] replay_reweight arrives as an EXTERNAL signal (like dopamine/glucose)
|
||
```
|
||
|
||
The two cell actors are structurally identical — same integrate-and-broadcast role, different
|
||
constituents and conserved quantity: NEURON conserves activity/weight, ASTROCYTE conserves
|
||
territory demand/load. Both have their own DAY (integrate, allocate in the gaps) and NIGHT
|
||
(broadcast the restructuring window). The HYPOTHALAMUS alone has no night: it runs CONTINUOUS,
|
||
always integrating fatigue and emitting sleep-pressure, spanning every other actor's day and
|
||
night — the clock that never sleeps.
|
||
|
||
NIGHT IS PHASED, AND OCCUPANCY RESETS. When a component is in NIGHT, early cycles DOWNSCALE
|
||
(occupancy filled during its day — VGCC_active, AMPA_surface, possible_tag — driven toward
|
||
baseline by multiplicative-global scaling broadcast by the neuron; total weight renormalized),
|
||
later cycles COMMIT (survivors' tags build ceilings). The rule the phasing enforces: WHAT
|
||
PERSISTS ACROSS A NIGHT MUST HAVE EARNED PERSISTENCE — occupancy that earned no tag returns to
|
||
baseline; only ceilings carry forward. A tagged synapse starts the next day strong because its
|
||
ceiling was raised, not because its transient occupancy was spared.
|
||
|
||
---
|
||
|
||
## Conventions
|
||
|
||
```
|
||
SCOPE = {DAY, NIGHT} CONTEXT = {AP, NOT_AP, NOT_SPIKE_TRAIN, bAP, NOT_bAP, CONTINUOUS}
|
||
|
||
THE RING (see logic_principles "The Three-Phase Ring"): ACTION → EVALUATION → PREPARATION
|
||
ACTION lateral, punctate — the component's defining act; deposits the fast trace.
|
||
ALWAYS LOCAL to the acting component (cannot be done on another's behalf).
|
||
EVALUATION local — read the fresh trace, climb the ladder toward the tag (the token for NIGHT).
|
||
PREPARATION vertical — settle pools/gates forward, read what descended, ready the next action.
|
||
Phase edges are event/decay-timed, not clocked. EVALUATION and PREPARATION may be LOCAL or
|
||
CONTEXTUAL (supplied by a neighbor/higher component); ACTION is always local. A near-pure-action
|
||
component (e.g. a channel) is written ACTION-only, its eval/prep noted as contextual.
|
||
|
||
CONTEXT LICENSES PHASE (context = the imposed condition; phase = the work it permits).
|
||
The context is what other components impose (a spike delivered or not, a train present or not);
|
||
the phase annotation says which ring-work runs. Contexts can NEST, and nested contexts run
|
||
ON TOP of their parent — a behavior is written in exactly ONE context, so nothing double-runs:
|
||
AP spike this step → ACTION
|
||
NOT_AP no spike this step → FAST eval + FAST prep (in-train gaps AND quiet)
|
||
NOT_SPIKE_TRAIN no spike AND no train ⊂ NOT_AP → adds SLOW eval + SLOW prep (runs on top of NOT_AP)
|
||
A process runs in the SHORTEST quiet its timescale fits: fast-trace decay and partial pool refill
|
||
in NOT_AP (they ride the train and set short-term depression); tag formation, full refill, and
|
||
occupancy read-out in NOT_SPIKE_TRAIN. (Components without trains use only their ACTION / quiet
|
||
contexts, e.g. bAP / NOT_bAP, or continuous graded activity.)
|
||
|
||
VARIABLE TIERS (timescale = meaning; see logic_principles "The Timescale Ladder")
|
||
FAST (ms–s) immediate response fast_trace
|
||
MEDIUM (s–min) occupancy + evidence possible_tag · endurance_need · VGCC_active · AMPA_surface · RRP
|
||
SLOW (hr) consolidation bridge tag
|
||
─────────────────────────────────────────────────────────────────────────────
|
||
PERSISTENT (NIGHT) capacity (the ceilings) structure · budget_ceiling
|
||
energy (not recoverable) · material (recoverable)
|
||
|
||
DAY budget · fast_trace · possible_tag · endurance_need
|
||
BRIDGE tag (POST: CANDIDATE→STABLE)
|
||
NIGHT energy (not recoverable) · material (recoverable) · structure · budget_ceiling
|
||
|
||
LOCALITY only local state + arrived signals; no component reads another's internal state.
|
||
|
||
CLEFT MESSAGE CHANNELS SHIPMENT CHANNELS (transit-delayed)
|
||
glutamate PRE → POST, ASTRO soma_ship_dend SOMA→DEND
|
||
astro_Dserine ASTRO → POST soma_ship_axon SOMA→AXON
|
||
retro_NO POST → PRE (+) dend_ship_post DEND→POST
|
||
retro_eCB POST → PRE (−) axon_ship_pre AXON→PRE
|
||
```
|
||
|
||
---
|
||
|
||
## Primitives (return the increment; caller applies it)
|
||
|
||
```
|
||
sat(x, K) = x / (K + x)
|
||
|
||
fill(pool, ceiling, rate, cost, budget) -> amount: // PRIVATE reserve, rate-limited (implicit τ)
|
||
amount = min(rate, ceiling - pool)·Δt; budget -= amount·cost; return amount
|
||
|
||
refill(c from supply S) -> amount: // CONTESTED supply, gap-bounded
|
||
demand = c.budget_ceiling - c.budget
|
||
factor = min(1, S / (Σ demand over components on S + ε)); S -= demand·factor
|
||
return demand·factor
|
||
|
||
ship(from_budget, demand_sig, frac, cost) -> amount: // emit into transit (not to target directly)
|
||
amount = min(from_budget·frac, demand_sig); from_budget -= amount·(1+ship_cost); return amount
|
||
|
||
transit(channel, τ_transport) -> arrival: // delivers in-transit cargo over τ
|
||
arrival = channel·(Δt/τ_transport); channel -= arrival; return arrival
|
||
```
|
||
|
||
---
|
||
|
||
## SHARED parameters
|
||
|
||
```
|
||
dopamine NE ACh // organism broadcasts (external)
|
||
replay_reweight[·] // assembly/network replay re-weighting (external, NIGHT)
|
||
glucose geometry // physical (external)
|
||
sleep_pressure // emitted by HYPOTHALAMUS, read by all (the day/night signal)
|
||
rest_thr sleep_thr wake_thr // per-component DAY↔NIGHT transition thresholds
|
||
elig dop_thr tag_thr tag_expiry // strength gates (universal)
|
||
traj_thr endur_thr // endurance gates (universal)
|
||
ship_cost // transport overhead (all shipments)
|
||
{dend,axon,pre,post}_ship_frac // DAY budget-shipment fractions
|
||
τ_transport_{dend,axon,spine,bouton} // shipment transit times (distance-dependent)
|
||
ε
|
||
```
|
||
|
||
## NIGHT parameters (consolidation only)
|
||
|
||
```
|
||
slot_batch cap_batch f_cap // per-CYCLE commit sizes / endurance fraction
|
||
night_energy_ceiling // total energy a single night can spend (supply bound)
|
||
Δt_cycle // duration of one NIGHT cycle
|
||
maint_frac cap_frac // maintenance allocation
|
||
decay_rate capacity_decay_rate recycle // passive ceiling decay + material recovery
|
||
homeostatic_ceiling coherence_factor assembly_cost biogenesis_cost maint_cost
|
||
f_dend f_axon f_spine f_bouton // per-cycle material/energy ship fractions (down the chain)
|
||
downscale_factor // per-early-cycle multiplicative occupancy reset (<1)
|
||
neuron_weight_ceiling // the cell's total-weight budget (renormalization target)
|
||
early_phase_frac // fraction of night cycles that are DOWNSCALE phase
|
||
```
|
||
|
||
---
|
||
---
|
||
# LOCAL COMPONENTS
|
||
> Each behaves by its DAY and restructures by its NIGHT — per-component emergent states
|
||
> (see Conventions: the transition rule). `DAY | …` / `NIGHT | …` label local states, not a clock.
|
||
---
|
||
|
||
## PRE
|
||
|
||
The presynaptic bouton releases neurotransmitter and gathers evidence about whether that
|
||
release was worth strengthening and worth sustaining. Like every component it turns one ring —
|
||
ACTION → EVALUATION → 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 · EVALUATION (after the AP, trace fresh) — climb toward the tag.** Reading the fast trace,
|
||
the bouton accumulates eligibility (`possible_tag`) and, on the dopamine coincidence, the `tag` —
|
||
the inert token minted for the night. It never acts here; it lays down evidence.
|
||
|
||
**DAY · PREPARATION (trace decaying) — ready the next release.** The bouton latches the retrograde
|
||
messages, tightens its VGCC coupling from accumulated eligibility (reversible short-term
|
||
potentiation, no dopamine, bounded by structure — readiness, not evidence), refills budget and
|
||
vesicles *toward the next demand* (not a restoration — forward-facing), and lets its traces decay.
|
||
Preparation is the sole gateway to the next action.
|
||
|
||
**NIGHT — the ring turned inward.** ACTION is the coherence check (does post and astro concur this
|
||
change should be kept). EVALUATION is draw-and-commit: burn shipped material and energy into
|
||
**structure** (where a validated tag stood) or **budget capacity** (where fuel interrupted a
|
||
succeeding release), spending the tag — the token minted for the next day. PREPARATION is
|
||
make-room: take the descended constraint, recycle material from decayed ceilings, ready for the
|
||
next round. The bouton is not a sink — by night it emits inward and upward (fatigue, demand,
|
||
recycled material).
|
||
|
||
```
|
||
// 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 EVALUATION/PREPARATION; pools refill in 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 RING × CONTEXT (Option B: organize by imposed context, annotate with phase):
|
||
// AP → ACTION (release; deposit fast trace)
|
||
// NOT_AP → FAST eval + FAST prep (rides the train; sets short-term depression)
|
||
// NOT_SPIKE_TRAIN → SLOW eval + SLOW prep ⊂ NOT_AP (runs ON TOP of NOT_AP in sustained quiet)
|
||
// nested, not exclusive: each behavior in exactly ONE block, so nothing double-runs.
|
||
|
||
DAY | AP: // ACTION (lateral): release into cleft
|
||
// deposit the fast trace THIS action leaves (FAST · impulse)
|
||
pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike)
|
||
drive = sat(pre_fast_trace × VGCC_active, K_release) × (1 - retro_eCB_local)
|
||
if pre_budget < release_cost: // FUEL shortfall → endurance evidence
|
||
suppress(NT_flux)
|
||
if pre_fast_trace > traj_thr: // MEDIUM · accumulate
|
||
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
|
||
|
||
DAY | NOT_AP: // FAST eval + FAST prep (in-train gaps AND quiet)
|
||
retro_NO_local = retro_NO; retro_eCB_local = retro_eCB // latch arrived signals
|
||
// FAST EVAL: eligibility climbs from the fresh trace (MEDIUM · accumulate)
|
||
if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt
|
||
// FAST PREP: partial vesicle refill (release-vs-refill race → sets STD depth) + fast-trace decay
|
||
RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
|
||
pre_fast_trace *= decay(100ms) // FAST — rides the train
|
||
|
||
DAY | NOT_SPIKE_TRAIN: // SLOW eval + SLOW prep (sustained quiet; ⊂ NOT_AP)
|
||
// SLOW EVAL: dopamine-gated tag — the inert token minted for NIGHT (SLOW · accumulate)
|
||
if dopamine > dop_thr and pre_possible_tag > tag_thr:
|
||
pre_tag += dopamine × pre_possible_tag·Δt
|
||
// SLOW PREP: STP read-out (eligibility → coupling readiness; NO dopamine; drifts back)
|
||
if pre_possible_tag > stp_thr:
|
||
VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling)
|
||
else:
|
||
VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline) // STD = un-honored decay
|
||
// 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))
|
||
// medium/slow settle (fast-trace decay already ran in NOT_AP; not repeated here)
|
||
pre_possible_tag *= decay(s); pre_endurance_need *= decay(min) // MEDIUM
|
||
pre_tag *= decay(hr) // SLOW
|
||
dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s)
|
||
|
||
NIGHT · ACTION | coherence check: // lateral: does post & astro concur?
|
||
coh = coherence_signal // arrived verdict (pre+post+astro tags aligned)
|
||
// (this is the night's "release": signal the standing claim, read what returns; leaves coh as trace)
|
||
|
||
NIGHT · EVALUATION | draw & commit (only if coherent + permitted): // local: mint structure for next DAY
|
||
if rest_permission and pre_tag > tag_expiry:
|
||
Δ = min(slot_batch, pre_material, pre_energy·f_cap)
|
||
pre_structure += Δ × coh; pre_material -= Δ; pre_energy -= Δ·assembly_cost
|
||
pre_tag -= Δ // tag-as-fuel; energy burned only here (irreversible)
|
||
if rest_permission and pre_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap)
|
||
pre_budget_ceiling += Δ'; pre_material -= Δ'; pre_energy -= Δ'·biogenesis_cost
|
||
pre_endurance_need -= Δ'
|
||
// if not coherent / not permitted: draw nothing, hold the tag, leave resource for peers — defer
|
||
|
||
NIGHT · PREPARATION | make room: // vertical: take constraint, recycle, ready
|
||
// receive shipped batch for the next round (forward-facing)
|
||
pre_material += transit(pre_material_ship, τ_transport_bouton)
|
||
pre_energy += transit(pre_energy_ship, τ_transport_bouton)
|
||
// apply the descended constraint to MYSELF (neuron only broadcasts; I scale myself)
|
||
VGCC_active *= occupancy_downscale; pre_possible_tag *= occupancy_downscale
|
||
if renorm_signal arrived:
|
||
freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal
|
||
emit(freed → recycled material pool)
|
||
// recycle material from decayed ceilings; unmaintained ceilings drift; emit inward/upward
|
||
pre_material += pre_ceiling_shrinkage·recycle // energy NOT recovered
|
||
pre_structure -= decay_rate·Δt_cycle; pre_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
pre_structure += min(pre_maint, maint_cost); pre_budget_ceiling += min(pre_cap_maint, cap_cost)
|
||
pre_tag *= decay(slow); pre_endurance_need *= decay(slow)
|
||
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 and PREPARATION share the quiet.** Evaluation reads the calcium trace and, on the
|
||
dopamine coincidence, climbs to the tag. Preparation fills AMPA surface toward the slot ceiling
|
||
from accumulated calcium (short-term potentiation, no dopamine), refills budget toward next demand,
|
||
and lets traces settle. A fuel shortfall while calcium was climbing toward a tag is endurance
|
||
evidence; a surface already at its ceiling is a structural limit, not endurance.
|
||
|
||
**During NIGHT — the spine's ceilings are rewritten.** The ring turned inward: coherence check,
|
||
draw-and-commit (structure where a validated tag stood — with a coherence bonus when pre, post, and
|
||
astro all tagged the same synapse — or budget capacity where fuel interrupted a climbing trajectory),
|
||
make-room. Both ceilings draw the same finite pool and compete; unmaintained ceilings drift down.
|
||
|
||
```
|
||
// PARAMETERS K_AMPA · AMPA_Ca · AMPA_cost · NMDA_cost · bAP_cost · pka_cost · traffic_cost
|
||
// 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.
|
||
// 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 | bAP: // ACTION (vertical): soma's spike confirms
|
||
Vm += bAP_depol × dend_structure.bAP_fidelity; post_budget -= bAP_cost
|
||
if post_possible_tag > Ca_TAG: post_fast_trace += bAP_Ca_boost() // amplify only if candidate present
|
||
|
||
DAY | NOT_bAP: // ACTION(integrate) then EVAL + PREP
|
||
// ── ACTION (lateral): integrate arrived input, detect instantaneous coincidences, emit retro ──
|
||
a = sat(glutamate, K_AMPA)
|
||
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
|
||
// ── EVALUATION (local): climb toward the tag; dopamine is the integrable coincidence (#3) ──
|
||
if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace; post_budget -= pka_cost
|
||
if dopamine > dop_thr and post_possible_tag > tag_thr:
|
||
post_tag += dopamine × post_possible_tag // token minted for NIGHT
|
||
// ── PREPARATION (vertical): STP fill / STD drift, refill toward next demand, settle ──
|
||
if post_fast_trace > Ca_STP:
|
||
if post_budget < traffic_cost: // FUEL shortfall → endurance
|
||
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_fast_trace *= decay(ms) // FAST
|
||
post_possible_tag *= decay(min); post_endurance_need *= decay(min) // MEDIUM
|
||
post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals
|
||
|
||
NIGHT | cycle: // leaf of DAY chain, but emits inward/upward by NIGHT
|
||
// RECEIVE batch arrived from DEND (material) + SOMA (energy) this cycle
|
||
post_material += transit(post_material_ship, τ_transport_spine)
|
||
post_energy += transit(post_energy_ship, τ_transport_spine)
|
||
// TRACE read standing demand (post_tag → structure ; post_endurance_need → budget_ceiling)
|
||
// ADJUST coherence applies to POST (synaptic component)
|
||
coh = coherence_signal
|
||
// BEHAVE commit batches; spend tag/need as fuel
|
||
if post_tag > tag_expiry:
|
||
Δ = min(slot_batch, post_material, post_energy·f_cap)
|
||
post_structure += Δ × coh; post_material -= Δ; post_energy -= Δ·assembly_cost
|
||
post_tag -= Δ
|
||
if post_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, post_material·f_cap, post_energy·f_cap)
|
||
post_budget_ceiling += Δ'; post_material -= Δ'; post_energy -= Δ'·biogenesis_cost
|
||
post_endurance_need -= Δ'
|
||
// EMIT (none — spine is a leaf)
|
||
// RECOVER reclaim material from decayed ceilings
|
||
post_material += post_ceiling_shrinkage·recycle // energy NOT recovered
|
||
// DECAY
|
||
post_structure -= decay_rate·Δt_cycle; post_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
post_structure += min(post_maint, maint_cost); post_budget_ceiling += min(post_cap_maint, cap_cost)
|
||
post_tag *= decay(slow); post_endurance_need *= decay(slow)
|
||
```
|
||
|
||
---
|
||
|
||
## DEND
|
||
|
||
The dendritic branch is the postsynapse's supply line and the neuron's input integrator. It
|
||
carries the back-propagating spike out to its spines, integrates their voltages toward the
|
||
soma, and ships material and budget to the spines it supports. Its behavior unfolds across two
|
||
DAY contexts and the NIGHT scope.
|
||
|
||
**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the
|
||
branch propagates the back-propagating spike toward its spines, with a fidelity that attenuates
|
||
with distance (distal spines get weaker confirmation, are harder to potentiate). It deposits
|
||
branch calcium and integrates its spines' voltages into a single branch signal sent on to the
|
||
soma. A fuel shortfall that cuts propagation short while the branch was strongly active is
|
||
endurance evidence; propagation that simply attenuates with distance is a structural limit, not
|
||
endurance.
|
||
|
||
**During DAY, during NOT_bAP — the branch consolidates, supplies, and recovers.** It maintains
|
||
its tag toward consolidation, lowers its commit threshold under acetylcholine (attention),
|
||
ships budget down to its spines (demand-weighted by their tags), runs local translation if
|
||
tagged, refills its own budget from astrocytic lactate and somatic shipment, and lets its
|
||
traces decay.
|
||
|
||
**During NIGHT — the branch's ceilings are rewritten.** NIGHT raises **structure** (bAP
|
||
fidelity, translation capacity) where a validated tag accumulated and **budget capacity** where
|
||
fuel interrupted strong branch activity, both from the shared pool, both competing; unmaintained
|
||
ceilings drift down.
|
||
|
||
```
|
||
// PARAMETERS prop_cost · branch_Ca_cost · integrate_cost · translate_cost · ACh_gain
|
||
// INTERFACE
|
||
// EMIT bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST
|
||
// RECEIVE (signals) SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
|
||
// READ SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
|
||
// OWN dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
|
||
// SUPPLY astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
|
||
// NOTE DEND endurance fires only on FUEL-limited propagation, not structural attenuation;
|
||
// own-state proxy (strong branch activity); no arrived feedback term.
|
||
|
||
// RING × CONTEXT: bAP → ACTION(propagate+integrate) + EVAL | NOT_bAP → EVAL + PREP (ship/refill/settle)
|
||
|
||
DAY | bAP: // ACTION (lateral/vertical): propagate + integrate
|
||
// ADJUST (propagation strength from structure — inside propagate())
|
||
// BEHAVE (propagate bAP; distinguish fuel-limited vs structure-limited shortfall)
|
||
if dend_budget < prop_cost:
|
||
// FUEL shortfall → endurance (branch was strongly active)
|
||
if dend_fast_trace > traj_thr:
|
||
dend_endurance_need += dend_fast_trace
|
||
bAP_local, reached = propagate_partial(dend_budget)
|
||
else:
|
||
bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry)
|
||
// reached < full here is structural attenuation (distance), NOT endurance
|
||
dend_budget -= prop_cost × reached
|
||
// TRACE (deposit fast trace THIS action leaves)
|
||
dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost
|
||
// EMIT (integrated voltage to soma ; propagated bAP already reached spines)
|
||
branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost
|
||
|
||
DAY | NOT_bAP: // EVALUATION (climb to tag) + PREPARATION (ship/refill/settle)
|
||
// EVAL: strength climb
|
||
if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
|
||
if dopamine > dop_thr and dend_possible_tag > tag_thr:
|
||
dend_tag += dopamine × dend_possible_tag // token minted for NIGHT
|
||
// PREP: attention lowers commit threshold; local translation; ship to spines; refill; settle
|
||
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))
|
||
// DECAY
|
||
// FAST (ms–s)
|
||
dend_fast_trace *= decay(300ms)
|
||
// MEDIUM (s–min)
|
||
dend_possible_tag *= decay(s); dend_endurance_need *= decay(min)
|
||
// SLOW (hr)
|
||
dend_tag *= decay(hr)
|
||
// (PERSISTENT: dend_structure, dend_budget_ceiling — no DAY decay; NIGHT only)
|
||
|
||
NIGHT | cycle: // intermediate node (relays down to POST)
|
||
// RECEIVE batch arrived from SOMA this cycle
|
||
dend_material += transit(soma_material_to_dend, τ_transport_dend)
|
||
dend_energy += transit(soma_energy_to_dend, τ_transport_dend)
|
||
// TRACE read standing demand (dend_tag → structure ; dend_endurance_need → budget_ceiling)
|
||
// ADJUST (no coherence — DEND is not a synaptic component)
|
||
// BEHAVE commit batches; spend tag/need as fuel
|
||
if dend_tag > tag_expiry:
|
||
Δ = min(slot_batch, dend_material, dend_energy·f_cap)
|
||
dend_structure += Δ; dend_material -= Δ; dend_energy -= Δ·assembly_cost; dend_tag -= Δ
|
||
if dend_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, dend_material·f_cap, dend_energy·f_cap)
|
||
dend_budget_ceiling += Δ'; dend_material -= Δ'; dend_energy -= Δ'·biogenesis_cost
|
||
dend_endurance_need -= Δ'
|
||
// EMIT ship remaining batch one hop down to POST (demand = post tag)
|
||
post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost)
|
||
post_energy_ship += ship(dend_energy, post_demand, f_spine, ship_cost)
|
||
// RECOVER reclaim material from decayed ceilings
|
||
dend_material += dend_ceiling_shrinkage·recycle // energy NOT recovered
|
||
// DECAY
|
||
dend_structure -= decay_rate·Δt_cycle; dend_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
dend_structure += min(dend_maint, maint_cost); dend_budget_ceiling += min(dend_cap_maint, cap_cost)
|
||
dend_tag *= decay(slow); dend_endurance_need *= decay(slow)
|
||
```
|
||
|
||
---
|
||
|
||
## SOMA
|
||
|
||
The soma is the neuron's integrating center and the root of its structural material. It sums
|
||
the branch inputs, fires when they exceed a threshold it sets from its own adaptation and the
|
||
neuromodulators, and ships material and budget out to the dendrites and axon. Its timing —
|
||
refractoriness, adaptation, rhythm alignment — emerges bottom-up from local traces, never from
|
||
a represented clock. Its behavior unfolds across two DAY contexts and the NIGHT scope.
|
||
|
||
**During DAY, during AP — the soma integrates and fires.** It computes its firing threshold
|
||
from its baseline (structure), its accumulated adaptation, and the neuromodulators, and checks
|
||
its refractory state; if the integrated branch input clears the threshold and fuel allows, it
|
||
fires. One spike deposits three traces at three timescales — sodium inactivation (refractory),
|
||
slow-potassium adaptation (threshold rise), and nuclear calcium (toward CREB and the tag). A
|
||
fuel shortfall while nuclear calcium was climbing is endurance evidence; being refractory or
|
||
sub-threshold is a timing limit, not endurance.
|
||
|
||
**During DAY, during NOT_AP — the soma recovers, aligns, and supplies.** It self-replenishes
|
||
from its own mitochondria (its private root), integrates the latest branch inputs, deposits a
|
||
refractory-alignment trace when suprathreshold input arrived during its refractory period (so it
|
||
aligns to its input rhythm bottom-up), ships budget to dendrites and axon (demand-weighted by
|
||
their tags), recovers from refractoriness at a rate its alignment trace speeds up, and lets its
|
||
traces decay.
|
||
|
||
**During NIGHT — the soma's ceilings are rewritten, and it gates the whole neuron's material.**
|
||
NIGHT raises **structure** (excitability, synthesis capacity) and **budget capacity** from the
|
||
shared pool; crucially the soma's own tag gates CREB-driven synthesis, so how much material all
|
||
downstream components receive depends on the soma having been tagged.
|
||
|
||
```
|
||
// PARAMETERS ap_cost · nuclear_cost · creb_cost · mito_output · inactivation · ap_amp · ap_contrib
|
||
// base_recovery · τ_Na · τ_adapt · τ_nuclear · τ_align
|
||
// INTERFACE
|
||
// EMIT fired → AXON (propagate) + DEND (bAP) ; soma_ship_dend → DEND ; soma_ship_axon → AXON
|
||
// RECEIVE (signals) branch_Vm ← DEND ; dopamine ; NE ; ACh
|
||
// READ dopamine ; NE ; ACh
|
||
// OWN soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling
|
||
// SUPPLY self (mitochondria, ROOT — private)
|
||
// NOTE SOMA endurance fires only on FUEL shortfall (budget < ap_cost);
|
||
// refractory / sub-threshold are timing limits, not endurance. Own-state proxy.
|
||
|
||
// RING × CONTEXT: AP → ACTION(fire) + EVAL(nuclear Ca→tag) | NOT_AP → EVAL + PREP
|
||
// the ONE spike's fast trace feeds TWO destinations: nuclear-Ca → tag (EVALUATION, cross-scope),
|
||
// and inactivation/adaptation/alignment → next-spike timing (PREPARATION, this scope).
|
||
|
||
DAY | AP: // ACTION (lateral): fire; then EVAL climbs to tag
|
||
// ADJUST (threshold from structure + adaptation + neuromodulators ; refractory gate)
|
||
threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh)
|
||
can_fire = soma_Na_inactivation < inactivation
|
||
// ACTION (fire if able)
|
||
if branch_Vm > threshold and can_fire:
|
||
if soma_budget < ap_cost:
|
||
// FUEL shortfall → endurance (firing was approaching CREB)
|
||
if soma_fast_trace > traj_thr and soma_fast_trace_rising:
|
||
soma_endurance_need += soma_fast_trace
|
||
exit
|
||
fired = True; soma_budget -= ap_cost // EMIT fired → AXON, DEND
|
||
// deposit the THREE traces from one AP: nuclear-Ca (→EVAL) + adaptation/inactivation (→PREP)
|
||
soma_Na_inactivation += ap_amp // PREP seed: refractory (emergent)
|
||
soma_adaptation += ap_contrib // PREP seed: threshold rise
|
||
soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // EVAL seed
|
||
// EVALUATION: strength climb toward the tag (cross-scope token for NIGHT)
|
||
if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
|
||
if dopamine > dop_thr and soma_possible_tag > tag_thr:
|
||
soma_tag += dopamine × soma_possible_tag
|
||
soma_budget -= creb_cost
|
||
soma_emitted_activity += 1; soma_emitted_structure = soma_structure // NEURON sums these
|
||
|
||
DAY | NOT_AP: // EVAL (align) + PREP (recover timing, ship, refill)
|
||
branch_Vm = integrate(DEND.branch_Vm, branches) // RECEIVE latest branch input
|
||
// PREP seed: refractory alignment (suprathreshold input during refractory → tune next-spike timing)
|
||
if branch_Vm > threshold and soma_Na_inactivation > inactivation:
|
||
soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
|
||
// PREP: ship downstream, self-replenish from root, recover refractoriness (sped by alignment)
|
||
soma_ship_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost)
|
||
soma_ship_axon = ship(soma_budget, axon_demand, axon_ship_frac, ship_cost)
|
||
soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
|
||
recovery = base_recovery × (1 + soma_refractory_alignment)
|
||
soma_Na_inactivation *= decay(τ_Na / recovery)
|
||
// DECAY
|
||
// FAST (ms–s) — refractory + nuclear-Ca + alignment
|
||
soma_fast_trace *= decay(τ_nuclear); soma_refractory_alignment *= decay(τ_align) // self-limiting
|
||
// MEDIUM (s–min) — adaptation + tagging evidence
|
||
soma_adaptation *= decay(τ_adapt)
|
||
soma_possible_tag *= decay(s); soma_endurance_need *= decay(min)
|
||
// SLOW (hr)
|
||
soma_tag *= decay(hr); dopamine *= decay(ms)
|
||
|
||
NIGHT | cycle: // ROOT (neuronal material) — produces each cycle
|
||
// RECEIVE = PRODUCTION: synthesize this cycle's batch, gated by own tag, capped externally
|
||
soma_material += CREB_synth(soma_tag)·Δt_cycle // material — recoverable
|
||
soma_energy += mito_synth()·Δt_cycle // energy — NOT recoverable, bounded by night budget
|
||
night_energy_spent += mito_synth()·Δt_cycle // track against night supply ceiling
|
||
// TRACE read standing demand (soma_tag → structure ; soma_endurance_need → budget_ceiling)
|
||
// ADJUST (no coherence — SOMA is not a synaptic component)
|
||
// BEHAVE commit own batches
|
||
if soma_tag > tag_expiry:
|
||
Δ = min(slot_batch, soma_material, soma_energy·f_cap)
|
||
soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost; soma_tag -= Δ
|
||
if soma_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap)
|
||
soma_budget_ceiling += Δ'; soma_material -= Δ'; soma_energy -= Δ'·biogenesis_cost
|
||
soma_endurance_need -= Δ'
|
||
// EMIT ship batches one hop down to DEND and AXON (demand = propagated tags)
|
||
soma_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost)
|
||
soma_material_to_axon += ship(soma_material, axon_demand, f_axon, ship_cost)
|
||
soma_energy_to_dend += ship(soma_energy, dend_demand, f_dend, ship_cost)
|
||
soma_energy_to_axon += ship(soma_energy, axon_demand, f_axon, ship_cost)
|
||
// RECOVER reclaim material from decayed ceilings (own + returned from downstream)
|
||
soma_material += soma_ceiling_shrinkage·recycle
|
||
// DECAY
|
||
soma_structure -= decay_rate·Δt_cycle; soma_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
soma_structure += min(soma_maint, maint_cost); soma_budget_ceiling += min(soma_cap_maint, cap_cost)
|
||
soma_tag *= decay(slow); soma_endurance_need *= decay(slow)
|
||
```
|
||
|
||
---
|
||
|
||
## AXON
|
||
|
||
The axon carries the soma's spike out to its boutons and is the presynapse's supply line. It
|
||
propagates reliably or not depending on its myelination and its recent load, and ships material
|
||
and budget to the boutons. Its behavior unfolds across two DAY contexts and the NIGHT scope.
|
||
|
||
**During DAY, during AP — the axon propagates the spike.** Reliability is set by structure
|
||
(myelination) and degraded by recent high-frequency load (sodium inactivation at branch points —
|
||
axonal short-term depression). A fuel shortfall while carrying a strong train is endurance
|
||
evidence; load-driven failure is short-term depression, a consequence, not endurance.
|
||
|
||
**During DAY, during NOT_AP — the axon supplies and recovers.** It maintains its tag, ships
|
||
budget to its boutons (demand-weighted by their tags), refills its own budget from somatic
|
||
shipment and astrocytic lactate, and lets its traces decay.
|
||
|
||
**During NIGHT — the axon's ceilings are rewritten.** NIGHT raises **structure** (myelination,
|
||
transport capacity) and **budget capacity** from the shared pool, both competing; unmaintained
|
||
ceilings drift down.
|
||
|
||
```
|
||
// PARAMETERS prop_cost · budget_factor
|
||
// INTERFACE
|
||
// EMIT APs_delivered → PRE (propagation) ; axon_ship_pre → PRE
|
||
// RECEIVE (signals) SOMA.fired ; dopamine
|
||
// READ SOMA.fired ; dopamine
|
||
// OWN axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling
|
||
// SUPPLY soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
|
||
// NOTE AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace)
|
||
// is axonal STD (a consequence), not endurance. Own-state proxy.
|
||
|
||
// RING × CONTEXT: AP → ACTION(propagate) | NOT_AP → EVAL(climb to tag) + PREP(ship/refill/settle)
|
||
|
||
DAY | AP: // ACTION (lateral): propagate the spike
|
||
// ADJUST (reliability from structure − load-driven failure)
|
||
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance
|
||
if axon_budget < prop_cost:
|
||
reliability *= budget_factor
|
||
if axon_fast_trace > traj_thr: // FUEL-limited → endurance
|
||
axon_endurance_need += axon_fast_trace
|
||
delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT delivered → boutons
|
||
axon_fast_trace += delivered; axon_fast_trace *= decay(s) // deposit fast trace
|
||
|
||
DAY | NOT_AP: // EVALUATION (climb to tag) + PREPARATION
|
||
// EVAL: strength climb → token for NIGHT
|
||
if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
|
||
if dopamine > dop_thr and axon_possible_tag > tag_thr:
|
||
axon_tag += dopamine × axon_possible_tag
|
||
// PREP: ship to boutons, refill toward next demand, settle
|
||
axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost)
|
||
axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
|
||
// DECAY
|
||
// FAST (ms–s)
|
||
axon_fast_trace *= decay(s)
|
||
// MEDIUM (s–min)
|
||
axon_possible_tag *= decay(s); axon_endurance_need *= decay(min)
|
||
// SLOW (hr)
|
||
axon_tag *= decay(hr)
|
||
|
||
NIGHT | cycle: // intermediate node (relays down to PRE)
|
||
// RECEIVE batch arrived from SOMA this cycle
|
||
axon_material += transit(soma_material_to_axon, τ_transport_dend)
|
||
axon_energy += transit(soma_energy_to_axon, τ_transport_dend)
|
||
// TRACE read standing demand (axon_tag → structure ; axon_endurance_need → budget_ceiling)
|
||
// ADJUST (no coherence — AXON is not a synaptic component)
|
||
// BEHAVE commit batches; spend tag/need as fuel
|
||
if axon_tag > tag_expiry:
|
||
Δ = min(slot_batch, axon_material, axon_energy·f_cap)
|
||
axon_structure += Δ; axon_material -= Δ; axon_energy -= Δ·assembly_cost; axon_tag -= Δ
|
||
if axon_endurance_need > endur_thr:
|
||
Δ' = min(cap_batch, axon_material·f_cap, axon_energy·f_cap)
|
||
axon_budget_ceiling += Δ'; axon_material -= Δ'; axon_energy -= Δ'·biogenesis_cost
|
||
axon_endurance_need -= Δ'
|
||
// EMIT ship remaining batch one hop down to PRE (demand = pre tag)
|
||
pre_material_ship += ship(axon_material, pre_demand, f_bouton, ship_cost)
|
||
pre_energy_ship += ship(axon_energy, pre_demand, f_bouton, ship_cost)
|
||
// RECOVER reclaim material from decayed ceilings
|
||
axon_material += axon_ceiling_shrinkage·recycle // energy NOT recovered
|
||
// DECAY
|
||
axon_structure -= decay_rate·Δt_cycle; axon_budget_ceiling -= capacity_decay_rate·Δt_cycle
|
||
axon_structure += min(axon_maint, maint_cost); axon_budget_ceiling += min(axon_cap_maint, cap_cost)
|
||
axon_tag *= decay(slow); axon_endurance_need *= decay(slow)
|
||
```
|
||
|
||
---
|
||
|
||
## ASTROSYNAPSE
|
||
|
||
> The astrosynapse is the perisynaptic astrocytic process — the LOCAL component at one synapse,
|
||
> the astroglial peer of pre/post and a constituent of the ASTROCYTE actor (which integrates
|
||
> across all of them, just as the NEURON integrates over the soma). The astrosynapse behaves
|
||
> locally here; the astrocyte integrates and broadcasts (see CELL ACTORS).
|
||
|
||
The astrosynapse is the synapse's gatekeeper and energy hub. It clears glutamate, supplies the
|
||
D-serine that gates postsynaptic NMDA, and distributes lactate across its territory by demand.
|
||
Unlike the others it runs in a single continuous context rather than spiking, and its structure
|
||
reshapes the synapse's operating point rather than just its range.
|
||
|
||
**During DAY, continuously — the astrosynapse clears, gates, and fuels.** It produces energy at
|
||
its cell body (glycolysis from glucose, the system's energy root), then allocates lactate across
|
||
its astrosynapses weighted by each one's clearance demand. At each astrosynapse it clears
|
||
spillover glutamate (EAAT) and supplies tonic D-serine; when spillover is high it adds a
|
||
demand-driven D-serine pulse, brakes nothing of the presynapse directly (the presynaptic brake
|
||
is PRE reading its own cleft), deposits its calcium trace, and accumulates a dopamine-gated tag.
|
||
A D-serine pulse cut short by low budget while demand was high is endurance evidence; one cut
|
||
short by precursor/material exhaustion is a material limit, not endurance. Excess overflow
|
||
triggers the protective shockwave lockdown.
|
||
|
||
**During NIGHT — the astrosynapse's ceilings are rewritten.** NIGHT raises **structure**
|
||
(perisynaptic wrap, EAAT density, tonic D-serine) where a validated tag accumulated and **budget
|
||
capacity** where budget-limited synthesis recurred; astro_structure is self-reinforcing in both
|
||
directions, so it amplifies whatever trajectory the synapse is already on.
|
||
|
||
```
|
||
// PARAMETERS K_Dserine · Ds_max · Ds_frac · Ds_cost · EAAT_cost · lactate_cost · spillover · overload
|
||
// INTERFACE
|
||
// EMIT astro_lactate[i] → pre/post/dend budgets ; astro_Dserine[i] → POST (gate)
|
||
// RECEIVE (signals) glutamate ← PRE (clearance + spillover) ; dopamine
|
||
// READ glutamate ; dopamine
|
||
// OWN astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling
|
||
// SUPPLY glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
|
||
// NOTE ASTRO endurance fires on BUDGET-limited synthesis (got<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·Δt
|
||
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 | cycle: // ROOT (synaptic energy + ECM) — produces each cycle
|
||
// RECEIVE = PRODUCTION: glycolysis + ECM synthesis this cycle, capped by glucose
|
||
astro_central_energy += overnight_glycolysis(glucose)·Δt_cycle // energy — NOT recoverable
|
||
astro_central_material += astro_cellbody_synth()·Δt_cycle // material — recoverable
|
||
night_energy_spent += overnight_glycolysis(glucose)·Δt_cycle
|
||
// ADJUST tag-weighted shares across the territory
|
||
W = Σ astro_tag[i] over astro_tag[i] > tag_expiry
|
||
// EMIT distribute this cycle's batch to astrosynapses (demand = own tag)
|
||
for each i with astro_tag[i] > tag_expiry:
|
||
w = astro_tag[i]/W
|
||
astro_energy[i] += astro_central_energy·w
|
||
astro_material[i] += astro_central_material·w
|
||
// BEHAVE each astrosynapse commits; spend tag/need as fuel (coherence applies — synaptic)
|
||
for each astrosynapse i:
|
||
coh = coherence_signal[i]
|
||
if astro_tag[i] > tag_expiry:
|
||
Δ = min(slot_batch, astro_material[i], astro_energy[i]·f_cap)
|
||
astro_structure[i] += Δ × coh // self-reinforcing both directions
|
||
astro_material[i] -= Δ; astro_energy[i] -= Δ·assembly_cost; astro_tag[i] -= Δ
|
||
if astro_endurance_need[i] > endur_thr:
|
||
Δ' = min(cap_batch, astro_material[i]·f_cap, astro_energy[i]·f_cap)
|
||
astro_budget_ceiling[i] += Δ'; astro_material[i] -= Δ'
|
||
astro_energy[i] -= Δ'·biogenesis_cost; astro_endurance_need[i] -= Δ'
|
||
// RECOVER reclaim material from decayed ceilings
|
||
astro_central_material += astro_ceiling_shrinkage·recycle // energy NOT recovered
|
||
// DECAY
|
||
for each i:
|
||
astro_structure[i] -= decay_rate·Δt_cycle; astro_budget_ceiling[i] -= capacity_decay_rate·Δt_cycle
|
||
astro_structure[i] += min(astro_maint[i], maint_cost)
|
||
astro_budget_ceiling[i] += min(astro_cap_maint[i], cap_cost)
|
||
astro_tag[i] *= decay(slow); astro_endurance_need[i] *= decay(slow)
|
||
```
|
||
|
||
---
|
||
|
||
## Special — Shockwave Lockdown
|
||
|
||
```
|
||
DAY or NIGHT | OVERLOAD:
|
||
Vm = HYPERPOLARIZED; AMPA_surface = mass_internalize() → post reserve
|
||
axon_fast_trace += overdrive(); astro_central_budget -= emergency_cost
|
||
```
|
||
|
||
---
|
||
---
|
||
> NIGHT-BLOCK UNIFORMITY. PRE's `NIGHT | cycle` above is the worked exemplar. POST, DEND, SOMA,
|
||
> AXON, and ASTROSYNAPSE follow the identical pattern, shown in their blocks in abbreviated form:
|
||
> (a) all commits are gated by `rest_permission` (arrived from the cell actor); (b) on a
|
||
> DOWNSCALE-phase signal each self-resets its own occupancy (`*_occupancy *= occupancy_downscale`)
|
||
> and self-renormalizes its own structure (`*_structure *= renorm_signal`, emitting the freed
|
||
> material) — the cell actor only broadcasts, the component scales itself; (c) each emits its own
|
||
> fatigue upward. Roots (SOMA material, ASTROSYNAPSE/ASTROCYTE energy) additionally PRODUCE their
|
||
> batch each cycle and track `night_energy_spent`. Only the occupancy-holders (PRE: VGCC_active,
|
||
> POST: AMPA_surface) carry the self-downscale line; the rest carry only the structure renorm.
|
||
|
||
---
|
||
---
|
||
# CELL ACTORS — NEURON and ASTROCYTE
|
||
Two structurally identical peers. Each integrates its constituents' EMITTED activity by its DAY
|
||
(never reading their interiors), detects when its aggregate has gone quiet, and BROADCASTS the
|
||
restructuring window + renormalization/reallocation by its NIGHT. Each component then restructures
|
||
ITSELF in response. The cell actor's own DAY/NIGHT follows the same transition rule, on its own
|
||
aggregate activity.
|
||
|
||
## NEURON
|
||
|
||
The neuron is the whole-cell actor over soma, pre, post, dend, axon. It cannot fire or release —
|
||
it integrates what its components emit and grants them the restructuring window none of them can
|
||
grant itself. The soma is one of its constituents, a peer of the bouton; the neuron is not the soma.
|
||
|
||
```
|
||
// PARAMETERS neuron_weight_ceiling · downscale_factor · early_phase_frac · rest_thr
|
||
// INTERFACE
|
||
// EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast)
|
||
// neuron_fatigue → HYPOTHALAMUS
|
||
// RECEIVE (signals) component activity emissions (summed) ; sleep_pressure ← HYPOTHALAMUS
|
||
// replay_reweight ← assembly/network (external)
|
||
// OWN neuron_activity · neuron_total_weight (aggregates aggregated from emissions)
|
||
// NOTE never reads a component interior; sums emitted activity, broadcasts signals only.
|
||
|
||
DAY | active: // (own_activity high → integrate only)
|
||
// TRACE integrate the cell's emitted activity + committed weight (aggregators)
|
||
neuron_activity += Σ component emitted_activity·Δt
|
||
neuron_total_weight = Σ component emitted_structure // from emissions, not interiors
|
||
// EMIT fatigue upward (metabolic debt of the whole cell)
|
||
neuron_fatigue = f(neuron_activity, unspent demand)
|
||
// (no restructuring permission while the cell is active — components are busy)
|
||
|
||
NIGHT | cycle: // (own_activity low AND sleep_pressure high)
|
||
phase = (cycle ≤ early_phase_frac × est_cycles) ? DOWNSCALE : COMMIT
|
||
// ADJUST read replay (external) + own aggregate
|
||
// EMIT (broadcast) — the neuron acts ONLY by signalling; components scale themselves
|
||
if phase == DOWNSCALE:
|
||
occupancy_downscale = downscale_factor // → components reset own occupancy
|
||
if neuron_total_weight > neuron_weight_ceiling:
|
||
renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure
|
||
rest_permission = TRUE // → components may restructure this cycle
|
||
// RECOVER reclaim material returned by components' renormalization (arrives as recycled pool)
|
||
// DECAY neuron_activity relaxes as the cell stays quiet
|
||
|
||
CODA | on waking (sleep_pressure < wake_thr):
|
||
neuron_activity = 0; neuron_total_weight = recomputed from surviving emissions
|
||
```
|
||
|
||
## ASTROCYTE
|
||
|
||
The astrocyte is the territory actor over its astrosynapses — the exact parallel of the neuron.
|
||
It integrates its astrosynapses' emitted demand/load, and reallocates its produced energy and
|
||
material across the territory. The astrosynapse is one of its constituents; the astrocyte is not
|
||
the astrosynapse.
|
||
|
||
```
|
||
// PARAMETERS (territory reallocation) · early_phase_frac · rest_thr
|
||
// INTERFACE
|
||
// EMIT astro_alloc[·] (reallocation), rest_permission → own astrosynapses (broadcast)
|
||
// astro_fatigue → HYPOTHALAMUS ; produced energy+material → territory (roots)
|
||
// RECEIVE (signals) astrosynapse demand emissions (summed) ; sleep_pressure ; replay_reweight
|
||
// OWN astro_territory_demand[·] (aggregated from emissions) ; astro_central_{energy,material}
|
||
// NOTE ROOT of synaptic energy + ECM material; integrate-and-broadcast like the neuron.
|
||
|
||
DAY | active:
|
||
// TRACE integrate territory-wide emitted demand (aggregator)
|
||
for each astrosynapse i: astro_territory_demand[i] += emitted_demand[i]·Δt
|
||
// BEHAVE DAY metabolic support already runs per-astrosynapse (lactate allocation, see ASTROSYNAPSE)
|
||
// EMIT fatigue upward
|
||
astro_fatigue = f(territory load, unmet demand)
|
||
|
||
NIGHT | cycle: // (territory quiet AND sleep_pressure high)
|
||
// RECEIVE = PRODUCTION (root): this cycle's energy + ECM batch, capped by glucose
|
||
astro_central_energy += overnight_glycolysis(glucose)·Δt_cycle // NOT recoverable
|
||
astro_central_material += astro_cellbody_synth()·Δt_cycle // recoverable
|
||
night_energy_spent += overnight_glycolysis(glucose)·Δt_cycle
|
||
// ADJUST reallocation weights across the territory (demand × replay)
|
||
for each i: astro_alloc[i] = (astro_territory_demand[i] × replay_reweight[i])
|
||
/ Σ(astro_territory_demand × replay_reweight)
|
||
// EMIT (broadcast) distribute this cycle's batch + grant restructuring window
|
||
for each i:
|
||
astro_energy[i] += astro_central_energy·astro_alloc[i]
|
||
astro_material[i] += astro_central_material·astro_alloc[i]
|
||
rest_permission[i] = TRUE // → each astrosynapse commits itself
|
||
// RECOVER reclaim material from decayed astrosynapse ceilings (returned to central pool)
|
||
astro_central_material += astro_ceiling_shrinkage·recycle
|
||
|
||
CODA | on waking:
|
||
astro_territory_demand[·] = 0
|
||
```
|
||
|
||
## HYPOTHALAMUS
|
||
|
||
The system actor. Unlike every other actor it has NO night: it runs CONTINUOUS, always
|
||
integrating fatigue from all components and emitting the single sleep-pressure signal that opens
|
||
everyone else's restructuring window. It is the clock that never sleeps — if it stopped, nothing
|
||
would track fatigue and the system could never transition.
|
||
|
||
```
|
||
// PARAMETERS fatigue_gain · pressure_decay · discharge_gain
|
||
// INTERFACE
|
||
// EMIT sleep_pressure → ALL actors (broadcast; the day/night signal)
|
||
// RECEIVE (signals) fatigue from all components + cell actors (summed)
|
||
// discharge signal (restructuring done → fatigue falling)
|
||
// OWN sleep_pressure
|
||
// NOTE single fatigue channel up, single sleep_pressure channel down. No DAY/NIGHT of its own.
|
||
|
||
CONTINUOUS: // spans every other actor's day and night
|
||
// RECEIVE integrate all incoming fatigue (rising with activity, falling with consolidation)
|
||
total_fatigue = Σ component_fatigue + neuron_fatigue + astro_fatigue
|
||
// TRACE accumulate sleep pressure from fatigue; discharge as restructuring proceeds
|
||
sleep_pressure += fatigue_gain × total_fatigue·Δt
|
||
sleep_pressure -= discharge_gain × consolidation_progress·Δt
|
||
sleep_pressure *= decay(pressure_decay)
|
||
// EMIT broadcast the current level — each actor reads it and sets its own DAY/NIGHT
|
||
broadcast(sleep_pressure)
|
||
// (rising pressure tips quiet components into NIGHT; falling pressure wakes them — emergently)
|
||
```
|
||
|
||
How it runs without a driver. There is no loop that orchestrates the actors. The hypothalamus
|
||
continuously emits sleep-pressure; each component and cell actor continuously reads it and its own
|
||
activity and sets its own DAY/NIGHT per the transition rule. As components quiet and cross into
|
||
NIGHT they restructure, which discharges fatigue, which lowers pressure, which eventually wakes
|
||
them. The "loop of NIGHT cycles" is simply what happens while a component remains in its NIGHT
|
||
state — it runs its `NIGHT | cycle` block repeatedly until its transition rule flips it back to
|
||
DAY. Termination (waking) is emergent from the fatigue loop, not a `break`: a rested system
|
||
discharges its fatigue and wakes; an overloaded one wakes with tags unspent (they carry forward).
|
||
|
||
---
|
||
|
||
## One-view summary
|
||
|
||
```
|
||
THE THREE-PHASE RING · EIGHT ACTORS · ONE FATIGUE LOOP
|
||
ACTION (lateral, deposits fast trace) → EVALUATION (local, climbs to tag) → PREPARATION (vertical, readies next)
|
||
action is always LOCAL; evaluation & preparation may be local or CONTEXTUAL (a neighbor supplies them)
|
||
CONTEXT licenses PHASE: AP→action · NOT_AP→fast eval+prep · NOT_SPIKE_TRAIN(⊂NOT_AP)→slow eval+prep
|
||
phase edges are event/decay-timed, not clocked; RECOVER folded into PREPARATION (ready ≠ restore)
|
||
|
||
ACTORS local: soma·pre·post·dend·axon·astrosynapse cell: neuron·astrocyte system: hypothalamus
|
||
same ring; higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in
|
||
|
||
DAY (per-component state: own_activity high) ring turned OUTWARD against the world
|
||
fast_trace + dopamine → tag (strength) ; FUEL shortfall + interrupted success → endurance_need
|
||
currency: information ; token minted by evaluation: the TAG (for NIGHT) ; emit fatigue upward
|
||
NIGHT (per-component state: own_activity low AND sleep_pressure high) ring turned INWARD against the economy
|
||
ACTION=coherence check · EVALUATION=draw & commit (only if coherent) · PREPARATION=make room
|
||
currency: resource ; token minted by evaluation: STRUCTURE (for next DAY) ; deferral if not coherent
|
||
what persists must EARN it: occupancy resets, only CEILINGS carry; unspent tags carry forward
|
||
LOOP no driver/scheduler. HYPOTHALAMUS runs CONTINUOUS: integrates fatigue → emits sleep_pressure.
|
||
activity→fatigue→pressure→quiet grants restructuring→discharge→pressure falls→wake. DAY/NIGHT
|
||
are 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
|
||
(holds an aggregate it can't see, opens a window it can't open). Acts locally, consolidates
|
||
hierarchically. Material recycles; ENERGY does not (the arrow of time).
|
||
FLOWS every flow has a timescale; shipment is transit-delayed (distal fills over cycles)
|
||
LOCAL only own state + arrived signals; ACTION/EMIT are the crossings; nothing is a pure sink
|
||
```
|