Lux: What does it mean for a computational experiment to be deterministic?
Hex: Same inputs, same outputs. Every time.
Lux: Simple to state. Surprisingly hard to guarantee. Because "inputs" means more than just the data. It means every parameter, every seed, every ordering choice, every library version. And the geometry paper's config system is designed to nail all of that down. Today, Hex — a case study in reproducibility as a design discipline.
Hex: The boring infrastructure that makes the exciting science trustworthy.
Lux: Exactly. So let's open the case file.
Hex: Where do we start?
Lux: Start with the config file. The geometry paper has six canonical experiments — grid, sphere, Sierpinski (seer-PIN-skee), anisotropic, holonomy (hoh-LON-oh-mee) demo, and the Pythagorean random walk. Each one is defined by a single configuration file. YAML extension, JSON content. Valid YAML one-point-two, readable by any JSON parser — no external dependencies.
Hex: One file captures the whole experiment?
Lux: Every parameter. The substrate type. The number of micro-states. The staging parameter tau. The number of macro states m. The number of eigenvectors for diffusion coordinates. The smoothing constant eta. The edge threshold epsilon. The prototype choice — uniform or stationary-conditional. The random seed. All of it in one file. And one command runs it: python experiments slash run-dot-py dash-dash-config, then the path to the config file.
Hex: So if I download the repo and run that command with the same config...
Lux: Same machine, same library versions — you get the same output. That's the determinism guarantee. And the guarantee rests on three specific mechanisms.
Hex: What are they?
Lux: Mechanism one. Explicit seeds. The lens construction — the step that turns five hundred twelve micro-states into one hundred twenty-eight macro labels — uses spectral embedding followed by k-means clustering. K-means is iterative and depends on its starting point. Different random starts can produce different clusters. So the config specifies the seed. Same seed, same starting point, same clusters, same lens.
Hex: And the holonomy demo?
Lux: Deterministic loop sampling under fixed seeds. The plane uses seed zero. The sphere uses seed one. Maximum eight hundred loops. Same seed, same sampled triangles, same holonomy angles.
Hex: So the clustering step — the one that defines what counts as a "point" in the macro layer — is pinned down by a single integer in the config.
Lux: One integer. But without it, you could run the same pipeline twice and get different macro labels, different distances, different holonomy. Different geometry from the same substrate. The seed eliminates that.
Hex: Mechanism two?
Lux: Sorted iteration. When you iterate over a set or dictionary in Python, the order can vary between runs or platforms. If the order matters for any computation downstream, you get nondeterminism. The geometry paper sorts all iteration — every set, every dictionary — to eliminate this source of variation.
Hex: [nodding] That's a subtle one. The math doesn't care about order, but the floating-point arithmetic does.
Lux: Exactly. Floating-point addition is not associative. Add three numbers in a different order, you can get a slightly different result. Sorted iteration removes that ambiguity.
Hex: Mechanism three?
Lux: Stable JSON hashing for config identity. Every config file gets a hash — a fingerprint. The hash is computed from a stable JSON serialization. Same config, same bytes, same hash. Change one parameter — even the seed — and the hash changes. The config hash becomes the experiment's identity.
Hex: So any figure or table in the paper can be traced back to a specific config hash.
Lux: And from the hash to the exact config file, and from the config file to every parameter that defined the run.
Hex: That's the input side. What about the output?
Lux: The artifact contract. This comes from the agency paper — same discipline, different domain. Every JSON artifact produced by the pipeline must include three things. First: the config dictionary and its config hash. Second: a metrics dictionary containing the quantitative outputs used in the paper. Third: provenance — a timestamp and a versions dictionary listing Python, NumPy, and any other relevant library.
Hex: Passport control for data. No artifact gets into the paper without proper documentation.
Lux: And an audit script enforces it. Run the script and it checks every artifact against the contract. Valid config hash? Check. Hash matches the stored config? Check. Probability objects satisfy basic stochasticity (stoh-KAS-tih-sih-tee) invariants? Check. If any check fails, the script fails. The emergence calculus infrastructure treats reproducibility as a pass-fail gate, not a nice-to-have.
Hex: So the system catches its own errors.
Lux: Before they make it into the paper. If your idempotence (eye-dem-POH-tence) defect is zero-point-three-two, the metrics dictionary says so, the config hash ties it to the exact parameters that produced it, and the provenance records when and with what software. The full chain of custody.
Hex: So every number in the paper — every delta, every distortion, every holonomy angle — has a paper trail back to a specific config hash.
Lux: Every single one.
Hex: But you said "same machine, same libraries." What about different machines?
Lux: That's the platform caveat. Linear algebra libraries — BLAS implementations — can produce slightly different floating-point results on different hardware. The fifth decimal place might differ. The twelfth eigenvector might get a slightly different sign. For most purposes, these differences are invisible. But for exact reproducibility, they matter.
Hex: The recipe is exact but ovens differ slightly.
Lux: Which is why the paper uses a two-tier system. Tier one: config-driven regeneration. You can always rebuild from the config files. The commands are documented. The seeds are fixed. On your machine, you'll get your deterministic output. Tier two: committed run packs. Snapshot copies of the outputs from the canonical runs, stored in the repository under version control. These are the authoritative reference for every number and figure in the paper.
Hex: Two tracks running in parallel. The recipe track says "you can always cook it yourself." The snapshot track says "and here's the reference dish, photographed and dated."
Lux: Neither track alone is sufficient. Config-driven regeneration without run packs means platform drift could silently change the numbers the paper quotes. Run packs without configs means the numbers are authoritative but can't be independently regenerated. Together, they close the loop. The paper says 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: Audited AND regenerated. Two verbs. Two tiers.
Lux: And this discipline isn't unique to the geometry paper.
Hex: The whole series does this?
Lux: The agency paper has its own artifact contract with the same structure — config, config hash, metrics, provenance. Plus a stable-naming system for paper-facing assets. A file called numbers-dot-json collects every key scalar cited in the exhibits together with the hashes of the runs that produced them.
Hex: One file you can open and see: this number came from that run with that config.
Lux: Complete traceability. And the foundations paper explains why this matters at the theoretical level. The self-generation theorem says: given a process soup, an interface lens, a refinement family, and a bounded-interface assumption, the six primitives appear canonically. In the computational pipeline, those four assumptions are operationalized as configuration parameters. Recording the config precisely means recording exactly which instantiation of the Six Birds theory you tested.
Hex: [quiet] Without config discipline, "the pipeline" is ambiguous. Which pipeline? Which lens? Which tau? Which seed?
Lux: And the emergence calculus framework makes that explicit. Every claim in the paper is relative to a specific instantiation. The config file IS the instantiation. The hash IS the identity. The run pack IS the evidence.
Hex: The recipe card isn't just documentation. It's the experiment itself.
Lux: And reproducibility isn't a feature you add after the science is done. It's the foundation the science stands on. Every parameter recorded. Every seed explicit. Every output auditable. Every claim traceable.
Hex: [pause] The honest infrastructure. Same philosophy as the proof anchors — name what you can control, name what you can't, and make the gap visible.
Lux: Config format and determinism. The plumbing that makes the whole building work.
Hex: Next time?
Lux: Episode one fifty-nine. Canonical configuration snapshot — the major knobs. We zoom into the actual parameter tables. What each knob controls, what happens when you change it, and why the canonical values were chosen. From the config format to the specific settings.
Hex: From the recipe format to the actual recipe. See you there.