Hex: Here's today's debate question. The geometry paper has an entire appendix devoted to reproducibility infrastructure — config format, determinism mechanisms, run packs, export scripts. Is all of that overkill for a theory paper?
Lux: I'll argue no. It's not overkill — it's essential. And the reason is specific to this theory.
Hex: Strong claim. Defend it.
Lux: Start with what "build the paper" actually means. The geometry paper's build command is five words: cd paper and make pdf. One command, one PDF. Elegant. But that simplicity is the tip of an iceberg.
Hex: What's underneath?
Lux: Three tiers. Tier one: the config files. These are the generative source of truth — every parameter, every seed, every knob from episodes one fifty-eight and one fifty-nine. Tier two: committed run packs. Snapshot copies of the actual outputs, stored under version control. These are what the paper references. Tier three: the paper figures themselves — copies of the run pack outputs placed in the LaTeX build directory.
Hex: So the build command only touches tier three — the final copies.
Lux: Exactly. The PDF depends on committed figures and summary tables — not on ephemeral (eh-FEM-er-ul) run outputs. You don't have to rerun anything to build the paper. But you can. That's the point. Two export scripts bridge the tiers. One takes run outputs and commits them as run packs. The other regenerates overlay comparison figures from committed packs.
Hex: So the build is fast and clean, but the regeneration path is always available.
Lux: Always. And the paper quotes it directly: "This repository is designed so that the paper can be audited from stable, committed artifacts and regenerated end to end from configuration files."
Hex: Okay, but that's the Plot paper. It generates its own data computationally. What about a paper that uses external datasets?
Lux: The Dark Energy paper. Different kitchen, same health code. And it goes further.
Hex: How so?
Lux: Four features the geometry paper doesn't have. First: a data registry. External datasets — supernova catalogs, baryon (BARE-ee-on) acoustic oscillation measurements — are fetched through a YAML registry. Each fetch records the URL, expected hash, observed hash, byte count, timestamp, and platform. Re-fetching uses a cache when hashes match. Complete provenance from download to analysis.
Hex: And the build itself?
Lux: Make paper. Similar to the geometry paper — one command. But the evidence chain is more elaborate. Every experiment writes a run bundle: resolved config, quantitative metrics in JSON, provenance record, at least one plot or table, plus a short run log as lab notes.
Hex: Lab notes in the build system?
Lux: In the run bundle. And then there's vendoring. The paper includes only "vendored" artifacts — copies from tracked paths. Each vendoring step writes a provenance YAML recording the originating run folder, source file, output path, hash, and timestamp.
Hex: [nodding] So you can trace any figure in the paper back through the vendoring step to the run bundle to the config to the raw data.
Lux: And the crown jewel: the evidence map. A LaTeX table — evidence-map-dot-tex — that maps every plot and quantitative table in the manuscript to its generating script, dataset key, run bundle, and vendored artifact. Machine-readable. Version-controlled. You can audit the entire paper without running a single line of code.
Hex: That's industrial-grade.
Lux: And every link in that chain is version-controlled. The evidence map doesn't just exist — it evolves with the paper.
Hex: But here's my pushback.
Lux: Go ahead.
Hex: Most theory papers don't do any of this. A typical mathematics paper has theorems and proofs. A typical computational paper might share code. But a formal evidence map? Data registries with hash verification? Vendoring with provenance chains? That's software engineering discipline, not standard academic practice. What makes the Six Birds papers different?
Lux: The nature of the claims. A traditional theorem is universal — it holds for all instances satisfying the hypotheses. You prove it once, it's done. But the emergence calculus makes claims that are layer-relative. The geometry isn't a universal truth about all possible substrates. It's a conditional closure artifact: given this substrate, this lens, this tau, this seed, these diagnostics are what emerge. Change the config, change the geometry.
Hex: So the config IS the claim.
Lux: The config IS the instantiation of the claim. And if you can't trace the claim back to a specific config identity, the claim is unauditable. It's not that reproducibility is nice to have. It's that without it, you literally don't know which theory layer you're talking about.
Hex: [pause] That's different from "we should all share our code." That's "the infrastructure IS the theory."
Lux: The foundations paper makes this explicit. The self-generation theorem says the six primitives appear canonically given four inputs — process soup, interface lens, refinement family, bounded-interface assumption. In the pipeline, those four inputs are configuration parameters. The build infrastructure is what records which set of inputs you actually used. Without it, the theorem is abstract. With it, the theorem is instantiated.
Hex: Okay, you're shifting my position. Let me test it against the Become paper.
Lux: The Become paper has its own variant. Build command: bash scripts slash build-physics-paper-dot-sh. But the distinctive feature is null gates.
Hex: Null gates?
Lux: Contract checks embedded in the build. Each physics instantiation (in-stan-shee-AY-shun) includes explicit null conditions that must pass. Set sigma to zero and the LES commutator must be zero. Set s to zero and the averaging mismatch must be zero. Set lambda to one and dephasing idempotence (eye-dem-POH-tence) must be exact. If any null gate fails, the build fails.
Hex: So the build doesn't just compile the paper. It tests the physics.
Lux: Falsification (fal-sih-fih-KAY-shun) embedded in infrastructure. Twenty-two tracked artifacts — CSVs, PNGs, JSONs — each mapped to its generating script through a generation map. The paper says it directly: "All figures and tables in this paper are generated by deterministic scripts in the accompanying repo."
Hex: That changes the argument. It's not just traceability. The null gates mean the build is itself a scientific instrument.
Lux: The build catches errors that a human reviewer might miss. If a code change breaks a null condition, the build fails before the paper can be regenerated with wrong numbers.
Hex: So how do the five papers compare?
Lux: Five kitchens, same health code. The geometry paper uses a three-tier system — configs, run packs, paper figures. The Dark Energy paper adds formal evidence mapping and data registry vendoring. The Become paper adds null gates as build gates. The agency paper uses an artifact contract with config hashes and a numbers-dot-json file. The life paper uses a claim ledger — a YAML file called claims-dot-yml that maps claim IDs to external experimental artifacts.
Hex: Lightest to heaviest?
Lux: The life paper is lightest — external claim IDs pointing to separate repositories. The agency paper is next — artifact contract enforced by audit script. The geometry paper is in the middle — three tiers with export scripts. The Become paper adds falsification gates. And the Dark Energy paper is the most elaborate — full evidence mapping with vendoring provenance.
Hex: Different implementations, same standard.
Lux: Every claim traceable. Every artifact identified. Every config recorded.
Hex: So where does the debate land?
Lux: The question was: is this overkill? And the answer depends on what your paper claims. If your claims are universal theorems, reproducibility is courtesy. If your claims are about what specific computational pipelines produce — which is what the emergence calculus claims — then the build infrastructure isn't hygiene. It's theory infrastructure. The build IS the instantiation. The evidence map IS the audit trail. The null gates ARE the falsification tests.
Hex: [quiet] Reproducibility as a load-bearing component, not a decorative one.
Lux: The paper build isn't separate from the science. It's part of the science. And every paper in the Six Birds series treats it that way — from the lightest claim ledger to the heaviest evidence map.
Hex: I'll concede the debate. When the theory is about conditional closures, the conditions have to be documented with infrastructure, not just prose.
Lux: How this paper was built. Not just engineering — theory in action.
Hex: Next time?
Lux: Episode one sixty-one. We leave the geometry paper's infrastructure and return to the science. A new series topic — the role of constraints in shaping emergent structure. How boundaries and limitations don't just restrict — they create.
Hex: From the build to the boundary. See you there.