DevinWatson commited on
Commit
b92fd4b
·
verified ·
1 Parent(s): cbac66b

Add builds (2026-11-10)

Browse files
README.md CHANGED
@@ -28,20 +28,24 @@ Every value below is read from the build folder's own reports; "not run" and "no
28
 
29
  | commit | Lean | packed | modules | `sorry` warnings | other warnings | axiom audit | round trip |
30
  |---|---|---|---|---|---|---|---|
31
- | `62c945fb6c06` | v4.28.0 | 2026-11-08 | 4 | 12 | 58 | flags sorry | passed |
32
 
33
  **Build `62c945fb6c06-82bd60733ffb416b`** (source commit `62c945fb6c06ac2f915bbfd7521e6c807e47e92a`)
34
 
35
- - `sorry` warnings: 12, in `Biswal/theorem1/problem.lean`, `Biswal/theorem2and3/problem.lean`. Results in these files are not proved.
36
- - Axiom audit: 584 declarations; axioms beyond the standard three: sorryAx.
37
- - Declarations that depend on them (first ones listed by the audit): `genFun_eq_one_of_m_eq_one` (sorryAx), `genFun_is_polynomial` (sorryAx), `genFun_coeff_eventually_pos` (sorryAx), `thm_manifest_coeff_nonneg` (sorryAx), `thm_comb_cauchy` (sorryAx), `thm_manifest_D_nonneg` (sorryAx), `D_coeff_mk` (sorryAx), `genFun_eq_reduced` (sorryAx), `polyP_coeff` (sorryAx), `thm_manifest_factorization` (sorryAx), `thm_comb` (sorryAx), `thm_manifest_coeff_formula` (sorryAx).
38
  - Round trip on a clean machine: passed. Restored on a clean machine; AxiomMath/Biswal: Lake reported every target up to date (8030 jobs). (1 of 1 projects using it passed; checked 2026-11-09)
39
 
40
  What the columns mean:
41
  - **`sorry` warnings:** declarations the build reported as using `sorry`. Anything depending on them is not proved.
 
 
 
42
  - **Axiom audit:** every declaration in the package's modules traced to the axioms it uses. "passed" means only
43
- `propext`, `Classical.choice` and `Quot.sound`. It does not say a statement is the intended one: a theorem that
44
- takes a hard fact as a hypothesis passes.
 
 
45
  - **Round trip:** a separate user with empty Lean and Lake caches restored the build from the archive and Lake reported
46
  every target up to date. It shows the archive is complete, not that the proofs are right.
47
 
 
28
 
29
  | commit | Lean | packed | modules | `sorry` warnings | other warnings | axiom audit | round trip |
30
  |---|---|---|---|---|---|---|---|
31
+ | `62c945fb6c06` | v4.28.0 | 2026-11-08 | 4 | 12 (problem statements only) | 58 | passed outside problem statements | passed |
32
 
33
  **Build `62c945fb6c06-82bd60733ffb416b`** (source commit `62c945fb6c06ac2f915bbfd7521e6c807e47e92a`)
34
 
35
+ - `sorry` warnings: 12, all in problem or challenge statement files: `Biswal/theorem1/problem.lean`, `Biswal/theorem2and3/problem.lean`. In this layout each statement file states the theorems with `sorry` and the matching solution file proves them; the axiom audit line below says whether the proofs themselves are clean.
36
+ - Axiom audit: 584 declarations, audited module by module. The only non-standard axiom is `sorryAx`, and every declaration using it is in a problem or challenge statement module (2: `Biswal.theorem1.problem`, `Biswal.theorem2and3.problem`). The other 2 modules, including every solution, depend only on propext, Classical.choice, Quot.sound.
 
37
  - Round trip on a clean machine: passed. Restored on a clean machine; AxiomMath/Biswal: Lake reported every target up to date (8030 jobs). (1 of 1 projects using it passed; checked 2026-11-09)
38
 
39
  What the columns mean:
40
  - **`sorry` warnings:** declarations the build reported as using `sorry`. Anything depending on them is not proved.
