universal-physics-tensor 8.0.0 → 10.0.0

package/dist/atlas/physjs-ref.js

@@ -8,48 +8,30 @@
  * `tests/atlas/physjs-manifest.test.ts` fails when the file and that table disagree
  * on the commit, a theorem, a key, or the coverage phrase.
  *
- * The commit is `PHYSJS_COMMIT`, copied from the manifest. The sentence that
- * the pin is PhysJS `main` `03e8bb77c952f720bdd2730af2afc6a7f2d36243` is the
- * record from before the table was generated.
- * PhysJS #63 stores each Lean file at `lean/<File>.lean`. The sentence that
- * the pin is `92f87257a1e3086a48cdc19fe4361cc1c5909d49` is the record from
- * before PhysJS #65. The sentence that the pin is
- * `ee753df77bd5b29b7207443181606b6004bfcf6a` is the record from
- * before PhysJS #64. The sentence that the pin is
- * `4ea35872513f8d4d12a01bfac225156bdddb87a9` and that the path is
- * `lean/PhysJS/<File>.lean` is the record from before that flatten. The
- * sentence that the pin is `3af15b49be09442350510e7c7f56f4aab92ea3bc` and
- * that the path is `PhysJS/<File>.lean` is the record from before PhysJS #61.
- * Theorem names of the earlier entries are unchanged. PhysJS #62 adds be-74,
- * be-75, and be-76. PhysJS #64 adds be-77 through be-87. PhysJS #65 adds
- * be-88 through be-102.
- * Milestone 1's six top-level theorems are unchanged. Milestone 2 adds four
- * atlas entries. Milestone 2b adds fifteen catalog entries. Bucket A adds
- * twenty-one counted catalog entries, keyed `be-<n>`. BE-20 is the nested
- * `corollary` on `be-13` and has no key. A counted covers line begins with
- * `reduction`, `limit`, or `derivation-step`. A labeled covers line begins
- * with `property` or `cross-check`. A nested object (`planeWave`, `oneLoop`,
- * `inversion`, `vacuum`, `corollary`, `friedmann`, `lengthMonomial`,
- * `torsionMonomial`, `coefficientNotFixed`, `unitCoefficient`, `scalingShape`,
- * `everyPower`, `perpendicularQuartic`, `tolmanRatio`) is recorded and is not
- * a `formalRef`. The sentence that those fourteen names are the whole nested
- * set is the record from before BE-103 through BE-125. That ingestion adds
- * `warmSound`, `cutoffL`, `whistlerLimit`, `equalTemperature`, `bohmGross`,
- * `referenceResistivity`, `lundquist`, and `bohmFlux`. PhysJS #66 adds
- * be-103 through be-125. The sentence that the pin is
- * `03e8bb77c952f720bdd2730af2afc6a7f2d36243` and that the table stops at
- * be-102 is the record from before that pin. PhysJS #67 adds be-126 through
- * be-133. The sentence that the pin is
- * `d519c2c6504e7fbbd2cf6932f9e52981ce595a0f` and that the table stops at
- * be-125 is the record from before that pin. PhysJS #68 adds be-134 through
- * be-146. The sentence that the pin is
- * `8515c621d1c6e6d31c2eea4467181eb85d58234b` and that the table stops at
- * be-133 is the record from before that pin. That ingestion adds
- * `heisenberg_fraction`.
+ * The commit is `PHYSJS_COMMIT`, copied from the manifest. Which PhysJS pull
+ * request added which keys, and what the pin was before, is history and lives
+ * in `NOTES.md` and `CHANGELOG.md`, not here.
+ *
+ * Each statement's `kind`, nested ones included, is the manifest's own field
+ * (schema `physjs-bridge-manifest/v2`), which PhysJS reads from the kind line
+ * of the Lean file that declares the theorem; this module keeps no override
+ * and does not parse the covers line for it. A field of a manifest entry
+ * outside the base fields is a nested statement: a second theorem on the same
+ * entry, named by the field, with no key. It is recorded and compared, and it
+ * is not a `formalRef`. The generator reads it by its shape, so a new nested
+ * name needs no edit here.
+ *
+ * A reference's `fidelity` is DERIVED here, never typed on a record:
+ * `physjsFidelity` reads the reviewed-row table (`physjs-reviewed.ts`) and the
+ * sanity-lemma key list, and a key ahead of the catalog, or whose row is not
+ * in that table, is `'unreviewed'`.
  *
  * @module atlas/physjs-ref
  */
