diff --git a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md index 3e744c6..db55329 100644 --- a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -8,8 +8,9 @@ > 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). +> (1) NINE actors: LOCAL components (soma·pre·post·dend·axon·astrosynapse) · CELL actors (neuron over +> soma/pre/post/dend/axon ; astrocyte over astrosynapses) · SYSTEM actors (hypothalamus: DAY/NIGHT +> + wake ; brainstem: the within-night NON_REM/REM sub-phase rhythm). > (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 ≥ @@ -249,6 +250,9 @@ 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) +sub_phase ∈ {NON_REM_1,NON_REM_2,REM} // BROADCAST by BRAINSTEM within NIGHT (the sub-phase rhythm) +circuit_recruitment need_remaining // NEURON/ASTROCYTE → BRAINSTEM (REM sensing: recruit, needs-left) +summed_tag_remaining night_fatigue // → HYPOTHALAMUS wake (tag-exhaustion) ; BRAINSTEM → HYPO (REM cost) 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) @@ -851,21 +855,24 @@ DAY | NOT_SPIKE_TRAIN: // 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) ===== +// ===== ACTION (build ⇄ release; consumes the restructuring-need REM left; tag funds build, persists) ===== NIGHT | NON_REM_1: - if soma_tag > tag_expiry and soma_participation ≥ MEDIUM: // BUILD (slice) - Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag) × soma_participation + // REM diagnosed what to fix; NON_REM_1 spends those need-traces (and reports need_remaining down to 0) + if soma_restructuring_need.BUILD > 0 and soma_tag > tag_expiry and soma_participation ≥ MEDIUM: // BUILD (slice) + Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag, soma_restructuring_need.BUILD) × soma_participation soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost - soma_tag -= Δ // SLICE — tag persists across cycles + soma_tag -= Δ // SLICE — tag persists across cycles (day-fuel depletes) + soma_restructuring_need.BUILD -= Δ // consume the need REM deposited 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 + else if soma_restructuring_need.RELEASE > 0 or soma_participation == LOW: // RELEASE: shed the leak, free material shed = release_rate × max(soma_structure - homeostatic_floor, 0) soma_structure -= shed; soma_freed_material += shed·recycle + soma_restructuring_need.RELEASE = max(soma_restructuring_need.RELEASE - shed, 0) // consume the release-need soma_budget_ceiling -= capacity_decay_rate·Δt_cycle - // else: HOLD — tag waits for its pattern + // else: HOLD — nothing left to fix this cycle // ===== RECOVERY (ROOT production + acquire/free material in CONTENTION; ship to feed the pattern) ===== NIGHT | NON_REM_2: // (SOMA also ROOT-produces here) @@ -884,7 +891,8 @@ NIGHT | NON_REM_2: // (SOMA also ROOT-p NIGHT | REM: // (SOMA replay-fires: ignites the pattern) // 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) + driven = branch_Vm // convergent replay input = the circuit ARRIVING at me + if spont > soma_spont_thr or driven > soma_spont_thr: // ignite (fluctuation OR circuit drive) 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 @@ -892,9 +900,16 @@ NIGHT | REM: // (SOMA replay-fires else: soma_budget -= ap_cost emit(replay_AP → AXON, DEND) // propagate: AXON/DEND relay onward IF primed + emitted_replay_fired += 1 // → NEURON sums into circuit_recruitment (well-recruited) + if soma_tag < tag_expiry: // fired WITHOUT a standing tag → leak (over-built) + soma_restructuring_need += RELEASE_need(driven) // "release me" — leftover structure carrying pattern + else if driven > near_miss_thr: // NEAR-MISS: circuit reached me, structure fell short + soma_restructuring_need += BUILD_need(soma_spont_thr - driven) // "build me" — under-recruited (local + circuit-correct) // 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 + emit(emitted_restructuring_need = soma_restructuring_need → NEURON) // → summed into need_remaining + emit(emitted_tag_remaining = soma_tag → NEURON) // → summed into summed_tag_remaining (wake signal) // MEDIUM: prime firing excitability from the standing tag soma_spont_thr = spont_thr_base − thr_gain × soma_tag // SLOW: settle @@ -1182,10 +1197,13 @@ grant itself. The soma is one of its constituents, a peer of the bouton; the neu // INTERFACE // EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast) // neuron_fatigue → HYPOTHALAMUS +// circuit_recruitment, need_remaining, summed_tag_remaining → BRAINSTEM / HYPOTHALAMUS // RECEIVE (signals) component activity emissions (summed) ; scope_context ← HYPOTHALAMUS -// replay_reweight ← assembly/network (external) +// sub_phase ← BRAINSTEM ; 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. +// It is the neuron (above the soma) that judges recruitment: the soma emits whether it +// was driven-and-fired vs near-missed; the neuron sums these into the circuit signal. DAY | active: // (within broadcast DAY context → integrate only) // TRACE integrate the cell's emitted activity + committed weight (aggregators) @@ -1195,15 +1213,17 @@ DAY | active: // (within broadcast neuron_fatigue = f(neuron_activity, unspent demand) // (no restructuring permission while the cell is active — components are busy) -NIGHT | cycle: // (within broadcast NIGHT context) +NIGHT | cycle: // (within broadcast NIGHT context + sub_phase) // 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 + // REPORT to the BRAINSTEM (sub-phase switch) and HYPOTHALAMUS (wake) — sums of emitted signals only: + circuit_recruitment = Σ soma emitted_replay_fired // how strongly circuits recruited this REM + need_remaining = Σ soma emitted_restructuring_need // build/release needs left by REM + summed_tag_remaining = Σ component emitted_tag_remaining // day-tags still unspent (wake signal) CODA | on waking (scope_context → DAY): neuron_activity = 0; neuron_total_weight = recomputed from surviving emissions @@ -1276,15 +1296,25 @@ FATIGUE⇄REST competition and BROADCASTING the DAY/NIGHT context that every oth 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. +integrate the competition and the scope could never switch. It owns only DAY/NIGHT; the within-night +sub-phases (NON_REM_1/NON_REM_2/REM) are owned by the BRAINSTEM. + +The WAKE condition (NIGHT → DAY) has two signals, combined as tag-primary-with-a-fatigue-cap: the +night's job is consolidation, so the normal end is **tag exhaustion** — when the day's tags (summed, +reported up) are spent, there is nothing left to consolidate and the system wakes. But a distinct +**night_fatigue** — driven by REM, since replay is the expensive phase — is a hard cap that forces +waking early if replay burned too much, protecting against endless exploration. So: wake when tags +are exhausted, OR when night_fatigue crosses its cap, whichever comes first. ``` -// PARAMETERS fatigue_gain · rest_gain · hysteresis +// PARAMETERS fatigue_gain · rest_gain · hysteresis · tag_floor · night_fatigue_cap // INTERFACE // EMIT scope_context ∈ {DAY, NIGHT} → ALL actors (broadcast; the switch) -// RECEIVE (signals) fatigue from components + ASTROCYTE (metabolic debt) ; rest (restoration) +// RECEIVE (signals) fatigue from components + ASTROCYTE (metabolic debt) ; rest (restoration) ; +// summed_tag_remaining ← NEURON/ASTROCYTE ; night_fatigue ← BRAINSTEM (REM-driven) // OWN fatigue · rest · scope_context // NOTE the switch is TOP-DOWN: components receive the context, they do not each decide it. +// DAY→NIGHT on fatigue; NIGHT→DAY on tag-exhaustion OR night_fatigue cap. CONTINUOUS: // spans every other actor's day and night // integrate the two competing drives @@ -1292,9 +1322,11 @@ CONTINUOUS: // spans every other 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 + // DAY → NIGHT when fatigue dominates (earned, hysteresis avoids chatter) + if scope_context == DAY and fatigue > rest + hysteresis: scope_context = NIGHT + // NIGHT → DAY: tag-exhaustion (the work is done) OR night_fatigue cap (replay too costly) + if scope_context == NIGHT and (summed_tag_remaining < tag_floor or night_fatigue > night_fatigue_cap): + scope_context = DAY broadcast(scope_context) // every actor behaves/restructures within it ``` @@ -1308,10 +1340,80 @@ that drives the switch, and its discharge during night is what permits waking. --- +## BRAINSTEM + +The other system actor, and a minimal one: within the NIGHT that the hypothalamus declares, the +BRAINSTEM owns the sub-phase rhythm — it emits the context NON_REM_1 / NON_REM_2 / REM that the +night elements run in. But it decides nothing on its own: it reads two levels reported up by the +NEURON and ASTROCYTE and switches context accordingly. The night is a self-contained loop; the +brainstem only checks and switches. + +The loop it closes. REM (PREPARATION) replays circuits — but the brainstem does not know which +circuits (they are unexpressed objects). It reads only **circuit recruitment**: while some circuit +recruits strongly, replay is productive, so stay in REM. Each recruited circuit **fatigues** (from +its neurons' participation), so it self-extinguishes and the next circuit surfaces — REM sweeps the +repertoire. REM also leaves **restructuring-need traces**: at a soma that received convergent replay +input but fell just short of firing (a near-miss — the circuit reached it, its structure could not +complete it), a "build me" need is deposited; at a soma that fired without a standing tag (leftover +structure leaking), a "release me" need. When recruitment finally falls across the board (every +supportable circuit swept and fatigued), the brainstem switches to NON_REM_1. NON_REM_1 (ACTION) +and NON_REM_2 (RECOVERY) then consume those need-traces — building the near-misses, releasing the +leaks, importing/freeing the material — cycling many times (the competition over who is potentiated +and who is depotentiated takes many action⇄recovery rounds). When the need-traces are exhausted, the +brainstem switches back to REM, which replays the newly restructured circuits and leaves a fresh, +smaller batch of needs. Around and around: REM diagnoses, NON_REM repairs, each fueling the other. + +REM is the expensive phase, and its cost is the night's clock. Replay burns energy — +**night_fatigue** accumulates during REM (only) — and because REM lengthens across the night (early, +on raw structure, circuits break fast and REM is short; late, on consolidated structure, circuits +sweep long and REM is long), night_fatigue accelerates toward the night's end. It is reported up to +the hypothalamus as the fatigue-cap that can force waking. Meanwhile building consumes the day's +tags, so as consolidation completes REM finds fewer near-misses and generates fewer needs; when the +tags are exhausted the loop quiesces and the hypothalamus wakes the system. Two fuels run down: tags +(informational — what to consolidate) and night energy (metabolic — how much replay costs), and the +night ends when either is spent. + +``` +// PARAMETERS recruit_thr · need_floor · rem_fatigue_gain +// INTERFACE +// EMIT sub_phase ∈ {NON_REM_1, NON_REM_2, REM} → night elements (broadcast, within NIGHT) ; +// night_fatigue → HYPOTHALAMUS (REM-driven, the wake cap) +// RECEIVE (signals) circuit_recruitment ← NEURON/ASTROCYTE (summed replay participation) ; +// need_remaining ← NEURON/ASTROCYTE (summed restructuring-need traces) ; scope_context +// OWN sub_phase · night_fatigue +// NOTE pure context-switch: senses nothing itself; NEURON/ASTROCYTE do the sensing (recruitment, +// circuit fatigue, need-remaining), the brainstem reads two levels and flips. Owns the +// within-night rhythm; the HYPOTHALAMUS owns DAY/NIGHT and the wake. + +DAY | active: // minimal by day: accumulate, emit nothing + // (day role held minimal for now; could later carry arousal tone) + night_fatigue = 0 // reset for the coming night + +NIGHT | active: // within the hypothalamus's NIGHT + if sub_phase == REM: + night_fatigue += rem_fatigue_gain·Δt // REPLAY IS EXPENSIVE — the night's energy clock + if circuit_recruitment < recruit_thr: // no circuit recruits → structure explored + sub_phase = NON_REM_1 // → repair: begin restructuring + else: // NON_REM_1 ⇄ NON_REM_2 run as the elements' ACTION⇄RECOVERY + if need_remaining < need_floor: // needs consumed → nothing left to build/release + sub_phase = REM // → diagnose the newly restructured circuits + broadcast(sub_phase) // night elements restructure/replay within it +``` + +Why the brainstem is separate from the hypothalamus. Two different clocks, two different sensings. +The hypothalamus integrates a *metabolic* competition (fatigue vs rest) to decide DAY vs NIGHT — +when to sleep. The brainstem reads *circuit recruitment* and *restructuring-need* to decide the +sub-phase — what phase of sleep. Loading both on one actor would conflate a metabolic decision with +a completion-sensing one. Separated, each is a clean context-switch on its own signal, and together +they compose: the night is a sequence of brainstem-driven REM⇄NON_REM cycles, running until the +hypothalamus judges (by tag-exhaustion or night_fatigue) that the night is over. + +--- + ## One-view summary ``` -THREE CATEGORIES · EIGHT ACTORS · ONE FATIGUE⇄REST SWITCH +THREE CATEGORIES · NINE ACTORS · ONE FATIGUE⇄REST SWITCH (+ BRAINSTEM sub-phase rhythm) 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)