Imagine two ways of building with Lego.
Same number of bricks either way. In 1950 a mathematician called Foulkes asked: if b is at least 6, does everything you can build the first way also fit inside what you can build the second way?
(In the real problem the “bricks” are polynomials, and “fit inside” has a precise meaning, but that’s the shape of it.)
It had been proved for 2, 3, 4 and 5 towers. OpenAI’s paper claims to prove it for 6.
The proof has three layers:
I checked layer 1.
It holds up. For every b from 6 to 25, the second way always has at least as much as the first. No exceptions.
The biggest cases ran on GitHub’s own servers, with public logs anyone can inspect.
No. The question and the right answer are fixed. Running a second, independent program is like having a second accountant redo the books from the receipts: if both get the same total, a mistake in the first one is very unlikely. If we’d disagreed, that would have meant an error somewhere.
Only layer 1. Layers 2 and 3 still need mathematicians to check them.
All code and results: github.com/realopjt/foulkes-sixth-power-check. Part 1 is here. I did this with help from Claude (Anthropic). The maths is OpenAI’s.
Claim checked. The base interval of Foulkes’ Conjecture for the Sixth Symmetric Power: for 6 ≤ b ≤ 25, [s_λ] h_b[h_6] ≥ [s_λ] h_6[h_b] for every λ ⊢ 6b (only ℓ(λ) ≤ 6 matters, since h_6[h_b] has no other constituents). Equivalently Sym⁶(Sym^b V) ↪ Sym^b(Sym⁶ V) in that range.
Re-run. verify_computations.py --run (unchanged, g++ 13.3, Boost 1.83) passes and matches all 62 reference output rows.
Independent checker. Rust, exact 128-bit integers with overflow checks. Unlike the paper’s Schur-basis Newton recurrences with signed lookups and an upper bound U to skip most partitions, it works in the weight basis: Newton’s identity j·ch Sym^j W = Σ_k ψ^k(W)·ch Sym^{j−k} W on dominant-weight multiplicities, with (ψ^k(W)·χ)(μ) = Σ_{s ∈ wt(W)} χ(sort(μ − k·s)), then Schur multiplicities by the Weyl alternation c(λ) = Σ_{w ∈ S₆} sgn(w) K(λ + δ − wδ). Every partition is computed exactly; no bound is used.
Checks. Σ_λ c(λ)·dim₆(λ) equals dim Sym⁶(Sym^b ℂ⁶) and dim Sym^b(Sym⁶ ℂ⁶) at every b; no negative multiplicities; A = B at b = 6. Self-tests: Thrall’s h₂[h_q] (q ≤ 12), h₃[h₂], h_q[h₂] (q ≤ 8), h₃[h₃].
Ties. Our count of λ with A = B (including A = B = 0) exceeds OpenAI’s table by 4 at b = 6, 3 at b = 7, 8 and 2 for every b from 9 to 25. Their table counts ties only among partitions their U-test could not settle, so this is expected.
Status. The full base interval b = 6 to 25 is done, zero violations; at b = 25 we check 1,229,120 partitions, matching the paper’s count for its largest complete level. The certificate layer (26 ≤ b ≤ 149) and the general argument are not checked.
]]>On 6 October 2026, OpenAI released 722 maths papers written by an AI. Some claim to solve problems that experts have been stuck on for decades.
The catch: almost none of it has been checked by humans yet. Writing proofs is now fast. Checking them is slow. That’s the bottleneck.
I’m not a mathematician. But some of these proofs lean on a big computer calculation, and a calculation is something anyone careful can re-check. So I picked one.
Take a deck of cards and think about all the ways you can shuffle it.
Mathematicians study shuffles by watching what they do to things. The simplest example is the cards themselves: a shuffle moves each card to a new place. You can also watch what a shuffle does to pairs of cards, or to more complicated patterns. Each of these is a different way of looking at the same shuffles.
Some of these views can be split into smaller, separate parts that never mix, and some can’t be split any further. The ones that can’t be split are the basic building blocks. Every other view is made of them, a bit like every whole number is made of primes. A deck of a given size has a fixed list of building blocks.
Combining a building block with itself means looking at pairs instead of single items. With 3 cards (A, B, C), instead of watching where each card goes, you watch where every pair goes: (A,A), (A,B), (B,C) and so on, 9 pairs in all. A shuffle that sends A to B and B to C turns the pair (A,B) into (B,C). This bigger collection then breaks back down into building blocks.
The puzzle: for almost every deck size, is there one building block that, combined with itself this way, breaks down into a list containing every building block at least once?
The paper says yes, for every deck size except 2, 4 and 9, where it is known to fail. For big decks it gives a written argument. For decks up to 64 cards it relies on a computer to check each case, and that computer part is what I checked.
It holds up. Every one of the 61 deck sizes checks out.
I checked the computer part, not the written argument for big decks. That still needs real mathematicians to read it.
AI can now produce maths faster than people can check it. Re-checking is how science decides what’s true, and some of it doesn’t need a PhD. There are plenty more results in OpenAI’s release that could be checked the same way.
All the code and results are public: github.com/realopjt/tensor-square-finite-check. I did this with help from Claude (Anthropic). The maths itself is OpenAI’s.
Claim checked. The finite-range proposition of Universal Tensor Squares for Symmetric Groups: for every 1 ≤ n ≤ 64 with n ∉ {2, 4, 9} there is a self-conjugate λ ⊢ n with g(λ, λ, ν) > 0 for every ν ⊢ n (the tensor square conjecture of Pak, Panova and Vallejo in that range).
Witnesses. OpenAI’s log records only exit statuses. I recovered the witness λ for each n by adding a print statement to a copy of their search (no change to its logic), e.g. λ = (13, 10, 8, 7, 6, 6, 4, 3, 2, 2, 1, 1, 1) at n = 64. Full list in the repo.
Independent checker. Rust, computing g(λ, λ, ν) = Σ_ρ χ^λ(ρ)² χ^ν(ρ) / z_ρ for all ν at once, modulo 2⁶¹ − 1 and 998244353 (OpenAI used 10⁹+7 and 10⁹+9). Differences from their implementation: rank-based partition indexing instead of hashed beta-set masks; border strips found from cells of hook length k and removed with the rim-hook formula instead of abacus bead moves; equal parts of ρ grouped by multiplicity with weight 1/(k^m m!) and a Horner scheme; dimensions from the hook length formula. Every target is nonzero modulo each prime separately. Built-in checks: Σ_ν g·dim ν = (dim λ)², g(λ, λ, (n)) = 1, g(λ, λ, (1ⁿ)) = 1.
Exact cross-check. A separate Python implementation (Murnaghan–Nakayama on cell sets, exact rationals) matches the checker coefficient for coefficient for n ≤ 22, and confirms no covering square exists for n = 2, 4, 9.
Scope. Finite range only. The large-n argument is not checked.
]]>