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-06 23:14:28 +02:00
parent 9d8ef10767
commit 9a3d75af04
1 changed files with 129 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md
+138 -115
View File
@@ -573,25 +573,41 @@ DAY | quiet: // sustained quiet
post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern.
// (ACTION ⇄ RECOVERY) × cycles, then PREPARATION. Night PREPARATION replays the DAY ACTION (same
// AMPA/NMDA machinery, same endurance trace), read for participation not significance.
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release contend WITHIN (participation
// arbitrates); material contends BETWEEN components (recovery). Night PREPARATION replays the DAY
// ACTION (same AMPA/NMDA machinery, same endurance trace), read for participation not significance.
// ===== RECOVERY (import + prime responsiveness) =====
NIGHT | import + prime:
post_material += transit(post_material_ship, τ_transport_spine)
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
NIGHT | build or release:
if rest_permission and post_tag > tag_expiry and post_participation ≥ MEDIUM: // BUILD (slice)
Δ = min(slot_batch, post_material, post_energy·f_cap, post_tag) × post_participation
post_structure += Δ; post_material -= Δ; post_energy -= Δ·assembly_cost
post_tag -= Δ // SLICE — tag persists across cycles
if post_endurance_need > endur_thr:
Δ' = min(cap_batch, post_material·f_cap, post_energy·f_cap)
post_budget_ceiling += Δ'; post_material -= Δ'; post_energy -= Δ'·biogenesis_cost
post_endurance_need -= Δ'
else if post_participation == LOW: // RELEASE: shed, free material; tag untouched
shed = release_rate × max(post_structure - homeostatic_floor, 0)
post_structure -= shed; post_freed_material += shed·recycle
post_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else: HOLD — tag waits for its pattern
// ===== RECOVERY (acquire material/energy in CONTENTION with other components; receive freed material) =====
NIGHT | import + free:
post_material += transit(post_material_ship, τ_transport_spine) // import (contested pool)
post_energy += transit(post_energy_ship, τ_transport_spine)
post_spont_thr = spont_thr_base − thr_gain × post_tag // restore responsiveness from standing tag
if post_tag > prime_thr:
AMPA_surface = min(AMPA_surface + prime_gain × post_tag, post_structure.slot_ceiling)
post_possible_tag *= occupancy_downscale
post_material += post_freed_material; post_freed_material = 0 // reclaim what release freed
if renorm_signal arrived:
freed = post_structure × (1 - renorm_signal); post_structure *= renorm_signal
emit(freed → recycled material pool)
post_material += post_ceiling_shrinkage·recycle // energy NOT recovered
post_structure += min(post_maint, maint_cost) // hold up what is used
// ===== PREPARATION (REM: REPLAY the response — SAME machinery as DAY ACTION) =====
NIGHT | replay + measure: // response here is PREPARATION, not the deed
if arrived_glutamate_replay or arrived_replay_AP: // re-evoked input arrives
// ===== PREPARATION (REPLAY the response — SAME machinery as day ACTION; multi-timescale) =====
NIGHT | replay + measure + prime:
// FAST: replay the response to the re-evoked input (probe)
if arrived_glutamate_replay or arrived_replay_AP:
a = sat(glutamate, K_AMPA)
post_fast_trace += AMPA_Ca·(a × AMPA_surface) // SAME AMPA machinery as DAY ACTION
if Vm > Mg_eject and astro_Dserine > Dserine_thr:
@@ -599,22 +615,13 @@ NIGHT | replay + measure: // response here is P
if post_budget < traffic_cost: // SAME capacity check → endurance evidence
if post_fast_trace > traj_thr: post_endurance_need += post_fast_trace // SAME trace, fed by replay
post_participation = level(post_fast_trace) // read replayed response as participation
post_fast_trace *= decay(ms)
// ===== ACTION (change the structure — the night's defining deed) =====
NIGHT | change the structure:
post_structure -= decay_rate·Δt_cycle; post_structure += min(post_maint, maint_cost) // homeostatic lowering
if post_tag > tag_expiry and post_participation ≥ MEDIUM:
Δ = min(slot_batch, post_material, post_energy·f_cap, post_tag) × post_participation
post_structure += Δ; post_material -= Δ; post_energy -= Δ·assembly_cost
post_tag -= Δ // CONSUME on build
if post_endurance_need > endur_thr:
Δ' = min(cap_batch, post_material·f_cap, post_energy·f_cap)
post_budget_ceiling += Δ'; post_material -= Δ'; post_energy -= Δ'·biogenesis_cost
post_endurance_need -= Δ'
else:
post_budget_ceiling -= capacity_decay_rate·Δt_cycle; post_budget_ceiling += min(post_cap_maint, cap_cost)
post_endurance_need *= decay(slow)
// MEDIUM: prime responsiveness (AMPA occupancy) from the standing tag
post_spont_thr = spont_thr_base − thr_gain × post_tag
if post_tag > prime_thr:
AMPA_surface = min(AMPA_surface + prime_gain × post_tag, post_structure.slot_ceiling)
post_possible_tag *= occupancy_downscale
// SLOW: settle
post_fast_trace *= decay(ms); post_tag *= decay(hr); post_endurance_need *= decay(slow)
emit(post_fatigue, post_demand → upward) // not a sink: emits inward/upward by night
```
@@ -624,8 +631,7 @@ NIGHT | change the structure:
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.
soma, and ships material and budget to the spines it supports.
**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the
branch propagates the back-propagating spike toward its spines, with a fidelity that attenuates
@@ -694,46 +700,52 @@ DAY | NOT_bAP:
dend_possible_tag *= decay(s); dend_endurance_need *= decay(min) // MEDIUM
dend_tag *= decay(hr) // SLOW
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. DEND is an
// intermediate RELAY: its PREPARATION replay relays replay_AP onward to spines IF primed (carrying
// SOMA→DEND→POST). (ACTION ⇄ RECOVERY) × cycles, then PREPARATION.
// ── NIGHT: SAME three categories, subject = the pattern. DEND is an intermediate RELAY: its
// PREPARATION replay relays replay_AP onward to spines IF primed (carrying SOMA→DEND→POST).
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release WITHIN; material BETWEEN.
// ===== RECOVERY (import + prime relay excitability + ship down) =====
NIGHT | import + prime:
dend_material += transit(soma_material_to_dend, τ_transport_dend)
dend_energy += transit(soma_energy_to_dend, τ_transport_dend)
dend_spont_thr = spont_thr_base − thr_gain × dend_tag // restore bAP-relay excitability from standing tag
if renorm_signal arrived:
freed = dend_structure × (1 - renorm_signal); dend_structure *= renorm_signal
emit(freed → recycled material pool)
dend_material += dend_ceiling_shrinkage·recycle // energy NOT recovered
post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost) // ship to feed spine links
post_energy_ship += ship(dend_energy, post_demand, f_spine, ship_cost)
// ===== PREPARATION (REM: REPLAY the propagation — SAME machinery as DAY ACTION; relays the pattern) =====
NIGHT | replay + measure: // propagation here is PREPARATION, not the deed
if arrived_replay_AP and dend_spont_thr < recruit_thr: // relay onward to spines IF primed
bAP_local = propagate(replay_AP, dend_structure.bAP_fidelity, geometry) // SAME propagate machinery
emit(bAP_local → POST) // carries the pattern to the spines
dend_fast_trace += bAP_Ca(bAP_local)
if dend_budget < prop_cost and dend_fast_trace > traj_thr: // SAME capacity check → endurance
dend_endurance_need += dend_fast_trace // SAME trace, fed by replay
dend_participation = level(dend_fast_trace) // read replayed response as participation
dend_fast_trace *= decay(300ms)
// ===== ACTION (change the structure — the night's defining deed) =====
NIGHT | change the structure:
dend_structure -= decay_rate·Δt_cycle; dend_structure += min(dend_maint, maint_cost) // homeostatic lowering
if dend_tag > tag_expiry and dend_participation ≥ MEDIUM:
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists) =====
NIGHT | build or release:
if dend_tag > tag_expiry and dend_participation ≥ MEDIUM: // BUILD (slice)
Δ = min(slot_batch, dend_material, dend_energy·f_cap, dend_tag) × dend_participation
dend_structure += Δ; dend_material -= Δ; dend_energy -= Δ·assembly_cost; dend_tag -= Δ
if dend_endurance_need > endur_thr:
Δ' = min(cap_batch, dend_material·f_cap, dend_energy·f_cap)
dend_budget_ceiling += Δ'; dend_material -= Δ'; dend_energy -= Δ'·biogenesis_cost
dend_endurance_need -= Δ'
else:
dend_budget_ceiling -= capacity_decay_rate·Δt_cycle; dend_budget_ceiling += min(dend_cap_maint, cap_cost)
dend_endurance_need *= decay(slow)
else if dend_participation == LOW: // RELEASE: shed, free material; tag untouched
shed = release_rate × max(dend_structure - homeostatic_floor, 0)
dend_structure -= shed; dend_freed_material += shed·recycle
dend_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else: HOLD
// ===== RECOVERY (acquire/free material in CONTENTION; ship down to feed spine links) =====
NIGHT | import + free:
dend_material += transit(soma_material_to_dend, τ_transport_dend)
dend_energy += transit(soma_energy_to_dend, τ_transport_dend)
dend_material += dend_freed_material; dend_freed_material = 0 // reclaim what release freed
if renorm_signal arrived:
freed = dend_structure × (1 - renorm_signal); dend_structure *= renorm_signal
emit(freed → recycled material pool)
dend_material += dend_ceiling_shrinkage·recycle // energy NOT recovered
dend_structure += min(dend_maint, maint_cost) // hold up what is used
post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost) // ship to feed spine links
post_energy_ship += ship(dend_energy, post_demand, f_spine, ship_cost)
// ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) =====
NIGHT | replay + measure + prime:
// FAST: relay the replay_AP onward to spines IF primed (probe)
if arrived_replay_AP and dend_spont_thr < recruit_thr:
bAP_local = propagate(replay_AP, dend_structure.bAP_fidelity, geometry) // SAME propagate machinery
emit(bAP_local → POST) // carries the pattern to the spines
dend_fast_trace += bAP_Ca(bAP_local)
if dend_budget < prop_cost and dend_fast_trace > traj_thr: // SAME capacity check → endurance
dend_endurance_need += dend_fast_trace // SAME trace, fed by replay
dend_participation = level(dend_fast_trace) // read replayed response as participation
// MEDIUM: prime bAP-relay excitability from the standing tag
dend_spont_thr = spont_thr_base − thr_gain × dend_tag
// SLOW: settle
dend_fast_trace *= decay(300ms); dend_tag *= decay(hr); dend_endurance_need *= decay(slow)
emit(dend_fatigue, dend_demand → upward)
```
@@ -745,7 +757,7 @@ The soma is the neuron's integrating center and the root of its structural mater
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 as the three categories at DAY and at NIGHT.
a represented clock.
**During DAY, during AP — the soma integrates and fires.** It computes its firing threshold
from its baseline (structure), its accumulated adaptation, and the neuromodulators, and checks
@@ -831,24 +843,41 @@ DAY | NOT_SPIKE_TRAIN:
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. SOMA is a ROOT
// (produces material each cycle) AND the IGNITION POINT: its PREPARATION replay-fire propagates a
// replay_AP down axon + dendrites, re-evoking the pattern through the DAY PATHWAY. A pattern
// carries only if every link is primed. Night PREPARATION mirrors day ACTION (same fire machinery),
// read for participation, not significance. (ACTION ⇄ RECOVERY) × cycles, then PREPARATION.
// replay_AP down axon + dendrites. Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release
// contend WITHIN (participation arbitrates); material contends BETWEEN components (recovery).
// ===== RECOVERY (produce + restore the ability to restructure: material, energy, excitability) =====
NIGHT | produce + prime: // ROOT production + alter-ego of night ACTION
soma_material += CREB_synth(soma_tag)·Δt_cycle // material — recoverable
soma_energy += mito_synth()·Δt_cycle // energy — NOT recoverable
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
NIGHT | build or release:
if soma_tag > tag_expiry and soma_participation ≥ MEDIUM: // BUILD (slice)
Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag) × soma_participation
soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost
soma_tag -= Δ // SLICE — tag persists across cycles
if soma_endurance_need > endur_thr:
Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap)
soma_budget_ceiling += Δ'; soma_material -= Δ'; soma_energy -= Δ'·biogenesis_cost
soma_endurance_need -= Δ'
else if soma_participation == LOW: // RELEASE: shed, free material; tag untouched
shed = release_rate × max(soma_structure - homeostatic_floor, 0)
soma_structure -= shed; soma_freed_material += shed·recycle
soma_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else: HOLD — tag waits for its pattern
// ===== RECOVERY (ROOT production + acquire/free material in CONTENTION; ship to feed the pattern) =====
NIGHT | produce + import + free:
soma_material += CREB_synth(soma_tag)·Δt_cycle // ROOT: produce material — recoverable
soma_energy += mito_synth()·Δt_cycle // ROOT: produce energy — NOT recoverable
night_energy_spent += mito_synth()·Δt_cycle
soma_spont_thr = spont_thr_base − thr_gain × soma_tag // restore firing excitability from standing tag
soma_material += soma_freed_material; soma_freed_material = 0 // reclaim what release freed
soma_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost) // ship to feed pattern links
soma_material_to_axon += ship(soma_material, axon_demand, f_axon, ship_cost)
soma_energy_to_dend += ship(soma_energy, dend_demand, f_dend, ship_cost)
soma_energy_to_axon += ship(soma_energy, axon_demand, f_axon, ship_cost)
soma_material += soma_ceiling_shrinkage·recycle
soma_structure += min(soma_maint, maint_cost) // hold up what is used
// ===== PREPARATION (REM: REPLAY the fire — SAME machinery as DAY ACTION; ignites the pattern) =====
NIGHT | replay-fire + measure: // firing here is PREPARATION, not the deed
// ===== PREPARATION (REPLAY the fire — SAME machinery as day ACTION; ignites the pattern; multi-timescale) =====
NIGHT | replay-fire + measure + prime:
// FAST: replay-fire (probe); ignites the pattern down the day pathway
spont = intrinsic_fluctuation()
if spont > soma_spont_thr: // ignite (SAME threshold logic as day fire)
replay_AP = TRUE
@@ -861,22 +890,10 @@ NIGHT | replay-fire + measure: // firing here is PRE
// 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
soma_fast_trace *= decay(τ_nuclear)
// ===== ACTION (change the structure — the night's defining deed) =====
NIGHT | change the structure:
soma_structure -= decay_rate·Δt_cycle; soma_structure += min(soma_maint, maint_cost) // homeostatic lowering
if soma_tag > tag_expiry and soma_participation ≥ MEDIUM:
Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag) × soma_participation
soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost
soma_tag -= Δ // CONSUME on build → excitability drops next cycle
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:
soma_budget_ceiling -= capacity_decay_rate·Δt_cycle; soma_budget_ceiling += min(soma_cap_maint, cap_cost)
soma_endurance_need *= decay(slow)
// MEDIUM: prime firing excitability from the standing tag
soma_spont_thr = spont_thr_base − thr_gain × soma_tag
// SLOW: settle
soma_fast_trace *= decay(τ_nuclear); soma_tag *= decay(hr); soma_endurance_need *= decay(slow)
```
---
@@ -885,7 +902,7 @@ NIGHT | change the structure:
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 as the three categories at DAY and at NIGHT.
and budget to the boutons.
**During DAY, during AP — the axon propagates the spike.** Reliability is set by structure
(myelination) and degraded by recent high-frequency load (sodium inactivation at branch points —
@@ -943,25 +960,42 @@ DAY | NOT_AP:
axon_possible_tag *= decay(s); axon_endurance_need *= decay(min) // MEDIUM
axon_tag *= decay(hr) // SLOW
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. AXON is an
// intermediate RELAY: its PREPARATION replay relays replay_AP onward to boutons IF primed (carrying
// SOMA→AXON→PRE). (ACTION ⇄ RECOVERY) × cycles, then PREPARATION.
// ── NIGHT: SAME three categories, subject = the pattern. AXON is an intermediate RELAY: its
// PREPARATION replay relays replay_AP onward to boutons IF primed (carrying SOMA→AXON→PRE).
// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release WITHIN; material BETWEEN.
// ===== RECOVERY (import + prime relay excitability + ship down) =====
NIGHT | import + prime:
// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists) =====
NIGHT | build or release:
if axon_tag > tag_expiry and axon_participation ≥ MEDIUM: // BUILD (slice)
Δ = min(slot_batch, axon_material, axon_energy·f_cap, axon_tag) × axon_participation
axon_structure += Δ; axon_material -= Δ; axon_energy -= Δ·assembly_cost; axon_tag -= Δ
if axon_endurance_need > endur_thr:
Δ' = min(cap_batch, axon_material·f_cap, axon_energy·f_cap)
axon_budget_ceiling += Δ'; axon_material -= Δ'; axon_energy -= Δ'·biogenesis_cost
axon_endurance_need -= Δ'
else if axon_participation == LOW: // RELEASE: shed, free material; tag untouched
shed = release_rate × max(axon_structure - homeostatic_floor, 0)
axon_structure -= shed; axon_freed_material += shed·recycle
axon_budget_ceiling -= capacity_decay_rate·Δt_cycle
// else: HOLD
// ===== RECOVERY (acquire/free material in CONTENTION; ship down to feed bouton links) =====
NIGHT | import + free:
axon_material += transit(soma_material_to_axon, τ_transport_dend)
axon_energy += transit(soma_energy_to_axon, τ_transport_dend)
axon_spont_thr = spont_thr_base − thr_gain × axon_tag // restore relay excitability from standing tag
axon_material += axon_freed_material; axon_freed_material = 0 // reclaim what release freed
if renorm_signal arrived:
freed = axon_structure × (1 - renorm_signal); axon_structure *= renorm_signal
emit(freed → recycled material pool)
axon_material += axon_ceiling_shrinkage·recycle // energy NOT recovered
axon_structure += min(axon_maint, maint_cost) // hold up what is used
pre_material_ship += ship(axon_material, pre_demand, f_bouton, ship_cost) // ship to feed bouton links
pre_energy_ship += ship(axon_energy, pre_demand, f_bouton, ship_cost)
// ===== PREPARATION (REM: REPLAY the propagation — SAME machinery as DAY ACTION; relays the pattern) =====
NIGHT | replay + measure: // propagation here is PREPARATION, not the deed
if arrived_replay_AP and axon_spont_thr < recruit_thr: // relay onward to boutons IF primed
// ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) =====
NIGHT | replay + measure + prime:
// FAST: relay the replay_AP onward to boutons IF primed (probe)
if arrived_replay_AP and axon_spont_thr < recruit_thr:
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // SAME reliability machinery
delivered = reliability × axon_structure.propagation
emit(replay_AP → PRE) // carries the pattern to the boutons
@@ -969,21 +1003,10 @@ NIGHT | replay + measure: // propagation here i
if axon_budget < prop_cost and axon_fast_trace > traj_thr: // SAME capacity check → endurance
axon_endurance_need += axon_fast_trace // SAME trace, fed by replay
axon_participation = level(axon_fast_trace) // read replayed response as participation
axon_fast_trace *= decay(s)
// ===== ACTION (change the structure — the night's defining deed) =====
NIGHT | change the structure:
axon_structure -= decay_rate·Δt_cycle; axon_structure += min(axon_maint, maint_cost) // homeostatic lowering
if axon_tag > tag_expiry and axon_participation ≥ MEDIUM:
Δ = min(slot_batch, axon_material, axon_energy·f_cap, axon_tag) × axon_participation
axon_structure += Δ; axon_material -= Δ; axon_energy -= Δ·assembly_cost; axon_tag -= Δ
if axon_endurance_need > endur_thr:
Δ' = min(cap_batch, axon_material·f_cap, axon_energy·f_cap)
axon_budget_ceiling += Δ'; axon_material -= Δ'; axon_energy -= Δ'·biogenesis_cost
axon_endurance_need -= Δ'
else:
axon_budget_ceiling -= capacity_decay_rate·Δt_cycle; axon_budget_ceiling += min(axon_cap_maint, cap_cost)
axon_endurance_need *= decay(slow)
// MEDIUM: prime relay excitability from the standing tag
axon_spont_thr = spont_thr_base − thr_gain × axon_tag
// SLOW: settle
axon_fast_trace *= decay(s); axon_tag *= decay(hr); axon_endurance_need *= decay(slow)
emit(axon_fatigue, axon_demand → upward)
```