41
+ "problem statements only" means every one is in a `problem.lean` or challenge file: in that layout the
42
+ statement file states the theorems with `sorry`, a matching solution file proves them, and a comparator checks
43
+ that the two match. The axiom audit then shows whether the solutions are clean.
44
  - **Axiom audit:** every declaration in the package's modules traced to the axioms it uses. "passed" means only
45
+ `propext`, `Classical.choice` and `Quot.sound`. "passed outside problem statements" means a module-by-module audit
46
+ found `sorryAx` only in problem or challenge statement modules, and every other module, including every solution,
47
+ uses only those three. Neither says a statement is the intended one: a theorem that takes a hard fact as a
48
+ hypothesis passes.
49
  - **Round trip:** a separate user with empty Lean and Lake caches restored the build from the archive and Lake reported
50
  every target up to date. It shows the archive is complete, not that the proofs are right.
51
 
builds/v4.28.0/x86_64-unknown-linux-gnu/62c945fb6c06-82bd60733ffb416b/SHA256SUMS.txt CHANGED
@@ -1,5 +1,10 @@
1
  8939386fa8c69d17b5e7f908d8baddaff7758c3de30fd4a8f1f192e1b99ba104 lake-manifest.json
2
  e4be156ea90fc10243edac622d588d7b23b44fa44a525da0f389c6d4c834fcb2 manifest.json
 
 
 
 
 
3
  b10a0db2da55885690f124f3bdd227215dab0f86e850620cfb02a19099c90f44 reports/axiom_audit.txt
4
  efb722e471fbfbd62e92edde4283aa8aabbdc6d048c2af0dc40245a2c6ac0cc0 reports/axiom_audit_result.json
5
  6fcddcbd8f0ec170bd6a090ba6635dd86c374985b807a3c01fec7217a5c49add reports/build.log
 
1
  8939386fa8c69d17b5e7f908d8baddaff7758c3de30fd4a8f1f192e1b99ba104 lake-manifest.json
2
  e4be156ea90fc10243edac622d588d7b23b44fa44a525da0f389c6d4c834fcb2 manifest.json
3
+ 26f17cabce0f2f6bae910b3635ffd4d66963ea5e6d2fb903e39dfa012960db5c reports/axiom_audit.0000.lean
4
+ 4e14f9f7a865e53ba32fd7cbca5d89be0d34f04c6063b9ce4a83169a4b47f430 reports/axiom_audit.0001.lean
5
+ 6a9992fd853078daf77b1c090237f9d8e51e0f5c99abfc3355e1feb5a96044aa reports/axiom_audit.0002.lean
6
+ c61a5818e7f1cd5664d36e342cda241e5fe57f3b96b5b96b9684d9b7ae007b50 reports/axiom_audit.0003.lean
7
+ dd1b79c339ad9e50b48204d9baa9dd0397aae8d8f05f6d1ad0d07dd4146f2ef0 reports/axiom_audit.lean
8
  b10a0db2da55885690f124f3bdd227215dab0f86e850620cfb02a19099c90f44 reports/axiom_audit.txt
9
  efb722e471fbfbd62e92edde4283aa8aabbdc6d048c2af0dc40245a2c6ac0cc0 reports/axiom_audit_result.json
10
  6fcddcbd8f0ec170bd6a090ba6635dd86c374985b807a3c01fec7217a5c49add reports/build.log
