From 421aae00951966359ebc2db96df0b6aa617e498c Mon Sep 17 00:00:00 2001 From: ocrampal Date: Wed, 8 Jul 2026 10:34:48 +0200 Subject: [PATCH] Update 2026-07-06-logic-principles-of-the-expresion_v5.md --- ...06-logic-principles-of-the-expresion_v5.md | 93 +++++++++++++++++++ 1 file changed, 93 insertions(+) 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 3faba8f..d595fbd 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 @@ -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.