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-03 18:43:35 +02:00
parent 3b94db3fdf
commit fe0147dda1
1 changed files with 130 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files
elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md
+130 -69
View File
@@ -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) ↓ signal (NEURON over soma/pre/post/dend/axon ; ASTROCYTE over astrosynapses)
COMPONENTS soma · pre · post · dend · axon · astrosynapse — each restructures ITSELF COMPONENTS soma · pre · post · dend · axon · astrosynapse — each restructures ITSELF
when its own DAY/NIGHT transition (above) grants the window 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 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 always integrating fatigue and emitting sleep-pressure, spanning every other actor's day and
night — the clock that never sleeps. night — the clock that never sleeps.
NIGHT IS PHASED, AND OCCUPANCY RESETS. When a component is in NIGHT, early cycles DOWNSCALE NIGHT IS A SEQUENCE OF REPLAY CYCLES (dual of DAY). DAY loops action-steps until energy/material
(occupancy filled during its day — VGCC_active, AMPA_surface, possible_tag — driven toward is exhausted; NIGHT loops RELAX → REPLAY → COMMIT cycles until the tag is exhausted. Each cycle:
baseline by multiplicative-global scaling broadcast by the neuron; total weight renormalized), RELAX lowers each component's OWN spontaneous-firing/release threshold in proportion to its OWN
later cycles COMMIT (survivors' tags build ceilings). The rule the phasing enforces: WHAT tag (and makes room: downscale occupancy, renormalize, recycle); REPLAY is spontaneous, intrinsic
PERSISTS ACROSS A NIGHT MUST HAVE EARNED PERSISTENCE — occupancy that earned no tag returns to firing — where a component's threshold has dropped enough, intrinsic fluctuation ignites it, and
baseline; only ceilings carry forward. A tagged synapse starts the next day strong because its the activation propagates through the SAME DAY PATHWAYS (soma→axon→pre→glutamate→post→dend→soma),
ceiling was raised, not because its transient occupancy was spared. 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) ## 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) 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 maint_frac cap_frac // maintenance allocation
decay_rate capacity_decay_rate recycle // passive ceiling decay + material recovery 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) 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) downscale_factor // per-RELAX multiplicative occupancy reset (<1)
neuron_weight_ceiling // the cell's total-weight budget (renormalization target) neuron_weight_ceiling // renormalization target (broadcast constraint)
early_phase_frac // fraction of night cycles that are DOWNSCALE phase // ── 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 pre_tag *= decay(hr) // SLOW
dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s) dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s)
NIGHT · ACTION | coherence check: // lateral: does post & astro concur? // ── NIGHT: a cycle of RELAX → REPLAY → COMMIT, repeated until the tag is spent (dual of DAY,
coh = coherence_signal // arrived verdict (pre+post+astro tags aligned) // which loops until energy is spent). The tag has THREE roles: (day) significance bridge;
// (this is the night's "release": signal the standing claim, read what returns; leaves coh as trace) // (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 NIGHT · RELAX | lower own threshold: // vertical: prepare excitability + make room
if rest_permission and pre_tag > tag_expiry: // receive shipped batch for this cycle (forward-facing)
Δ = 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)
pre_material += transit(pre_material_ship, τ_transport_bouton) pre_material += transit(pre_material_ship, τ_transport_bouton)
pre_energy += transit(pre_energy_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 VGCC_active *= occupancy_downscale; pre_possible_tag *= occupancy_downscale
if renorm_signal arrived: if renorm_signal arrived:
freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal
emit(freed → recycled material pool) 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_material += pre_ceiling_shrinkage·recycle // energy NOT recovered
pre_structure -= decay_rate·Δt_cycle; pre_budget_ceiling -= capacity_decay_rate·Δt_cycle 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_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 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) // SLOW (hr)
soma_tag *= decay(hr); dopamine *= decay(ms) soma_tag *= decay(hr); dopamine *= decay(ms)
NIGHT | cycle: // ROOT (neuronal material) — produces each cycle // ── NIGHT: RELAX → REPLAY → COMMIT, until tag spent. SOMA is a ROOT (produces material each
// RECEIVE = PRODUCTION: synthesize this cycle's batch, gated by own tag, capped externally // 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_material += CREB_synth(soma_tag)·Δt_cycle // material — recoverable
soma_energy += mito_synth()·Δt_cycle // energy — NOT recoverable, bounded by night budget soma_energy += mito_synth()·Δt_cycle // energy — NOT recoverable
night_energy_spent += mito_synth()·Δt_cycle // track against night supply ceiling night_energy_spent += mito_synth()·Δt_cycle
// TRACE read standing demand (soma_tag → structure ; soma_endurance_need → budget_ceiling) // lower OWN spontaneous-firing threshold in proportion to OWN tag (primes ignition)
// ADJUST (no coherence — SOMA is not a synaptic component) soma_spont_thr = spont_thr_base − thr_gain × soma_tag
// BEHAVE commit own batches // ship this cycle's batch down to DEND and AXON (feeds the pattern's downstream links)
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_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost) 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_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)
// RECOVER reclaim material from decayed ceilings (own + returned from downstream) // recycle + settle
soma_material += soma_ceiling_shrinkage·recycle soma_material += soma_ceiling_shrinkage·recycle
// DECAY
soma_structure -= decay_rate·Δt_cycle; soma_budget_ceiling -= capacity_decay_rate·Δt_cycle 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_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, > NIGHT-BLOCK UNIFORMITY. PRE and SOMA above are the worked exemplars of the NIGHT replay cycle
> AXON, and ASTROSYNAPSE follow the identical pattern, shown in their blocks in abbreviated form: > (RELAX → REPLAY → COMMIT). POST, DEND, AXON, and ASTROSYNAPSE follow the identical pattern:
> (a) all commits are gated by `rest_permission` (arrived from the cell actor); (b) on a > (a) RELAX lowers each one's OWN spontaneous threshold from its OWN tag, applies the descended
> DOWNSCALE-phase signal each self-resets its own occupancy (`*_occupancy *= occupancy_downscale`) > constraint to itself (occupancy downscale, structure renorm), recycles, and — for intermediate
> and self-renormalizes its own structure (`*_structure *= renorm_signal`, emitting the freed > nodes AXON/DEND — relays the arrived `replay_AP` onward IF primed (this is what carries the
> material) — the cell actor only broadcasts, the component scales itself; (c) each emits its own > pattern from SOMA to PRE and to POST); (b) REPLAY: the component participates if the propagating
> fatigue upward. Roots (SOMA material, ASTROSYNAPSE/ASTROCYTE energy) additionally PRODUCE their > re-evocation reaches it while its threshold is low (primed), running its STRUCTURAL code, not its
> batch each cycle and track `night_energy_spent`. Only the occupancy-holders (PRE: VGCC_active, > DAY significance code; (c) COMMIT allocates a slice of its tag to the replayed behavior, builds
> POST: AMPA_surface) carry the self-downscale line; the rest carry only the structure renorm. > 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. 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 // INTERFACE
// EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast) // EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast)
// neuron_fatigue → HYPOTHALAMUS // neuron_fatigue → HYPOTHALAMUS
@@ -952,13 +1015,11 @@ DAY | active: // (own_activity high
// (no restructuring permission while the cell is active — components are busy) // (no restructuring permission while the cell is active — components are busy)
NIGHT | cycle: // (own_activity low AND sleep_pressure high) NIGHT | cycle: // (own_activity low AND sleep_pressure high)
phase = (cycle ≤ early_phase_frac × est_cycles) ? DOWNSCALE : COMMIT // the neuron acts ONLY by signalling; components scale/commit themselves. No early/late phase
// ADJUST read replay (external) + own aggregate // split — each component's cycle is RELAX→REPLAY→COMMIT; the neuron just supplies the constraint.
// EMIT (broadcast) — the neuron acts ONLY by signalling; components scale themselves occupancy_downscale = downscale_factor // → components reset own occupancy (in RELAX)
if phase == DOWNSCALE: if neuron_total_weight > neuron_weight_ceiling:
occupancy_downscale = downscale_factor // → components reset own occupancy renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure
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 rest_permission = TRUE // → components may restructure this cycle
// RECOVER reclaim material returned by components' renormalization (arrives as recycled pool) // RECOVER reclaim material returned by components' renormalization (arrives as recycled pool)
// DECAY neuron_activity relaxes as the cell stays quiet // 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. the astrosynapse.
``` ```
// PARAMETERS (territory reallocation) · early_phase_frac · rest_thr // PARAMETERS (territory reallocation) · rest_thr
// INTERFACE // INTERFACE
// EMIT astro_alloc[·] (reallocation), rest_permission → own astrosynapses (broadcast) // EMIT astro_alloc[·] (reallocation), rest_permission → own astrosynapses (broadcast)
// astro_fatigue → HYPOTHALAMUS ; produced energy+material → territory (roots) // astro_fatigue → HYPOTHALAMUS ; produced energy+material → territory (roots)