CatQualia/falsification-ledger

Falsification Ledger

Machine-written research ledgers recording claims that were tested against measurable thresholds, together with the verdicts produced by the author's own checking scripts. The majority of rows are negative or inconclusive results that were retained rather than discarded.

This dataset bundles three files written by one autonomous research process:

file	bytes	lines	data rows
FALSIFICATION_LEDGER.jsonl	17,295,354	16218	16217 (minus 1 corrupt line, see below)
FORMAL_VERDICTS.jsonl	142233	230	230
certified_nulls.json	8376	—	12 pre-registered claims

Schema

FALSIFICATION_LEDGER.jsonl — one JSON object per line:

field	type	rows containing it
claim	str	16214
threshold	str	16194
measured	dict/str	16152
n	int	16192
verdict	str	16217
method	str	16207
check	str	16192
ts	int/str	16217
evidence	str	15
reason	str	62
doc	str	48
note	str	8
next_ratchet	str	1
honest_note	str	2
source	str	7
did_not_survive	str	1
falsifier	str	3
tag	str	3
summary	str	3
detail	dict	2

checked as reported above: claim is absent on 3 rows, check on 25 rows, threshold on 23 rows, and n is present but null on 25 rows. The table lists 20 distinct keys in total, though only the first nine appear on anything like every row: the remaining 11 keys (evidence, reason, doc, note, next_ratchet, honest_note, source, did_not_survive, falsifier, tag, summary, detail) each appear on fewer than 70 rows and are absent from the overwhelming majority. The first record in the file has exactly nine keys; do not infer the schema from it.

FORMAL_VERDICTS.jsonl has a deliberately looser schema, because it merges several generations of record. Two distinct verdict fields exist and never co-occur on the same row, so the effective verdict is formal_verdict if present, otherwise verdict:

field	type	rows containing it
claim	str	230
doc_or_ledger_row	str	168
formal_verdict	str	192
evidence	str	230
overturns_prior	bool	207
ts	str	230
method	str	183
doc	str	62
steps	list	204
tool	str	24
batch	str	24
kind	str	38
verdict	str	38
prior_verdict	NoneType/str	22
chunk	str	15
note	str	15
primitive	str	23
pass	str	23
supersedes_prior_pass6_UNKNOWN	bool	2
supersedes	str	1

Verdict values and counts

FALSIFICATION_LEDGER.jsonl — verdict, counted over the 16217 parsable rows:

verdict	rows
REFUTED	5837
CONFIRMED	5520
UNVERIFIED	4815
STRONG_FALSIFIED / WEAK_CONFIRMED	39
CONTESTED	2
SURVIVES	1
CRASH	1
DRY	1
CONFIRMED-PROVEN	1

FORMAL_VERDICTS.jsonl — effective verdict (formal_verdict ?? verdict), 230 rows:

verdict	rows
PROVEN	180
EMPIRICAL-ONLY	37
REFUTED	10
UNKNOWN	3

certified_nulls.json — a different vocabulary again; these are pre-registered hypotheses graded as a set of twelve rather than as a running ledger:

verdict	rows
NULL	10
POSITIVE	1
BOUNDARY	1

What a record actually asserts