-import { catalogEdgeKey } from '../bridges/catalog-load.js';
+import { createHash } from 'node:crypto';
+import { FORMAL_REF_KINDS } from '../relations/types.js';
+import { catalogEntries, catalogIdNumber } from '../bridges/catalog-load.js';
+import { PHYSJS_REVIEWED_ROWS, PHYSJS_SANITY_LEMMA_KEYS } from './physjs-reviewed.js';
 import { PHYSJS_COMMIT, PHYSJS_MATHLIB, PHYSJS_PHYS_LIB, PHYSJS_TOOLCHAIN, PHYSJS_ENTRIES as GENERATED_PHYSJS_ENTRIES, } from './physjs-entries.generated.js';
 /**
  * PhysJS commit the vendored manifest records.
@@ -62,52 +44,41 @@ export { PHYSJS_COMMIT } from './physjs-entries.generated.js';
  * `bound.delta` does not certify the regime, the horizon, or the side conditions.
  */
 const PHYSJS_COVERAGE = 'covers its statement only';
-/** Nested objects the manifest schema records. A new name is a problem. */
-const NESTED_FIELDS = [
-    'planeWave',
-    'oneLoop',
-    'inversion',
-    'vacuum',
-    'corollary',
-    'friedmann',
-    'lengthMonomial',
-    'torsionMonomial',
-    'coefficientNotFixed',
-    'unitCoefficient',
-    'scalingShape',
-    'everyPower',
-    'perpendicularQuartic',
-    'tolmanRatio',
-    'warmSound',
-    'cutoffL',
-    'whistlerLimit',
-    'equalTemperature',
-    'bohmGross',
-    'referenceResistivity',
-    'lundquist',
-    'bohmFlux',
-    'heisenberg_fraction',
-];
-const ENTRY_FIELDS = new Set([
-    'key',
-    'bridgeId',
-    'theorem',
-    'covers',
-    'coverage',
-    'leanProof',
-    'axioms',
-    'imports',
-    ...NESTED_FIELDS,
-]);
-/** Counted catalog kinds. Not a property and not a cross-check. */
-const COUNTED_KIND = /^(reduction|limit|derivation-step): /;
 /**
- * Labeled catalog kinds. A reader tells them from a counted statement by
- * this word. They occupy a catalog `formalRef` and are not the counted kind.
+ * The axioms a complete Lean 4 proof over Mathlib may rest on. `#print axioms`
+ * of a proof with a `sorry` adds `sorryAx`, and Lean still exits 0 (TOOLS.md),
+ * so every statement's list is held to this set; PhysJS reports the list and
+ * this repository does not re-measure it.
+ */
+const PHYSJS_ALLOWED_AXIOMS = new Set(['propext', 'Classical.choice', 'Quot.sound']);
+/** The fields of a manifest entry. Any other field is a nested statement. */
+const BASE_FIELDS = new Set(['key', 'bridgeId', 'theorem', 'kind', 'covers', 'coverage', 'leanProof', 'axioms', 'imports']);
+/** The fields of a statement, sorted. A nested field with exactly these is a statement. */
+const STATEMENT_FIELDS = ['axioms', 'coverage', 'covers', 'kind', 'leanProof', 'theorem'];
+/**
+ * The nested statements of a manifest entry, in field order: every field
+ * outside the base fields whose value has exactly the statement fields. A
+ * field that is neither is returned in `problems`.
+ * @internal
  */
