nickh007/pqc-formal-corpus

Dataset Card — PQC Formal Corpus

Summary

122 named formal results — theorems, lemmas, goals, queries and invariants — from a single sustained effort to mechanically verify a post-quantum authenticated key exchange, spread across 6 prover dialects.

Each row records what was named and where, plus two derived index fields. It is a map of what has been mechanically established about one PQC migration: usable as an index, a teaching aid, or a target list for independent re-derivation.

• Rows: 122
• Provers: 6 (Lean, EasyCrypt, Tamarin, TLA+, CryptoVerif, Squirrel)
• Format: JSON Lines, one result per line
• Licence: Apache-2.0

Schema

Field	Type	Description
prover	string	dialect the result lives in: lean, easycrypt, tamarin, tla, cryptoverif, squirrel
name	string	identifier the result is proven under, e.g. no_key_reinstall
kind	string	theorem · lemma · goal · query · invariant
module	string	source module stem, no path, e.g. MerkleBeacon
category	string	derived subject bucket, e.g. downgrade, resource-bound
polarity	string	derived role: safety · reachability · reduction · control · bound · security-property · structural · other

Distribution

prover	results
easycrypt	51
tamarin	35
lean	20
tla	14
cryptoverif	1
squirrel	1

polarity	results
safety	32
reachability	15
structural	15
bound	14
reduction	14
security-property	13
other	15
control	4

⚠️ category and polarity are heuristics, not ground truth

Both are derived from the identifier string alone by substring matching, not from the proof body or any semantic analysis. They exist to make 122 rows browsable. They are useful for filtering and wrong often enough that you should not build a claim on them.

Two known behaviours, documented rather than hidden:

• Controls are checked before safety properties. A control is typically named for the property it deliberately fails to uphold (naive_forgery_is_free), so testing safety first would file it as the property itself. There is a test asserting this ordering.
• 15 rows land in polarity: other and 7 in category: other. Those are rows whose names carry no signal the heuristic recognises, not rows that mean nothing.

prover, name, kind and module are extracted directly and carry no interpretation.

What is NOT in this dataset

No proof bodies. No tactic scripts. No model source.

A name plus its provenance is an index. The mechanised argument stays in the closed tree, because several of these proofs encode repair mechanisms directly, and publishing the argument would publish the repair.

Two tests enforce this. One greps the shipped file for proof syntax (:=, by omega, qed, Proof., sorry, admit) and fails if any appears. The other asserts that every row carries exactly the six documented fields and nothing else, so no internal annotation can ride along with an identifier.

Prover builtins are excluded. attacker is a ProVerif builtin predicate, not a lemma. Before the denylist it was extracted as the sole "ProVerif result" — which would have made the corpus quietly wrong. ProVerif therefore contributes zero rows: its models are query-driven in a form this extractor does not treat as named results. That is a real limitation, not an omission.

How it was produced

One regex per dialect over the committed prover sources, then:

1. drop identifiers shorter than 5 characters (they collide with ordinary language);
2. drop anything in the builtin denylist;
3. deduplicate on (prover, name);
4. derive category and polarity from the name;
5. sort by (prover, name) so the output is byte-stable across runs.

python -m pqc_formal_corpus.build <formal-models-root> \
    src/pqc_formal_corpus/data/pqc_formal_corpus.jsonl

CLI

The package ships a pqc-corpus command:

pip install git+https://github.com/nickharris808/pqc-formal-corpus
pqc-corpus stats
pqc-corpus query --prover lean --category resource-bound
pqc-corpus export --format csv -o corpus.csv

Usage

from pqc_formal_corpus import load, by_prover, by_category

results = load()
len(results)                                   # 122
by_prover(results)                             # {'cryptoverif': 1, 'easycrypt': 51, ...}

safety = [r for r in results if r.polarity == "safety"]
[r.name for r in safety][:3]
# ['no_safe_policy_skips_gate', 'no_third_option', 'no_eap_method_downgrade']

# every result about resource bounds, whichever prover proved it
[r.name for r in results if r.category == "resource-bound"]
# ['bounded', 'bounded_at_canonical', 'naive_unbounded', 'separation',
#  'window_admits_and_bounded', 'window_nonempty']

Note no_third_option in that safety list: it is really a dichotomy result, filed as safety because the heuristic matches the no_ prefix first. That is the imprecision the warning above describes, shown rather than hidden.

# Hugging Face
from datasets import load_dataset
ds = load_dataset("nickh007/pqc-formal-corpus")

Intended use

• An index into what one PQC migration has actually proven, and in which prover.
• A re-derivation target list — every row names something a third party could independently formalise and check against.
• Research on verification practice: how effort distributes across provers, how many results are controls versus properties, what a multi-prover corpus looks like in shape.

Out of scope

• Not the proofs. You cannot check these results from this dataset; it names them.
• Not a benchmark. There is no task, no split, no metric. For a scorable benchmark see PQC-MFB.
• Not a completeness claim. These are the results this effort named. A property nobody named is absent, and absence here says nothing about the protocol.
• Not a vulnerability disclosure.

Limitations and biases

• One effort, one protocol family. Everything derives from a single verification push on post-quantum Wi-Fi authentication. Category proportions reflect that effort's priorities, not the field's.
• Extraction is regex-based, so a result declared in an unusual syntactic form is missed. ProVerif contributing zero rows is the clearest instance.
• easycrypt dominates at 51/122, which reflects where the computational proofs live, not that EasyCrypt results matter more.
• Derived fields are heuristic — see the warning above.

Citation

@misc{pqcformalcorpus2026,
  title  = {PQC Formal Corpus: named results from a post-quantum verification effort},
  author = {{PQC Migration Safety Lab}},
  year   = {2026},
  note   = {122 named results across 6 prover dialects}
}

Contact

Issues via the repository. For the closed core, open a GitHub Discussion or an issue.

---

The PQC migration toolkit

Nine free tools for teams moving authenticated key exchange to post-quantum. They find and measure; they do not repair.

Tool	What it does	Where
pqc-sizes	Sizes, fragment counts, and the two-sided reassembly window	PyPI
pqc-sizes-js	The same arithmetic for Node and the browser	npm
pqc-guard-action	Fail the build when the window is empty	GitHub Action
pqc-dos-embedded	169 lines of C: the failure on a real 64 KB device	source
farkas-check	Re-verify the bound on-device, no SMT solver	source
pqc-migration-mcp	Six MCP tools for AI agents	PyPI
pqc-mfb	322 cases · 39 failure families · scorer	PyPI
pqc-mfb (data)	The benchmark as a dataset	HF
pqc-formal-corpus ← you are here	122 named formal results, 6 provers	HF
pqc-explorer	Try it in your browser, no install	HF Space

Start here: pqc-sizes tells you in five seconds whether your credential fragments and whether a safe cap exists. pqc-explorer does the same in a browser.

The closed core

Closing the 39 failure families — downgrade binding, retransmission-safe installation, fragmentation transcripts, roaming forward secrecy, multi-link key separation, admission control, group-key binding — is a separate proprietary codebase. Relevant subject matter is covered by a filed provisional patent application.

That split is measured, not asserted: under a replicate noise control only 4 of 32 repair mechanisms are externally distinguishable, so publishing these detectors does not disclose the repairs.

For commercial licensing, open a GitHub Discussion or an issue on any of these repos.