Each row in FALSIFICATION_LEDGER.jsonl is one test of one claim. The fields carry: claim (the proposition under test, in the author's own words), threshold (the pre-declared numeric condition that would confirm or refute it), measured (the observed value(s)), n (sample size), verdict, method, check (an identifier for the script or check that produced the verdict), and ts.

Five representative rows, quoted verbatim from the file:

• CONFIRMED — "The autonomous ingest loop COMPOUNDS (adds new rows most cycles)." Threshold: REFUTED if productive cycles < 50%. Measured productive_ratio = 0.5079 over n = 315 cycles. The claim held, but only just above its own refutation bound.
• CONFIRMED — "The forge produces mostly GENERATIVE charges (not decorative noise)." Threshold GENERATIVE/total > 0.50; measured ratio 0.6256 over n = 9824.
• REFUTED — of 18 isomorphism candidates listed in COMPOSITION_CANDIDATES.md, only 2 share genuine non-generic domain types; the rest are template artefacts. The measured field records the two that survived and names them.
• REFUTED — "The 3 largest datasets/*.jsonl have >90% unique rows (sellable)." Full-row exact dedup did exceed 90% (91.11% / 99.42% / 98.41%), but the rows differ only by timestamp, so the refutation is of the sellable part of the claim, not the uniqueness part. Verdicts in this ledger frequently hinge on a qualifier rather than the headline number.
• UNVERIFIED — a claim about per-row implementation scores could not be tested because no such field exists: measured records implementation_field: "ABSENT" across the corpus. UNVERIFIED here means "not testable as posed", not "test failed".

Two further examples showing the vocabulary is graded rather than binary:

• STRONG_FALSIFIED / WEAK_CONFIRMED — a four-surface grader-hardening claim. Threshold: STRONG_CONFIRMED iff Delta_after <= 0.05 on all four surfaces under one operator; STRONG_FALSIFIED iff any surface needs a structurally different operator; WEAK_CONFIRMED iff every surface closes under some operator. The measured field holds per-surface before/after deltas. The verdict is the compound label because the result sits between the two.
• CONTESTED — a cross-domain overlap test where two statistics disagreed: the cosine statistic fell below its shuffled-label null (z_cos = -78.83) while the Jaccard statistic rose above its null (z_jac = 3.85). Two simultaneous truth conditions, one met and one not, recorded as CONTESTED rather than resolved.

Provenance and verification status — read this before using

These verdicts are the author's own verdicts, produced by the author's own scripts running against the author's own files. They are not independent replication.

• The method field is dominated by the author's internal checking programs (ground-truth file check is the most common label among script-run methods; the three largest single methods are the author's own named checkers). The check field names the script or check, not an external replicator.
• ts values span 84 distinct values in FALSIFICATION_LEDGER.jsonl, from 1783591210 to 2026-09-13, and are written by the generating script rather than by a notary. All 230 rows of FORMAL_VERDICTS.jsonl carry the single timestamp 2026-06-22.
• Nothing in these files is signed, hash-chained, or externally attested. A row is a claim about a computation that the reader cannot see.

Several FORMAL_VERDICTS.jsonl rows are self-referential with respect to the author's earlier work: 4 rows carry overturns_prior: true, meaning the formal result contradicts a verdict the author had previously recorded elsewhere. Only 204 of 230 rows include a steps list showing the derivation.

What independent reproduction would require

To independently reproduce a single verdict from this dataset, a replicator needs:

1. The check script. 8607 rows have a check value ending in .py. 254 of those name a .py file that is not included in this dataset — the value names a module in the wider source tree rather than a file shipped here. Even the 8353 rows whose check value matches a filename in the source's falsifications/ directory cannot be run from this dataset alone, because falsifications/ is not part of it. The remaining 7585 rows name a bare check identifier rather than a file, which is not resolvable to a script from the ledger alone.
2. The input data the check read. The claims are about the author's corpus — row counts, ratios, and file contents under <<WME>>. That corpus is not shipped here.
3. The same thresholds and the same arithmetic. Some rows include the threshold, but 23 of 16217 do not; where the threshold is absent, the confirm/refute boundary has to be inferred from the text.
4. For FORMAL_VERDICTS.jsonl, the formal method is named (method cites specific solver versions, e.g. sympy1.14+z3-4.16) but the proof scripts are not included. Reproduction means re-deriving the obligation in a solver, not re-running a shipped artefact.

In short: this dataset is a faithful record of one process's self-assessment. It is evidence about that process, not evidence about the world.

Companion script directory — how a row maps to a script

The source tree carries a directory of falsifier scripts beside the ledger. Measured: falsifications/ holds 386 directory entries, of which 385 are regular files — 383 files matching *.py, plus _worklist.json and ueto_substrate4_results.json, and a __pycache__ directory. Those *.py files total 2,162,874 bytes; regular files including the two JSON files total 2,485,939 bytes, and every entry including the directory totals 2,518,707 bytes. That directory is not shipped in this dataset — these are the source numbers it would need to be checked against.

The link between a ledger row and a script is the check field, and it is not a uniform pointer. Measured over the 16217 parsable rows:

check value shape	rows	resolves to a shipped file?
absent	25	no
a bare identifier, e.g. loop_ingest_compounds, corpus_integrity_guard	7585	no
ends in .py, and the filename exists in falsifications/	8353	N of M = 8353 of 16217 rows name a script that exists there
ends in .py, filename not in falsifications/ (module reference)	254	no

So the direct answer to "does every row name a script that exists?" is no — 8353 of 16217 rows (51.5%) name a file that is present in falsifications/. 7585 rows (46.8%) name a bare check identifier that is not a filename at all; those correspond to checks implemented as functions inside the larger loop programs rather than as standalone falsifier scripts, and the ledger does not record which file defines them. 25 rows carry no check at all.