-const LABELED_KIND = /^(property|cross-check): /;
+export function physjsNestedStatements(entry) {
+    const nested = [];
+    const problems = [];
+    for (const [field, value] of Object.entries(entry)) {
+        if (BASE_FIELDS.has(field))
+            continue;
+        const keys = typeof value === 'object' && value !== null && !Array.isArray(value) ? Object.keys(value).sort() : [];
+        if (keys.join() === STATEMENT_FIELDS.join())
+            nested.push({ name: field, ...value });
+        else
+            problems.push(`manifest entry '${entry.key}' has unexpected field '${field}'`);
+    }
+    return { nested, problems };
+}
 const PHYSJS_ENTRIES = GENERATED_PHYSJS_ENTRIES;
 const entryByKey = new Map(PHYSJS_ENTRIES.map((entry) => [entry.key, entry]));
+/** Theorem → its Lean file, for every statement of the compiled table, nested ones included. */
+const FILE_BY_THEOREM = new Map(PHYSJS_ENTRIES.flatMap((entry) => [entry, ...entry.nested].map((statement) => [statement.theorem, statement.file])));
 /**
  * Theorem name on the compiled manifest copy for `key`.
  *
@@ -123,28 +94,22 @@ export function physjsTheorem(key) {
 function physjsVersion() {
     return `physjs@${PHYSJS_COMMIT} ${PHYSJS_TOOLCHAIN} mathlib:${PHYSJS_MATHLIB} physlib@${PHYSJS_PHYS_LIB}`;
 }
-/**
- * Namespaces whose theorems live in another Lean file at this pin.
- * `SpringLc` and `DampedRlc` are namespaces inside `lean/OscillatorDictionary.lean`,
- * not their own files. Rechecked at this pin.
- */
-const PHYSJS_FILE_BY_NAMESPACE = {
-    SpringLc: 'OscillatorDictionary.lean',
-    DampedRlc: 'OscillatorDictionary.lean',
-};
 /**
  * Lean file name that contains `theorem` at the pinned commit.
  *
- * `SpringLc` and `DampedRlc` are namespaces inside `OscillatorDictionary.lean`.
+ * Read from the compiled table, which copies `formal/physjs/theorem-files.json`:
+ * the file is where the theorem is declared, not its namespace
+ * (`PhysJS.Einstein.friedmann_corollary` is in `VacuumFriedmann.lean`;
+ * `PhysJS.SpringLc` is a namespace inside `OscillatorDictionary.lean`).
+ * Throws for a theorem the manifest does not name.
  *
  * @internal
  */
 export function physjsLeanFile(theorem) {
-    const parts = theorem.split('.');
-    if (parts.length < 3 || parts[0] !== 'PhysJS' || parts[1] === undefined) {
-        throw new Error(`PhysJS theorem '${theorem}' is not PhysJS.<module>.<name>`);
-    }
-    return PHYSJS_FILE_BY_NAMESPACE[parts[1]] ?? `${parts[1]}.lean`;
+    const file = FILE_BY_THEOREM.get(theorem);
+    if (file === undefined)
+        throw new Error(`PhysJS theorem '${theorem}' is not a statement of the vendored manifest`);
+    return file;
 }
 /**
  * Permalink to one Lean file at the pinned commit.
@@ -161,63 +126,122 @@ export function physjsFileUrl(file) {
 function physjsStatementUrl(theorem) {
     return physjsFileUrl(physjsLeanFile(theorem));
 }
+/** The highest id in the bridge catalog. */
+const CATALOG_MAX_ID = Math.max(...catalogEntries().map((entry) => entry.id));
+/**
+ * True when `key` is ahead of the catalog: PhysJS proved the statement for a
+ * catalog id the catalog has not reached yet. That is an id above the
+ * catalog's highest, with every id between them also a key of `keys` (the
+ * manifest's), so the ahead keys are one unbroken run that starts right after
+ * the catalog. Such an entry is vendored and compared, and it is not a seed
+ * and not a problem until the catalog entry exists. A missing id inside the
+ * catalog's range is not ahead, nor is an id past a gap in the run (a typo
+ * such as an extra digit), nor an atlas key.
+ *
+ * @internal
+ */
+export function physjsAheadOfCatalog(key, keys = PHYSJS_ENTRIES.map((entry) => entry.key)) {
+    const id = catalogIdNumber(key);
+    if (id === undefined || id <= CATALOG_MAX_ID)
+        return false;
+    const ids = new Set(keys.map(catalogIdNumber));
+    for (let n = CATALOG_MAX_ID + 1; n < id; n++)
+        if (!ids.has(n))
+            return false;
+    return true;
+}
 /**
- * Catalog keys whose theorem states the catalogued equation.
- * The PhysJS covers line still begins with `derivation-step`.
- * The kind is bridge because that equation is the theorem.
+ * Manifest keys of kind `bridge`, the theorem stating the equation its key
+ * names, that resolve to a bridge: every such atlas key, and every such
+ * catalog key whose catalog entry exists. The kind is the manifest's own
+ * field. A caller-supplied overlay entry is read the same way. The return
+ * value is not stored on a bridge.
+ *
+ * @internal
  */
