Update 2026-07-06-logic-principles-of-the-expresion_v5.md

2026-07-08 10:34:48 +02:00
parent 4ea6ffa504
commit 421aae0095
1 changed files with 93 additions and 0 deletions
@@ -439,3 +439,96 @@ multiplied into a describable whole by four operations — integrate, coincide,
 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.
 ---
 ## 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.