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 7097ad8..3e744c6 100644 --- a/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md +++ b/elements/neuron/appunti/2026-06-29-tripartite-synapse_v17.md @@ -1,1314 +1,1341 @@ -# The Logic of the Tripartite Synapse Model — v5 +# Tripartite Synapse — Pseudocode v17 -*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.* +> 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. --- -# PART I — Why This Is Not a Model but a Way of Making Models +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: -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. +``` +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. +``` -**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. +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 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. +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. -**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. +``` + 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) +``` -**The decisive answer: there is no one model to simulate — only a way of making models.** Compare two -cases. +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. -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. +``` + 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 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. +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. -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. +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. -**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. +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. -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. +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. -**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). +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). --- -# PART II — The Unifying Principle +## Conventions -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. +``` +SCOPE = {DAY, NIGHT} DAY CONTEXT = {AP, REFRACTORY⊂NOT_AP, NOT_AP, NOT_SPIKE_TRAIN, CONTINUOUS} NIGHT CONTEXT = {NON_REM_1, NON_REM_2, REM} -That is the whole model in one instance. Stated generally: +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. -> **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.** +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.) -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. + 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). -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. + 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. -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. +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 +``` --- -# PART III — What the Physics Is, and How It Works +## 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 +``` --- -## 1. Locality — The Only Thing That Exists Is a Local Component +## SHARED parameters -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. +``` +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) +ε +``` -**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. +## NIGHT parameters (consolidation only) -**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. +``` +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) +``` -**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. +--- +--- +# 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. +--- -**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. +## PRE -**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. +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). -**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 · 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. -**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 · 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 **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. +**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. -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. +**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 +``` --- -## 2. The Ring — One Act in Three Phases +## POST -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 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 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 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 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. +**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. -**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*. +**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. -**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. +**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. -**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. +``` +// 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. -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 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. -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. +// ===== 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 +``` --- -## 3. The Two Turnings — Day and Night +## DEND -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. +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. -**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 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. -**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 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. -**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. +**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. -**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. +``` +// 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. -**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. +// 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) +``` --- -## 4. The Timescale Ladder +## SOMA -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 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. -**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 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. -**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 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. -**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. +**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) +``` --- -## 5. Scarcity Decides — Collaboration by Day, Competition by Night +## AXON -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. +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. -**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 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. -**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 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. -**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. +**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. -**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. +``` +// 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) +``` --- -## 6. Causation Circulates — Emergence Up, Constraint Down, Command Nowhere +## ASTROSYNAPSE -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 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). -**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. +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). -**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. +**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. -**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. +**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) +``` --- -## 7. The Four Operations — How the Local Is Multiplied Into a Whole +## Special — Shockwave Lockdown -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. +``` +DAY or NIGHT | OVERLOAD: + Vm = HYPERPOLARIZED; AMPA_surface = mass_internalize() → post reserve + axon_fast_trace += overdrive(); astro_central_budget -= emergency_cost +``` -**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*. +--- +--- +> 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. -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. +--- +--- +# 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. -**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. +## NEURON -**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. +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. -**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. +``` +// 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. -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. +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. --- -## 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. -# The Logic of the Tripartite Synapse Model — v5 - -*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. +## One-view summary + +``` +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. + +ACTORS local: soma·pre·post·dend·axon·astrosynapse cell: neuron·astrocyte system: hypothalamus + higher actors INTEGRATE constituents' emissions and BROADCAST — never reach in + +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 +```