-const CATALOG_EQUATION_KEYS = new Set([
-    12, 16, 21, 27, 33, 37, 40, 43, 50, 54, 55, 59, 60, 63, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
-].map((id) => catalogEdgeKey(id)));
+export function bridgeSeedKeys(entries = PHYSJS_ENTRIES) {
+    return entries.filter((entry) => entry.kind === 'bridge' && !physjsAheadOfCatalog(entry.key)).map((entry) => entry.key);
+}
+/** Every manifest key ahead of the catalog, in manifest order. @internal */
+export function physjsKeysAheadOfCatalog() {
+    return PHYSJS_ENTRIES.filter((entry) => physjsAheadOfCatalog(entry.key)).map((entry) => entry.key);
+}
 /**
- * Atlas keys are bridges. A catalog key whose theorem states the catalogued
- * equation is a bridge. BE-28 is a property of the defining sum. Every other
- * catalog key's kind is the covers prefix.
+ * The row of a manifest entry as PhysJS writes it, in the shape
+ * {@link physjsRowHash} reads. @internal
  */
-function formalRefKind(key, covers) {
-    if (key.startsWith('ab-'))
-        return 'bridge';
-    if (CATALOG_EQUATION_KEYS.has(key))
-        return 'bridge';
-    if (key === catalogEdgeKey(28))
-        return 'property';
-    const word = covers.split(':')[0];
-    if (word === 'property' ||
-        word === 'cross-check' ||
-        word === 'reduction' ||
-        word === 'limit' ||
-        word === 'derivation-step') {
-        return word;
-    }
-    return undefined;
+export function physjsManifestRow(entry) {
+    return {
+        key: entry.key,
+        theorem: entry.theorem,
+        kind: entry.kind,
+        covers: entry.covers,
+        leanProof: entry.leanProof,
+        axioms: entry.axioms,
+        nested: physjsNestedStatements(entry).nested.map((statement) => ({
+            name: statement.name,
+            theorem: statement.theorem,
+            kind: statement.kind,
+            covers: statement.covers,
+            leanProof: statement.leanProof,
+            axioms: statement.axioms,
+        })),
+    };
 }
 /**
- * Manifest keys whose derived kind is `bridge`.
+ * SHA-256 of one row: `[key, theorem, kind, covers, leanProof, axioms,
+ * nested[]]`, each nested statement as `[name, theorem, kind, covers,
+ * leanProof, axioms]`. A swapped theorem or key, a changed kind, a reworded
+ * covers line, a proof status, an axiom, or a nested statement changes it.
+ * This is what `physjs-reviewed.ts` pins per key.
  *
- * An `ab-` key is a bridge. A catalog key is a bridge when `formalRefKind`
- * says the theorem states the catalogued equation. A canonical id uses that
- * same function: it is a seed when this table, or a caller-supplied overlay
- * entry, has derived kind `bridge`. A textbook covers word is not a seed.
- * One function, so a second list cannot drift.
+ * @internal
+ */
+export function physjsRowHash(row) {
+    const columns = [
+        row.key,
+        row.theorem,
+        row.kind,
+        row.covers,
+        row.leanProof,
+        [...row.axioms],
+        row.nested.map((n) => [n.name, n.theorem, n.kind, n.covers, n.leanProof, [...n.axioms]]),
+    ];
+    return createHash('sha256').update(JSON.stringify(columns)).digest('hex');
+}
+/**
+ * The fidelity a manifest key earns, derived from what checks it:
  *
- * `kind`, when supplied, is that derived kind for an overlay reference the
- * compiled table does not carry. The live call omits it. The return value
- * is not stored on a bridge.
+ * - `'unreviewed'` when the key is ahead of the catalog
+ *   ({@link physjsAheadOfCatalog}): no bridge exists to read the row against;
+ * - `'unreviewed'` when the compiled row's hash is not the one
+ *   `PHYSJS_REVIEWED_ROWS` records for the key, or the key has no entry there;
+ * - `'sanity-lemmas'` when the row is reviewed AND the key is in
+ *   `PHYSJS_SANITY_LEMMA_KEYS`, whose statements
+ *   `tests/atlas/formal-sanity.test.ts` instantiates on known cases;
+ * - `'reviewed-manifest'` when the row is reviewed and no sanity lemma exists.
+ *
+ * A key the manifest does not name throws, like {@link physjsFormalRef}.
  *
  * @internal
  */
-export function bridgeSeedKeys(entries = PHYSJS_ENTRIES) {
-    const keys = [];
-    for (const entry of entries) {
-        const kind = entry.kind ?? formalRefKind(entry.key, entry.covers);
-        if (kind === 'bridge')
-            keys.push(entry.key);
-    }
-    return keys;
+export function physjsFidelity(key, 
+/** Defaults to the generated table. A test passes a mutated copy. */
+compiledEntries = PHYSJS_ENTRIES) {
+    const entry = compiledEntries.find((candidate) => candidate.key === key);
+    if (entry === undefined)
+        throw new Error(`PhysJS manifest has no entry for '${key}'`);
+    if (physjsAheadOfCatalog(key))
+        return 'unreviewed';
+    if (PHYSJS_REVIEWED_ROWS[key] !== physjsRowHash(entry))
+        return 'unreviewed';
+    return PHYSJS_SANITY_LEMMA_KEYS.includes(key) ? 'sanity-lemmas' : 'reviewed-manifest';
 }
 /**
- * The reviewed reference for a manifest key. Throws when the key is not an
- * entry, so a typo cannot ship a bridge with no reference.
+ * The reference for a manifest key, with its derived fidelity. Throws when
+ * the key is not an entry, so a typo cannot ship a bridge with no reference.
+ * A key ahead of the catalog, or whose row is not reviewed, is returned
+ * `'unreviewed'` and derives no proof tag.
  *
  * @internal
  */
@@ -225,46 +249,40 @@ export function physjsFormalRef(key) {
     const entry = entryByKey.get(key);
     if (entry === undefined)
         throw new Error(`PhysJS manifest has no entry for '${key}'`);
-    const kind = formalRefKind(entry.key, entry.covers);
-    if (kind === undefined)
-        throw new Error(`PhysJS entry '${entry.key}' covers line has no catalog kind`);
     return {
         system: 'lean4-physjs',
         statement: entry.theorem,
         version: physjsVersion(),
         axioms: entry.axioms,
-        fidelity: 'sanity-lemmas',
-        kind,
+        fidelity: physjsFidelity(key),
+        kind: entry.kind,
         url: physjsStatementUrl(entry.theorem),
         covers: `${entry.covers} — ${entry.coverage}`,
     };
 }
+/** The axioms of a statement that are outside {@link PHYSJS_ALLOWED_AXIOMS}. */
+function disallowedAxioms(axioms) {
+    return axioms.filter((axiom) => !PHYSJS_ALLOWED_AXIOMS.has(axiom));
+}
 function sameAxioms(recorded, manifest) {
     return recorded.length === manifest.length && recorded.every((axiom, i) => axiom === manifest[i]);
 }
-function sameNested(compiled, manifest) {
-    if (compiled === undefined && manifest === undefined)
-        return true;
-    if (compiled === undefined || manifest === undefined)
-        return false;
+function sameStatement(compiled, manifest) {
     return (compiled.theorem === manifest.theorem &&
+        compiled.kind === manifest.kind &&
         compiled.covers === manifest.covers &&
         compiled.coverage === manifest.coverage &&
         compiled.leanProof === manifest.leanProof &&
         sameAxioms(compiled.axioms, manifest.axioms));
 }
-/**
- * A `be-` covers line begins with a counted kind or a labeled kind.
- * Atlas covers lines stay as milestone 1 and 2 wrote them.
- */
-function catalogCoversProblems(key, covers, where) {
-    if (!key.startsWith('be-'))
-        return [];
-    if (COUNTED_KIND.test(covers) || LABELED_KIND.test(covers))
-        return [];
-    return [
-        `${where} '${key}' covers line does not begin with a catalog kind (reduction, limit, derivation-step, property, or cross-check)`,
-    ];
+/** The compiled nested statements are the manifest's: the same names, in order, each the same statement. */
+function sameNested(compiled, manifest) {
+    return (compiled.length === manifest.length &&
+        compiled.every((statement, i) => statement.name === manifest[i].name && sameStatement(statement, manifest[i])));
+}
+/** The kind of a manifest entry is one of the formal-reference kinds. */
+function isFormalRefKind(kind) {
+    return typeof kind === 'string' && FORMAL_REF_KINDS.includes(kind);
 }
 /**
  * Problems in the vendored manifest against the bridges that claim to be keyed
@@ -275,17 +293,23 @@ function catalogCoversProblems(key, covers, where) {
  * entry with no bridge is a problem. A `lean4-physjs` reference with no entry
  * is a problem: the gate does not skip that system. A nested object is kept
  * and compared; naming it as the `formalRef` is a problem. The top-level
- * theorem stays the reference. A catalog entry whose covers line is a
- * `property` or a `cross-check` is a labeled reference: it resolves to a
- * `formalRef`, and it is not a counted kind.
+ * theorem stays the reference. The reference's kind is the entry's
+ * `kind`; a kind outside the formal-reference kinds is a problem. An axiom
+ * outside {@link PHYSJS_ALLOWED_AXIOMS} on any statement is a problem. A `be-`
+ * key in the unbroken run above the catalog's highest id is ahead of the
+ * catalog and is not a problem (`physjsAheadOfCatalog`); any other key with
+ * no bridge is. Every structural check (fields, kinds, coverage, proof
+ * status, axioms, Lean file, compiled copy) runs for every entry, ahead keys
+ * included; only the checks against a bridge's reference are skipped for a
+ * key that has no bridge yet.
  *
  * @internal
  */
 export function physjsManifestProblems(input) {
     const problems = [];
     const manifest = input.manifest;
-    if (manifest.schema !== 'physjs-bridge-manifest/v1') {
-        problems.push(`manifest schema is '${manifest.schema}', expected 'physjs-bridge-manifest/v1'`);
+    if (manifest.schema !== 'physjs-bridge-manifest/v2') {
+        problems.push(`manifest schema is '${manifest.schema}', expected 'physjs-bridge-manifest/v2'`);
     }
     if (manifest.commit !== PHYSJS_COMMIT) {
         problems.push(`manifest commit is '${manifest.commit}', expected '${PHYSJS_COMMIT}'`);
@@ -299,18 +323,19 @@ export function physjsManifestProblems(input) {
     if (manifest.physlib !== PHYSJS_PHYS_LIB) {
         problems.push(`manifest physlib is '${manifest.physlib}', expected '${PHYSJS_PHYS_LIB}'`);
     }
-    const compiledByKey = new Map((input.compiledEntries ?? PHYSJS_ENTRIES).map((entry) => [entry.key, entry]));
+    const compiledEntries = input.compiledEntries ?? PHYSJS_ENTRIES;
+    const compiledByKey = new Map(compiledEntries.map((entry) => [entry.key, entry]));
+    /** Theorem → Lean file over the compiled table under test, nested statements included. */
+    const fileByTheorem = new Map(compiledEntries.flatMap((entry) => [entry, ...entry.nested].map((statement) => [statement.theorem, statement.file])));
     const byId = new Map(input.bridges.map((bridge) => [bridge.id, bridge]));
     const seen = new Set();
+    const manifestKeys = manifest.entries.map((entry) => entry.key);
     for (const entry of manifest.entries) {
         if (seen.has(entry.key))
             problems.push(`manifest key '${entry.key}' is duplicated`);
         seen.add(entry.key);
-        for (const field of Object.keys(entry)) {
-            if (!ENTRY_FIELDS.has(field)) {
-                problems.push(`manifest entry '${entry.key}' has unexpected field '${field}'`);
-            }
-        }
+        const { nested, problems: fieldProblems } = physjsNestedStatements(entry);
+        problems.push(...fieldProblems);
         if (entry.key !== entry.bridgeId) {
             problems.push(`manifest key '${entry.key}' does not equal bridgeId '${entry.bridgeId}'`);
         }
@@ -320,23 +345,50 @@ export function physjsManifestProblems(input) {
         if (entry.leanProof !== 'complete') {
             problems.push(`leanProof for '${entry.key}' is '${entry.leanProof}', expected 'complete'`);
         }
-        const coversProblems = catalogCoversProblems(entry.key, entry.covers, 'manifest key');
-        problems.push(...coversProblems);
-        for (const field of NESTED_FIELDS) {
-            const nested = entry[field];
-            if (nested === undefined)
-                continue;
-            if (nested.coverage !== PHYSJS_COVERAGE) {
-                problems.push(`${field} coverage phrase for '${entry.key}' is '${nested.coverage}', expected '${PHYSJS_COVERAGE}'`);
+        if (!isFormalRefKind(entry.kind)) {
+            problems.push(`manifest key '${entry.key}' kind '${String(entry.kind)}' is not one of ${FORMAL_REF_KINDS.join(', ')}`);
+        }
+        if (disallowedAxioms(entry.axioms).length > 0) {
+            problems.push(`manifest key '${entry.key}' axioms [${entry.axioms.join(', ')}] are not a subset of [${[...PHYSJS_ALLOWED_AXIOMS].join(', ')}]`);
+        }
+        for (const statement of nested) {
+            if (!isFormalRefKind(statement.kind)) {
+                problems.push(`${statement.name} kind for '${entry.key}' is '${String(statement.kind)}', not one of ${FORMAL_REF_KINDS.join(', ')}`);
+            }
+            if (statement.coverage !== PHYSJS_COVERAGE) {
+                problems.push(`${statement.name} coverage phrase for '${entry.key}' is '${statement.coverage}', expected '${PHYSJS_COVERAGE}'`);
             }
-            if (nested.leanProof !== 'complete') {
-                problems.push(`${field} leanProof for '${entry.key}' is '${nested.leanProof}', expected 'complete'`);
+            if (statement.leanProof !== 'complete') {
+                problems.push(`${statement.name} leanProof for '${entry.key}' is '${statement.leanProof}', expected 'complete'`);
             }
-            problems.push(...catalogCoversProblems(entry.key, nested.covers, `${field} covers`));
+            if (disallowedAxioms(statement.axioms).length > 0) {
+                problems.push(`${statement.name} axioms for '${entry.key}' [${statement.axioms.join(', ')}] are not a subset of [${[...PHYSJS_ALLOWED_AXIOMS].join(', ')}]`);
+            }
+            if (!fileByTheorem.has(statement.theorem)) {
+                problems.push(`manifest theorem '${statement.theorem}' (${entry.key}.${statement.name}) has no Lean file in formal/physjs/theorem-files.json`);
+            }
+        }
+        const file = fileByTheorem.get(entry.theorem);
+        if (file === undefined) {
+            problems.push(`manifest theorem '${entry.theorem}' has no Lean file in formal/physjs/theorem-files.json`);
+        }
+        const compiled = compiledByKey.get(entry.key);
+        if (compiled === undefined) {
+            problems.push(`manifest key '${entry.key}' is not in the compiled entry table`);
+        }
+        else if (compiled.theorem !== entry.theorem ||
+            compiled.kind !== entry.kind ||
+            compiled.covers !== entry.covers ||
+            compiled.coverage !== entry.coverage ||
+            compiled.leanProof !== entry.leanProof ||
+            !sameAxioms(compiled.axioms, entry.axioms) ||
+            !sameNested(compiled.nested, nested)) {
+            problems.push(`compiled entry for '${entry.key}' disagrees with the vendored manifest`);
         }
         const bridge = byId.get(entry.key);
         if (bridge === undefined) {
-            problems.push(`manifest key '${entry.key}' does not resolve to a bridge`);
+            if (!physjsAheadOfCatalog(entry.key, manifestKeys))
+                problems.push(`manifest key '${entry.key}' does not resolve to a bridge`);
             continue;
         }
         const ref = bridge.formalRef;
@@ -344,15 +396,9 @@ export function physjsManifestProblems(input) {
             problems.push(`bridge '${entry.key}' has no lean4-physjs formalRef (system '${ref?.system ?? 'none'}')`);
             continue;
         }
-        if (entry.planeWave !== undefined && ref.statement === entry.planeWave.theorem) {
-            problems.push(`bridge '${entry.key}' formalRef names the nested planeWave theorem '${entry.planeWave.theorem}'; the top-level theorem stays the reference`);
-        }
-        for (const field of NESTED_FIELDS) {
-            if (field === 'planeWave')
-                continue;
-            const nested = entry[field];
-            if (nested !== undefined && ref.statement === nested.theorem) {
-                problems.push(`bridge '${entry.key}' formalRef names the nested ${field} theorem '${nested.theorem}'; the top-level theorem stays the reference`);
+        for (const statement of nested) {
+            if (ref.statement === statement.theorem) {
+                problems.push(`bridge '${entry.key}' formalRef names the nested ${statement.name} theorem '${statement.theorem}'; the top-level theorem stays the reference`);
             }
         }
         if (ref.statement !== entry.theorem) {
@@ -361,7 +407,6 @@ export function physjsManifestProblems(input) {
         if (!sameAxioms(ref.axioms, entry.axioms)) {
             problems.push(`bridge '${entry.key}' axioms [${ref.axioms.join(', ')}] differ from the manifest [${entry.axioms.join(', ')}]`);
         }
-        problems.push(...catalogCoversProblems(entry.key, ref.covers, 'formalRef covers'));
         if (!ref.covers.includes(PHYSJS_COVERAGE)) {
             problems.push(`bridge '${entry.key}' covers line does not say '${PHYSJS_COVERAGE}'`);
         }
@@ -374,23 +419,11 @@ export function physjsManifestProblems(input) {
         if (ref.fidelity === 'unreviewed') {
             problems.push(`bridge '${entry.key}' formalRef is unreviewed`);
         }
-        const kind = formalRefKind(entry.key, entry.covers);
-        if (kind !== undefined && ref.kind !== kind) {
-            problems.push(`bridge '${entry.key}' kind is '${ref.kind}', expected '${kind}'`);
+        if (ref.kind !== entry.kind) {
+            problems.push(`bridge '${entry.key}' kind is '${ref.kind}', expected '${entry.kind}'`);
         }
-        const url = physjsStatementUrl(entry.theorem);
-        if (ref.url !== url) {
-            problems.push(`bridge '${entry.key}' url is '${ref.url}', expected '${url}'`);
-        }
-        const compiled = compiledByKey.get(entry.key);
-        if (compiled === undefined) {
-            problems.push(`manifest key '${entry.key}' is not in the compiled entry table`);
-        }
-        else if (compiled.theorem !== entry.theorem ||
-            compiled.covers !== entry.covers ||
-            compiled.coverage !== entry.coverage ||
-            NESTED_FIELDS.some((field) => !sameNested(compiled[field], entry[field]))) {
-            problems.push(`compiled entry for '${entry.key}' disagrees with the vendored manifest`);
+        if (file !== undefined && ref.url !== physjsFileUrl(file)) {
+            problems.push(`bridge '${entry.key}' url is '${ref.url}', expected '${physjsFileUrl(file)}'`);
         }
     }
     for (const bridge of input.bridges) {