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
+202 -139
View File
@@ -1,187 +1,250 @@
# The Abstract Pattern # 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 ## The Grammar
Every DAY behavior runs within two ceilings and competes for two shared resources.
``` ```
given: STRUCTURE // bounds behavior strength (ceiling from NIGHT) RECEIVE take in resources + signals that arrived from outside
BUDGET_CEILING // bounds fuel capacity (ceiling from NIGHT) EVALUATE judge behavior — strength (needs dopamine) + endurance (interrupted success)
in: CONTEXT // local or global triggering condition ADJUST compute local operating parameters from structure + traces + modulators
if: BUDGET >= cost // operational fuel available BEHAVE the component's defining action, within both ceilings
then: behavior executes, strength bounded by STRUCTURE EMIT send out — signals (messages) and resources (shipments) across the boundary
BUDGET -= cost TRACE deposit the fast trace that records the behavior
FAST_TRACE += f(behavior) // local record deposited RECOVER refill own private pools consumed by behaving
else: behavior suppressed // fuel was the limit DECAY let traces recede, closing their windows
if behavior was ON A SUCCESSFUL TRAJECTORY:
ENDURANCE_NEED += g(trajectory) // fuel interrupted a forming success
``` ```
Two competitive DAY processes fill the two ceilings: 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.
**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. 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
**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: cross-compartment influence travels through RECEIVE (signals in) and EMIT (signals out).
```
// 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
```
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.
The fast trace drives two parallel processes; depletion drives a third.
**Within the same context** — the fast trace biases the next execution of the same behavior. Short-term modulation. Local, no external signal.
**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.
**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.
--- ---
### Tag Formation — Non-Local Coincidence (drives STRENGTH) ## DAY — The Grammar on Occupancy
Strength is associative. The tag requires local eligibility plus non-local validation, the number of coincidences set by the component's spatial scale. ### 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:
**PRE, DEND, SOMA, AXON, ASTRO — one non-local coincidence:**
``` ```
if FAST_TRACE > eligibility and dopamine > threshold: // CONTESTED supply (astrocyte lactate, shipments) — rationed by competing demands
TAG += dopamine × possible_tagging 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
``` ```
**POST — three coincidences (astrosynapse, soma, organism):** 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.
``` ```
// 1. NOT_bAP: local Ca²⁺ + astrosynapse D-serine → CANDIDATE // most components — one non-local coincidence
if FAST_TRACE > Ca_TAG_threshold and D-serine > threshold: if FAST_TRACE > elig and dopamine > dop_thr:
post_possible_tagging += FAST_TRACE TAG += dopamine × possible_tag
// 2. bAP: CANDIDATE + soma fired → amplified above Ca_HIGH
if post_possible_tagging > threshold and bAP arrives: // POST — three coincidences (astrosynapse gate, soma bAP, organism dopamine)
FAST_TRACE += bAP_boost if FAST_TRACE > Ca_TAG and astro_Dserine > thr: possible_tag += FAST_TRACE // CANDIDATE
// 3. any context: CANDIDATE + dopamine → STABLE if possible_tag > thr and bAP arrives: FAST_TRACE += bAP_boost // confirm
if post_possible_tagging > threshold and dopamine > threshold: if possible_tag > thr and dopamine > dop_thr: TAG += dopamine × possible_tag // STABLE
TAG += dopamine × post_possible_tagging
``` ```
**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
else:
behavior suppressed // fuel was the binding constraint
// → endurance EVALUATE fires here if the interrupted trajectory was locally succeeding
```
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.
### EMIT — send signals and resources outward
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
```
FAST_TRACE += f(behavior)
```
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.
### RECOVER — refill private pools
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.
### DECAY — let the windows close
```
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.
--- ---
### Endurance Formation — Interrupted Success (drives ENDURANCE) ## NIGHT — The Same Grammar on Ceilings
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.** NIGHT runs once per cycle and applies the identical grammar to the slow variables.
**RECEIVE** — overnight production at the roots (astrocyte glycolysis, soma CREB synthesis,
soma mitochondria), capped externally by the vascular supply and gated by `soma_tag`.
**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).
**EVALUATE + BEHAVE** — the two commits, drawing on the same finite pool so they compete:
``` ```
if BUDGET < cost and trajectory_was_succeeding: // STRENGTH — driven by tag (validated coincidence)
ENDURANCE_NEED += g(trajectory) // graded by closeness to success 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*: A component that is both significant and fuel-limited demands both commits and is the strongest
- **PRE** — release was driving rising postsynaptic engagement claimant on the pool, potentially forcing decay elsewhere.
- **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
The signal shape is identical everywhere — fuel ran out at the verge of a valuable outcome — only the local definition of "verge" varies. **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:
### Trace Recession — The Temporal Behavior
In every NOT/CONTINUOUS context, all traces decay:
``` ```
FAST_TRACE *= decay(τ_fast) // ms–s — closes eligibility window STRUCTURE -= decay_rate × Δt; STRUCTURE += min(maint, maint_cost)
possible_tagging *= decay(τ_mid) // s–min — closes tagging window BUDGET_CEILING -= capacity_decay_rate × Δt; BUDGET_CEILING += min(cap_maint, cap_cost)
ENDURANCE_NEED *= decay(τ_mid) // s–min — closes endurance window // shortfall → depotentiation by neglect (structure) / mitophagy of idle capacity (budget)
TAG *= decay(τ_slow) // hours — closes commitment window 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. **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.
## 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
```
--- ---
## The Pattern in One View ## 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; RECEIVE · EVALUATE · ADJUST · BEHAVE · EMIT · TRACE · RECOVER · DECAY
filled in DAY by competing for occupancy;
raised in NIGHT by TAG (validated coincidence)
BUDGET_CEILING (endurance) bounds fuel capacity; DAY runs the grammar on OCCUPANCY within two ceilings:
filled in DAY by competing for shared supply; STRUCTURE (strength) filled by competing for occupancy
raised in NIGHT by ENDURANCE_NEED (interrupted success) 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 NIGHT runs the SAME grammar on the CEILINGS:
consumes budget, deposits fast trace TAG → raise STRUCTURE (per-event power)
fast trace + non-local coincidence → TAG (evidence for strength) ENDURANCE_NEED → raise BUDGET_CEILING (sustainable duration)
depletion + interrupted success → ENDURANCE_NEED (evidence for endurance) both draw the SAME material + energy → strength and endurance compete
traces decay in NOT/CONTINUOUS contexts — windows close unmaintained ceilings decay → recovered material funds the rest
NIGHT TAG → raise STRUCTURE (per-event power) LOCALITY every group uses only own state + arrived signals;
ENDURANCE_NEED → raise BUDGET_CEILING (sustainable duration) RECEIVE and EMIT are the only boundary crossings.
both draw the SAME material + energy → strength and endurance compete
unmaintained ceilings of either kind decay → freed material funds the rest
A high ceiling of either kind is never free: structure must be filled by winning A high ceiling of either kind is never free: structure must be filled by winning occupancy,
occupancy, budget capacity must be filled by winning shared fuel — both against budget capacity by winning shared fuel — both against competing components, every DAY. The
competing components, every DAY. The system invests STRENGTH where a valuable system invests STRENGTH where a validated coincidence completed, and ENDURANCE where fuel —
coincidence completed and was validated, and ENDURANCE where fuel — not structure, not structure, not significance — was what stood between a component's own activity and its
not significance — was what stood between activity and success. To be both effective own success. To be both effective and sustainable, a connection must win on both, at both
and sustainable, a connection must win on both, at both timescales, against all timescales, against all others drawing from the same finite pools.
others drawing from the same finite pools.
``` ```
# More details # More details
## SOMA ## 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 > Companion to `tripartite_synapse_v13_pseudocode.md`. Explains the biology each variable and
> behavior conflates. Variable meanings are unchanged; v12 only refined the pseudocode > behavior conflates. Variable meanings are unchanged; v13 refined the model logic:
> grammar (SENSE→TRACE, new ADJUST group, EVALUATE reordered before ADJUST/DECAY, NIGHT > per-spike calcium deposit (frequency emergent, not a parameter); BEHAVE now separates a FUEL
> labeled with the same groups, aligned group headers). The ADJUST group makes explicit the > shortfall (deposits endurance need) from an OCCUPANCY/structure shortfall (short-term
> step where a component computes its operating parameters — release drive, firing threshold, > depression — no endurance, since more fuel would not help); the endurance feedback term
> propagation reliability, lactate-allocation weights — from its structure, its current > (retrograde NO) appears only at the presynapse, where such a signal actually arrives, while
> traces, and arrived neuromodulators, before it acts. > every other component's endurance proxy is own-state only; EVALUATE merged into TRACE
> conflates biologically. The pseudocode aggregates many molecular details into single > (judging a behavior is maintaining a trace); shipment is modelled as a transit-delayed flow
> variables for clarity; here each aggregation is unpacked. Read the pseudocode for the > (axonal/dendritic transport takes a characteristic time, so distal targets receive later),
> logic; read this when you need to know what a variable physically represents. > reflecting the general principle that every flow has a timescale.
--- ---
elements/neuron/appunti/2026-06-22-tripartite-synapse_v12.md
+163 -103
View File
@@ -1,30 +1,40 @@
# Tripartite Synapse — Pseudocode v12 # Tripartite Synapse — Pseudocode v13
> Companion: `tripartite_synapse_v12_biology.md`. > Companion: `tripartite_synapse_v13_biology.md`.
> Changes from v11: SENSE renamed TRACE; new ADJUST group (compute local operating > Changes from v12:
> parameters from structure + traces + modulators); reference order puts EVALUATE before > (1) per-spike calcium deposit (frequency stays emergent, not a parameter)
> ADJUST and DECAY; NIGHT labeled with the same group grammar; all `// GROUP` headers sit > (2) BEHAVE splits FUEL shortfall (→ endurance) from OCCUPANCY shortfall (→ STD)
> at one indentation column so they stand out. > (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 RECEIVE take in resources + signals that arrived from outside (boundary: in)
EVALUATE judge behavior — strength (needs dopamine) + endurance (interrupted success) 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 ADJUST compute local operating parameters from structure + traces + modulators
BEHAVE the component's defining action, using the adjusted parameters BEHAVE the component's defining action, within both ceilings
EMIT send out — signals (messages) and resources (shipments) across the boundary EMIT send out — signals (messages) + resources (shipments) (boundary: out)
TRACE deposit the fast trace that records the behavior
RECOVER refill own private pools consumed by behaving RECOVER refill own private pools consumed by behaving
DECAY let traces recede, closing their windows 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) EVALUATE merged into TRACE: judging a behavior is always maintaining a trace, whether or not
carry RECEIVE/strength-EVALUATE/RECOVER/DECAY. Not every component uses every group. Group a trace is written. BEHAVE and EMIT stay separate — EMIT is the output half of the locality
order within a context follows data dependencies (e.g. where a fast trace both drives a interface (RECEIVE/EMIT are the only boundary crossings). TRACE spans all timescales: the
behavior and records it, TRACE precedes ADJUST). NIGHT runs the same grammar on ceilings. 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. 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 glutamate PRE → POST, ASTRO soma_ship_dend SOMA→DEND
astro_Dserine ASTRO → POST soma_ship_axon SOMA→AXON astro_Dserine ASTRO → POST soma_ship_axon SOMA→AXON
retro_NO POST → PRE (+) dend_ship_post DEND→POST retro_NO POST → PRE (+) dend_ship_post DEND→POST
@@ -53,16 +63,19 @@ CLEFT MESSAGE CHANNELS SHIPMENT CHANNELS
``` ```
sat(x, K) = x / (K + x) 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 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 demand = c.budget_ceiling - c.budget
factor = min(1, S / (Σ demand over components on S + ε)); S -= demand·factor factor = min(1, S / (Σ demand over components on S + ε)); S -= demand·factor
return demand·factor return demand·factor
ship(from_budget, demand_sig, frac, cost) -> amount: // DIRECTED transfer 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+cost); return amount 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) glucose geometry // physical (external)
elig dop_thr tag_thr tag_expiry // strength gates (universal) elig dop_thr tag_thr tag_expiry // strength gates (universal)
traj_thr endur_thr // endurance gates (universal) traj_thr endur_thr // endurance gates (universal)
decay_rate capacity_decay_rate recycle homeostatic_ceiling ship_cost // transport overhead (all shipments)
coherence_factor assembly_cost biogenesis_cost maint_cost τ_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 // EMERGENCY shockwave_lockdown ← ASTRO
DAY | AP: DAY | AP:
// TRACE (residual Ca²⁺ from this spike — also drives release) // TRACE (Ca²⁺ bolus from THIS spike — also drives release; frequency is emergent)
pre_fast_trace += spike_Ca(input_freq) pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)
// ADJUST (release drive from trace + received DSE brake) // ADJUST (release drive from residual Ca²⁺ + received DSE brake)
drive = sat(pre_fast_trace, K_release) × (1 - retro_eCB_local) 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: if pre_budget < release_cost:
// FUEL shortfall → endurance evidence (retro_NO-confirmed local success)
suppress(NT_flux) 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) pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)
exit exit
if RRP > 0: if RRP == 0:
NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost // OCCUPANCY shortfall → short-term depression (NOT endurance; fuel was fine)
// EMIT suppress(NT_flux)
glutamate += NT_flux·Δt exit
NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost
// EMIT (glutamate into cleft)
glutamate += NT_flux·Δt
if glutamate > spillover: drive *= brake // own-cleft autobrake if glutamate > spillover: drive *= brake // own-cleft autobrake
DAY | NOT_AP: DAY | NOT_AP:
// RECEIVE // RECEIVE (latch backward messages ; replenish budget from contested supply)
retro_NO_local = retro_NO; retro_eCB_local = retro_eCB retro_NO_local = retro_NO; retro_eCB_local = retro_eCB
pre_budget += refill(pre from astro_lactate[syn] + axon_ship_pre) pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton))
// EVALUATE (strength) // TRACE (strength: eligibility → tag via dopamine)
if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace
if dopamine > dop_thr and pre_possible_tag > tag_thr: if dopamine > dop_thr and pre_possible_tag > tag_thr:
pre_tag += dopamine × pre_possible_tag 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) RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget)
// DECAY // DECAY
pre_fast_trace *= decay(100ms); pre_possible_tag *= decay(s) pre_fast_trace *= decay(100ms); pre_possible_tag *= decay(s)
@@ -138,15 +168,15 @@ DAY | NOT_AP:
// NO_synth_cost · eCB_synth_cost // NO_synth_cost · eCB_synth_cost
// INTERFACE // INTERFACE
// EMIT retro_NO (+), retro_eCB (−) → PRE // EMIT retro_NO (+), retro_eCB (−) → PRE
// RECEIVE astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND // RECEIVE astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
// post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT)
// READ glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP (dend_structure.bAP_fidelity) ; dopamine // READ glutamate ← PRE ; astro_Dserine ← ASTRO ; bAP (dend_structure.bAP_fidelity) ; dopamine
// OWN post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling // OWN post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling
// EMERGENCY shockwave_lockdown ← ASTRO // EMERGENCY shockwave_lockdown ← ASTRO
// NOTE POST endurance is own-state only (own Ca climbing); no arrived feedback term.
DAY | NOT_bAP: DAY | NOT_bAP:
// RECEIVE // 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) // ADJUST (AMPA drive from arrived glutamate)
a = sat(glutamate, K_AMPA) a = sat(glutamate, K_AMPA)
// BEHAVE (SOURCE 1 AMPA: current + small Ca + begins Mg ejection) // 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) // BEHAVE (SOURCE 2 NMDA: large Ca on local coincidence)
if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0: if Vm > Mg_eject and astro_Dserine > Dserine_thr and glutamate > 0:
post_fast_trace += NMDA_Ca(glutamate)·rise_speed(); post_budget -= NMDA_cost 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 retro_NO += NO_emit(post_fast_trace); post_budget -= NO_synth_cost
// EMIT (−) endocannabinoid (DSE) when over-driven // EMIT (− endocannabinoid / DSE when over-driven)
if Vm > eCB_thr: retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost if Vm > eCB_thr:
retro_eCB += eCB_emit(Vm); post_budget -= eCB_synth_cost
post_fast_trace *= decay(ms) 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: if post_fast_trace > Ca_STP:
AMPA_surface = min(AMPA_surface + Ca_insert(post_fast_trace), post_structure.slot_ceiling) if post_budget < traffic_cost:
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
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: else:
AMPA_surface = max(AMPA_surface - drift·Δt, baseline) AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = consequence
// EVALUATE (endurance: own Ca was climbing toward a tag when fuel failed) // TRACE (strength: CANDIDATE then STABLE via dopamine)
if post_budget < req_cost and post_fast_trace > traj_thr and post_fast_trace_rising:
post_endurance_need += post_fast_trace
// EVALUATE (strength: CANDIDATE then STABLE via dopamine)
if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace; post_budget -= pka_cost 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: if dopamine > dop_thr and post_possible_tag > tag_thr:
post_tag += dopamine × post_possible_tag post_tag += dopamine × post_possible_tag
@@ -190,21 +223,27 @@ DAY | bAP:
## DEND ## DEND
``` ```
// PARAMETERS prop_cost · branch_Ca_cost · integrate_cost · translate_cost // PARAMETERS prop_cost · branch_Ca_cost · integrate_cost · translate_cost · ACh_gain
// INTERFACE // INTERFACE
// EMIT bAP_local → POST ; branch_Vm → SOMA ; dend_ship_post → POST // 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) // RECEIVE astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT)
// READ SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh // READ SOMA.fired ; POST.Vm + spine spillover ; dopamine ; ACh
// OWN dend_structure{bAP_fidelity(pos), translation_ceiling, transport_speed} ; dend_budget_ceiling // 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: DAY | bAP:
// ADJUST (propagation strength from structure) -> inside propagate() // ADJUST (propagation strength from structure — inside propagate())
// BEHAVE (propagate bAP; may fall short if depleted) // BEHAVE (propagate bAP; distinguish fuel-limited vs structure-limited shortfall)
bAP_local, reached = propagate(SOMA.fired, dend_structure.bAP_fidelity, dend_budget, geometry) 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 dend_budget -= prop_cost × reached
// EVALUATE (endurance: propagation cut short while branch strongly active)
if reached < full and dend_fast_trace > traj_thr:
dend_endurance_need += dend_fast_trace
// TRACE // TRACE
dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost dend_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost
// EMIT (integrated voltage to soma ; propagated bAP already reached spines) // EMIT (integrated voltage to soma ; propagated bAP already reached spines)
@@ -212,13 +251,13 @@ DAY | bAP:
DAY | NOT_bAP: DAY | NOT_bAP:
// RECEIVE // RECEIVE
dend_budget += refill(dend from astro_lactate[branch] + soma_ship_dend) dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend))
// EVALUATE (strength) // TRACE (strength)
if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace if dend_fast_trace > elig: dend_possible_tag += dend_fast_trace
if dopamine > dop_thr and dend_possible_tag > tag_thr: if dopamine > dop_thr and dend_possible_tag > tag_thr:
dend_tag += dopamine × dend_possible_tag dend_tag += dopamine × dend_possible_tag
// ADJUST (commit threshold lowered by attention) // 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) // EMIT (ship budget to spines; demand = post tag)
dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost) dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost)
// BEHAVE (local translation if tagged — fills dend capacity faster) // BEHAVE (local translation if tagged — fills dend capacity faster)
@@ -240,6 +279,8 @@ DAY | NOT_bAP:
// RECEIVE self (mitochondria, ROOT) ; branch_Vm ← DEND // RECEIVE self (mitochondria, ROOT) ; branch_Vm ← DEND
// READ dopamine ; NE ; ACh // READ dopamine ; NE ; ACh
// OWN soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling // 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: DAY | AP:
// ADJUST (threshold from structure + adaptation + neuromodulators ; refractory gate) // ADJUST (threshold from structure + adaptation + neuromodulators ; refractory gate)
@@ -248,15 +289,17 @@ DAY | AP:
// BEHAVE (fire if able) // BEHAVE (fire if able)
if branch_Vm > threshold and can_fire: if branch_Vm > threshold and can_fire:
if soma_budget < ap_cost: 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 soma_endurance_need += soma_fast_trace
exit exit
fired = True; soma_budget -= ap_cost // EMIT: fired → AXON, DEND // EMIT (fired → AXON, DEND)
// TRACE (three traces from one AP) fired = True; soma_budget -= ap_cost
// TRACE (three traces from one AP — all timescales)
soma_Na_inactivation += ap_amp // → refractory (emergent) soma_Na_inactivation += ap_amp // → refractory (emergent)
soma_adaptation += ap_contrib // → threshold rise soma_adaptation += ap_contrib // → threshold rise
soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost 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 soma_fast_trace > elig: soma_possible_tag += soma_fast_trace
if dopamine > dop_thr and soma_possible_tag > tag_thr: if dopamine > dop_thr and soma_possible_tag > tag_thr:
soma_tag += dopamine × soma_possible_tag soma_tag += dopamine × soma_possible_tag
@@ -266,10 +309,10 @@ DAY | NOT_AP:
// RECEIVE (self-replenish from private root ; integrate input) // RECEIVE (self-replenish from private root ; integrate input)
soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget) soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget)
branch_Vm = integrate(DEND.branch_Vm, branches) 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: if branch_Vm > threshold and soma_Na_inactivation > inactivation:
soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_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_dend = ship(soma_budget, dend_demand, dend_ship_frac, ship_cost)
soma_ship_axon = ship(soma_budget, axon_demand, axon_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) // 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) // RECEIVE soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT)
// READ SOMA.fired ; dopamine // READ SOMA.fired ; dopamine
// OWN axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling // 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: DAY | AP:
// ADJUST (reliability from structure − load-driven failure) // ADJUST (reliability from structure − load-driven failure)
reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance
// BEHAVE (propagate; degraded if depleted) // BEHAVE (propagate; FUEL shortfall degrades + flags endurance)
if axon_budget < prop_cost: if axon_budget < prop_cost:
reliability *= budget_factor 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 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 // TRACE
axon_fast_trace += delivered; axon_fast_trace *= decay(s) axon_fast_trace += delivered; axon_fast_trace *= decay(s)
DAY | NOT_AP: DAY | NOT_AP:
// RECEIVE // RECEIVE
axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft]) 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 axon_fast_trace > elig: axon_possible_tag += axon_fast_trace
if dopamine > dop_thr and axon_possible_tag > tag_thr: if dopamine > dop_thr and axon_possible_tag > tag_thr:
axon_tag += dopamine × axon_possible_tag axon_tag += dopamine × axon_possible_tag
@@ -331,6 +377,8 @@ DAY | NOT_AP:
// RECEIVE glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT) // RECEIVE glucose (ROOT) ; astro_material, astro_energy ← cell body (NIGHT)
// READ glutamate ← PRE (clearance + spillover) ; dopamine // READ glutamate ← PRE (clearance + spillover) ; dopamine
// OWN astro_structure{perisynaptic_distance⁻¹, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling // 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 // EMERGENCY emits shockwave_lockdown on overload
DAY | CONTINUOUS: // per astrosynapse i DAY | CONTINUOUS: // per astrosynapse i
@@ -348,14 +396,15 @@ DAY | CONTINUOUS: // per astrosynapse i
if glutamate[i] > spillover: if glutamate[i] > spillover:
// TRACE // TRACE
astro_fast_trace[i] += mGluR_Ca(); astro_fast_trace[i] *= decay(s) 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 want = sat(astro_fast_trace[i], K_Dserine) × Ds_max
got = min(want, astro_central_budget × Ds_frac) 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 astro_Dserine[i] += got; astro_central_budget -= got·Ds_cost
// EVALUATE (endurance: ran out of synthesis under high own demand) // TRACE (endurance: BUDGET-limited synthesis under high own demand)
if got < want and astro_fast_trace[i] > traj_thr: if got < want and astro_central_budget low and astro_fast_trace[i] > traj_thr:
astro_endurance_need[i] += (want - got) 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 astro_fast_trace[i] > elig: astro_possible_tag[i] += astro_fast_trace[i]
if dopamine > dop_thr and astro_possible_tag[i] > tag_thr: if dopamine > dop_thr and astro_possible_tag[i] > tag_thr:
astro_tag[i] += dopamine × astro_possible_tag[i] astro_tag[i] += dopamine × astro_possible_tag[i]
@@ -378,39 +427,44 @@ DAY or NIGHT | OVERLOAD:
--- ---
--- ---
# NIGHT # NIGHT
The same grammar on ceilings: RECEIVE production, EVALUATE/ADJUST the commits, BEHAVE Same grammar on ceilings, once per cycle.
(build ceilings), DECAY (unmaintained ceilings recede). Runs once per cycle, not per spike.
``` ```
NIGHT | 1 RECEIVE + EMIT (replenish and distribute) NIGHT | 1 RECEIVE + ADJUST + EMIT (replenish, weight, distribute)
astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt // RECEIVE // RECEIVE overnight production at roots (capped by glucose; gated by soma_tag)
soma_{budget,energy} += overnight_*()·Δt ; soma_material += CREB_synth(soma_tag)·Δt // RECEIVE (bottleneck) astro_central_{budget,energy,material} += overnight_*(glucose, …)·Δt
for each i with astro_tag[i] > tag_expiry: w = astro_tag[i]/Σastro_tag // ADJUST (weights) soma_{budget,energy} += overnight_*()·Δt ; soma_material += CREB_synth(soma_tag)·Δt
astro_energy[i] += astro_central_energy·w; astro_material[i] += astro_central_material·w // EMIT // ADJUST tag-weighted shares
dend_material += soma_material·f_dend ; axon_material += soma_material·f_axon ; soma_material -= … // EMIT for each i with astro_tag[i] > tag_expiry: w = astro_tag[i]/Σastro_tag
post_material += dend_material·f_spine ; pre_material += axon_material·f_bouton // EMIT // EMIT distribute material + energy down the supply chains
{pre,post,dend,axon}_energy += soma_energy·f[·] ; {…}_budget += astro_lactate_reserve·f[·]·Δt 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) NIGHT | 2 TRACE + BEHAVE (strength commits → raise structure)
coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1 // ADJUST // ADJUST coherence bonus when pre, post, astro tags align
for each c with c_tag > tag_expiry: // EVALUATE coherence = (pre_tag, post_tag, astro_tag all > tag_expiry) ? coherence_factor : 1
Δ = min(slot_cost, c_material, c_energy·f) // BEHAVE // 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_structure += Δ × (coherence if c in {pre,post,astro} else 1)
c_material -= Δ; c_energy -= Δ·assembly_cost; if Δ < slot_cost: queue(→ next NIGHT) 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) NIGHT | 2b TRACE + BEHAVE (endurance commits → raise budget_ceiling ; no dopamine ; competes w/ 2)
for each c with c_endurance_need > endur_thr: // EVALUATE for each c with c_endurance_need > endur_thr:
Δ = min(cap_cost, c_material·f_cap, c_energy·f_cap) // BEHAVE Δ = min(cap_cost, c_material·f_cap, c_energy·f_cap)
c_budget_ceiling += Δ; c_material -= Δ; c_energy -= Δ·biogenesis_cost; if Δ<cap_cost: queue c_budget_ceiling += Δ; c_material -= Δ; c_energy -= Δ·biogenesis_cost; if Δ<cap_cost: queue
NIGHT | 3 DECAY + RECOVER (both ceilings decay by neglect ; material recovered) NIGHT | 3 DECAY + RECOVER (both ceilings decay by neglect ; material recovered)
maint = (total_material - consumed) × maint_frac / synapse_count maint = (total_material - consumed) × maint_frac / synapse_count
for each synapse: // DECAY for each synapse: // DECAY
{pre,post,dend,astro}_structure -= decay_rate·Δt {pre,post,dend,astro}_structure -= decay_rate·Δt
{pre,post,dend,astro}_budget_ceiling -= capacity_decay_rate·Δt {pre,post,dend,astro}_budget_ceiling -= capacity_decay_rate·Δt
if maint ≥ maint_cost: structure += full_maint ; budget_ceiling += full_cap_maint if maint ≥ maint_cost: structure += full_maint ; budget_ceiling += full_cap_maint
else: structure += maint·frac ; budget_ceiling += maint·cap_frac else: structure += maint·frac ; budget_ceiling += maint·cap_frac
for each synapse with net_change < 0: // RECOVER for each synapse with net_change < 0: // RECOVER
{pre,post,astro}_material += |net_change|·recycle·frac // material recovered, energy not {pre,post,astro}_material += |net_change|·recycle·frac // material recovered, energy not
NIGHT | 4 BEHAVE (homeostatic scaling) NIGHT | 4 BEHAVE (homeostatic scaling)
@@ -431,12 +485,18 @@ NIGHT | 5 DECAY (clear traces)
## One-view summary ## One-view summary
``` ```
DAY per context: RECEIVE → EVALUATE → ADJUST → BEHAVE/EMIT/TRACE → RECOVER → DECAY SEVEN-GROUP GRAMMAR, TWO TIMESCALES
behavior runs within structure (strength) and budget_ceiling (endurance), RECEIVE · TRACE · ADJUST · BEHAVE · EMIT · RECOVER · DECAY
both filled competitively (refill = contested, fill = private, ship = directed)
fast_trace + dopamine → tag (strength evidence) DAY grammar on OCCUPANCY within two ceilings (structure=strength, budget_ceiling=endurance)
depletion + interrupted LOCAL success → endurance_need (endurance evidence) TRACE yields two evidence streams from local state + arrived signals:
NIGHT same grammar on ceilings: tag → structure ; endurance_need → budget_ceiling fast_trace + dopamine → tag (strength)
both draw one pool (compete) ; unmaintained ceilings decay → freed material recycles FUEL shortfall + interrupted LOCAL success → endurance_need (endurance)
LOCAL every evaluation uses only own state + arrived signals; coupling is via channels. 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.
``` ```