The recursive inversion function
The stack is a function. Not a metaphor — a literal executable function:
f(goal) → [(missing_piece, dependency_order, why)]
Each missing_piece is itself a goal. Feed it back in. The recursion terminates when every piece in the chain maps to something that already exists — a shipping chip, a published algorithm, a working library, a proven theorem. When it terminates, you have the complete build order.
Step 1 — Decompose the goal into stack primitives
A goal is a computation you want to accelerate. Examples: "real-time Bayesian posterior update on a 5W edge device", "post-quantum TLS handshake under 1ms", "lattice QCD at 10× current throughput". The first step is to decompose the goal into a computation graph where every node is a primitive in the stack.
The instrument's detail panel shows you the decomposition: click any primitive and its "BUILT FROM" list is the incoming edges — the sub-operations it depends on. Walk the graph from your target down to the leaves.
Step 2 — Check each primitive against the registry
For every node in the decomposition, at the required abstraction level, on the required substrate: does an implementation exist? The existing field in the stack data tells you: HW (shipping silicon), ISA (instruction-set extension), EM (emerging), SW (software only), TH (theoretical).
Anything that's HW or ISA is done — it already exists. Anything that's SW or below is a gap. Gaps become the next-level goals.
Step 3 — Order the gaps by dependency
The composition edges give you the build order. Leaves first: a primitive with no incoming edges is a leaf and can be built immediately. A primitive with incoming edges depends on its sources being built first. The topological sort of the gap subgraph IS the build schedule.
Step 4 — Map each gap to physics
For each gap, the stack provides the (B, C, D) coordinates — the physics of implementation:
- B (abstraction) — can this be a gate-level design (B₁), a microarchitecture (B₂), an ISA extension (B₃), or does it need to stay in software (B₄)?
- C (thermo cost) — is this L₀ (free, candidate for reversible substrate), L₁ (needs entropy source), or L₂ (pays Landauer)?
- D (concurrency) — is this scalar (D₀), vector (D₁), matrix (D₂, systolic), graph (D₃, irregular), embarrassingly parallel (D₄), or sequential (D₅)?
The silicon target field gives a concrete starting point for the datapath design.
Step 5 — Prototype on FPGA
The gap analysis produces a specification: a primitive with known (B, C, D) coordinates and a concrete silicon target description. The next step is to implement it on an FPGA. This validates the datapath, measures the actual energy cost, and checks it against the thermodynamic prediction from the C axis.
If the measured energy matches the predicted floor (L₀ for bijective, kT ln 2 per bit for L₂), the design is thermodynamically optimal. If it's higher, there's room to improve the implementation. The stack tells you what to measure; the FPGA tells you what you got.
Step 6 — Tape out
A validated FPGA design becomes an ASIC specification. The concurrency topology (D axis) determines the array structure: systolic for matrix ops, tree for reductions, crossbar for graph-irregular. The thermodynamic class determines the power budget. The abstraction level determines the interface: register-level for B₃ (ISA extension), memory-mapped for B₂ (accelerator), standalone for B₁ (dedicated chip).
Step 7 — Update the registry
When the chip ships, add it to the silicon registry. The gap closes. The stack's existing field updates from SW to HW. The cycle completes, and the next iteration begins with fewer gaps.
The Periodic Stack is not a document. It is a function — a recursive inversion that turns any computational goal into an ordered build schedule with thermodynamic cost predictions and concrete silicon targets. Chemistry got its periodic table in 1869. Computation gets its periodic stack now. The math is the source of truth. The compute stack is the map. The silicon registry is the scoreboard. The gap between them is the roadmap. Math × material science = computing.