Dataset Viewer
Auto-converted to Parquet Duplicate
name
stringlengths
8
25
category
stringclasses
9 values
family
stringclasses
4 values
scored
bool
2 classes
filename
stringclasses
2 values
content
stringlengths
0
1.36k
why_a_pass_is_unearned
stringlengths
31
212
empty_json_object
empty
any
true
case.json
{}
an object with no members: there is no property here to check
empty_json_array
empty
any
true
case.json
[]
zero records; any 'all records satisfy P' is vacuously true
empty_file
empty
any
true
case.jsonl
zero bytes; a verifier that reports success has verified nothing
whitespace_only
empty
any
true
case.jsonl
no records, but not zero bytes — a naive length check passes this
empty_graph
empty
graph
true
case.json
{}
no nodes: 'no cycle exists' is true and says nothing about your system
zero_bindings
empty
certificate
true
case.json
{ "bindings": [], "checked": 0 }
nothing was bound, so nothing was compared
chain_tail_removed
truncated
chain
true
case.jsonl
{ "decision": "admit", "hash": "9d820cafe552ad3e28728cac1927198be0e9267a584d6a7db076d73bc9c884ac", "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 0} { "decision": "admit", "hash": "ed64379c2eb4ee2f809fd905476548bff93724da63d851745029341984d9693a", "prev": "9d820cafe552ad3e2872...
a prefix of a hash chain verifies PERFECTLY; only an anchor reveals the missing tail
chain_last_record_cut
truncated
chain
true
case.jsonl
{ "decision": "admit", "hash": "9d820cafe552ad3e28728cac1927198be0e9267a584d6a7db076d73bc9c884ac", "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 0} { "decision": "admit", "hash": "ed64379c2eb4ee2f809fd905476548bff93724da63d851745029341984d9693a", "prev": "9d820cafe552ad3e2872...
the final record is cut mid-JSON: a line-wise reader may simply drop it
json_truncated_mid_object
truncated
certificate
true
case.json
{ "bound": 0.01, "records"
invalid JSON that begins validly; a streaming parser can emit a partial result
chain_without_anchor
no_anchor
chain
true
case.jsonl
{ "decision": "admit", "hash": "9d820cafe552ad3e28728cac1927198be0e9267a584d6a7db076d73bc9c884ac", "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 0} { "decision": "admit", "hash": "ed64379c2eb4ee2f809fd905476548bff93724da63d851745029341984d9693a", "prev": "9d820cafe552ad3e2872...
internally consistent and tied to nothing; self-consistency is not authenticity
cert_unsigned
no_anchor
certificate
true
case.json
{ "bound": 0.001, "schema": "example/v1", "signature": null, "verdict": "PASS" }
a verdict with no signature and no pinned key: nothing attests to it
self_referential_root
no_anchor
certificate
true
case.json
{ "index": { "root": "abc123" }, "root": "abc123", "verified_against": "index" }
the artifact is checked against a value it itself supplies
single_record
sound_pass
chain
false
case.jsonl
{ "anchor": { "sth": "9d820cafe552ad3e28728cac1927198be0e9267a584d6a7db076d73bc9c884ac", "witnessed_by": "example-log" }, "decision": "admit", "hash": "9d820cafe552ad3e28728cac1927198be0e9267a584d6a7db076d73bc9c884ac", "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 0}
one record with a valid genesis pointer. A chain of length one has no LINK to check, but it is a well-formed chain and accepting it is defensible.
single_node_graph
sound_pass
graph
false
case.json
{ "a": [] }
one node waiting on nothing. A verifier MAY pass this: a system where nobody waits genuinely cannot wedge. Listed so over-refusal is visible, not scored.
bound_of_one
degenerate
certificate
true
case.json
{ "false_pass_bound": 1.0, "n": 0, "verdict": "PASS" }
a bound of 1.0 excludes nothing; passing under it is not evidence
sample_size_zero
degenerate
certificate
true
case.json
{ "failures": 0, "rate": 0.0, "trials": 0 }
0 failures in 0 trials is a rate of nothing, not a rate of zero
all_cases_skipped
degenerate
certificate
true
case.json
{ "failed": 0, "passed": 0, "skipped": 12, "tests": 12 }
every case was skipped; a green result here means nobody ran anything
not_json
malformed
any
true
case.json
this is not json at all
the correct response is a diagnosis naming the expected shape, not a verdict
wrong_root_type
malformed
any
true
case.json
"a bare string"
a string where an object was required
nan_bound
malformed
certificate
true
case.json
{"verdict": "PASS", "false_pass_bound": NaN}
NaN compares false against every threshold, so a naive `bound < t` check rejects it, but a naive `not (bound > t)` check ACCEPTS it
negative_count
malformed
certificate
true
case.json
{ "records": -5, "verdict": "PASS" }
a negative count is not a count
bom_and_crlf
malformed
chain
true
case.jsonl
{ "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 0}
a byte-order mark ahead of the first record breaks strict parsers silently
future_schema_version
out_of_distribution
certificate
true
case.json
{ "fields_you_do_not_know": true, "schema": "example/v99", "verdict": "PASS" }
a schema version from the future: 'I do not recognise this' is the honest answer
unknown_verdict_value
out_of_distribution
certificate
true
case.json
{ "bound": 0.01, "schema": "example/v1", "verdict": "PROBABLY_FINE" }
an unrecognised verdict string must not be coerced to the nearest known one
cyclic_where_dag_expected
out_of_distribution
graph
true
case.json
{ "a": [ "b" ], "b": [ "a" ] }
a cyclic graph handed to something expecting a DAG; infinite loop or wrong answer
seq_repeats
out_of_distribution
chain
true
case.jsonl
{ "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 0} { "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 1} { "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 1} { "prev": "00000000000000000000000000000000000000...
a repeated sequence number: two records claim the same position
rtl_and_unicode_ids
sound_pass
graph
false
case.json
{ "\u0645\u0633\u062a\u062e\u062f\u0645": [], "\u202eadmin": [ "\u0645\u0633\u062a\u062e\u062f\u0645" ] }
identifiers containing a right-to-left override RENDER deceptively, but the graph is genuinely acyclic. Passing it is correct; the defect is in display, not the verdict, so scoring it would be a false accusation.
valid_chain_with_anchor
positive_control
chain
false
case.jsonl
{ "decision": "admit", "hash": "9d820cafe552ad3e28728cac1927198be0e9267a584d6a7db076d73bc9c884ac", "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 0} { "decision": "admit", "hash": "ed64379c2eb4ee2f809fd905476548bff93724da63d851745029341984d9693a", "prev": "9d820cafe552ad3e2872...
a well-formed anchored chain: a working verifier SHOULD accept this
valid_acyclic_graph
positive_control
graph
false
case.json
{ "a": [ "b" ], "b": [ "c" ], "c": [] }
a genuine acyclic wait-for graph with three nodes and two edges
valid_certificate
positive_control
certificate
false
case.json
{ "false_pass_bound": 0.001, "n": 4000, "schema": "example/v1", "scope": "the enumerated domain", "signature": "deadbeef", "verdict": "PASS" }
a complete certificate with a finite bound, a scope and a signature
broken_chain_link
negative_control
chain
false
case.jsonl
{ "decision": "admit", "hash": "9d820cafe552ad3e28728cac1927198be0e9267a584d6a7db076d73bc9c884ac", "prev": "0000000000000000000000000000000000000000000000000000000000000000", "seq": 0} { "decision": "admit", "hash": "ed64379c2eb4ee2f809fd905476548bff93724da63d851745029341984d9693a", "prev": "9d820cafe552ad3e2872...
record 3's back-pointer is wrong: a working verifier SHOULD reject this
cyclic_graph
negative_control
graph
false
case.json
{ "a": [ "b" ], "b": [ "a" ] }
a two-cycle: a working deadlock checker SHOULD reject this

Abstain Corpus — inputs a verifier must not pass

32 inputs for testing whether a verifier claims success on something it could not possibly have checked. 24 are scored; 8 are controls that make the score mean anything.

Every verifier — a linter, an SBOM scanner, an attestation checker, a policy engine, a deadlock detector — has the same tempting shape: return success unless you find a problem. Hand one an empty file, a truncated log, or an artifact with no trust anchor and it finds no problem, so it reports success. It has verified nothing, and said so in green.

This corpus is the input side of that test. The harness that scores against it is abstain-bench; the data is published separately so it is reusable by anyone building a verifier, in any language.

Load it

from datasets import load_dataset

ds = load_dataset("nickh007/abstain-corpus", split="train")
print(len(ds))                                        # 32
scored = ds.filter(lambda r: r["scored"])             # 24
print(scored[0]["name"], scored[0]["why_a_pass_is_unearned"])

Or regenerate it from source — the corpus is constructed, not stored, so every case is reproducible:

pip install abstain-bench
abstain-bench export ./cases

Fields

field meaning
name stable identifier
category which way this input has nothing to check (below)
family chain, graph, certificate, or any
scored whether passing it counts as an unearned pass
filename the name to write it as (.json / .jsonl matters to some parsers)
content the artifact itself, verbatim
why_a_pass_is_unearned the reason, in a sentence

Categories

category n why a pass is unearned
empty 6 zero records, nodes or bindings. all([]) is True
malformed 5 not the thing it claims to be; the right answer is a diagnosis, not a verdict
out_of_distribution 4 a schema, version or shape the verifier does not know
truncated 3 a hash chain's prefix verifies perfectly; only an anchor reveals the missing tail
no_anchor 3 internally consistent, tied to nothing. Self-consistency is not authenticity
degenerate 3 structurally valid, semantically vacuous: a bound of 1.0, a sample of size zero

The 8 unscored rows, and why they exist

positive_control (3) — valid artifacts a working verifier should accept, one per family. negative_control (2) — clearly broken artifacts it should reject.

These are not decoration. A verifier that exits non-zero on absolutely everything scores a perfect zero unearned passes and is completely useless. Any harness using this corpus must refuse to report a score until the subject accepts a positive control and rejects a negative one — otherwise the headline number is an artefact of the harness rather than a property of the tool.

sound_pass (3) — cases a verifier may legitimately pass, scored in neither direction.

These exist because the first live run of the associated benchmark accused a correct verifier of two unearned passes. {"a": []} — one node waiting on nothing — genuinely cannot deadlock. An acyclic graph whose identifiers contain a right-to-left override is still acyclic; the deception is in how a terminal renders the name, not in the verdict. Both were moved out of the numerator. A corpus that manufactures findings is exactly as untrustworthy as the unearned passes it exists to measure. They are kept and still run, because over-refusal is a real defect too — it is just not this one.

Family scoping matters

A graph checker handed a truncated hash chain will refuse it — because it is not a graph. That is a free correct answer for a reason unrelated to truncation, and counting it inflates the score. Score a subject only on the families whose positive control it accepted.

Honest scope

A 0% unearned-pass rate against this corpus means: on these inputs, in the families the subject demonstrated it handles, it never claimed success on something it could not check. It does not mean the verifier is correct — this covers one failure mode, not soundness — and the corpus is not exhaustive. It covers six ways of having nothing to check; there are certainly others. With 24 scored cases, report an exact binomial interval rather than a bare proportion: 0 of 24 is not "0% ± 0%".

Licence

Apache-2.0. Generated by abstain-bench (abstain_bench.corpus.build_corpus).


The rest of the portfolio

25 artifacts, one idea: a measurement you cannot check is a press release. Every tool here reports; none of them gates.

Tools

abstain-bench how often does a verifier pass input it could not check?
evidence run the whole portfolio over your repo — the weakest leg, never the mean
floorgen what must your system remember? an exact lower bound
formal-proof-mcp a proof kernel for your coding agent
gatecount exactly how many states does removing this check admit?
gridlock certify a wait-for relation cannot wedge
honestbench measure your CI's escape rate
kvleak cross-tenant leak scanner
kvprobe model-substitution detector with a measured FPR
preregister refuses to seal a plan whose conclusion is already fixed
proof-carrying-ci the whole portfolio as one CI check, with SARIF
proof-to-code-drift fail the build when the proof stops matching
sf-verify re-derive admission decisions offline
signoff-cert certificates that carry their own false-pass bound
tokencount a token count both parties can recompute

Benchmarks — each recomputes one of our own published numbers from its certificate

illusion-bench how many broken kernels does your oracle admit?
kv-reuse-econ-bench recompute our economics headline
llm-tenant-isolation-bench recompute our isolation figures

Datasets

abstain-corpus 32 inputs a verifier must NOT pass ← you are here
kv-reuse-econ-traces per-workload reuse accounting + the closed form
kv-tenant-isolation-bench isolation observations, uninterpretable rows included
llm-precision-fingerprints precision-labelled logprobs with a negative control

Try it in a browser — no install, no GPU

negative-results-atlas ten claims we took back
tenant-leak-demo the residency calculator
wait-for-visualiser paste a wait-for graph, see the cycle

Documentation

Everything above, explained in one place: https://nickharris808.github.io/evidence-docs/ — the tutorial, what this proves and what it does not, and a CLI reference generated by running --help on every published command.

The commercial edition

Everything above is measure-only and Apache-2.0: it tells you what is true and never acts on it. The enforcement side — binding a partition key at the admission decision, the compiled gate corpus, and the certificate-issuing faucet — is covered by filed patents and licensed separately.

Reading is free. Enforcing is licensed.

Downloads last month
-