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 993f080..add06e5 100644 --- a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -125,7 +125,9 @@ they cannot open, then BROADCASTS — it never reaches into a constituent's inte ↓ signal (NEURON over soma/pre/post/dend/axon ; ASTROCYTE over astrosynapses) COMPONENTS soma · pre · post · dend · axon · astrosynapse — each restructures ITSELF when its own DAY/NIGHT transition (above) grants the window - [ ASSEMBLY / NETWORK ] replay_reweight arrives as an EXTERNAL signal (like dopamine/glucose) + [ ASSEMBLY / NETWORK ] replay is INTERNALLY generated (spontaneous firing, below); the external + replay_reweight only BIASES which internal patterns are favored (cross-neuron + coordination), arriving like dopamine/glucose — it is not the replay itself ``` The two cell actors are structurally identical — same integrate-and-broadcast role, different @@ -135,13 +137,30 @@ territory demand/load. Both have their own DAY (integrate, allocate in the gaps) always integrating fatigue and emitting sleep-pressure, spanning every other actor's day and night — the clock that never sleeps. -NIGHT IS PHASED, AND OCCUPANCY RESETS. When a component is in NIGHT, early cycles DOWNSCALE -(occupancy filled during its day — VGCC_active, AMPA_surface, possible_tag — driven toward -baseline by multiplicative-global scaling broadcast by the neuron; total weight renormalized), -later cycles COMMIT (survivors' tags build ceilings). The rule the phasing enforces: WHAT -PERSISTS ACROSS A NIGHT MUST HAVE EARNED PERSISTENCE — occupancy that earned no tag returns to -baseline; only ceilings carry forward. A tagged synapse starts the next day strong because its -ceiling was raised, not because its transient occupancy was spared. +NIGHT IS A SEQUENCE OF REPLAY CYCLES (dual of DAY). DAY loops action-steps until energy/material +is exhausted; NIGHT loops RELAX → REPLAY → COMMIT cycles until the tag is exhausted. Each cycle: +RELAX lowers each component's OWN spontaneous-firing/release threshold in proportion to its OWN +tag (and makes room: downscale occupancy, renormalize, recycle); REPLAY is spontaneous, intrinsic +firing — where a component's threshold has dropped enough, intrinsic fluctuation ignites it, and +the activation propagates through the SAME DAY PATHWAYS (soma→axon→pre→glutamate→post→dend→soma), +self-igniting, re-evoking the tagged pattern; COMMIT lets each re-evoked component allocate a slice +of its tag to THIS replayed behavior, build structure, and CONSUME that slice (raising its +threshold back, so the next cycle surfaces a different pattern). + +REPLAY REUSES DAY PATHWAYS UNDER A STRUCTURAL UMBRELLA. The re-activated components run their NIGHT +code (test structural fit, allocate), NOT their DAY code (evaluate significance) — significance was +already settled by day; the tag is why the pattern replays. COHERENCE IS MECHANICAL, not a checked +flag: a pattern re-evokes only where EVERY link in its recurrent loop is primed (each component's +own tag lowered its own threshold); a loop with one un-primed link breaks at the gap, so only +patterns significant all the way around carry. The assembly that replays is NOT an actor — it is +the coincidence of many components' own lowered thresholds propagating through recurrent coupling. + +WHAT PERSISTS MUST HAVE EARNED PERSISTENCE. RELAX drives occupancy (VGCC_active, AMPA_surface, +possible_tag) toward baseline; only ceilings, built in COMMIT from a replayed-and-allocated tag, +carry forward. A tagged synapse starts the next day strong because its ceiling was raised, not +because its transient occupancy was spared. NIGHT ends when the tag is exhausted (well-rested — +every significant pattern replayed and allocated) OR energy is spent (overloaded — unspent tags +carry to the next night). --- @@ -235,16 +254,20 @@ ship_cost // transport overhead (all shipments) ## NIGHT parameters (consolidation only) ``` -slot_batch cap_batch f_cap // per-CYCLE commit sizes / endurance fraction +slot_batch cap_batch f_cap // per-CYCLE commit/allocation sizes / endurance fraction night_energy_ceiling // total energy a single night can spend (supply bound) -Δt_cycle // duration of one NIGHT cycle +Δt_cycle // duration of one NIGHT cycle (relax→replay→commit) maint_frac cap_frac // maintenance allocation decay_rate capacity_decay_rate recycle // passive ceiling decay + material recovery -homeostatic_ceiling coherence_factor assembly_cost biogenesis_cost maint_cost +homeostatic_ceiling assembly_cost biogenesis_cost maint_cost f_dend f_axon f_spine f_bouton // per-cycle material/energy ship fractions (down the chain) -downscale_factor // per-early-cycle multiplicative occupancy reset (<1) -neuron_weight_ceiling // the cell's total-weight budget (renormalization target) -early_phase_frac // fraction of night cycles that are DOWNSCALE phase +downscale_factor // per-RELAX multiplicative occupancy reset (<1) +neuron_weight_ceiling // renormalization target (broadcast constraint) +// ── REPLAY (spontaneous re-evocation) ── +spont_thr_base thr_gain // spontaneous threshold = base − gain×own_tag (RELAX) +intrinsic_fluctuation() // intrinsic sub-threshold noise (the night's ignition source) +mini_flux recruit_thr // spontaneous mini size ; threshold to be recruited by arrived replay_AP +replay_AP // propagated re-evocation spike (soma → axon/dend, self-igniting) ``` --- @@ -347,35 +370,52 @@ DAY | NOT_SPIKE_TRAIN: // SLOW eval + SLOW p pre_tag *= decay(hr) // SLOW dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s) -NIGHT · ACTION | coherence check: // lateral: does post & astro concur? - coh = coherence_signal // arrived verdict (pre+post+astro tags aligned) - // (this is the night's "release": signal the standing claim, read what returns; leaves coh as trace) +// ── NIGHT: a cycle of RELAX → REPLAY → COMMIT, repeated until the tag is spent (dual of DAY, +// which loops until energy is spent). The tag has THREE roles: (day) significance bridge; +// (night) lowers own spontaneous threshold in RELAX; consumed by allocation in COMMIT. +// Replay reuses the DAY PATHWAY (soma→axon→PRE→glutamate→post…) but under a STRUCTURAL +// umbrella — PRE does not re-evaluate significance (already settled), it tests structural fit +// and allocates. Propagation carries only where every link is primed (mechanical coherence). -NIGHT · EVALUATION | draw & commit (only if coherent + permitted): // local: mint structure for next DAY - if rest_permission and pre_tag > tag_expiry: - Δ = min(slot_batch, pre_material, pre_energy·f_cap) - pre_structure += Δ × coh; pre_material -= Δ; pre_energy -= Δ·assembly_cost - pre_tag -= Δ // tag-as-fuel; energy burned only here (irreversible) - if rest_permission and pre_endurance_need > endur_thr: - Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap) - pre_budget_ceiling += Δ'; pre_material -= Δ'; pre_energy -= Δ'·biogenesis_cost - pre_endurance_need -= Δ' - // if not coherent / not permitted: draw nothing, hold the tag, leave resource for peers — defer - -NIGHT · PREPARATION | make room: // vertical: take constraint, recycle, ready - // receive shipped batch for the next round (forward-facing) +NIGHT · RELAX | lower own threshold: // vertical: prepare excitability + make room + // receive shipped batch for this cycle (forward-facing) pre_material += transit(pre_material_ship, τ_transport_bouton) pre_energy += transit(pre_energy_ship, τ_transport_bouton) - // apply the descended constraint to MYSELF (neuron only broadcasts; I scale myself) + // lower OWN spontaneous-release threshold in proportion to OWN tag (primes participation) + pre_spont_thr = spont_thr_base − thr_gain × pre_tag + // apply descended constraint to MYSELF (broadcast only; I scale myself); recycle; settle VGCC_active *= occupancy_downscale; pre_possible_tag *= occupancy_downscale if renorm_signal arrived: freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal emit(freed → recycled material pool) - // recycle material from decayed ceilings; unmaintained ceilings drift; emit inward/upward pre_material += pre_ceiling_shrinkage·recycle // energy NOT recovered pre_structure -= decay_rate·Δt_cycle; pre_budget_ceiling -= capacity_decay_rate·Δt_cycle pre_structure += min(pre_maint, maint_cost); pre_budget_ceiling += min(pre_cap_maint, cap_cost) - pre_tag *= decay(slow); pre_endurance_need *= decay(slow) + +NIGHT · REPLAY | spontaneous re-evocation (structural umbrella): // lateral: re-ignite tagged pattern + // spontaneous release if intrinsic fluctuation crosses the tag-lowered threshold + spont = intrinsic_fluctuation() + if spont > pre_spont_thr: + glutamate += mini_flux·Δt // spontaneous mini → POST (same day channel) + pre_replayed = TRUE // I am participating in this re-evocation + // OR: I am recruited because my SOMA spontaneously fired and its bAP/AP reached me primed + if arrived_replay_AP and pre_spont_thr < recruit_thr: + pre_replayed = TRUE + // (no significance evaluation here — that was DAY; this is structural testing only) + +NIGHT · COMMIT | allocate tag to THIS replayed behavior: // local: mint structure, consume tag + if pre_replayed and rest_permission: + // allocate a SLICE of the tag to the behavior just re-evoked (incremental, not all at once) + Δ = min(slot_batch, pre_material, pre_energy·f_cap, pre_tag) + pre_structure += Δ; pre_material -= Δ; pre_energy -= Δ·assembly_cost + pre_tag -= Δ // CONSUME tag → threshold rises next RELAX + if pre_endurance_need > endur_thr: + Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap) + pre_budget_ceiling += Δ'; pre_material -= Δ'; pre_energy -= Δ'·biogenesis_cost + pre_endurance_need -= Δ' + // if not replayed this cycle: allocate nothing, hold the tag, leave resource for others — defer + pre_replayed = FALSE + pre_endurance_need *= decay(slow) emit(pre_fatigue, pre_demand → upward) // not a sink: emits inward/upward by night ``` @@ -675,32 +715,51 @@ DAY | NOT_AP: // EVAL (align) + PRE // SLOW (hr) soma_tag *= decay(hr); dopamine *= decay(ms) -NIGHT | cycle: // ROOT (neuronal material) — produces each cycle - // RECEIVE = PRODUCTION: synthesize this cycle's batch, gated by own tag, capped externally +// ── NIGHT: RELAX → REPLAY → COMMIT, until tag spent. SOMA is a ROOT (produces material each +// cycle) AND the IGNITION POINT for pattern replay: its spontaneous firing propagates a replay +// AP down axon + dendrites, re-evoking the pattern through the DAY PATHWAY. A pattern carries +// only if every link is primed (each component's own tag lowered its own threshold). + +NIGHT · RELAX | produce + lower own firing threshold: // vertical: production + excitability + make room + // PRODUCTION (root): this cycle's material + energy batch, gated by own tag, capped externally soma_material += CREB_synth(soma_tag)·Δt_cycle // material — recoverable - soma_energy += mito_synth()·Δt_cycle // energy — NOT recoverable, bounded by night budget - night_energy_spent += mito_synth()·Δt_cycle // track against night supply ceiling - // TRACE read standing demand (soma_tag → structure ; soma_endurance_need → budget_ceiling) - // ADJUST (no coherence — SOMA is not a synaptic component) - // BEHAVE commit own batches - if soma_tag > tag_expiry: - Δ = min(slot_batch, soma_material, soma_energy·f_cap) - soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost; soma_tag -= Δ - 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 -= Δ' - // EMIT ship batches one hop down to DEND and AXON (demand = propagated tags) + soma_energy += mito_synth()·Δt_cycle // energy — NOT recoverable + night_energy_spent += mito_synth()·Δt_cycle + // lower OWN spontaneous-firing threshold in proportion to OWN tag (primes ignition) + soma_spont_thr = spont_thr_base − thr_gain × soma_tag + // ship this cycle's batch down to DEND and AXON (feeds the pattern's downstream links) soma_material_to_dend += ship(soma_material, dend_demand, f_dend, 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_axon += ship(soma_energy, axon_demand, f_axon, ship_cost) - // RECOVER reclaim material from decayed ceilings (own + returned from downstream) + // recycle + settle soma_material += soma_ceiling_shrinkage·recycle - // DECAY soma_structure -= decay_rate·Δt_cycle; soma_budget_ceiling -= capacity_decay_rate·Δt_cycle soma_structure += min(soma_maint, maint_cost); soma_budget_ceiling += min(soma_cap_maint, cap_cost) - soma_tag *= decay(slow); soma_endurance_need *= decay(slow) + +NIGHT · REPLAY | spontaneous firing ignites the pattern: // lateral: re-evoke through the day pathway + // spontaneous AP if intrinsic fluctuation crosses the tag-lowered threshold + spont = intrinsic_fluctuation() + if spont > soma_spont_thr: + replay_AP = TRUE; soma_replayed = TRUE + // propagate down the DAY PATHWAY (self-igniting): AP → axon → boutons ; bAP → dendrites/spines + emit(replay_AP → AXON, DEND) // AXON/DEND relay onward IF they are primed + // the pattern carries link by link, each relaying only if primed (mechanical coherence): + // SOMA →[replay_AP]→ AXON(primed?) →→ PRE(primed?) →[glutamate]→ POST(primed?) →→ DEND →→ SOMA + // a single un-primed link breaks the loop at the gap — only all-primed patterns re-evoke. + +NIGHT · COMMIT | allocate tag to THIS replayed pattern: // local: mint structure, consume tag + if soma_replayed: + Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag) + soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost + soma_tag -= Δ // CONSUME → threshold rises next RELAX + 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 -= Δ' + // if not ignited this cycle: allocate nothing, hold tag, leave resource — defer + soma_replayed = FALSE + soma_endurance_need *= decay(slow) ``` --- @@ -908,15 +967,19 @@ DAY or NIGHT | OVERLOAD: --- --- -> NIGHT-BLOCK UNIFORMITY. PRE's `NIGHT | cycle` above is the worked exemplar. POST, DEND, SOMA, -> AXON, and ASTROSYNAPSE follow the identical pattern, shown in their blocks in abbreviated form: -> (a) all commits are gated by `rest_permission` (arrived from the cell actor); (b) on a -> DOWNSCALE-phase signal each self-resets its own occupancy (`*_occupancy *= occupancy_downscale`) -> and self-renormalizes its own structure (`*_structure *= renorm_signal`, emitting the freed -> material) — the cell actor only broadcasts, the component scales itself; (c) each emits its own -> fatigue upward. Roots (SOMA material, ASTROSYNAPSE/ASTROCYTE energy) additionally PRODUCE their -> batch each cycle and track `night_energy_spent`. Only the occupancy-holders (PRE: VGCC_active, -> POST: AMPA_surface) carry the self-downscale line; the rest carry only the structure renorm. +> NIGHT-BLOCK UNIFORMITY. PRE and SOMA above are the worked exemplars of the NIGHT replay cycle +> (RELAX → REPLAY → COMMIT). POST, DEND, AXON, and ASTROSYNAPSE follow the identical pattern: +> (a) RELAX lowers each one's OWN spontaneous threshold from its OWN tag, applies the descended +> constraint to itself (occupancy downscale, structure renorm), recycles, and — for intermediate +> nodes AXON/DEND — relays the arrived `replay_AP` onward IF primed (this is what carries the +> pattern from SOMA to PRE and to POST); (b) REPLAY: the component participates if the propagating +> re-evocation reaches it while its threshold is low (primed), running its STRUCTURAL code, not its +> DAY significance code; (c) COMMIT allocates a slice of its tag to the replayed behavior, builds +> structure, and CONSUMES that slice (raising its threshold). Roots (SOMA material, ASTROCYTE +> energy) additionally PRODUCE each cycle and track `night_energy_spent`. Only occupancy-holders +> (PRE: VGCC_active, POST: AMPA_surface) carry the RELAX self-downscale line. +> [The POST/DEND/AXON/ASTROSYNAPSE night blocks below still show the pre-replay commit form and +> are pending conversion to RELAX/REPLAY/COMMIT — the mechanism is defined by PRE + SOMA.] --- --- @@ -934,7 +997,7 @@ it integrates what its components emit and grants them the restructuring window grant itself. The soma is one of its constituents, a peer of the bouton; the neuron is not the soma. ``` -// PARAMETERS neuron_weight_ceiling · downscale_factor · early_phase_frac · rest_thr +// PARAMETERS neuron_weight_ceiling · downscale_factor · rest_thr // INTERFACE // EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast) // neuron_fatigue → HYPOTHALAMUS @@ -952,13 +1015,11 @@ DAY | active: // (own_activity high // (no restructuring permission while the cell is active — components are busy) NIGHT | cycle: // (own_activity low AND sleep_pressure high) - phase = (cycle ≤ early_phase_frac × est_cycles) ? DOWNSCALE : COMMIT - // ADJUST read replay (external) + own aggregate - // EMIT (broadcast) — the neuron acts ONLY by signalling; components scale themselves - if phase == DOWNSCALE: - occupancy_downscale = downscale_factor // → components reset own occupancy - if neuron_total_weight > neuron_weight_ceiling: - renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure + // the neuron acts ONLY by signalling; components scale/commit themselves. No early/late phase + // split — each component's cycle is RELAX→REPLAY→COMMIT; the neuron just supplies the constraint. + occupancy_downscale = downscale_factor // → components reset own occupancy (in RELAX) + if neuron_total_weight > neuron_weight_ceiling: + renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure rest_permission = TRUE // → components may restructure this cycle // RECOVER reclaim material returned by components' renormalization (arrives as recycled pool) // DECAY neuron_activity relaxes as the cell stays quiet @@ -975,7 +1036,7 @@ material across the territory. The astrosynapse is one of its constituents; the the astrosynapse. ``` -// PARAMETERS (territory reallocation) · early_phase_frac · rest_thr +// PARAMETERS (territory reallocation) · rest_thr // INTERFACE // EMIT astro_alloc[·] (reallocation), rest_permission → own astrosynapses (broadcast) // astro_fatigue → HYPOTHALAMUS ; produced energy+material → territory (roots)