A quick, arbitrary signal approximator that runs at population scale
The design intent, the seven-column anatomy, the math, the lineage, and what is genuinely new versus what is rediscovery.
Design intent
Cheap signal approximation. A population of generators in lockstep, each tuned to one slice of the signal landscape. One observer's encoder in the Distributed Reconstruction picture.
Amateur engineering project. No competitive claims. The combination presented here is structurally novel; the ingredients have heavy prior art and that is the point — every primitive has a name and a date earlier than this work, and the value is in how they snap together for one specific use.
SECTION 1 · DESIGN INTENT
What was being built
The original design statement, in the author's own words, was to build a very quick, arbitrary signal approximation generator. They can be run on a massive scale. Two design constraints sit underneath that statement, and a third behavioural property follows from running many of them together.
Quick
One tick of the clock equals one full approximation pass.
Sparse arithmetic only — no dense matrix multiplications anywhere on the inner loop.
Browser-runnable on a single CPU thread, audible output as a ground-truth check.
Stateless within a single tick.
Arbitrary signal
Tune the routing matrix and the per-row weights, and any target waveform on a finite span can be approximated.
Universal-approximator class on that span.
Driven by a phase clock, not by data — the generator does not look at any input vector to decide what to do.
Massive scale
One generator on its own is small. The design intent is to run a population of them — each tuned to a different patch of the signal space — in lockstep on a shared tick clock. The aggregate output of that population is the reconstruction the broader Distributed Reconstruction framework names. The single generator is the unit; the population is what does the work.
SECTION 2 · ANATOMY
Seven columns, left to right
Phase clock at the input, harmonic signal at the output. Each column is a small step; the seven together are the full forward pass.
Figure 1. The seven-column anatomy of one generator.
The clock at column one ticks out a phase value. The phase indexes a lookup table that returns a recipe vector — sparse, structured. The recipe selects rows of a routing matrix; the row vector multiplied by feature weights gives the activation, which is squeezed through standard nonlinearities, propagated through a small feed-forward network, and reassembled at column seven into the output sample. Repeat at the next tick.
SECTION 3 · THE MATH
Sparse matrix–vector multiply is the core operation
One sparse mat-vec per tick, optionally followed by an elementwise nonlinearity and a small dense feed-forward.
y(t) = σ( W · r(φ(t)) )
φ(t) : scalar phase from the clock at tick t
r(·) : LUT — phase → sparse recipe vector ∈ ℝᴺ
W : sparse routing matrix ∈ ℝᴹˣᴺ, density ρ ≪ 1
σ(·) : elementwise nonlinearity
y(t) : output activation vector at tick t
Why sparse mat-vec rather than dense matmul
The cost is proportional to the number of nonzeros in the routing matrix, not to its full size. With one percent density on a thousand-by-thousand matrix, the per-tick work is on the order of ten thousand multiply-adds rather than a million.
The nonzero pattern is fixed at compile time — recipe-shaped — which makes it vectorisable, cache-friendly, and trivial to dispatch on a GPU.
The same sparse-mat-vec kernel that runs here is the one that runs the hex-seven-color path of the Savanna engine. Same Metal kernel, same throughput class.
Output reassembly
Column seven sums the activations into harmonic basis coefficients, of the form s(t) = Σₖ aₖ(t) · cos(ωₖ·t + ψₖ). That sum is what the speakers play.
SECTION 4 · LUT RECIPES — THE INPUT LAYER
Recipes-as-LUT-entries, not random projections
This is the structurally distinctive piece of the design. Most prior art uses random sparse vectors at the input; the work here uses compositional, ranked recipes loaded into the LUT.
Recipe structure
LUT[φ] = recipe r = (i₁:w₁, i₂:w₂, …, i_k:w_k)
k = recipe arity (typically 6, matching the
6-bounded DAG substrate)
iⱼ = index into the feature space
wⱼ = recipe weight (compile-time, not learned)
recipe rank r.rank = longest dependency chain
in the compositional DAG that
produced this recipe
The recipe as a node in a compositional DAG
Figure 2. Each recipe is a node in a compositional DAG. The LUT entry for a phase is a leaf of that DAG; recipes share atoms and intermediate binds.
The sparse routing matrix
Figure 3. The routing matrix is mostly empty. Only a handful of cells per row are nonzero — the highlighted cells. Cost of W·r is proportional to the highlighted count, not to the full grid.
What is different from random projections
Random projection
r is independent identically distributed Rademacher, Gaussian, or sparse-Bernoulli.
No structure between recipes.
Johnson–Lindenstrauss guarantee in expectation; per-draw quality is luck.
Compositional recipes
r is a compiled DAG node, ranked by depth.
Recipes share substructure — atoms and intermediate binds are reused across recipes.
Deterministic — no luck-of-draw; the same phase always produces the same recipe.
The shared substructure is what lets a population of generators interpolate coherently between slices of the signal landscape, rather than each generator being an independent random throw at the same target.
SECTION 5 · ONE TICK, IN PSEUDOCODE
The forward pass
What the engine does for a single generator at a single tick.
# inputs: phi (phase), W (sparse), LUT (phase→recipe), basis# output: s (signal sample)def tick(phi, W, LUT, basis):
r = LUT[phi] # sparse recipe lookup
x = spmv(W, r) # O(nnz(W)) multiply-add
y = sigma(x) # elementwise nonlinearity
h = feedforward(y) # tiny MLP, 2 layers
s = basis @ h # harmonic reassemblyreturn s
# population scale:parallel for g in generators: # 10⁶ … 10¹¹ in flight
s[g] = tick(phi[g], W[g], LUT[g], basis[g])
# aggregate across the observer family:
recon = aggregate(s) # Σ across the family
The parallel for across generators is the design payoff. Every generator is independent within a tick, so the substrate maps directly onto GPU thread blocks — or, on the engine that hosts this work in production, onto hex-seven-color groups. Throughput scales linearly with hardware up to the sparse-mat-vec bandwidth ceiling.
SECTION 6 · THE DUAL DRAWING
The same arithmetic, drawn rule-based and as a deep network
This is the pedagogical move that makes the equivalence visible on a small enough example to fit in a browser tab.
Figure 4. Pipeline view (left) and deep-network view (right). The boxes are the pipeline stages; the nodes are the same stages drawn as a layered graph. The weighted edges are the nonzeros of the routing matrix.
Once the same seven-column computation is rendered both as a discrete pipeline (boxes connected by arrows) and as a layered graph (nodes connected by weighted edges), the difference between rule-based and neural-network stops being interesting. The ranked DAG of recipes is a layered graph; the layered graph is a pipeline that respects the rank order. The computation is one object; the two pictures are pedagogy.
SECTION 7 · HERITAGE
Each ingredient has named prior art
Famous-name comparisons, kept on the table. The combination presented here has its own shape; the parallels make the lineage real, not isolated.
Achlioptas2003Sparse Johnson–Lindenstrauss projections — sparse matrix as fast signal approximator. The sparse-mat-vec-as-encoder move.
Bingham & Mannila2001Random projection in dimensionality reduction. Same structural move, dense-with-zeros.
Olshausen & Field1996Sparse coding and dictionary learning. Signal as a sparse linear combination of atoms.
Albus (CMAC)1975Tile-coding — lookup table as input feature extractor. Cerebellar model articulation controller.
Weinberger et al.2009Hashing trick — sparse feature vectors via deterministic input mapping for ML at scale.
Rahimi & Recht2007Random Fourier features — fixed random projection plus elementwise nonlinearity approximates a kernel.
Shazeer et al.2017Sparse mixture-of-experts gating. Routing-pattern parallel to LUT row selection at scale.
FPGA LUT compilation1980s onwardCompositional LUT networks as the basic compute primitive on programmable hardware.
Kanerva (HDC)1988Hyperdimensional computing — sparse high-dimensional vectors with bind and unbind algebra.
Donoho · Candès · Tao2004–2006Compressive sensing — recover a signal from a small number of sparse linear measurements.
A long list of named priors is the antifragile signal here. The work sits on a real lineage; each ingredient is borrowed; the assembly is what is being claimed.
SECTION 8 · WHAT IS GENUINELY NEW
The honest novelty surface
Adversarial read. What holds, what is rediscovery, what is engineering.
Holds
Recipes-as-LUT over a ranked DAG. Most prior art uses random sparse vectors; this is structured compositional. Recipes share substructure via the DAG, not luck-of-draw.
Dual-drawing pedagogy. The same arithmetic rendered as a rule-pipeline and as a neural network side-by-side, on a small enough example to fit in a browser tab.
Browser-scale audible encoder demo tied to the Distributed Reconstruction theory's partial-observer slice. The artefact form is novel.
Engineering throughput. Structured sparse routing on Apple Silicon Metal at billions of nodes via the Savanna engine. Real win over CPU random-sparse-projection libraries.
Rediscovery
Sparse mat-vec as encoder full stop. That is compressive sensing and random features.
LUT as input feature extractor. Albus 1975, Weinberger 2009.
Sparse-matrix signal approximation. Achlioptas 2003.
Population of cheap approximators in lockstep. Ensemble methods, mixture of experts.
The line that holds under push-back
A compositional recipe substrate, ranked by DAG depth, executed as structured-sparse mat-vec, surfaced as a dual-drawing artefact, scaled to populations on a hex-seven-color engine.
Each clause is borrowed from a named prior. The sentence is the contribution.
SECTION 9 · POPULATION SCALE
One generator is the small thing — the population is the point
From a single observer to the Distributed Reconstruction observer family.
Figure 5. The scaling-shape staircase. Single generator on the left, browser-runnable population in the middle, engine-scale population on the right. Same architecture at every step; only the deployment widens.
What the population does together
Each generator is one observer's encoder — a partial projection of the latent signal landscape into harmonic output.
The aggregate across the observer family is the reconstruction the framework names.
Per-tick: every generator is independent, so the work is trivially data-parallel.
Across ticks: the LUT phase clock is shared, so coherence emerges across observers without explicit coupling.
Why this matters operationally
The substrate the generator sits on — the hex-seven-color sparse-mat-vec path of the Savanna engine — is the same substrate that runs the hundred-billion-cell ecosystem demo. Same engine, same throughput class. Scaling the generator population is not "build a new engine"; it is "tile the population across the existing engine."
CLOSING · WHAT TO TAKE AWAY
The compact pitch
Three things, if you remember nothing else:
1 · The mechanism
A phase clock indexes a lookup table of compositional recipes. Each recipe is multiplied through a sparse routing matrix and a small feed-forward stage. The output is one harmonic signal sample per tick. Cheap per tick, structured across recipes.
2 · The lineage
Sparse Johnson–Lindenstrauss projections, sparse coding, tile-coding, hash features, random features, mixture-of-experts gating, FPGA LUTs, hyperdimensional computing, compressive sensing. The combination is structurally novel; the ingredients are borrowed.
3 · The payoff
One generator is small. The population is large. The aggregate is the reconstruction the framework names. The substrate is the same engine that runs Savanna at hundred-billion-cell scale.
Amateur engineering project. We are not HPC professionals and make no competitive claims. Numbers speak. Ego does not. Errors are likely; the work is openly in progress.