ocrampal/organism
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v13

Browse Source
This commit is contained in:
ocrampal
2026-06-22 16:35:11 +02:00
parent 955f572774
commit bec6e8f09d
3 changed files with 376 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
elements/neuron/appunti/2026-06-19-abstract-pattern-expression.md
+197 -134
View File
@@ -1,187 +1,250 @@
# The Abstract Pattern
A component operates within two ceilings set by the previous NIGHT: a **structure** that bounds how strongly each behavior can act, and a **budget capacity** that bounds how much fuel the component can hold. Both ceilings bound an active, competitive DAY process — structure bounds how far behavior strength can be filled toward its maximum, budget capacity bounds how far fuel can be replenished toward its maximum — and in both cases the filling competes against other components for a shared resource. During DAY, in each context, the component executes behaviors that draw on budget and deposit fast traces. Two kinds of evidence accumulate: a **tag**, when a local eligibility signal coincides with non-local validation, driving *strength*; and an **endurance need**, when budget depletion interrupts a behavior on a successful trajectory, driving *endurance*. At NIGHT, tags raise structure and endurance needs raise budget capacity, both proportional to available material and energy, both drawing from the same finite pool, so that strength and endurance compete. What is not committed decays for lack of maintenance, and the resources freed partially fund what was.
A component operates within two ceilings set by the previous NIGHT: a **structure** that
bounds how strongly each behavior can act, and a **budget capacity** that bounds how much fuel
it can hold. Both ceilings bound an active, competitive DAY process and are raised at NIGHT by
two kinds of evidence — a **tag** (a local eligibility signal coinciding with non-local
validation, driving strength) and an **endurance need** (budget depletion interrupting a
locally successful trajectory, driving endurance). Strength and endurance draw on the same
finite material and energy, so they compete; what is not committed decays for lack of
maintenance, and the freed resources partially fund what was.
Everything a component does — in DAY and in NIGHT alike — is an instance of one grammar of
eight functional groups. This is the common template. Each component differs only in how it
fills the groups, never in their structure.
---
## DAY — The General Form
Every DAY behavior runs within two ceilings and competes for two shared resources.
## The Grammar
```
given: STRUCTURE // bounds behavior strength (ceiling from NIGHT)
BUDGET_CEILING // bounds fuel capacity (ceiling from NIGHT)
in: CONTEXT // local or global triggering condition
if: BUDGET >= cost // operational fuel available
then: behavior executes, strength bounded by STRUCTURE
RECEIVE take in resources + signals that arrived from outside
EVALUATE judge behavior — strength (needs dopamine) + endurance (interrupted success)
ADJUST compute local operating parameters from structure + traces + modulators
BEHAVE the component's defining action, within both ceilings
EMIT send out — signals (messages) and resources (shipments) across the boundary
TRACE deposit the fast trace that records the behavior
RECOVER refill own private pools consumed by behaving
DECAY let traces recede, closing their windows
```
The grammar runs at two timescales. In **DAY** it operates on occupancy *within* the ceilings:
fast traces, budgets, behaviors. In **NIGHT** it operates on the *ceilings themselves*:
material, energy, structure, budget capacity. Same eight groups, two scopes — which is the
capacity-versus-occupancy principle written into the shape of the process.
A strict locality rule governs every group: a component uses only its own state and signals
that have physically arrived. It never reads another compartment's interior. All
cross-compartment influence travels through RECEIVE (signals in) and EMIT (signals out).
---
## DAY — The Grammar on Occupancy
### RECEIVE — what arrived becomes local
Resources arrive by two filling disciplines, each bounded by a ceiling through the *gap* it
leaves, never by a post-hoc clamp:
```
// CONTESTED supply (astrocyte lactate, shipments) — rationed by competing demands
demand = BUDGET_CEILING - BUDGET // the gap is the claim
factor = min(1, S / (Σ demand on S + ε))
BUDGET += demand × factor; S -= demand × factor // never exceeds the ceiling
// PRIVATE reserve (own vesicle pool, own mitochondria) — uncontested, rate-limited
POOL += min(rate, CEILING - POOL) × Δt
```
Signals arrive as channel reads — forward transmitter, the co-agonist gate, retrograde
messengers, neuromodulatory broadcast. A read signal is latched into a local copy; the channel
itself decays. A high budget ceiling is therefore not free even in DAY: it makes a large
standing claim on contested supply, satisfiable only by out-competing neighbours.
### EVALUATE — the two evidence streams
Two independent judgments, each using only local state and arrived signals.
**Strength (associative, needs dopamine).** A tag forms when local eligibility coincides with
non-local validation; the number of coincidences set by the component's spatial scale.
```
// most components — one non-local coincidence
if FAST_TRACE > elig and dopamine > dop_thr:
TAG += dopamine × possible_tag
// POST — three coincidences (astrosynapse gate, soma bAP, organism dopamine)
if FAST_TRACE > Ca_TAG and astro_Dserine > thr: possible_tag += FAST_TRACE // CANDIDATE
if possible_tag > thr and bAP arrives: FAST_TRACE += bAP_boost // confirm
if possible_tag > thr and dopamine > dop_thr: TAG += dopamine × possible_tag // STABLE
```
**Endurance (homeostatic, no dopamine).** A need forms when depletion interrupts a *locally*
successful trajectory. "Successful" is each component's own local proxy — never a read of
another compartment, optionally amplified by a retrograde signal that has arrived.
```
if BUDGET < cost and LOCAL_SUCCESS_PROXY > traj_thr:
ENDURANCE_NEED += LOCAL_SUCCESS_PROXY × (1 + arrived_feedback)
```
Local success proxies: PRE — own strong release (amplified by retrograde NO that POST
emitted); POST — own calcium climbing toward the tag; DEND — own branch strongly active when
propagation fell short; SOMA — own nuclear calcium approaching CREB; AXON — own strong
propagation load; ASTRO — own high glutamate/clearance demand when synthesis ran out. Same
shape everywhere — fuel ran out at the verge of the component's *own* success — only the proxy
differs.
### ADJUST — set the operating parameters
From structure (the ceiling), the current traces, and arrived modulators, the component
computes the parameters that govern this step's behavior:
```
parameter = f(STRUCTURE, FAST_TRACE, modulators, arrived_signals)
```
PRE — release drive from residual calcium and the received DSE brake; POST — AMPA drive from
arrived glutamate; SOMA — firing threshold from baseline × adaptation × neuromodulators, plus
the refractory gate; AXON — propagation reliability from structure minus load-driven failure;
ASTRO — lactate-allocation weights across the territory. ADJUST is where the NIGHT-built ceiling
silently shapes the moment: the same structure that bounds the maximum also tunes the
transfer function.
### BEHAVE — the defining action, within both ceilings
```
if BUDGET >= cost:
behavior executes, strength bounded by STRUCTURE // fills occupancy toward the ceiling
BUDGET -= cost
FAST_TRACE += f(behavior) // local record deposited
else: behavior suppressed // fuel was the limit
if behavior was ON A SUCCESSFUL TRAJECTORY:
ENDURANCE_NEED += g(trajectory) // fuel interrupted a forming success
else:
behavior suppressed // fuel was the binding constraint
// → endurance EVALUATE fires here if the interrupted trajectory was locally succeeding
```
Two competitive DAY processes fill the two ceilings:
Behavior fills occupancy — receptors to the surface, vesicles to docking slots — toward the
structural ceiling. When the driving trace decays, occupancy passively drifts back: short-term
depression is the *absence* of drive, never a signalled act.
**Strength filling (bounded by STRUCTURE).** Behavior strength rises toward the structural ceiling by competing for local occupancy resources — receptors at the postsynapse, vesicles at the presynapse. A behavior cannot act more strongly than its structure permits, because the occupancy it draws on is itself bounded by the structure.
### EMIT — send signals and resources outward
**Fuel replenishment (bounded by BUDGET_CEILING).** Fuel rises toward the budget ceiling by competing for shared upstream supply — astrocyte lactate, soma shipment. Each component's claim is the gap between its current budget and its ceiling; the shared supply is rationed by these claims:
The component writes its outputs into shared channels: the forward transmitter into the cleft,
retrograde messages back, integrated voltage onward, shipments to downstream pools (rationed by
the downstream component's propagated demand). EMIT and RECEIVE are the only boundary crossings;
together they make locally-computing components into a communicating whole.
### TRACE — record the behavior
```
// competitive replenishment — the ceiling bounds the process via the demand
c_demand = BUDGET_CEILING - BUDGET // gap below ceiling = claim on supply
total_demand = sum(c_demand for components on shared supply S)
allocation_factor = min(1, S / (total_demand + ε))
replenishment = c_demand × allocation_factor // rationed share
BUDGET += replenishment // never exceeds ceiling (demand was the gap)
S -= replenishment
FAST_TRACE += f(behavior)
```
Neither ceiling is applied as a clamp. Each bounds its process from within: structure is the thing being filled with occupancy, budget_ceiling is the target the replenishment demand reaches toward. A high budget_ceiling is not free even during DAY — it makes a large standing claim on shared fuel, and the component reaches it only if the supply can satisfy that claim against competing claims.
Where a fast trace both *drives* and *records* a behavior (residual calcium at the presynapse),
TRACE precedes ADJUST; elsewhere it follows BEHAVE. The trace is the system's short-term memory:
it biases the next behavior in the same context and opens the eligibility window for tagging.
The fast trace drives two parallel processes; depletion drives a third.
### RECOVER — refill private pools
**Within the same context** — the fast trace biases the next execution of the same behavior. Short-term modulation. Local, no external signal.
Pools consumed by behaving are refilled from the component's own reserve toward their ceiling,
rate-limited and budget-costed (the presynaptic RRP from the reserve vesicle pool, the soma's
budget from its own mitochondria). Private recovery grants a component autonomy that contested
supply does not.
**Across contexts** — the fast trace accumulates into `possible_tagging` above the eligibility threshold. The bridge toward strength. Requires the trace to survive into a NOT/CONTINUOUS context.
### DECAY — let the windows close
**On depletion** — when budget gates a behavior that was succeeding, `endurance_need` accumulates. The bridge toward endurance. Requires the depletion to have interrupted something valuable, not merely to have occurred.
```
FAST_TRACE *= decay(τ_fast) // ms–s — closes the eligibility window
possible_tag *= decay(τ_mid) // s–min — closes the tagging window
ENDURANCE_NEED *= decay(τ_mid) // s–min — closes the endurance window
TAG *= decay(τ_slow) // hours — closes the commitment window
arrived channels *= decay // received signals fade
```
Decay is not an action — it is the passive relaxation that enforces every time window without a
clock. A coincidence must complete, and a depletion must interrupt a success, while the relevant
trace is still elevated. Timing is the competition between accumulation and decay.
---
### Tag Formation — Non-Local Coincidence (drives STRENGTH)
## NIGHT — The Same Grammar on Ceilings
Strength is associative. The tag requires local eligibility plus non-local validation, the number of coincidences set by the component's spatial scale.
NIGHT runs once per cycle and applies the identical grammar to the slow variables.
**PRE, DEND, SOMA, AXON, ASTRO — one non-local coincidence:**
```
if FAST_TRACE > eligibility and dopamine > threshold:
TAG += dopamine × possible_tagging
```
**RECEIVE** — overnight production at the roots (astrocyte glycolysis, soma CREB synthesis,
soma mitochondria), capped externally by the vascular supply and gated by `soma_tag`.
**POST — three coincidences (astrosynapse, soma, organism):**
```
// 1. NOT_bAP: local Ca²⁺ + astrosynapse D-serine → CANDIDATE
if FAST_TRACE > Ca_TAG_threshold and D-serine > threshold:
post_possible_tagging += FAST_TRACE
// 2. bAP: CANDIDATE + soma fired → amplified above Ca_HIGH
if post_possible_tagging > threshold and bAP arrives:
FAST_TRACE += bAP_boost
// 3. any context: CANDIDATE + dopamine → STABLE
if post_possible_tagging > threshold and dopamine > threshold:
TAG += dopamine × post_possible_tagging
```
**ADJUST** — compute the commit weights: the coherence bonus when pre, post and astro tags
align, and the tag-weighted shares for distributing material and energy to competing
astrosynapses, spines, and boutons.
---
**EMIT** — distribute the produced material and energy down the supply chains
(soma → branch/axon → spine/bouton; astrocyte body → astrosynapses).
### Endurance Formation — Interrupted Success (drives ENDURANCE)
Endurance is homeostatic, not associative. It requires depletion plus a successful trajectory, the meaning of "successful" set by the component's local function. **No dopamine.**
**EVALUATE + BEHAVE** — the two commits, drawing on the same finite pool so they compete:
```
if BUDGET < cost and trajectory_was_succeeding:
ENDURANCE_NEED += g(trajectory) // graded by closeness to success
// STRENGTH — driven by tag (validated coincidence)
if TAG > tag_expiry:
Δ = min(slot_cost, MATERIAL, ENERGY × f)
STRUCTURE += Δ × coherence; MATERIAL -= Δ; ENERGY -= Δ × assembly_cost
// ENDURANCE — driven by endurance need (interrupted success); no dopamine, no coherence
if ENDURANCE_NEED > endur_thr:
Δ = min(cap_cost, MATERIAL × f, ENERGY × f)
BUDGET_CEILING += Δ; MATERIAL -= Δ; ENERGY -= Δ × biogenesis_cost
```
Per-component definition of *succeeding*:
- **PRE** — release was driving rising postsynaptic engagement
- **POST** — calcium was climbing toward the tagging threshold
- **DEND** — active spines existed distal to where propagation died
- **SOMA** — nuclear calcium was approaching CREB, or firing was recruiting downstream
- **AXON** — propagation failed to engaged boutons, not idle ones
- **ASTRO** — the postsynapse was depolarized and waiting for D-serine when synthesis ran out
A component that is both significant and fuel-limited demands both commits and is the strongest
claimant on the pool, potentially forcing decay elsewhere.
The signal shape is identical everywhere — fuel ran out at the verge of a valuable outcome — only the local definition of "verge" varies.
---
### Trace Recession — The Temporal Behavior
In every NOT/CONTINUOUS context, all traces decay:
**RECOVER + DECAY** — both ceilings decay by neglect; maintenance from the remaining pool
resists decay only where sufficient. What shrinks returns its **material** (not its energy) to
the pool, partially funding the commits above:
```
FAST_TRACE *= decay(τ_fast) // ms–s — closes eligibility window
possible_tagging *= decay(τ_mid) // s–min — closes tagging window
ENDURANCE_NEED *= decay(τ_mid) // s–min — closes endurance window
TAG *= decay(τ_slow) // hours — closes commitment window
STRUCTURE -= decay_rate × Δt; STRUCTURE += min(maint, maint_cost)
BUDGET_CEILING -= capacity_decay_rate × Δt; BUDGET_CEILING += min(cap_maint, cap_cost)
// shortfall → depotentiation by neglect (structure) / mitophagy of idle capacity (budget)
MATERIAL += shrinkage × recycle // energy is gone — not recoverable
```
Decay is not a separate behavior — it is the passive consequence of molecular processes. It enforces time windows without any clock: a coincidence must complete, and a depletion must interrupt a success, while the relevant trace is still elevated. Timing is the competition between accumulation and decay.
---
## NIGHT — The General Form
NIGHT raises two ceilings from two kinds of evidence, both drawing on the same finite material and energy.
**Strength commit — driven by tag (validated coincidence):**
```
if TAG > threshold:
Δstructure = min(expansion_cost, MATERIAL, ENERGY × fraction)
STRUCTURE += Δstructure × coherence_bonus // raises the strength ceiling
MATERIAL -= Δstructure // RECOVERABLE
ENERGY -= Δstructure × ATP_cost // NOT recoverable
```
Coherence bonus when pre, post, and astro tags are all set together — the three synaptic components independently gathered evidence for the same change.
**Endurance commit — driven by endurance need (interrupted success):**
```
if ENDURANCE_NEED > threshold:
Δcap = min(capacity_cost, MATERIAL, ENERGY × fraction)
BUDGET_CEILING += Δcap // raises the endurance ceiling
MATERIAL -= Δcap // RECOVERABLE (mitochondria recyclable)
ENERGY -= Δcap × biogenesis_cost // NOT recoverable
// no coherence bonus, no dopamine — endurance is per-component homeostatic
```
The two commits compete for the same material and energy: building endurance somewhere cannot strengthen elsewhere. A component both significant and fuel-limited demands both and is the strongest claimant, potentially forcing decay elsewhere.
**What is not committed decays — by neglect, for both ceilings:**
```
STRUCTURE -= decay_rate × Δt_night
STRUCTURE += min(structure_maintenance, maintenance_cost)
BUDGET_CEILING -= capacity_decay_rate × Δt_night
BUDGET_CEILING += min(capacity_maintenance, capacity_cost)
// if maintenance < decay: the ceiling drifts down
// structure → depotentiation by neglect
// budget_ceiling → loss of endurance (mitophagy of idle capacity)
// recovered material partially funds the commits above
```
**DECAY (clear)** — fast traces, possible tags, endurance needs, and the soma timing traces
reset; tags below expiry clear, above-expiry tags carry forward for multi-night consolidation;
structure and budget capacity persist as the ceilings the next DAY will operate within.
---
## The Pattern in One View
```
TWO CEILINGS, each bounding a competitive DAY process and raised by NIGHT evidence:
ONE GRAMMAR, EIGHT GROUPS, TWO TIMESCALES
STRUCTURE (strength) bounds behavior strength;
filled in DAY by competing for occupancy;
raised in NIGHT by TAG (validated coincidence)
RECEIVE · EVALUATE · ADJUST · BEHAVE · EMIT · TRACE · RECOVER · DECAY
BUDGET_CEILING (endurance) bounds fuel capacity;
filled in DAY by competing for shared supply;
raised in NIGHT by ENDURANCE_NEED (interrupted success)
DAY runs the grammar on OCCUPANCY within two ceilings:
STRUCTURE (strength) filled by competing for occupancy
BUDGET_CEILING (endurance) filled by competing for shared fuel
EVALUATE yields two evidence streams, both from local state + arrived signals:
fast_trace + dopamine coincidence → TAG (strength)
depletion + interrupted LOCAL success → ENDURANCE_NEED (endurance)
DAY behavior runs within both ceilings, both filled competitively
consumes budget, deposits fast trace
fast trace + non-local coincidence → TAG (evidence for strength)
depletion + interrupted success → ENDURANCE_NEED (evidence for endurance)
traces decay in NOT/CONTINUOUS contexts — windows close
NIGHT TAG → raise STRUCTURE (per-event power)
NIGHT runs the SAME grammar on the CEILINGS:
TAG → raise STRUCTURE (per-event power)
ENDURANCE_NEED → raise BUDGET_CEILING (sustainable duration)
both draw the SAME material + energy → strength and endurance compete
unmaintained ceilings of either kind decay → freed material funds the rest
unmaintained ceilings decay → recovered material funds the rest
A high ceiling of either kind is never free: structure must be filled by winning
occupancy, budget capacity must be filled by winning shared fuel — both against
competing components, every DAY. The system invests STRENGTH where a valuable
coincidence completed and was validated, and ENDURANCE where fuel — not structure,
not significance — was what stood between activity and success. To be both effective
and sustainable, a connection must win on both, at both timescales, against all
others drawing from the same finite pools.
LOCALITY every group uses only own state + arrived signals;
RECEIVE and EMIT are the only boundary crossings.
A high ceiling of either kind is never free: structure must be filled by winning occupancy,
budget capacity by winning shared fuel — both against competing components, every DAY. The
system invests STRENGTH where a validated coincidence completed, and ENDURANCE where fuel —
not structure, not significance — was what stood between a component's own activity and its
own success. To be both effective and sustainable, a connection must win on both, at both
timescales, against all others drawing from the same finite pools.
```
# More details
## SOMA
elements/neuron/appunti/2026-06-22-biological-reference_v12.md
+11 -11
View File
@@ -1,15 +1,15 @@
# Tripartite Synapse — Biological Reference (companion to v12 pseudocode)
# Tripartite Synapse — Biological Reference (companion to v13 pseudocode)
> Companion to `tripartite_synapse_v12_pseudocode.md`. Explains the biology each variable and
> behavior conflates. Variable meanings are unchanged; v12 only refined the pseudocode
> grammar (SENSE→TRACE, new ADJUST group, EVALUATE reordered before ADJUST/DECAY, NIGHT
> labeled with the same groups, aligned group headers). The ADJUST group makes explicit the
> step where a component computes its operating parameters — release drive, firing threshold,
> propagation reliability, lactate-allocation weights — from its structure, its current
> traces, and arrived neuromodulators, before it acts.
> conflates biologically. The pseudocode aggregates many molecular details into single
> variables for clarity; here each aggregation is unpacked. Read the pseudocode for the
> logic; read this when you need to know what a variable physically represents.
> Companion to `tripartite_synapse_v13_pseudocode.md`. Explains the biology each variable and
> behavior conflates. Variable meanings are unchanged; v13 refined the model logic:
> per-spike calcium deposit (frequency emergent, not a parameter); BEHAVE now separates a FUEL
> shortfall (deposits endurance need) from an OCCUPANCY/structure shortfall (short-term
> depression — no endurance, since more fuel would not help); the endurance feedback term
> (retrograde NO) appears only at the presynapse, where such a signal actually arrives, while
> every other component's endurance proxy is own-state only; EVALUATE merged into TRACE
> (judging a behavior is maintaining a trace); shipment is modelled as a transit-delayed flow
> (axonal/dendritic transport takes a characteristic time, so distal targets receive later),
> reflecting the general principle that every flow has a timescale.
---
elements/neuron/appunti/2026-06-22-tripartite-synapse_v12.md
+159 -99
View File
@@ -1,30 +1,40 @@
# Tripartite Synapse — Pseudocode v12
# Tripartite Synapse — Pseudocode v13
> Companion: `tripartite_synapse_v12_biology.md`.
> Changes from v11: SENSE renamed TRACE; new ADJUST group (compute local operating
> parameters from structure + traces + modulators); reference order puts EVALUATE before
> ADJUST and DECAY; NIGHT labeled with the same group grammar; all `// GROUP` headers sit
> at one indentation column so they stand out.
> Companion: `tripartite_synapse_v13_biology.md`.
> Changes from v12:
> (1) per-spike calcium deposit (frequency stays emergent, not a parameter)
> (2) BEHAVE splits FUEL shortfall (→ endurance) from OCCUPANCY shortfall (→ STD)
> (3) endurance feedback term only where a retrograde signal actually arrives
> (4) TRACE absorbs EVALUATE → seven-group grammar
> (5) parameter declarations completed (ship_cost, ACh_gain, NIGHT block)
> (6) shipment is a transit-delayed flow; every flow has a timescale
> (7) all group labels are standalone headers at one column
---
## Functional groups (uniform grammar, applied within each context)
## Functional groups (seven-group grammar)
```
RECEIVE take in resources + signals that arrived from outside
EVALUATE judge behavior — strength (needs dopamine) + endurance (interrupted success)
RECEIVE take in resources + signals that arrived from outside (boundary: in)
TRACE maintain the trace hierarchy — deposit fast trace; accumulate
possible_tag + endurance_need; stabilize tag on coincidence
ADJUST compute local operating parameters from structure + traces + modulators
BEHAVE the component's defining action, using the adjusted parameters
EMIT send out — signals (messages) and resources (shipments) across the boundary
TRACE deposit the fast trace that records the behavior
BEHAVE the component's defining action, within both ceilings
EMIT send out — signals (messages) + resources (shipments) (boundary: out)
RECOVER refill own private pools consumed by behaving
DECAY let traces recede, closing their windows
```
Groups sit inside the DAY contexts (Option A). Execution contexts (AP/bAP/CONTINUOUS) carry
ADJUST/BEHAVE/EMIT/TRACE and endurance-EVALUATE; replenishment contexts (NOT_AP/NOT_bAP)
carry RECEIVE/strength-EVALUATE/RECOVER/DECAY. Not every component uses every group. Group
order within a context follows data dependencies (e.g. where a fast trace both drives a
behavior and records it, TRACE precedes ADJUST). NIGHT runs the same grammar on ceilings.
EVALUATE merged into TRACE: judging a behavior is always maintaining a trace, whether or not
a trace is written. BEHAVE and EMIT stay separate — EMIT is the output half of the locality
interface (RECEIVE/EMIT are the only boundary crossings). TRACE spans all timescales: the
soma's inactivation, adaptation, and nuclear-Ca deposits are all TRACE. Order within a context
follows data dependencies; TRACE reads/writes whatever trace state is current.
EVERY FLOW HAS A TIMESCALE. Decay relaxes toward 0 over τ; creation/arrival relaxes toward a
target over τ — the same first-order operator. Within-step writes are the special case τ ≪ Δt.
Rate-limited inflows (fill/refill/flux·Δt) carry their τ implicitly; shipment carries an
explicit transit delay (see `transit`).
---
@@ -39,7 +49,7 @@ NIGHT energy (not recoverable) · material (recoverable) · structure · budg
LOCALITY only local state + arrived signals; no component reads another's internal state.
CLEFT MESSAGE CHANNELS SHIPMENT CHANNELS
CLEFT MESSAGE CHANNELS SHIPMENT CHANNELS (transit-delayed)
glutamate PRE → POST, ASTRO soma_ship_dend SOMA→DEND
astro_Dserine ASTRO → POST soma_ship_axon SOMA→AXON
retro_NO POST → PRE (+) dend_ship_post DEND→POST
@@ -53,16 +63,19 @@ CLEFT MESSAGE CHANNELS SHIPMENT CHANNELS
```
sat(x, K) = x / (K + x)
fill(pool, ceiling, rate, cost, budget) -> amount: // PRIVATE reserve
fill(pool, ceiling, rate, cost, budget) -> amount: // PRIVATE reserve, rate-limited (implicit τ)
amount = min(rate, ceiling - pool)·Δt; budget -= amount·cost; return amount
refill(c from supply S) -> amount: // CONTESTED supply
refill(c from supply S) -> amount: // CONTESTED supply, gap-bounded
demand = c.budget_ceiling - c.budget
factor = min(1, S / (Σ demand over components on S + ε)); S -= demand·factor
return demand·factor
ship(from_budget, demand_sig, frac, cost) -> amount: // DIRECTED transfer
amount = min(from_budget·frac, demand_sig); from_budget -= amount·(1+cost); return amount
ship(from_budget, demand_sig, frac, cost) -> amount: // emit into transit (not to target directly)
amount = min(from_budget·frac, demand_sig); from_budget -= amount·(1+ship_cost); return amount
transit(channel, τ_transport) -> arrival: // delivers in-transit cargo over τ
arrival = channel·(Δt/τ_transport); channel -= arrival; return arrival
```
---
@@ -74,8 +87,21 @@ dopamine NE ACh // organism broadcasts (external)
glucose geometry // physical (external)
elig dop_thr tag_thr tag_expiry // strength gates (universal)
traj_thr endur_thr // endurance gates (universal)
decay_rate capacity_decay_rate recycle homeostatic_ceiling
coherence_factor assembly_cost biogenesis_cost maint_cost
ship_cost // transport overhead (all shipments)
τ_transport_{dend,axon,spine,bouton} // shipment transit times (distance-dependent)
ε
```
## NIGHT parameters (consolidation only)
```
slot_cost cap_cost f_cap // commit sizes / endurance fraction
maint_frac cap_frac // maintenance allocation
decay_rate capacity_decay_rate recycle // passive decay + recovery
homeostatic_ceiling coherence_factor assembly_cost biogenesis_cost maint_cost
f_dend f_axon f_spine f_bouton // material distribution fractions
{dend,axon,pre,post}_ship_frac // DAY shipment fractions
{dend,axon,pre,post}_energy_frac // energy distribution fractions
```
---
@@ -96,31 +122,35 @@ coherence_factor assembly_cost biogenesis_cost maint_cost
// EMERGENCY shockwave_lockdown ← ASTRO
DAY | AP:
// TRACE (residual Ca²⁺ from this spike — also drives release)
pre_fast_trace += spike_Ca(input_freq)
// ADJUST (release drive from trace + received DSE brake)
// TRACE (Ca²⁺ bolus from THIS spike — also drives release; frequency is emergent)
pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)
// ADJUST (release drive from residual Ca²⁺ + received DSE brake)
drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local)
// BEHAVE (release or fail)
// BEHAVE (release; two distinct failure modes)
if pre_budget < release_cost:
// FUEL shortfall → endurance evidence (retro_NO-confirmed local success)
suppress(NT_flux)
if pre_fast_trace > traj_thr: // EVALUATE (endurance): retro_NO-confirmed
if pre_fast_trace > traj_thr:
pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)
exit
if RRP > 0:
if RRP == 0:
// OCCUPANCY shortfall → short-term depression (NOT endurance; fuel was fine)
suppress(NT_flux)
exit
NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost
// EMIT
// EMIT (glutamate into cleft)
glutamate += NT_flux·Δt
if glutamate > spillover: drive *= brake // own-cleft autobrake
DAY | NOT_AP:
// RECEIVE
// RECEIVE (latch backward messages ; replenish budget from contested supply)
retro_NO_local = retro_NO; retro_eCB_local = retro_eCB
pre_budget += refill(pre from astro_lactate[syn] + axon_ship_pre)
// EVALUATE (strength)
pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
// TRACE (strength: eligibility → tag via dopamine)
if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace
if dopamine > dop_thr and pre_possible_tag > tag_thr:
pre_tag += dopamine × pre_possible_tag
// RECOVER (RRP from private reserve)
// RECOVER (RRP from private reserve toward its ceiling)
RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
// DECAY
pre_fast_trace *= decay(100ms); pre_possible_tag *= decay(s)
@@ -138,15 +168,15 @@ DAY | NOT_AP:
// NO_synth_cost · eCB_synth_cost
// INTERFACE
// EMIT retro_NO (+), retro_eCB (−) → PRE
// RECEIVE astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND
// post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
// RECEIVE astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
// READ glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP (dend_structure.bAP_fidelity) ; dopamine
// OWN post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
// EMERGENCY shockwave_lockdown ← ASTRO
// NOTE POST endurance is own-state only (own Ca climbing); no arrived feedback term.
DAY | NOT_bAP:
// RECEIVE
post_budget += refill(post from astro_lactate[syn] + dend_ship_post)
post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine))
// ADJUST (AMPA drive from arrived glutamate)
a = sat(glutamate, K_AMPA)
// BEHAVE (SOURCE 1 AMPA: current + small Ca + begins Mg ejection)
@@ -156,21 +186,24 @@ DAY | NOT_bAP:
// BEHAVE (SOURCE 2 NMDA: large Ca on local coincidence)
if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:
post_fast_trace += NMDA_Ca(glutamate)·rise_speed(); post_budget -= NMDA_cost
// EMIT (+) NO/BDNF: "release reached a responsive target"
// EMIT (+ NO/BDNF: "release reached a responsive target")
retro_NO += NO_emit(post_fast_trace); post_budget -= NO_synth_cost
// EMIT (−) endocannabinoid (DSE) when over-driven
if Vm > eCB_thr: retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost
// EMIT (− endocannabinoid / DSE when over-driven)
if Vm > eCB_thr:
retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost
post_fast_trace *= decay(ms)
// BEHAVE (STP: fill slots from private reserve ; else STD drift = consequence)
// BEHAVE (STP fill slots from private reserve ; else STD drift = consequence)
if post_fast_trace > Ca_STP:
AMPA_surface = min(AMPA_surface + Ca_insert(post_fast_trace), post_structure.slot_ceiling)
post_budget -= traffic_cost
else:
AMPA_surface = max(AMPA_surface - drift·Δt, baseline)
// EVALUATE (endurance: own Ca was climbing toward a tag when fuel failed)
if post_budget < req_cost and post_fast_trace > traj_thr and post_fast_trace_rising:
if post_budget < traffic_cost:
// FUEL shortfall → endurance (own Ca was climbing toward a tag)
if post_fast_trace > traj_thr and post_fast_trace_rising:
post_endurance_need += post_fast_trace
// EVALUATE (strength: CANDIDATE then STABLE via dopamine)
else if AMPA_surface < post_structure.slot_ceiling:
AMPA_surface += Ca_insert(post_fast_trace); post_budget -= traffic_cost
// else: surface already at slot_ceiling → structure-limited (not endurance)
else:
AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = consequence
// TRACE (strength: CANDIDATE then STABLE via dopamine)
if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace; post_budget -= pka_cost
if dopamine > dop_thr and post_possible_tag > tag_thr:
post_tag += dopamine × post_possible_tag
@@ -190,21 +223,27 @@ DAY | bAP:
## DEND
```
// PARAMETERS prop_cost · branch_Ca_cost · integrate_cost · translate_cost
// PARAMETERS prop_cost · branch_Ca_cost · integrate_cost · translate_cost · ACh_gain
// INTERFACE
// EMIT bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST
// RECEIVE astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
// READ SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
// OWN dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling
// NOTE DEND endurance fires only on FUEL-limited propagation, not structural attenuation;
// own-state proxy (strong branch activity); no arrived feedback term.
DAY | bAP:
// ADJUST (propagation strength from structure) -> inside propagate()
// BEHAVE (propagate bAP; may fall short if depleted)
bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, dend_budget, geometry)
dend_budget -= prop_cost × reached
// EVALUATE (endurance: propagation cut short while branch strongly active)
if reached < full and dend_fast_trace > traj_thr:
// ADJUST (propagation strength from structure — inside propagate())
// BEHAVE (propagate bAP; distinguish fuel-limited vs structure-limited shortfall)
if dend_budget < prop_cost:
// FUEL shortfall → endurance (branch was strongly active)
if dend_fast_trace > traj_thr:
dend_endurance_need += dend_fast_trace
bAP_local, reached = propagate_partial(dend_budget)
else:
bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, geometry)
// reached < full here is structural attenuation (distance), NOT endurance
dend_budget -= prop_cost × reached
// TRACE
dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost
// EMIT (integrated voltage to soma ; propagated bAP already reached spines)
@@ -212,13 +251,13 @@ DAY | bAP:
DAY | NOT_bAP:
// RECEIVE
dend_budget += refill(dend from astro_lactate[branch] + soma_ship_dend)
// EVALUATE (strength)
dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
// TRACE (strength)
if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
if dopamine > dop_thr and dend_possible_tag > tag_thr:
dend_tag += dopamine × dend_possible_tag
// ADJUST (commit threshold lowered by attention)
commit_threshold *= 1/(1 + ACh·gain)
commit_threshold *= 1/(1 + ACh·ACh_gain)
// EMIT (ship budget to spines; demand = post tag)
dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
// BEHAVE (local translation if tagged — fills dend capacity faster)
@@ -240,6 +279,8 @@ DAY | NOT_bAP:
// RECEIVE self (mitochondria, ROOT) ; branch_Vm ← DEND
// READ dopamine ; NE ; ACh
// OWN soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling
// NOTE SOMA endurance fires only on FUEL shortfall (budget < ap_cost);
// refractory / sub-threshold are timing limits, not endurance. Own-state proxy.
DAY | AP:
// ADJUST (threshold from structure + adaptation + neuromodulators ; refractory gate)
@@ -248,15 +289,17 @@ DAY | AP:
// BEHAVE (fire if able)
if branch_Vm > threshold and can_fire:
if soma_budget < ap_cost:
if soma_fast_trace > traj_thr and soma_fast_trace_rising: // EVALUATE (endurance)
// FUEL shortfall → endurance (firing was approaching CREB)
if soma_fast_trace > traj_thr and soma_fast_trace_rising:
soma_endurance_need += soma_fast_trace
exit
fired = True; soma_budget -= ap_cost // EMIT: fired → AXON, DEND
// TRACE (three traces from one AP)
// EMIT (fired → AXON, DEND)
fired = True; soma_budget -= ap_cost
// TRACE (three traces from one AP — all timescales)
soma_Na_inactivation += ap_amp // → refractory (emergent)
soma_adaptation += ap_contrib // → threshold rise
soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost
// EVALUATE (strength)
// TRACE (strength)
if soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
if dopamine > dop_thr and soma_possible_tag > tag_thr:
soma_tag += dopamine × soma_possible_tag
@@ -266,10 +309,10 @@ DAY | NOT_AP:
// RECEIVE (self-replenish from private root ; integrate input)
soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
branch_Vm = integrate(DEND.branch_Vm, branches)
// BEHAVE (bottom-up refractory alignment: suprathreshold input during refractory)
// TRACE (bottom-up refractory alignment: suprathreshold input during refractory)
if branch_Vm > threshold and soma_Na_inactivation > inactivation:
soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation
// EMIT (ship downstream; demand = propagated tags)
// EMIT (ship downstream into transit; demand = propagated tags)
soma_ship_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost)
soma_ship_axon = ship(soma_budget, axon_demand, axon_ship_frac, ship_cost)
// RECOVER (inactivation recovery sped by alignment trace → emergent refractory)
@@ -293,23 +336,26 @@ DAY | NOT_AP:
// RECEIVE soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
// READ SOMA.fired ; dopamine
// OWN axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling
// NOTE AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace)
// is axonal STD (a consequence), not endurance. Own-state proxy.
DAY | AP:
// ADJUST (reliability from structure − load-driven failure)
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace))
// BEHAVE (propagate; degraded if depleted)
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance
// BEHAVE (propagate; FUEL shortfall degrades + flags endurance)
if axon_budget < prop_cost:
reliability *= budget_factor
if axon_fast_trace > traj_thr: // EVALUATE (endurance)
if axon_fast_trace > traj_thr: // FUEL-limited → endurance
axon_endurance_need += axon_fast_trace
delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT → boutons
delivered = fired × reliability; axon_budget -= prop_cost × delivered
// EMIT (delivered APs reach boutons)
// TRACE
axon_fast_trace += delivered; axon_fast_trace *= decay(s)
DAY | NOT_AP:
// RECEIVE
axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft])
// EVALUATE (strength)
// TRACE (strength)
if axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
if dopamine > dop_thr and axon_possible_tag > tag_thr:
axon_tag += dopamine × axon_possible_tag
@@ -331,6 +377,8 @@ DAY | NOT_AP:
// RECEIVE glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
// READ glutamate ← PRE (clearance + spillover) ; dopamine
// OWN astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling
// NOTE ASTRO endurance fires on BUDGET-limited synthesis (got<want via low budget);
// material/precursor-limited synthesis is a material limit, not endurance. Own-state proxy.
// EMERGENCY emits shockwave_lockdown on overload
DAY | CONTINUOUS: // per astrosynapse i
@@ -348,14 +396,15 @@ DAY | CONTINUOUS: // per astrosynapse i
if glutamate[i] > spillover:
// TRACE
astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s)
// BEHAVE + EMIT (D-serine pulse: demand-driven, budget-limited)
// ADJUST (D-serine demand from spillover)
want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
got = min(want, astro_central_budget × Ds_frac)
// BEHAVE + EMIT (D-serine pulse to POST gate)
astro_Dserine[i] += got; astro_central_budget -= got·Ds_cost
// EVALUATE (endurance: ran out of synthesis under high own demand)
if got < want and astro_fast_trace[i] > traj_thr:
// TRACE (endurance: BUDGET-limited synthesis under high own demand)
if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
astro_endurance_need[i] += (want - got)
// EVALUATE (strength)
// TRACE (strength)
if astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i]
if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
astro_tag[i] += dopamine × astro_possible_tag[i]
@@ -378,29 +427,34 @@ DAY or NIGHT | OVERLOAD:
---
---
# NIGHT
The same grammar on ceilings: RECEIVE production, EVALUATE/ADJUST the commits, BEHAVE
(build ceilings), DECAY (unmaintained ceilings recede). Runs once per cycle, not per spike.
Same grammar on ceilings, once per cycle.
```
NIGHT | 1 RECEIVE + EMIT (replenish and distribute)
astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt // RECEIVE
soma_{budget,energy} += overnight_*()·Δt ; soma_material += CREB_synth(soma_tag)·Δt // RECEIVE (bottleneck)
for each i with astro_tag[i] > tag_expiry: w = astro_tag[i]/Σastro_tag // ADJUST (weights)
astro_energy[i] += astro_central_energy·w; astro_material[i] += astro_central_material·w // EMIT
dend_material += soma_material·f_dend ; axon_material += soma_material·f_axon ; soma_material -= … // EMIT
post_material += dend_material·f_spine ; pre_material += axon_material·f_bouton // EMIT
{pre,post,dend,axon}_energy += soma_energy·f[·] ; {…}_budget += astro_lactate_reserve·f[·]·Δt
NIGHT | 1 RECEIVE + ADJUST + EMIT (replenish, weight, distribute)
// RECEIVE overnight production at roots (capped by glucose; gated by soma_tag)
astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt
soma_{budget,energy} += overnight_*()·Δt ; soma_material += CREB_synth(soma_tag)·Δt
// ADJUST tag-weighted shares
for each i with astro_tag[i] > tag_expiry: w = astro_tag[i]/Σastro_tag
// EMIT distribute material + energy down the supply chains
astro_energy[i] += astro_central_energy·w; astro_material[i] += astro_central_material·w
dend_material += soma_material·f_dend ; axon_material += soma_material·f_axon ; soma_material -= …
post_material += dend_material·f_spine ; pre_material += axon_material·f_bouton
{pre,post,dend,axon}_energy += soma_energy·{·}_energy_frac
{pre,post,dend,axon}_budget += astro_lactate_reserve·{·}_frac·Δt
NIGHT | 2 EVALUATE + BEHAVE (strength commits → raise structure)
coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1 // ADJUST
for each c with c_tag > tag_expiry: // EVALUATE
Δ = min(slot_cost, c_material, c_energy·f) // BEHAVE
NIGHT | 2 TRACE + BEHAVE (strength commits → raise structure)
// ADJUST coherence bonus when pre, post, astro tags align
coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1
// TRACE+BEHAVE build structure for tagged components
for each c with c_tag > tag_expiry:
Δ = min(slot_cost, c_material, c_energy·f_cap)
c_structure += Δ × (coherence if c in {pre,post,astro} else 1)
c_material -= Δ; c_energy -= Δ·assembly_cost; if Δ < slot_cost: queue(→ next NIGHT)
NIGHT | 2b EVALUATE + BEHAVE (endurance commits → raise budget_ceiling ; no dopamine ; competes w/ 2)
for each c with c_endurance_need > endur_thr: // EVALUATE
Δ = min(cap_cost, c_material·f_cap, c_energy·f_cap) // BEHAVE
NIGHT | 2b TRACE + BEHAVE (endurance commits → raise budget_ceiling ; no dopamine ; competes w/ 2)
for each c with c_endurance_need > endur_thr:
Δ = min(cap_cost, c_material·f_cap, c_energy·f_cap)
c_budget_ceiling += Δ; c_material -= Δ; c_energy -= Δ·biogenesis_cost; if Δ<cap_cost: queue
NIGHT | 3 DECAY + RECOVER (both ceilings decay by neglect ; material recovered)
@@ -431,12 +485,18 @@ NIGHT | 5 DECAY (clear traces)
## One-view summary
```
DAY per context: RECEIVE → EVALUATE → ADJUST → BEHAVE/EMIT/TRACE → RECOVER → DECAY
behavior runs within structure (strength) and budget_ceiling (endurance),
both filled competitively (refill = contested, fill = private, ship = directed)
fast_trace + dopamine → tag (strength evidence)
depletion + interrupted LOCAL success → endurance_need (endurance evidence)
NIGHT same grammar on ceilings: tag → structure ; endurance_need → budget_ceiling
both draw one pool (compete) ; unmaintained ceilings decay → freed material recycles
LOCAL every evaluation uses only own state + arrived signals; coupling is via channels.
SEVEN-GROUP GRAMMAR, TWO TIMESCALES
RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY
DAY grammar on OCCUPANCY within two ceilings (structure=strength, budget_ceiling=endurance)
TRACE yields two evidence streams from local state + arrived signals:
fast_trace + dopamine → tag (strength)
FUEL shortfall + interrupted LOCAL success → endurance_need (endurance)
OCCUPANCY/structure/timing shortfalls → short-term depression (NOT endurance)
NIGHT same grammar on the CEILINGS:
tag → structure ; endurance_need → budget_ceiling ; both draw one pool (compete)
unmaintained ceilings decay → recovered material funds the rest
FLOWS every flow has a timescale: decay relaxes toward 0 over τ, arrival toward a target
over τ; shipment is transit-delayed; rate-limited inflows carry τ implicitly.
LOCAL every group uses only own state + arrived signals; RECEIVE/EMIT are the only crossings.
```