builds/v4.28.0/x86_64-unknown-linux-gnu/62c945fb6c06-82bd60733ffb416b/reports/axiom_audit.0000.lean ADDED
@@ -0,0 +1,55 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import Lean
2
+ import Biswal.theorem1.problem
3
+
4
+ open Lean Elab Command
5
+
6
+ namespace AxAudit
7
+ structure St where
8
+ seen : NameMap (Array Name) := {}
9
+ axioms : NameSet := {}
10
+ abbrev M := ReaderT Environment (StateM St)
11
+
12
+ partial def collect (c : Name) : M Unit := do
13
+ let env ← read
14
+ let s ← get
15
+ if let some axs := s.seen.find? c then
16
+ modify fun s => { s with axioms := axs.foldl (fun a x => a.insert x) s.axioms }
17
+ return
18
+ let saved := s.axioms
19
+ modify fun s => { s with axioms := {}, seen := s.seen.insert c #[] }
20
+ let ce (e : Expr) : M Unit := e.getUsedConstants.forM collect
21
+ match env.find? c with
22
+ | some (.axiomInfo v) => modify (fun s => { s with axioms := s.axioms.insert c }); ce v.type
23
+ | some (.defnInfo v) => ce v.type *> ce v.value
24
+ | some (.thmInfo v) => ce v.type *> ce v.value
25
+ | some (.opaqueInfo v) => ce v.type *> ce v.value
26
+ | some (.quotInfo _) => pure ()
27
+ | some (.ctorInfo v) => ce v.type
28
+ | some (.recInfo v) => ce v.type
29
+ | some (.inductInfo v) => ce v.type *> v.ctors.forM collect
30
+ | none => pure ()
31
+ let res := (← get).axioms.toArray.qsort Name.lt
32
+ modify fun s => { s with seen := s.seen.insert c res, axioms := res.foldl (fun a x => a.insert x) saved }
33
+ end AxAudit
34
+
35
+ run_cmd do
36
+ let env ← getEnv
37
+ let penv := env.setExporting false
38
+ let mods : NameSet := (#[`Biswal.theorem1.problem] : Array Name).foldl (fun s n => s.insert n) {}
39
+ let std : NameSet := (#[``propext, ``Classical.choice, ``Quot.sound] : Array Name).foldl (fun s n => s.insert n) {}
40
+ let mut roots : Array Name := #[]
41
+ let mut declared : Array Name := #[]
42
+ for (c, ci) in env.constants.map₁.toList do
43
+ let some idx := env.getModuleIdxFor? c | continue
44
+ unless mods.contains env.header.moduleNames[idx.toNat]! do continue
45
+ roots := roots.push c
46
+ if let .axiomInfo _ := ci then declared := declared.push c
47
+ let (_, st) := ((roots.forM AxAudit.collect).run penv).run {}
48
+ let mut used : NameSet := {}
49
+ let mut nonstd : Array (Name × Array Name) := #[]
50
+ for c in roots do
51
+ let axs := (st.seen.find? c).getD #[]
52
+ for a in axs do used := used.insert a
53
+ let bad := axs.filter (fun a => !std.contains a)
54
+ unless bad.isEmpty do nonstd := nonstd.push (c, bad)
55
+ logInfo m!"AXIOM-AUDIT decls={roots.size} declared_axioms={declared.toList} axioms_used={used.toList} nonstandard_count={nonstd.size} nonstandard_first={nonstd.toList.take 10} constants_walked={st.seen.size} AXIOM-AUDIT-END"
builds/v4.28.0/x86_64-unknown-linux-gnu/62c945fb6c06-82bd60733ffb416b/reports/axiom_audit.0001.lean ADDED
@@ -0,0 +1,55 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import Lean
2
+ import Biswal.theorem1.solution
3
+
4
+ open Lean Elab Command
5
+
6
+ namespace AxAudit
7
+ structure St where
8
+ seen : NameMap (Array Name) := {}
9
+ axioms : NameSet := {}
10
+ abbrev M := ReaderT Environment (StateM St)
11
+
12
+ partial def collect (c : Name) : M Unit := do
13
+ let env ← read
14
+ let s ← get
15
+ if let some axs := s.seen.find? c then
16
+ modify fun s => { s with axioms := axs.foldl (fun a x => a.insert x) s.axioms }
17
+ return
18
+ let saved := s.axioms
19
+ modify fun s => { s with axioms := {}, seen := s.seen.insert c #[] }
20
+ let ce (e : Expr) : M Unit := e.getUsedConstants.forM collect
21
+ match env.find? c with
22
+ | some (.axiomInfo v) => modify (fun s => { s with axioms := s.axioms.insert c }); ce v.type
23
+ | some (.defnInfo v) => ce v.type *> ce v.value
24
+ | some (.thmInfo v) => ce v.type *> ce v.value
25
+ | some (.opaqueInfo v) => ce v.type *> ce v.value
26
+ | some (.quotInfo _) => pure ()
27
+ | some (.ctorInfo v) => ce v.type
28
+ | some (.recInfo v) => ce v.type
29
+ | some (.inductInfo v) => ce v.type *> v.ctors.forM collect
30
+ | none => pure ()
31
+ let res := (← get).axioms.toArray.qsort Name.lt
32
+ modify fun s => { s with seen := s.seen.insert c res, axioms := res.foldl (fun a x => a.insert x) saved }
33
+ end AxAudit
34
+
35
+ run_cmd do
36
+ let env ← getEnv
37
+ let penv := env.setExporting false
38
+ let mods : NameSet := (#[`Biswal.theorem1.solution] : Array Name).foldl (fun s n => s.insert n) {}
39
+ let std : NameSet := (#[``propext, ``Classical.choice, ``Quot.sound] : Array Name).foldl (fun s n => s.insert n) {}
40
+ let mut roots : Array Name := #[]
41
+ let mut declared : Array Name := #[]
42
+ for (c, ci) in env.constants.map₁.toList do
43
+ let some idx := env.getModuleIdxFor? c | continue
44
+ unless mods.contains env.header.moduleNames[idx.toNat]! do continue
45
+ roots := roots.push c
46
+ if let .axiomInfo _ := ci then declared := declared.push c
47
+ let (_, st) := ((roots.forM AxAudit.collect).run penv).run {}
48
+ let mut used : NameSet := {}
49
+ let mut nonstd : Array (Name × Array Name) := #[]
50
+ for c in roots do
51
+ let axs := (st.seen.find? c).getD #[]
52
+ for a in axs do used := used.insert a
53
+ let bad := axs.filter (fun a => !std.contains a)
54
+ unless bad.isEmpty do nonstd := nonstd.push (c, bad)
55
+ logInfo m!"AXIOM-AUDIT decls={roots.size} declared_axioms={declared.toList} axioms_used={used.toList} nonstandard_count={nonstd.size} nonstandard_first={nonstd.toList.take 10} constants_walked={st.seen.size} AXIOM-AUDIT-END"
builds/v4.28.0/x86_64-unknown-linux-gnu/62c945fb6c06-82bd60733ffb416b/reports/axiom_audit.0002.lean ADDED
@@ -0,0 +1,55 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import Lean
2
+ import Biswal.theorem2and3.problem
3
+
4
+ open Lean Elab Command
5
+
6
+ namespace AxAudit
7
+ structure St where
8
+ seen : NameMap (Array Name) := {}
9
+ axioms : NameSet := {}
10
+ abbrev M := ReaderT Environment (StateM St)
11
+
12
+ partial def collect (c : Name) : M Unit := do
13
+ let env ← read
14
+ let s ← get
15
+ if let some axs := s.seen.find? c then
16
+ modify fun s => { s with axioms := axs.foldl (fun a x => a.insert x) s.axioms }
17
+ return
18
+ let saved := s.axioms
19
+ modify fun s => { s with axioms := {}, seen := s.seen.insert c #[] }
20
+ let ce (e : Expr) : M Unit := e.getUsedConstants.forM collect
21
+ match env.find? c with
22
+ | some (.axiomInfo v) => modify (fun s => { s with axioms := s.axioms.insert c }); ce v.type
23
+ | some (.defnInfo v) => ce v.type *> ce v.value
24
+ | some (.thmInfo v) => ce v.type *> ce v.value
25
+ | some (.opaqueInfo v) => ce v.type *> ce v.value
26
+ | some (.quotInfo _) => pure ()
27
+ | some (.ctorInfo v) => ce v.type
28
+ | some (.recInfo v) => ce v.type
29
+ | some (.inductInfo v) => ce v.type *> v.ctors.forM collect
30
+ | none => pure ()
31
+ let res := (← get).axioms.toArray.qsort Name.lt
32
+ modify fun s => { s with seen := s.seen.insert c res, axioms := res.foldl (fun a x => a.insert x) saved }
33
+ end AxAudit
34
+
35
+ run_cmd do
36
+ let env ← getEnv
37
+ let penv := env.setExporting false
38
+ let mods : NameSet := (#[`Biswal.theorem2and3.problem] : Array Name).foldl (fun s n => s.insert n) {}
39
+ let std : NameSet := (#[``propext, ``Classical.choice, ``Quot.sound] : Array Name).foldl (fun s n => s.insert n) {}
40
+ let mut roots : Array Name := #[]
41
+ let mut declared : Array Name := #[]
42
+ for (c, ci) in env.constants.map₁.toList do
43
+ let some idx := env.getModuleIdxFor? c | continue
44
+ unless mods.contains env.header.moduleNames[idx.toNat]! do continue
45
+ roots := roots.push c
46
+ if let .axiomInfo _ := ci then declared := declared.push c
47
+ let (_, st) := ((roots.forM AxAudit.collect).run penv).run {}
48
+ let mut used : NameSet := {}
49
+ let mut nonstd : Array (Name × Array Name) := #[]
50
+ for c in roots do
51
+ let axs := (st.seen.find? c).getD #[]
52
+ for a in axs do used := used.insert a
53
+ let bad := axs.filter (fun a => !std.contains a)
54
+ unless bad.isEmpty do nonstd := nonstd.push (c, bad)
55
+ logInfo m!"AXIOM-AUDIT decls={roots.size} declared_axioms={declared.toList} axioms_used={used.toList} nonstandard_count={nonstd.size} nonstandard_first={nonstd.toList.take 10} constants_walked={st.seen.size} AXIOM-AUDIT-END"
builds/v4.28.0/x86_64-unknown-linux-gnu/62c945fb6c06-82bd60733ffb416b/reports/axiom_audit.0003.lean ADDED
@@ -0,0 +1,55 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import Lean
2
+ import Biswal.theorem2and3.solution
3
+
4
+ open Lean Elab Command
5
+
6
+ namespace AxAudit
7
+ structure St where
8
+ seen : NameMap (Array Name) := {}
9
+ axioms : NameSet := {}
10
+ abbrev M := ReaderT Environment (StateM St)
11
+
12
+ partial def collect (c : Name) : M Unit := do
13
+ let env ← read
14
+ let s ← get
15
+ if let some axs := s.seen.find? c then
16
+ modify fun s => { s with axioms := axs.foldl (fun a x => a.insert x) s.axioms }
17
+ return
18
+ let saved := s.axioms
19
+ modify fun s => { s with axioms := {}, seen := s.seen.insert c #[] }
20
+ let ce (e : Expr) : M Unit := e.getUsedConstants.forM collect
21
+ match env.find? c with
22
+ | some (.axiomInfo v) => modify (fun s => { s with axioms := s.axioms.insert c }); ce v.type
23
+ | some (.defnInfo v) => ce v.type *> ce v.value
24
+ | some (.thmInfo v) => ce v.type *> ce v.value
25
+ | some (.opaqueInfo v) => ce v.type *> ce v.value
26
+ | some (.quotInfo _) => pure ()
27
+ | some (.ctorInfo v) => ce v.type
28
+ | some (.recInfo v) => ce v.type
29
+ | some (.inductInfo v) => ce v.type *> v.ctors.forM collect
30
+ | none => pure ()
31
+ let res := (← get).axioms.toArray.qsort Name.lt
32
+ modify fun s => { s with seen := s.seen.insert c res, axioms := res.foldl (fun a x => a.insert x) saved }
33
+ end AxAudit
34
+
35
+ run_cmd do
36
+ let env ← getEnv
37
+ let penv := env.setExporting false
38
+ let mods : NameSet := (#[`Biswal.theorem2and3.solution] : Array Name).foldl (fun s n => s.insert n) {}
39
+ let std : NameSet := (#[``propext, ``Classical.choice, ``Quot.sound] : Array Name).foldl (fun s n => s.insert n) {}
40
+ let mut roots : Array Name := #[]
41
+ let mut declared : Array Name := #[]
42
+ for (c, ci) in env.constants.map₁.toList do
43
+ let some idx := env.getModuleIdxFor? c | continue
44
+ unless mods.contains env.header.moduleNames[idx.toNat]! do continue
45
+ roots := roots.push c
46
+ if let .axiomInfo _ := ci then declared := declared.push c
47
+ let (_, st) := ((roots.forM AxAudit.collect).run penv).run {}
48
+ let mut used : NameSet := {}
49
+ let mut nonstd : Array (Name × Array Name) := #[]
50
+ for c in roots do
51
+ let axs := (st.seen.find? c).getD #[]
52
+ for a in axs do used := used.insert a
53
+ let bad := axs.filter (fun a => !std.contains a)
54
+ unless bad.isEmpty do nonstd := nonstd.push (c, bad)
55
+ logInfo m!"AXIOM-AUDIT decls={roots.size} declared_axioms={declared.toList} axioms_used={used.toList} nonstandard_count={nonstd.size} nonstandard_first={nonstd.toList.take 10} constants_walked={st.seen.size} AXIOM-AUDIT-END"
builds/v4.28.0/x86_64-unknown-linux-gnu/62c945fb6c06-82bd60733ffb416b/reports/axiom_audit.lean ADDED
@@ -0,0 +1,58 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import Lean
2
+ import Biswal.theorem1.problem
3
+ import Biswal.theorem1.solution
4
+ import Biswal.theorem2and3.problem
5
+ import Biswal.theorem2and3.solution
6
+
7
+ open Lean Elab Command
8
+
9
+ namespace AxAudit
10
+ structure St where
11
+ seen : NameMap (Array Name) := {}
12
+ axioms : NameSet := {}
13
+ abbrev M := ReaderT Environment (StateM St)
14
+
15
+ partial def collect (c : Name) : M Unit := do
16
+ let env ← read
17
+ let s ← get
18
+ if let some axs := s.seen.find? c then
19
+ modify fun s => { s with axioms := axs.foldl (fun a x => a.insert x) s.axioms }
20
+ return
21
+ let saved := s.axioms
22
+ modify fun s => { s with axioms := {}, seen := s.seen.insert c #[] }
23
+ let ce (e : Expr) : M Unit := e.getUsedConstants.forM collect
24
+ match env.find? c with
25
+ | some (.axiomInfo v) => modify (fun s => { s with axioms := s.axioms.insert c }); ce v.type
26
+ | some (.defnInfo v) => ce v.type *> ce v.value
27
+ | some (.thmInfo v) => ce v.type *> ce v.value
28
+ | some (.opaqueInfo v) => ce v.type *> ce v.value
29
+ | some (.quotInfo _) => pure ()
30
+ | some (.ctorInfo v) => ce v.type
31
+ | some (.recInfo v) => ce v.type
32
+ | some (.inductInfo v) => ce v.type *> v.ctors.forM collect
33
+ | none => pure ()
34
+ let res := (← get).axioms.toArray.qsort Name.lt
35
+ modify fun s => { s with seen := s.seen.insert c res, axioms := res.foldl (fun a x => a.insert x) saved }
36
+ end AxAudit
37
+
38
+ run_cmd do
39
+ let env ← getEnv
40
+ let penv := env.setExporting false
41
+ let mods : NameSet := (#[`Biswal.theorem1.problem, `Biswal.theorem1.solution, `Biswal.theorem2and3.problem, `Biswal.theorem2and3.solution] : Array Name).foldl (fun s n => s.insert n) {}
42
+ let std : NameSet := (#[``propext, ``Classical.choice, ``Quot.sound] : Array Name).foldl (fun s n => s.insert n) {}
43
+ let mut roots : Array Name := #[]
44
+ let mut declared : Array Name := #[]
45
+ for (c, ci) in env.constants.map₁.toList do
46
+ let some idx := env.getModuleIdxFor? c | continue
47
+ unless mods.contains env.header.moduleNames[idx.toNat]! do continue
48
+ roots := roots.push c
49
+ if let .axiomInfo _ := ci then declared := declared.push c
50
+ let (_, st) := ((roots.forM AxAudit.collect).run penv).run {}
51
+ let mut used : NameSet := {}
52
+ let mut nonstd : Array (Name × Array Name) := #[]
53
+ for c in roots do
54
+ let axs := (st.seen.find? c).getD #[]
55
+ for a in axs do used := used.insert a
56
+ let bad := axs.filter (fun a => !std.contains a)
57
+ unless bad.isEmpty do nonstd := nonstd.push (c, bad)
58
+ logInfo m!"AXIOM-AUDIT decls={roots.size} declared_axioms={declared.toList} axioms_used={used.toList} nonstandard_count={nonstd.size} nonstandard_first={nonstd.toList.take 10} constants_walked={st.seen.size} AXIOM-AUDIT-END"