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
+129 -106
View File
@@ -573,25 +573,41 @@ DAY | quiet: // sustained quiet
post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. // ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern.
// (ACTION ⇄ RECOVERY) × cycles, then PREPARATION. Night PREPARATION replays the DAY ACTION (same // Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release contend WITHIN (participation
// AMPA/NMDA machinery, same endurance trace), read for participation not significance. // 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) ===== // ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
NIGHT | import + prime: NIGHT | build or release:
post_material += transit(post_material_ship, τ_transport_spine) 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_energy += transit(post_energy_ship, τ_transport_spine)
post_spont_thr = spont_thr_base − thr_gain × post_tag // restore responsiveness from standing tag post_material += post_freed_material; post_freed_material = 0 // reclaim what release freed
if post_tag > prime_thr:
AMPA_surface = min(AMPA_surface + prime_gain × post_tag, post_structure.slot_ceiling)
post_possible_tag *= occupancy_downscale
if renorm_signal arrived: if renorm_signal arrived:
freed = post_structure × (1 - renorm_signal); post_structure *= renorm_signal freed = post_structure × (1 - renorm_signal); post_structure *= renorm_signal
emit(freed → recycled material pool) emit(freed → recycled material pool)
post_material += post_ceiling_shrinkage·recycle // energy NOT recovered 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) ===== // ===== PREPARATION (REPLAY the response — SAME machinery as day ACTION; multi-timescale) =====
NIGHT | replay + measure: // response here is PREPARATION, not the deed NIGHT | replay + measure + prime:
if arrived_glutamate_replay or arrived_replay_AP: // re-evoked input arrives // FAST: replay the response to the re-evoked input (probe)
if arrived_glutamate_replay or arrived_replay_AP:
a = sat(glutamate, K_AMPA) a = sat(glutamate, K_AMPA)
post_fast_trace += AMPA_Ca·(a × AMPA_surface) // SAME AMPA machinery as DAY ACTION post_fast_trace += AMPA_Ca·(a × AMPA_surface) // SAME AMPA machinery as DAY ACTION
if Vm > Mg_eject and astro_Dserine > Dserine_thr: 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_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 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_participation = level(post_fast_trace) // read replayed response as participation
post_fast_trace *= decay(ms) // MEDIUM: prime responsiveness (AMPA occupancy) from the standing tag
post_spont_thr = spont_thr_base − thr_gain × post_tag
// ===== ACTION (change the structure — the night's defining deed) ===== if post_tag > prime_thr:
NIGHT | change the structure: AMPA_surface = min(AMPA_surface + prime_gain × post_tag, post_structure.slot_ceiling)
post_structure -= decay_rate·Δt_cycle; post_structure += min(post_maint, maint_cost) // homeostatic lowering post_possible_tag *= occupancy_downscale
if post_tag > tag_expiry and post_participation ≥ MEDIUM: // SLOW: settle
Δ = min(slot_batch, post_material, post_energy·f_cap, post_tag) × post_participation post_fast_trace *= decay(ms); post_tag *= decay(hr); post_endurance_need *= decay(slow)
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)
emit(post_fatigue, post_demand → upward) // not a sink: emits inward/upward by night 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 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 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 soma, and ships material and budget to the spines it supports.
DAY contexts and the NIGHT scope.
**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the **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 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_possible_tag *= decay(s); dend_endurance_need *= decay(min) // MEDIUM
dend_tag *= decay(hr) // SLOW dend_tag *= decay(hr) // SLOW
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. DEND is an // ── NIGHT: SAME three categories, subject = the pattern. DEND is an intermediate RELAY: its
// intermediate RELAY: its PREPARATION replay relays replay_AP onward to spines IF primed (carrying // PREPARATION replay relays replay_AP onward to spines IF primed (carrying SOMA→DEND→POST).
// SOMA→DEND→POST). (ACTION ⇄ RECOVERY) × cycles, then PREPARATION. // Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release WITHIN; material BETWEEN.
// ===== RECOVERY (import + prime relay excitability + ship down) ===== // ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists) =====
NIGHT | import + prime: 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 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_material += transit(soma_material_to_dend, τ_transport_dend)
dend_energy += transit(soma_energy_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 dend_material += dend_freed_material; dend_freed_material = 0 // reclaim what release freed
if renorm_signal arrived: if renorm_signal arrived:
freed = dend_structure × (1 - renorm_signal); dend_structure *= renorm_signal freed = dend_structure × (1 - renorm_signal); dend_structure *= renorm_signal
emit(freed → recycled material pool) emit(freed → recycled material pool)
dend_material += dend_ceiling_shrinkage·recycle // energy NOT recovered 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_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) 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) ===== // ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) =====
NIGHT | replay + measure: // propagation here is PREPARATION, not the deed NIGHT | replay + measure + prime:
if arrived_replay_AP and dend_spont_thr < recruit_thr: // relay onward to spines IF primed // 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 bAP_local = propagate(replay_AP, dend_structure.bAP_fidelity, geometry) // SAME propagate machinery
emit(bAP_local → POST) // carries the pattern to the spines emit(bAP_local → POST) // carries the pattern to the spines
dend_fast_trace += bAP_Ca(bAP_local) dend_fast_trace += bAP_Ca(bAP_local)
if dend_budget < prop_cost and dend_fast_trace > traj_thr: // SAME capacity check → endurance 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_endurance_need += dend_fast_trace // SAME trace, fed by replay
dend_participation = level(dend_fast_trace) // read replayed response as participation dend_participation = level(dend_fast_trace) // read replayed response as participation
dend_fast_trace *= decay(300ms) // MEDIUM: prime bAP-relay excitability from the standing tag
dend_spont_thr = spont_thr_base − thr_gain × dend_tag
// ===== ACTION (change the structure — the night's defining deed) ===== // SLOW: settle
NIGHT | change the structure: dend_fast_trace *= decay(300ms); dend_tag *= decay(hr); dend_endurance_need *= decay(slow)
dend_structure -= decay_rate·Δt_cycle; dend_structure += min(dend_maint, maint_cost) // homeostatic lowering
if dend_tag > tag_expiry and dend_participation ≥ MEDIUM:
Δ = 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)
emit(dend_fatigue, dend_demand → upward) 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 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 — 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 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 **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 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 // ── 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 // (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 // replay_AP down axon + dendrites. Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release
// carries only if every link is primed. Night PREPARATION mirrors day ACTION (same fire machinery), // contend WITHIN (participation arbitrates); material contends BETWEEN components (recovery).
// read for participation, not significance. (ACTION ⇄ RECOVERY) × cycles, then PREPARATION.
// ===== RECOVERY (produce + restore the ability to restructure: material, energy, excitability) ===== // ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) =====
NIGHT | produce + prime: // ROOT production + alter-ego of night ACTION NIGHT | build or release:
soma_material += CREB_synth(soma_tag)·Δt_cycle // material — recoverable if soma_tag > tag_expiry and soma_participation ≥ MEDIUM: // BUILD (slice)
soma_energy += mito_synth()·Δt_cycle // energy — NOT recoverable Δ = 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 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_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)
soma_energy_to_dend += ship(soma_energy, dend_demand, f_dend, 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_energy_to_axon += ship(soma_energy, axon_demand, f_axon, ship_cost)
soma_material += soma_ceiling_shrinkage·recycle 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) ===== // ===== PREPARATION (REPLAY the fire — SAME machinery as day ACTION; ignites the pattern; multi-timescale) =====
NIGHT | replay-fire + measure: // firing here is PREPARATION, not the deed NIGHT | replay-fire + measure + prime:
// FAST: replay-fire (probe); ignites the pattern down the day pathway
spont = intrinsic_fluctuation() spont = intrinsic_fluctuation()
if spont > soma_spont_thr: // ignite (SAME threshold logic as day fire) if spont > soma_spont_thr: // ignite (SAME threshold logic as day fire)
replay_AP = TRUE replay_AP = TRUE
@@ -861,22 +890,10 @@ NIGHT | replay-fire + measure: // firing here is PRE
// 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 soma_participation = level(soma_fast_trace) // read replayed response as participation
soma_fast_trace *= decay(τ_nuclear) // MEDIUM: prime firing excitability from the standing tag
soma_spont_thr = spont_thr_base − thr_gain × soma_tag
// ===== ACTION (change the structure — the night's defining deed) ===== // SLOW: settle
NIGHT | change the structure: soma_fast_trace *= decay(τ_nuclear); soma_tag *= decay(hr); soma_endurance_need *= decay(slow)
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)
``` ```
--- ---
@@ -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 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 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 **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 — (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_possible_tag *= decay(s); axon_endurance_need *= decay(min) // MEDIUM
axon_tag *= decay(hr) // SLOW axon_tag *= decay(hr) // SLOW
// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. AXON is an // ── NIGHT: SAME three categories, subject = the pattern. AXON is an intermediate RELAY: its
// intermediate RELAY: its PREPARATION replay relays replay_AP onward to boutons IF primed (carrying // PREPARATION replay relays replay_AP onward to boutons IF primed (carrying SOMA→AXON→PRE).
// SOMA→AXON→PRE). (ACTION ⇄ RECOVERY) × cycles, then PREPARATION. // Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release WITHIN; material BETWEEN.
// ===== RECOVERY (import + prime relay excitability + ship down) ===== // ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists) =====
NIGHT | import + prime: 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_material += transit(soma_material_to_axon, τ_transport_dend)
axon_energy += transit(soma_energy_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: if renorm_signal arrived:
freed = axon_structure × (1 - renorm_signal); axon_structure *= renorm_signal freed = axon_structure × (1 - renorm_signal); axon_structure *= renorm_signal
emit(freed → recycled material pool) emit(freed → recycled material pool)
axon_material += axon_ceiling_shrinkage·recycle // energy NOT recovered 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_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) 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) ===== // ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) =====
NIGHT | replay + measure: // propagation here is PREPARATION, not the deed NIGHT | replay + measure + prime:
if arrived_replay_AP and axon_spont_thr < recruit_thr: // relay onward to boutons IF primed // 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 reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // SAME reliability machinery
delivered = reliability × axon_structure.propagation delivered = reliability × axon_structure.propagation
emit(replay_AP → PRE) // carries the pattern to the boutons 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 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_endurance_need += axon_fast_trace // SAME trace, fed by replay
axon_participation = level(axon_fast_trace) // read replayed response as participation axon_participation = level(axon_fast_trace) // read replayed response as participation
axon_fast_trace *= decay(s) // MEDIUM: prime relay excitability from the standing tag
axon_spont_thr = spont_thr_base − thr_gain × axon_tag
// ===== ACTION (change the structure — the night's defining deed) ===== // SLOW: settle
NIGHT | change the structure: axon_fast_trace *= decay(s); axon_tag *= decay(hr); axon_endurance_need *= decay(slow)
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)
emit(axon_fatigue, axon_demand → upward) emit(axon_fatigue, axon_demand → upward)
``` ```