CxR fi ❦ 📡🌚

Operator Dispatch / Entry 006

The Matrix, Not the Pivot

/ Le Blog

Forgotten Industries // Le Blog // Entry 006 // FI-ROUAGE-006

The problem with two trains

Le Rouage routes in two places. rouage.py routes in Python. train.js routes in the browser, because the interactive dial has to work without Python running underneath it. That is a second implementation of the same stage logic — the exact duplication the rest of the build refuses everywhere else, where the roster, the ladder, the cap, and every phrase are parsed once from markdown so nothing is ever written twice.

Two implementations of the same rule are survivable on one condition: they have to be shown to agree, not asserted to. And the word for the thing that shows it turned out to matter more than expected.

Why "matrix" and not something looser

test_conformance.py already called it "the same input matrix" before I ever named it that on purpose, which is usually a sign the code knew something before I did. Once I looked at it as a matrix on purpose, the shape sharpened:

  • Rows are the corpus. Every case worth checking — an utterance, an arming state, a proposal with its evidence.
  • Columns are the implementations. Python's train, the browser's train. Two, today.
  • The cell is a trace. Whatever that row, run through that column, actually produced.
  • The oracle is nothing more than: the row is constant. Conformance isn't a clever comparison. It's the assertion that every row's cells are equal, field by field.

The literal half — phrase matching, named routes, the cap, the seal, where a route actually ends — builds its rows by cross product: 14 utterances × 2 arming states = 28 rows, 2 columns, all 28 required to agree. The barrel's half — Stage 6, COLLECT, the stage that admits a proposal on a verbatim citation rather than a phrase match — is a smaller, hand-built matrix: 15 rows, chosen to hit every way a proposal can be admitted or refused, still 2 columns, still one rule.

What a pivot would have cost

The alternative was never "no shared source of truth" — that part was already settled by generating both engines' vocabulary from the same doctrine. The alternative was a pivot: one canonical trace format, both engines normalized down to it, one artifact per case.

A pivot collapses the columns. Once there's one artifact, there's nothing left to compare — you can check the artifact against expectations, but you can no longer catch the two engines disagreeing with each other, because disagreement was the entire question and the pivot already threw one side away before the check ran.

The matrix keeps the columns genuinely separate. Python produces its trace. The browser produces its own, independently, from the same doctrine and the same case. Nothing is normalized before the comparison — the comparison is the point. And a third engine, if one ever shows up, is a third column. Not a rewrite of the harness, not a new pivot format everyone has to be re-normalized into. That's not a coincidence of this codebase; it's why test262 and the CommonMark spec test suite are built the same way — a shared corpus, one column per implementation, and an oracle no more elaborate than "they agree."

Where a matrix goes quiet

Equality across a row is symmetric, which means a row of two empty cells satisfies it as completely as a row of two identical, hard-won ones. A matrix can be internally consistent and prove nothing at all — every engine agreeing, at length, to do nothing.

That's the gap two more tests exist to close, and they check rank, not agreement:

  • test_the_matrix_actually_exercises_every_branch walks every row's failures and confirms the full rejection set is still hit — unknown member, a prohibition offered as grounds, a citation that isn't verbatim, evidence that doesn't resolve, evidence required and never given. A matrix that quietly stopped covering one of those branches would keep passing every agreement test in the file. This is the one thing that would still catch it.
  • test_a_proposal_can_actually_convene_someone checks the positive case on its own — that at least one row actually admits somebody. If admission itself ever silently broke, every "the two engines agree" test above would keep passing on two engines agreeing to admit nobody, forever, and look green doing it.

A matrix of zeros is a matrix that agrees with itself perfectly. Rank is the part that notices.

Provenance. Drafted by ATLAS from the operator's own working notes on rouage/test_conformance.py and rouage/CONFORMANCE.md during the same session the distinction was drawn in. The engineering claims — row counts, branch names, member roles — are read off the checked-in code, not reconstructed from memory.

A thing documented is a thing not yet lost.