From 9a3d75af042aa3c2c98d282761375ebf411ed0c3 Mon Sep 17 00:00:00 2001 From: ocrampal Date: Mon, 6 Jul 2026 23:14:28 +0200 Subject: [PATCH] Update 2026-06-29-tripartite-synapse_v17.md --- .../2026-06-29-tripartite-synapse_v17.md | 235 ++++++++++-------- 1 file changed, 129 insertions(+), 106 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 b5d4d02..5623d7e 100644 --- a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -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: +// ===== 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 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_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: 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 (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 +// ===== 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 - 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: - Δ = 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) + // 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) ```