Why there is a second post
About six months ago we built and published the original QSOT artifact. The name — Quantum State Over Time — promised a deeper link between quantum evolution and temporal structure than the thing underneath could actually support.
Then last week we published a post-mortem with an uncomfortable title: "We Made a High-Formality, Fake Physics Slop Artifact." A quiet admission that we had been wrong, and that the original claims did not survive scrutiny.
It was not a marketing move and not self-flagellation. It was a confession: we had shipped a repository with a DOI, two LaTeX papers, a project page, release notes, plots, and tests — the full visual grammar of serious science — around a core claim that was hollow underneath.
That post diagnosed the failure. It did not repair it. This is the repair.
If we made the mess, we clean it up.
The repair is called QSOT2. It is smaller, narrower, and far less ambitious than the original — and that is the point: the goal is no longer to look impressive, only to keep the claims we can actually justify.
You do not need to have read the first post. I will rebuild the context and show what changed, using evidence rather than adjectives.
For readers who never met QSOT
QSOT stands for Quantum State Over Time — a real idea from the physics literature (Lie & Fullwood) that treats time inside quantum mechanics as a first-class object rather than an external dial.
Our implementation of that idea — QSOT Compiler v1 — tried to map curved-spacetime backgrounds (Schwarzschild, de Sitter, AdS, Gödel) into single-qubit noise channels, then report whether the channels stayed physically valid, whether curvature showed up as decoherence, and whether quantum-information signals changed between backgrounds.
That is an ambitious sentence. It was ambitious in the wrong order.
The foundations were real — standard quantum-channel mathematics, Kraus operators, CPTP conditions. Those are not in dispute. The problem was everything we stacked on top of them.
What was actually wrong
The original problem was not that the repository looked broken. It was the opposite: it looked credible. The code ran, the paper compiled, the plots looked scientific, and the project carried the surface markers of serious work.
But the chain from claim to evidence was not disciplined enough.
The clearest example was the project's theoretical heart: Kirkwood-Dirac negativity. In the actual run, that number was a placeholder. So was the memory-depth signal. The curved-spacetime metrics were named in the papers, but not executed in the way the prose implied.
The form had outrun the evidence. QSOT2 begins by refusing to let that happen again.
Why dig up our own grave six months later
Two reasons, one of them not flattering.
The honorable one: by 2026 we had built executable verification, reproducibility surfaces, hash-based provenance, and a public ledger. The old artifact stopped feeling like an embarrassment and started feeling like an obligation — we made the mess, we finally had the tools to understand it, so cleaning it was our job.
The other: curiosity. Criticising a bad artifact after the fact is easy. Taking the same domain and producing something tighter, smaller, and able to survive its own tooling is not. We wanted to know whether the newer skill was real. QSOT2 was the test.
What QSOT2 changed — and it was not a new theorem
The most important change in QSOT2 is not a result. It is a boundary.
Boundary first. QSOT2 is not a quantum-gravity result. It is not a first-principles derivation. It is a bounded mathematical-consistency verifier for one implemented phenomenological model.
QSOT v1 tried to be a new-physics paper, a quantum-gravity gesture, a governance platform, and a math verifier at once. QSOT2 refuses all of that and asks one question:
Does the implemented model stay internally consistent — as quantum mechanics and as software — and are its numbers honest about what they are?
Smaller question. Much better question.
1. The math matured by subtraction, not ambition
QSOT2 did not make the model bolder. It made its mathematical status clean, by removing every place the old version could pretend:
- the curvature-to-noise map is stated plainly —
p = 1 - exp(-alpha * ||Riemann||_F), with alpha a free, dimensionless calibration parameter, not a derived constant;
- the curvature inputs are disclosed as non-derived toy proxies, so the product
alpha * ||Riemann||_F carries no hidden physical-unit claim;
- Kirkwood-Dirac is demoted from "contextuality witness" to a bounded, flat-relative diagnostic;
- the memory proxy is demoted from "full reconstruction" to a self-tested one.
The curvature tensors are not smuggled in as derived physics: they are explicitly labelled toy proxies in the artifact (a per-background riemann_is_toy flag), so the model cannot silently upgrade itself into a physical claim.
This is what strengthening looks like when the problem was epistemic inflation, not numerical instability. You do not fix inflation by computing harder. You fix it by removing the claims the math could never support.
2. The code stopped being "simulation" and became the witness
In QSOT2 the code's job is not to simulate. It is constraint enforcement — it fixes what may be claimed, what must be measured, what can be re-run, what gets hashed, and what is allowed to fail.
A paper can write "the axioms hold" for free. QSOT2 instead emits, per run: linearity deviation 1.1e-16, CPTP completeness 1.6e-16, trace preservation 4.4e-16 — all at machine epsilon — across 35 deterministic checks (34 pass / 1 degraded / 0 fail). The rule behind it:
Do not let prose carry a claim that the code cannot witness.
There is an architectural version too: the math layer is forbidden from importing the reporting layer — the separation that was missing in v1 is now enforced by the code, not promised by prose.
3. The negative result is advertised, not hidden
!6.png
The overall verdict is DEGRADED_PASS, on purpose: the flat-baseline KD optimizer does not converge inside its fixed 50-step budget — meaning it was still improving when the budget ran out, not that it diverged, so the reported value remains interpretable within the fixed-budget run.
Instead of rounding up, the run says so — in the verdict, the schema, the README, and the paper. The difference between an artifact that wants to impress and one that wants to be trusted often lives in exactly this footnote.
4. The workflow became a claim-custody pipeline
The workflow ties it together: every claim travels a gated path —
claim → code check → artifact → canonical-LF hash → paper line → DOI.
One command runs the experiment and emits one machine-readable result under a fixed schema with a four-field claim boundary; one command runs 50 tests behind a ≥ 90% coverage gate (currently ~96%); the line is DOI-archived on Zenodo (QSOT2 v0.1.2). None of this makes the model physically true — it makes the artifact auditable.
One detail matters here: the reproducibility claim is not hand-waved. The result is anchored to a canonical-LF SHA-256; the known non-byte-stable field is generated_at, and that exception is disclosed rather than hidden. The sensitivity numbers live in a separate committed sweep artifact, and the paper maps each claim back to a named file and hash.
The paper is not decoration. In the original artifact, formal writing made the work look stronger than the evidence underneath. In QSOT2, the paper has the opposite job: it records the boundary of the claim.
Its title says the scope plainly: A Mathematical-Consistency Verifier for a Phenomenological Curved-Spacetime Quantum-Channel Model. The paper does not present QSOT2 as a quantum-gravity result, a first-principles derivation, or an externally validated physical model. It presents it as an executable internal-consistency check for one implemented ansatz.
The structure follows that boundary. It starts with scope and background, then moves through temporal axiom checks, curvature-noise baselines, the flat-relative KD diagnostic, the TTM-inspired memory proxy, consolidated results, explicit non-claims, and reproducibility.
That order matters. The paper does not ask the reader to trust a polished argument. It asks the reader to follow a constrained chain: what the model claims, what the code checks, what the result reports, what the artifact refuses to claim, and how the run can be reproduced.
The abstract already carries the important limits: the curvature-to-channel mapping is a conceptual ansatz with a free calibration parameter; the curvature norms are non-derived toy proxies; the product alpha * ||Riemann||_F carries no physical-unit claim; and the reference run ends in DEGRADED_PASS for one documented reason, the flat-baseline KD optimizer’s fixed-budget non-convergence.
So the paper is not where QSOT2 becomes more impressive. It is where QSOT2 becomes harder to overclaim.
If the repository is the executable surface, and the public ledger is the receipt surface, the paper is the formal boundary surface: the place where the claim is written down in a form that can be checked against the code, the result artifact, and the hash trail.
The receipt: every v1 failure → a measurable
The honest way to prove a repair is to put the old defect and the new measurement side by side. The three that mattered:
1. Placeholders → bounded diagnostics
- v1: KD negativity and non-Markovianity were both exactly
0.0.
- QSOT2:
kd_delta = +0.1230; self-test nm = 1.41e-4 (must fire on injected backflow) vs. model nm = 0.
- Means: reproducible, model-relative comparisons — not proofs of contextuality or curvature-induced decoherence.
2. Named spacetime labels → explicit model inputs
- v1: the curved-spacetime metrics were named in the papers, absent from the run.
- QSOT2: curvature drives the channel across six backgrounds; purities verified — Schwarzschild
0.99943, de Sitter 0.63607, AdS5 0.67764, Eguchi-Hanson 0.99887.
- Means: the behaviour of a phenomenological ansatz — not a derived spacetime result.
3. Asserted axioms → verified axioms
- v1: temporal and axiomatic properties were stated, not checked.
- QSOT2: five temporal-state axioms verified as algebraic invariants, deviations
≤ 4.4e-16.
- Means: the model's quantum mechanics is internally consistent under its assumptions. That is the whole claim.
Read this section as the remediation map. The next question is where that map can be inspected outside this essay.
The public ledger is the receipt surface
The public Flamehaven Verification Ledger is where this repair becomes inspectable outside the essay.
The QSOT2 entry is recorded as EQA-TEST-0058, a verification run dated 2026-06-17: "QSOT2: Mathematical-Consistency Verifier (re-scoped honest successor of the 0057 slop)."
That entry states the result directly: DEGRADED_PASS (34 / 0 / 0 / 1). It also states why: the KD flat-baseline optimizer did not converge within its fixed budget. The limitation is surfaced, not hidden.
The ledger record makes the repair checkable in four directions:
- JSON — the raw machine-readable result;
- Report — the human-readable verification note;
- Repo — the source implementation;
- Paper — the formal boundary record.
In about three minutes, a reader can move from the ledger card to the raw JSON, the report, the repository, and the paper, and see the same claim boundary repeated across all of them: model-output consistency only, not external physical validity.
That is the point of the ledger. It is not a marketing page. It is a public verification record for Flamehaven's governance reviews, physics verification runs, and biomedical audit scans. Each published run is meant to be deterministic, locally executed, and inspectable from repository state.
The ledger answers one question: where can the evidence be inspected? The next question is narrower and more important: what exactly does that evidence support?
What QSOT2 can verify — and what it refuses to claim
Stated plainly, because vagueness is where slop hides.
QSOT2 verifies, and proves per run:
- the implemented single-qubit channels are CPTP (completeness error at machine epsilon);
- evolved states stay valid density matrices (Hermitian, unit-trace, positive semidefinite);
- five temporal-state axioms hold to
≤ 4.4e-16;
- the reported purities, entropies, and KD-delta are deterministic, reproducible, hash-anchored outputs of the implemented model;
- the non-Markovianity detector actually fires on injected backflow before it is trusted to report the model's
0.
QSOT2 does not claim, and says so in the artifact:
- that the curvature-to-channel map is physically real;
- any first-principles derivation;
- any quantum-gravity or external-physical result;
- that KD negativity is a contextuality proof.
Those refusals are not a closing disclaimer. They are serialized as a claim_boundary block in every result file the system writes.
Why this is not just "nicer slop"
Here is the test, and you can run it yourself.
Slop is the condition where, if you delete the rhetoric, nothing load-bearing remains. In QSOT v1, if you stripped the LaTeX and the project page, the core claim — KD negativity — collapsed to a placeholder. The formality was load-bearing for the deception.
Apply the same deletion to QSOT2. Strip the prose, the README, this newsletter. What is left:
- a machine-readable result with 35 named checks and their pass/degrade status,
- numerical deviations at machine epsilon you can recompute,
- a four-field boundary that states the scope in the data itself,
- byte-deterministic outputs with a SHA-256 you can regenerate,
- a DOI you can resolve,
- a test suite you can run,
- an import boundary the interpreter will enforce whether you read the docs or not.
In other words: remove the rhetoric and QSOT2 is still standing; remove the rhetoric and QSOT v1 was a placeholder. That is the difference between persuasion and verification, and it is the only argument here I actually trust — because it does not depend on trusting me.
The cleanest single proof is the one most products would bury: QSOT2 ships its own failing check in plain sight. Slop hides its failures behind formality. QSOT2 prints its one degraded result on the front of the box.
What this actually felt like
Unpleasant first, then clarifying. We had worked hard on QSOT v1 — that was never in question. The hard part was accepting that effort and legitimacy are not the same thing. You can write clean code around a weak claim and a polished paper around a boundary you never defended, and if AI is accelerating your workflow, it accelerates the self-deception too.
That is why the confession had to be public — and why the confession was not enough on its own. Anyone can say "we got this wrong." The harder move is to say: here is what was wrong, here is how we constrained it, here is the artifact that now withstands inspection. The repair matters more than the confession.
The broader lesson
The lesson is not "don't use AI" — we used it heavily for both artifacts. It is sharper:
When AI lets you produce high-formality output in minutes, the scarce resource is no longer generation. It is claim custody.
What is being claimed? What file carries it? What check fails if it drifts? What survives when you delete the rhetoric? QSOT v1 had abundant generation and almost no custody. QSOT2 inverts that ratio in one narrow domain.
Closing
Six months ago we had something that looked like a scientific success and wasn't. Today we have something smaller, less glamorous, and much harder to fool — including harder for us to fool ourselves with. We trust the second one more. That is the progress.
QSOT v1 was the cautionary tale. QSOT2 is what happened when we treated that failure not as embarrassment, but as engineering input.
QSOT2 — a mathematical-consistency verifier, Open source under MIT (Flamehaven Labs). If you disagree with any of it, use the path the artifact was built to survive: clone it, re-run it, and check the hash.
