mirror of
https://github.com/saymrwulf/dalek-ed25519-verified.git
synced 2026-09-03 20:13:48 +00:00
mrwulf
e2c5cf1d4b
Aeneas emits a *_Template.lean naming everything the extracted code needs from outside itself — the extraction's own statement of its boundary. extract.sh has always said, in prose, "after regenerating, diff the template against the hand-written file". Prose is not a gate, and the diff cannot be one: the two files legitimately differ in almost every line, holes and Aeneas comments against real definitions and modeling policy. MEASURING FIRST CHANGED WHAT THIS ITEM SHOULD BE. The TODO offered two options — enforce the diff, or pin both files — and the answer turned out to be neither. Both files were ALREADY byte-pinned by Phase 0b. And two further things stand here: the generated Funs.lean imports the model and CALLS these externals, so the Lean compiler enforces their TYPES wherever the extracted code uses them; and the per-certificate exact cones catch any external that becomes, or stops being, an assumption anything depends on. What none of those three sees is the CLASSIFICATION: for each name the extraction asks for, whether this repository answers with an ASSUMPTION or with a PROOF. That is the tier-A/B claim the documents make in prose — the curve calls and the three curve types resolve to proven definitions rather than axioms, because gen/CurveField/Funs.lean opens `namespace curve25519_dalek` and so defines the very names Aeneas asks for. Nothing checked it. A regeneration that renamed one, or a model that quietly answered one with an axiom instead, would have left the documents claiming a proof where the repository had an assumption. Phase 0d recomputes the classification with model-correspondence.py (namespace-aware, so a definition inside a namespace counts under its full name) and requires equality with the committed MODEL-CORRESPONDENCE.txt. UNRESOLVED — the extraction asking for something nothing here provides — is a hard failure. dalek 43 MODEL 8 PROVEN 3 EXTRA anza 38 MODEL 0 PROVEN 4 EXTRA (no CurveSig crate) risc0 36 MODEL 8 PROVEN 4 EXTRA betrusted 35 MODEL 8 PROVEN 4 EXTRA selftest-correspondence.sh, five cases, negative-tested by disabling the comparison. The case that matters is 2: a PROVEN external answered by an axiom instead. No name changes anywhere, every byte pin still matches, and it compiles, because the signature is unchanged — before Phase 0d nothing in the button could tell. Trap recorded for whoever extends it: case 3 first deleted the PROVEN rows, which was VACUOUS on anza, since anza has none — it removed nothing, the table still matched, and the case passed while testing nothing. It now deletes the first row whatever its verdict AND asserts the file changed. extract.sh now points at the gate instead of asking a human to look. Certified by a full sweep: both buttons, all four forks, purged trees, machine otherwise idle. 8/8 green.
74 lines
2.9 KiB
Python
Executable file
74 lines
2.9 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
"""Classify every external the extraction declares.
|
|
|
|
For each gen/<dir>/<X>_Template.lean, Aeneas states what the extracted Rust
|
|
needs from outside. Each such name must be provided by exactly one of:
|
|
|
|
MODEL — declared in the hand-written sibling gen/<dir>/<X>.lean: an
|
|
assumption, which the axiom gate and the per-certificate cones
|
|
then govern;
|
|
PROVEN — resolved to a real definition in the proven corpus, because a
|
|
module of this repository declares it (namespace-aware). This is
|
|
the valuable case and the one the docs claim for the tier-A/B
|
|
curve calls; nothing has ever checked it.
|
|
|
|
Anything else is drift: the extraction asks for something this repository does
|
|
not provide.
|
|
"""
|
|
import re, sys, os, glob
|
|
|
|
DECL = re.compile(
|
|
r'^[ \t]*(?:@\[[^\]]*\]\s*)?(?:private |protected |noncomputable |unsafe )*'
|
|
r'(axiom|def|abbrev|opaque|structure|inductive)[ \t]+([A-Za-z_][A-Za-z0-9_.\'!?]*)')
|
|
NS = re.compile(r'^[ \t]*(namespace|end)[ \t]+([A-Za-z_][A-Za-z0-9_.\']*)')
|
|
|
|
def declared(path):
|
|
"""Fully-qualified names declared in one file, honouring namespaces."""
|
|
names, stack = set(), []
|
|
for line in open(path, encoding='utf-8', errors='replace'):
|
|
m = NS.match(line)
|
|
if m:
|
|
if m.group(1) == 'namespace':
|
|
stack.append(m.group(2))
|
|
elif stack and stack[-1] == m.group(2):
|
|
stack.pop()
|
|
continue
|
|
d = DECL.match(line)
|
|
if d:
|
|
names.add('.'.join(stack + [d.group(2)]) if stack else d.group(2))
|
|
return names
|
|
|
|
def main(root):
|
|
gen = os.path.join(root, 'gen')
|
|
templates = sorted(glob.glob(os.path.join(gen, '*', '*_Template.lean')))
|
|
# The proven corpus: every generated module that is neither a template nor
|
|
# a hand-written model. These are the files Aeneas produced from Rust.
|
|
models = {t.replace('_Template', '') for t in templates}
|
|
corpus = set()
|
|
for f in sorted(glob.glob(os.path.join(gen, '*', '*.lean'))):
|
|
if f in models or f.endswith('_Template.lean'):
|
|
continue
|
|
corpus |= declared(f)
|
|
|
|
rows, unresolved = [], []
|
|
for t in templates:
|
|
model = t.replace('_Template', '')
|
|
rel = os.path.relpath(t, gen).replace('_Template.lean', '')
|
|
tnames = declared(t)
|
|
mnames = declared(model) if os.path.exists(model) else set()
|
|
for n in sorted(tnames):
|
|
if n in mnames:
|
|
rows.append(f'{rel}|{n}|MODEL')
|
|
elif n in corpus:
|
|
rows.append(f'{rel}|{n}|PROVEN')
|
|
else:
|
|
rows.append(f'{rel}|{n}|UNRESOLVED')
|
|
unresolved.append(f'{rel}|{n}')
|
|
for n in sorted(mnames - tnames):
|
|
rows.append(f'{rel}|{n}|EXTRA')
|
|
print('\n'.join(rows))
|
|
print(f'CORRESPONDENCE-COUNT|{len(rows)}')
|
|
return 1 if unresolved else 0
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(main(sys.argv[1]))
|