cert-machine · report · generated from the records
The ten minimum universal sets of MacMahon cubes: a classification decided twice
On 1 November 2026 Jason Davies published a proof, developed with OpenAI’s GPT-6 Astra and written in Lean, that exactly ten collections of twelve MacMahon cubes can build every one of the thirty cubes as a 2×2×2 model. It settles two conjectures of Johnson and Roldán from 2024. The result and the proof are his. With Claude (Anthropic’s AI model), I checked his release three ways that share no code with each other: my own program rebuilt all 300 of his released constructions, two independent proof checkers accepted his ten Lean theorems, and two exhaustive searches, a reader’s and mine, found the same ten sets and no other collection of twelve cubes or fewer.
The claim, drawn. A MacMahon cube has six colours, one on each side; there are 30 of them, and Conway’s table names each by two different letters from A to F. Split the six letters into two triples and take the cubes whose two letters fall in the same triple: a set of 12. There are 10 splits, so 10 sets. Davies’s theorem says these 10, and no other collection of 12 cubes or fewer, can build every one of the 30 cubes. The sets drawn are the ones in his released file.Records: certs/macmahon-witnesses.json · sha256 4627cdbad9d0; corpus/macmahon/results/universal_witnesses.json · sha256 18ded406ca9aThe build refuses this figure if a released set is not a split of the six letters into two triples, the sets are not 10 different ones, or a released construction is not rebuilt.
released constructions rebuilt
300 of 300
by my own program, with its own rotations and corner positions
Lean theorems accepted
10 of 10
by two kernels: Lean’s own and nanoda
collections of 12 cubes or fewer that work
10
found by two searches that share no code; none smaller
planted errors caught
9 of 9
on all three routes
The result and the proof are Jason Davies’s; his disclosure says GPT-6 Astra (OpenAI) developed the argument, the code, the Lean proofs and the manuscript under his direction. The conjectures are Inga Johnson and Erika Roldán’s. This page checks his release; it is not new mathematics. The checks are mine, run with Claude (Anthropic’s AI model), which wrote the programs under my direction.
read this first
What is still open
The second half is decided by search, not by a second proof. That no other collection of 12 works, and none of 11, is now decided here by two exhaustive searches that agree. Each search is complete by a written argument and a program; neither is machine-checked, and the Lean proof stays the only formal proof. The reader’s search is named by the sha256 of its files, which carry no licence line and are not published here: anyone can re-run my search, not the reader’s.
The kernels repeat a check that had already been run. The author’s own automated checks and the Palomar registry (entry PALOMAR-2026-11-01-000019) had checked the same commit. Mine is a second party’s run on a separate machine, with my own report of the axioms. It agrees with theirs; it is not a different kind of evidence. Lean and Mathlib are trusted, as in any check of this kind, and so is Comparator’s matching of the statements.
What is taken from the author. My programs take his table of the 30 colourings as the naming of the cubes, after checking that it lists every cube exactly once, and the first one takes his lists of which eight cubes to use; how to turn and place them it works out itself. The kernels ran on the commit the registry names, and the constructions and his disclosure were read at a later one; every Lean and configuration file is the same bytes at both, and the kernel run holds each to its pinned digest.
The cubes are a model, and the paper was read, not checked. The Lean statement is about six directions and a table of 24 rotations, not about solid cubes in space; that this is what building a 2×2×2 model means is the paper’s declaration, and I take it on the paper’s word. The Lean statement was read against the paper’s main theorem and matches; that is a reading. The paper’s written argument was not checked, and the author’s disclosure says the Lean proof takes a different route from it. The paper’s other computations (counts of how many cubes sets of eight to thirteen can build) are not Lean theorems, and I did not re-run them: his search and his verifier were read, never run. Nothing here was compared with Johnson and Roldán’s own wording of their conjectures.
AI models on every side, and no human referee. The proof was developed by GPT-6 Astra (OpenAI). My programs, the second search among them, were written by Claude (Anthropic), and the author’s disclosure says a Claude model also reviewed his manuscript. Exact programs and two kernels decide here, not a model; you should still know. The author’s disclosure calls the work self-assessed and not independently reviewed by a human expert, and says priority beyond the sources it cites has not been established. Neither was examined here.
the claim
Thirty cubes, twelve at a time
Paint the six sides of a cube with six colours, one each. Up to turning the cube in the hand there are 30 ways, mirror images counted apart: the MacMahon cubes. A collection of cubes is universal if, for every one of the 30, eight cubes of the collection can be stacked into a 2×2×2 block whose outside is that cube, twice as large; the hidden sides need not match.
Kazuya Haraguchi showed that a universal collection needs at least 12 cubes and gave one of that size. In 2024 Inga Johnson and Erika Roldán conjectured that exactly 10 sets of 12 different cubes are universal (their Conjectures 4 and 8), and described them: the two-triple splits drawn above. Davies’s theorem is that the conjecture is right, and stays right when a collection may hold the same cube more than once: no collection with a repeat reaches the minimum.
1 · my own program
All 300 released constructions, rebuilt
What he released. For each of the 10 sets and each of the 30 cubes to build, the eight cubes that build it: 300 constructions.
What the program does.instruments/macmahon/check.py was written from the definitions by Claude (Anthropic’s AI model) under my direction, in Python’s standard library. It makes its own 24 rotations of a cube and its own eight corner positions. For each construction it searches for a way to turn the eight cubes and put one in each corner so that every outside side shows the right colour. It ignores the rotations and positions his file suggests, and runs none of his code.
First, the names. His table gives 30 colourings, six different colours on each, and no rotation takes one to another. They are the same 30 classes that all 720 colourings of a cube fall into, so the table lists every cube once. CERTIFIED
Then the sets. The released sets are 10 different sets of 12 cubes, and they are exactly the 10 splits of six letters into two triples. CERTIFIED
Then the constructions. 300 of 300 build their cube. CERTIFIED
What that decides. That each of the 10 sets can build all 30 cubes. It says nothing about whether other sets can.
2 · two kernels
His 10 Lean theorems, accepted by two independent checkers
What was run. On a machine hosted by GitHub (.github/workflows/macmahon-kernel.yml, run 41729708954), with Claude writing the workflow under my direction: his repository at the commit the Palomar registry names, built with its own Lean 4.35.0 and Mathlib 4.35.0. Then Comparator 4.35.0, in the configuration his repository ships, with one change: nanoda, a kernel written in Rust apart from Lean, switched on beside Lean’s own.
What Comparator checks. That each of the 10 theorems proved is exactly the one stated in a separate file that imports only Mathlib, so a proof cannot quietly change what it proves; that only the three standard axioms are used; and that the proofs replay.
What came back. Both kernels accept all 10. A report of the axioms, printed from a file of mine, names nothing beyond propext, Classical.choice, Quot.sound; one theorem needs propext alone. The library’s cache took 116 s, the build 207 s and the comparison 347 s. CERTIFIED
One declared change to nanoda. Its working memory per thread (the stack) was raised to 1 GiB. Nothing else in it was touched.
The statement, read. With Claude, I read the Lean statement file against the paper’s main theorem, sentence by sentence. It matches: a collection counts copies, so repeats are in the statement; a construction needs eight distinct physical cubes; only the outside sides are constrained; all 30 cubes must be built. This is a reading, kept apart from what the kernels decided.
Challenge.lean (imports only Mathlib) read against the paper's Theorem 1 ("The minimum size of a universal collection is twelve. Exactly ten labelled collections attain that size, even when repeated varieties are permitted. Each unordered partition of the six labels into triples gives one; these are all; none has repeats.") — a reading, not a decision.
1. An Inventory is Pair → ℕ: multiplicities allowed, so "repeated varieties permitted" is in the statement; DiagonalZero removes the thirty diagonal non-varieties; total is the collection size.
2. PhysicalBuilds a t asks for an INJECTION of the eight slots into the stock (eight distinct physical copies) with a rotation each, and FaceFits constrains only the three exposed faces of each slot: "exteriors only, internal faces free" as the paper says.
3. PhysicalUniversal quantifies over every ordered pair i ≠ j: all thirty varieties, each labelled by Conway's tableau; "labelled" (colours fixed, no quotient by colour permutations) is the statement's own frame, as the paper's Theorem 1 says.
4. minimum_size (IsLeast … 12) and physical_minimum are the first sentence; physical_exactly_ten (Nat.card = 10) the second; physical_iff_two_triangles the third (twoTriangles s for a 3-subset s); physical_minimum_has_no_repeats the last.
5. The five auxiliary theorems (proper_rotation_iff, exposed_face_rule, face_colours_valid, face_assignment_coverage, face_assignment_unique) certify the tables the statement rests on: the 24 rotations are exactly the proper ones, the slots expose the outward faces, and the faceColours table lists every six-distinct-colour colouring exactly once up to rotation — the same facts certs/macmahon-witnesses.json decided independently (T1).
6. Not in the Lean statement: the physical cubes themselves (the model is the discrete one the paper declares: six face directions, signed-axis permutations of determinant +1). The paper says so; this is the one step a reader takes on the paper's word.
3 · two searches
No other collection of twelve, and none of 11: searched twice
What was missing. Until 13 November 2026 this page rested the second half of the theorem on the Lean proof alone: my program showed that the 10 sets work, not that nothing else does. A reader pointed that out and sent an exhaustive search for the missing half. I replayed that search and, with Claude, wrote a second one that shares no code and no method with it.
The rules came first.corpus/macmahon-necessity/RULES.md was written, sealed and published before either search was run here: what would pass, what would refuse, and 6 planted errors.
The reader’s search. It turns “eight different cubes can fill the eight corners” into counting conditions (Hall’s theorem; 6,290 of them over the 30 cubes to build), then tries, one cube at a time, every way to meet them with at most 12 cubes: 156,751 steps. Replayed unchanged, it finds 10 collections, each of 12 different cubes, none smaller, and writes the same result file its author sent, byte for byte.
My search.instruments/macmahon/necessity.py was written by Claude under my direction, in a session that had seen neither the reader’s files nor Davies’s search, proof files or paper. It does not use Hall’s theorem. It lists collections cube by cube, tests each by actually matching cubes to corners, and gives up on a branch only when even the most generous way to finish it cannot build some cube. After 7,563,891 steps: no collection of 0 to 11 cubes works, and exactly 10 of 12 do. CERTIFIED
With the shortcut switched off. Run once without that one shortcut, the same program visits every collection of up to 12 cubes and judges each, in 15,338,678,264 steps: the same ten. This run is outside the sealed rules and is kept as an extra.
The two against each other. The two lists are the same ten collections, and they are the ten released sets, name for name through his table. CERTIFIED
What that decides. In the model the Lean statement declares: no collection of 11 cubes or fewer can build all 30, and the only collections of 12 that can are the ten sets, even when a collection may hold the same cube more than once. By search, not by a second proof.
4 · planted errors
What would have caught a wrong result
A cube from outside the set. In one released construction, one of the eight cubes is swapped for a cube that is not in the set. The program refuses it.
A wrong cube to build. The same eight cubes are asked to build a cube with two of its sides exchanged. The program refuses it.
Mirror images allowed. If turning a cube could include mirror reflections (48 maps in place of 24), the 30 cubes would merge into 15 and the check of the names would fail. Under that table it does.
A false theorem for the kernels. In the statement file, “exactly ten” was changed to “exactly nine” and his proof left as it is. Comparator refuses it: the theorem stated and the theorem proved no longer match.
Mirror images allowed, in both searches. If a cube may also be placed mirrored, 8 cubes are enough and 672,000 collections of 8 work. Both searches report exactly that, with the same list.
One cube in several corners. If one physical cube may fill several corners, 5 cubes are enough, in 12 ways. Both searches agree.
One cube made useless, then required. With the cube Ab declared to fit nowhere, both searches keep exactly the 6 sets without it; with Ab required, exactly the 4 sets with it. These two numbers follow from the theorem, so they show that the searches respond to the model; they are not evidence for the theorem by themselves.
At most 11 cubes. Both searches find nothing.
who did what
Each step is a separate job
The result and the proof. Jason Davies, with GPT-6 Astra (OpenAI), which his disclosure says developed the argument, the code, the Lean proofs and the manuscript under his direction.
The conjectures. Inga Johnson and Erika Roldán. The minimum of 12: Kazuya Haraguchi. The cubes are MacMahon’s; the table of names is Conway’s.
The checkers. Lean, Mathlib, Comparator and nanoda: their authors. The earlier mechanical check of the same commit: the Palomar registry.
The first search for the other half. A reader of this page, who pointed out that it decided one half only and sent the search. The reader is not named here; the files are named in the record by their sha256.
The checks on this page. Carlos Toledo, with Claude (Anthropic), which wrote the programs and the workflow under my direction. The constructions and the kernels ran on 3 November 2026, the searches on 13 November 2026.
check it yourself
How to re-run it
The constructions.python3 instruments/macmahon/check.py --check rebuilds all 300 from the pinned files and refuses on any difference from certs/macmahon-witnesses.json.
The kernels.node tools/record-macmahon-kernel.js --check re-reads certs/macmahon-kernel.json from the run’s saved output; gh workflow run macmahon-kernel.yml on a copy of this repository runs the build and both kernels again.
The searches.python3 tools/record-macmahon-necessity.py --check runs my search again and refuses on any difference from certs/macmahon-necessity.json; add --full for the mirror-image run too. The reader’s search cannot be re-run from this repository: what it printed here is in corpus/macmahon-necessity/route-r/replay.json.