From f9dfb2e542c6fbbe8be005e3477a0ffab58c5a43 Mon Sep 17 00:00:00 2001 From: ocrampal Date: Wed, 8 Jul 2026 11:21:19 +0200 Subject: [PATCH] Update 2026-07-06-logic-principles-of-the-expresion_v5.md --- ...06-logic-principles-of-the-expresion_v5.md | 341 +++++++++--------- 1 file changed, 172 insertions(+), 169 deletions(-) diff --git a/elements/neuron/appunti/2026-07-06-logic-principles-of-the-expresion_v5.md b/elements/neuron/appunti/2026-07-06-logic-principles-of-the-expresion_v5.md index 4bae0d0..9aeeb13 100644 --- a/elements/neuron/appunti/2026-07-06-logic-principles-of-the-expresion_v5.md +++ b/elements/neuron/appunti/2026-07-06-logic-principles-of-the-expresion_v5.md @@ -4,10 +4,12 @@ include_toc: true # The Logic of the Tripartite Synapse Model — v5 -*A synthesis of the principles the pseudocode enacts. This version is reorganized top-down: it -opens with the single principle everything specializes, then descends through six categories, each -presented as a facet of that principle rather than a separate idea. Where earlier versions built -bottom-up toward a conclusion, this one hands over the key first and shows each category turning it.* +*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 @@ -16,16 +18,151 @@ rhythm is (ACTION ⇄ RECOVERY) × many, then PREPARATION; every category spans 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 (acting leaves signals AND traces) and meaning is assigned by the reader not the -signal; and the three categories are the three modulable dimensions of behavior (intensity↔action, -timing↔recovery, space↔preparation) — which is why the synapse is tripartite. Nine categories are -consolidated to six, and a seventh is added — the four operations (integrate, coincide, broadcast, -inject) by which the local is multiplied into a describable whole: a different cut from the other -six, naming the mechanics of how scale is crossed.* +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.* --- -## The Unifying Principle +# 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. + +**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.* + +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 @@ -43,11 +180,15 @@ That is the whole model in one instance. Stated generally: > (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.** -Every category below 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. +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 @@ -56,6 +197,10 @@ 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, @@ -432,7 +577,7 @@ inside; the third circulates it; the fourth admits the one thing meaning cannot --- -## Coda — The Seven as One +## 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 @@ -441,156 +586,14 @@ collaborative where the currency is free and competitive where it is conserved ( 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. There is only the local component and its one repeating act — and -everything else is that act, multiplied, coupled, and described from outside. +facet; none stands apart from it. ---- - -## A Note on the Status of the Model — Why the Pseudocode Is Not an Algorithm - -The companion pseudocode reads like a program: assignments, conditionals, loops. It is not one, and -mistaking it for one hides what the model is. This note walks from the obvious to the surprising — -each step is needed to make the last one legible. - -**The pseudocode is a physics written in the grammar of an algorithm.** Every line leans on -something code cannot supply. Its primitives — the calcium influxes, the fluctuations, the -clearances — name *physical processes*, not computations; the syntax `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. -So 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 — every place it "cheats" as -code (hiding physics in a primitive, discretizing a continuum, reading many locals in one condition) -is a place the physical system does *for free, without a controller* what a computation could only do -*with* one. - -**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; one could write the ODEs, discretize, and run them. If "implement" means "numerically -approximate the trajectory," computation suffices. This objection is correct as far as it goes — and -it is worth stating plainly, because the interesting conclusion is not that the model is magic, but -what happens when you try to act on this objection. - -**First reason the simulation is false to the model even when numerically accurate: it must occupy -the vantage the model denies.** The model's whole 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: it reads all interiors at once and holds the whole. -To serialize the updates it needs a schedule — a central order-giver — and to parallelize them it -needs a synchronous clock ticking all components together; both are the "command from above" that -"causation circulates, command nowhere" denies. And it must *count* time as an advancing variable, -where the model insists time is *suffered* — read off the decay of stores, kept by forgetting, never -represented. So a computed simulation gets the trajectory right and the ontology exactly backwards: it -manufactures, as machinery, every global thing the model exists to deny. This is a real objection, but -a philosophical one — being-the-dynamics versus representing-them — and on its own it can be waved -away as metaphysics. The second reason cannot. - -**Second reason, and the decisive one: there is no fixed system to simulate.** An ordinary simulation -runs fixed dynamics on changing state — the equations stay put, the variables evolve. This model -rewrites its own structure every night, and *structure is the equations, not the state*. When a -process builds coverage it changes the clearance that governs the next day's timing; when it builds -release capacity it changes the release function; when a synapse is pruned or grown, the very -*dimension* of the state space changes. So the night does not advance the state within a fixed system -— it produces a *different dynamical system* for the next day. The run is not a trajectory through a -state space; it is a trajectory through the space of *programs*: day one runs P₁, whose night yields -P₂, whose night yields P₃, each with different couplings and possibly different dimension. - -And the night that turns P₁ into the next program is not a function — it is a *branching, coupled, -dimension-changing* process. Branching: which patterns replay depends on stochastic spontaneous -ignitions, so P₁ can yield P₂, P₂′, P₂″, … — and over N nights the possible program-trajectories -grow as (branches)^N. Coupled: the night is a competition for shared material with coherence -requiring whole loops primed together, so the branches do not factor into independent per-component -trees you could simulate apart and recombine — the joint configuration is irreducible. Dimension- -changing: pruning and building alter the variable set itself, so it is not even a fixed -high-dimensional space you branch within — the space's dimension is part of what branches, and -path-dependently, since an early pruning forecloses whole regions of later program-space. - -So ask the concrete question: *which simulation do you run tomorrow?* There is no answer. To run one, -you must either **commit to a single branch** — pick particular ignitions, get one P₂, and simulate -one accidental history, which is a measure-zero, path-dependent sample of the model rather than the -model — or **carry the whole distribution of branches**, which is the exponential blowup made -explicit: after N nights, (branches)^N distinct programs of changing dimension, non-factorable, -intractable by construction. There is no faithful third option. "The simulation" is not one object; -it is an exponentially branching, path-dependent, non-factorable family of distinct programs, and -which one is real depends on the entire stochastic history. The in-principle computability is real -and beside the point; the practical intractability is the point. - -**Why the two reasons are one insight.** The deep cause of both 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. The night turns data into program; the 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 program/data split: the program is, -by definition, the stable part. A system with no stable program cannot be captured by one, except by -the intractable device of enumerating every program it might become. - -**What the physics does instead.** The physical synapse escapes all of this not by being -non-computable but by *never enumerating*. It does not compute which next-day program obtains; it -*becomes* it, by undergoing its night. It realizes exactly one path through the exponential tree at -no cost, because it does not explore the tree — it *is* the walk. It needs no global memory because -each component holds only its own state; no scheduler because time sequences everything at once, -everywhere, for free; no counted clock because its stores keep time by decaying. The faithful -"implementation" of this model is therefore not a program but a *material* — something that, by its -own constitution, undergoes these dynamics with locality, simultaneity, continuity, and suffered time, -without any controller. The synapse is not *running* this model. It *is* this model, because the model -is a description of what its matter does. That is why the pseudocode can only ever be a transcription: -it points, in the grammar of computation, at a physics whose faithful execution is the matter itself. - -## The limitation of traditional tools for an implementation - -### First, name what you actually need - -No global state, no scheduler, no counted time, and — the decisive one — *the structure rewrites itself, so there's no fixed program*. So a helpful physical framework must give you a substrate where (a) dynamics run without a central updater, (b) the parameters of the dynamics are themselves physical variables that evolve, and (c) time and simultaneity come for free. That's the spec. Now let's see what physics has. - -### 1. Analog / continuous-time physical computation (the most direct help, and real) - -The cleanest fit is the oldest idea: **don't simulate the dynamics, build a device whose native physics *is* the dynamics.** This is analog computation, and it's not a metaphor — it's a tradition. - -- **Neuromorphic hardware** (memristor crossbars, analog VLSI) is built exactly for this. A memristor's conductance *is* a physical synaptic weight that changes as a continuous function of the current through it — the structure variable is a material property, updated by the physics of the device, not by a CPU writing to memory. No scheduler: every device updates simultaneously and continuously because they're all just obeying their I-V physics at once. No counted clock: the dynamics evolve in real physical time. This directly answers (a) and (c), and *partially* (b) — the weights evolve physically. - -Where it helps: this genuinely removes the global state, the scheduler, and the counted clock. A memristor crossbar undergoing your day-dynamics is doing coincidence-detection and integration *as physics*, for free, in parallel, in real time. This is not speculative — it exists. - -Where it stops: standard neuromorphic hardware changes *weights*, but your model changes *structure* — it prunes and grows synapses, changing the *dimension* and *connectivity*, not just the values. Memristor arrays have fixed topology. So analog hardware solves the "no scheduler / no clock / continuous" problem but not yet the "self-rewriting dimension" problem. That's the frontier — and there is work on structurally reconfigurable and self-organizing neuromorphic substrates, but it's much less mature. So: real help, incomplete. - -### 2. Self-organizing / dissipative systems (help for the self-rewriting part) - -The part physics helps *most* with conceptually is the thing you found hardest: a system whose own structure is built by its own running. This is the domain of **non-equilibrium thermodynamics and dissipative structures** (Prigogine), and more broadly self-organization. - -The key idea you can borrow: **structure that is maintained by dissipation.** A dissipative structure (a convection cell, a chemical pattern, a flame) is not a fixed object — it is a *pattern held in place by a continuous flow of energy through the system*. Cut the flow and it vanishes. This is *exactly* your model's structure: coverage, active-zone capacity, receptor slots are all maintained by ongoing metabolic flow (energy that ratchets, material that circulates), and decay without maintenance. Your "structure builds where flow sustains it, releases where it doesn't" is a dissipative-structure principle almost verbatim. - -Why this helps: it tells you the self-rewriting isn't mysterious or unphysical — physics has a whole theory of *systems whose organization is a dynamic steady state of matter/energy flow, not a fixed configuration.* The equations of your model are the local rules; the structure is the emergent dissipative pattern. You don't implement the structure directly — you implement the *flows and the local rules*, and let the structure be what the flows sustain. That reframes your implementation problem: **don't try to represent the changing program; implement the flows whose sustained patterns *are* the program.** The structure stops being something you update and becomes something that persists only while used — which is what the model already says. - -Where it stops: dissipative-structure theory is strong on *pattern formation and maintenance* but weak on *the specific, addressed, memory-like structures* your model builds (this synapse, not that one). Convection cells are generic; your synapses are individuated by history. Bridging generic self-organization to individuated, history-dependent memory is not solved. So it gives you the right *category* of physics but not a ready equation. - -### 3. Field theory / continuum descriptions (help for "no global state, yet coordinated") - -Your worry about simultaneity and no-global-state is, in physics, the ordinary situation of a **field**. A field has no global controller — each point evolves by local rules (the field equations) reading only its immediate neighborhood, yet the whole exhibits coordinated, coherent behavior (waves, coherence, propagation) with no scheduler. Simultaneity is not imposed; it's what "the field at time t" means, and locality is built in (nothing propagates faster than the field's characteristic speed). - -Why this helps: it's a proof-of-concept that *"purely local rules, no global state, no controller, yet globally coordinated behavior"* is not only possible but is how most of physics already works. Your replay-coherence (a pattern carries only where every link is primed) is a *propagation* phenomenon — it's a field/excitable-medium concept. **Excitable media** (the theory behind waves in heart tissue, the Belousov-Zhabotinsky reaction, forest-fire models) are the precise physics of "a disturbance propagates only where the medium is primed, and dies at unprimed gaps." That is your night replay, exactly. So excitable-media math (reaction-diffusion, wave propagation in heterogeneous media) is a directly applicable tool for the coherence-is-mechanical claim. - -Where it stops: fields are usually *fixed-parameter* (the medium's properties don't change as the wave passes). Your medium rewrites itself. So you'd need an excitable medium *with plastic parameters* — reaction-diffusion where the diffusion constants and reaction rates are themselves slow dynamical variables driven by the fast activity. This exists in pockets (adaptive reaction-diffusion, self-modifying excitable media) but is not standard. Again: the right tool, needing an extension. - -### 4. The honest synthesis — what I think your implementation actually is - -Putting these together, here's the shape of an answer, and it's neither "just simulate it" nor "impossible": - -**Your model is a plastic excitable medium maintained as a dissipative structure, and its faithful implementation is a physical (analog) substrate with three coupled timescales of its own material dynamics.** Concretely, the implementation you're looking for is not a program but a specification of: - -- a **fast** excitable dynamics (the day: propagation, coincidence, integration) running on a medium, -- whose **parameters are slow physical variables** (the structure) that evolve by their own dynamics (the night: build/release as a dissipative steady state of material flow), -- **coupled** so that the fast activity drives the slow parameter change and vice versa, -- realized on a substrate (analog/neuromorphic) where all of this is *material behavior in continuous time*, not represented state updated by a clock. - -The mathematics for this is **slow-fast coupled dynamical systems** (singular perturbation theory, adiabatic elimination) — the branch of dynamical-systems theory built precisely for "fast variables running on a landscape that slow variables reshape." That's the formal home of your day/night structure. It won't let you *escape* the exponential-branching intractability of *simulating* it — but it's the right language to *specify* it, and analog substrates are how you'd *instantiate* it without simulating. - -### The one caveat I owe you - -I want to be straight about the limit. None of this makes the *simulation* tractable — the exponential-branching argument stands. What physics offers is a different move: **stop trying to simulate, and instead specify-and-instantiate.** Slow-fast dynamical systems + excitable media + dissipative structures give you the *language to specify* the model as a physics; analog/neuromorphic substrates give you a way to *instantiate* it as matter that runs itself. The gap that remains — the genuinely unsolved part — is *structural* self-modification (changing dimension/topology, not just parameters) in a physical substrate. That's a real research frontier, not a solved problem. So you're not stuck, but the path is "build/specify a self-modifying analog dynamics," and the last mile (physical substrates that grow and prune their own topology) is open. - -Two directions to pursue depending on what you want: - -- If you want to **understand and specify**: slow-fast dynamical systems and excitable-media/reaction-diffusion are the math to write your model in — they'll turn the pseudocode into actual (continuous, local, controller-free) equations. -- If you want to **instantiate**: neuromorphic/memristive analog computing is the substrate tradition, with structural plasticity as the open extension. - -Would it be useful if I took *one* component — say the astrosynapse, since it's the cleanest controller (spillover-error → coverage) — and tried to rewrite its day/night pseudocode as an actual slow-fast dynamical system (fast clearance dynamics, slow coverage as the drifting parameter, coupled)? That would be a concrete test of whether the "specify as physics" path actually works on this model, or whether something resists — and it's the honest way to find out if physics really helps here or just sounds like it should. +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.