From a5d1c8387b7ca45b751bb050719e58c274a577d1 Mon Sep 17 00:00:00 2001 From: ocrampal Date: Tue, 14 Jul 2026 20:32:37 +0200 Subject: [PATCH] Update 2026-06-29-tripartite-synapse_v17.md --- .../2026-06-29-tripartite-synapse_v17.md | 107 +++++++++--------- 1 file changed, 55 insertions(+), 52 deletions(-) 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 db55329..7b77872 100644 --- a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -251,7 +251,7 @@ replay_reweight[·] // assembly/network replay re-weighti 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) +circuit_recruitment unspent_participation // NEURON/ASTROCYTE → BRAINSTEM (REM recruit ; participation not yet acted on) 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) @@ -855,30 +855,32 @@ 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; consumes the restructuring-need REM left; tag funds build, persists) ===== +// ===== ACTION (build ⇄ release; PARTICIPATION arbitrates; tag + material fund build, persist) ===== NIGHT | NON_REM_1: - // 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 + // participation (traced in REM) is the signal: components that took part in circuits, and have + // material, are strengthened; those that did not participate drift down. No separate need-trace. + if soma_participation ≥ MEDIUM and soma_tag > tag_expiry: // BUILD (slice) — participated + tagged + Δ = 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 (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_restructuring_need.RELEASE > 0 or soma_participation == LOW: // RELEASE: shed the leak, free material + else if soma_participation == LOW: // RELEASE: did not take part → shed, 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 — nothing left to fix this cycle + // else: HOLD + soma_participation *= decay(cycle) // participation relaxes; re-earned each REM -// ===== RECOVERY (ROOT production + acquire/free material in CONTENTION; ship to feed the pattern) ===== +// ===== RECOVERY (ROOT production + acquire/free material in CONTENTION; ALLOCATE energy for REM) ===== NIGHT | NON_REM_2: // (SOMA also ROOT-produces here) 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 + // ALLOCATE the REM energy store: all get a base, tagged components get MORE (more chance to participate) + soma_energy += energy_base + energy_tag_gain × soma_tag // past participation (tag) → more energy for REM 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) @@ -888,28 +890,28 @@ NIGHT | NON_REM_2: // (SOMA also ROOT-p 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 | REM: // (SOMA replay-fires: ignites the pattern) - // FAST: replay-fire (probe); ignites the pattern down the day pathway +NIGHT | REM: // (SOMA replay-fires: participates in circuits) + // REM is PARTICIPATION under a limited ENERGY store (replenished tag-weighted in NON_REM_2 RECOVERY). + // Participating (igniting in a circuit) SPENDS that store; when it runs low the soma can no longer + // sustain participation and GIVES WAY, letting other circuits (other somas with energy) recruit. spont = intrinsic_fluctuation() - 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) + driven = branch_Vm // convergent replay input = a circuit ARRIVING at me + if (spont > soma_spont_thr or driven > soma_spont_thr) and soma_energy > participate_cost: // can I take part? replay_AP = TRUE + soma_energy -= participate_cost // PARTICIPATION SPENDS THE STORE (the scarce resource) soma_fast_trace += nuclear_Ca()·δ(replay) // SAME trace deposit as DAY ACTION + soma_participation += soma_fast_trace·Δt // TRACE participation (accumulates across the night) 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 + if soma_fast_trace > traj_thr: soma_endurance_need += soma_fast_trace 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) + emit(emitted_replay_fired → NEURON) // → circuit_recruitment (a circuit is recruiting now) + // else: no energy (or not driven) → give way this pass; another circuit's somas recruit instead // 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) + emit(emitted_participation = soma_participation → NEURON) // → recruitment falls as stores deplete + emit(emitted_tag_remaining = soma_tag → NEURON) // → 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 @@ -1197,7 +1199,7 @@ 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 +// circuit_recruitment, unspent_participation, summed_tag_remaining → BRAINSTEM / HYPOTHALAMUS // RECEIVE (signals) component activity emissions (summed) ; scope_context ← HYPOTHALAMUS // sub_phase ← BRAINSTEM ; replay_reweight ← assembly/network (external) // OWN neuron_activity · neuron_total_weight (aggregates aggregated from emissions) @@ -1221,9 +1223,9 @@ NIGHT | cycle: // (within broadcast renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure rest_permission = TRUE // → components may restructure this cycle // 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) + circuit_recruitment = Σ soma emitted_replay_fired // strength of REM recruitment (falls as energy depletes) + unspent_participation = Σ soma emitted_participation // participation not yet acted on by NON_REM_1 + 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 @@ -1348,20 +1350,21 @@ night elements run in. But it decides nothing on its own: it reads two levels re 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. +The loop it closes. REM (PREPARATION) is participation under a limited energy store — but the +brainstem does not know which circuits (they are unexpressed objects). Each soma participates in a +circuit by igniting, which **spends its energy store** (replenished in NON_REM_2, tag-weighted: all +somas get a base, the day-tagged get more, so past participation buys present chance). As a circuit's +somas spend down their stores they can no longer sustain participation and **give way**, letting other +circuits — other somas with energy still to spend — recruit; so REM sweeps the repertoire, circuit by +circuit, as stores deplete. The brainstem reads only **circuit recruitment** (summed participation): +while it stays strong, stay in REM. When it falls across the board (stores spent, no circuit can +recruit), switch to NON_REM_1. NON_REM_1 (ACTION) **strengthens the participants** — the somas whose +participation trace is high, and which have material, build up; those that did not take part drift +down — while NON_REM_2 (RECOVERY) re-supplies energy and material, cycling many times (the competition +over who is potentiated and who is depotentiated takes many action⇄recovery rounds). When the +participation has been acted on and energy re-supplied, the brainstem switches back to REM, which +participates again on the newly strengthened structure. Around and around: REM selects by +participation, NON_REM consolidates the participants, 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, @@ -1374,29 +1377,29 @@ tags are exhausted the loop quiesces and the hypothalamus wakes the system. Two night ends when either is spent. ``` -// PARAMETERS recruit_thr · need_floor · rem_fatigue_gain +// PARAMETERS recruit_thr · settle_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 +// RECEIVE (signals) circuit_recruitment ← NEURON/ASTROCYTE (summed REM participation, falls as +// energy stores deplete) ; unspent_participation ← NEURON/ASTROCYTE (participation not yet +// acted on by NON_REM_1) ; 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. +// NOTE pure context-switch: senses nothing itself; NEURON/ASTROCYTE do the sensing, the +// brainstem reads two levels and flips. Owns the within-night rhythm; 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 + if circuit_recruitment < recruit_thr: // energy stores depleted → no circuit recruits + sub_phase = NON_REM_1 // → strengthen the participants, re-supply energy 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 + if unspent_participation < settle_floor: // participation acted on, energy re-supplied + sub_phase = REM // → participate again on the newly strengthened structure broadcast(sub_phase) // night elements restructure/replay within it ```