claimbox · the claim language for cert-machine

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.

every sentence, and what came back DeepMind’s cryptids release ×× 107 decided22 name the reason AI phrasings of a Riemann certificate 56 decided24 name the reason cert-machine’s register 74 decided72 name the reason cert-machine’s word a named hole × refuted
every sentence, and what came back DeepMind’s cryptids release ×× 107 decided22 name the reason AI phrasings of a Riemann certificate 56 decided24 name the reason cert-machine’s register 74 decided72 name the reason cert-machine’s word a named hole × refuted

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.

agreement with cert-machine
10 of 10
of cert-machine’s own hand-written claims, reproduced field for field
planted defects caught
56 of 56
a moved digit, a flipped relation, a swapped file: each comes out refused or decided differently
digits compared exactly
2,598,236
for one bound on the root of xx = 64, with no logarithm evaluated
AI models writing claims
17
each given the same rules; every claim that passed the checks, 715 of them, came back CERTIFIED
see it translate

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.

a theorem, as a paper prints it
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
written by Gemini 4 Argon; the same claim, passing every check, from 17 of 17 models
a constant cut off with “…”, in a post
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
written by Claude Opus 5.5; the same claim, passing every check, from 17 of 17 models
a bound written right to left
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
written by Claude Opus 5.5; the same claim, passing every check, from 12 of 17 models
a leaderboard record
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
written by Claude Opus 5.5; the same claim, passing every check, from 4 of 11 models
a results notebook
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
written by DeepSeek V4 Pro; the same claim, passing every check, from 6 of 11 models
a theorem no finite check decides
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.
named by Gemini 4 Argon: not a claim any finite check decides, so none is written
AI models write it · checks decide what counts

17 AI models wrote claims. Every one that passed the checks held.

715 of 715
claims that passed every check, CERTIFIED by cert-machine

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.

of 80 sentences: stated as a claim, and passed every check Gemini 3.8 Flash 50 Gemini 4 Argon 50 Claude Opus 5.5 49 Kimi K3.1 Pro 49 Qwen 3.8 Max 47 GLM-5.3 45 MiniMax M3 44 model:deepseek-v4-pro.guide2 44 GPT-OSS 120B 43 GPT-6 Luna 41 GPT-6.1 Sol 41 model:gpt-6.1-sol.guide2 38 model:gpt-6-luna.guide2 37 model:mistral-large-2512.guide2 36 DeepSeek V4 Pro 34 Mistral Large 34 Grok 4.7 33 passed every checkstated, then refused
of 80 sentences: stated as a claim, and passed every check Gemini 3.8 Flash 50 Gemini 4 Argon 50 Claude Opus 5.5 49 Kimi K3.1 Pro 49 Qwen 3.8 Max 47 GLM-5.3 45 MiniMax M3 44 model:deepseek-v4-pro.guide2 44 GPT-OSS 120B 43 GPT-6 Luna 41 GPT-6.1 Sol 41 model:gpt-6.1-sol.guide2 38 model:gpt-6-luna.guide2 37 model:mistral-large-2512.guide2 36 DeepSeek V4 Pro 34 Mistral Large 34 Grok 4.7 33 passed every checkstated, then refused

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 one wrong claim, caught
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
The sentence writes its bound right to left. The model read it the wrong way round; the checks refused the claim before anything decided it, and cert-machine, given it anyway, refutes it.
write a claim

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
for people and for models

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.

proof 1 of 2 · honesty

It says why when it cannot

49 of 49
refusals in cert-machine’s register that name their reason

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.

prose, no claim shape33 prints no quantity23 needs its bytes21 can be read two ways13 nothing decides that quantity9 about every case9 approximate (≈)4
prose, no claim shape33 prints no quantity23 needs its bytes21 can be read two ways13 nothing decides that quantity9 about every case9 approximate (≈)4

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.

proof 2 of 2 · exact

xx = 64, trapped by fractions

210
bounds on the roots of xx = y, certified, for 105 values of y

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 →

3.3991 < x < 3.3992width 1.0e-04 58815/17303 < x < 47207/13888width 4.2e-09 458912/135009 < x < 400097/117706width 6.3e-11 each row zooms in: the line is the root, the box its two fractions
3.3991 < x < 3.3992width 1.0e-04 58815/17303 < x < 47207/13888width 4.2e-09 458912/135009 < x < 400097/117706width 6.3e-11 zooming in: the root, and its two fractions

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.

the uses

Three ways to use it

for anyone who publishes a number

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.

for teams whose models write claims

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.

for AI agents that cite numbers

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.

how it works

From a sentence to one of three words

  1. The sentenceas the author printed it, in a file anyone can open.|D(1)| ≤ 0.82395317
  2. The claimwritten in claimbox’s language: which bytes, how they are read, which bound. If that cannot be done exactly, the reason is named.
  3. The objectthe pinned bytes, their reading, and each bound as the exact number its digits mean, printed back in plain words.
  4. 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
built on

Small parts, each checkable

cert-machineThe only judge. claimbox never prints a verdict of its own; it shows cert-machine’s.
The languageClaims, holes and forks: every reading of the bytes written down, every reading decided.
The libraryEach definition written once and used by name, from step functions to the busy beavers.
The grammar of evidenceSolid for decided, dashed for computed, dotted for chosen. The red × only marks a witness.
bring one claim

Send a sentence. Get back a claim, decided, or the reason it cannot be.

  1. The sentenceand where it is printed: a paper, a README, a post, a model’s output.
  2. The bytesit is about, or where they live. A claim about data no one can open stays a named hole.
  3. The answerthe claim in claimbox’s language with cert-machine’s word on it, or the exact reason it cannot be stated.
for the careful reader · the roadmap

Where claimbox goes next

The language is built in this order. A step is called built only when its checks pass.

#stepwhat you gethow it is checkedstatus
0Today's translatora closed list of claim shapes read by patterns, readers of real sources, objects cert-machine decidesthe calibration objects reproduced; planted defects caught; every refusal has a red controlbuilt
1The language, written downLANGUAGE.md: the syntax, readings, holes, forks, the print-back, the object, and examples, each a claim already decidedevery 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'sbuilt
2Read it and print it backa parser that rejects malformed claims with a reason, and the plain-words printerevery example round-trips; planted malformed claims are rejectedbuilt
3Compile and checkclaim, object, cert-machine's word, and what it rests onthe same words cert-machine gives today, claim for claimbuilt
4The librarythe definitions written once: kissing, the autocorrelation constants, the platform scores, the Riemann functionals, machine runs, each with its conventionsidentical objects to today'sbuilt
5Holes and forksrefusals become named holes; ambiguous readings become forks, every reading decidedthe decimal and double readings of one file give their two exact counts; every refusal today maps to a holebuilt
6From prose to claimsanyone 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 sourcesthe AI phrasings and the register, measured; every planted mistranslation caught; the refusal rate publishedbuilt
7Helpers and watcherstighten, attack, fill; watchers for "for all" claims that report how far they searchedevery proposal is decided by cert-machine; planted twins halt where predictedbuilt
8Documents that builda report whose numbers are claims: it does not build when one is refuted, and each number shows what it rests onone existing report rebuilt this waybuilt
9Teaching models to write itthe Claim Court environment on the Hub; its first task is writing claims claimbox readsthe share of validated claims before and after trainingresearch
10Proposal loops at scalemany model proposals, the deterministic filter, cert-machine's word, counterexamples fed backthe target pinned first; red controls before every loop; every denominator publishedresearch
decided
exact arithmetic, or an exact count from a record
computed
a number someone printed; nothing decided it
refused
a named hole: the reason, never a guess

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.