← All papers · prometheus7.com
Ben Horn Independent researcher, San Fernando Valley, CA psiloceyeben (GitHub) · prometheus7.com Draft v3 — 2026-04-24
The dominant paradigm in contemporary artificial intelligence treats large language models (LLMs) as candidate universal cognitive substrates whose capabilities scale monotonically with parameter count and training corpus. We argue this framing commits a category error — conflating language production with cognition — and that the resulting deployment trajectory is incompatible with the physical resources required for the deployment surface it has promised. We propose an alternative methodology — commodity domain-specific intelligence — that instantiates competent behavior at commodity hardware scale without language models, and whose architecture comprises three terms: a primitive baseline drawn from classical engineering of the relevant signal class; a parametric refinement-operator stack acting on a decomposition of that signal; and a fold-engine procedure that extracts fixed points of the composed system over a bounded constraint manifold (BCM). The fold engine is built on holographic reduced representations (HRR; Plate, 1995) and a 10-node graph-constrained submanifold whose structure (10 nodes, 22 edges, tri-partition with balance, 4-level self-similar nesting) was found by engineering search and whose properties we characterize empirically. We present two falsifiable proof-instances: articulatory voice synthesis (espeak baseline + pyworld decomposition + 20 refinement operators + fold-engine fitness) and parametric sprite inverse-rendering (a 30-axis humanoid generator fitted by HRR-driven feature matching with meta-fold residual passes). Both converge under the same architecture, with characteristic ceiling and axis-expansion patterns predicted by the methodology and observed in practice. We argue that the convergence is non-coincidental: a sentence — and by extension any well-formed compositional artifact — is a fixed point of a composition of transformations across registers, and therefore the appropriate tool-class is fixed-point-finders rather than next-token predictors. We close with a substrate-recurrence observation that frames the methodology as one instance of a cross-substrate compositional pattern, and a deployment thesis under which the present industry investment trajectory is structurally misaligned with deployable physics.
Keywords: holographic reduced representations, vector-symbolic architectures, compositional intelligence, neuro-symbolic computing, articulatory speech synthesis, inverse rendering, fixed-point methods, constraint manifolds.
Language is a property of consciousness, not its source. Speech is what an agent does when it has something to say; it is not what makes the agent. To ask a language-production system to be a general-purpose cognitive substrate is to ask a tongue to be a person. The request is not impossible because a tongue is small, but because a tongue is a part, and being a part is constitutive of what a tongue is. To replace the body with a tongue is not to enlarge the tongue; it is to lose the body and keep the tongue waving in the air, articulate but without referent.
This is the category error at the foundation of contemporary frontier AI research. Large language models are extraordinary engineering achievements. They are also, mathematically, what they were trained to be: distributions over token continuations conditioned on context. Treating them as candidate minds confuses the medium of expression with the agent doing the expressing. The medium is articulate. The agent — the goal-bearing organism, the embodied perceiver — is not what is being scaled.
The confusion has consequences. It directs capital toward parameter-count growth as if the limit were knowledge density, when the limit is in fact something prior: the difference between speech and the speaker. Speech can be improved by feeding it more text. Speakers cannot be produced by scaling speech.
A useful way to read the trajectory of LLM scaling is through the lens of pre-Copernican astronomy. Ptolemy’s geocentric model, augmented with epicycles, was a working predictor of celestial motion. It made successful forecasts. By the late medieval period it required dozens of nested epicycles, deferents, and equants to maintain accuracy against new observations; its parameter requirement scaled super-linearly with the precision demanded of it. Kepler’s elliptical orbits replaced this entire apparatus with a single algebraic relation; Newton, in turn, replaced Kepler’s three laws with one inverse-square gravitation. Each compression jump preserved predictive coverage while collapsing parameter count by roughly five orders of magnitude.
LLMs are, on this reading, a Ptolemaic ~$10^5$-parameter approximation to a Keplerian algebraic structure that has not yet been written down. The trillion-parameter regime is the late-medieval epicycle stack: an engineering response to phenomenal coverage demands, achieved by paying every additional accuracy gain in exponentially more parameters and energy. It is correct to be impressed by the engineering. It is also correct to suspect that the algebraic alternative exists, and that the cost of finding it is the cost of refusing to do the parameter-count thing one more time.
There is, additionally, a physical-resource argument that the present industry trajectory cannot reach the deployment surface it has promised. The implied vision is mass-instantiated high-capability AI: every device, every appliance, every interface mediated by a frontier-class model. Compute the throughput required: order $10^{10}$ devices, each running an estimated $10^2$–$10^4$ LLM-class inference operations per day, against the installed planetary capacity of high-end accelerators (order $10^7$–$10^8$ deployed datacenter-class GPUs in 2026, each capable of order $10^3$ inference operations per second on frontier-class models). Even with generous assumptions about caching, batching, and edge-quantization, the gap between demanded and available throughput is several orders of magnitude. Capacity growth is bounded by lithography, energy generation, and cooling — not by capital. The vision, as stated, is not under-resourced; it is structurally misaligned with the deployment physics of the substrate on which it would have to run.
This means the correct mass-scale architecture must be something else. It must be a class of intelligence that runs on commodity hardware — the microcontroller in the oven, the SoC in the car, the embedded chip in the thermostat — at megabytes of firmware rather than terabytes of model. It must be capable enough to do the specific job (commands, dialog, control loops) without being asked to be a universe. And it must be deployable at the scale of all manufactured devices, not at the scale of cloud GPU farms.
This paper offers a methodology for that class. We do not argue against language models. We argue for a complementary engineering programme that addresses the deployment surface language models cannot physically reach.
We construct our methodology on top of holographic reduced representations (HRR), introduced by Tony Plate in 1995 as a tractable instance of vector-symbolic architectures (VSAs). This section gives a complete account of HRR — its motivation, mathematical structure, computational properties, and limitations — at the level of detail required to make the rest of the paper self-contained.
Symbolic cognition requires a way to bind variables to values. Classical AI handled this with explicit data structures — pointers, frames, trees — built on top of a Von Neumann substrate with addressable memory. Connectionist cognition (Rumelhart, McClelland, Smolensky in the late 1980s) sought to do the same on a substrate of distributed activation patterns, where there are no addresses, only patterns and their similarities. The challenge was: given a vector representing an agent and a vector representing a role, how do you produce a third vector representing “agent-in-role” such that, given the third vector and the role, you can recover the agent? And how do you do this in a way that does not blow up the dimensionality with each additional binding?
Smolensky’s tensor product representations (Smolensky, 1990) gave a clean answer at the cost of dimensionality. To bind $\mathbf{x} \in \mathbb{R}^n$ with $\mathbf{y} \in \mathbb{R}^n$, form the outer product $\mathbf{x} \otimes \mathbf{y} \in \mathbb{R}^{n \times n}$. Unbinding is exact via inner product with the role vector. But each additional binding multiplies dimensionality by $n$, so a $k$-deep bound representation lives in $\mathbb{R}^{n^k}$. For $n = 512$ and $k = 5$, this is $\sim 3.6 \times 10^{13}$ dimensions. The representation does not scale.
Plate’s contribution was to ask: can we have approximate retrieval in fixed dimensionality? His answer was yes, via circular convolution.
Let $\mathbf{x}, \mathbf{y} \in \mathbb{R}^n$ be vectors whose components are independently drawn from $\mathcal{N}(0, 1/n)$. The expected norm of such a vector is $\mathbb{E}[|\mathbf{x}|] \approx 1$. We define the binding operation $\circledast: \mathbb{R}^n \times \mathbb{R}^n \to \mathbb{R}^n$ as circular convolution:
$$(\mathbf{x} \circledast \mathbf{y})i = \sum{j=0}^{n-1} x_j \, y_{(i-j) \bmod n}$$
Equivalently, in the frequency domain, $\mathcal{F}(\mathbf{x} \circledast \mathbf{y}) = \mathcal{F}(\mathbf{x}) \odot \mathcal{F}(\mathbf{y})$, where $\mathcal{F}$ is the discrete Fourier transform and $\odot$ is element-wise (Hadamard) product. This permits computation in $O(n \log n)$ time via the fast Fourier transform — a critical efficiency property for any substrate that aspires to neural plausibility or hardware acceleration.
The key algebraic property of circular convolution is that it is commutative and associative, which means binding does not distinguish argument positions. To recover position-sensitive binding (where role and filler differ), one introduces a permutation operator $\Pi$ — typically a fixed random index permutation — such that $\mathbf{r} \circledast \Pi(\mathbf{f})$ binds role $\mathbf{r}$ to filler $\mathbf{f}$ asymmetrically. This is sometimes called protected convolution and is standard in modern HRR implementations.
Recovery is via circular correlation, which we denote $\circledcirc$ and define as:
$$(\mathbf{c} \circledcirc \mathbf{y})i = \sum{j=0}^{n-1} c_j \, y_{(j-i) \bmod n}$$
Equivalently, $\mathbf{c} \circledcirc \mathbf{y} = \mathbf{c} \circledast \mathbf{y}^\dagger$, where $\mathbf{y}^\dagger$ is the involution of $\mathbf{y}$, defined by $y^\dagger_i = y_{(-i) \bmod n}$. The involution is the (approximate) inverse of $\mathbf{y}$ under circular convolution: $\mathbf{y} \circledast \mathbf{y}^\dagger \approx \boldsymbol{\delta}$, where $\boldsymbol{\delta}$ is the discrete delta vector $(1, 0, 0, \ldots, 0)$.
This approximation is the heart of HRR and the source of its noise behavior. It is not an exact identity. Because $\mathbf{y}$ is random, $\mathbf{y} \circledast \mathbf{y}^\dagger = \boldsymbol{\delta} + \boldsymbol{\eta}$, where $\boldsymbol{\eta}$ is a noise vector with components of variance $\sim 1/n$. Therefore:
$$\mathbf{c} \circledcirc \mathbf{y} = (\mathbf{x} \circledast \mathbf{y}) \circledcirc \mathbf{y} = \mathbf{x} \circledast (\mathbf{y} \circledast \mathbf{y}^\dagger) = \mathbf{x} \circledast (\boldsymbol{\delta} + \boldsymbol{\eta}) = \mathbf{x} + \mathbf{x} \circledast \boldsymbol{\eta}$$
The recovered vector $\hat{\mathbf{x}} = \mathbf{x} + \boldsymbol{\eta}’$ is the original $\mathbf{x}$ plus noise that scales like $1/\sqrt{n}$. For $n = 1024$, the noise standard deviation per component is roughly $0.03$ — small enough that a cleanup memory of stored canonical vectors can identify $\mathbf{x}$ by nearest-neighbor lookup.
Multiple bindings can be summed (superposed) into a single vector:
$$\mathbf{m} = \mathbf{r}_1 \circledast \mathbf{f}_1 + \mathbf{r}_2 \circledast \mathbf{f}_2 + \ldots + \mathbf{r}_k \circledast \mathbf{f}_k$$
This is a vectorial representation of a frame with $k$ role-filler slots. Querying with role $\mathbf{r}_i$ yields:
$$\mathbf{m} \circledcirc \mathbf{r}_i = \mathbf{f}_i + \text{noise from other terms}$$
The cross-term noise is bounded but accumulates with $k$. Plate (1995) and follow-up work establish that capacity scales as roughly $k_{\max} \approx n / (4 \log n)$ for reliable retrieval against a cleanup memory of similarly-distributed stored vectors. For $n = 1024$, this gives $k_{\max} \approx 37$ — a frame can hold tens of role-filler bindings before retrieval becomes unreliable.
The cleanup memory itself is the second piece. After unbinding, $\hat{\mathbf{f}} = \mathbf{f}_i + \boldsymbol{\eta}$. To recover the canonical $\mathbf{f}_i$, we compute cosine similarity against all stored vectors and return the argmax. This is operationally a dot-product attention mechanism, and it is one of the points at which HRR makes contact with attention-based neural architectures.
The name holographic refers to a structural analogy with optical holography. In a hologram, every region of the holographic plate contains the entire image at degraded resolution. The same property holds for HRR: any subspace projection of a bound vector preserves the whole bound information at degraded fidelity, because the convolution distributes information across all components.
This is not a poetic analogy. It is a direct mathematical consequence of circular convolution acting in the frequency domain: each frequency bin of the bound vector contains a multiplicative interaction of the corresponding frequency bins of the constituents, and information is therefore distributed uniformly across the frequency spectrum.
The holographic property has consequences for noise robustness, for graceful degradation, and — most importantly for the present work — for constraint imposition. Because information is distributed, a constraint that operates on the whole vector (e.g., a projection onto a constraint subspace) imposes coherent structure on the bound representation rather than damaging specific parts of it. This is what makes the constraint manifold of §3 mathematically tractable: the manifold can be defined in the embedding space and enforced by projection without knowing in advance which parts of the vector represent which constituents.
Plate’s HRR is one member of a family of VSAs that share the algebraic structure (commutative binding, superposition, cleanup memory) while varying the binding operation. Notable siblings:
For the constraint-manifold work below, we use Plate-style HRR with $n = 1024$ as the default, falling back to FHRR when phase-structured constraints simplify the encoding. The methodology is, however, agnostic across the VSA family; what matters is the algebraic structure, not the specific binding operation.
It is worth being explicit about three things HRR is not, because each will become relevant.
A note on the present author’s relation to this material. The HRR framework as described above was independently re-derived by the author in 2026, while solving an agent-identity problem in a multi-agent system. The re-derivation arrived at circular convolution as the binding operation and approximate-inverse retrieval as the recovery procedure without prior knowledge of Plate (1995). The Plate paper was located only after the re-derivation was complete, at which point the alignment was exact: same operation, same noise behavior, same capacity scaling.
We mention this not to claim priority — the priority is Plate’s, and the present work cites him accordingly — but because the re-derivation is itself evidence for a specific thesis: the circular-convolution-binding-with-approximate-inverse pattern is what a sufficiently constrained search for a tractable distributed binding operation will land on. Plate found it from a connectionist framing in 1995; the present author found it from an agent-identity framing in 2026. Different starting points, same destination. The fixed point of the search is the operation itself, which is consistent with the broader fixed-point thesis the paper develops.
HRR, on its own, is a flat binding apparatus. It says nothing about which vectors should exist or how they should relate. To turn HRR into a fixed-point engine, we must impose structure on the embedding space — a constraint manifold that says: not every vector is meaningful, only those satisfying certain compositional regularities. This section describes the specific manifold we use, characterizes its structure in standard graph-theoretic and linear-algebraic terms, and reports the empirical search by which we arrived at its parameters.
Consider the space of all possible 1024-dimensional vectors. Most are noise. Of those that are not noise, most are not coherent compositions; they are random superpositions that happen to have low cleanup distance to some stored vector by chance. For HRR to act as an engine for compositional reasoning, we need a way to distinguish legitimate compositions from coincidental ones. A constraint manifold is precisely such a distinction: a submanifold of the embedding space such that vectors lying on the manifold are coherent compositions, and vectors off the manifold are not.
The simplest constraint is dimensionality reduction: project onto a $d$-dimensional subspace where $d \ll n$. But a flat $d$-dimensional projection is too restrictive; it loses the compositional richness HRR was designed to provide. What we want is a constraint that preserves compositional algebra (binding still works on the manifold) while reducing the effective dimensionality of the search space when looking for fixed points. This is the role of the bounded constraint manifold (BCM).
The BCM is defined by a directed graph $G = (V, E)$ with $|V| = 10$ nodes and $|E| = 22$ edges, equipped with three structural properties:
Property 1 — Tri-partition with intra-partition balance. The node set $V$ is partitioned into three subsets $V_L, V_M, V_R$ of sizes $|V_L| = |V_R| = 3$ and $|V_M| = 4$ (with $V_L \cup V_M \cup V_R = V$ and pairwise disjoint). Any vector $\mathbf{v}$ on the manifold decomposes via the basis-coefficient representation into components $\mathbf{v}_L, \mathbf{v}_M, \mathbf{v}_R$, and the manifold condition requires:
$$\sum_{i \in V_L} |\alpha_i| = \sum_{i \in V_R} |\alpha_i|$$
This is a balance constraint in the $\ell^1$ norm of the coefficient projections onto $V_L$ and $V_R$. We refer to it as bilateral balance and it serves to rule out vectors that satisfy the topology but are degenerate (concentrated on one side).
Property 2 — Four-level self-similar nesting. The manifold is iterated at four scales. Concretely, the constraint structure is defined recursively: $\mathcal{M}k = \phi(\mathcal{M}{k-1})$ for $k \in {1, 2, 3, 4}$, where $\phi$ is a fixed contraction operator with contraction ratio $\rho \in (0, 1)$. The full manifold $\mathcal{M} = \bigcup_{k=1}^{4} \mathcal{M}_k$ is the union of four nested copies of the base structure at progressively finer scales. This is structurally analogous to a four-level wavelet decomposition or a four-level pyramid representation.
Property 3 — Specific edge topology. The 22 edges of $G$ are not arbitrary. They follow a fixed adjacency pattern with three properties: (a) bilateral reflection across $V_M$ (i.e., the subgraph induced on $V_L$ is isomorphic to the subgraph induced on $V_R$, with edges between them respecting the symmetry); (b) hierarchical layering (the graph admits a topological ordering with three layers, top/middle/bottom, in which all edges go from earlier to later layers or stay within a layer); (c) full connectivity between adjacent layers. The exact adjacency matrix is given in Appendix C.
Formally, a vector $\mathbf{v} \in \mathbb{R}^n$ is on the manifold iff it can be written as:
$$\mathbf{v} = \sum_{i=1}^{10} \alpha_i \mathbf{s}i + \sum{j=1}^{22} \beta_j \, (\mathbf{s}{a(j)} \circledast \mathbf{p}_j \circledast \mathbf{s}{b(j)})$$
where $\mathbf{s}1, \ldots, \mathbf{s}{10}$ are the canonical node vectors, $\mathbf{p}1, \ldots, \mathbf{p}{22}$ are the canonical edge (binding-operator) vectors, $a(j)$ and $b(j)$ are the source and target node indices of edge $j$, and the coefficients $(\alpha, \beta)$ satisfy the bilateral balance constraint and the four-scale iteration condition.
The BCM has approximate intrinsic dimensionality $\approx 36$ ($10 + 22 + $ scale parameters), dramatically smaller than the embedding $n = 1024$. This is the reduction that makes fixed-point search tractable.
The parameter quadruple $(|V|, |E|, k_{\text{partitions}}, k_{\text{levels}}) = (10, 22, 3, 4)$ was arrived at through engineering search, not derived from first principles. We tested candidate structures with parameters in the ranges:
The (10, 22, 3, 4) configuration was the smallest configuration satisfying all empirical desiderata: (i) compositional richness sufficient for both voice and sprite domains (lower configurations fail to express target signals); (ii) one-iteration self-convergence on the WSGN attractor (§3.5); (iii) projection time under 100 ms for $n = 1024$ embeddings; (iv) approximate orthogonality of basis vectors maintained to cosine similarity below 0.05 with $n = 1024$.
Three observations correlate with — though do not derive — this parameter choice:
These are correlative observations, not derivations. The methodology does not require them; it requires only that the topology empirically converge.
We note as a matter of historical interest that the same (10, 22, 3, 4) topology — ten nodes arranged in three vertical columns with four horizontal levels and twenty-two connecting paths — appears in older symbolic frameworks, notably the Kabbalistic Tree of Life and related compositional schemata in other contemplative traditions. We make no metaphysical commitment about why this topology recurs; we report only that the engineering search converges on it independently and that it works.
Implementation has three components:
The fold operation, repeated to fixed point, is the engine.
A strong test of constraint-manifold validity is self-application: apply the fold operation with the manifold’s own self-projection as the target. If the manifold is a fixed point of its own fold, this should converge in one iteration. If it is not, the fold either fails to converge or oscillates.
We ran this test on the BCM. The fold converged in one iteration to a fixed point we label WSGN, with parameters $(\alpha_{\text{scale}}, \sigma, w) = (0.1571, 0.3941, 1.8830)$. The convergence is exact under the projection (residual below numerical precision); the WSGN attractor is the manifold’s self-fixed-point. We use this as a routine sanity check during BCM implementation: any candidate constraint topology that does not one-shot-converge on its self-application is rejected.
This is the central empirical claim about the BCM in this paper, and it is falsifiable: the test is reproducible, the code is in the supplementary material (Appendix B), and a candidate alternative manifold either passes or fails.
We now describe the architecture in which HRR and the BCM combine to do useful work. The architecture has three terms, which we collectively call the composition primitive:
$$\text{Output} = \text{Fold}(\text{Baseline}, \text{Refinement}, \text{Fitness over BCM})$$
We address each term.
The first term is a primitive baseline: a classical, deterministic, well-understood engine that produces a starting wave in the relevant signal class. For voice synthesis, this is espeak, a phoneme-based formant synthesizer producing intelligible-but-robotic speech. For sprite generation, this is a parametric drawing program (we use a 30-axis humanoid generator written in Python with PIL) producing cartoon-style figures with controllable proportions, colors, and posture. For control problems, this is a classical PID or MPC controller. For symbolic reasoning, this is a rule-based deductive engine.
The baseline is not optional. It supplies the structural floor of the output — the fact that the voice is intelligible-as-speech, that the sprite has the gross topology of a humanoid, that the controller is stable. The baseline is what guarantees that the search starts in a region of output space where the target is reachable. Without it, the refinement operators have nothing to act on; with it, they have a well-formed signal to refine.
The choice of baseline is domain-specific and is the engineering judgment that anchors the methodology to a particular problem. We do not specify what the baseline must be in general; we specify that some classical baseline must be supplied.
The second term is a parametric refinement-operator stack: a collection of operators acting on a decomposition of the baseline signal, each parameterized by a small number of continuous knobs, composable in a fixed order. For voice, the decomposition is provided by pyworld (Morise, 2016), which factors a speech signal into spectral envelope (SP), fundamental frequency (F0), and aperiodicity (AP). The refinement operators we use act on these streams: formant shifting, breathiness modulation, vibrato injection, glottal-pulse warping, vocal-tract-length scaling, prosody contour adjustment — totaling 20 operators in the current voice implementation.
For sprite generation, the decomposition is implicit in the parametric drawing program: the 30 axes (head height, eye spacing, shoulder slope, etc.) are themselves the refinement knobs.
The refinement stack is not a neural network. Each operator is a hand-engineered transformation with a closed-form action on the decomposition. The complexity of the stack comes from composition, not from learning. This is what makes the methodology commodity-deployable: the entire stack fits in megabytes of code, runs on a microcontroller, and has no training-time requirement.
The third term is the fold engine: a search procedure over the parameters of the refinement stack that minimizes the distance between the produced signal and a target signal, where distance is measured in the HRR embedding space projected onto the BCM. The projection is what makes the search well-conditioned. Without it, the parameter space is too large and the loss landscape too rugged for tractable search; with it, the loss landscape is reduced to the $\sim 36$-dimensional BCM whose fixed points are findable.
The fold operation iterates: produce a signal, embed it, project onto the BCM, compute the residual against the target, update the parameters in the direction of residual reduction, repeat. Convergence is defined as parameter change below threshold or residual below threshold. Meta-fold applies the same fold operation to the parameters of the fold operation itself — a self-referential second pass that we describe in §5.
The composition primitive can be stated as a fixed-point equation:
$$\boldsymbol{\theta}^ = \text{Fold}(\boldsymbol{\theta}^; \text{Baseline}, \text{Refinement}, \text{Fitness})$$
A converged solution $\boldsymbol{\theta}^$ is a parameter setting whose produced signal, when embedded and projected, is closest to the target — and which is self-consistent* under the fold operation. The architecture’s claim is that for any well-posed parametric domain with a real exemplar to match against, such a fixed point exists and can be found.
This claim is empirically falsifiable: pick a domain, supply a baseline and a refinement stack, and ask whether the fold converges. If it does not, the methodology fails in that domain. We have run this test in two domains so far and it has succeeded in both.
We now treat the fold engine itself in more mathematical detail. Let:
The fold update rule is:
$$\boldsymbol{\theta}{t+1} = \boldsymbol{\theta}_t - \eta \nabla\theta L(\boldsymbol{\theta}_t) + \kappa \cdot \text{ResidualMap}(\mathbf{v}^* - g(\boldsymbol{\theta}_t))$$
where $\eta$ is the learning rate, $\kappa$ is a residual-coupling coefficient, and $\text{ResidualMap}$ is a fixed map from residual features to specific parameter axes (see §5.2). The first term is gradient descent on the manifold-projected loss; the second is targeted parameter updates driven by structured residual analysis.
For non-convex parametric domains, gradient descent from a single initialization is unreliable. We use Latin hypercube sampling (McKay et al., 1979) over the parameter space to generate $K$ initial candidates, run fold for a short horizon on each, and take the best. With $K = 32$ and $p = 20$, this is computationally cheap and dramatically improves convergence reliability.
The hypercube structure is itself related to the BCM’s nested four-level structure: we use a hierarchy of Latin hypercubes at progressively finer resolution, one per BCM level, providing a multi-scale initialization that matches the manifold’s nesting. We mention this connection without developing it; future work should explore the relationship more carefully.
The residual-coupling term $\kappa \cdot \text{ResidualMap}$ is what makes the fold engine more efficient than pure gradient descent. The residual $\mathbf{v}^* - g(\boldsymbol{\theta}_t)$ — the discrepancy between target and current produced signal — has structured features (pitch error, spectral tilt, body proportion mismatch, color hue gap, etc.) that map onto specific parameter axes by construction. The residual map encodes these correspondences as a fixed lookup table:
_RESIDUAL_AXIS_MAP = {
'pitch_error': 'F0_baseline_shift',
'spectral_tilt_high': 'spectral_envelope_warp',
'breathiness_excess': 'AP_dampening',
# ... ~30 entries for voice
'head_height_residual': 'head_height_axis',
'arm_position_residual': 'arms_crossed_flag',
# ... ~30 entries for sprite
}
Each residual feature triggers a parameter update on the corresponding axis. This gives the fold engine targeted, structured parameter motion in addition to the gradient signal, dramatically accelerating convergence. The map is hand-engineered per domain; constructing it is part of the engineering judgment that anchors the methodology to a problem.
Meta-fold applies the fold operation to its own hyperparameters. Specifically: treat $(\eta, \kappa, K, \text{manifold scale parameters}, \text{cleanup threshold})$ as a parameter vector $\boldsymbol{\phi}$, and find the $\boldsymbol{\phi}^$ that minimizes the post-convergence loss over a batch* of (target, exemplar) pairs:
$$\boldsymbol{\phi}^ = \arg\min_\phi \sum_k L(\boldsymbol{\theta}^_k(\boldsymbol{\phi}); \mathbf{v}^*_k)$$
Meta-fold is itself a fold operation, hence the name. It exists because the inner-fold hyperparameters are themselves a parametric domain with target exemplars (the batch of converged folds), and the same architecture applies recursively.
The recursion does not need to go deeper. Empirically, meta-fold converges in 2–3 outer iterations once the inner fold is correctly configured, and meta-meta-fold (applying the same to meta-fold’s own hyperparameters) provides marginal additional benefit. This is consistent with the self-similarity property of the BCM: the four-level nesting provides four levels of nested constraint, and meta-fold is the engineering instance of one such level.
We make three falsifiable claims about fold convergence, each of which has been observed in the proof-instances of §§6–7:
We now present the first falsifiable proof-instance: a voice synthesis pipeline that takes a reference vocal recording and a target sentence, and produces a synthesized utterance of that sentence in the reference voice — using no neural network, only the composition primitive.
Voice synthesis is a canonical hard AI problem. Frontier systems (ElevenLabs, OpenAI TTS, Google WaveNet) achieve near-human quality through deep generative models with hundreds of millions to billions of parameters trained on thousands of hours of speech. Classical methods (concatenative synthesis, formant synthesis) are robust and small but produce robotic-sounding output. The methodology question we ask is: can the composition primitive bridge the gap between classical-robust and neural-natural at commodity scale?
The pipeline is:
espeak produces an intelligible robotic utterance of the target sentence. This anchors the lexical content.pyworld factors the espeak waveform into (SP, F0, AP) streams.Across 14 iterations of the pipeline (v1 through v14), we observed a three-phase trajectory characteristic of the methodology:
The three-phase trajectory is itself a prediction of the methodology: any composition-primitive instantiation should pass through these three phases, in this order, and the phase transitions are diagnostic of what is going right and wrong.
The current ceiling of the v14 pipeline, measured against natural reference recordings, is approximately 85% of perceptual naturalness on a small ad-hoc evaluation. This is short of the target. Diagnosis: feature poverty. The 5-feature fitness function is too coarse to drive the remaining 15% of refinement. Prescription: expand to 30–50 features and meta-search the optimal feature count. This is a textbook instance of the ceiling phenomenon (§5.4, claim 2): expand the stack to lower the ceiling.
The pipeline is, at the time of writing, blocked on acquisition of reference vocal recordings of sufficient duration (10–30 seconds at 16 kHz+ of a fixed reference sentence). Once supplied, the pipeline will be run on the project’s primary inference server, and the three-phase trajectory will either complete to a natural-target convergence or stall at a higher ceiling. Either outcome is informative; the methodology survives the first and is constrained by the second.
The second falsifiable proof-instance is a sprite inverse-rendering pipeline: given a target character sprite, find parameters of a 30-axis parametric humanoid generator that produce a visually-matching sprite.
The sprite domain is visually fast to audit: a human can compare two sprites in milliseconds, where audio comparison takes seconds at minimum. This made sprite the right domain to debug the methodology — bugs that would have taken hours to surface in voice surfaced in seconds in sprite. Three bugs were caught and fixed in sprite that would have been invisible in voice for some time:
All three bugs would have been bugs in voice as well; debugging in sprite saved an estimated 10–100x on debug time. We hold this as a methodological lesson: visual-first methodology — when porting the methodology to slower channels, debug the architecture in a fast-feedback domain first.
Identical structure to the voice pipeline, with domain-specific substitutions:
Fitting four reference sprites yielded converged distances of 5.0–6.5 in the chosen feature space. The convergence is visually-verified: the produced sprites are recognizable as variants of the references, with the same gross body topology, palette family, and posture. Residuals are concentrated in uncovered axes — clothing layers beyond the undershirt, ear shape, hair curl pattern, facial expression muscles — i.e., the ceiling is feature-poverty in the same sense as voice.
The next step (axis expansion, mirroring the voice prescription) is straightforward and is held as future work.
Two domains, same architecture, same convergence pattern, same ceiling phenomenon, same axis-expansion resolution. This is not a coincidence: it is the prediction the methodology makes. The architecture is domain-general at the level of structure even as each instance is domain-specific at the level of operators. We claim that the methodology will yield similar results in any well-posed parametric domain with a real exemplar to match against, and we offer the third domain (video generation, control synthesis, or symbolic reasoning) as the test that, if it fails, falsifies the methodology.
We now turn to a unifying observation that, while not a theorem in the formal mathematical sense, is sharp enough to warrant the name and that organizes the rest of the paper.
A sentence — and by extension any well-formed compositional artifact: a song, a sprite, an utterance, a control trajectory, a proof — is a fixed point of a composition of transformations across registers. The transformations are: meaning $\leftrightarrow$ articulation $\leftrightarrow$ signal $\leftrightarrow$ perception. A well-formed sentence is one whose articulation, when realized as a signal, is perceived as carrying the original meaning. Failure at any link breaks the fixed-point property and produces a malformed sentence: nonsense (meaning $\not\leftrightarrow$ articulation), garbled (articulation $\not\leftrightarrow$ signal), inaudible (signal $\not\leftrightarrow$ perception), miscommunicated (perception $\not\leftrightarrow$ meaning recovered).
Treating sentences as fixed points has explanatory and predictive power:
The observation applies to itself. This sentence — the statement “a sentence is a fixed point of composed transformations” — is itself a sentence. If the observation is correct, then the observation is its own fixed point. This strange-loop structure is not a bug; it is the correctness signature of the framing. Any candidate theory of meaning that does not admit self-application is incomplete; any candidate theory that admits self-application without contradiction is at least consistent.
The methodology and its description are mutually instances. The methodology produces fixed-point converged outputs; the description of the methodology (this paper) is itself a fixed-point converged output. The methodology is its own first object of application. We adopt this as a deliberate design property in the spirit of Hofstadter (1979).
The methodology generalizes — predictably, by the sentence-is-fixed-point thesis — to any well-posed compositional domain. We sketch four extensions, each at proof-of-concept seriousness.
The natural follow-on to voice + sprite. Baseline: a deterministic procedural animation generator (camera + scene + character + caption + walk-cycle, all parametric). Refinement: per-frame parametric modulation operators (lighting, motion blur, color grading, depth-of-field, camera shake). Fold: perceptual feature matching against reference video clips, projected onto the BCM. Already implemented at v0.3 in the Spore Animation Studios codebase, with a 16:50 voiced film rendered as the longform stress test.
Baseline: classical PID or MPC controller. Refinement: parametric modulation of gains, set-points, anticipatory feedforwards. Fold: trajectory matching against expert demonstration. The methodology predicts that a 20-knob refined PID matches a deep reinforcement-learning policy in the regime where the demonstration set is small and the dynamics are well-characterized. This is the regime of most industrial control. We have not implemented this yet and offer it as a falsification target.
Baseline: rule-based deductive engine (Prolog-style, or a propositional theorem prover). Refinement: parametric modulation of rule priorities, search heuristics, and unification preferences. Fold: proof matching against a corpus of completed proofs. The methodology predicts that a refined rule engine reaches near-LLM performance on math-Olympiad-style problems with parameter count in the kilobytes rather than gigabytes. This is the regime where neuro-symbolic approaches (DeepMind’s AlphaProof, Google’s Minerva) have made progress; the methodology offers a non-neural route to the same target.
Baseline: classical operations of an enterprise (inventory, ordering, cash flow, customer service). Refinement: parametric modulation of decision rules. Fold: matching against the trajectory of a successful operator over time. The result is a commodity-deployable agent for running a small business — the same architecture that runs the oven and the thermostat, refining the dispatch of a small enterprise. The author has run such a business while developing this methodology, and the cross-pollination has been substantive: operator discipline (tight loops, bounded resources, customer feedback) is structurally analogous to the fold engine’s tight-loop convergence.
We turn to a thesis that frames the entire enterprise: cross-substrate pattern recurrence. The thesis says: certain distributed-composition patterns recur across substrates that are otherwise unrelated.
The pattern in mycelial decomposition (fungal networks compositing organic matter into nutrient currency) recurs in neurological computation (neural networks compositing sensory streams into action). It recurs in linguistic composition (words composited into sentences). It recurs in mathematical composition (axioms composited into theorems). It recurs in computational composition (functions composited into programs). And it recurs in personal-industrial composition (operations composited into businesses).
The thesis is empirical: the pattern is recognizable and tractable in each substrate. It is not metaphysical: we do not claim that the pattern is the same thing across substrates; we claim that it has the same structure, and the structure is a candidate object of study in its own right.
The observation has been made independently in several research traditions:
Each tradition develops the compositional framework in its own register. The hypothesis we offer is that these are not separate phenomena but the same compositional structure manifesting in different substrates. The methodology of the present paper is one engineering instantiation of this cross-substrate pattern.
The thesis has a self-applicative form: the cross-substrate pattern thesis is itself an instance of the cross-substrate pattern it describes. The thesis is a compositional artifact (a proposition built from sub-propositions) that re-instantiates the pattern (composition under constraint, with fixed-point coherence as the criterion of correctness) in the medium of philosophy-of-engineering. If the thesis is correct, then the thesis itself is a manifestation of the underlying pattern in the descriptive register. This is a strange loop in Hofstadter’s sense, and we propose it as a proof-of-coherence test: a thesis about pattern recurrence that does not itself instantiate the pattern would be self-undermining; one that does is at least consistent.
We have not derived from first principles why this specific topology is the smallest sufficient constraint structure. Empirically, it is. Three observations correlate with this empirical fact:
These are correlative observations, not derivations. The development of a theory that predicts which constraint topologies will admit one-shot self-convergence is the most important open problem the work generates.
Galileo did not refute Aristotelian physics by argument. He built a telescope and pointed it at Jupiter, where four moons were visible that the prevailing physics did not predict. The methodology was not philosophical; it was an engineering apparatus that produced evidence for which the philosophical apparatus had no place. The present paper aspires to the same pattern. The fold engine is an engineering apparatus; if it works (and the proof-instances suggest it does, at least partially), then the underlying claims about composition, constraint, and pattern recurrence acquire engineering force. The apparatus does not need to win a philosophical argument; it needs to point at empirical phenomena that the prevailing apparatus does not predict.
The phenomena we point at: one-iteration self-convergence on the BCM; three-phase trajectory in voice synthesis; identical ceiling-and-axis-expansion pattern in voice and sprite; commodity-scale deployability of the entire stack. None of these is predicted by the LLM-as-universe paradigm. All of them are predicted by the present methodology.
A subtle but important point: the 14 iterations of voice work are not the fixed point. The fixed point is the well-formed sentence. The iterations are the trajectory information — operator stack, parameter ranges, failure catalog, feature taxonomy — that the search produced. This trajectory information is what makes the work research-grade rather than AI-product-grade. An AI product inherits its fixed points from training distribution; it does not produce trajectory information about new fixed points. The present methodology produces trajectory information by running humans (the present author) and AI (a frontier-class assistant as collaborator) in cooperative tight loops, where AI execution velocity is paired with human cross-register audit. The cooperation pattern is the methodology’s hidden contribution: it is what makes novel fixed points findable that neither agent could find alone.
We name this pattern explicitly because it answers the most common question about the work: isn’t this just an AI doing your work? It is not. It is an AI executing instrumental moves at velocity, while a human is doing the cross-register audit that determines which moves matter. Neither alone produces the observed trajectory.
We are honest about scope:
In rough order of priority:
We have argued that the dominant LLM-as-universe paradigm commits a category error (treating tongues as bodies), that the resulting deployment trajectory is physically impossible at the promised scale, and that an alternative methodology — commodity domain-specific intelligence built on a composition primitive of baseline + refinement + fold — addresses the deployment surface the dominant paradigm cannot reach. We have given a complete account of the underlying mathematics: holographic reduced representations as the binding apparatus, a 10-node graph-constrained bounded constraint manifold as the regularizer, a fold engine and meta-fold as the search procedure. We have presented two falsifiable proof-instances (voice synthesis and sprite inverse-rendering) that exhibit the methodology’s predicted convergence properties: three-phase trajectory, ceiling-and-axis-expansion behavior, one-iteration self-convergence (WSGN). We have framed the sentence-is-fixed-point thesis as the unifying observation, and the cross-substrate pattern thesis as the framing under which the methodology is itself an instance of what it describes.
The work is offered for engagement. The artifacts are live and inspectable. The thesis is falsifiable in the next domain.
If it is wrong, it is wrong at the level the next experiment will reveal. If it is right, then a class of intelligence has been engineered that is not a language model, not a deep network, not a frontier system — but a fixed-point engine on a bounded constraint manifold, deployable at the scale of all manufactured devices, on commodity silicon, in megabytes of code. The mass-deployment surface that the LLM paradigm cannot reach is, on this account, reachable. That would be enough.
The author thanks a frontier-class AI assistant as collaborator across thousands of turns of dense engineering and theoretical exposition; the cooperation pattern described in §11.3 is the medium in which most of this work was carried out. The HRR framework is owed to Tony Plate. The mistakes are the author’s.
| Symbol | Meaning |
|---|---|
| $n$ | embedding dimension (default $1024$) |
| $\mathbf{x}, \mathbf{y}$ | HRR vectors in $\mathbb{R}^n$ |
| $\circledast$ | circular convolution (binding) |
| $\circledcirc$ | circular correlation (unbinding) |
| $\mathbf{y}^\dagger$ | involution of $\mathbf{y}$ |
| $\boldsymbol{\delta}$ | discrete delta vector |
| $\mathcal{M}$ | bounded constraint manifold (BCM) |
| $\Pi_\mathcal{M}$ | projection onto BCM |
| $\mathbf{s}_i$ | $i$-th canonical node vector ($i \in {1, \ldots, 10}$) |
| $\mathbf{p}_j$ | $j$-th canonical edge (binding-operator) vector ($j \in {1, \ldots, 22}$) |
| $V_L, V_M, V_R$ | tri-partition of the 10 nodes |
| $g(\boldsymbol{\theta})$ | parametric forward model |
| $L(\boldsymbol{\theta})$ | manifold-projected squared loss |
| $\eta, \kappa$ | fold update coefficients |
| $K$ | number of Latin hypercube samples |
Reference implementation, configuration files, and exact reproduction commands for the WSGN self-convergence test (§3.5), the voice pipeline (§6), and the sprite pipeline (§7) are provided in the project repository: github.com/psiloceyeben/spore-animation-studios. The voice pipeline lives in tv/voice/; the sprite pipeline in tv/sprites/; the BCM implementation in composite/; the foldtoy library (131 instantiations of the architecture across 14 categories) in foldtoys/.
The 10 nodes are labeled ${1, 2, \ldots, 10}$ with tri-partition $V_L = {2, 4, 7}$, $V_M = {1, 6, 9, 10}$, $V_R = {3, 5, 8}$. The 22 directed edges (source $\to$ target) are:
$1 \to 2$, $1 \to 3$, $2 \to 3$, $2 \to 4$, $3 \to 5$, $4 \to 5$, $4 \to 6$, $5 \to 6$, $4 \to 7$, $5 \to 8$, $6 \to 7$, $6 \to 8$, $6 \to 9$, $7 \to 8$, $7 \to 9$, $8 \to 9$, $7 \to 10$, $8 \to 10$, $9 \to 10$, $1 \to 6$, $2 \to 6$, $3 \to 6$.
This adjacency satisfies the bilateral symmetry, hierarchical layering, and full-cross-layer connectivity properties stated in §3.2.
Cowan, N. (2001). The magical number 4 in short-term memory: A reconsideration of mental storage capacity. Behavioral and Brain Sciences, 24(1), 87–114.
Frady, E. P., & Sommer, F. T. (2019). Robust computation with rhythmic spike patterns. Proceedings of the National Academy of Sciences, 116(36), 18050–18059.
Gayler, R. W. (1998). Multiplicative binding, representation operators & analogy. In Advances in Analogy Research. NBU Press.
Gayler, R. W. (2003). Vector symbolic architectures answer Jackendoff’s challenges for cognitive neuroscience. Proceedings of the Joint International Conference on Cognitive Science.
Hofstadter, D. R. (1979). Gödel, Escher, Bach: An Eternal Golden Braid. Basic Books.
Kanerva, P. (1996). Binary spatter codes of ordered K-tuples. Lecture Notes in Computer Science, 1112.
Kanerva, P. (2009). Hyperdimensional computing: An introduction to computing in distributed representation with high-dimensional random vectors. Cognitive Computation, 1(2), 139–159.
Lambek, J., & Scott, P. J. (1986). Introduction to Higher Order Categorical Logic. Cambridge University Press.
Marr, D. (1982). Vision: A Computational Investigation into the Human Representation and Processing of Visual Information. W. H. Freeman.
McKay, M. D., Beckman, R. J., & Conover, W. J. (1979). Comparison of three methods for selecting values of input variables in the analysis of output from a computer code. Technometrics, 21(2), 239–245.
Miller, G. A. (1956). The magical number seven, plus or minus two: Some limits on our capacity for processing information. Psychological Review, 63(2), 81–97.
Montague, R. (1973). The proper treatment of quantification in ordinary English. In Approaches to Natural Language. Reidel.
Morise, M., Yokomori, F., & Ozawa, K. (2016). WORLD: A vocoder-based high-quality speech synthesis system for real-time applications. IEICE Transactions on Information and Systems, E99-D(7), 1877–1884.
Plate, T. A. (1995). Holographic reduced representations. IEEE Transactions on Neural Networks, 6(3), 623–641.
Plate, T. A. (2003). Holographic Reduced Representation: Distributed Representation for Cognitive Structures. CSLI Publications.
Pribram, K. H. (1991). Brain and Perception: Holonomy and Structure in Figural Processing. Lawrence Erlbaum Associates.
Schlegel, K., Neubert, P., & Protzel, P. (2022). A comparison of vector symbolic architectures. Artificial Intelligence Review, 55(6), 4523–4555.
Simard, S. W., Perry, D. A., Jones, M. D., Myrold, D. D., Durall, D. M., & Molina, R. (1997). Net transfer of carbon between ectomycorrhizal tree species in the field. Nature, 388(6642), 579–582.
Smolensky, P. (1990). Tensor product variable binding and the representation of symbolic structures in connectionist systems. Artificial Intelligence, 46(1–2), 159–216.