CatQualia/falsification-suite

Falsification Suite

Standalone Python scripts, one per claim, each attempting to falsify a specific claim made in the accompanying research campaign documents. Published by CatQualia. Author: Christopher Betances — catqualia.com.

This suite is replayable — here is the measured result

Most datasets assert that their contents were verified. This one lets you re-run the verification, and publishes how much of it reproduces.

verify_ledger.py takes the accompanying falsification ledger, finds every row that names the script which produced it, re-runs that script, parses the JSON_RESULT it prints, and compares the fresh verdict against the recorded one. Run across the whole suite:

Outcome	Scripts
Verdicts reproduced	163
Fresh UNVERIFIED because inputs are not shipped	120
Could not import (author's modules or packages absent)	13
Produced no JSON_RESULT	2
Genuine divergences	1

The single divergence is not a failure to reproduce. fals_federation_of_clocks_hierarchy.py emits the verdict SURVIVES_GATED_OPTIMUM, which the ledger never recorded — a taxonomy mismatch, where the script has a verdict vocabulary the ledger does not. It is reported rather than smoothed over.

Reproduce it yourself:

python3 verify_ledger.py --ledger FALSIFICATION_LEDGER.jsonl --scripts . --limit 30
python3 verify_ledger.py --ledger FALSIFICATION_LEDGER.jsonl --scripts . --limit 0 --jobs 6

Two things to understand before running it:

1. UNVERIFIED is not agreement. A script that cannot measure returns UNVERIFIED and states why. It is counted separately from a reproduced verdict: counting it as agreement would overstate the record, and counting it as disagreement would understate it.
2. Set WME_ROOT if you hold the author's code. Many scripts import modules (hj_spectral_bridge, gpu_scheduler) and read model weights or grader data that are not in this repository; they look for them under $WME_ROOT, defaulting to a placeholder. Without it they degrade honestly to UNVERIFIED with a stated reason — which is why 120 scripts land in that bucket. With it, the reproducible fraction rises. The scripts do not pretend otherwise.

Coverage: which ledger rows can be replayed at all

reproducibility_map.json joins this suite to the ledger and reports, per row, whether the recorded outcome can be re-derived:

Ledger rows	Status
8,353 (51.5%)	Replayable — the row names a script shipped here
7,610 (46.9%)	Bespoke check — an internal harness with no shipped script
254 (1.6%)	Names a script absent from this suite

That table is the honest measure of how verifiable the ledger is. Half of it can be re-derived by anyone holding this repository. The other half is named but not yet packaged, and this file says so rather than implying the whole record is reproducible.

What this collection is

This is a corpus of 308 executable Python scripts that each take one research claim and try to break it by measurement rather than argument. The scripts were written as part of an internal research workflow in which claims are not allowed to stand on rhetoric: a claim earns belief only if a script that would have killed it fails to do so on real, on-disk data.

The scripts are not a library. They are not imported by each other and they share no package structure. Each is a self-contained program that measures one thing and prints a verdict.

Two overlapping families exist in the collection:

• 149 hand-written falsifiers. These read a real artifact (a JSONL dataset row count, a file size, a corpus statistic, a recomputed metric) and compare it against a pre-registered numeric threshold.
• 159 auto-emitted stubs. These were generated mechanically by a script named research_recursion_bridge.py so that an unmeasured claim would occupy a visible, counted ledger row rather than disappear. The stubs are explicit that they do not measure anything. See Limitations.

How many scripts

Metric	Value	Command
Python scripts staged	308	find . -maxdepth 1 -name 'fals_*.py' | wc -l
Total bytes	1,969,284	find . -maxdepth 1 -name 'fals_*.py' -printf '%s\n' | python3 -c "import sys;print(sum(int(x) for x in sys.stdin))"

The shared interface

The interface is a convention, not an enforced abstraction. Across the 308 scripts:

Property	Scripts	Command
Defines def main()	304	grep -l 'def main' fals_*.py | wc -l
Prints a JSON_RESULT= line	306	grep -l 'JSON_RESULT' fals_*.py | wc -l
Defines def measure()	198	grep -l 'def measure' fals_*.py | wc -l
Declares a module-level CLAIM = constant	231	grep -l '^CLAIM' fals_*.py | wc -l
Declares a module-level THRESHOLD = constant	231	grep -l '^THRESHOLD' fals_*.py | wc -l
Auto-emitted stubs	159	grep -l 'AUTO-EMITTED' fals_*.py | wc -l

Four scripts have no def main and two print no JSON_RESULT= line, so the convention is near-universal rather than total.

Input

Whatever ground truth the claim rests on. Most commonly a JSONL corpus under the sibling datasets/ directory, a file size, or a recomputed corpus statistic. Four scripts resolve paths relative to a parent repository root:

REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
CORPUS = os.path.join(REPO, "datasets", "anime_metaphor_engine.jsonl")

77 scripts reference a datasets path, 35 a model path, 12 a reports path. The referenced artifacts are not included in this dataset (see Limitations).

Computation

The substantive scripts follow a common three-step shape: load the ground-truth artifact, compute the claimed quantity alongside a null or baseline, then compare the difference against a pre-registered threshold. The verdict is then selected by an explicit branch. From fals_alignment_scalar_gate_phase_coherence.py, verbatim:

# ---- PRE-REGISTERED VERDICT ----
revived = bool(phase_minus_partition > 0.05 and ph_beats)
if revived:
    verdict = "CONFIRMED"
    note = "REVIVED: phase-coherence beat partition by >+0.05 held-out AND beat its null."
elif directed_revival:
    verdict = "REVIVAL-CONDITIONAL"
    ...
else:
    verdict = "REFUTED"

That script's own docstring states its pre-registered thresholds verbatim:

  REVIVED  : held-out  real_corr(phase) - real_corr(partition) > +0.05  AND phase beats its null
  REFUTED  : phase fails +0.05 over partition AND/OR fails its null on the symmetric graph
  REVIVAL-CONDITIONAL: phase fails on symmetric, BUT directed q>0 beats q=0 by held-out +0.05

Output

A single machine-parseable line on stdout:

print("JSON_RESULT=" + json.dumps(out))

The out object carries claim, threshold, measured, n, and verdict. Because n is included, a measurement that silently read zero rows is detectable rather than silent. This is the reason n is present at all.

Verdict vocabulary

Verdicts are string literals. Counting occurrences of each literal across the suite (not the number of scripts that can emit it):

Verdict	Occurrences	Meaning in this framework
UNVERIFIED	304	The claim was not measured. Either a stub, or a real script whose ground truth was absent.
REFUTED	146	The measurement contradicted the claim, or fell below the pre-registered threshold.
CONFIRMED	145	The measurement met the pre-registered threshold.
PASS	7	Non-standard synonym for CONFIRMED used in a few scripts.
FALSIFIED	3	Non-standard synonym for REFUTED.
FAIL, FALSE, TRUE, INCONCLUSIVE	1 each	Non-standard, used in single scripts.
REVIVAL-CONDITIONAL	—	Third state used where a claim fails on one graph but survives on a directed variant.

Command: grep -hoE '"(UNVERIFIED|CONFIRMED|REFUTED|FALSIFIED|INCONCLUSIVE|PASS|FAIL|TRUE|FALSE)"' fals_*.py | sort | uniq -c

How to run one script

# 1. Fetch the dataset
git clone https://huggingface.co/datasets/CatQualia/falsification-suite
cd falsification-suite

# 2. Run a script (most are stdlib-only; 79 need numpy)
python3 fals_acceptance_rate_prediction_adaptive_draft_leng.py

# 3. Read the verdict
# JSON_RESULT={"claim": "...", "threshold": "...", "measured": {...}, "n": 0, "verdict": "UNVERIFIED", ...}

Verified working example — fals_acceptance_rate_prediction_adaptive_draft_leng.py runs to completion with exit status 0 and prints a JSON_RESULT= line:

{"claim": "On a *small* target model \u2014 the regime WaveMotion actually runs on a single dying laptop \u2014 the", "threshold": "proves the optimal policy is a threshold policy: stop and verify when `P(\u22651 rejection) > \u03c4`. [REAL] A *trained*", "measured": {"status": "STUB_NOT_YET_MEASURED", ...}, "n": 0, "verdict": "UNVERIFIED"}

That output is a stub reporting UNVERIFIED, which is the honest result for it — it demonstrates the reporting convention, not a measured finding.

Most scripts are pure standard library. 79 require numpy (grep -l 'import numpy' fals_*.py | wc -l). One script, fals_asi_feasibility_and_timeline.py, performs live HTTP requests to arxiv.org and will hang or fail without network access.

What a falsified claim means in this framework

A falsifier is written before the verdict is known, with its threshold fixed in the source, so the number cannot be chosen after seeing the result. When a script returns REFUTED, the claim is treated as removed from the project's working set of beliefs: fals_agentic_benchmarks_swebench.py illustrates the terminal consequence, where a refutation is written into the output as a generalizable conclusion —

"REFUTED: empty and list-all agents score ~0 on the real grader; the "
"sec 5 null holds and the ABC exploit does not transfer here."

CONFIRMED does not mean proven. In this framework it means this specific falsification attempt, at this threshold, on this data, failed to break the claim. The claims here are narrow and mostly quantitative, so a CONFIRMED verdict is evidence about one measurement, not a validated theory. The collection is closer to a lab notebook with executable entries than to a benchmark suite.

The verdict field always describes the fate of the script's own pre-registered hypothesis, and is not consistently oriented relative to a source document's claim. In fals_asi_feasibility_and_timeline.py the script quotes a claim it is attacking — Claim: "ASI is bound to be discovered" — REFUTED as stated. — so a reader who scans only for the word REFUTED cannot tell whether the source claim or its negation was refuted. That specific inverted framing appears in 1 script. Read each script's threshold and measured fields rather than the verdict string alone.

Limitations

Read these before drawing any conclusion from a verdict.

1. The ground-truth artifacts are not included. 77 scripts read from a datasets/ directory and 35 from a model/ directory that are not part of this release. Run as-is, most substantive scripts will raise FileNotFoundError or report UNVERIFIED. Confirmed by execution: fals_alignment_scalar_gate_phase_coherence.py fails with FileNotFoundError: [Errno 2] No such file or directory: '.../datasets/anime_metaphor_engine.jsonl'. The scripts document their methods and thresholds reproducibly; the numbers are not reproducible from this repository alone.
2. 159 of 308 scripts (52%) measure nothing. They are auto-emitted stubs that return STUB_NOT_YET_MEASURED and the verdict UNVERIFIED. Their docstrings state this in the source, verbatim: "STATUS: UNVERIFIED STUB. This fires a ledger row so the doc's claim is TRACKED in FALSIFICATION_LEDGER.jsonl instead of sitting un-fired. It does NOT yet run a real measurement -- it reports verdict=UNVERIFIED (loud, first-class) so the gap between "claim written" and "claim measured" is VISIBLE and COUNTED, never hidden." These files are included because the stub/hand-written split is itself the finding.
3. The CLAIM field is not always a claim. Of the 231 scripts declaring a module-level CLAIM = constant, most hold a verbatim claim string. In a number of files the same variable name holds document metadata instead — for example fals_CHECKPOINT_BATCH4.py holds "Timestamp: 2026-06-18 (post-break resume) · Status: STAGED, SAFETY ON, awaiting Captain fire signal." Field semantics are therefore not uniform. manifest.json records the constant verbatim and does not repair it.
4. 77 scripts declare no CLAIM constant. Their claim is stated in prose under a section heading in the module docstring (e.g. WHAT THE DOC CLAIMS in 38 scripts). manifest.json records these as "not determined from the content" and preserves the full docstring instead, so the text can be read at its source rather than reconstructed.
5. 16 files are not falsifiers. Files named with an uppercase stem (fals_MASTER_INVENTORY.py, fals_RESEARCH_NOTES.py, fals_DOCUMENT_QUALITY_AUDIT.py, fals_CANONICAL_TYPES.py, among others) are project-admin and checkpoint documents that carry the fals_ prefix but do not falsify a claim. Command: ls fals_*.py | grep -cE 'fals_[A-Z]'
6. Not peer-reviewed. Every claim, threshold, corpus, and verdict is the author's own. Nothing here has been independently verified, and the CONFIRMED/REFUTED strings are self-assigned.
7. A stale count to be aware of. Some scripts quote corpus statistics in their docstrings that no longer match the present corpus; fals_MASTER_INVENTORY.py contains the line - 122 documents total in reports/research_campaigns/ (5.9 MB). Those strings are frozen at authoring time and are not current measurements.

Files

• manifest.json — machine-readable index of all 308 scripts. Per script: filename, bytes, claim_verbatim (copied from the script's own constant, never paraphrased), claim_source, source_doc, threshold_verbatim, docstring, docstring_header, verdict_literals, is_stub, has_measure, emits_json_result.
• fals_*.py — the 308 scripts.
• build_manifest.py — stdlib-only generator for manifest.json. Re-run with python3 build_manifest.py to regenerate the index from the scripts themselves.
• LICENSE — MIT.

Why MIT

MIT is the right choice here because the payload is executable source code rather than prose or data. The scripts are meant to be read, run, modified, and re-used as templates for writing one's own falsifiers, and MIT permits all of that with no ambiguity and minimal obligations — retain the notice, accept the warranty disclaimer. A more restrictive license would obstruct the only useful thing to do with the collection. MIT imposes no restriction on the claims or documents the scripts describe, and grants no rights over the underlying research corpora or model weights, which are not distributed here. The LICENSE file also carries the author's site, catqualia.com.

Citation

@misc{betances2026falsificationsuite,
  author       = {Betances, Christopher},
  title        = {Falsification Suite: 308 Executable Claim-Falsification Scripts},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/CatQualia/falsification-suite}},
  note         = {Author site: catqualia.com}
}