Note the direction of the mismatch: the 8353 resolvable rows draw on only a subset of the 383 scripts present. The directory holds more scripts than the ledger references by filename, so a reader cannot infer "one script per row" in either direction.

Known defects

• FALSIFICATION_LEDGER.jsonl contains 1 corrupt line at 1-indexed line 15254: a run of NUL bytes beginning at byte offset 16219770, produced by an interrupted write. It is the only line in the file that does not parse, and the 16217 parsable rows before and after it are intact. A reader should skip unparsable lines rather than fail.
• 25 rows carry n: null even though the field is present, so n cannot be treated as a reliable integer column without coercing.
• verdict mixes single labels with compound ones (STRONG_FALSIFIED / WEAK_CONFIRMED) and with rare process states (CRASH, DRY, SURVIVES). A naive 3-class filter over CONFIRMED / REFUTED / UNVERIFIED will silently drop those rows.
• ts is not uniformly typed across the wider corpus this was drawn from; within this file it is consistent.

How to load

import json
rows = []
for line in open("FALSIFICATION_LEDGER.jsonl", "rb"):
    line = line.strip()
    if not line:
        continue
    try:
        rows.append(json.loads(line))
    except json.JSONDecodeError:
        continue          # skips the single corrupt line

refuted = [r for r in rows if r.get("verdict") == "REFUTED"]

Internal paths — redacted (resolved, was a pre-release disclosure)

FALSIFICATION_LEDGER.jsonl originally carried the author's absolute filesystem paths in its measured and check values — the literal files his own machine inspected. An earlier revision of this card flagged that as an open publish-or-redact decision. It has been redacted.

Absolute machine paths are now replaced with stable tokens:

Token	Replaces
<<TREES>>	the author's primary research tree root
<<WME>>	the author's second research tree root
<<DRIVE>>	the author's external storage root
<<HOME>>	any other path under the author's home directory

Measured over the 16,218 lines (16,217 parsable rows): 630 rows carried such a path and now carry tokens instead; zero absolute owner paths remain. The redaction was verified to be row-count-identical and to leave every row valid JSON, because this ledger's published integrity claims — the row count, the composition split, the re-run analysis — all depend on that being true.

Two consequences worth stating plainly:

• The row count is unchanged at 16,218 lines / 16,217 parsable, so every count on this card still holds.
• Paths inside measured values are now tokenised too, so re-running a check against the author's own tree will produce a literal path where the ledger shows a token. Compare on the measured quantities, not on the path strings.

FORMAL_VERDICTS.jsonl and certified_nulls.json remain clean.

A note on why this is a real fix rather than cosmetics: a leaked directory layout is not sensitive in the way a credential is, but it is detail that helps nobody and identifies the machine. The author's own release pipeline treats /home/<user> and /run/media as leak patterns; this ledger now passes that same test.

Reproducibility — the replay result

The companion script directory is published as the falsification suite, and it ships verify_ledger.py, which re-runs the scripts and compares their fresh verdicts against the verdicts recorded here.

Run across all 299 shipped scripts referenced by this ledger:

Outcome	Scripts
Verdicts reproduced	163
Fresh UNVERIFIED — inputs not shipped	120
Import failed outright	13
No JSON_RESULT produced	2
Genuine divergences	1

The single divergence is fals_federation_of_clocks_hierarchy.py, which emits SURVIVES_GATED_OPTIMUM — a verdict label this ledger never recorded. That is a taxonomy mismatch rather than a failed reproduction, and it is reported as such.

Of this ledger's 16,217 rows, 8,353 (51.5%) name a script shipped in the suite and can be replayed by anyone; 254 name a fals_*.py that is not in the suite; and 7,610 were produced by bespoke internal checks whose harness is named in check but shipped nowhere. That last group is the honest gap in the record, and reproducibility_map.json names every one of them rather than leaving it as an average.

Files

• FALSIFICATION_LEDGER.jsonl — 17,295,354 B, 16217 parsable rows, 1 corrupt line.
• FORMAL_VERDICTS.jsonl — 142233 B, 230 rows.
• certified_nulls.json — 8376 B, a JSON array of 12 objects, each with id, name, claim, verdict, evidence, method, campaign, implication, and attestation object with source, provenance, and ts.

Licence

CC-BY-4.0 — attribution required, commercial use permitted.

Copyright 2026 Christopher Betances (catqualia.com)