Claims are written in words no machine can check. claimbox states them so one can.
claimbox is a language, and a translator into it. A sentence from a paper, a README, a leaderboard or an AI’s answer becomes an exact claim: the bytes it is about, how they are read, and each bound as the exact number its digits mean. A person or an AI model writes the claim by its rules; claimbox checks the writing and prints it back in plain words; cert-machine decides it with one of three words, CERTIFIED, REFUTED or REFUSED. When a sentence cannot be stated exactly, the reason is named instead of a guess.
Three collections of claims, as their authors wrote them. Each sentence came back with cert-machine’s word on it, or with the exact reason it cannot be stated as a claim. None was dropped, and none was guessed.
From the sentence an author printed to the claim a machine decides
Real sentences, each given alone to an AI model with claimbox’s rules. The model writes the claim; claimbox prints it back from the object cert-machine receives, never from what was typed; cert-machine decides. Where a sentence states no claim a finite check can decide, the model names the hole instead.
- the sentence
- Theorem 1.2. We have $|D(1)| \leq 0.82395317$, where $D(1) = T_{256}/256 - 1/2$ is the discrepancy at $1$ of the form factor of the $256$-periodic law.
- the claim
|D(1)| ≤ 0.82395317- printed back
- |D(1)| is at most 0.82395317 (exactly 82395317/10^8)
- cert-machine
- CERTIFIED
- the sentence
- c₁* = 0.7532960… and 1/c₁* = 1/2 + (1/√2)·cot(1/√2). the Montgomery–Taylor constant has a clean closed form
- the claim
c₁* = 0.7532960…- printed back
- c₁* lies in [47081/62500, 7532961/10^7): the digits 0.7532960 cut off
- cert-machine
- CERTIFIED
- the sentence
- $3\cdot 10^{-40} \geq \left| 256\,S(j) - j \right|$ for all $j \in \{1, \dots, 255\}$, with $S(j)$ the grid form factor of the $256$-periodic law.
- the claim
for every j in 0 < j < 256 : |256·S(j) - j| ≤ 3·10⁻⁴⁰- printed back
- for every integer j from 1 to 255: |256·S(j) - j| is at most 3·10⁻⁴⁰ (exactly 3/10^40)
- cert-machine
- CERTIFIED
- the sentence
- n = 21 circles in a rectangle of perimeter 4 (bounding box w + h ≤ 2), no overlaps: Σ r = 2.3658323759
- the claim
circ_ours_2026 is a feasible solution of "Circles in a Rectangle (n = 21)" and its score is 2.3658323759- printed back
- circ_ours_2026 meets every condition of "Circles in a Rectangle (n = 21)", and the score the platform defines is in [47316647517/20000000000, 47316647519/20000000000]: 2.3658323759 as a rounding
- cert-machine
- REFUTED
- the sentence
- the notebook's "Rank-96 decomposition of <4,4,8> over 0.5*C" is a decomposition of that tensor of rank 96 over that ring
- the claim
n["Rank-96 decomposition of <4,4,8> over 0.5*C"] is a rank-96 decomposition of <4,4,8> over 0.5*C- printed back
- the factors in n under "Rank-96 decomposition of <4,4,8> over 0.5*C" sum to the tensor <4,4,8> with 96 rank-one terms over 0.5*C
- cert-machine
- CERTIFIED
- the sentence
- Theorem 1. Every Dirichlet $L$-function, including $\zeta(s)$, is zero-free in $\operatorname{Re} s > 7/8$.
- the claim
- hole unbounded
- why
- The sentence states a theorem claiming a zero-free region for every Dirichlet L-function, which no finite check can decide.
17 AI models wrote claims. Every one that passed the checks held.
Each model was given the same rules and the same 80 AI-written sentences, one at a time, and wrote 768 claims between them. None of the checks is a model: every number must be found in its sentence, the claim must read back with the sentence’s own relation, move exactly when one digit of its bar is moved, and stay put when the sentence is reworded. A claim that fails one is refused and named, and the others still count.
Among the claims the checks refused, 1 was wrong, and the checks refused it before cert-machine refuted it: it is below. Asked 3 times, Gemini 4 Argon wrote the same claim, or named the same hole, for 80 of the 80 sentences. On cert-machine’s register, 11 models wrote 250 claims that passed, and 27 sentences are validated: the grammar and a model, two different kinds of writer, agree. On the AI phrasings 3 are, so far: every model counts as one kind of writer, and the second kind there is a person.
17 AI models, each given the same rules and the same sentences one at a time, wrote the claims. Each bar is how many it stated; the solid part, how many passed every check. None of the checks is a model.
- the sentence
- $3\cdot 10^{-40} \geq \left| 256\,S(j) - j \right|$ for all $j \in \{1, \dots, 255\}$, with $S(j)$ the grid form factor of the $256$-periodic law.
- MiniMax M3 wrote
for every j in 0 < j < 256 : |256·S(j) - j| ≥ 3·10⁻⁴⁰- printed back
- for every integer j from 1 to 255: |256·S(j) - j| is at least 3·10⁻⁴⁰ (exactly 3/10^40)
- the checks
- refused: it does not read back with the sentence’s relation; it does not move exactly when the sentence’s bar is moved; its word does not move as the arithmetic says when its bar moves
- cert-machine
- REFUTED
One file says what is claimed, about which bytes, read how
The language is small: the source that prints the sentence, the data it is about and how its bytes are read, the definitions it uses, and the claim. A model gets the same rules as a person, written down once in the guide.
source P = notes/my-paper.md data f = corpus/my-construction.json read f as doubles use C_1b v1 claim my_bound over f quote "the construction gives C_1b ≤ 1.5029" from P : C_1b ≤ 1.5029
The rules, written once
Copy the bar exactly as printed. Keep the sentence’s relation, read the right way round. Use only the names the library defines over the data. When a sentence states no exact claim, write the hole and its reason: a hole is an answer. The same text is the prompt an AI model is given.
It says why when it cannot
Most claims fail to be checkable for an ordinary reason: the bytes they are about were never published, the sentence prints no number, or it states a limit no finite run can reach. claimbox names the reason for each one, out of 146 sentences. A sentence is never silently dropped and never guessed at.
The reasons a sentence could not be stated, across the three collections. Most need the bytes the claim is about, or print no quantity at all.
xx = 64, trapped by fractions
The root of xx = 64 is not a fraction, but two fractions can trap it, 458912/135009 below and 400097/117706 above. Each side reduces to comparing two whole numbers of about two and a half million digits, compared exactly. That fixes the first nine decimals, with no logarithm evaluated. The full study →
The root of xx = 64, trapped between fractions. Each step is one comparison of whole numbers on each side, decided exactly, with no logarithm evaluated.
Three ways to use it
Say exactly what you claim
Write the claim once in claimbox: the file, its reading, the bound. claimbox prints it back in plain words from the object cert-machine decides, never from what was typed. A reader then knows exactly what was checked, and on which bytes.
Count only what holds up
Let a model propose, and let claimbox validate. Each number must be found in the source and the claim must read back with the sentence’s relation. The bar is moved and the claim must move with it; the sentence is reworded and the claim must stay put. A second kind of proposer must agree. What fails is named, not hidden.
Write the claim, not the adjective
Give a model the guide and a sentence; it writes the claim, or the hole and its reason. claimbox checks the writing, cert-machine decides it, and the agent reports only what came back CERTIFIED, with what it rests on.
From a sentence to one of three words
- The sentenceas the author printed it, in a file anyone can open.|D(1)| ≤ 0.82395317
- The claimwritten in claimbox’s language: which bytes, how they are read, which bound. If that cannot be done exactly, the reason is named.
- The objectthe pinned bytes, their reading, and each bound as the exact number its digits mean, printed back in plain words.
- cert-machine’s wordfrom a separate program that shares no code with claimbox: CERTIFIED, REFUTED with the object that breaks it, or REFUSED with the reason.CERTIFIED
Small parts, each checkable
Send a sentence. Get back a claim, decided, or the reason it cannot be.
- The sentenceand where it is printed: a paper, a README, a post, a model’s output.
- The bytesit is about, or where they live. A claim about data no one can open stays a named hole.
- The answerthe claim in claimbox’s language with cert-machine’s word on it, or the exact reason it cannot be stated.
Where claimbox goes next
The language is built in this order. A step is called built only when its checks pass.
| # | step | what you get | how it is checked | status |
|---|---|---|---|---|
| 0 | Today's translator | a closed list of claim shapes read by patterns, readers of real sources, objects cert-machine decides | the calibration objects reproduced; planted defects caught; every refusal has a red control | built |
| 1 | The language, written down | LANGUAGE.md: the syntax, readings, holes, forks, the print-back, the object, and examples, each a claim already decided | every shape today's grammar reads and every rule it refuses with has its construct (a battery check); each claim's round trip is step 2's | built |
| 2 | Read it and print it back | a parser that rejects malformed claims with a reason, and the plain-words printer | every example round-trips; planted malformed claims are rejected | built |
| 3 | Compile and check | claim, object, cert-machine's word, and what it rests on | the same words cert-machine gives today, claim for claim | built |
| 4 | The library | the definitions written once: kissing, the autocorrelation constants, the platform scores, the Riemann functionals, machine runs, each with its conventions | identical objects to today's | built |
| 5 | Holes and forks | refusals become named holes; ambiguous readings become forks, every reading decided | the decimal and double readings of one file give their two exact counts; every refusal today maps to a hole | built |
| 6 | From prose to claims | anyone proposes a translation of a sentence; claimbox validates it: numbers found in the source, the print-back, two proposals of different kinds agreeing, also on planted sources | the AI phrasings and the register, measured; every planted mistranslation caught; the refusal rate published | built |
| 7 | Helpers and watchers | tighten, attack, fill; watchers for "for all" claims that report how far they searched | every proposal is decided by cert-machine; planted twins halt where predicted | built |
| 8 | Documents that build | a report whose numbers are claims: it does not build when one is refuted, and each number shows what it rests on | one existing report rebuilt this way | built |
| 9 | Teaching models to write it | the Claim Court environment on the Hub; its first task is writing claims claimbox reads | the share of validated claims before and after training | research |
| 10 | Proposal loops at scale | many model proposals, the deterministic filter, cert-machine's word, counterexamples fed back | the target pinned first; red controls before every loop; every denominator published | research |
Every number on this page is read from claimbox’s records when the page is built, and the build checks each one again. The records, the language and the tests are on GitHub.