ocrampal/organism
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update 2026-06-29-tripartite-synapse_v17.md

Browse Source
This commit is contained in:
ocrampal
2026-07-14 20:32:37 +02:00
parent 4ef2c87c3e
commit a5d1c8387b
1 changed files with 55 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files
elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md
+54 -51
View File
@@ -251,7 +251,7 @@ replay_reweight[·] // assembly/network replay re-weighti
glucose geometry // physical (external) glucose geometry // physical (external)
scope_context ∈ {DAY, NIGHT} // BROADCAST by HYPOTHALAMUS (top-down; the switch, read by all) 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) 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) summed_tag_remaining night_fatigue // → HYPOTHALAMUS wake (tag-exhaustion) ; BRAINSTEM → HYPO (REM cost)
fatigue_gain rest_gain // hypothalamus fatigue⇄rest integration weights fatigue_gain rest_gain // hypothalamus fatigue⇄rest integration weights
elig dop_thr tag_thr tag_expiry // strength gates (universal) 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 // replay_AP down axon + dendrites. Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release
// contend WITHIN (participation arbitrates); material contends BETWEEN components (recovery). // 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: NIGHT | NON_REM_1:
// REM diagnosed what to fix; NON_REM_1 spends those need-traces (and reports need_remaining down to 0) // participation (traced in REM) is the signal: components that took part in circuits, and have
if soma_restructuring_need.BUILD > 0 and soma_tag > tag_expiry and soma_participation ≥ MEDIUM: // BUILD (slice) // material, are strengthened; those that did not participate drift down. No separate need-trace.
Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag, soma_restructuring_need.BUILD) × soma_participation 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_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost
soma_tag -= Δ // SLICE — tag persists across cycles (day-fuel depletes) 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: if soma_endurance_need > endur_thr:
Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap) Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap)
soma_budget_ceiling += Δ'; soma_material -= Δ'; soma_energy -= Δ'·biogenesis_cost soma_budget_ceiling += Δ'; soma_material -= Δ'; soma_energy -= Δ'·biogenesis_cost
soma_endurance_need -= Δ' 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) shed = release_rate × max(soma_structure - homeostatic_floor, 0)
soma_structure -= shed; soma_freed_material += shed·recycle 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 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) NIGHT | NON_REM_2: // (SOMA also ROOT-produces here)
soma_material += CREB_synth(soma_tag)·Δt_cycle // ROOT: produce material — recoverable soma_material += CREB_synth(soma_tag)·Δt_cycle // ROOT: produce material — recoverable
soma_energy += mito_synth()·Δt_cycle // ROOT: produce energy — NOT recoverable soma_energy += mito_synth()·Δt_cycle // ROOT: produce energy — NOT recoverable
night_energy_spent += mito_synth()·Δt_cycle 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 += 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_dend += ship(soma_material, dend_demand, f_dend, ship_cost) // ship to feed pattern links
soma_material_to_axon += ship(soma_material, axon_demand, f_axon, ship_cost) soma_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 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) ===== // ===== PREPARATION (REPLAY the fire — SAME machinery as day ACTION; ignites the pattern; multi-timescale) =====
NIGHT | REM: // (SOMA replay-fires: ignites the pattern) NIGHT | REM: // (SOMA replay-fires: participates in circuits)
// FAST: replay-fire (probe); ignites the pattern down the day pathway // 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() spont = intrinsic_fluctuation()
driven = branch_Vm // convergent replay input = the circuit ARRIVING at me driven = branch_Vm // convergent replay input = a circuit ARRIVING at me
if spont > soma_spont_thr or driven > soma_spont_thr: // ignite (fluctuation OR circuit drive) if (spont > soma_spont_thr or driven > soma_spont_thr) and soma_energy > participate_cost: // can I take part?
replay_AP = TRUE 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_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_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: else:
soma_budget -= ap_cost soma_budget -= ap_cost
emit(replay_AP → AXON, DEND) // propagate: AXON/DEND relay onward IF primed emit(replay_AP → AXON, DEND) // propagate: AXON/DEND relay onward IF primed
emitted_replay_fired += 1 // → NEURON sums into circuit_recruitment (well-recruited) emit(emitted_replay_fired → NEURON) // → circuit_recruitment (a circuit is recruiting now)
if soma_tag < tag_expiry: // fired WITHOUT a standing tag → leak (over-built) // else: no energy (or not driven) → give way this pass; another circuit's somas recruit instead
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): // 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 →[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_participation = soma_participation → NEURON) // → recruitment falls as stores deplete
emit(emitted_restructuring_need = soma_restructuring_need → NEURON) // → summed into need_remaining emit(emitted_tag_remaining = soma_tag → NEURON) // → summed_tag_remaining (wake signal)
emit(emitted_tag_remaining = soma_tag → NEURON) // → summed into summed_tag_remaining (wake signal)
// MEDIUM: prime firing excitability from the standing tag // MEDIUM: prime firing excitability from the standing tag
soma_spont_thr = spont_thr_base − thr_gain × soma_tag soma_spont_thr = spont_thr_base − thr_gain × soma_tag
// SLOW: settle // SLOW: settle
@@ -1197,7 +1199,7 @@ grant itself. The soma is one of its constituents, a peer of the bouton; the neu
// INTERFACE // INTERFACE
// EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast) // EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast)
// neuron_fatigue → HYPOTHALAMUS // 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 // RECEIVE (signals) component activity emissions (summed) ; scope_context ← HYPOTHALAMUS
// sub_phase ← BRAINSTEM ; replay_reweight ← assembly/network (external) // sub_phase ← BRAINSTEM ; replay_reweight ← assembly/network (external)
// OWN neuron_activity · neuron_total_weight (aggregates aggregated from emissions) // OWN neuron_activity · neuron_total_weight (aggregates aggregated from emissions)
@@ -1221,8 +1223,8 @@ NIGHT | cycle: // (within broadcast
renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure
rest_permission = TRUE // → components may restructure this cycle rest_permission = TRUE // → components may restructure this cycle
// REPORT to the BRAINSTEM (sub-phase switch) and HYPOTHALAMUS (wake) — sums of emitted signals only: // 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 circuit_recruitment = Σ soma emitted_replay_fired // strength of REM recruitment (falls as energy depletes)
need_remaining = Σ soma emitted_restructuring_need // build/release needs left by REM 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) summed_tag_remaining = Σ component emitted_tag_remaining // day-tags still unspent (wake signal)
CODA | on waking (scope_context → DAY): CODA | on waking (scope_context → DAY):
@@ -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 NEURON and ASTROCYTE and switches context accordingly. The night is a self-contained loop; the
brainstem only checks and switches. brainstem only checks and switches.
The loop it closes. REM (PREPARATION) replays circuits — but the brainstem does not know which The loop it closes. REM (PREPARATION) is participation under a limited energy store — but the
circuits (they are unexpressed objects). It reads only **circuit recruitment**: while some circuit brainstem does not know which circuits (they are unexpressed objects). Each soma participates in a
recruits strongly, replay is productive, so stay in REM. Each recruited circuit **fatigues** (from circuit by igniting, which **spends its energy store** (replenished in NON_REM_2, tag-weighted: all
its neurons' participation), so it self-extinguishes and the next circuit surfaces — REM sweeps the somas get a base, the day-tagged get more, so past participation buys present chance). As a circuit's
repertoire. REM also leaves **restructuring-need traces**: at a soma that received convergent replay somas spend down their stores they can no longer sustain participation and **give way**, letting other
input but fell just short of firing (a near-miss — the circuit reached it, its structure could not circuits — other somas with energy still to spend — recruit; so REM sweeps the repertoire, circuit by
complete it), a "build me" need is deposited; at a soma that fired without a standing tag (leftover circuit, as stores deplete. The brainstem reads only **circuit recruitment** (summed participation):
structure leaking), a "release me" need. When recruitment finally falls across the board (every while it stays strong, stay in REM. When it falls across the board (stores spent, no circuit can
supportable circuit swept and fatigued), the brainstem switches to NON_REM_1. NON_REM_1 (ACTION) recruit), switch to NON_REM_1. NON_REM_1 (ACTION) **strengthens the participants** — the somas whose
and NON_REM_2 (RECOVERY) then consume those need-traces — building the near-misses, releasing the participation trace is high, and which have material, build up; those that did not take part drift
leaks, importing/freeing the material — cycling many times (the competition over who is potentiated down — while NON_REM_2 (RECOVERY) re-supplies energy and material, cycling many times (the competition
and who is depotentiated takes many action⇄recovery rounds). When the need-traces are exhausted, the over who is potentiated and who is depotentiated takes many action⇄recovery rounds). When the
brainstem switches back to REM, which replays the newly restructured circuits and leaves a fresh, participation has been acted on and energy re-supplied, the brainstem switches back to REM, which
smaller batch of needs. Around and around: REM diagnoses, NON_REM repairs, each fueling the other. 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 — 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, **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. night ends when either is spent.
``` ```
// PARAMETERS recruit_thr · need_floor · rem_fatigue_gain // PARAMETERS recruit_thr · settle_floor · rem_fatigue_gain
// INTERFACE // INTERFACE
// EMIT sub_phase ∈ {NON_REM_1, NON_REM_2, REM} → night elements (broadcast, within NIGHT) ; // EMIT sub_phase ∈ {NON_REM_1, NON_REM_2, REM} → night elements (broadcast, within NIGHT) ;
// night_fatigue → HYPOTHALAMUS (REM-driven, the wake cap) // night_fatigue → HYPOTHALAMUS (REM-driven, the wake cap)
// RECEIVE (signals) circuit_recruitment ← NEURON/ASTROCYTE (summed replay participation) ; // RECEIVE (signals) circuit_recruitment ← NEURON/ASTROCYTE (summed REM participation, falls as
// need_remaining ← NEURON/ASTROCYTE (summed restructuring-need traces) ; scope_context // energy stores deplete) ; unspent_participation ← NEURON/ASTROCYTE (participation not yet
// acted on by NON_REM_1) ; scope_context
// OWN sub_phase · night_fatigue // OWN sub_phase · night_fatigue
// NOTE pure context-switch: senses nothing itself; NEURON/ASTROCYTE do the sensing (recruitment, // NOTE pure context-switch: senses nothing itself; NEURON/ASTROCYTE do the sensing, the
// circuit fatigue, need-remaining), the brainstem reads two levels and flips. Owns the // brainstem reads two levels and flips. Owns the within-night rhythm; HYPOTHALAMUS owns
// within-night rhythm; the HYPOTHALAMUS owns DAY/NIGHT and the wake. // DAY/NIGHT and the wake.
DAY | active: // minimal by day: accumulate, emit nothing 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_fatigue = 0 // reset for the coming night
NIGHT | active: // within the hypothalamus's NIGHT NIGHT | active: // within the hypothalamus's NIGHT
if sub_phase == REM: if sub_phase == REM:
night_fatigue += rem_fatigue_gain·Δt // REPLAY IS EXPENSIVE — the night's energy clock night_fatigue += rem_fatigue_gain·Δt // REPLAY IS EXPENSIVE — the night's energy clock
if circuit_recruitment < recruit_thr: // no circuit recruits → structure explored if circuit_recruitment < recruit_thr: // energy stores depleted → no circuit recruits
sub_phase = NON_REM_1 // → repair: begin restructuring sub_phase = NON_REM_1 // → strengthen the participants, re-supply energy
else: // NON_REM_1 ⇄ NON_REM_2 run as the elements' ACTION⇄RECOVERY 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 if unspent_participation < settle_floor: // participation acted on, energy re-supplied
sub_phase = REM // → diagnose the newly restructured circuits sub_phase = REM // → participate again on the newly strengthened structure
broadcast(sub_phase) // night elements restructure/replay within it broadcast(sub_phase) // night elements restructure/replay within it
``` ```