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.

Papers report that a protocol was verified. This is the ledger underneath one: every result the effort named, which prover carried it, and what kind of obligation it was — queryable in one line. Use it as an index into a real verification effort, as a re-derivation target list, or as data on where proof effort actually goes.

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

Load it

from datasets import load_dataset

ds = load_dataset("nickh007/pqc-formal-corpus", split="train")
ds.num_rows                                     # 122
sorted(ds.unique("prover"))
# ['cryptoverif', 'easycrypt', 'lean', 'squirrel', 'tamarin', 'tla']

# every result about resource bounds, whichever prover proved it
list(ds.filter(lambda r: r["category"] == "resource-bound")["name"])
# ['bounded', 'bounded_at_canonical', 'naive_unbounded', 'separation',
#  'window_admits_and_bounded', 'window_nonempty']

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

The four extracted fields are exact. The two marked derived are indexing aids — how far to trust them.

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

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

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 How category and polarity are derived describes, shown rather than hidden.

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.

How category and polarity are derived

These two fields are indexing aids, not ground truth — here is exactly how far to trust them. The four extracted fields (prover, name, kind, module) carry no interpretation at all.

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.

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.

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 How category and polarity are derived.

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

Eleven 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	source
pqc-sizes-js	The same arithmetic for Node and the browser	source
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-bounds-lean	The same bound in Lean 4 — 0 sorry, 0 imports	source
pqc-dos-gate-rtl	The gate in synthesizable RTL, 5 Yosys proofs	source
pqc-migration-mcp	Six MCP tools for AI agents	source
pqc-mfb	322 cases · 39 failure families · scorer	source
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

New here? The end-to-end tutorial walks one realistic migration through all of them in about ten minutes: sizes -> window -> CI gate -> benchmark.

In a hurry? 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, with no install.

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.