From ac97417beb1f0c1144def89ad19e1072cd915a5e Mon Sep 17 00:00:00 2001 From: ocrampal Date: Sun, 5 Jul 2026 20:37:59 +0200 Subject: [PATCH] varie --- .../2026-06-29-tripartite-synapse_v17.md | 218 +++++++++--------- 1 file changed, 115 insertions(+), 103 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 add06e5..56bd995 100644 --- a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -138,29 +138,31 @@ always integrating fatigue and emitting sleep-pressure, spanning every other act night — the clock that never sleeps. 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). +is exhausted; NIGHT loops NON_REM_1 → REM → NON_REM_2 cycles until the tag is exhausted. It is the +SAME three-phase ring as DAY (PREPARATION · ACTION · EVALUATION) — only the subjects and the +assignment of which phase is ACTION vs EVALUATION rotate: + NON_REM_1 = PREPARATION import material/energy; PRIME the threshold/VGCC from the standing tag + REM = EVALUATION release NT as a PROBE to MEASURE participation (fast_trace level); + NO dopamine — significance is settled; this reads circuit centrality only + NON_REM_2 = ACTION the structural change itself (the night's defining deed): general + homeostatic lowering, then increase where tag stands AND REM measured + high/medium participation, consuming the tag on the build +The SAME physical NT release is ACTION by DAY (transmit) and EVALUATION by NIGHT (probe to measure). +The structural change is only MARKED by day (the inert tag) and ENACTED by night. SOMA is the +ignition point: its REM firing propagates a replay_AP through the DAY PATHWAYS +(soma→axon→pre→glutamate→post→dend→soma), self-igniting the tagged 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. +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 in NON_REM_1); one +un-primed link breaks the loop 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). +WHAT PERSISTS MUST HAVE EARNED PERSISTENCE. NON_REM_1 drives occupancy (VGCC_active, AMPA_surface, +possible_tag) toward baseline; NON_REM_2's homeostatic lowering trims all structure; only what is +rebuilt from a still-standing tag with confirmed participation carries forward. NIGHT ends when the +tag is exhausted (well-rested — every significant pattern replayed and its structure rebuilt) OR +energy is spent (overloaded — unspent tags carry to the next night). --- @@ -256,17 +258,19 @@ ship_cost // transport overhead (all shipments) ``` 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 (relax→replay→commit) +Δt_cycle // duration of one NIGHT cycle (NON_REM_1→REM→NON_REM_2) maint_frac cap_frac // maintenance allocation decay_rate capacity_decay_rate recycle // passive ceiling decay + material recovery 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-RELAX multiplicative occupancy reset (<1) +downscale_factor // per-cycle multiplicative occupancy reset (<1), NON_REM_1 neuron_weight_ceiling // renormalization target (broadcast constraint) -// ── REPLAY (spontaneous re-evocation) ── -spont_thr_base thr_gain // spontaneous threshold = base − gain×own_tag (RELAX) +// ── NIGHT RING (NON_REM_1 = PREPARATION · REM = EVALUATION · NON_REM_2 = ACTION) ── +spont_thr_base thr_gain // spontaneous threshold = base − gain×own_tag (NON_REM_1 prime) +prime_thr prime_gain // tag threshold to raise VGCC, and the gain (NON_REM_1) 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 +mini_flux mini_Ca() // spontaneous mini release size + its Ca deposit (REM probe) +level(·) → {LOW, MEDIUM, HIGH} // reads fast_trace as circuit participation (REM, no dopamine) replay_AP // propagated re-evocation spike (soma → axon/dend, self-igniting) ``` @@ -303,12 +307,16 @@ vesicles *toward the next demand* (not a restoration — forward-facing), and le Preparation is the sole gateway to the next action. **NIGHT — the ring turned inward.** ACTION is the coherence check (does post and astro concur this -change should be kept). EVALUATION is draw-and-commit: burn shipped material and energy into -**structure** (where a validated tag stood) or **budget capacity** (where fuel interrupted a -succeeding release), spending the tag — the token minted for the next day. PREPARATION is -make-room: take the descended constraint, recycle material from decayed ceilings, ready for the -next round. The bouton is not a sink — by night it emits inward and upward (fatigue, demand, -recycled material). +**NIGHT — the same ring, rotated; release becomes a probe, structure-change becomes the act.** +The night runs the SAME three phases as the day (PREPARATION · ACTION · EVALUATION) — only the +subjects and the assignment of which phase is which rotate. NON_REM_1 = PREPARATION imports material +and energy and primes the threshold/VGCC from the standing tag. REM = EVALUATION releases NT — but +as a PROBE, to measure its own fast_trace as *participation* in the re-evoked circuit (no dopamine; +significance is settled). NON_REM_2 = ACTION is the structural change itself — the night's defining +deed: general homeostatic lowering, then increase where the tag still stands AND REM measured +high/medium participation, consuming the tag on the build. The same NT release is ACTION by day +(transmit) and EVALUATION by night (measure); the structural change is only marked by day (the inert +tag) and enacted by night. The bouton is not a sink — by night it emits inward and upward. ``` // PARAMETERS K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake @@ -370,51 +378,56 @@ 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: 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: a cycle of NON_REM_1 → REM → NON_REM_2, repeated until the tag is spent (dual of DAY, +// which loops until energy is spent). SAME RING as DAY, only the SUBJECTS and the assignment of +// ACTION/EVALUATION rotate — the same physical NT release is ACTION by DAY (transmit) and +// EVALUATION by NIGHT (probe to measure participation). One TAG, three roles: (day) significance +// bridge; (NON_REM_1) primes threshold/VGCC; (NON_REM_2) gates + fuels the build, then consumed. +// NON_REM_1 = PREPARATION (import + prime) — vertical +// REM = EVALUATION (release to MEASURE participation; NO dopamine) — local/measuring +// NON_REM_2 = ACTION (the structural change itself — the night's defining deed) — the act -NIGHT · RELAX | lower own threshold: // vertical: prepare excitability + make room - // receive shipped batch for this cycle (forward-facing) +NIGHT · NON_REM_1 = PREPARATION | import + prime: // vertical: supply + set excitability + // import this cycle's material + energy (forward-facing) pre_material += transit(pre_material_ship, τ_transport_bouton) pre_energy += transit(pre_energy_ship, τ_transport_bouton) - // lower OWN spontaneous-release threshold in proportion to OWN tag (primes participation) + // prime from the STANDING tag: high tag lowers threshold → raises VGCC (else leave unchanged) 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 pre_tag > prime_thr: + VGCC_active = min(VGCC_active + prime_gain × pre_tag, pre_structure.VGCC_coupling) + // apply descended constraint to MYSELF (broadcast only); recycle + pre_possible_tag *= occupancy_downscale if renorm_signal arrived: freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal emit(freed → recycled material pool) 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) -NIGHT · REPLAY | spontaneous re-evocation (structural umbrella): // lateral: re-ignite tagged pattern - // spontaneous release if intrinsic fluctuation crosses the tag-lowered threshold +NIGHT · REM = EVALUATION | release to MEASURE participation (NO dopamine): // local: probe, not transmit + // release using the primed VGCC — a PROBE, deposits fast trace (same channel as DAY, different purpose) 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) + if spont > pre_spont_thr or arrived_replay_AP: // spontaneous, or recruited by the propagating pattern + pre_fast_trace += mini_Ca(VGCC_active); glutamate += mini_flux·Δt + // READ the fast trace as PARTICIPATION in the re-evoked circuit — no dopamine, no tag accumulation + pre_participation = level(pre_fast_trace) // high / medium / low = circuit centrality + pre_fast_trace *= decay(100ms) -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) +NIGHT · NON_REM_2 = ACTION | change the structure (the night's defining deed): // the irreversible act + // (1) general homeostatic lowering of structure — the subtractive baseline + pre_structure -= decay_rate·Δt_cycle + pre_structure += min(pre_maint, maint_cost) // maintenance holds up what is used + // (2) increase structure where the tag STILL STANDS and REM measured high/medium participation + if rest_permission and pre_tag > tag_expiry and pre_participation ≥ MEDIUM: + Δ = min(slot_batch, pre_material, pre_energy·f_cap, pre_tag) × pre_participation 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_tag -= Δ // (3) CONSUME tag on build → threshold rises next cycle + // endurance capacity (fuel-limited succeeding release) builds on the same act + 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 -= Δ' + else: + pre_budget_ceiling -= capacity_decay_rate·Δt_cycle; pre_budget_ceiling += min(pre_cap_maint, cap_cost) + // if tag low or participation low: no build — the change was never worth the spend (forgotten) pre_endurance_need *= decay(slow) emit(pre_fatigue, pre_demand → upward) // not a sink: emits inward/upward by night ``` @@ -715,50 +728,50 @@ DAY | NOT_AP: // EVAL (align) + PRE // SLOW (hr) soma_tag *= decay(hr); dopamine *= decay(ms) -// ── 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: NON_REM_1 → REM → NON_REM_2, until tag spent (same ring as PRE, rotated). SOMA is a +// ROOT (produces material each cycle) AND the IGNITION POINT: its REM 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). SOMA's own +// firing/participation is measured the way PRE measures release; NON_REM_2 is its structural act. -NIGHT · RELAX | produce + lower own firing threshold: // vertical: production + excitability + make room +NIGHT · NON_REM_1 = PREPARATION | produce + prime: // vertical: production + excitability + supply // 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 night_energy_spent += mito_synth()·Δt_cycle - // lower OWN spontaneous-firing threshold in proportion to OWN tag (primes ignition) + // prime OWN spontaneous-firing threshold from OWN standing tag (high tag → easier to ignite) 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) - // recycle + settle - soma_material += soma_ceiling_shrinkage·recycle - 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_material += soma_ceiling_shrinkage·recycle // recycle -NIGHT · REPLAY | spontaneous firing ignites the pattern: // lateral: re-evoke through the day pathway - // spontaneous AP if intrinsic fluctuation crosses the tag-lowered threshold +NIGHT · REM = EVALUATION | fire to ignite + MEASURE participation (NO dopamine): // ignition + probe spont = intrinsic_fluctuation() if spont > soma_spont_thr: - replay_AP = TRUE; soma_replayed = TRUE + replay_AP = TRUE + soma_fast_trace += nuclear_Ca() // deposit trace (the measurement) // 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): + emit(replay_AP → AXON, DEND) // AXON/DEND relay onward IF primed + // 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. + // a single un-primed link breaks the loop — only all-primed patterns re-evoke. + soma_participation = level(soma_fast_trace) // high/medium/low = circuit centrality (no dopamine) + soma_fast_trace *= decay(τ_nuclear) -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) +NIGHT · NON_REM_2 = ACTION | change the structure: // the night's defining deed + 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 → threshold rises next RELAX + soma_tag -= Δ // CONSUME on build → threshold rises 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 -= Δ' - // if not ignited this cycle: allocate nothing, hold tag, leave resource — defer - soma_replayed = FALSE + // if tag low or participation low: no build — never worth the spend (forgotten) soma_endurance_need *= decay(slow) ``` @@ -967,19 +980,18 @@ DAY or NIGHT | OVERLOAD: --- --- -> 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.] +> NIGHT-BLOCK UNIFORMITY. PRE and SOMA above are the worked exemplars of the NIGHT ring +> (NON_REM_1 = PREPARATION · REM = EVALUATION · NON_REM_2 = ACTION). POST, DEND, AXON, and +> ASTROSYNAPSE follow the identical pattern: (a) NON_REM_1 imports supply, primes each one's OWN +> threshold from its OWN standing tag (→ occupancy), applies the descended constraint to itself, +> recycles, and — for intermediate nodes AXON/DEND — relays the arrived `replay_AP` onward IF primed +> (this carries the pattern SOMA→PRE and SOMA→POST); (b) REM releases/fires as a PROBE and reads its +> own fast_trace as participation (level: high/medium/low), NO dopamine; (c) NON_REM_2 lowers +> structure homeostatically, then rebuilds where the tag still stands AND participation ≥ medium, +> consuming the tag on the build. Roots (SOMA material, ASTROCYTE energy) additionally PRODUCE each +> cycle and track `night_energy_spent`. +> [The POST/DEND/AXON/ASTROSYNAPSE night blocks below still show the earlier commit form and are +> pending conversion to NON_REM_1/REM/NON_REM_2 — the mechanism is defined by PRE + SOMA.] --- --- @@ -1015,9 +1027,9 @@ 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) - // 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) + // the neuron acts ONLY by signalling; components prime/measure/rebuild themselves. Each + // component's cycle is NON_REM_1→REM→NON_REM_2; the neuron just supplies the constraint. + occupancy_downscale = downscale_factor // → components reset own occupancy (in NON_REM_1) 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