From f7fff7d9b16d679a4e71137b0803c3dfb0b71d92 Mon Sep 17 00:00:00 2001 From: ocrampal Date: Mon, 13 Jul 2026 16:49:36 +0200 Subject: [PATCH] Update 2026-06-29-tripartite-synapse_v17.md --- .../2026-06-29-tripartite-synapse_v17.md | 2459 ++++++++--------- 1 file changed, 1216 insertions(+), 1243 deletions(-) diff --git a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md index 3e744c6..7097ad8 100644 --- a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -1,1341 +1,1314 @@ -# Tripartite Synapse — Pseudocode v17 +# The Logic of the Tripartite Synapse Model — v5 -> Companion: `tripartite_synapse_v17_biology.md` · principle: `logic_principles_v5`. -> Model — every component runs the SAME THREE CATEGORIES in two directions: -> (ACTION ⇄ RECOVERY) × many, then PREPARATION — outward by DAY (world), inward by NIGHT (economy). -> ACTION = the defining deed (day: release/fire/respond/propagate ; night: build ⇄ release structure). -> RECOVERY = fast alter-ego, restore the ability to act (day: refill ; night: import + free material). -> PREPARATION = shape what's next, facing this scope AND the other; night PREPARATION REPLAYS the day -> ACTION (same machinery, no dopamine) to measure PARTICIPATION. "Evaluation" retired — a trace is a -> provision, not a judgment. Each category spans FAST · MEDIUM · SLOW. -> (1) EIGHT actors: LOCAL components (soma·pre·post·dend·axon·astrosynapse) · CELL actors (neuron over -> soma/pre/post/dend/axon ; astrocyte over astrosynapses) · SYSTEM actor (hypothalamus). -> (2) DAY/NIGHT is a TOP-DOWN context BROADCAST by the hypothalamus, which integrates FATIGUE -> (astrocyte-reported metabolic debt) ⇄ REST and emits the scope. Earned, not clocked; not local. -> (3) NIGHT ACTION is BUILD ⇄ RELEASE, participation-arbitrated: build (tag stands + participation ≥ -> MEDIUM; tag funds a slice, persists across cycles) vs release (participation LOW; frees material; -> tag untouched). Build/release compete WITHIN a component; material competes BETWEEN components. -> Two forgettings: structural pruning (low participation) · intention decay (tag unspent). -> TWO PATHWAYS: STRENGTH (possible_tag → dopamine → tag → structure) is dopamine-gated and belongs -> only to the significance-deciding sites — POST (primary), PRE, SOMA. ENDURANCE (endurance_need → -> budget_ceiling) is homeostatic, load-driven, NO dopamine. The relays AXON and DEND and the glial -> ASTROSYNAPSE are ENDURANCE-ONLY (no reward-validated strength tag); the astrosynapse's coverage -> build is driven by coverage_need (spillover coincident with postsynaptic NO), a homeostatic signal. -> (4) DAY collaborates (non-rival information; each acts so the next can act); NIGHT competes (rival -> conserved material) — but the competition is ADJUDICATED by collaborative replay (participation). -> (5) ASTROCYTE is the metabolic sensor (drives the switch, permits waking) and DAY primer (alpha-driven -> localized neuromodulation). Higher actors INTEGRATE emissions and BROADCAST — never reach in. -> (6) governing rule: NO actor authorizes its own restructuring — each is PUT IN POSITION by the actor -> above (holds an aggregate it cannot see, opens a window it cannot open). Act locally, consolidate -> hierarchically. Material recycles; ENERGY does not (the arrow of time). -> ASTROSYNAPSE now converted: D-serine = POST gain (not gate) ; astrocyte Ca-spike = territory-coincidence -> broadcast (integrate-and-fire) ; astrosynapse = volume/gain modulator, build⇄release coverage. +*A synthesis of the principles the pseudocode enacts. The document is ordered why → what → how: it +opens with why this is a different kind of object than an ordinary model (Part I), states the single +principle its content obeys (Part II), then descends through seven categories that specialize that +principle (Part III). The why comes first because it is the reason everything else matters — without +it, a reader could take the categories for a description of a synapse and miss that they describe a +physics that writes itself.* + +*What changed in v5. The old "evaluation" phase is retired — it was always preparation aimed at +the other scope. The ring is recut into three categories: ACTION, RECOVERY, PREPARATION. The +obsolete subject-mapping (lateral/local/vertical) is dropped. New findings are folded in: the +rhythm is (ACTION ⇄ RECOVERY) × many, then PREPARATION; every category spans all timescales; night +PREPARATION replays the day ACTION with the same machinery; build and release compete within a +component while material competes between components; there are two independent forgettings; +collaboration by day versus competition by night follows from the rivalry of each scope's currency; +behavior is legible and meaning is assigned by the reader not the signal; and the three categories +are the three modulable dimensions of behavior. Nine categories are consolidated to six, a seventh +is added (the four operations), and — new in this revision — the "why" (formerly a closing note) is +corrected and promoted to the front as Part I.* --- -DAY AND NIGHT ARE A TOP-DOWN CONTEXT, BROADCAST BY THE HYPOTHALAMUS. The alternation is NOT a local -per-component decision — it is a single context signal emitted from above and received by every -component, the way the neuron's renormalization or the astrocyte's priming is broadcast. The -hypothalamus integrates two competing drives — FATIGUE (metabolic debt, reported chiefly by the -ASTROCYTE, which runs the energy economy) and REST (restoration accumulated during quiet) — and -emits the DAY/NIGHT context according to which dominates: +# PART I — Why This Is Not a Model but a Way of Making Models -``` -SCOPE CONTEXT (computed by HYPOTHALAMUS, broadcast to all; CONTINUOUS — the one actor that never sleeps): - fatigue ← integrate metabolic debt + unspent demand emitted by components (astrocyte-reported) - rest ← integrate restoration accumulated while quiet - emit DAY while rest dominates fatigue (behave outward) - emit NIGHT while fatigue dominates rest (restructure inward) - The context is EARNED, not clocked: it is the integrated outcome of the fatigue⇄rest competition, - not a wall-clock schedule. Components do not each decide when to cross; they receive the context. -``` +Before the principles, one question: *what kind of object is this?* The answer is unusual, and it +governs everything that follows. This is not a model you can write down and run. It is a **generator +of models** — a rule that turns each history into a different fixed model, and only once that history +has been lived. History is not a variable inside the model; history *is* the model. This part earns +that claim, because stated cold it sounds like mysticism, and it is not — it is a checkable fact +about what the coupled components do. -Why top-down and not local: behaving and restructuring compete for the same substrate (a component -cannot restructure while busy), so the crossing must be coordinated across the coupled components — -a pattern can only replay at night if its whole loop is in NIGHT together. A per-component local -crossing could not guarantee that coherence; a broadcast context does. The switch is top-down; what -each component DOES within the context (behave / replay / build) remains fully local. +**The pseudocode is a physics written in the grammar of an algorithm.** The companion pseudocode +reads like a program — assignments, conditionals, loops — but every line leans on something code +cannot supply. Its primitives — the calcium influxes, the fluctuations, the clearances — name +*physical processes*, not computations; `mini_Ca()` is a placeholder for "whatever the matter does +here." Every `·Δt` is a differential equation in disguise: the discrete step is our notation, the +thing itself is continuous. And every coincidence — the three-way gate, the tag, the build — assumes +its inputs are *present at the same instant at the same place*, which the physical cleft supplies for +free by diffusion but which an `if` can only presuppose. The imperative grammar is a transcription; +the content is a dynamical system. The pseudocode is faithful to the model exactly where it is +unfaithful to computation. -THE FATIGUE⇄REST LOOP. Activity generates fatigue (the astrocyte accrues and reports metabolic -debt); rising fatigue tips the hypothalamus to broadcast NIGHT; restructuring discharges debt and -accrues rest; rising rest tips it back to DAY. DAY and NIGHT are the two phases of one homeostatic -competition the hypothalamus integrates and broadcasts — the astrocyte is the metabolic sensor that -feeds it, and (see ASTROCYTE) the discharge of debt during night is what permits waking. +**The natural objection: surely it can still be simulated.** Nothing here is non-computable in +principle. The dynamics are differential equations with thresholds, which computers integrate +routinely. If "implement" means "numerically approximate a trajectory," computation suffices. This +objection is correct as far as it goes — so the question is what happens when you try to act on it. -``` - every component → emits fatigue (metabolic debt, unspent demand) ↑ - ASTROCYTE → integrates territory energy debt → reports fatigue ↑ (the metabolic sensor) - HYPOTHALAMUS → integrates fatigue ⇄ rest → BROADCASTS DAY/NIGHT ↓ (CONTINUOUS) - every component → receives the DAY/NIGHT context (top-down) -``` +**A first answer that is true but philosophical: the simulator occupies the vantage the model +denies.** The model's content is that there is no global state — no component reads another's +interior, no place holds the whole, holism is enacted and never encoded. But to compute the system +you must hold every component's state in one memory and step them in one loop: the simulator *is* the +forbidden global observer. To order the updates it needs a scheduler (a central order-giver) or a +synchronous clock ticking all components together — the "command from above" that "causation +circulates, command nowhere" denies. And it must *count* time as a variable, where the model insists +time is *suffered* — read off the decay of stores, kept by forgetting. So a computed simulation gets +the trajectory right and the ontology backwards. This is real, but on its own it can be waved away as +metaphysics. The decisive answer is concrete. -ACTORS ARE PEERS AT EVERY SCALE; EACH IS PUT IN POSITION BY THE ONE ABOVE. No actor authorizes -its own restructuring. Each holds an aggregate its constituents cannot see and opens a window -they cannot open, then BROADCASTS — it never reaches into a constituent's interior. +**The decisive answer: there is no one model to simulate — only a way of making models.** Compare two +cases. -``` - HYPOTHALAMUS integrates fatigue ⇄ rest → broadcasts DAY/NIGHT context (system, CONTINUOUS) - ↓ signal - NEURON integrates its components' activity/weight → broadcasts (cell actor) - ASTROCYTE reports fatigue upward ; primes (day) + reallocates (night) (cell actor) - ↓ signal (NEURON over soma/pre/post/dend/axon ; ASTROCYTE over astrosynapses) - COMPONENTS soma · pre · post · dend · axon · astrosynapse — each restructures ITSELF - within the broadcast DAY/NIGHT context - [ ASSEMBLY / NETWORK ] replay is INTERNALLY generated (spontaneous firing, below); the external - replay_reweight only BIASES which internal patterns are favored (cross-neuron - coordination), arriving like dopamine/glucose — it is not the replay itself -``` +Where simulation *works* — pricing a financial option. You have **one fixed model**: a stochastic +equation with fixed parameters, the same rule on day 1 and day 200. You run 100,000 random price +paths through that same equation. Each path differs, but all are **samples of one stationary object** +— the fixed distribution the equation defines. Average the payoff over them and it **converges**: +100,000 paths give a good estimate, 200,000 barely move it. It works because the paths are variations +on a single system — noise around a stable structure. History matters *within* a path but never +changes *the model*; every path runs the same equation. The model is one object; the paths are its +samples. -The two cell actors are structurally identical — same integrate-and-broadcast role, different -constituents and conserved quantity: NEURON conserves activity/weight, ASTROCYTE conserves -territory demand/load. Both have their own DAY (integrate, allocate in the gaps) and NIGHT -(broadcast the restructuring window). The HYPOTHALAMUS alone has no night: it runs CONTINUOUS, -always integrating fatigue and emitting sleep-pressure, spanning every other actor's day and -night — the clock that never sleeps. +Where the same recipe breaks — this model. Take the four steps in turn. **(1) There is no one fixed +model.** The equation is not the same on day 1 and day 200: night 1 rewrites it into a new equation, +night 2 rewrites that. Each path runs a *different, self-modified* equation by day 10 — there is no +fixed rule to sample from. **(2) The paths are not variations on one system; they are different +systems.** In option pricing, two paths are the same stock behaving differently. Here, the path where +synapse X won an early material competition and grew, and the path where its neighbour Y won instead, +have *physically different structures* — different synapses exist. They are not two runs of one model +but two different models a shared early history produced. **(3) There is no center to converge to.** +The average final price is a real thing; the "average" of *X exists, Y pruned* and *Y exists, X +pruned* is not a valid configuration — it is a blend of two incompatible circuits, corresponding to +no possible state. **(4) More samples stabilize nothing.** More option paths tighten the estimate; +more runs here yield *more distinct circuits*, never a better estimate of one, because there is +nothing for them to estimate. -EVERY SCOPE RUNS THE SAME THREE CATEGORIES: (ACTION ⇄ RECOVERY) × many, then PREPARATION. - ACTION the scope's defining deed (DAY: release/fire/respond/propagate — the cleft exchange; - NIGHT: change structure — the irreversible build). - RECOVERY the fast alter-ego of the action — restore the ability to act again (DAY: vesicle - refill, refractory de-inactivation, Ca clearance; NIGHT: import material/energy, prime). - PREPARATION shape what comes next — faces BOTH the next same-scope action AND the other scope. - This is where what earlier drafts called "evaluation" lives: depositing a trace is not - judging, it is provisioning. DAY-preparation stocks the tag (for NIGHT) and sets - occupancy/thresholds (for the next action). NIGHT-preparation REPLAYS the action — - re-runs the SAME machinery as DAY ACTION (same capacity/vesicle checks, same endurance - deposit into the SAME trace), but with NO dopamine and the release as a PROBE, read as - participation, not transmitted. +In one line: in Monte Carlo, history varies *within* a fixed model, so samples estimate the model; +here history *is* the model — each history builds a different system — so there is nothing the +samples jointly estimate. That is the precise content of "there is no one model, only a way of making +models." The pseudocode is not a model you sample; it is a *generator* of models, one per history, +knowable only once the history is complete. -NIGHT IS A SEQUENCE OF REPLAY CYCLES (dual of DAY). DAY loops until energy/material is exhausted; -NIGHT loops until the tag is exhausted. The rotation across scopes: the SAME physical release/fire -is ACTION by DAY (the deed) and PREPARATION by NIGHT (the probe that replays it); the structural -change is only MARKED by day (the inert tag) and ENACTED by night (its action). SOMA is the ignition -point: its night-PREPARATION replay-fire propagates a replay_AP through the DAY PATHWAYS -(soma→axon→pre→glutamate→post→dend→soma), self-igniting the tagged pattern. +**And Monte Carlo is not the only rescue that fails — every acceleration method fails, for the same +reason.** Each general way to compute a system faster than living it out relies on some *stable +invariant* to exploit, and this model, by construction, holds none. +- *Closed-form solution* needs the future to be a computable function of **time**; here it is a + function of the whole **history** — no formula takes a path as input and skips it. +- *Coarse-graining / renormalization* (physics' strongest tool, and tempting given the fast-day / + slow-night split) needs the fast variables to settle, at fixed slow parameters, to a **stationary + average** the slow dynamics can see. But the day's dynamics never settle history-independently — + *which patterns can fire* depends on structure built by every prior night — and the coupling is + bidirectional and same-order: the slow change *is made of* specific fast events (which pattern + replayed), not their average. Coarse-graining discards exactly the individuating detail the model + consolidates. The micro-detail here is the signal, not the noise. +- *Dynamic programming / memoization* needs **state recurrence** to cache and reuse; irreversible + ratcheting (energy spent, structure pruned) means no configuration is ever revisited — + nothing repeats, so nothing can be cached. +- *Surrogate / learned models* need **cross-history regularity** to generalize; the histories are + incommensurable individuals with no shared structure, so there is nothing to learn that is cheaper + than running the history. -COHERENCE IS MECHANICAL, not a checked flag: a pattern re-evokes only where EVERY link in its -recurrent loop is primed (each component's own tag lowered its own threshold in RECOVERY); one -un-primed link breaks the loop at the gap, so only patterns significant all the way around carry. -The assembly that replays is NOT an actor — it is the coincidence of many components' own lowered -thresholds propagating through recurrent coupling. +Every method needs one of: time-parametrizability, scale separation with stationary fast statistics, +state recurrence, or cross-history regularity. This model has none — it is history-parametrized, its +fast and slow are same-order coupled, it never recurs (irreversible ratchet), and its histories are +incommensurable. The methods do not fail by bad luck; each needs the stable, reusable structure that +"the specification is continuously rewritten by its own running" abolishes. -WHAT PERSISTS MUST HAVE EARNED PERSISTENCE. Night-RECOVERY drives occupancy (VGCC_active, -AMPA_surface, possible_tag) toward baseline; night-ACTION's homeostatic lowering trims all -structure; only what is rebuilt from a still-standing tag with confirmed participation carries -forward. NIGHT ends when the tag is exhausted (well-rested — every significant pattern replayed and -its structure rebuilt) OR energy is spent (overloaded — unspent tags carry to the next night). +**And here the exponential appears — not as the obstruction, but as its price.** Suppose you refuse +all of the above and insist on simulating anyway. To simulate *is* to fix a structure: a simulation +is a set of variables updated by fixed rules, and you cannot write the loop without committing to +what the variables are. But the real structure changes every night. So you face a forced choice. +Freeze *one* structure and you have committed to a single branch — one accidental history, a +measure-zero sample of a thing that is not a distribution. Stay faithful while keeping a fixed +substrate and you must instead carry *every* structure the system might occupy as an enumerated set — +and that set multiplies each night, growing exponentially in the number of nights, of changing +dimension, non-factorable. This exponential is not a property of the model; the model never +enumerates, it simply becomes one structure. The exponential is the shadow the fluid, self-rewriting +model casts on a fixed substrate — it arises *if and only if* you demand the stable structure that +simulation requires. The need for stable structure is what converts self-rewriting into +exponential enumeration; drop the demand and the exponential vanishes, leaving only a physics living +one history. + +**Three concrete faces of the obstruction.** *The foreclosed synapse:* a synapse pruned on night 3 +is gone; a pattern that would have used it on night 50 breaks at that link and cannot replay, so its +downstream components lose participation and drift toward pruning too — one cheap early pruning +deterministically forecloses a family of patterns fifty nights later, and you cannot know night 50's +structure without having run nights 3–49 in order. *The two histories that never reconcile:* run from +the same start twice; because material is conserved and structure capped, X-growing starves Y, and by +night 20 the runs have disjoint sets of synapses — not noisy versions of one answer but two +incompatible circuits with no meaningful average. *No shortcut:* because each night's structural +change feeds the next day's dynamics feeds the next night's change, with no scale separation to +exploit and no recurrence to cache, the one honest trajectory must be computed night by night, in +order, in full — it is its own shortest description. The only way to know the state at night N is to +run all N nights. + +**Why this is one insight, not several.** The deep cause is that the model **abolishes the separation +between program and data.** Structure (the equations) is built from the accumulated traces of +behavior; behavior runs on structure. Night turns data into program; day turns program into data. +There is no stable specification anywhere, because the specification is continuously rewritten by its +own running — which is just "holism enacted, not encoded" and "no global state," seen over time. A +computation *requires* the split: the program is, by definition, the stable part. A thing with no +stable program cannot be captured by one. + +**What the physics does instead — and why the synapse is its own faithful implementation.** The +physical synapse escapes all of this not by being non-computable but by never needing an invariant. +It does not compute which structure obtains tomorrow; it *becomes* it, by undergoing its night. It +realizes exactly one history in real time — the *real* one, not a sampled one — needing no global +memory (each component holds only its own state), no scheduler (time sequences everything at once, +everywhere, for free), no counted clock (its stores keep time by decaying). So the faithful +implementation of this model is not a program but a *material*: something that, by its own +constitution, undergoes these dynamics with locality, simultaneity, continuity, and suffered time, +without a controller. You can compute *a* life — one honest history, in full, in order, +incompressibly — but never *the* model, because there is no "the model": there is a rule that makes +one model from each history, and the synapse is the matter that runs that rule by being it. + +*Two honest limits. This says faithful **acceleration** is impossible, not that useful +**approximation** is — a coarse model can teach you things, it just would not be this model. And it +holds for the model as specified (irreversible, non-recurring, individuating); whether real neural +tissue is secretly more regular, with statistics one could exploit, is an open empirical question, +not something these principles can foreclose.* + +**The same no-privileged-vantage principle has a second face, in description rather than simulation.** +The first face is simulative: there is no fixed model, only histories. The second is descriptive: +there is no privileged object, only *cuts*. Nothing in the system is a bounded, persisting object one +could isolate and make the whole story — the synapse is part of a neuron, the neuron of an assembly, +the assembly of an organ, with no top and no bottom, only nested aligning projects. To describe it at +all, an observer must *choose a cut*: a boundary, a timescale, and a scope, treating what is inside as +the object and everything larger and smaller as context appearing at the boundary. Every cut is +partial by necessity; none is the whole, for the same reason no computation is the model — there is no +privileged, bounded, stable thing to be the whole. This is orthogonal to the reductive default of +classical physics, which cuts at *static object-boundaries* and explains by *cause and effect between +persisting objects*. Here the objects are active alignments continuously re-achieved, not persisting +substances; the cut is a chosen boundary × timescale × scope, not a given; and the relations that +matter are *constitution across cuts* (parts constitute an object; a level constrains the one below, +emerges into the one above), not efficient causation between objects at one level. Within a single cut +at a single timescale, ordinary cause and effect still works (this release causes that response); it +is the *objects of interest* — synapse, alignment, assembly — that live at the intersection of cuts, +where between-object causation is not the operative relation. There are affinities here with the +scale-relative parts of modern physics — the renormalization group, non-equilibrium thermodynamics, +effective field theory, all of which make descriptions depend on the scale of the cut — but those do +not *solve* this system (see the acceleration survey: they lack the invariants it refuses to hold); +they only point in the right *direction*, toward descriptions that are cut-relative rather than +absolute. The descriptive consequence — that each real object is an object-under-a-cut, partial by +construction — is developed in the companion document on the unexpressed objects. + +Everything below is what this self-writing physics *is* (Part II) and how it works, category by +category (Part III). --- -## Conventions +# PART II — The Unifying Principle -``` -SCOPE = {DAY, NIGHT} DAY CONTEXT = {AP, REFRACTORY⊂NOT_AP, NOT_AP, NOT_SPIKE_TRAIN, CONTINUOUS} NIGHT CONTEXT = {NON_REM_1, NON_REM_2, REM} +Watch one presynaptic bouton for a day and a night. By day it releases neurotransmitter, restocks +its vesicles so it can release again, and — in the quiet after a burst — stocks a trace that records +how much this release mattered. By night it does the same three things at a slower tempo: it changes +its structure, restocks the material to change again, and replays the release as a probe to measure +whether the change is still warranted. Nothing supervises it. It reads only its own state and the +signals that reach it. What we call the synapse, the neuron, the memory, the organism is nowhere +inside the bouton — it is only the name we give to many such boutons, coupled. -THE THREE CATEGORIES (see logic_principles "The Ring"): (ACTION ⇄ RECOVERY) × many, then PREPARATION - ACTION the component's defining deed; deposits the fast trace. ALWAYS LOCAL to the acting - component (cannot be done on another's behalf — that would be signalling, not acting). - RECOVERY the fast alter-ego of action — restore the ability to act again (refill, de-inactivate, - clear). Day: restock private pools. Night: import material/energy, free trimmed material. - PREPARATION shape what comes next; faces BOTH the next same-scope action AND the other scope. - Stocks the tag (for NIGHT) and tunes occupancy/thresholds (for the next action). What - earlier drafts called "evaluation" is here: depositing a trace is provisioning, not - judging. RECOVERY and PREPARATION may be LOCAL or CONTEXTUAL (a neighbor supplies them); - ACTION is always local. A near-pure-action component (e.g. a channel) is ACTION-only. - A category names a KIND of work, not a timescale: each spans FAST · MEDIUM · SLOW. +That is the whole model in one instance. Stated generally: -CONTEXT LICENSES PHASE (context = the imposed condition; phase = the work it permits). - The context is what other components impose (a spike delivered or not, a train present or not); - the category annotation says which work runs. Contexts can NEST, and nested contexts run - ON TOP of their parent — a behavior is written in exactly ONE context, so nothing double-runs: - AP spike this step → ACTION - NOT_AP no spike this step → RECOVERY (restock) (in-train gaps AND quiet) - NOT_SPIKE_TRAIN no spike AND no train ⊂ NOT_AP → adds PREPARATION (runs on top of NOT_AP) - A process runs in the SHORTEST quiet its timescale fits: fast-trace decay and partial pool refill - in NOT_AP (they ride the train and set short-term depression); tag formation, full refill, and - occupancy read-out in NOT_SPIKE_TRAIN. (Components without trains use continuous flow.) +> **There is only the local component and its one repeating act. Everything we call a system — the +> synapse, the neuron, the assembly, the organism — is that act, multiplied and coupled, and +> described from outside. The act has one shape (act, recover, prepare) run in two directions +> (outward by day, inward by night), and the relations between components are set by what is scarce. +> Holism is real, but it is enacted by the coupling, never encoded in any part.** - WHO EMITS THE CONTEXT (a context is a signal from ABOVE, not self-generated): - AP, REFRACTORY emitted by SOMA — its own firing state (AP = it fired; REFRACTORY = the recovery - window after, when it cannot fire again yet). What was "NOT_AP" is REFRACTORY. - NOT_SPIKE_TRAIN emitted by the NEURON — sustained absence of soma spikes can only be tracked from - ABOVE the soma (a component cannot easily know "I have not fired for a while"); - the neuron keeps count of the gap and broadcasts it down. - NON_REM_1/2, REM emitted top-down within the NIGHT context (see DAY/NIGHT switch) — the night's - sub-phases: NON_REM_1 → ACTION (build⇄release), NON_REM_2 → RECOVERY - (import+free), REM → PREPARATION (replay+measure+prime). +This is why the model is a generator rather than a fixed object (Part I): because the specification +is never encoded in any part but enacted by the running, it is rewritten by that running, so no fixed +model exists — only the rule and the history. - POST INVERTS THE DAY MAP. For the postsynapse the deed is RECEIVING, which happens whenever no - descending spike is arriving, so: NOT_AP → ACTION (open AMPA/NMDA, respond), AP → RECOVERY (the - brief descending spike, driven from above, restore + boost traces), NOT_SPIKE_TRAIN → PREPARATION. - POST's ACTION continues through the soma's REFRACTORY (refractory is the soma's state, not POST's; - from POST it is NOT_AP), which is how the spine charges up to ready the next spike. +Every category in Part III is this principle, turned to face one question: *What is a component?* +(locality), *What is its act?* (the ring), *What are its two directions?* (the two turnings), *At +what speeds does it act?* (the ladder), *How do components relate?* (scarcity), *Who is in charge?* +(causation — no one), and *By what operations is the local multiplied and coupled into a describable +whole?* (the four operations). None adds a new assumption; each specializes the one above. -VARIABLE TIERS (timescale = meaning; see logic_principles "The Timescale Ladder") - FAST (ms–s) immediate response fast_trace - MEDIUM (s–min) occupancy + evidence possible_tag · endurance_need · VGCC_active · AMPA_surface · RRP - SLOW (hr) consolidation bridge tag - ───────────────────────────────────────────────────────────────────────────── - PERSISTENT (NIGHT) capacity (the ceilings) structure · budget_ceiling - energy (not recoverable) · material (recoverable) - -THE DAY STRENGTH CLIMB (same three-tier averaging in every component): - 1. each ACTION leaves a fast_trace (FAST). - 2. the running AVERAGE of fast_traces over SECONDS fills occupancy → short-term strength - (VGCC_active in PRE, AMPA_surface in POST, …); a LOW average lets occupancy drift back (STD). - 3. the AVERAGE-OF-THE-AVERAGE over MINUTES (possible_tag), in coincidence with dopamine, raises - the TAG (SLOW) — the token passed to NIGHT. At night the tag is spent to modify structure - (the persistent version of the same strength the occupancy held transiently). - So occupancy is the fast/medium memory of participation; the tag is its dopamine-validated, - night-consolidatable distillate. Same climb, same three tiers, in all six components. - -DAY budget · fast_trace · possible_tag · endurance_need -BRIDGE tag (POST: CANDIDATE→STABLE) -NIGHT energy (not recoverable) · material (recoverable) · structure · budget_ceiling - -LOCALITY only local state + arrived signals; no component reads another's internal state. - -CUT SIGNPOSTS (@cut) — an INDEX into the possibility, not part of it. The pseudocode expresses the - POSSIBILITY of verifying behaviours in time/space/quantity; a CUT is a reading WE impose from the - outside to construct an object, and cuts are UNBOUNDED, so they are NOT in the code — they live in - the companion `logic_of_aggregations` (there, a "cut" fixes levels on time/space/quantity + scope, - and an OBJECT is a name over the behaviours so read). A signpost only marks a STORE where such an - outside reading can be TAKEN — what it affords us, at what grain. It is NOT a mark on the - component's own local decisions: thresholds, tags, and bucketings like level() are the component - BEHAVING (expression), not us reading (a cut), and carry no signpost. The test is whose act it is: - the component's own decision is expression; our reading-to-build-an-object is a cut. A signpost - computes nothing and privileges no reading; deleting every @cut leaves the expression unchanged. - Form: - ... // @cut affords: [grain] - Rules: one per load-bearing store (the traces, tags, occupancies, coincidence sites — not every - line); names affordances, never computes them; must be deletable with zero effect. For the worked - readings, see logic_of_aggregations. - -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 - retro_eCB POST → PRE (−) axon_ship_pre AXON→PRE -``` +A note on language. This document does not say "the system." There is no system — only local +components, contextualized by their neighbors. Where the phrase appears, it is inside quotation +marks, naming the thing we are denying: an actor that stands above the parts, holds the whole, and +acts on it. No such actor exists here. --- -## Primitives (return the increment; caller applies it) - -``` -sat(x, K) = x / (K + x) - -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, 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: // 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 -``` +# PART III — What the Physics Is, and How It Works --- -## SHARED parameters +## 1. Locality — The Only Thing That Exists Is a Local Component -``` -dopamine NE ACh // organism broadcasts (external) -replay_reweight[·] // assembly/network replay re-weighting (external, NIGHT) -glucose geometry // physical (external) -scope_context ∈ {DAY, NIGHT} // BROADCAST by HYPOTHALAMUS (top-down; the switch, read by all) -fatigue_gain rest_gain // hypothalamus fatigue⇄rest integration weights -elig dop_thr tag_thr tag_expiry // strength gates (universal) -traj_thr endur_thr // endurance gates (universal) -ship_cost // transport overhead (all shipments) -{dend,axon,pre,post}_ship_frac // DAY budget-shipment fractions -τ_transport_{dend,axon,spine,bouton} // shipment transit times (distance-dependent) -ε -``` +Everything the model contains is a local component: the bouton, the spine, the astrocytic process, +the dendrite, the soma, the axon. The actors we call higher — neuron, astrocyte, organism — are not +additional things. They are descriptions of many components' coupled activity, spoken from outside. +This is the direct reading of the unifying principle, and the rest of the category is its mechanics. -## NIGHT parameters (consolidation only) +**A component reads only its own state and the signals that arrive.** It cannot read another +component's interior, and it cannot read "the whole." When the bouton needs to know whether its +release reached a responsive target, it does not inspect the spine; it waits for a retrograde signal +the spine emitted. Coordination is never achieved by a component consulting a global state, because +there is no global state to consult. It is achieved by signals crossing between components, each +read locally and made to mean something by the local context that receives it. -``` -slot_batch cap_batch f_cap // per-CYCLE commit/allocation sizes / endurance fraction -night_energy_ceiling // total energy a single night can spend (supply bound) -Δt_cycle // duration of one NIGHT cycle (recovery→preparation→action) -maint_frac cap_frac // maintenance allocation -decay_rate capacity_decay_rate recycle // passive ceiling decay + material recovery -homeostatic_ceiling assembly_cost biogenesis_cost maint_cost -f_dend f_axon f_spine f_bouton // per-cycle material/energy ship fractions (down the chain) -downscale_factor // per-cycle multiplicative occupancy reset (<1), night RECOVERY -neuron_weight_ceiling // renormalization target (broadcast constraint) -// ── NIGHT (RECOVERY = import/prime · PREPARATION = replay probe · ACTION = restructure) ── -spont_thr_base thr_gain // spontaneous threshold = base − gain×own_tag (night RECOVERY prime) -prime_thr prime_gain // tag threshold to raise VGCC, and the gain (night RECOVERY) -release_rate homeostatic_floor // night RELEASE: shed rate + floor structure never pruned below -intrinsic_fluctuation() // intrinsic sub-threshold noise (the night's ignition source) -mini_flux mini_Ca() // spontaneous mini release size + its Ca deposit (REM probe) -level(·) → {LOW, MEDIUM, HIGH} // reads fast_trace as circuit participation (REM, no dopamine) -replay_AP // propagated re-evocation spike (soma → axon/dend, self-igniting) -``` +**Everything emits; nothing is a pure sink.** A component that only consumed would be invisible to +the rest and could not participate in coordination. Even the leaves of the daytime chain — the +bouton, the spine — emit: by day they emit fatigue upward and retrograde messages laterally; by +night they emit freed material into the shared pool and demand upward. To exist in the model is to +be readable, and to be readable is to emit. ---- ---- -# LOCAL COMPONENTS -> Each behaves within the broadcast DAY context and restructures within the broadcast NIGHT context -> (see Conventions: the transition rule). `DAY | …` / `NIGHT | …` label local states, not a clock. ---- +**Behavior is legible: acting leaves a readable mark, sent or not.** What a component emits is not +always an intended message. Some emissions are *signals* — sent to be read (glutamate, the +retrograde messages, D-serine). Others are *traces* — the physical residue of acting, read by +others though never "sent": spillover glutamate is the consequence of a bouton releasing more than +the cleft can clear, and that overrun is itself information about the bouton's power. There are no +silent acts. Acting and informing are inseparable, because behavior displaces the shared medium and +the displacement is readable. This is why coordination needs no broadcast of intent: a component +that simply behaves is already legible to whoever shares its medium. -## PRE +**Meaning is assigned by the reader, not carried by the signal.** A signal is a physical fact — a +molecule, a voltage, an overrun. It has no intrinsic meaning; its meaning is fixed by the local +context that reads it. The same endocannabinoid is a *brake* to the bouton (reduce release) and a +report of *postsynaptic excess* to the astrocytic process (a pressure cue for its own structural +control). The same nitric oxide is *confirmation to strengthen* for the bouton and *this coincidence +was real, keep the capacity* for the astrocyte. The same spillover is *lost transmitter* to no one +and *my presynapse has outgrown my volume* to the astrocyte. One emission, many readers, many +meanings — and none of the readers consults the others to agree on the meaning. This is the locality +principle at the level of semantics: because no component can read another's interior, all it ever +has is the shared physical facts, which it must interpret unilaterally. Coordination is achieved +without shared meaning — each component reads the common medium and assigns its own. -The presynaptic bouton releases neurotransmitter and gathers evidence about whether that -release was worth strengthening and worth sustaining. Like every component it runs the three -categories — (ACTION ⇄ RECOVERY) × many, then PREPARATION — in two directions: outward by DAY -(against the cleft), inward by NIGHT (against the economy). +**Coupling is openness, and openness is bounded.** A component is open — it takes in signals and +supply, gives out signals and product — but its openness is bounded by what it can physically +reach: its own cleft, its own supply lines, the neighbors it is wired to. It is neither sealed (that +would make coordination impossible) nor unbounded (that would make it the whole). The bounded +openness is what lets many local components compose into something we can describe as a whole +without any of them being that whole. -**DAY · ACTION (the AP) — the bouton releases.** The amount released depends on residual -**calcium** (the fast trace, set by this spike), the current **VGCC coupling occupancy** (how -tightly channels are coupled right now, bounded by structure), the two **retrograde messages** -(`retro_eCB` brakes, `retro_NO` confirms release reached a responsive target), and the -availability of **fuel and vesicles**. The action deposits the fast trace the rest of the turn -reads. Two shortfalls read differently: a fuel shortfall on a succeeding release is *endurance* -evidence; an empty pool with fuel to spare is ordinary short-term depression. +**Holism is real but only described.** The re-evoked pattern at night, the neuron's total activity, +the memory a synapse carries — these are real. But they are not stored anywhere. The pattern is not +in any component; it is what happens when many primed components ignite each other. The neuron's +"excitability" is not computed by anyone; it is the coincidence of many components' own lowered +thresholds. Holism is enacted by the coupling and read off by us as observers — it is never encoded +in a part, because if it were, that part would be the system, and there is no system. -**DAY · RECOVERY (between spikes) — restock to release again.** In the inter-spike gaps the bouton -refills its vesicle pool and lets the fast trace relax — the fast alter-ego of release, riding the -train, and the release-vs-refill race is what sets short-term depression. +**A component cannot be contextualized by a context it emits — so initiators self-trigger.** A +*context* is a signal one component emits for others to read (a spike delivered or not, a train +present or not). Locality has a consequence for contexts that is easy to miss: a component cannot +consume its own emission as its context. It would be reading its own interior, which locality forbids; +and it is circular — a component that fires does not need to be told it fired, it *is* the firing. So +what a component emits (the soma emits AP and REFRACTORY) is its *output*, never its own context. This +splits components in two: -**DAY · PREPARATION (train passed) — shape the next release AND the night.** Reading the accumulated -fast trace, the bouton climbs eligibility (`possible_tag`) and, on the dopamine coincidence, the -`tag` — the token stocked for the night (this is provisioning, not judging). It also latches the -retrograde messages, tightens its VGCC coupling from eligibility (reversible short-term potentiation, -no dopamine, bounded by structure), and refills budget toward the next demand. +- A **responder** (the spine, the perisynaptic process, the relays) has a deed that is a *response to + an arrival*, so an external context licenses even its ACTION: glutamate present, a spike arriving. + It consumes a context to act. +- An **initiator** (the soma) fires from *its own* integration crossing *its own* threshold. Nothing + external licenses its action; it runs continuously and the alternation between acting and recovering + is decided by its internal condition. It emits its phases (AP, REFRACTORY) as contexts *for others*, + and cannot itself be contextualized by them, since it is their source. -**NIGHT — the same three categories as DAY, at a slower timescale, turned inward.** Every scope -runs the same shape: an alternation of ACTION ⇄ RECOVERY (many times), then PREPARATION. By DAY -that is (release ⇄ vesicle-refill) × many spikes, then preparation (climb the tag, set VGCC, -refill, thresholds). By NIGHT it is (restructure ⇄ material-import) × many cycles, then preparation -(the probe-release that measures participation to shape the next restructuring). ACTION is the -scope's defining deed; RECOVERY is its fast alter-ego, restoring the capacity to act again; -PREPARATION follows the alternation to shape what comes next — and faces both the next same-scope -action and the OTHER scope (which is where what earlier drafts called "evaluation" lives: stocking -the tag is preparing for night, not judging the present). Note the rotation: NT release is ACTION -by day and PREPARATION by night; the structural change is only marked by day (the tag) and enacted -by night. The bouton is not a sink — by night it emits inward and upward. - -``` -// PARAMETERS K_release · release_cost · fusion_cost · vatpase_cost · spillover · brake -// stp_thr · coupling_gain · coupling_drift · VGCC_baseline -// INTERFACE -// EMIT glutamate → POST, ASTRO -// RECEIVE retro_NO, retro_eCB ← POST (signals latched in PREPARATION; pools refill in RECOVERY/PREPARATION) -// READ glutamate (own cleft, autobrake) ; dopamine (gates tag) -// OWN pre_structure{slot_ceiling, VGCC_coupling, refill_ceiling} ; pre_budget_ceiling -// VGCC_active (occupancy: current coupling, filled toward VGCC_coupling ceiling) -// SUPPLY astro_lactate[syn] ← ASTRO ; axon_ship_pre ← AXON ; pre_material ← AXON(NIGHT) ; pre_energy ← SOMA(NIGHT) -// EMERGENCY shockwave_lockdown ← ASTRO -// -// TRACE CREATION MODES (every trace: trace += input·Δt − trace·(Δt/τ_decay)) -// impulse input = quantum·δ(event) — a point event; no rise time, τ = decay only (FAST) -// accumulate input = rate(condition)·Δt — ramps while a condition holds; τ = rise AND decay (MEDIUM/SLOW) -// -// THE THREE CATEGORIES (same at DAY and NIGHT; here at the DAY timescale, subject = the cleft): -// ACTION release NT (the defining deed) — context AP -// RECOVERY restore the ability to release again: vesicle refill — the fast alter-ego of AP, -// runs in the inter-spike gaps (NOT_AP), riding the train, setting STD depth -// PREPARATION shape what comes next — climb the tag (for NIGHT), set VGCC, refill budget, -// thresholds, decay — runs once the train subsides (NOT_SPIKE_TRAIN ⊂ NOT_AP) -// Pattern per scope: (ACTION ⇄ RECOVERY) × many spikes, then PREPARATION. -// Contexts nest (NOT_SPIKE_TRAIN ⊂ NOT_AP); each behavior in exactly ONE block. - -// ===== ACTION ===== -DAY | AP: // release into the cleft (the defining deed) - // deposit the fast trace THIS action leaves (FAST · impulse) - pre_fast_trace += spike_Ca(pre_structure.VGCC_coupling)·δ(spike) // @cut affords: NT-emission frequency, recency (elapsed-since-release) [ms] - drive = sat(pre_fast_trace × VGCC_active, K_release) × (1 - retro_eCB_local) - if pre_budget < release_cost: // FUEL shortfall → endurance evidence - suppress(NT_flux) - if pre_fast_trace > traj_thr: // MEDIUM · accumulate (a PREPARATION deposit) - pre_endurance_need += pre_fast_trace × (1 + retro_NO_local)·Δt // @cut affords: stamina / sustained-load need (endurance pathway) [min] - exit - if RRP == 0: suppress(NT_flux); exit // OCCUPANCY shortfall → STD (not endurance) - NT_flux = RRP × drive; RRP -= NT_flux·Δt; pre_budget -= NT_flux·fusion_cost - glutamate += NT_flux·Δt // EMIT glutamate → POST, ASTRO // @cut affords: NT flow into cleft; joint pre-post coincidence read downstream at POST.NMDA [ms] - if glutamate > spillover: drive *= brake // own-cleft autobrake - -// ===== RECOVERY (alter-ego of ACTION; runs in the inter-spike gaps, rides the train) ===== -DAY | NOT_AP: // restore the ability to release again - RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget) - pre_fast_trace *= decay(100ms) // FAST — the trace relaxes between spikes - // (partial refill vs release is the STD race — this is recovery keeping pace with action) - -// ===== PREPARATION (shape what comes next; faces the next train AND the NIGHT) ===== -DAY | NOT_SPIKE_TRAIN: // sustained quiet; ⊂ NOT_AP - retro_NO_local = retro_NO; retro_eCB_local = retro_eCB // latch arrived signals - // for NIGHT: climb the tag (stock the token the night-action will spend) (MEDIUM→SLOW accumulate) - if pre_fast_trace > elig: pre_possible_tag += pre_fast_trace·Δt // @cut affords: participation / consistency-of-co-activity (running average) [min] - if dopamine > dop_thr and pre_possible_tag > tag_thr: - pre_tag += dopamine × pre_possible_tag·Δt // @cut affords: structural-consolidation need (spent overnight; precision pathway) [hr→night] - // for the NEXT TRAIN: STP read-out (eligibility → coupling readiness; NO dopamine; drifts back) - if pre_possible_tag > stp_thr: - VGCC_active = min(VGCC_active + coupling_gain × pre_possible_tag, pre_structure.VGCC_coupling) - else: - VGCC_active = max(VGCC_active - coupling_drift·Δt, VGCC_baseline) // STD = un-honored decay - // for the NEXT TRAIN: full budget refill toward next demand (forward-facing) - pre_budget += refill(pre from astro_lactate[syn] + transit(axon_ship_pre, τ_transport_bouton)) - // settle the medium/slow stocks (fast-trace decay already ran in RECOVERY; not repeated) - pre_possible_tag *= decay(s); pre_endurance_need *= decay(min) // MEDIUM - pre_tag *= decay(hr) // SLOW - dopamine *= decay(ms); retro_NO *= decay(s); retro_eCB *= decay(s) - -// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. The rhythm is -// (ACTION ⇄ RECOVERY) × many, then PREPARATION, then again — like DAY's (release ⇄ refill) × many -// → prep. Two competitions at two loci: WITHIN action, build vs release contend over the -// component's own structure (participation is the arbiter); WITHIN recovery, THIS component vs -// OTHERS contend for shared material/energy. A category spans all THREE timescales (fast/med/slow). -// ACTION change structure — BUILD (participation high + tag stands; tag funds it, a slice -// per cycle so the tag persists across cycles) ⇄ RELEASE (participation LOW; frees -// material; tag untouched). Both always possible; participation selects direction. -// RECOVERY restore the ability to build: acquire material/energy from the shared pool AND -// receive freed material — in CONTENTION with other components. -// PREPARATION replay the release as a probe (SAME machinery as day ACTION) to measure -// participation; itself multi-timescale: probe⇄restock (fast), VGCC/threshold -// prime from the tag (medium), tag settle (slow). -// Two independent forgettings: structural pruning ← low participation (release); intention decay -// ← tag decaying unspent. Loops until the tag is spent. - -// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) ===== -NIGHT | build or release: // the night's defining deed (both directions) - // BUILD (participation confirmed AND tag stands): spend a SLICE of the tag — persists next cycle - if rest_permission and pre_tag > tag_expiry and pre_participation ≥ MEDIUM: - Δ = min(slot_batch, pre_material, pre_energy·f_cap, pre_tag) × pre_participation - pre_structure += Δ; pre_material -= Δ; pre_energy -= Δ·assembly_cost // @cut affords: overnight build⇄release, structural persistence [night] - pre_tag -= Δ // SLICE only — tag survives for successive cycles - if pre_endurance_need > endur_thr: // endurance capacity builds on the same act - Δ' = min(cap_batch, pre_material·f_cap, pre_energy·f_cap) - pre_budget_ceiling += Δ'; pre_material -= Δ'; pre_energy -= Δ'·biogenesis_cost - pre_endurance_need -= Δ' - // RELEASE (participation LOW): shed structure, FREE material back to the shared pool; tag untouched - else if pre_participation == LOW: - shed = release_rate × max(pre_structure - homeostatic_floor, 0) - pre_structure -= shed; pre_freed_material += shed·recycle // freed → contested pool (RECOVERY) - pre_budget_ceiling -= capacity_decay_rate·Δt_cycle - // else (tag present but participation not confirmed this cycle): HOLD — tag waits for its pattern - -// ===== RECOVERY (acquire material/energy in CONTENTION with other components; receive freed material) ===== -NIGHT | import + free: // alter-ego of the night ACTION (inter-component) - pre_material += transit(pre_material_ship, τ_transport_bouton) // import build material (contested pool) - pre_energy += transit(pre_energy_ship, τ_transport_bouton) // import build energy (contested pool) - pre_material += pre_freed_material; pre_freed_material = 0 // reclaim what release freed - if renorm_signal arrived: // descended constraint → free structure - freed = pre_structure × (1 - renorm_signal); pre_structure *= renorm_signal - emit(freed → recycled material pool) // freed material re-enters contention - pre_material += pre_ceiling_shrinkage·recycle // energy NOT recovered - pre_maintain: pre_structure += min(pre_maint, maint_cost) // hold up what is used - -// ===== PREPARATION (REPLAY the release as a probe — SAME machinery as day ACTION; multi-timescale) ===== -// Replay re-runs the release exactly as by day: same drive, same capacity + vesicle checks, same -// endurance deposit into the SAME pre_endurance_need trace. Differs from DAY ACTION: no dopamine, -// and the glutamate is a PROBE — drives the pattern onward and its own trace is read as participation. -NIGHT | replay + measure + prime: // release here is PREPARATION, not the deed - // FAST: probe-release ⇄ restock (the replay, run repeatedly to measure participation) - spont = intrinsic_fluctuation() - if spont > pre_spont_thr or arrived_replay_AP: // ignite: spontaneous, or recruited by the pattern - pre_fast_trace += mini_Ca(VGCC_active)·δ(replay) // SAME trace deposit as DAY ACTION - drive = sat(pre_fast_trace × VGCC_active, K_release) - if pre_budget < release_cost: // SAME capacity check → endurance evidence - suppress(replay_flux) - if pre_fast_trace > traj_thr: - pre_endurance_need += pre_fast_trace·Δt // SAME trace, fed by replay too - else if RRP > 0: // SAME vesicle check - replay_flux = RRP × drive; RRP -= replay_flux·Δt; pre_budget -= replay_flux·fusion_cost - glutamate += replay_flux·Δt // real glutamate → POST: carries the pattern onward - RRP += fill(RRP, pre_structure.slot_ceiling, pre_structure.refill_ceiling, vatpase_cost, pre_budget) // restock - pre_participation = level(pre_fast_trace) // read the replayed response as participation - // MEDIUM: prime excitability + VGCC from the standing tag (readies the next probe AND next build) - pre_spont_thr = spont_thr_base − thr_gain × pre_tag - if pre_tag > prime_thr: - VGCC_active = min(VGCC_active + prime_gain × pre_tag, pre_structure.VGCC_coupling) - pre_possible_tag *= occupancy_downscale // apply descended constraint to self - // SLOW: settle - pre_fast_trace *= decay(100ms); pre_tag *= decay(hr); pre_endurance_need *= decay(slow) - emit(pre_fatigue, pre_demand → upward) // not a sink: emits inward/upward by night -``` +So the emission structure is the inverse of the consumption structure: initiators generate the +contexts that responders consume. And one category is exempt from this split — PREPARATION always +faces outward and upward, toward the next act and the other scope, so even an initiator is +externally contextualized *for its preparation* (the neuron, tracking the sustained absence of soma +spikes that the soma cannot know from inside, emits the quiet context that licenses it). A component +self-triggers its own deed; it is told, from above, only when it has been idle long enough to prepare. --- -## POST +## 2. The Ring — One Act in Three Phases -The postsynaptic spine is the synapse's primary memory locus: it detects coincident input, -runs the calcium dynamics that decide potentiation versus depression, and requires the most -validation (three coincidences) before committing. +The local component's act has one shape, and it is the same shape everywhere: **ACTION, RECOVERY, +PREPARATION.** This is the specialization of the principle to the question *what is the act?* -**POST's ACTION is the synaptic response (context NOT_AP).** Integration is graded and ongoing -rather than spike-punctate, so POST's action-context is "no descending AP arriving": it opens its -channels and responds to whatever glutamate has arrived. Three calcium sources feed the fast trace — -AMPA current (small Ca, begins ejecting the NMDA Mg block) and NMDA (large Ca, scaled by the local -coincidence of depolarization + astrocyte D-serine + glutamate). The action deposits the calcium -trace and emits **NO** — the fast retrograde, tracking the NMDA calcium transient, confirming the -response reached a responsive target. (The other retrograde, **eCB**, is slow — produced from -*accumulated* depolarization and emitted in PREPARATION as an integrated brake on the next release, -not per-response.) Crucially POST's ACTION **continues through the soma's -refractory period**: the refractory belongs to the soma, not to POST — from POST it is simply NOT_AP, -so the spine keeps responding and integrating, charging up so the neuron is ready to fire again once -its refractory ends. +**The three phases.** +- **ACTION** is the component's defining deed — the thing that makes it the component it is. The + bouton releases; the soma fires; the spine responds; the axon and dendrite propagate. Action is + the only phase that spends irreversibly and reaches outside the component. +- **RECOVERY** is the fast alter-ego of action: it restores the capacity to act again. Vesicles + refill, sodium channels de-inactivate, calcium clears. Recovery undoes the local depletion the + action caused, so a next action is possible. It looks backward — it repairs what was just spent. +- **PREPARATION** shapes what comes next. It faces two futures at once: the next action in this same + scope, and the action of the *other* scope. Setting the release machinery for the next spike is + preparation for this scope; stocking the tag that the night will spend is preparation for the + other. Preparation is provisioning, not judging — which is why the old "evaluation" phase was a + misnomer and has been retired. Depositing a trace does not render a verdict; it lays down a + provision that a later phase may or may not draw on. What we once called evaluation was always + preparation aimed at the other scope. -**POST's RECOVERY is the descending AP (context AP) — a brief event.** When the soma's spike arrives -it adds depolarization and calcium, supralinearly boosts an existing candidate (the soma's -confirmation that it fired), and resets the spine: calcium extrudes, the NMDA Mg-block re-establishes -as Vm falls, and the trace relaxes — restoring the ability to respond again. This is the *alter-ego* -of the response, and it is short (the spike event), not the whole refractory window. +**The rhythm is (ACTION ⇄ RECOVERY) × many, then PREPARATION — then again.** The act is not one pass +through three phases. Action and recovery alternate rapidly — a tight inner loop, release-and-restock +many times over — and only when that alternation subsides does preparation run, punctuating the +bout and setting up the next. A spike train is exactly this: release ⇄ refill, release ⇄ refill, +then, in the sustained quiet, the preparation that stocks the tag and tunes the next train. The +inner loop is fast; preparation is the slower punctuation. -**EVALUATION FOLDS INTO PREPARATION (context NOT_SPIKE_TRAIN).** PREPARATION shapes what comes next: -it fills AMPA surface toward the slot ceiling from accumulated calcium (short-term potentiation, no -dopamine — for the next response), climbs the tag on the dopamine coincidence (for the night), -refills budget, and settles. A fuel shortfall while calcium was climbing toward a tag is endurance -evidence (a preparation deposit made during action); a surface already at its ceiling is a -structural limit, not endurance. +**Every category spans all three timescales.** The three phases are not three speeds. Each phase is +a kind of work — deed, restore-capacity, provision — and each kind happens fast, medium, and slow. +Preparation especially is multi-timescale: it contains a fast loop (probe and restock), a medium +adjustment (tuning the release machinery from the tag), and a slow settling. A category names *what +kind* of work, never *how fast*. -**During NIGHT — the same three categories, turned inward, in sleep-stage contexts.** NON_REM_2 -(RECOVERY) imports material/energy and primes AMPA responsiveness from the standing tag. REM -(PREPARATION) replays: POST responds to the re-evoked glutamate exactly as it responds by day (same -AMPA/NMDA machinery, same endurance deposit into the same trace), reading the response as -participation rather than transmitting — no dopamine. NON_REM_1 (ACTION) is the structural change: -rebuild where the tag stands and participation was confirmed (consuming the tag) ⇄ release where -participation was low. Both ceilings draw the same finite pool and compete; unmaintained ceilings -drift down. +**Action is always local; recovery and preparation may be contextual.** A component necessarily has +its own action — the deed just is the local event occurring in it, and it cannot be performed on +another's behalf (that would be signalling, not acting). But the recovery and preparation of an +action can live in other components. A calcium channel's action is letting calcium in; its +recovery-and-preparation live in the presynapse and above. So the ring is a property of *coupled +components*, not of the individual: **the ring must close — every action recovered from and prepared +for — but no single component need run all three phases itself.** What is necessary is the closing +of the ring, not its co-location. -``` -// PARAMETERS K_AMPA · AMPA_Ca · AMPA_cost · NMDA_cost · AP_cost · pka_cost · traffic_cost -// req_cost · Mg_eject · K_Ds · Ca_STP · Ca_TAG · eCB_thr · drift · baseline -// NO_synth_cost · eCB_synth_cost -// INTERFACE -// EMIT retro_NO (+), retro_eCB (−) → PRE -// RECEIVE (signals) glutamate ← PRE ; astro_Dserine ← ASTRO ; AP (descending) ← DEND/SOMA ; dopamine -// READ glutamate ; astro_Dserine (GAIN, not gate) ; AP via dend_structure.bAP_fidelity ; dopamine -// OWN post_structure{slot_ceiling, spine_volume, reserve_ceiling} ; post_budget_ceiling -// SUPPLY astro_lactate[syn] ← ASTRO ; dend_ship_post ← DEND ; post_material ← DEND(NIGHT) ; post_energy ← SOMA(NIGHT) -// EMERGENCY shockwave_lockdown ← ASTRO -// NOTE POST endurance is own-state only (own Ca climbing); no arrived feedback term. +**The three categories are the three modulable dimensions of behavior — which is why the synapse has +three parts.** Ask what about a behavior can be changed, and there are exactly three answers: *how +hard* (intensity), *how soon again* (timing), and *where* (spatial extent — which connections exist, +how isolated they are). These are not an arbitrary list; they are the three categories seen from +outside. Intensity is the magnitude of the ACTION — a bigger release is a bigger deed. Timing is set +by RECOVERY — how fast the capacity to act is restored *is* the temporal window and the readiness +for the next deed. Space is set by PREPARATION — which structure is built or pruned is the +configuration future action will run on. To modulate a dimension is to modulate the corresponding +phase; there is nothing to change about a behavior except its three phases, so there are exactly +three dimensions, in one-to-one correspondence. -// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = arrived glutamate / AP): -// ACTION (NOT_AP) respond: open AMPA/NMDA channels, integrate glutamate, detect the -// instantaneous coincidence, emit retro. This is POST's defining deed and it happens -// ALWAYS EXCEPT during an arriving AP — INCLUDING through the soma's refractory period: -// refractory is the SOMA's state, not POST's; from POST it is simply NOT_AP, so POST -// keeps responding and integrating, charging the spine so the neuron is ready to fire -// again once refractory ends. -// RECOVERY (AP) the BRIEF descending-spike arrival (ms): POST is driven from above, restores its -// ability to respond (Ca extrusion, Mg-block re-establishes as Vm falls), and deposits/ -// boosts traces. Short event, not a long window. -// PREPARATION (NOT_SPIKE_TRAIN) shape what comes next: AMPA fill (next response) + tag climb (NIGHT) -// + refill + settle. -// Coincidences sort by timescale: D-serine detected IN ACTION (instantaneous); dopamine in PREPARATION. +This is why the synapse is tripartite and not bipartite. Three separable dimensions want three +independent controllers, and the parties divide them: the presynapse owns the clean intensity knob +(how much it releases), the postsynapse owns sensitivity (how strongly it responds), and the +astrocytic process owns timing and space (its clearance sets how fast transmitter is cleared — +shorter dwell, sharper temporal window — and its coverage sets spillover and isolation). A +two-party synapse could set intensity but could not independently sharpen timing or bound space; +the third party exists precisely to control the dimensions the two coinciding parties cannot. In the +category language, the astrocytic process is the *recovery-and-preparation* specialist of the synapse +— it owns how-soon and where — while the pre and post are *action* specialists — they own how-hard. +The tripartite structure and the three-phase act are therefore two expressions of one three-way +partition: three phases of the deed, three dimensions of what can be changed, three parties to +change them. -// ===== ACTION (NOT_AP: open channels, respond — continues through the soma's refractory) ===== -DAY | NOT_AP: // respond to arrived input (the defining deed) - a = sat(glutamate, K_AMPA) - AMPA_current = a × AMPA_surface; Vm += AMPA_current; post_budget -= AMPA_cost // SOURCE 1 AMPA - post_fast_trace += AMPA_Ca·AMPA_current // @cut affords: channel-opening frequency, response magnitude (quantity of response) [ms] - if Vm > Mg_eject and glutamate > 0: // SOURCE 2 NMDA (Mg relieved) - post_fast_trace += NMDA_Ca(glutamate) × sat(astro_Dserine, K_Ds)·rise_speed(); post_budget -= NMDA_cost // @cut affords: THE pre-post-astro COINCIDENCE — joint three-component read (glutamate × depolarisation × D-serine gain); the meeting-site owning none of its inputs [ms, three-component space] - // D-serine sets the GAIN (how strongly POST responds), not a coincidence gate — dialed by the astrocyte - retro_NO += NO_emit(post_fast_trace); post_budget -= NO_synth_cost // EMIT + "responsive target" (fast: tracks the NMDA Ca transient) - // (eCB is NOT emitted here — it is slow/integrated, produced in PREPARATION from accumulated depolarisation) - -// ===== RECOVERY (AP: brief descending-spike arrival — restore + boost traces) ===== -DAY | AP: // soma's spike arrives (ms event), driven from above - Vm += AP_depol × dend_structure.bAP_fidelity; post_budget -= AP_cost - if post_possible_tag > Ca_TAG: post_fast_trace += AP_Ca_boost() // boost only if a candidate is present - post_fast_trace *= decay(ms) // Ca extruded, trace relaxes — ready to respond again - // (NMDA Mg-block re-establishes as Vm falls — implicit in the Vm>Mg_eject gate next response) - -// ===== PREPARATION (NOT_SPIKE_TRAIN: shape the next response AND the NIGHT) ===== -DAY | NOT_SPIKE_TRAIN: // sustained quiet (emitted by NEURON — above SOMA) - // slow retrograde: eCB is produced from ACCUMULATED depolarisation (integrated, not per-response) — - // a brake on the NEXT release, so it is prepared here, not deposited in the action - if post_fast_trace > eCB_thr: - retro_eCB += eCB_emit(post_fast_trace); post_budget -= eCB_synth_cost // EMIT − brake (slow, integrated) - // for NIGHT: climb the tag; dopamine is the integrable coincidence (#3) - if post_fast_trace > Ca_TAG: post_possible_tag += post_fast_trace; post_budget -= pka_cost // @cut affords: participation / consistency of co-activity (running average) [min] - if dopamine > dop_thr and post_possible_tag > tag_thr: - post_tag += dopamine × post_possible_tag // token minted for NIGHT // @cut affords: structural-consolidation need (precision pathway; dopamine-gated) [hr→night] - // for the NEXT RESPONSE: STP fill / STD drift - if post_fast_trace > Ca_STP: - if post_budget < traffic_cost: // FUEL shortfall → endurance (a PREPARATION deposit) - if post_fast_trace > traj_thr and post_fast_trace_rising: - post_endurance_need += post_fast_trace // @cut affords: stamina / sustained-load need (endurance pathway) [min] - else if AMPA_surface < post_structure.slot_ceiling: - AMPA_surface += Ca_insert(post_fast_trace); post_budget -= traffic_cost - // else: surface at slot_ceiling → structure-limited (not endurance) - else: - AMPA_surface = max(AMPA_surface - drift·Δt, baseline) // STD = un-honored decay - post_budget += refill(post from astro_lactate[syn] + transit(dend_ship_post, τ_transport_spine)) - post_possible_tag *= decay(min); post_endurance_need *= decay(min) // MEDIUM - post_tag *= decay(hr); dopamine *= decay(ms) // SLOW + signals - -// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. -// Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release contend WITHIN (participation -// arbitrates); material contends BETWEEN components (recovery). Night PREPARATION replays the DAY -// ACTION (same AMPA/NMDA machinery, same endurance trace), read for participation not significance. - -// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) ===== -NIGHT | NON_REM_1: - if rest_permission and post_tag > tag_expiry and post_participation ≥ MEDIUM: // BUILD (slice) - Δ = min(slot_batch, post_material, post_energy·f_cap, post_tag) × post_participation - post_structure += Δ; post_material -= Δ; post_energy -= Δ·assembly_cost - post_tag -= Δ // SLICE — tag persists across cycles - if post_endurance_need > endur_thr: - Δ' = min(cap_batch, post_material·f_cap, post_energy·f_cap) - post_budget_ceiling += Δ'; post_material -= Δ'; post_energy -= Δ'·biogenesis_cost - post_endurance_need -= Δ' - else if post_participation == LOW: // RELEASE: shed, free material; tag untouched - shed = release_rate × max(post_structure - homeostatic_floor, 0) - post_structure -= shed; post_freed_material += shed·recycle - post_budget_ceiling -= capacity_decay_rate·Δt_cycle - // else: HOLD — tag waits for its pattern - -// ===== RECOVERY (acquire material/energy in CONTENTION with other components; receive freed material) ===== -NIGHT | NON_REM_2: - post_material += transit(post_material_ship, τ_transport_spine) // import (contested pool) - post_energy += transit(post_energy_ship, τ_transport_spine) - post_material += post_freed_material; post_freed_material = 0 // reclaim what release freed - if renorm_signal arrived: - freed = post_structure × (1 - renorm_signal); post_structure *= renorm_signal - emit(freed → recycled material pool) - post_material += post_ceiling_shrinkage·recycle // energy NOT recovered - post_structure += min(post_maint, maint_cost) // hold up what is used - -// ===== PREPARATION (REPLAY the response — SAME machinery as day ACTION; multi-timescale) ===== -NIGHT | REM: - // FAST: replay the response to the re-evoked input (probe) - if arrived_glutamate_replay or arrived_replay_AP: - a = sat(glutamate, K_AMPA) - post_fast_trace += AMPA_Ca·(a × AMPA_surface) // SAME AMPA machinery as DAY ACTION - if Vm > Mg_eject: - post_fast_trace += NMDA_Ca(glutamate) × sat(astro_Dserine, K_Ds) // SAME NMDA machinery (D-serine = gain) - if post_budget < traffic_cost: // SAME capacity check → endurance evidence - if post_fast_trace > traj_thr: post_endurance_need += post_fast_trace // SAME trace, fed by replay - post_participation = level(post_fast_trace) // read replayed response as participation - // MEDIUM: prime responsiveness (AMPA occupancy) from the standing tag - post_spont_thr = spont_thr_base − thr_gain × post_tag - if post_tag > prime_thr: - AMPA_surface = min(AMPA_surface + prime_gain × post_tag, post_structure.slot_ceiling) - post_possible_tag *= occupancy_downscale - // SLOW: settle - post_fast_trace *= decay(ms); post_tag *= decay(hr); post_endurance_need *= decay(slow) - emit(post_fatigue, post_demand → upward) // not a sink: emits inward/upward by night -``` +The correspondence is not perfectly symmetric, and the asymmetry is instructive. Intensity and +timing each have a *live* mode — they are modulated moment to moment by the action and the recovery — +and also a *provisioned* mode, the persistent ceiling on them, set slowly. Space has no live mode: a +connection cannot be added mid-behavior; spatial structure is inherently slow. So preparation owns +space outright and also sets the ceilings for intensity and timing, while action and recovery hold +the live knobs. This is why "evaluation" was never a fourth category — there is no fourth dimension +for it to modulate. Behavior has three modulable dimensions; the act has three phases; a would-be +fourth phase would have nothing to change, which is exactly why it collapsed into preparation. --- -## DEND +## 3. The Two Turnings — Day and Night -The dendritic branch is the postsynapse's supply line and the neuron's input integrator. It -carries the back-propagating spike out to its spines, integrates their voltages toward the -soma, and ships material and budget to the spines it supports. +The one ring is turned in two directions. This specializes the principle to *what are the +component's two scopes?* — and it is where the model's deepest duality lives. -**During DAY, during bAP — the branch propagates and integrates.** When the soma fires, the -branch propagates the back-propagating spike toward its spines, with a fidelity that attenuates -with distance (distal spines get weaker confirmation, are harder to potentiate). It deposits -branch calcium and integrates its spines' voltages into a single branch signal sent on to the -soma. A fuel shortfall that cuts propagation short while the branch was strongly active is -endurance evidence; propagation that simply attenuates with distance is a structural limit, not -endurance. +**Two contextualizations, two currencies.** By day the component faces outward, against the world +(the cleft); its currency is information — cheap, gathered passively, and non-rival (see category 5). +By night it faces inward, against the economy; its currency is material and energy — scarce, +conserved, and rival. The component does not know it is in "day" or "night" as a global state; each +turning simply runs against whatever environment is present, and the environment differs. -**During DAY, during NOT_bAP — the branch consolidates, supplies, and recovers.** It maintains -its tag toward consolidation, lowers its commit threshold under acetylcholine (attention), -ships budget down to its spines (demand-weighted by their tags), runs local translation if -tagged, refills its own budget from astrocytic lactate and somatic shipment, and lets its -traces decay. +**The rotation: the same physical event is a different phase in each scope.** This is the sharpest +form of the duality. Neurotransmitter release is the day's ACTION — the outward deed. The *same +release*, run at night, is PREPARATION: the component releases not to transmit but as a probe, to +replay a behavior and measure how much it participates in the re-evoked pattern. And the structural +change, which the day can only *mark* (the tag is an inert claim pointing at a restructuring that +never happens by day), is the night's ACTION — its irreversible defining deed. So the defining act +of one scope is the measuring-instrument of the other: release is day-action / night-preparation; +restructuring is night-action / day-inert-mark. The scopes do not merely run the ring in two +directions — they swap which event is the deed and which is the provisioning. Because it is a ring, +each scope simply enters at a different phase. -**During NIGHT — the branch's ceilings are rewritten.** NIGHT raises **structure** (bAP -fidelity, translation capacity) where a validated tag accumulated and **budget capacity** where -fuel interrupted strong branch activity, both from the shared pool, both competing; unmaintained -ceilings drift down. +**Night PREPARATION replays the day ACTION — the same machinery.** Because preparation-at-night is a +*replay* of the behavior, it runs the very code the day action runs: the same release, the same +capacity and vesicle checks, the same endurance deposit into the *same* trace. Endurance discovered +in replay is as real as endurance discovered in behaving. Only two things differ: there is no +dopamine (significance is already settled), and the released transmitter is a probe — it carries the +pattern onward to the next component and its own trace is read as participation. The action machinery +is written once and serves as the deed by day and the measurement by night. -``` -// 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 (signals) 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 -// SUPPLY astro_lactate[branch] ← ASTRO ; soma_ship_dend ← SOMA ; dend_material, dend_energy ← SOMA(NIGHT) -// NOTE DEND endurance fires only on FUEL-limited propagation, not structural attenuation; -// own-state proxy (strong branch activity); no arrived feedback term. +**The tag is the payload that crosses between the turnings; the fatigue loop is the switch.** Each +scope's PREPARATION mints what the other scope will consume. Day-preparation mints the tag — a +token of confirmed significance — which the night spends on structure. Night-preparation measures +participation, which gates that spending. The tag is one token with three roles: by day it is the +significance bridge; at night it lowers the component's own threshold so its pattern can re-ignite, +and it funds the build, a slice at a time. Distinct from this payload handoff is the *switch* — the +fatigue loop that decides *when* a component crosses between scopes. Activity accrues fatigue; a +single continuous integrator (the one actor that never sleeps) reads the aggregate fatigue and emits +a pressure; when a component's own activity falls and pressure is high, it crosses into night; when +pressure discharges, it crosses back. No scheduler; no clock. The switch says *when* to turn; the +tag says *what* crosses when it turns. One ring, two turnings, stitched by the tag and switched by +fatigue. -// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = soma's bAP / spine input): -// ACTION propagate the bAP to spines + integrate spine voltage to soma (context bAP) -// RECOVERY restore branch excitability: Ca clearance (fast alter-ego of propagation) -// PREPARATION shape the next: tag climb (NIGHT), attention threshold, ship to spines, refill, settle -// ONE fuel shortfall that cuts propagation short = endurance; distance attenuation = structural limit. - -// ===== ACTION ===== -DAY | bAP: // propagate + integrate (the defining deed) - if dend_budget < prop_cost: - if dend_fast_trace > traj_thr: // FUEL shortfall → endurance (a PREPARATION deposit) - dend_endurance_need += dend_fast_trace // @cut affords: stamina / sustained-propagation need (endurance pathway; DEND is endurance-only) [min] - 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_fast_trace += bAP_Ca(bAP_local) + spine_spillover(); dend_budget -= branch_Ca_cost // @cut affords: branch propagation activity, recency [ms] - branch_Vm = integrate(POST.Vm, spines); dend_budget -= integrate_cost // EMIT integrated Vm → SOMA // @cut affords: SPATIAL EXTENT — summed spine input over the branch (space made present at one site); the branch-grain read no spine has [ms, branch space] - -// ===== RECOVERY (restore branch excitability; alter-ego of propagation) ===== -DAY | NOT_bAP · recovered: // Ca clearance - dend_fast_trace *= decay(300ms) // FAST — branch Ca relaxes - -// ===== PREPARATION (shape the next propagation AND the NIGHT) ===== -DAY | NOT_bAP: - // DEND is an ENDURANCE-ONLY relay: NO dopamine-gated strength tag. Its consolidation is load-driven - // (endurance_need, deposited in ACTION on fuel-limited propagation) — not reward-validated potentiation. - // (structural strengthening of a branch is emergent from its spines' tags, not an independent dend tag.) - // for the next: attention lowers commit threshold; local translation; ship to spines; refill - commit_threshold *= 1/(1 + ACh·ACh_gain) - if dend_budget > translate_cost and dend_endurance_need > endur_thr: dend_budget -= translate_cost - dend_ship_post = ship(dend_budget, post_demand, post_ship_frac, ship_cost) // EMIT down to spines - dend_budget += refill(dend from astro_lactate[branch] + transit(soma_ship_dend, τ_transport_dend)) - dend_endurance_need *= decay(min) // MEDIUM (the only pathway) - -// ── NIGHT: SAME three categories, subject = the pattern. DEND is an intermediate RELAY: its -// PREPARATION replay relays replay_AP onward to spines IF primed (carrying SOMA→DEND→POST). -// ENDURANCE-ONLY: night ACTION builds CAPACITY (from endurance_need) ⇄ releases where participation -// is low — no dopamine strength tag. Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. - -// ===== ACTION (build CAPACITY ⇄ release; participation gates direction; endurance funds build) ===== -NIGHT | build or release: - if dend_endurance_need > endur_thr and dend_participation ≥ MEDIUM: // BUILD capacity (load-driven, no dopamine) - Δ' = min(cap_batch, dend_material·f_cap, dend_energy·f_cap) - dend_budget_ceiling += Δ'; dend_material -= Δ'; dend_energy -= Δ'·biogenesis_cost - dend_endurance_need -= Δ' - else if dend_participation == LOW: // RELEASE: shed, free material - shed = release_rate × max(dend_structure - homeostatic_floor, 0) - dend_structure -= shed; dend_freed_material += shed·recycle - dend_budget_ceiling -= capacity_decay_rate·Δt_cycle - // else: HOLD - -// ===== RECOVERY (acquire/free material in CONTENTION; ship down to feed spine links) ===== -NIGHT | import + free: - dend_material += transit(soma_material_to_dend, τ_transport_dend) - dend_energy += transit(soma_energy_to_dend, τ_transport_dend) - dend_material += dend_freed_material; dend_freed_material = 0 // reclaim what release freed - if renorm_signal arrived: - freed = dend_structure × (1 - renorm_signal); dend_structure *= renorm_signal - emit(freed → recycled material pool) - dend_material += dend_ceiling_shrinkage·recycle // energy NOT recovered - dend_structure += min(dend_maint, maint_cost) // hold up what is used - post_material_ship += ship(dend_material, post_demand, f_spine, ship_cost) // ship to feed spine links - post_energy_ship += ship(dend_energy, post_demand, f_spine, ship_cost) - -// ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) ===== -NIGHT | replay + measure + prime: - // FAST: relay the replay_AP onward to spines IF primed (probe) - if arrived_replay_AP and dend_spont_thr < recruit_thr: - bAP_local = propagate(replay_AP, dend_structure.bAP_fidelity, geometry) // SAME propagate machinery - emit(bAP_local → POST) // carries the pattern to the spines - dend_fast_trace += bAP_Ca(bAP_local) - if dend_budget < prop_cost and dend_fast_trace > traj_thr: // SAME capacity check → endurance - dend_endurance_need += dend_fast_trace // SAME trace, fed by replay - dend_participation = level(dend_fast_trace) // read replayed response as participation - // MEDIUM: a relay stays recruitable at baseline (no tag to prime from — it carries whatever reaches it) - dend_spont_thr = spont_thr_base - // SLOW: settle - dend_fast_trace *= decay(300ms); dend_endurance_need *= decay(slow) - emit(dend_fatigue, dend_demand → upward) -``` +**Two independent forgettings.** Because night ACTION is build ⇄ release (category 5), two distinct +things can be lost, by two distinct mechanisms. *Structural pruning* sheds built structure a +component no longer uses — driven by low participation, regardless of any tag it holds. *Intention +decay* is the tag itself decaying unspent — a planned strengthening that never found the +participation to license it. The tag is patient: it is sliced by building and never touched by +releasing, so it survives across non-participating cycles and cashes in when its pattern finally +re-evokes. Disuse prunes structure; unspent intention fades on its own slow clock. The two are +independent, and both are forgetting. --- -## SOMA +## 4. The Timescale Ladder -The soma is the neuron's integrating center and the root of its structural material. It sums -the branch inputs, fires when they exceed a threshold it sets from its own adaptation and the -neuromodulators, and ships material and budget out to the dendrites and axon. Its timing — -refractoriness, adaptation, rhythm alignment — emerges bottom-up from local traces, never from -a represented clock. +Orthogonal to the ring is the ladder of timescales. This specializes the principle to *at what +speeds does the component act?* The ring says *what kind* of work; the ladder says *how fast*; they +compose — every phase of the ring occurs at every rung of the ladder. -**During DAY, during AP — the soma integrates and fires.** It computes its firing threshold -from its baseline (structure), its accumulated adaptation, and the neuromodulators, and checks -its refractory state; if the integrated branch input clears the threshold and fuel allows, it -fires. One spike deposits three traces at three timescales — sodium inactivation (refractory), -slow-potassium adaptation (threshold rise), and nuclear calcium (toward CREB and the tag). A -fuel shortfall while nuclear calcium was climbing is endurance evidence; being refractory or -sub-threshold is a timing limit, not endurance. +**The rungs.** FAST (milliseconds to seconds): the immediate trace a single action leaves. MEDIUM +(seconds to minutes): occupancy and evidence — the running average of fast traces, and the +eligibility climbing toward a tag. SLOW (hours): the tag, the consolidation bridge. PERSISTENT +(written only at night): the structural ceilings, and the two conserved stocks — energy, which does +not return, and material, which does. -**During DAY, during NOT_AP — the soma recovers, aligns, and supplies.** It self-replenishes -from its own mitochondria (its private root), integrates the latest branch inputs, deposits a -refractory-alignment trace when suprathreshold input arrived during its refractory period (so it -aligns to its input rhythm bottom-up), ships budget to dendrites and axon (demand-weighted by -their tags), recovers from refractoriness at a rate its alignment trace speeds up, and lets its -traces decay. +**A tier's timescale is set by both its creation and its decay.** A fast trace is deposited as a +point event and relaxes in milliseconds. A medium trace ramps while a condition holds and settles +over minutes. The timescale is not a label attached to a variable; it is the joint consequence of +how the variable is written and how it fades. This is why the same climb appears in every component: +each action leaves a fast trace; the average of fast traces over seconds fills occupancy (short-term +strength); the average of that average over minutes, gated by dopamine, raises the tag. Occupancy is +the fast-and-medium memory of participation; the tag is its slow, validated distillate. -**During NIGHT — the soma's ceilings are rewritten, and it gates the whole neuron's material.** -NIGHT raises **structure** (excitability, synthesis capacity) and **budget capacity** from the -shared pool; crucially the soma's own tag gates CREB-driven synthesis, so how much material all -downstream components receive depends on the soma having been tagged. - -``` -// PARAMETERS ap_cost · nuclear_cost · creb_cost · mito_output · inactivation · ap_amp · ap_contrib -// base_recovery · τ_Na · τ_adapt · τ_nuclear · τ_align -// INTERFACE -// EMIT fired → AXON (propagate) + DEND (bAP) ; soma_ship_dend → DEND ; soma_ship_axon → AXON -// RECEIVE (signals) branch_Vm ← DEND ; dopamine ; NE ; ACh -// READ dopamine ; NE ; ACh -// OWN soma_structure{baseline_threshold, AP_reliability, synthesis_ceiling} ; soma_budget_ceiling -// SUPPLY self (mitochondria, ROOT — private) -// NOTE SOMA endurance fires only on FUEL shortfall (budget < ap_cost); -// refractory / sub-threshold are timing limits, not endurance. Own-state proxy. - -// THE THREE CATEGORIES (SOMA is an INITIATOR — it fires from its OWN integration crossing its OWN -// threshold, so nothing external licenses its ACTION. It runs CONTINUOUS and the ACTION⇄RECOVERY -// alternation is decided INTERNALLY by its own condition. It EMITS AP and REFRACTORY as signals of -// these internal phases — it cannot be contextualized by them, since it is their source. Only its -// PREPARATION is externally contextualized, by the NEURON's NOT_SPIKE_TRAIN. See logic_principles §1.): -// ACTION (CONTINUOUS; internal guard: branch_Vm > threshold and can_fire) fire — the defining -// deed. Self-triggered. Emits AP. -// RECOVERY (CONTINUOUS; internal: not firing) restore the ability to fire again: refractory -// de-inactivation + mito replenish — the alter-ego of the spike. Emits REFRACTORY. -// PREPARATION (NOT_SPIKE_TRAIN, from the NEURON) shape the next spike: alignment, adaptation, -// tag-climb (for NIGHT), ship, decay. -// Pattern: (ACTION ⇄ RECOVERY) × many spikes, then PREPARATION. -// ONE spike's fast trace feeds TWO preparation destinations: nuclear-Ca → tag (for NIGHT), -// inactivation/adaptation/alignment → next-spike timing (this scope). - -// ===== ACTION (CONTINUOUS — self-triggered by internal threshold-crossing; emits AP) ===== -DAY | CONTINUOUS · action: // integrate + fire (the defining deed) - threshold = soma_structure.baseline_threshold × (1 + soma_adaptation) × neuromod(NE, ACh) - can_fire = soma_Na_inactivation < inactivation - if branch_Vm > threshold and can_fire: // INTERNAL guard licenses the action (no external context) - if soma_budget < ap_cost: // FUEL shortfall → endurance (a PREPARATION deposit) - 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 // @cut affords: THE DISCRETE FIRE EVENT — continuous branch integration read out as one all-or-nothing spike [ms]; over a train, the neuron's own FIRING FREQUENCY [sec] - // deposit the THREE traces from one AP (all PREPARATION content, deposited in the action): - soma_Na_inactivation += ap_amp // → refractory (recovery will undo this) - soma_adaptation += ap_contrib // → threshold rise (next-spike timing) - soma_fast_trace += nuclear_Ca(); soma_budget -= nuclear_cost // → tag (for NIGHT) // @cut affords: cell-wide activity accumulation (nuclear integral → consolidation) [min→hr] - 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 // @cut affords: cell-wide structural-consolidation need (precision pathway; dopamine-gated) [hr→night] - soma_budget -= creb_cost - soma_emitted_activity += 1; soma_emitted_structure = soma_structure // NEURON sums these - -// ===== RECOVERY (CONTINUOUS — self-entered when not firing; emits REFRACTORY) ===== -DAY | CONTINUOUS · recovery: // de-inactivate + replenish (soma's own refractory dynamics) - soma_budget += fill(soma_budget, soma_budget_ceiling, mito_output, 0, soma_budget) // mito replenish - recovery = base_recovery × (1 + soma_refractory_alignment) - soma_Na_inactivation *= decay(τ_Na / recovery) // refractory recovery (sped by alignment) - soma_fast_trace *= decay(τ_nuclear) // FAST — nuclear-Ca relaxes - -// ===== PREPARATION (shape the next spike AND the NIGHT; ⊂ NOT_AP, sustained quiet) ===== -DAY | NOT_SPIKE_TRAIN: - branch_Vm = integrate(DEND.branch_Vm, branches) // RECEIVE latest branch input // @cut affords: SPATIAL CONVERGENCE — all branches summed at the whole-cell grain (the neuron's total input, one level above the branch) [ms, cell space] - // for next-spike timing: refractory alignment (suprathreshold input during refractory) - if branch_Vm > threshold and soma_Na_inactivation > inactivation: - soma_refractory_alignment += (branch_Vm - threshold) × soma_Na_inactivation - // for downstream: ship budget to dendrites + axon (demand-weighted) - 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) - // settle medium/slow stocks - soma_refractory_alignment *= decay(τ_align); soma_adaptation *= decay(τ_adapt) - soma_possible_tag *= decay(s); soma_endurance_need *= decay(min) - soma_tag *= decay(hr); dopamine *= decay(ms) - -// ── NIGHT: SAME three categories, consolidation timescale, subject = the pattern. SOMA is a ROOT -// (produces material each cycle) AND the IGNITION POINT: its PREPARATION replay-fire propagates a -// replay_AP down axon + dendrites. Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. Build⇄release -// contend WITHIN (participation arbitrates); material contends BETWEEN components (recovery). - -// ===== ACTION (build ⇄ release; participation gates direction; tag funds build, persists across cycles) ===== -NIGHT | NON_REM_1: - if soma_tag > tag_expiry and soma_participation ≥ MEDIUM: // BUILD (slice) - Δ = min(slot_batch, soma_material, soma_energy·f_cap, soma_tag) × soma_participation - soma_structure += Δ; soma_material -= Δ; soma_energy -= Δ·assembly_cost - soma_tag -= Δ // SLICE — tag persists across cycles - if soma_endurance_need > endur_thr: - Δ' = min(cap_batch, soma_material·f_cap, soma_energy·f_cap) - soma_budget_ceiling += Δ'; soma_material -= Δ'; soma_energy -= Δ'·biogenesis_cost - soma_endurance_need -= Δ' - else if soma_participation == LOW: // RELEASE: shed, free material; tag untouched - shed = release_rate × max(soma_structure - homeostatic_floor, 0) - soma_structure -= shed; soma_freed_material += shed·recycle - soma_budget_ceiling -= capacity_decay_rate·Δt_cycle - // else: HOLD — tag waits for its pattern - -// ===== RECOVERY (ROOT production + acquire/free material in CONTENTION; ship to feed the pattern) ===== -NIGHT | NON_REM_2: // (SOMA also ROOT-produces here) - soma_material += CREB_synth(soma_tag)·Δt_cycle // ROOT: produce material — recoverable - soma_energy += mito_synth()·Δt_cycle // ROOT: produce energy — NOT recoverable - night_energy_spent += mito_synth()·Δt_cycle - soma_material += soma_freed_material; soma_freed_material = 0 // reclaim what release freed - soma_material_to_dend += ship(soma_material, dend_demand, f_dend, ship_cost) // ship to feed pattern links - soma_material_to_axon += ship(soma_material, axon_demand, f_axon, ship_cost) - soma_energy_to_dend += ship(soma_energy, dend_demand, f_dend, ship_cost) - soma_energy_to_axon += ship(soma_energy, axon_demand, f_axon, ship_cost) - soma_material += soma_ceiling_shrinkage·recycle - soma_structure += min(soma_maint, maint_cost) // hold up what is used - -// ===== PREPARATION (REPLAY the fire — SAME machinery as day ACTION; ignites the pattern; multi-timescale) ===== -NIGHT | REM: // (SOMA replay-fires: ignites the pattern) - // FAST: replay-fire (probe); ignites the pattern down the day pathway - spont = intrinsic_fluctuation() - if spont > soma_spont_thr: // ignite (SAME threshold logic as day fire) - replay_AP = TRUE - soma_fast_trace += nuclear_Ca()·δ(replay) // SAME trace deposit as DAY ACTION - if soma_budget < ap_cost: // SAME capacity check → endurance evidence - if soma_fast_trace > traj_thr: soma_endurance_need += soma_fast_trace // SAME trace, fed by replay - else: - soma_budget -= ap_cost - emit(replay_AP → AXON, DEND) // propagate: AXON/DEND relay onward IF primed - // pattern carries link by link, primed→primed (mechanical coherence): - // SOMA →[replay_AP]→ AXON →→ PRE →[glutamate]→ POST →→ DEND →→ SOMA ; one un-primed link breaks it - soma_participation = level(soma_fast_trace) // read replayed response as participation - // MEDIUM: prime firing excitability from the standing tag - soma_spont_thr = spont_thr_base − thr_gain × soma_tag - // SLOW: settle - soma_fast_trace *= decay(τ_nuclear); soma_tag *= decay(hr); soma_endurance_need *= decay(slow) -``` +**Evidence ascends the ladder; capacity descends it.** By day, information climbs from fast trace to +tag — evidence accumulating upward. By night, capacity is written downward from the tag into +persistent structure. Each rung also has its own failure meaning, set by its timescale: a fast pool +running dry is transient depression; a medium pool constrained is a standing endurance need; a +persistent ceiling reached is a structural limit. Depletion and recovery at each rung mirror the +creation and decay of its trace — the same timescale governs both the evidence and the capacity at +that level. --- -## AXON +## 5. Scarcity Decides — Collaboration by Day, Competition by Night -The axon carries the soma's spike out to its boutons and is the presynapse's supply line. It -propagates reliably or not depending on its myelination and its recent load, and ships material -and budget to the boutons. +How components relate to one another is not an independent fact; it follows from what is scarce. +This specializes the principle to *how do components relate?* — and it unifies conservation, +selection, and the collaboration/competition character of the two scopes into one causal chain. -**During DAY, during AP — the axon propagates the spike.** Reliability is set by structure -(myelination) and degraded by recent high-frequency load (sodium inactivation at branch points — -axonal short-term depression). A fuel shortfall while carrying a strong train is endurance -evidence; load-driven failure is short-term depression, a consequence, not endurance. +**Two conserved currencies, two rules of flow.** Energy ratchets: it is spent irreversibly, the +arrow of time in the model — a component that burns energy into structure cannot get it back. +Material circulates: it is freed by one component and reclaimed by another, conserved as it moves. +Scarcity of both forces choice — two ceilings (structure and endurance) compete for one finite +night pool, and what is not maintained drifts back down. -**During DAY, during NOT_AP — the axon supplies and recovers.** It maintains its tag, ships -budget to its boutons (demand-weighted by their tags), refills its own budget from somatic -shipment and astrocytic lactate, and lets its traces decay. +**Rivalry of the currency sets the relation.** By day the currency is information, which is +*non-rival*: a bouton releasing glutamate does not use up the spine's ability to receive it; a trace +here does not deplete a trace there. When producing for others costs nothing, the natural relation +is **collaboration** — and the day is exactly that: each component acts so the next can act, releasing, +integrating, clearing, passing activity along the chain, co-producing the pattern and the tags. By +night the currency is material and energy, which are *rival and conserved*: every unit one component +builds into its structure is a unit another cannot have, and the total is capped. When what one takes +another loses, the natural relation is **competition** — and the night is exactly that: components +contend for the shared pool, build what they win, and free what they shed back into contention. -**During NIGHT — the axon's ceilings are rewritten.** NIGHT raises **structure** (myelination, -transport capacity) and **budget capacity** from the shared pool, both competing; unmaintained -ceilings drift down. +**But night's competition is adjudicated by collaboration.** The relation is subtler than "day +collaborate, night compete." The replay that arbitrates the night's competition is itself a +collaborative act: a pattern re-evokes only if every component along its loop is primed and ignites +the next — mechanical coherence, a collaboration all the way around, one un-primed link breaking it. +Participation — the measure that gates who gets to build — *is* a measure of successful collaboration +in that re-enactment. So a component earns its share of the scarce material in proportion to how well +it collaborated in replaying the pattern. Collaboration is primary in both scopes: by day it +*produces* the shared, non-rival good; by night it *adjudicates* the competition for the rival one. +The register is economic, not martial — components do not fight; they contend for a conserved +resource, and the contention is settled fairly by a collaborative criterion. -``` -// PARAMETERS prop_cost · budget_factor -// INTERFACE -// EMIT APs_delivered → PRE (propagation) ; axon_ship_pre → PRE -// RECEIVE (signals) SOMA.fired ; dopamine -// READ SOMA.fired ; dopamine -// OWN axon_structure{propagation, transport_ceiling, mito_density} ; axon_budget_ceiling -// SUPPLY soma_ship_axon ← SOMA ; astro_lactate[shaft] ← ASTRO ; axon_material, axon_energy ← SOMA(NIGHT) -// NOTE AXON endurance fires only on FUEL shortfall; load-driven failure fail(fast_trace) -// is axonal STD (a consequence), not endurance. Own-state proxy. - -// THE THREE CATEGORIES (same at DAY and NIGHT; here DAY, subject = soma's spike): -// ACTION propagate the delivered spike to boutons (context AP) -// RECOVERY restore axon excitability: ionic re-equilibration (fast alter-ego of propagation) -// PREPARATION shape the next: tag climb (NIGHT), ship to boutons, refill, settle -// fail(fast_trace) is load-driven axonal STD (a consequence); FUEL shortfall is endurance. - -// ===== ACTION ===== -DAY | AP: // propagate the spike (the defining deed) - reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // fail() = STD, not endurance - if axon_budget < prop_cost: - reliability *= budget_factor - if axon_fast_trace > traj_thr: // FUEL-limited → endurance (a PREPARATION deposit) - axon_endurance_need += axon_fast_trace - delivered = fired × reliability; axon_budget -= prop_cost × delivered // EMIT delivered → boutons - axon_fast_trace += delivered // deposit fast trace // @cut affords: propagation reliability / conduction fidelity over distance [ms]. (AXON is a near-pure relay: it integrates almost nothing, so it affords very few reads — the sparseness is the point.) - -// ===== RECOVERY (restore axon excitability; alter-ego of propagation) ===== -DAY | NOT_AP · recovered: // ionic re-equilibration - axon_fast_trace *= decay(s) // FAST — shaft relaxes - -// ===== PREPARATION (shape the next propagation AND the NIGHT) ===== -DAY | NOT_AP: - // AXON is an ENDURANCE-ONLY relay: NO dopamine-gated strength tag. Structural change (myelination, - // propagation reliability) is LOAD-driven — built from endurance_need where it repeatedly propagated - // hard — not reward-validated. An axon needs no signal that a memory was rewarding to know it ran hard. - // for the next: ship to boutons, refill toward next demand - axon_ship_pre = ship(axon_budget, pre_demand, pre_ship_frac, ship_cost) - axon_budget += refill(axon from soma_ship_axon + astro_lactate[shaft]) - axon_endurance_need *= decay(min) // MEDIUM (the only pathway) - -// ── NIGHT: SAME three categories, subject = the pattern. AXON is an intermediate RELAY: its -// PREPARATION replay relays replay_AP onward to boutons IF primed (carrying SOMA→AXON→PRE). -// ENDURANCE-ONLY: night ACTION builds CAPACITY (from endurance_need) ⇄ releases where participation -// is low — no dopamine strength tag. Rhythm: (ACTION ⇄ RECOVERY) × many, then PREPARATION. - -// ===== ACTION (build CAPACITY ⇄ release; participation gates direction; endurance funds build) ===== -NIGHT | build or release: - if axon_endurance_need > endur_thr and axon_participation ≥ MEDIUM: // BUILD capacity (load-driven, no dopamine) - Δ' = min(cap_batch, axon_material·f_cap, axon_energy·f_cap) - axon_budget_ceiling += Δ'; axon_material -= Δ'; axon_energy -= Δ'·biogenesis_cost - axon_endurance_need -= Δ' - else if axon_participation == LOW: // RELEASE: shed, free material - shed = release_rate × max(axon_structure - homeostatic_floor, 0) - axon_structure -= shed; axon_freed_material += shed·recycle - axon_budget_ceiling -= capacity_decay_rate·Δt_cycle - // else: HOLD - -// ===== RECOVERY (acquire/free material in CONTENTION; ship down to feed bouton links) ===== -NIGHT | import + free: - axon_material += transit(soma_material_to_axon, τ_transport_dend) - axon_energy += transit(soma_energy_to_axon, τ_transport_dend) - axon_material += axon_freed_material; axon_freed_material = 0 // reclaim what release freed - if renorm_signal arrived: - freed = axon_structure × (1 - renorm_signal); axon_structure *= renorm_signal - emit(freed → recycled material pool) - axon_material += axon_ceiling_shrinkage·recycle // energy NOT recovered - axon_structure += min(axon_maint, maint_cost) // hold up what is used - pre_material_ship += ship(axon_material, pre_demand, f_bouton, ship_cost) // ship to feed bouton links - pre_energy_ship += ship(axon_energy, pre_demand, f_bouton, ship_cost) - -// ===== PREPARATION (REPLAY the propagation — SAME machinery as day ACTION; relays the pattern; multi-timescale) ===== -NIGHT | replay + measure + prime: - // FAST: relay the replay_AP onward to boutons IF primed (probe) - if arrived_replay_AP and axon_spont_thr < recruit_thr: - reliability = axon_structure.propagation × (1 - fail(axon_fast_trace)) // SAME reliability machinery - delivered = reliability × axon_structure.propagation - emit(replay_AP → PRE) // carries the pattern to the boutons - axon_fast_trace += delivered - if axon_budget < prop_cost and axon_fast_trace > traj_thr: // SAME capacity check → endurance - axon_endurance_need += axon_fast_trace // SAME trace, fed by replay - axon_participation = level(axon_fast_trace) // read replayed response as participation - // MEDIUM: a relay stays recruitable at baseline (no tag to prime from — it carries whatever reaches it) - axon_spont_thr = spont_thr_base - // SLOW: settle - axon_fast_trace *= decay(s); axon_endurance_need *= decay(slow) - emit(axon_fatigue, axon_demand → upward) -``` +**Two competitions at two loci.** Within the night, competition appears twice, cleanly separated. +*Within* a component, build and release contend over its own structure, arbitrated by participation: +high participation builds (funded by the tag, a slice per cycle), low participation releases (freeing +material, the tag untouched), and in between the component holds. *Between* components, this one and +its peers contend for the shared material and energy during recovery. The internal tension (grow or +shrink?) is settled by the replayed pattern; the external tension (can I get material?) is settled by +contention with neighbors. Selection under scarcity is the sum of these: what survives a night has +both earned its tag by day and won its material by night, and what neither participates nor is +maintained returns to the pool. Selection is not a judge's verdict; it is what scarcity leaves +standing. --- -## ASTROSYNAPSE +## 6. Causation Circulates — Emergence Up, Constraint Down, Command Nowhere -> The astrosynapse is the perisynaptic astrocytic process — the LOCAL component at one synapse, -> the astroglial peer of pre/post and a constituent of the ASTROCYTE actor (which integrates -> across all of them, just as the NEURON integrates over the soma). The astrosynapse behaves -> locally here; the astrocyte integrates and broadcasts (see CELL ACTORS). +The final category specializes the principle to *who is in charge?* — and the answer is no one. +Causation moves in two directions across the coupling, and neither is command. -The astrosynapse is the synapse's **modulator** — the third party that tunes all three dimensions -of transmission without performing the deed itself. It clears glutamate (setting how long -transmitter dwells → **timing**), releases D-serine that dials the *gain* of the postsynaptic -response to a given release (**intensity**, via POST's sensitivity — not a coincidence gate but a -volume knob on POST), and its perisynaptic coverage sets spillover and isolation (**space**). Its -one error signal is **spillover**: when PRE outpowers the current coverage, glutamate escapes — the -direct physical sign that this astrosynapse is too small for its presynapse. Spillover coincident -with a real postsynaptic response (read from the eavesdropped retrograde NO) is what it tags; its -absence means the coverage can shrink. It reads the cleft it sits in: glutamate from PRE (spillover), -the retrograde eCB/NO from POST (postsynaptic pressure and success), and — from above — the -ASTROCYTE's territory-wide Ca²⁺ spike, which arrives at ALL the astrocyte's astrosynapses at once -when enough of them were co-active (a territory-scale coincidence broadcast, the astrocytic analog -of the soma's AP). +**Emergence ascends; constraint descends.** By day, evidence and activity emerge upward: components +act locally, and their emitted activity is what a higher description (the neuron, the assembly) is +*made of*. Nothing reaches down to make them act. By night, constraint descends: a higher actor +broadcasts a bound — a renormalization target, a downscale factor — but it does not reach in. It +emits a signal; each component reads that signal and scales *itself*. The neuron never edits a +synapse; it announces a total, and the synapses each renormalize their own structure against it. -**DAY · ACTION — clear + prime.** The defining local deed: take up glutamate (EAAT clearance) and -release D-serine to set POST's gain, biased by the astrocyte's slow priming field and pulsed up by -an arriving territory Ca²⁺ spike. Spillover deposits its Ca²⁺ fast trace. -**DAY · RECOVERY — restock clearance + D-serine capacity**, so it can service the next release (its -recovery speed *is* the synapse's timing resolution). -**DAY · PREPARATION — stock the volume/gain evidence.** Accumulate the tag: how often spillover -occurred coincident with a real postsynaptic response — "this synapse repeatedly outgrew its -coverage on genuine co-activation." Read the descended spike/prime that will bias the next action. +**No actor authorizes its own restructuring.** A component cannot open its own night. It is *put in +position* by the actor above — which holds an aggregate the component cannot see and opens a window +the component cannot open — and then, within that window, the component acts locally on its own +state. The soma cannot decide within the soma which of its synapses matter; the synapses decide that +locally, by their own thresholds. And the synapses cannot ignite their pattern alone; the soma's +firing does that. Each is put in position by the other; neither reads the other's interior. This is +the recursive grant: act locally, be enabled hierarchically. -**NIGHT — build ⇄ release coverage.** Build perisynaptic coverage / clearance capacity / tonic -D-serine where the tag stands (repeated spillover → enlarge to clear faster, sharpen timing, contain -spillover — the build cancels the very spillover that signalled it) ⇄ release coverage where no -spillover occurred (over-provisioned → shrink, free material). Astrosynapses compete for the -astrocyte's produced material and energy. - -``` -// PARAMETERS K_Dserine · Ds_max · Ds_frac · Ds_cost · EAAT_cost · spillover · overload · spike_gain -// INTERFACE -// EMIT astro_Dserine[i] → POST (GAIN primer, not a gate) ; astro_localCa[i] → ASTROCYTE (integrated up) -// astro_fatigue, astro_demand → upward -// RECEIVE (signals) glutamate ← PRE (spillover) ; retro_NO, retro_eCB ← POST (eavesdropped) ; -// astro_prime[i] ← ASTROCYTE (slow gain field) ; astro_Ca_spike ← ASTROCYTE (territory broadcast) -// READ glutamate ; retro_NO ; retro_eCB ; astro_prime[i] ; astro_Ca_spike -// OWN astro_structure{coverage, EAAT, Dserine_tonic, ECM} ; astro_budget_ceiling ; astro_fast_trace -// SUPPLY astro_material, astro_energy ← ASTROCYTE (root) ; lactate distributed by ASTROCYTE -// NOTE D-serine is POST's GAIN, dialed by this astrosynapse × the astrocyte's prime/spike. -// Error signal = SPILLOVER (PRE outpowering coverage), tagged when coincident with retro_NO. -// EMERGENCY emits shockwave_lockdown on overload -// -// CONTINUOUS (no spike of its own): each step runs ACTION ⇄ RECOVERY, then PREPARATION, in graded flow. - -// ===== ACTION (clear glutamate + release D-serine = POST's gain; the defining local deed) ===== -DAY | CONTINUOUS · action | per astrosynapse i: - glutamate[i] -= astro_structure[i].EAAT × glutamate[i]·Δt; astro_budget[i] -= clearance·EAAT_cost // clear (timing) // @cut affords: TIMING — dwell time / temporal window (how long transmitter persists; clearance sets it) [ms, cleft space] - gain = astro_structure[i].Dserine_tonic × astro_prime[i] × (1 + spike_gain × astro_Ca_spike) // prime POST gain - astro_Dserine[i] += gain·Δt // → POST (intensity) - if glutamate[i] > spillover: // SPILLOVER = PRE outpowered coverage (error signal) - astro_fast_trace[i] += mGluR_Ca() // deposit Ca fast trace (this action's residue) // @cut affords: SPATIAL containment — spillover extent (coverage adequacy: contained vs shared) [ms, cleft space] - want = sat(astro_fast_trace[i], K_Dserine) × Ds_max - got = min(want, astro_budget[i] × Ds_frac) - astro_Dserine[i] += got; astro_budget[i] -= got·Ds_cost // phasic D-serine (extra gain on spillover) - astro_localCa[i] = astro_fast_trace[i] // EMIT own Ca upward → ASTROCYTE integrates // @cut affords: this synapse's contribution to TERRITORY-scale coincidence (read one level up at the astrocyte spike) [ms→sec, territory space] - if got < want and astro_budget[i] low and astro_fast_trace[i] > traj_thr: - astro_endurance_need[i] += (want - got) // FUEL-limited synthesis → endurance - if astro_fast_trace[i] > overload: emit(shockwave_lockdown) // EMERGENCY - -// ===== RECOVERY (restore clearance + D-serine capacity; alter-ego — its speed IS the synapse's timing) ===== -DAY | CONTINUOUS · recovery | per astrosynapse i: - astro_budget[i] += refill(astro[i] from lactate ← ASTROCYTE) // restock (contested territory supply) - astro_fast_trace[i] *= decay(s) // Ca relaxes — ready to detect next spillover - -// ===== PREPARATION (stock the volume-need tag; read descended spike/prime; faces the NIGHT) ===== -DAY | CONTINUOUS · preparation | per astrosynapse i: - // ENDURANCE-TYPE tag (NO dopamine): the volume-need is homeostatic, like fuel-shortfall endurance. - // It accumulates directly from spillover COINCIDENT with a real postsynaptic response (eavesdropped - // NO) — "I repeatedly outgrew my coverage on genuine co-activation" — not from reward validation. - // (dopamine reaches glia only as slow tone, folded into the astrocyte's prime — not a per-event gate.) - if astro_fast_trace[i] > elig and retro_NO > NO_thr: - astro_coverage_need[i] += astro_fast_trace[i] × (1 + retro_NO)·Δt // the volume tag, self-gated - astro_coverage_need[i] *= decay(hr) // SLOW (persists across cycles) - astro_endurance_need[i] *= decay(min) // MEDIUM (synthesis capacity) - -// ── NIGHT: SAME three categories, subject = the pattern. Astrosynapses compete for the ASTROCYTE's -// produced material/energy (the astrocyte is their root). ENDURANCE-TYPE: coverage build is driven by -// coverage_need (homeostatic spillover signal), NOT a dopamine strength tag. Build ⇄ release COVERAGE, -// participation from the Ca response to re-evoked spillover. (ACTION ⇄ RECOVERY) × many, then PREPARATION. - -// ===== ACTION (build ⇄ release COVERAGE; participation gates direction; coverage_need funds build) ===== -NIGHT | build or release | per astrosynapse i: - if astro_coverage_need[i] > tag_expiry and astro_participation[i] ≥ MEDIUM: // BUILD coverage (slice) - Δ = min(slot_batch, astro_material[i], astro_energy[i]·f_cap, astro_coverage_need[i]) × astro_participation[i] - astro_structure[i] += Δ // enlarge coverage → faster clearance, less spillover - astro_material[i] -= Δ; astro_energy[i] -= Δ·assembly_cost; astro_coverage_need[i] -= Δ - if astro_endurance_need[i] > endur_thr: - Δ' = min(cap_batch, astro_material[i]·f_cap, astro_energy[i]·f_cap) - astro_budget_ceiling[i] += Δ'; astro_material[i] -= Δ' - astro_energy[i] -= Δ'·biogenesis_cost; astro_endurance_need[i] -= Δ' - else if astro_participation[i] == LOW: // RELEASE coverage: shed, free material - shed = release_rate × max(astro_structure[i] - homeostatic_floor, 0) - astro_structure[i] -= shed; astro_freed_material[i] += shed·recycle - astro_budget_ceiling[i] -= capacity_decay_rate·Δt_cycle - // else: HOLD - -// ===== RECOVERY (acquire material/energy from the ASTROCYTE in CONTENTION with sibling astrosynapses) ===== -NIGHT | import + free | per astrosynapse i: - astro_material[i] += astro_alloc[i]·astro_central_material // receive this cycle's share (contested) - astro_energy[i] += astro_alloc[i]·astro_central_energy - astro_material[i] += astro_freed_material[i]; astro_freed_material[i] = 0 // reclaim what release freed - astro_structure[i] += min(astro_maint[i], maint_cost) // hold up what is used - -// ===== PREPARATION (REPLAY: respond to re-evoked spillover — SAME mGluR machinery — measure participation) ===== -NIGHT | replay + measure | per astrosynapse i: - if arrived_glutamate_replay[i]: // re-evoked spillover arrives (probe) - astro_fast_trace[i] += mGluR_Ca() // SAME mGluR machinery as DAY ACTION - astro_participation[i] = level(astro_fast_trace[i]) // read replayed response as participation - astro_fast_trace[i] *= decay(s); astro_coverage_need[i] *= decay(hr); astro_endurance_need[i] *= decay(slow) - emit(astro_fatigue, astro_demand → upward) -``` +**Command is nowhere.** There is no actor that both holds the whole and acts on it — that would be +the system, and there is no system. What looks like top-down control is always a broadcast constraint +scaled locally; what looks like bottom-up assembly is always local emission summed from outside. The +neuron that "renormalizes" only announces a number. The assembly that "replays" is only coincident +local thresholds propagating through coupling. Causation circulates — up as emergence, down as +constraint — but it never concentrates into command. This is the unifying principle in its final +form: because there is only the local component and its one act, there is no one to be in charge, and +the whole is enacted by the parts, never encoded above them. --- -## Special — Shockwave Lockdown +## 7. The Four Operations — How the Local Is Multiplied Into a Whole -``` -DAY or NIGHT | OVERLOAD: - Vm = HYPERPOLARIZED; AMPA_surface = mass_internalize() → post reserve - axon_fast_trace += overdrive(); astro_central_budget -= emergency_cost -``` +The six categories describe what a component is and does. This one is a different cut: it asks by +what *operations* the local is coupled into something we can describe as a whole. There are four — +integrate, coincide, broadcast, inject — and together they are the entire vocabulary by which scale +is crossed. The previous category named the two *directions* of causation; this one names the +*mechanisms*, and adds the two the directional view misses. ---- ---- -> NIGHT-BLOCK UNIFORMITY (three categories). PRE, SOMA, POST, DEND, AXON now run both DAY and NIGHT -> chunked as (ACTION ⇄ RECOVERY) × many, then PREPARATION, under explicit `// ===== =====` separators: -> (a) NIGHT-RECOVERY imports/produces supply, primes its OWN threshold from its OWN standing tag, -> applies the descended constraint to itself, recycles, and — for intermediate nodes AXON/DEND — -> ships downstream so the pattern's links are fed; (b) NIGHT-PREPARATION REPLAYS the day action — -> re-runs the SAME release/fire/respond/propagate machinery (same capacity/vesicle checks, same -> endurance deposit into the SAME trace), read as participation (level: high/medium/low), NO dopamine; -> AXON/DEND/SOMA also propagate the replay_AP onward IF primed (carrying SOMA→AXON→PRE and -> SOMA→DEND→POST); (c) NIGHT-ACTION lowers structure homeostatically, then rebuilds where the tag -> still stands AND participation ≥ medium, consuming the tag. Roots (SOMA material) additionally -> PRODUCE each cycle. The replay pattern propagates entirely through the DAY PATHWAYS, self-igniting, -> carrying only where every link is primed. -> ASTROSYNAPSE is now converted too (all six local components uniform): its ACTION is clear+prime -> (D-serine = POST gain), RECOVERY restocks clearance/D-serine, PREPARATION stocks the volume tag; -> NIGHT builds⇄releases COVERAGE. The ASTROCYTE adds a third role — a regenerative Ca spike that -> integrates astrosynaptic Ca and broadcasts territory-coincidence to all astrosynapses at once. +**Integrate — make the distributed present.** A quantity spread over time or space has no +instantaneous local existence. Flow is nowhere emitted; it is the accumulation of many releases +across a duration. Frequency is not present at any instant — a single spike has no rate; rate lives +only in the relation between events separated in time. Total activity is not held by any component; +it is the sum over many. The system reads none of these directly — it *cannot*, because they are not +anywhere. It reads them by **transducing the distributed into a store whose instantaneous level is +the quantity's present shadow.** The fast trace is the device: each event deposits a quantum, the +store leaks, and its standing level encodes recent frequency — high when deposits outran decay, low +when they did not. Spatial integration does the same across space: the dendrite summing its spines, +the soma summing its dendrites, the astrocyte summing its processes each make a spatially-distributed +quantity locally present at one site. This is how a distributed system verifies what is expressed +nowhere and by no one: it never reads the quantity, it reads the store the quantity filled. And it is +how the whole "knows" what no part knows — not by computing, but by *being the place where the parts +accumulate*. ---- ---- -# CELL ACTORS — NEURON and ASTROCYTE -Two structurally identical peers. Each integrates its constituents' EMITTED activity by its DAY -(never reading their interiors), detects when its aggregate has gone quiet, and BROADCASTS the -restructuring window + renormalization/reallocation by its NIGHT. Each component then restructures -ITSELF in response. The cell actor's own DAY/NIGHT follows the same transition rule, on its own -aggregate activity. +Time itself is read this way. The system has no clock; it does not count duration. Time enters only +as the *decay* of stores — "how long ago" is how far a trace has fallen, "how fast" is how high it +stands against its leak. Time is not represented; it is suffered, and the store's level is the +readout. Every leaky store is a little clock that keeps time by forgetting rather than by counting. -## NEURON +**Coincide — read several present-made stores at one site, and get an event.** Integration produces +quantities; coincidence produces *events* — the meaningful happenings the components act on. And nothing +significant is caused by a single signal: significance is always the co-occurrence of several. The +postsynaptic calcium event requires glutamate and depolarization and the astrocytic gain together; +the tag requires accumulated eligibility and validation together; the night's build requires a +standing tag and confirmed participation together; the astrocytic spike requires many processes' +calcium together. A coincidence is *two or more stores being high at the same instant* — which can +only be read where all of them are present. So every coincidence needs a **meeting-site that owns +none of the signals it compares**: the site where the transduced-present stores overlap. This is why +the synapse is tripartite (the coincidence detector needs a third input neither coinciding party +owns), and the pattern recurs at every level — each has its coincidence and its meeting-site. +Integration makes the distributed present; coincidence reads several presences together. They are one +mechanism in two steps: transduce, then compare. -The neuron is the whole-cell actor over soma, pre, post, dend, axon. It cannot fire or release — -it integrates what its components emit and grants them the restructuring window none of them can -grant itself. The soma is one of its constituents, a peer of the bouton; the neuron is not the soma. +**Broadcast — distribute one state to many, without addresses.** The third operation sends a single +state outward to a whole population at once: the back-propagating spike to all a soma's spines, the +action potential to all its boutons, the renormalization to all a neuron's synapses, the priming +field and the calcium spike to all an astrocyte's processes. Broadcast is the descending partner of +integration, and like integration it is *addressless* — integration destroys location by summing +(the sum does not say which input), broadcast destroys it by spraying (the signal does not select +which target). Neither is a message from one component to another specific component; there is no +addressed communication across scale, only summation up and spraying down. Crucially, almost every +broadcast is **endogenous and reflective**: it carries a quantity integrated from the components' own +locals and sends back down. The back-propagating spike carries "the soma fired," which is the +integral of dendritic input, reflected to the spines. The renormalization carries the integrated +total weight. These are top-down in delivery but bottom-up in origin — the components talking to themselves +across scales, closing the loop that integration opened. -``` -// PARAMETERS neuron_weight_ceiling · downscale_factor -// INTERFACE -// EMIT rest_permission, renorm_signal, occupancy_downscale → own components (broadcast) -// neuron_fatigue → HYPOTHALAMUS -// RECEIVE (signals) component activity emissions (summed) ; scope_context ← HYPOTHALAMUS -// replay_reweight ← assembly/network (external) -// OWN neuron_activity · neuron_total_weight (aggregates aggregated from emissions) -// NOTE never reads a component interior; sums emitted activity, broadcasts signals only. +**Inject — import the one thing that cannot be built from within.** Reward is different, and the +difference is not its direction. It, too, descends as a broadcast, like the spike and the +renormalization — so top-down delivery is not what sets it apart. What sets it apart is its *origin*: +every other broadcast reflects a quantity assembled from the components' own activity, but no amount +of integrating the components' own activity can produce whether the behavior was *good for the organism in +its world*. That fact is exogenous — it comes from outside the components' own self-talk, from the +organism's encounter with its environment. Reward is the single channel by which information that +could not have been integrated from below enters the coupling at all. This is the precise sense in +which it is the opposite of integration: not top-down versus bottom-up, but **exogenous versus +endogenous** — a global that is *irreducible to* the locals, against a global that is *made of* them. +And it is necessary, because significance is defined at the organism's scale: locality can compute +what happened (activity, load, coincidence) but never whether it mattered, so that verdict must be +injected. The tag is exactly the meeting-site where endogenous evidence (eligibility, built from +local activity) coincides with this exogenous value — consolidation is the marriage of the components' +self-knowledge to the world's verdict, and it is the one place the model reaches outside itself. -DAY | active: // (within broadcast DAY context → integrate only) - // TRACE integrate the cell's emitted activity + committed weight (aggregators) - neuron_activity += Σ component emitted_activity·Δt - neuron_total_weight = Σ component emitted_structure // from emissions, not interiors - // EMIT fatigue upward (metabolic debt of the whole cell) - neuron_fatigue = f(neuron_activity, unspent demand) - // (no restructuring permission while the cell is active — components are busy) - -NIGHT | cycle: // (within broadcast NIGHT context) - // the neuron acts ONLY by signalling; components prime/measure/rebuild themselves. Each - // component's cycle is RECOVERY→PREPARATION→ACTION; the neuron just supplies the constraint. - occupancy_downscale = downscale_factor // → components reset own occupancy (in RECOVERY) - if neuron_total_weight > neuron_weight_ceiling: - renorm_signal = neuron_weight_ceiling / neuron_total_weight // → components scale own structure - rest_permission = TRUE // → components may restructure this cycle - // RECOVER reclaim material returned by components' renormalization (arrives as recycled pool) - // DECAY neuron_activity relaxes as the cell stays quiet - -CODA | on waking (scope_context → DAY): - neuron_activity = 0; neuron_total_weight = recomputed from surviving emissions -``` - -## ASTROCYTE - -The astrocyte is the territory actor over its astrosynapses — the parallel of the neuron, with -three roles. First, it is the ROOT of synaptic energy and ECM material, and therefore the system's -METABOLIC SENSOR: it accrues territory energy debt and reports it upward as the fatigue that drives -the hypothalamus's DAY/NIGHT switch, and its discharge of that debt during night permits waking. -Second, it has its own ACTION — a regenerative Ca²⁺ SPIKE: it integrates the local Ca²⁺ emitted by -its astrosynapses, and when the sum crosses threshold it fires a Ca²⁺ wave that reaches ALL its -astrosynapses at once. This is the astrocytic analog of the soma's action potential — an -integrate-and-fire event that detects and broadcasts a TERRITORY-SCALE COINCIDENCE (many synapses -co-active), transiently boosting D-serine gain across the whole territory and marking every -participating astrosynapse. Third, by DAY it PRIMES its territory: reading its own slow calcium -wave (alpha-band), it sets a localized, slow, neuromodulator-like gain field on D-serine — -dialing postsynaptic response strength across a field of synapses. - -``` -// PARAMETERS (territory reallocation) · alpha_gain · Ca_spike_thr · lactate_cost -// INTERFACE -// EMIT astro_prime[·] (DAY gain field) ; astro_Ca_spike (territory broadcast) ; astro_lactate[·] ; -// astro_alloc[·] + rest_permission (NIGHT) → astrosynapses ; astro_fatigue → HYPOTHALAMUS -// RECEIVE (signals) astro_localCa[·] (integrated up from astrosynapses) ; scope_context ; replay_reweight ; glucose -// OWN astro_integrated_Ca ; astro_slow_Ca (alpha wave) ; astro_central_{energy,material} -// NOTE THREE roles: ROOT (energy+material) · integrate-and-FIRE (Ca spike = territory coincidence) · -// PRIME (alpha gain field). Metabolic sensor: reports fatigue that drives the day/night switch. - -DAY | active: - // integrate the local Ca emitted by astrosynapses (aggregator) + own slow alpha wave - astro_integrated_Ca += Σ astro_localCa[i]·Δt - astro_slow_Ca = integrate_slow(territory activity) // alpha-band astrocytic calcium - // ACTION: regenerative Ca SPIKE when integrated Ca crosses threshold → broadcast to ALL astrosynapses - if astro_integrated_Ca > Ca_spike_thr: - astro_Ca_spike = 1; astro_integrated_Ca = 0 // fire + reset (territory-coincidence event) - // → every astrosynapse reads astro_Ca_spike this step (boosts its D-serine gain; marks its tag) - else: - astro_Ca_spike = 0 - // PRIME: alpha-driven localized gain field on D-serine (dials POST response strength territory-wide) - for each astrosynapse i: astro_prime[i] = 1 + alpha_gain × astro_slow_Ca - // SUPPLY: distribute lactate across the territory by clearance demand (day metabolic support) - factor = min(1, astro_central_energy / (Σ clearance_load·lactate_cost + ε)) - for each i: astro_lactate[i] = clearance_load[i] × factor; astro_central_energy -= astro_lactate[i]·lactate_cost - // EMIT report metabolic debt upward — the fatigue that drives the DAY/NIGHT switch - astro_fatigue = f(territory energy debt, unmet demand) - -NIGHT | cycle: // (within broadcast NIGHT context) - // PRODUCTION (root): this cycle's energy + ECM batch, capped by glucose - astro_central_energy += overnight_glycolysis(glucose)·Δt_cycle // NOT recoverable - astro_central_material += astro_cellbody_synth()·Δt_cycle // recoverable - night_energy_spent += overnight_glycolysis(glucose)·Δt_cycle - // ADJUST allocation weights across the territory (tag × replay) — astrosynapses APPLY these in their RECOVERY - for each i: astro_alloc[i] = (astro_coverage_need[i] × replay_reweight[i]) / Σ(astro_coverage_need × replay_reweight) - rest_permission[i] = TRUE // → each astrosynapse builds/releases itself - // RECOVER reclaim material from decayed astrosynapse ceilings (returned to central pool) - astro_central_material += astro_ceiling_shrinkage·recycle - // discharge: producing + distributing energy repays territory debt → astro_fatigue falls → wake permitted - astro_fatigue -= discharge × astro_central_energy·Δt_cycle - -CODA | on waking: - astro_integrated_Ca = 0 -``` - -## HYPOTHALAMUS - -The system actor. Unlike every other actor it has NO night: it runs CONTINUOUS, integrating the -FATIGUE⇄REST competition and BROADCASTING the DAY/NIGHT context that every other actor receives. It -is the clock that never sleeps — but not a wall-clock: the context it emits is the earned outcome of -the competition, not a schedule. Fatigue is reported chiefly by the ASTROCYTE (the metabolic sensor -that runs the energy economy); rest accrues while quiet. If the hypothalamus stopped, nothing would -integrate the competition and the scope could never switch. - -``` -// PARAMETERS fatigue_gain · rest_gain · hysteresis -// INTERFACE -// EMIT scope_context ∈ {DAY, NIGHT} → ALL actors (broadcast; the switch) -// RECEIVE (signals) fatigue from components + ASTROCYTE (metabolic debt) ; rest (restoration) -// OWN fatigue · rest · scope_context -// NOTE the switch is TOP-DOWN: components receive the context, they do not each decide it. - -CONTINUOUS: // spans every other actor's day and night - // integrate the two competing drives - fatigue += fatigue_gain × (Σ component_fatigue + astro_fatigue)·Δt // rises with activity (astrocyte-reported) - fatigue -= discharge × consolidation_progress·Δt // night restructuring discharges debt - rest += rest_gain × quiet·Δt // restoration accrues while quiet - rest -= rest_drain × activity·Δt - // BROADCAST the context according to which drive dominates (hysteresis avoids chatter) - if fatigue > rest + hysteresis: scope_context = NIGHT - if rest > fatigue + hysteresis: scope_context = DAY - broadcast(scope_context) // every actor behaves/restructures within it -``` - -How it runs without a driver. There is no loop that orchestrates the actors. The hypothalamus -continuously integrates fatigue (astrocyte-reported metabolic debt) against rest and broadcasts the -DAY/NIGHT context; every component and cell actor receives it and behaves or restructures within it. -Night restructuring discharges debt (fatigue falls) while quiet accrues rest — so a rested system's -context flips back to DAY (waking) and an overloaded one wakes with tags unspent (they carry -forward). The astrocyte is the sensor that makes this loop turn: it accrues and reports the debt -that drives the switch, and its discharge during night is what permits waking. +So four operations, and they divide cleanly: integration makes *quantities* (by transducing the +distributed into present stores, time included, as decay); coincidence makes *events* (by reading +several such stores at a site that owns none of them); broadcast *distributes* (mostly the components' +own integrated state, reflected back down, addresslessly); injection *imports* the one global — +organism-in-world value — that no integration could produce. The first two build meaning from the +inside; the third circulates it; the fourth admits the one thing meaning cannot be built from within. --- -## One-view summary +## Coda — The Seven as One, and the Why Beneath Them -``` -THREE CATEGORIES · EIGHT ACTORS · ONE FATIGUE⇄REST SWITCH - Every component runs (ACTION ⇄ RECOVERY) × many, then PREPARATION — same shape at DAY and NIGHT. - ACTION the defining deed (day: release/fire/respond/propagate ; night: change structure) - RECOVERY the fast alter-ego — restore the ability to act (day: refill ; night: import + free material) - PREPARATION shape what's next; faces this scope AND the other. "Evaluation" was preparation all along: - depositing a trace is provisioning, not judging. Each category spans FAST·MEDIUM·SLOW. +Read downward, the seven categories are one principle refracted seven ways. A component is local +(1); its act has one shape, the ring (2); the ring turns in two directions, day and night (3), at +every rung of the timescale ladder (4); the relations between components are set by what is scarce, +collaborative where the currency is free and competitive where it is conserved (5); causation +circulates between components without ever concentrating into command (6); and the local is +multiplied into a describable whole by four operations — integrate, coincide, broadcast, inject — +none of which is a component reading another's interior (7). Remove any one and the principle loses a +facet; none stands apart from it. -ACTORS local: soma·pre·post·dend·axon·astrosynapse cell: neuron·astrocyte system: hypothalamus - higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in +And all seven serve the why of Part I. Each is a way the specification refuses to sit still in any +part: locality forbids a global copy; the ring builds structure from behavior and behavior from +structure; the two turnings make the night rewrite what the day runs; scarcity makes the rewriting +irreversible and history-locked; causation-without-command leaves no controller to hold a fixed +program; the four operations cross scale only by summing and spraying, never by encoding the whole +anywhere. Together they are why there is no fixed model to run — only the rule and the history. There +is only the local component and its one repeating act; everything else is that act, multiplied, +coupled, and described from outside — and because it is only ever *enacted*, never *encoded*, it must +be lived to be known. +# The Logic of the Tripartite Synapse Model — v5 -DAY (broadcast context: rest dominates) ring turned OUTWARD against the world — COLLABORATION - each acts so the next can act (pre→post→dend→soma→axon→pre) ; currency: information (non-rival) - fast_trace → (avg/seconds) occupancy → (avg/minutes + dopamine) TAG, passed to NIGHT -NIGHT (broadcast context: fatigue dominates) ring turned INWARD against the economy — COMPETITION - PREPARATION replays the day ACTION (same machinery, no dopamine) → measures PARTICIPATION - ACTION = BUILD (participation high + tag stands; tag funds a slice, persists) ⇄ RELEASE - (participation LOW; frees material; tag untouched) — build vs release compete WITHIN - RECOVERY = contend WITH OTHER components for shared material/energy ; currency: material (rival) - competition is ADJUDICATED BY COLLABORATION: you build in proportion to replay participation - two forgettings: structural pruning (low participation) ; intention decay (tag decays unspent) -SWITCH DAY/NIGHT is a TOP-DOWN context. HYPOTHALAMUS integrates FATIGUE (astrocyte-reported metabolic - debt) ⇄ REST (restoration) and BROADCASTS the context. Earned, not clocked. Astrocyte is the - metabolic sensor: it drives the switch and its night discharge permits waking. -RULE no actor authorizes its own restructuring — each is PUT IN POSITION by the actor above - (holds an aggregate it can't see, opens a window it can't open). Material recycles; ENERGY - does not (the arrow of time). Coherence is mechanical: a pattern replays only if every link primed. -LOCAL only own state + arrived signals; ACTION/EMIT are the crossings; nothing is a pure sink -``` +*A synthesis of the principles the pseudocode enacts. The document is ordered why → what → how: it +opens with why this is a different kind of object than an ordinary model (Part I), states the single +principle its content obeys (Part II), then descends through seven categories that specialize that +principle (Part III). The why comes first because it is the reason everything else matters — without +it, a reader could take the categories for a description of a synapse and miss that they describe a +physics that writes itself.* + +*What changed in v5. The old "evaluation" phase is retired — it was always preparation aimed at +the other scope. The ring is recut into three categories: ACTION, RECOVERY, PREPARATION. The +obsolete subject-mapping (lateral/local/vertical) is dropped. New findings are folded in: the +rhythm is (ACTION ⇄ RECOVERY) × many, then PREPARATION; every category spans all timescales; night +PREPARATION replays the day ACTION with the same machinery; build and release compete within a +component while material competes between components; there are two independent forgettings; +collaboration by day versus competition by night follows from the rivalry of each scope's currency; +behavior is legible and meaning is assigned by the reader not the signal; and the three categories +are the three modulable dimensions of behavior. Nine categories are consolidated to six, a seventh +is added (the four operations), and — new in this revision — the "why" (formerly a closing note) is +corrected and promoted to the front as Part I.* + +--- + +# PART I — Why This Is Not a Model but a Way of Making Models + +Before the principles, one question: *what kind of object is this?* The answer is unusual, and it +governs everything that follows. This is not a model you can write down and run. It is a **generator +of models** — a rule that turns each history into a different fixed model, and only once that history +has been lived. History is not a variable inside the model; history *is* the model. This part earns +that claim, because stated cold it sounds like mysticism, and it is not — it is a checkable fact +about what the coupled components do. + +**The pseudocode is a physics written in the grammar of an algorithm.** The companion pseudocode +reads like a program — assignments, conditionals, loops — but every line leans on something code +cannot supply. Its primitives — the calcium influxes, the fluctuations, the clearances — name +*physical processes*, not computations; `mini_Ca()` is a placeholder for "whatever the matter does +here." Every `·Δt` is a differential equation in disguise: the discrete step is our notation, the +thing itself is continuous. And every coincidence — the three-way gate, the tag, the build — assumes +its inputs are *present at the same instant at the same place*, which the physical cleft supplies for +free by diffusion but which an `if` can only presuppose. The imperative grammar is a transcription; +the content is a dynamical system. The pseudocode is faithful to the model exactly where it is +unfaithful to computation. + +**The natural objection: surely it can still be simulated.** Nothing here is non-computable in +principle. The dynamics are differential equations with thresholds, which computers integrate +routinely. If "implement" means "numerically approximate a trajectory," computation suffices. This +objection is correct as far as it goes — so the question is what happens when you try to act on it. + +**A first answer that is true but philosophical: the simulator occupies the vantage the model +denies.** The model's content is that there is no global state — no component reads another's +interior, no place holds the whole, holism is enacted and never encoded. But to compute the system +you must hold every component's state in one memory and step them in one loop: the simulator *is* the +forbidden global observer. To order the updates it needs a scheduler (a central order-giver) or a +synchronous clock ticking all components together — the "command from above" that "causation +circulates, command nowhere" denies. And it must *count* time as a variable, where the model insists +time is *suffered* — read off the decay of stores, kept by forgetting. So a computed simulation gets +the trajectory right and the ontology backwards. This is real, but on its own it can be waved away as +metaphysics. The decisive answer is concrete. + +**The decisive answer: there is no one model to simulate — only a way of making models.** Compare two +cases. + +Where simulation *works* — pricing a financial option. You have **one fixed model**: a stochastic +equation with fixed parameters, the same rule on day 1 and day 200. You run 100,000 random price +paths through that same equation. Each path differs, but all are **samples of one stationary object** +— the fixed distribution the equation defines. Average the payoff over them and it **converges**: +100,000 paths give a good estimate, 200,000 barely move it. It works because the paths are variations +on a single system — noise around a stable structure. History matters *within* a path but never +changes *the model*; every path runs the same equation. The model is one object; the paths are its +samples. + +Where the same recipe breaks — this model. Take the four steps in turn. **(1) There is no one fixed +model.** The equation is not the same on day 1 and day 200: night 1 rewrites it into a new equation, +night 2 rewrites that. Each path runs a *different, self-modified* equation by day 10 — there is no +fixed rule to sample from. **(2) The paths are not variations on one system; they are different +systems.** In option pricing, two paths are the same stock behaving differently. Here, the path where +synapse X won an early material competition and grew, and the path where its neighbour Y won instead, +have *physically different structures* — different synapses exist. They are not two runs of one model +but two different models a shared early history produced. **(3) There is no center to converge to.** +The average final price is a real thing; the "average" of *X exists, Y pruned* and *Y exists, X +pruned* is not a valid configuration — it is a blend of two incompatible circuits, corresponding to +no possible state. **(4) More samples stabilize nothing.** More option paths tighten the estimate; +more runs here yield *more distinct circuits*, never a better estimate of one, because there is +nothing for them to estimate. + +In one line: in Monte Carlo, history varies *within* a fixed model, so samples estimate the model; +here history *is* the model — each history builds a different system — so there is nothing the +samples jointly estimate. That is the precise content of "there is no one model, only a way of making +models." The pseudocode is not a model you sample; it is a *generator* of models, one per history, +knowable only once the history is complete. + +**And Monte Carlo is not the only rescue that fails — every acceleration method fails, for the same +reason.** Each general way to compute a system faster than living it out relies on some *stable +invariant* to exploit, and this model, by construction, holds none. +- *Closed-form solution* needs the future to be a computable function of **time**; here it is a + function of the whole **history** — no formula takes a path as input and skips it. +- *Coarse-graining / renormalization* (physics' strongest tool, and tempting given the fast-day / + slow-night split) needs the fast variables to settle, at fixed slow parameters, to a **stationary + average** the slow dynamics can see. But the day's dynamics never settle history-independently — + *which patterns can fire* depends on structure built by every prior night — and the coupling is + bidirectional and same-order: the slow change *is made of* specific fast events (which pattern + replayed), not their average. Coarse-graining discards exactly the individuating detail the model + consolidates. The micro-detail here is the signal, not the noise. +- *Dynamic programming / memoization* needs **state recurrence** to cache and reuse; irreversible + ratcheting (energy spent, structure pruned) means no configuration is ever revisited — + nothing repeats, so nothing can be cached. +- *Surrogate / learned models* need **cross-history regularity** to generalize; the histories are + incommensurable individuals with no shared structure, so there is nothing to learn that is cheaper + than running the history. + +Every method needs one of: time-parametrizability, scale separation with stationary fast statistics, +state recurrence, or cross-history regularity. This model has none — it is history-parametrized, its +fast and slow are same-order coupled, it never recurs (irreversible ratchet), and its histories are +incommensurable. The methods do not fail by bad luck; each needs the stable, reusable structure that +"the specification is continuously rewritten by its own running" abolishes. + +**And here the exponential appears — not as the obstruction, but as its price.** Suppose you refuse +all of the above and insist on simulating anyway. To simulate *is* to fix a structure: a simulation +is a set of variables updated by fixed rules, and you cannot write the loop without committing to +what the variables are. But the real structure changes every night. So you face a forced choice. +Freeze *one* structure and you have committed to a single branch — one accidental history, a +measure-zero sample of a thing that is not a distribution. Stay faithful while keeping a fixed +substrate and you must instead carry *every* structure the system might occupy as an enumerated set — +and that set multiplies each night, growing exponentially in the number of nights, of changing +dimension, non-factorable. This exponential is not a property of the model; the model never +enumerates, it simply becomes one structure. The exponential is the shadow the fluid, self-rewriting +model casts on a fixed substrate — it arises *if and only if* you demand the stable structure that +simulation requires. The need for stable structure is what converts self-rewriting into +exponential enumeration; drop the demand and the exponential vanishes, leaving only a physics living +one history. + +**Three concrete faces of the obstruction.** *The foreclosed synapse:* a synapse pruned on night 3 +is gone; a pattern that would have used it on night 50 breaks at that link and cannot replay, so its +downstream components lose participation and drift toward pruning too — one cheap early pruning +deterministically forecloses a family of patterns fifty nights later, and you cannot know night 50's +structure without having run nights 3–49 in order. *The two histories that never reconcile:* run from +the same start twice; because material is conserved and structure capped, X-growing starves Y, and by +night 20 the runs have disjoint sets of synapses — not noisy versions of one answer but two +incompatible circuits with no meaningful average. *No shortcut:* because each night's structural +change feeds the next day's dynamics feeds the next night's change, with no scale separation to +exploit and no recurrence to cache, the one honest trajectory must be computed night by night, in +order, in full — it is its own shortest description. The only way to know the state at night N is to +run all N nights. + +**Why this is one insight, not several.** The deep cause is that the model **abolishes the separation +between program and data.** Structure (the equations) is built from the accumulated traces of +behavior; behavior runs on structure. Night turns data into program; day turns program into data. +There is no stable specification anywhere, because the specification is continuously rewritten by its +own running — which is just "holism enacted, not encoded" and "no global state," seen over time. A +computation *requires* the split: the program is, by definition, the stable part. A thing with no +stable program cannot be captured by one. + +**What the physics does instead — and why the synapse is its own faithful implementation.** The +physical synapse escapes all of this not by being non-computable but by never needing an invariant. +It does not compute which structure obtains tomorrow; it *becomes* it, by undergoing its night. It +realizes exactly one history in real time — the *real* one, not a sampled one — needing no global +memory (each component holds only its own state), no scheduler (time sequences everything at once, +everywhere, for free), no counted clock (its stores keep time by decaying). So the faithful +implementation of this model is not a program but a *material*: something that, by its own +constitution, undergoes these dynamics with locality, simultaneity, continuity, and suffered time, +without a controller. You can compute *a* life — one honest history, in full, in order, +incompressibly — but never *the* model, because there is no "the model": there is a rule that makes +one model from each history, and the synapse is the matter that runs that rule by being it. + +*Two honest limits. This says faithful **acceleration** is impossible, not that useful +**approximation** is — a coarse model can teach you things, it just would not be this model. And it +holds for the model as specified (irreversible, non-recurring, individuating); whether real neural +tissue is secretly more regular, with statistics one could exploit, is an open empirical question, +not something these principles can foreclose.* + +**The same no-privileged-vantage principle has a second face, in description rather than simulation.** +The first face is simulative: there is no fixed model, only histories. The second is descriptive: +there is no privileged object, only *cuts*. Nothing in the system is a bounded, persisting object one +could isolate and make the whole story — the synapse is part of a neuron, the neuron of an assembly, +the assembly of an organ, with no top and no bottom, only nested aligning projects. To describe it at +all, an observer must *choose a cut*: a boundary, a timescale, and a scope, treating what is inside as +the object and everything larger and smaller as context appearing at the boundary. Every cut is +partial by necessity; none is the whole, for the same reason no computation is the model — there is no +privileged, bounded, stable thing to be the whole. This is orthogonal to the reductive default of +classical physics, which cuts at *static object-boundaries* and explains by *cause and effect between +persisting objects*. Here the objects are active alignments continuously re-achieved, not persisting +substances; the cut is a chosen boundary × timescale × scope, not a given; and the relations that +matter are *constitution across cuts* (parts constitute an object; a level constrains the one below, +emerges into the one above), not efficient causation between objects at one level. Within a single cut +at a single timescale, ordinary cause and effect still works (this release causes that response); it +is the *objects of interest* — synapse, alignment, assembly — that live at the intersection of cuts, +where between-object causation is not the operative relation. There are affinities here with the +scale-relative parts of modern physics — the renormalization group, non-equilibrium thermodynamics, +effective field theory, all of which make descriptions depend on the scale of the cut — but those do +not *solve* this system (see the acceleration survey: they lack the invariants it refuses to hold); +they only point in the right *direction*, toward descriptions that are cut-relative rather than +absolute. The descriptive consequence — that each real object is an object-under-a-cut, partial by +construction — is developed in the companion document on the unexpressed objects. + +Everything below is what this self-writing physics *is* (Part II) and how it works, category by +category (Part III). + +--- + +# PART II — The Unifying Principle + +Watch one presynaptic bouton for a day and a night. By day it releases neurotransmitter, restocks +its vesicles so it can release again, and — in the quiet after a burst — stocks a trace that records +how much this release mattered. By night it does the same three things at a slower tempo: it changes +its structure, restocks the material to change again, and replays the release as a probe to measure +whether the change is still warranted. Nothing supervises it. It reads only its own state and the +signals that reach it. What we call the synapse, the neuron, the memory, the organism is nowhere +inside the bouton — it is only the name we give to many such boutons, coupled. + +That is the whole model in one instance. Stated generally: + +> **There is only the local component and its one repeating act. Everything we call a system — the +> synapse, the neuron, the assembly, the organism — is that act, multiplied and coupled, and +> described from outside. The act has one shape (act, recover, prepare) run in two directions +> (outward by day, inward by night), and the relations between components are set by what is scarce. +> Holism is real, but it is enacted by the coupling, never encoded in any part.** + +This is why the model is a generator rather than a fixed object (Part I): because the specification +is never encoded in any part but enacted by the running, it is rewritten by that running, so no fixed +model exists — only the rule and the history. + +Every category in Part III is this principle, turned to face one question: *What is a component?* +(locality), *What is its act?* (the ring), *What are its two directions?* (the two turnings), *At +what speeds does it act?* (the ladder), *How do components relate?* (scarcity), *Who is in charge?* +(causation — no one), and *By what operations is the local multiplied and coupled into a describable +whole?* (the four operations). None adds a new assumption; each specializes the one above. + +A note on language. This document does not say "the system." There is no system — only local +components, contextualized by their neighbors. Where the phrase appears, it is inside quotation +marks, naming the thing we are denying: an actor that stands above the parts, holds the whole, and +acts on it. No such actor exists here. + +--- + +# PART III — What the Physics Is, and How It Works + +--- + +## 1. Locality — The Only Thing That Exists Is a Local Component + +Everything the model contains is a local component: the bouton, the spine, the astrocytic process, +the dendrite, the soma, the axon. The actors we call higher — neuron, astrocyte, organism — are not +additional things. They are descriptions of many components' coupled activity, spoken from outside. +This is the direct reading of the unifying principle, and the rest of the category is its mechanics. + +**A component reads only its own state and the signals that arrive.** It cannot read another +component's interior, and it cannot read "the whole." When the bouton needs to know whether its +release reached a responsive target, it does not inspect the spine; it waits for a retrograde signal +the spine emitted. Coordination is never achieved by a component consulting a global state, because +there is no global state to consult. It is achieved by signals crossing between components, each +read locally and made to mean something by the local context that receives it. + +**Everything emits; nothing is a pure sink.** A component that only consumed would be invisible to +the rest and could not participate in coordination. Even the leaves of the daytime chain — the +bouton, the spine — emit: by day they emit fatigue upward and retrograde messages laterally; by +night they emit freed material into the shared pool and demand upward. To exist in the model is to +be readable, and to be readable is to emit. + +**Behavior is legible: acting leaves a readable mark, sent or not.** What a component emits is not +always an intended message. Some emissions are *signals* — sent to be read (glutamate, the +retrograde messages, D-serine). Others are *traces* — the physical residue of acting, read by +others though never "sent": spillover glutamate is the consequence of a bouton releasing more than +the cleft can clear, and that overrun is itself information about the bouton's power. There are no +silent acts. Acting and informing are inseparable, because behavior displaces the shared medium and +the displacement is readable. This is why coordination needs no broadcast of intent: a component +that simply behaves is already legible to whoever shares its medium. + +**Meaning is assigned by the reader, not carried by the signal.** A signal is a physical fact — a +molecule, a voltage, an overrun. It has no intrinsic meaning; its meaning is fixed by the local +context that reads it. The same endocannabinoid is a *brake* to the bouton (reduce release) and a +report of *postsynaptic excess* to the astrocytic process (a pressure cue for its own structural +control). The same nitric oxide is *confirmation to strengthen* for the bouton and *this coincidence +was real, keep the capacity* for the astrocyte. The same spillover is *lost transmitter* to no one +and *my presynapse has outgrown my volume* to the astrocyte. One emission, many readers, many +meanings — and none of the readers consults the others to agree on the meaning. This is the locality +principle at the level of semantics: because no component can read another's interior, all it ever +has is the shared physical facts, which it must interpret unilaterally. Coordination is achieved +without shared meaning — each component reads the common medium and assigns its own. + +**Coupling is openness, and openness is bounded.** A component is open — it takes in signals and +supply, gives out signals and product — but its openness is bounded by what it can physically +reach: its own cleft, its own supply lines, the neighbors it is wired to. It is neither sealed (that +would make coordination impossible) nor unbounded (that would make it the whole). The bounded +openness is what lets many local components compose into something we can describe as a whole +without any of them being that whole. + +**Holism is real but only described.** The re-evoked pattern at night, the neuron's total activity, +the memory a synapse carries — these are real. But they are not stored anywhere. The pattern is not +in any component; it is what happens when many primed components ignite each other. The neuron's +"excitability" is not computed by anyone; it is the coincidence of many components' own lowered +thresholds. Holism is enacted by the coupling and read off by us as observers — it is never encoded +in a part, because if it were, that part would be the system, and there is no system. + +**A component cannot be contextualized by a context it emits — so initiators self-trigger.** A +*context* is a signal one component emits for others to read (a spike delivered or not, a train +present or not). Locality has a consequence for contexts that is easy to miss: a component cannot +consume its own emission as its context. It would be reading its own interior, which locality forbids; +and it is circular — a component that fires does not need to be told it fired, it *is* the firing. So +what a component emits (the soma emits AP and REFRACTORY) is its *output*, never its own context. This +splits components in two: + +- A **responder** (the spine, the perisynaptic process, the relays) has a deed that is a *response to + an arrival*, so an external context licenses even its ACTION: glutamate present, a spike arriving. + It consumes a context to act. +- An **initiator** (the soma) fires from *its own* integration crossing *its own* threshold. Nothing + external licenses its action; it runs continuously and the alternation between acting and recovering + is decided by its internal condition. It emits its phases (AP, REFRACTORY) as contexts *for others*, + and cannot itself be contextualized by them, since it is their source. + +So the emission structure is the inverse of the consumption structure: initiators generate the +contexts that responders consume. And one category is exempt from this split — PREPARATION always +faces outward and upward, toward the next act and the other scope, so even an initiator is +externally contextualized *for its preparation* (the neuron, tracking the sustained absence of soma +spikes that the soma cannot know from inside, emits the quiet context that licenses it). A component +self-triggers its own deed; it is told, from above, only when it has been idle long enough to prepare. + +--- + +## 2. The Ring — One Act in Three Phases + +The local component's act has one shape, and it is the same shape everywhere: **ACTION, RECOVERY, +PREPARATION.** This is the specialization of the principle to the question *what is the act?* + +**The three phases.** +- **ACTION** is the component's defining deed — the thing that makes it the component it is. The + bouton releases; the soma fires; the spine responds; the axon and dendrite propagate. Action is + the only phase that spends irreversibly and reaches outside the component. +- **RECOVERY** is the fast alter-ego of action: it restores the capacity to act again. Vesicles + refill, sodium channels de-inactivate, calcium clears. Recovery undoes the local depletion the + action caused, so a next action is possible. It looks backward — it repairs what was just spent. +- **PREPARATION** shapes what comes next. It faces two futures at once: the next action in this same + scope, and the action of the *other* scope. Setting the release machinery for the next spike is + preparation for this scope; stocking the tag that the night will spend is preparation for the + other. Preparation is provisioning, not judging — which is why the old "evaluation" phase was a + misnomer and has been retired. Depositing a trace does not render a verdict; it lays down a + provision that a later phase may or may not draw on. What we once called evaluation was always + preparation aimed at the other scope. + +**The rhythm is (ACTION ⇄ RECOVERY) × many, then PREPARATION — then again.** The act is not one pass +through three phases. Action and recovery alternate rapidly — a tight inner loop, release-and-restock +many times over — and only when that alternation subsides does preparation run, punctuating the +bout and setting up the next. A spike train is exactly this: release ⇄ refill, release ⇄ refill, +then, in the sustained quiet, the preparation that stocks the tag and tunes the next train. The +inner loop is fast; preparation is the slower punctuation. + +**Every category spans all three timescales.** The three phases are not three speeds. Each phase is +a kind of work — deed, restore-capacity, provision — and each kind happens fast, medium, and slow. +Preparation especially is multi-timescale: it contains a fast loop (probe and restock), a medium +adjustment (tuning the release machinery from the tag), and a slow settling. A category names *what +kind* of work, never *how fast*. + +**Action is always local; recovery and preparation may be contextual.** A component necessarily has +its own action — the deed just is the local event occurring in it, and it cannot be performed on +another's behalf (that would be signalling, not acting). But the recovery and preparation of an +action can live in other components. A calcium channel's action is letting calcium in; its +recovery-and-preparation live in the presynapse and above. So the ring is a property of *coupled +components*, not of the individual: **the ring must close — every action recovered from and prepared +for — but no single component need run all three phases itself.** What is necessary is the closing +of the ring, not its co-location. + +**The three categories are the three modulable dimensions of behavior — which is why the synapse has +three parts.** Ask what about a behavior can be changed, and there are exactly three answers: *how +hard* (intensity), *how soon again* (timing), and *where* (spatial extent — which connections exist, +how isolated they are). These are not an arbitrary list; they are the three categories seen from +outside. Intensity is the magnitude of the ACTION — a bigger release is a bigger deed. Timing is set +by RECOVERY — how fast the capacity to act is restored *is* the temporal window and the readiness +for the next deed. Space is set by PREPARATION — which structure is built or pruned is the +configuration future action will run on. To modulate a dimension is to modulate the corresponding +phase; there is nothing to change about a behavior except its three phases, so there are exactly +three dimensions, in one-to-one correspondence. + +This is why the synapse is tripartite and not bipartite. Three separable dimensions want three +independent controllers, and the parties divide them: the presynapse owns the clean intensity knob +(how much it releases), the postsynapse owns sensitivity (how strongly it responds), and the +astrocytic process owns timing and space (its clearance sets how fast transmitter is cleared — +shorter dwell, sharper temporal window — and its coverage sets spillover and isolation). A +two-party synapse could set intensity but could not independently sharpen timing or bound space; +the third party exists precisely to control the dimensions the two coinciding parties cannot. In the +category language, the astrocytic process is the *recovery-and-preparation* specialist of the synapse +— it owns how-soon and where — while the pre and post are *action* specialists — they own how-hard. +The tripartite structure and the three-phase act are therefore two expressions of one three-way +partition: three phases of the deed, three dimensions of what can be changed, three parties to +change them. + +The correspondence is not perfectly symmetric, and the asymmetry is instructive. Intensity and +timing each have a *live* mode — they are modulated moment to moment by the action and the recovery — +and also a *provisioned* mode, the persistent ceiling on them, set slowly. Space has no live mode: a +connection cannot be added mid-behavior; spatial structure is inherently slow. So preparation owns +space outright and also sets the ceilings for intensity and timing, while action and recovery hold +the live knobs. This is why "evaluation" was never a fourth category — there is no fourth dimension +for it to modulate. Behavior has three modulable dimensions; the act has three phases; a would-be +fourth phase would have nothing to change, which is exactly why it collapsed into preparation. + +--- + +## 3. The Two Turnings — Day and Night + +The one ring is turned in two directions. This specializes the principle to *what are the +component's two scopes?* — and it is where the model's deepest duality lives. + +**Two contextualizations, two currencies.** By day the component faces outward, against the world +(the cleft); its currency is information — cheap, gathered passively, and non-rival (see category 5). +By night it faces inward, against the economy; its currency is material and energy — scarce, +conserved, and rival. The component does not know it is in "day" or "night" as a global state; each +turning simply runs against whatever environment is present, and the environment differs. + +**The rotation: the same physical event is a different phase in each scope.** This is the sharpest +form of the duality. Neurotransmitter release is the day's ACTION — the outward deed. The *same +release*, run at night, is PREPARATION: the component releases not to transmit but as a probe, to +replay a behavior and measure how much it participates in the re-evoked pattern. And the structural +change, which the day can only *mark* (the tag is an inert claim pointing at a restructuring that +never happens by day), is the night's ACTION — its irreversible defining deed. So the defining act +of one scope is the measuring-instrument of the other: release is day-action / night-preparation; +restructuring is night-action / day-inert-mark. The scopes do not merely run the ring in two +directions — they swap which event is the deed and which is the provisioning. Because it is a ring, +each scope simply enters at a different phase. + +**Night PREPARATION replays the day ACTION — the same machinery.** Because preparation-at-night is a +*replay* of the behavior, it runs the very code the day action runs: the same release, the same +capacity and vesicle checks, the same endurance deposit into the *same* trace. Endurance discovered +in replay is as real as endurance discovered in behaving. Only two things differ: there is no +dopamine (significance is already settled), and the released transmitter is a probe — it carries the +pattern onward to the next component and its own trace is read as participation. The action machinery +is written once and serves as the deed by day and the measurement by night. + +**The tag is the payload that crosses between the turnings; the fatigue loop is the switch.** Each +scope's PREPARATION mints what the other scope will consume. Day-preparation mints the tag — a +token of confirmed significance — which the night spends on structure. Night-preparation measures +participation, which gates that spending. The tag is one token with three roles: by day it is the +significance bridge; at night it lowers the component's own threshold so its pattern can re-ignite, +and it funds the build, a slice at a time. Distinct from this payload handoff is the *switch* — the +fatigue loop that decides *when* a component crosses between scopes. Activity accrues fatigue; a +single continuous integrator (the one actor that never sleeps) reads the aggregate fatigue and emits +a pressure; when a component's own activity falls and pressure is high, it crosses into night; when +pressure discharges, it crosses back. No scheduler; no clock. The switch says *when* to turn; the +tag says *what* crosses when it turns. One ring, two turnings, stitched by the tag and switched by +fatigue. + +**Two independent forgettings.** Because night ACTION is build ⇄ release (category 5), two distinct +things can be lost, by two distinct mechanisms. *Structural pruning* sheds built structure a +component no longer uses — driven by low participation, regardless of any tag it holds. *Intention +decay* is the tag itself decaying unspent — a planned strengthening that never found the +participation to license it. The tag is patient: it is sliced by building and never touched by +releasing, so it survives across non-participating cycles and cashes in when its pattern finally +re-evokes. Disuse prunes structure; unspent intention fades on its own slow clock. The two are +independent, and both are forgetting. + +--- + +## 4. The Timescale Ladder + +Orthogonal to the ring is the ladder of timescales. This specializes the principle to *at what +speeds does the component act?* The ring says *what kind* of work; the ladder says *how fast*; they +compose — every phase of the ring occurs at every rung of the ladder. + +**The rungs.** FAST (milliseconds to seconds): the immediate trace a single action leaves. MEDIUM +(seconds to minutes): occupancy and evidence — the running average of fast traces, and the +eligibility climbing toward a tag. SLOW (hours): the tag, the consolidation bridge. PERSISTENT +(written only at night): the structural ceilings, and the two conserved stocks — energy, which does +not return, and material, which does. + +**A tier's timescale is set by both its creation and its decay.** A fast trace is deposited as a +point event and relaxes in milliseconds. A medium trace ramps while a condition holds and settles +over minutes. The timescale is not a label attached to a variable; it is the joint consequence of +how the variable is written and how it fades. This is why the same climb appears in every component: +each action leaves a fast trace; the average of fast traces over seconds fills occupancy (short-term +strength); the average of that average over minutes, gated by dopamine, raises the tag. Occupancy is +the fast-and-medium memory of participation; the tag is its slow, validated distillate. + +**Evidence ascends the ladder; capacity descends it.** By day, information climbs from fast trace to +tag — evidence accumulating upward. By night, capacity is written downward from the tag into +persistent structure. Each rung also has its own failure meaning, set by its timescale: a fast pool +running dry is transient depression; a medium pool constrained is a standing endurance need; a +persistent ceiling reached is a structural limit. Depletion and recovery at each rung mirror the +creation and decay of its trace — the same timescale governs both the evidence and the capacity at +that level. + +--- + +## 5. Scarcity Decides — Collaboration by Day, Competition by Night + +How components relate to one another is not an independent fact; it follows from what is scarce. +This specializes the principle to *how do components relate?* — and it unifies conservation, +selection, and the collaboration/competition character of the two scopes into one causal chain. + +**Two conserved currencies, two rules of flow.** Energy ratchets: it is spent irreversibly, the +arrow of time in the model — a component that burns energy into structure cannot get it back. +Material circulates: it is freed by one component and reclaimed by another, conserved as it moves. +Scarcity of both forces choice — two ceilings (structure and endurance) compete for one finite +night pool, and what is not maintained drifts back down. + +**Rivalry of the currency sets the relation.** By day the currency is information, which is +*non-rival*: a bouton releasing glutamate does not use up the spine's ability to receive it; a trace +here does not deplete a trace there. When producing for others costs nothing, the natural relation +is **collaboration** — and the day is exactly that: each component acts so the next can act, releasing, +integrating, clearing, passing activity along the chain, co-producing the pattern and the tags. By +night the currency is material and energy, which are *rival and conserved*: every unit one component +builds into its structure is a unit another cannot have, and the total is capped. When what one takes +another loses, the natural relation is **competition** — and the night is exactly that: components +contend for the shared pool, build what they win, and free what they shed back into contention. + +**But night's competition is adjudicated by collaboration.** The relation is subtler than "day +collaborate, night compete." The replay that arbitrates the night's competition is itself a +collaborative act: a pattern re-evokes only if every component along its loop is primed and ignites +the next — mechanical coherence, a collaboration all the way around, one un-primed link breaking it. +Participation — the measure that gates who gets to build — *is* a measure of successful collaboration +in that re-enactment. So a component earns its share of the scarce material in proportion to how well +it collaborated in replaying the pattern. Collaboration is primary in both scopes: by day it +*produces* the shared, non-rival good; by night it *adjudicates* the competition for the rival one. +The register is economic, not martial — components do not fight; they contend for a conserved +resource, and the contention is settled fairly by a collaborative criterion. + +**Two competitions at two loci.** Within the night, competition appears twice, cleanly separated. +*Within* a component, build and release contend over its own structure, arbitrated by participation: +high participation builds (funded by the tag, a slice per cycle), low participation releases (freeing +material, the tag untouched), and in between the component holds. *Between* components, this one and +its peers contend for the shared material and energy during recovery. The internal tension (grow or +shrink?) is settled by the replayed pattern; the external tension (can I get material?) is settled by +contention with neighbors. Selection under scarcity is the sum of these: what survives a night has +both earned its tag by day and won its material by night, and what neither participates nor is +maintained returns to the pool. Selection is not a judge's verdict; it is what scarcity leaves +standing. + +--- + +## 6. Causation Circulates — Emergence Up, Constraint Down, Command Nowhere + +The final category specializes the principle to *who is in charge?* — and the answer is no one. +Causation moves in two directions across the coupling, and neither is command. + +**Emergence ascends; constraint descends.** By day, evidence and activity emerge upward: components +act locally, and their emitted activity is what a higher description (the neuron, the assembly) is +*made of*. Nothing reaches down to make them act. By night, constraint descends: a higher actor +broadcasts a bound — a renormalization target, a downscale factor — but it does not reach in. It +emits a signal; each component reads that signal and scales *itself*. The neuron never edits a +synapse; it announces a total, and the synapses each renormalize their own structure against it. + +**No actor authorizes its own restructuring.** A component cannot open its own night. It is *put in +position* by the actor above — which holds an aggregate the component cannot see and opens a window +the component cannot open — and then, within that window, the component acts locally on its own +state. The soma cannot decide within the soma which of its synapses matter; the synapses decide that +locally, by their own thresholds. And the synapses cannot ignite their pattern alone; the soma's +firing does that. Each is put in position by the other; neither reads the other's interior. This is +the recursive grant: act locally, be enabled hierarchically. + +**Command is nowhere.** There is no actor that both holds the whole and acts on it — that would be +the system, and there is no system. What looks like top-down control is always a broadcast constraint +scaled locally; what looks like bottom-up assembly is always local emission summed from outside. The +neuron that "renormalizes" only announces a number. The assembly that "replays" is only coincident +local thresholds propagating through coupling. Causation circulates — up as emergence, down as +constraint — but it never concentrates into command. This is the unifying principle in its final +form: because there is only the local component and its one act, there is no one to be in charge, and +the whole is enacted by the parts, never encoded above them. + +--- + +## 7. The Four Operations — How the Local Is Multiplied Into a Whole + +The six categories describe what a component is and does. This one is a different cut: it asks by +what *operations* the local is coupled into something we can describe as a whole. There are four — +integrate, coincide, broadcast, inject — and together they are the entire vocabulary by which scale +is crossed. The previous category named the two *directions* of causation; this one names the +*mechanisms*, and adds the two the directional view misses. + +**Integrate — make the distributed present.** A quantity spread over time or space has no +instantaneous local existence. Flow is nowhere emitted; it is the accumulation of many releases +across a duration. Frequency is not present at any instant — a single spike has no rate; rate lives +only in the relation between events separated in time. Total activity is not held by any component; +it is the sum over many. The system reads none of these directly — it *cannot*, because they are not +anywhere. It reads them by **transducing the distributed into a store whose instantaneous level is +the quantity's present shadow.** The fast trace is the device: each event deposits a quantum, the +store leaks, and its standing level encodes recent frequency — high when deposits outran decay, low +when they did not. Spatial integration does the same across space: the dendrite summing its spines, +the soma summing its dendrites, the astrocyte summing its processes each make a spatially-distributed +quantity locally present at one site. This is how a distributed system verifies what is expressed +nowhere and by no one: it never reads the quantity, it reads the store the quantity filled. And it is +how the whole "knows" what no part knows — not by computing, but by *being the place where the parts +accumulate*. + +Time itself is read this way. The system has no clock; it does not count duration. Time enters only +as the *decay* of stores — "how long ago" is how far a trace has fallen, "how fast" is how high it +stands against its leak. Time is not represented; it is suffered, and the store's level is the +readout. Every leaky store is a little clock that keeps time by forgetting rather than by counting. + +**Coincide — read several present-made stores at one site, and get an event.** Integration produces +quantities; coincidence produces *events* — the meaningful happenings the components act on. And nothing +significant is caused by a single signal: significance is always the co-occurrence of several. The +postsynaptic calcium event requires glutamate and depolarization and the astrocytic gain together; +the tag requires accumulated eligibility and validation together; the night's build requires a +standing tag and confirmed participation together; the astrocytic spike requires many processes' +calcium together. A coincidence is *two or more stores being high at the same instant* — which can +only be read where all of them are present. So every coincidence needs a **meeting-site that owns +none of the signals it compares**: the site where the transduced-present stores overlap. This is why +the synapse is tripartite (the coincidence detector needs a third input neither coinciding party +owns), and the pattern recurs at every level — each has its coincidence and its meeting-site. +Integration makes the distributed present; coincidence reads several presences together. They are one +mechanism in two steps: transduce, then compare. + +**Broadcast — distribute one state to many, without addresses.** The third operation sends a single +state outward to a whole population at once: the back-propagating spike to all a soma's spines, the +action potential to all its boutons, the renormalization to all a neuron's synapses, the priming +field and the calcium spike to all an astrocyte's processes. Broadcast is the descending partner of +integration, and like integration it is *addressless* — integration destroys location by summing +(the sum does not say which input), broadcast destroys it by spraying (the signal does not select +which target). Neither is a message from one component to another specific component; there is no +addressed communication across scale, only summation up and spraying down. Crucially, almost every +broadcast is **endogenous and reflective**: it carries a quantity integrated from the components' own +locals and sends back down. The back-propagating spike carries "the soma fired," which is the +integral of dendritic input, reflected to the spines. The renormalization carries the integrated +total weight. These are top-down in delivery but bottom-up in origin — the components talking to themselves +across scales, closing the loop that integration opened. + +**Inject — import the one thing that cannot be built from within.** Reward is different, and the +difference is not its direction. It, too, descends as a broadcast, like the spike and the +renormalization — so top-down delivery is not what sets it apart. What sets it apart is its *origin*: +every other broadcast reflects a quantity assembled from the components' own activity, but no amount +of integrating the components' own activity can produce whether the behavior was *good for the organism in +its world*. That fact is exogenous — it comes from outside the components' own self-talk, from the +organism's encounter with its environment. Reward is the single channel by which information that +could not have been integrated from below enters the coupling at all. This is the precise sense in +which it is the opposite of integration: not top-down versus bottom-up, but **exogenous versus +endogenous** — a global that is *irreducible to* the locals, against a global that is *made of* them. +And it is necessary, because significance is defined at the organism's scale: locality can compute +what happened (activity, load, coincidence) but never whether it mattered, so that verdict must be +injected. The tag is exactly the meeting-site where endogenous evidence (eligibility, built from +local activity) coincides with this exogenous value — consolidation is the marriage of the components' +self-knowledge to the world's verdict, and it is the one place the model reaches outside itself. + +So four operations, and they divide cleanly: integration makes *quantities* (by transducing the +distributed into present stores, time included, as decay); coincidence makes *events* (by reading +several such stores at a site that owns none of them); broadcast *distributes* (mostly the components' +own integrated state, reflected back down, addresslessly); injection *imports* the one global — +organism-in-world value — that no integration could produce. The first two build meaning from the +inside; the third circulates it; the fourth admits the one thing meaning cannot be built from within. + +--- + +## Coda — The Seven as One, and the Why Beneath Them + +Read downward, the seven categories are one principle refracted seven ways. A component is local +(1); its act has one shape, the ring (2); the ring turns in two directions, day and night (3), at +every rung of the timescale ladder (4); the relations between components are set by what is scarce, +collaborative where the currency is free and competitive where it is conserved (5); causation +circulates between components without ever concentrating into command (6); and the local is +multiplied into a describable whole by four operations — integrate, coincide, broadcast, inject — +none of which is a component reading another's interior (7). Remove any one and the principle loses a +facet; none stands apart from it. + +And all seven serve the why of Part I. Each is a way the specification refuses to sit still in any +part: locality forbids a global copy; the ring builds structure from behavior and behavior from +structure; the two turnings make the night rewrite what the day runs; scarcity makes the rewriting +irreversible and history-locked; causation-without-command leaves no controller to hold a fixed +program; the four operations cross scale only by summing and spraying, never by encoding the whole +anywhere. Together they are why there is no fixed model to run — only the rule and the history. There +is only the local component and its one repeating act; everything else is that act, multiplied, +coupled, and described from outside — and because it is only ever *enacted*, never *encoded*, it must +be lived to be known.