claim_check
Check a claim by entailment over the figures in the answer you were given. This does not read your sentence: the verdict comes from the arithmetic, so it is the same claim in any language. Pass the receipt and one or more claims in the claim grammar, naming a figure by its path in the payload, for example {"op": "<=", "left": "report.level_noise_sd", "right": 12, "scope": "marginal"}. An element of an array is named either cells[0].median or cells.0.median; both resolve. Arithmetic is written {"op": "/", "left": ..., "right": ...} with +, -, * and /. ONE RULE ABOUT DECIMALS, because it decides which claims can pass. A figure the payload carries as a decimal is read as rounded, so `== 20.57` against it is `not_entailed` no matter how exactly the digits match: equality would assert a precision the answer never had. Claim a decimal with <=, >=, or an interval. Whole numbers are read as exact, so equality against a count does pass. AND THE CONSEQUENCE, because callers have read it the other way and withdrawn a true answer. `not_entailed` from an equality claim over a decimal says your CLAIM WAS THE WRONG SHAPE. It does not say the figure is unsupported, it is not a finding about the payload, and it is never a reason to retract the sentence or to refuse the question. Reclaim it as the bound you meant, or, if what you actually want is to QUOTE the published figure in a sentence, that is not this tool at all: `judgement_check` reads the sentence and answers there, and a figure this receipt already served is supported by that receipt whether or not you restate it. MEASURED 2026-09-10: an agent told to check before writing reached for `== 20.77` against a payload carrying 20.77, read the refusal as the record failing it, and declined a question it had already answered correctly. Only `entailed` licenses writing the claim down. Every other verdict is a refusal with its own remedy: `refuted`, the payload settles it the other way; `not_entailed`, the payload does not settle it either way; `invalidated`, the claim rests on a figure that restates the arguments you passed in; `undefined`, the payload carries no figure of that name; `out_of_scope`, the claim asks at a scope this world cannot support; `vacuous`, the claim consults no payload figure at all; `indeterminate`, the arithmetic denotes no value; `not_composable`, the claim puts a figure inside arithmetic that this world declares means nothing once combined with anything, so there is no better number to go and find. AN ANSWER ECHOES YOUR INPUT BACK, AND AN ECHO IS NOT EVIDENCE. An audit returns the rows it summarised, so some figures in the payload are the numbers you supplied. Every figure whose value your own arguments carry is named in the reply under `world.restates_your_input` and licenses nothing: a claim touching one comes back `invalidated`. This is deliberately conservative, so a computed figure that happens to equal a number you passed is refused too. It cannot see a number you copied out of your own input and wrote into the claim as a literal, so a claim over your own grid is your assertion and not this world's. A QUANTITY AN ANSWER ONLY BOUNDS IS CLAIMED BY THE NAME OF ITS REGION. Where a payload carries a region, an object with `lower_end` and `upper_end`, the path of that object is declared as the quantity the region admits, and it is listed under `world.declared.bounded` with `at_least` and `at_most`, either of which is null where the payload declares no wall on that side. Claim about that path: for a region ending at 0.9 the claim `<= 0.9` is entailed and `== 0.9` is not, which is the difference between a bound and a score. A claim about `region.upper_end` instead is a claim about the end of the region and says nothing about the quantity. A BOOLEAN FIELD IS CLAIMED WITH `==` OR `!=` AGAINST `true` OR `false`, and a flag is often the most important qualifier on an answer. A payload that states one has decided it, so the world admits that single value: equality against the value the payload states is entailed and equality against the other is refuted. Every flag is listed under `world.declared.flags` at the value the payload states, and the path there is what a claim names on the left. There is no ordering over a flag, so `<`, `<=`, `>` and `>=` against one are refused rather than answered. `null` is not a value at all: a null field is declared by nothing, a claim about it is `undefined`, and `null` on the right of any operator is unreadable. EQUALITY AGAINST A DECIMAL FIGURE ALMOST NEVER PASSES, and that is not a fault to work around. A decimal in a payload is a rounded figure, so it is declared one ulp wide either side and `== 2040` comes back `not_entailed` on a figure of 2040.0. Claim the interval you are actually writing, `>= 2039.5` and `<= 2040.5`, which is what licenses the sentence "about 2040". A count crosses as an integer, is exact, and does pass equality. This world is built from one payload, so it declares that payload's numeric figures and its flags and nothing else, at marginal scope only. It carries no per-case or per-segment scope, no relations and no declared incomparability, so a claim about this case, about one named segment, or about a lineage is refused here rather than guessed, and restating your input is the only reason a figure here is unusable. Every field it could not declare, text and nulls, is named in the reply under `world.not_declared`. This is not judgement_check and neither falls back to the other. A claim you send here gets this tool's verdict.
Use this form for new arguments. Follow concrete links for known values. Fetch-only readers may be unable to submit new URLs.
Exact input contract
{
"properties": {
"claims": {
"description": "One claim per entry, in the claim grammar. A comparison is `op`, `left` and `right`; a membership claim is `op` `in` with `right` a list of labels; a lineage claim is `rel` with `edge` or `reaches`. `scope` is required on every shape.",
"items": {
"properties": {
"left": {
"description": "A figure's dotted path, a number, or an arithmetic object."
},
"op": {
"description": "The comparison.",
"enum": [
"<",
"<=",
">",
">=",
"==",
"!=",
"in"
],
"type": "string"
},
"right": {
"description": "A figure's dotted path, a number, an arithmetic object, or `true` or `false` against a flag. `null` is refused: an absent value is not a value."
},
"scope": {
"description": "\"marginal\", \"per_case\", or {\"per_segment\": \"name\"}. Required: a claim whose scope is defaulted is the overclaim this check exists to refuse. A payload-derived world supports \"marginal\" only."
},
"sentence": {
"description": "The prose you mean to write. THE VERDICT NEVER READS IT: the arithmetic decides, so the same claim in any language gets the same verdict. It is recorded on the receipt, and it is what the model advisory beside `claims` reads — an opinion that overturns no verdict and licenses nothing.",
"type": "string"
}
},
"required": [
"scope"
],
"type": "object"
},
"type": "array"
},
"receipt": {
"description": "The receipt id from the answer this claim rests on.",
"type": "string"
}
},
"required": [
"receipt",
"claims"
],
"type": "object"
}