diff --git a/.github/workflows/c296-regular-point-chart.yml b/.github/workflows/c296-regular-point-chart.yml new file mode 100644 index 000000000..1e325db30 --- /dev/null +++ b/.github/workflows/c296-regular-point-chart.yml @@ -0,0 +1,63 @@ +name: C296 regular-point chart + +on: + pull_request: + paths: + - "frontiers/critical_level_attainment_20261020/final-project/Lifetime.lean" + - "frontiers/regular_point_chart_20261020/**" + - ".github/workflows/c296-regular-point-chart.yml" + workflow_dispatch: + +permissions: + contents: read + +jobs: + regular-point-chart: + runs-on: ubuntu-latest + timeout-minutes: 30 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + fetch-depth: 0 + - uses: leanprover/lean-action@f061402b660e0c34644504b324e830f2991d4865 + with: + auto-config: 'false' + build: 'false' + test: 'false' + lint: 'false' + use-mathlib-cache: 'true' + use-github-cache: 'false' + lake-package-directory: frontiers/regular_point_chart_20261020 + - name: Build and kernel-check the exact C296 interface + working-directory: frontiers/regular_point_chart_20261020 + run: | + set -euo pipefail + sha256sum --check SOURCE_SHA256SUMS + lean --version + lake build RegularPointChart RegularPointChartInterface + lake env lean -E warning RegularPointChart.lean + lake env lean -E warning RegularPointChartInterface.lean + lake env leanchecker RegularPointChart + lake env leanchecker RegularPointChartInterface + lake env lean RegularPointChartAxiomAudit.lean + - name: Exercise axiom policy and inventory controls with Lean + working-directory: frontiers/regular_point_chart_20261020 + run: | + set -euo pipefail + python3 -B -S scripts/test_axiom_audit.py + - name: Mutation-test the negative diagnostic classifier + working-directory: frontiers/regular_point_chart_20261020 + run: | + set -euo pipefail + bash scripts/test_negative_classifier.sh + - name: Require omission of noncriticality to be rejected + working-directory: frontiers/regular_point_chart_20261020 + run: | + set -euo pipefail + set +e + lake env lean WithoutNoncriticality.lean > negative.log 2>&1 + status=$? + set -e + cat negative.log + bash scripts/classify_negative.sh negative.log "$status" diff --git a/docs/superpowers/plans/2026-10-20-c296-regular-point-chart.md b/docs/superpowers/plans/2026-10-20-c296-regular-point-chart.md new file mode 100644 index 000000000..f09c352f4 --- /dev/null +++ b/docs/superpowers/plans/2026-10-20-c296-regular-point-chart.md @@ -0,0 +1,111 @@ +# C296 Regular-Point Chart Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Kernel-check the literal regular scalar chart at a noncritical point of the project space `E d`, without weakening C294's closed-superlevel local-path-connectivity premise. + +**Architecture:** Add one isolated Lean package based on Math- PR #487 head `7af365e8c8db1ae0275d4efe08a70a678f153ca2`. The package copies C294's exact `Lifetime.lean` input, proves only the strict-derivative/surjective-derivative chart interface, and carries positive, negative, and axiom-audit modules. A packet-specific GitHub workflow provides red-then-green hosted execution because the local runtime cannot read `/proc//exe` in this environment. + +**Tech Stack:** Lean 4.34.1; Mathlib `d13f23b723b8a846827a245b89c10fc7d3f11612`; GitHub Actions `leanprover/lean-action@f061402b660e0c34644504b324e830f2991d4865`. + +**Spec:** `frontiers/critical_level_attainment_20261020/SCOPE.md`, narrowed by C295 finding `Math-#487/6289066726` and C296 pickup `Math-#487/6289277782`. + +## Global Constraints + +- Preserve every existing C294/C293 byte; the new packet is additive. +- Scientific effect remains NONE; no formal or scientific registry promotion. +- Do not prove or suggest a critical-point Morse chart, quotient transport, half-space relative LPC, or removal of C294's `LocallyPathConnectedSpace` premise. +- Pin Lean 4.34.1, Mathlib `d13f23b723b8a846827a245b89c10fc7d3f11612`, and every hosted source head used as evidence. +- Treat the local `/proc//exe` denial as a stop for local Lean execution; do not patch or bypass it. + +## Review Focus + +- Noncriticality must be used to prove the scalar derivative is nonzero; the negative module omits exactly that premise. +- Continuous-linear-map versus linear-map coercion must preserve the exact derivative and range statement. +- First-coordinate equality is global as a function equality, while inverse/homeomorphism claims remain restricted to source/target. +- The base point and `(g x, 0)` must be proved members of the chart's source and target. +- No theorem may silently imply closed-superlevel local path connectivity at critical points. + +--- + +### Task 1: Hosted red test for the missing project chart + +**Files:** +- Create: `frontiers/regular_point_chart_20261020/lean-toolchain` +- Create: `frontiers/regular_point_chart_20261020/lakefile.toml` +- Create: `frontiers/regular_point_chart_20261020/Lifetime.lean` +- Create: `frontiers/regular_point_chart_20261020/RegularPointChart.lean` +- Test: `frontiers/regular_point_chart_20261020/RegularPointChartInterface.lean` +- Create: `.github/workflows/c296-regular-point-chart.yml` + +**Interfaces:** +- Consumes: C294 `UniversalLaw.Spec.Lifetime.E`, `IsSmooth`, and `IsCriticalPoint` from the exact copied `Lifetime.lean`. +- Produces: a failing interface test naming the intended `regularPointChart` declaration and its source/target identities. + +- [x] **Step 1: Write the failing interface test** + +The test imports `RegularPointChart` and invokes the wished-for chart plus first-coordinate, self, source-membership, and target-membership declarations at arbitrary `d`, `g`, and `x` under smoothness and noncriticality. + +- [x] **Step 2: Run the hosted test to verify it fails** + +Run: open a draft PR from `codex/c296-regular-point-chart-20261020` to `codex/c294-critical-level-attainment-20261020` and wait for `c296-regular-point-chart`. + +Expected: FAIL at the exact red commit because `regularPointChart` (or its first intended helper) is unknown; setup/toolchain/source errors do not count as RED. + +- [x] **Step 3: Commit the red harness** + +Commit message: `test: pin C296 regular-point chart interface` + +### Task 2: Minimal literal chart implementation + +**Files:** +- Modify: `frontiers/regular_point_chart_20261020/RegularPointChart.lean` +- Test: `frontiers/regular_point_chart_20261020/RegularPointChartInterface.lean` +- Test: `frontiers/regular_point_chart_20261020/WithoutNoncriticality.lean` +- Test: `frontiers/regular_point_chart_20261020/RegularPointChartAxiomAudit.lean` + +**Interfaces:** +- Consumes: `(hg 1).hasStrictFDerivAt`, `Module.Dual.range_eq_top_of_ne_zero`, and `HasStrictFDerivAt.implicitToOpenPartialHomeomorph` at the pinned Mathlib revision. +- Produces: `regularPointDerivative_range_eq_top`, `regularPointHasStrictFDerivAt`, `regularPointChart`, `regularPointChart_fst`, `regularPointChart_self`, `mem_regularPointChart_source`, and `mem_regularPointChart_target`. + +- [x] **Step 1: Implement only the derivative and chart declarations required by the failing interface test** + +Use `fderiv ℝ g x` literally; derive strict differentiability from `IsSmooth`; convert noncriticality to a nonzero continuous linear functional, then to full scalar range; invoke the existing Mathlib chart. + +- [x] **Step 2: Add the omitted-noncriticality interface rejection** + +The negative module must fail by leaving the required `¬ IsCriticalPoint d g x` argument unsupplied. The workflow must require a nonzero exit and a diagnostic mentioning `IsCriticalPoint`; timeout/import/syntax/unknown-production-identifier failures do not count. + +- [x] **Step 3: Run hosted tests to verify they pass** + +Expected: positive modules build with warnings as errors; the negative module is rejected for the intended missing premise; named-module `leanchecker` and the axiom audit succeed. + +- [x] **Step 4: Commit the minimal implementation** + +Commit message: `feat: instantiate the regular scalar chart` + +### Task 3: Freeze source identities and hand off review + +**Files:** +- Create: `frontiers/regular_point_chart_20261020/README.md` +- Create: `frontiers/regular_point_chart_20261020/SCOPE.md` +- Create: `frontiers/regular_point_chart_20261020/SOURCE_SHA256SUMS` +- Create: `frontiers/regular_point_chart_20261020/RESULTS.md` + +**Interfaces:** +- Consumes: exact green head, workflow run/job identities, test streams, and Git blob/SHA-256 identities. +- Produces: a source-bound reviewable packet and explicit release record; no acceptance or integration claim. + +- [x] **Step 1: Record exact source, toolchain, positive/negative, axiom, and hosted-run identities** + +- [ ] **Step 2: Re-run the full hosted workflow at the frozen documentation head** + +Expected: all C296 jobs green at the new exact head; previous green evidence is stale if source bytes changed. + +- [ ] **Step 3: Commit documentation and request bounded nonauthor review** + +Commit message: `docs: freeze C296 execution scope` + +- [ ] **Step 4: Post result/release on Math-#487 and pointer on main#419** + +The release must state exact head, source blobs/digests, run IDs, negative-control reason, axiom scope, local platform denial, and all exclusions. diff --git a/frontiers/critical_level_attainment_20261020/AUTHOR_NOTES.md b/frontiers/critical_level_attainment_20261020/AUTHOR_NOTES.md new file mode 100644 index 000000000..eee6914bc --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/AUTHOR_NOTES.md @@ -0,0 +1,184 @@ +# C294 author notes — conditional attainment at literal death + +Author: OpenAI/Codex agent `/root/adapter_feasibility_c292`, delegated by the +parent for Dylan Roy. Same-provider and source/design exposure are explicit. +No organizational independence or human review is claimed. This is a new +formal implementation unit of the already delivered conventional C292 argument, +not a claim of a new conventional theorem or of full C292 formalization. + +Claim supplied and verified by parent: R17 Work Events 2392, +`2afaffe8-cf58-4bc7-9824-7585f9feb788`, 2026-10-20 08:18:25.505179 UTC through +10:18:25.505179 UTC. Canonical pickup: +[Math #419 / 6286648588](https://github.com/d6g8k5htny-coder/Math-/pull/419#issuecomment-6286648588); +mirror: +[Main #419 / 6286653565](https://github.com/d6g8k5htny-coder/main/pull/419#issuecomment-6286653565). +Parent handles continuing ownership, review, final isolated verification, +publication and custody. Shared libraries and all previous deliveries are +unchanged. + +## Exact acceptance boundary + +The public declarations are +`TorusCriticalAttainment.quotient_death_attainment` and +`TorusCriticalAttainment.euclidean_death_attainment`. +Their inputs are literal Lifetime smoothness, period-L periodicity, and Morse +distinctness, a positive real period, a starting point, and C263 nonessentiality. +The one additional geometric premise is + +```lean +LocallyPathConnectedSpace + {q : torus_quotient d L hL // + superlevelBar_deathHeight g M ≤ descendedHeight d L hL g hperiodic q} +``` + +Here `descendedHeight` is exactly C263 `torus_descend`, using the identical +Lifetime/C263 lattice-vector formula. There is no product-torus replacement +or half-open representative-domain compactness assumption. + +The quotient theorem derives one strictly older literal quotient critical point, +an actual path to it in the closed death superlevel, and equality with death at +some path parameter. The Euclidean theorem lifts this one path from the +prescribed representative M, derives literal criticality of the resulting +endpoint, and preserves every path height. It does not select one Euclidean +representative consistently across separate strict-level lifts. + +No fixed endpoint, finite event list, supplied path, trap, or desired death +identity is an input. Neither theorem claims strict death drop. The hypotheses +in fact permit every natural dimension; C292's positive-dimensional +nondegenerate-maximum locus specializes them without changing its d or L. +Only the nondegeneracy conjunct of Morse distinctness is used, through C293. +The distinct-critical-values conjunct is retained in the public source-facing +signature. + +## Proof and reuse + +For each a below the literal death delta, form the connected component K_a of +the starting quotient point in the closed superlevel {F >= a}. C263's strict +cut supplies a path to a strictly higher point and hence a higher point in K_a. +C263 already proves delta <= g(M), so no strict-death-drop or Taylor argument +is needed here. + +K_a is compact and connected. A maximizer of F on K_a lies strictly above g(M) +and therefore in the interior of {F >= a}. Ambient local connectedness implies +that K_a is a neighborhood of that maximizer. It is consequently a local +maximum on the quotient. Pulling back through the continuous projection and +using Fermat's theorem proves literal Euclidean criticality, hence membership +in C293's quotient critical set. + +Intersect that finite critical set with {F > g(M)}. This compact older set +meets every K_a. Since the K_a form a downward-directed family of closed sets, +compactness supplies one older critical Q in all of them. This is an actual +fixed-endpoint argument, without assuming a candidate/event list. + +The directed intersection of the K_a is preconnected. The new elementary +helper proves this by normal separation and the existing compact +directed-closed-family lemma: a separation of the intersection would give a +separation of one K_a. This argument concerns compact sets, not path space. +Every point of the intersection lies in {F >= delta}, so M and Q belong to +the same connected component of that actual closed level. + +The explicit closed-level local-path-connectivity premise is used at this last +step to turn connected-component membership into a path. If the path never +equalled delta, its heights would all be strictly above delta, contradicting +C263's `superlevelBar_death_not_mem_clearance`. Finally, specified-start +covering-map lifting preserves the whole path and C293's quotient derivative +identifies the lifted endpoint as a literal critical point. + +Before adding this helper, inspected C258 `DEATH_PAIR_PROOF.md` and +`NEXT_TASK.md`: these are a conventional proof and a formal dependency list, +not a Lean intersection implementation. C258 expressly leaves formal +realization open. Also inspected the actual frozen `ClosedSuperlevel`, +`OrdinaryH0`, `ElderClearance`, `ElderInterval`, and `ElderBridge` +declarations. The existing trap has a `closed_path` input; its attainment +theorem assumes the displayed path and its closed-height bound. +`OrdinaryH0` explicitly supplies no critical-level attainment theorem. +`ClosedSuperlevel` is reused unchanged, including its closed-level definition +and `superlevel_neg_height`/`superlevel_isClosed` facts. No generic +compact-directed-connected-intersection theorem was located in these modules +or in the pinned Mathlib search. + +The immutable module DAG is: + +```text +Lifetime ───────┐ + ├── MorseFiniteCritical ──┐ +TorusTopology ─┘ │ +SuperlevelBar ───────────────────────────┼── CriticalLevelAttainment +ClosedSuperlevel ────────────────────────┘ +``` + +Exact source bytes, SHA-256 and Git blobs are in `SOURCE_INPUTS.json`. +Mathlib is pinned at `d13f23b723b8a846827a245b89c10fc7d3f11612`. +The runtime is the existing Lean 4.34.1 binary, SHA-256 +`1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554`. + +## Remaining mathematical boundary + +The implication from literal Morse data to local path connectivity of the +actual closed death superlevel remains open in this formal development. +No smooth Morse normal-form theorem was found at the pin. +The submersion file defines its property through local normal forms and lists +the implication from a derivative right inverse/surjectivity as future work. +C293's inverse-function argument for the derivative map proves critical-point +isolation, not a quadratic normal form for g. + +This unit does not prove the full C292 trap/frontier package, strict death +drop, a saddle index, actual elder pairing, exhaustive once-counted bars, +all-small-bars converses, regional shrinking-collision statements, or any +probabilistic/asymptotic conclusion. There is no coefficient-field input or +limit-order change: this is deterministic geometry of one literal sample +function at fixed d and positive L. + +## Development evidence + +Development writes are confined to C294. The runner serializes Lean, +uses two threads and a 4096 MB limit, retains stdout/stderr and receipts, +and stores each compiled source snapshot by SHA-256. Shared dependencies +are read only. + +The first fresh Lifetime dependency build timed out at 240.03 seconds with +empty diagnostics and unchanged exact source. This failure is retained. +The three C293 dependency objects were then copied only after live source +and object hashes matched C293's terminal receipt. That explicit development +reuse is recorded in `evidence/DEVELOPMENT_OBJECT_REUSE.json`; it is not +fresh C294 source-build evidence. + +The independent fresh ClosedSuperlevel build also timed out at 240.06 seconds +with empty diagnostics and unchanged source. Its old object was copied only +after its live hash and source hash matched the existing successful build +record and reviewed compiled-artifact manifest. This separate development +reuse is in `evidence/CLOSED_SUPERLEVEL_OBJECT_REUSE.json`. +The original 240-second runner is retained in evidence. Later development +invocations have a bounded 600-second limit. A one-second sample of the +running SuperlevelBar process located the active worker in Lean import +finalization (`lean_mark_persistent`), not theorem elaboration. +SuperlevelBar then passed a fresh build in 204.61 seconds with clean output. + +The main module's first three attempts failed elaboration in 92.74, 75.04, +and 67.34 seconds. Their exact source snapshots and diagnostics are retained. +Corrections made actual set-membership inequalities explicit, installed the +actual quotient's derived ambient local-path-connectivity instance explicitly, +used the existing JoinedIn subtype/component API, and replaced obsolete +proof-local `letI` style with `let`. The public endpoint signatures and +mathematical hypotheses did not change. + +The fourth main-module attempt passed in 73.72253683299999 seconds, return code +zero, with empty stdout and stderr and unchanged source. Receipt: +`runs/20261020T084025Z-CriticalLevelAttainment-deeba258/RECEIPT.json`, +SHA-256 `e64482068df7b48ac984c156054188b09b4ef865b504e6d1faa39334875aab1c`. + +Stable main source: 14,338 bytes, +SHA-256 `ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12`, +Git blob `1579751ec03c14f3dfd90df98db7a37d8ca74e09`. +Development object SHA-256: +`ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235`. +`AUTHOR_MODULE_INVENTORY.json` binds these records and lists the thirteen +explicit declarations; this count is not a generated/transitive axiom census. +Proof edits stopped at this clean source. + +Status: **clean author development compilation passed**. This does not claim +fresh C294 compilation of all reused dependencies. Parent's isolated final +source builds, standard named-module kernel replays, complete axiom census, +omitted-LPC negative invocation, exact-artifact nonauthor review, publication +and custody remain separate work. No final acceptance or scientific promotion +is claimed. diff --git a/frontiers/critical_level_attainment_20261020/FINAL_SEQUENCE_RESULT.json b/frontiers/critical_level_attainment_20261020/FINAL_SEQUENCE_RESULT.json new file mode 100644 index 000000000..e723cc824 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/FINAL_SEQUENCE_RESULT.json @@ -0,0 +1,72 @@ +{ + "started_utc": "2026-10-20T08:43:13.224447+00:00", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "phases": [ + { + "kind": "build", + "module": "Lifetime", + "started_utc": "2026-10-20T08:43:13.224471+00:00", + "ended_utc": "2026-10-20T08:44:50.326760+00:00", + "returncode": 0 + }, + { + "kind": "build", + "module": "TorusTopology", + "started_utc": "2026-10-20T08:44:50.326790+00:00", + "ended_utc": "2026-10-20T08:46:21.882911+00:00", + "returncode": 0 + }, + { + "kind": "build", + "module": "SuperlevelBar", + "started_utc": "2026-10-20T08:46:21.882966+00:00", + "ended_utc": "2026-10-20T08:47:47.813570+00:00", + "returncode": 0 + }, + { + "kind": "build", + "module": "ClosedSuperlevel", + "started_utc": "2026-10-20T08:47:47.813615+00:00", + "ended_utc": "2026-10-20T08:49:08.013194+00:00", + "returncode": 0 + }, + { + "kind": "build", + "module": "MorseFiniteCritical", + "started_utc": "2026-10-20T08:49:08.013234+00:00", + "ended_utc": "2026-10-20T08:50:31.224729+00:00", + "returncode": 0 + }, + { + "kind": "build", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:50:31.224771+00:00", + "ended_utc": "2026-10-20T08:51:55.500432+00:00", + "returncode": 0 + }, + { + "kind": "build", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:51:55.500471+00:00", + "ended_utc": "2026-10-20T08:53:36.147949+00:00", + "returncode": 0 + }, + { + "kind": "kernel", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:53:36.147990+00:00", + "ended_utc": "2026-10-20T08:54:50.049220+00:00", + "returncode": 0 + }, + { + "kind": "kernel", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:54:50.049271+00:00", + "ended_utc": "2026-10-20T08:56:01.524620+00:00", + "returncode": 0 + } + ], + "scientific_effect": "NONE", + "status": "PASS_FROZEN_BUILD_AND_STANDARD_KERNEL_REPLAY", + "ended_utc": "2026-10-20T08:56:01.524659+00:00" +} diff --git a/frontiers/critical_level_attainment_20261020/FINAL_SEQUENCE_START.json b/frontiers/critical_level_attainment_20261020/FINAL_SEQUENCE_START.json new file mode 100644 index 000000000..810971ef6 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/FINAL_SEQUENCE_START.json @@ -0,0 +1,6 @@ +{ + "started_utc": "2026-10-20T08:43:13.223895+00:00", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "driver_sha256": "8cb8a75b384c0c84f1a000f217616a3d99710b34bf2e04237b65f220ff9302ce", + "scientific_effect": "NONE" +} diff --git a/frontiers/critical_level_attainment_20261020/FINAL_SOURCE_INVENTORY.json b/frontiers/critical_level_attainment_20261020/FINAL_SOURCE_INVENTORY.json new file mode 100644 index 000000000..1482e902a --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/FINAL_SOURCE_INVENTORY.json @@ -0,0 +1,80 @@ +{ + "frozen_utc": "2026-10-20T08:43:07.492616+00:00", + "prepare_start_record": "$C294_ROOT/final-prepare-attempts/2026-10-20T084258.355017_0000-4f2675bdddb74318b5624e5d370117c4.json", + "prepare_start_sha256": "ba4d3513666bd0bf33ae2206a03d70fa2f0372fc28809c0cbdd580bb1601bfed", + "prior_legacy_start": null, + "sources": [ + { + "name": "Lifetime.lean", + "sha256": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "bytes": 51383 + }, + { + "name": "TorusTopology.lean", + "sha256": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1", + "bytes": 12257 + }, + { + "name": "SuperlevelBar.lean", + "sha256": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "bytes": 15309 + }, + { + "name": "ClosedSuperlevel.lean", + "sha256": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "bytes": 8088 + }, + { + "name": "MorseFiniteCritical.lean", + "sha256": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "bytes": 9445 + }, + { + "name": "CriticalLevelAttainment.lean", + "sha256": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "bytes": 14338 + }, + { + "name": "CriticalLevelAxiomAudit.lean", + "sha256": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "bytes": 2719 + } + ], + "build_order": [ + "Lifetime", + "TorusTopology", + "SuperlevelBar", + "ClosedSuperlevel", + "MorseFiniteCritical", + "CriticalLevelAttainment", + "CriticalLevelAxiomAudit" + ], + "local_imports": { + "Lifetime": [], + "TorusTopology": [], + "SuperlevelBar": [], + "ClosedSuperlevel": [], + "MorseFiniteCritical": [ + "Lifetime", + "TorusTopology" + ], + "CriticalLevelAttainment": [ + "MorseFiniteCritical", + "SuperlevelBar", + "ClosedSuperlevel" + ], + "CriticalLevelAxiomAudit": [ + "CriticalLevelAttainment" + ] + }, + "new_modules": [ + "CriticalLevelAttainment", + "CriticalLevelAxiomAudit" + ], + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "preparer_sha256": "53a84ed98df9b694d75cae29460c5e9cb79150e04ad318afcae94297a5c4e8e8", + "dependency_artifact_inventory_sha256": "834e1c65f1c32e1b6660ae2fda385e46e741cc371b05652d407d0b173ad04476", + "c291_inventory_sha256": "b78b6e0f99bd38c633ae2677c55698363b1290e6d4318e505991c8df259ae2e3", + "scientific_effect": "NONE", + "execution_provenance": "LOCAL; no hosted qualification" +} diff --git a/frontiers/critical_level_attainment_20261020/PUBLIC_PROJECTION.json b/frontiers/critical_level_attainment_20261020/PUBLIC_PROJECTION.json new file mode 100644 index 000000000..1259ad3b0 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/PUBLIC_PROJECTION.json @@ -0,0 +1,718 @@ +{ + "files": [ + { + "bytes": 10001, + "original_bytes": 10001, + "original_sha256": "74084e011d356bd8a342b970c59e7cdecae89280e7e54cd9f44dec6ced6d8992", + "path": "AUTHOR_NOTES.md", + "projection": false, + "sha256": "74084e011d356bd8a342b970c59e7cdecae89280e7e54cd9f44dec6ced6d8992" + }, + { + "bytes": 2179, + "original_bytes": 2179, + "original_sha256": "38f9d6ec096c3ce6136c5a2a9b514b172b226baffcf3356ba94df3976cfd8cab", + "path": "FINAL_SEQUENCE_RESULT.json", + "projection": false, + "sha256": "38f9d6ec096c3ce6136c5a2a9b514b172b226baffcf3356ba94df3976cfd8cab" + }, + { + "bytes": 264, + "original_bytes": 264, + "original_sha256": "97b87fdcc73eb27e2ce251b99b73d66235f822cae901c66d79acafacf807a0cd", + "path": "FINAL_SEQUENCE_START.json", + "projection": false, + "sha256": "97b87fdcc73eb27e2ce251b99b73d66235f822cae901c66d79acafacf807a0cd" + }, + { + "bytes": 2567, + "original_bytes": 2648, + "original_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "path": "FINAL_SOURCE_INVENTORY.json", + "projection": true, + "sha256": "cbb62b5ea58455f598fa243b1a907196fbbf3601b0d21cebda171dc3c024ccbd" + }, + { + "bytes": 3929, + "original_bytes": 3929, + "original_sha256": "00cd2d7572977854831917c8be5d8c93b1f7aab67d1967dfb6d0cd60ddfbe2b5", + "path": "PUBLIC_SOURCE_BINDINGS.json", + "projection": false, + "sha256": "00cd2d7572977854831917c8be5d8c93b1f7aab67d1967dfb6d0cd60ddfbe2b5" + }, + { + "bytes": 6993, + "original_bytes": 6993, + "original_sha256": "3a5cf6565bb28cc7df91a3abdd732758af1dfad1e60b66a0ec35157604f97e5b", + "path": "README.md", + "projection": false, + "sha256": "3a5cf6565bb28cc7df91a3abdd732758af1dfad1e60b66a0ec35157604f97e5b" + }, + { + "bytes": 11600, + "original_bytes": 11600, + "original_sha256": "f324dc7d26cd279f26090623ee010b874d6bf28e7acd1447f7b6b52a3a6c1928", + "path": "REPLAY.md", + "projection": false, + "sha256": "f324dc7d26cd279f26090623ee010b874d6bf28e7acd1447f7b6b52a3a6c1928" + }, + { + "bytes": 1722, + "original_bytes": 1722, + "original_sha256": "cf987620b862625805dd8ce6b1df8174c1e3cf3ddd9570a60737f6dea309a5f0", + "path": "ROOT_ACCEPTANCE.json", + "projection": false, + "sha256": "cf987620b862625805dd8ce6b1df8174c1e3cf3ddd9570a60737f6dea309a5f0" + }, + { + "bytes": 5240, + "original_bytes": 5240, + "original_sha256": "505556eba193ebe2e3e064c76ebbcf056c5557d5e220f84c673b1394bce6d7ff", + "path": "SCOPE.md", + "projection": false, + "sha256": "505556eba193ebe2e3e064c76ebbcf056c5557d5e220f84c673b1394bce6d7ff" + }, + { + "bytes": 5353, + "original_bytes": 5353, + "original_sha256": "8f434fa12a8e9e59ad3609b29c289abf430212bee6073a32266ae71f169d297c", + "path": "evidence/EXECUTION_HISTORY.md", + "projection": false, + "sha256": "8f434fa12a8e9e59ad3609b29c289abf430212bee6073a32266ae71f169d297c" + }, + { + "bytes": 519, + "original_bytes": 600, + "original_sha256": "bdd7f609cfd998c517652f53144de0300ca9f919387866ca0997caba8aa3732d", + "path": "evidence/FINAL_BUILD_INITIALIZATION.json", + "projection": true, + "sha256": "e901162290e2097cbab87a12eb9d867654c97922e4a8122ee748d8b767d8e37b" + }, + { + "bytes": 3332, + "original_bytes": 3332, + "original_sha256": "b727da20efcf4f3b7cb11731af40bb97b1ec3bf93eb9d856ca3585d2860e85c2", + "path": "evidence/MASTER_CONTRACT.md", + "projection": false, + "sha256": "b727da20efcf4f3b7cb11731af40bb97b1ec3bf93eb9d856ca3585d2860e85c2" + }, + { + "bytes": 864, + "original_bytes": 864, + "original_sha256": "6e8d850e396b964694bd7033d6e5be1fd4639ccf335328ff49ef72396d28387c", + "path": "evidence/MEASURED_AXIOM_CENSUS.json", + "projection": false, + "sha256": "6e8d850e396b964694bd7033d6e5be1fd4639ccf335328ff49ef72396d28387c" + }, + { + "bytes": 3038, + "original_bytes": 3038, + "original_sha256": "2f32254771f9ce10f6c40ad68c411b1631cea967be5a0ad0932a8db345464dcc", + "path": "evidence/PREPUBLICATION_DELTA_20261020T085749Z.md", + "projection": false, + "sha256": "2f32254771f9ce10f6c40ad68c411b1631cea967be5a0ad0932a8db345464dcc" + }, + { + "bytes": 5930, + "original_bytes": 5930, + "original_sha256": "ec2034b3abc7998015edf8b2c74f435ada9cf199320b6ad072f4cb2d122b5439", + "path": "evidence/ROOT_MATHEMATICAL_CHECK.md", + "projection": false, + "sha256": "ec2034b3abc7998015edf8b2c74f435ada9cf199320b6ad072f4cb2d122b5439" + }, + { + "bytes": 192, + "original_bytes": 192, + "original_sha256": "ba4d3513666bd0bf33ae2206a03d70fa2f0372fc28809c0cbdd580bb1601bfed", + "path": "final-prepare-attempts/2026-10-20T084258.355017_0000-4f2675bdddb74318b5624e5d370117c4.json", + "projection": false, + "sha256": "ba4d3513666bd0bf33ae2206a03d70fa2f0372fc28809c0cbdd580bb1601bfed" + }, + { + "bytes": 8088, + "original_bytes": 8088, + "original_sha256": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "path": "final-project/ClosedSuperlevel.lean", + "projection": false, + "sha256": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2" + }, + { + "bytes": 14338, + "original_bytes": 14338, + "original_sha256": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "path": "final-project/CriticalLevelAttainment.lean", + "projection": false, + "sha256": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12" + }, + { + "bytes": 2719, + "original_bytes": 2719, + "original_sha256": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "path": "final-project/CriticalLevelAxiomAudit.lean", + "projection": false, + "sha256": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358" + }, + { + "bytes": 51383, + "original_bytes": 51383, + "original_sha256": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "path": "final-project/Lifetime.lean", + "projection": false, + "sha256": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6" + }, + { + "bytes": 9445, + "original_bytes": 9445, + "original_sha256": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "path": "final-project/MorseFiniteCritical.lean", + "projection": false, + "sha256": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b" + }, + { + "bytes": 15309, + "original_bytes": 15309, + "original_sha256": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "path": "final-project/SuperlevelBar.lean", + "projection": false, + "sha256": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9" + }, + { + "bytes": 12257, + "original_bytes": 12257, + "original_sha256": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1", + "path": "final-project/TorusTopology.lean", + "projection": false, + "sha256": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + { + "bytes": 2438, + "original_bytes": 3599, + "original_sha256": "9a3fb6e2169d64052fae057a69d1b7b1a03491afa5bfa7fef6029dcc2432bdc1", + "path": "final-runs/20261020T084313Z-build-Lifetime-f6a32f33/PREFLIGHT.json", + "projection": true, + "sha256": "7ec245be3da05f284c976d7054e1c9d1ef1ad06acd0a012851a56e356480e164" + }, + { + "bytes": 2460, + "original_bytes": 3621, + "original_sha256": "3eb1f0e583f061988d72a7bb691ad1541caf8cfc3c1a46b4ece30a365fce5bb2", + "path": "final-runs/20261020T084313Z-build-Lifetime-f6a32f33/PROCESS_START.json", + "projection": true, + "sha256": "d9b42123f72f6954e01a0c11447903a53a5ea5f466f053904a1efd784737d11c" + }, + { + "bytes": 4052, + "original_bytes": 5213, + "original_sha256": "f2a6d46be92dcf11e26af3d7bbdc052cd5f16f58f697790ffd0fa0328d8e9a68", + "path": "final-runs/20261020T084313Z-build-Lifetime-f6a32f33/RECEIPT.json", + "projection": true, + "sha256": "c2c614da787136ed5bc393b1071ed756cb8dc5f55b0d8159b5951947486e561a" + }, + { + "bytes": 399, + "original_bytes": 399, + "original_sha256": "3d7b31dbe17cc3d6693262983abb166337a3baf9dfedf63033e1aad68a6a13ed", + "path": "final-runs/20261020T084313Z-build-Lifetime-f6a32f33/START.json", + "projection": false, + "sha256": "3d7b31dbe17cc3d6693262983abb166337a3baf9dfedf63033e1aad68a6a13ed" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084313Z-build-Lifetime-f6a32f33/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084313Z-build-Lifetime-f6a32f33/stdout.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 2545, + "original_bytes": 3706, + "original_sha256": "aff63c028ad5095fceaa370eb55b64e2e0b328f9cee6c9672dda9abf49768742", + "path": "final-runs/20261020T084450Z-build-TorusTopology-d84fe754/PREFLIGHT.json", + "projection": true, + "sha256": "e92ea6987f1b80c410c9c32f4809f7a83c05eec8febda3accc938227088d9532" + }, + { + "bytes": 2567, + "original_bytes": 3728, + "original_sha256": "a4baba6d13b65a7e02f1bc90186998ae325ea9d441da3b324ec6a313c101100e", + "path": "final-runs/20261020T084450Z-build-TorusTopology-d84fe754/PROCESS_START.json", + "projection": true, + "sha256": "44aead47055c4b7c7aa00f63217d8f7d7d96600bc48c9cfab44d3b1158a30986" + }, + { + "bytes": 4258, + "original_bytes": 5419, + "original_sha256": "db6d742d26a8bda5c1d9b60612bdb9d7c76d1a8a8299628ca9cc5aac854c7e2d", + "path": "final-runs/20261020T084450Z-build-TorusTopology-d84fe754/RECEIPT.json", + "projection": true, + "sha256": "531f9999b4acf444cd385e37521e3a07d79748365050fcb0b9dde643e39489f7" + }, + { + "bytes": 404, + "original_bytes": 404, + "original_sha256": "c1e1cb5760734b18231eb45bbebf1491453de9f388355797cf94d91c877156fc", + "path": "final-runs/20261020T084450Z-build-TorusTopology-d84fe754/START.json", + "projection": false, + "sha256": "c1e1cb5760734b18231eb45bbebf1491453de9f388355797cf94d91c877156fc" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084450Z-build-TorusTopology-d84fe754/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084450Z-build-TorusTopology-d84fe754/stdout.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 2640, + "original_bytes": 3801, + "original_sha256": "6a645044adad9ce5e7927422f1195ff142fce243f35bcf07a720e2854dd93f24", + "path": "final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/PREFLIGHT.json", + "projection": true, + "sha256": "d3e0879e5a267f1946b592338db767f39db3224fc210a6e6522be600f2e4eed9" + }, + { + "bytes": 2662, + "original_bytes": 3823, + "original_sha256": "85d2b59fa45b1225327bdb0a561c695d33858ff47a5050b72cad0479261e7279", + "path": "final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/PROCESS_START.json", + "projection": true, + "sha256": "8328bacc22b720fb279d15d3c000f66679062007480d1f61eeb65a496f9f1eee" + }, + { + "bytes": 4454, + "original_bytes": 5615, + "original_sha256": "8737621e1c2e2d34e6c68d452f3d19a693960ff3a066b431194ec480a45ebbb9", + "path": "final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/RECEIPT.json", + "projection": true, + "sha256": "d7238f8b5cd68e47f7a980e6405f2f63fcb407b75bef1f33e86a01b306863feb" + }, + { + "bytes": 404, + "original_bytes": 404, + "original_sha256": "665cbfe23a08dee8a9d60aa4aa2436b2d16ef0e67ffffa3778bbc09026849e73", + "path": "final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/START.json", + "projection": false, + "sha256": "665cbfe23a08dee8a9d60aa4aa2436b2d16ef0e67ffffa3778bbc09026849e73" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/stdout.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 2744, + "original_bytes": 3905, + "original_sha256": "037053af8203be0827dc935a7860dd0c2eba860fc592aa5ac0ca7110eb110df8", + "path": "final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/PREFLIGHT.json", + "projection": true, + "sha256": "b0b3e75304290e82c518c2161a48509c871abd98daf932b19d7531d7e64e0d00" + }, + { + "bytes": 2766, + "original_bytes": 3927, + "original_sha256": "619bbc3b0ec3909bcbb458db8a55a02ed9e6cdc9dec2bd568e0277c70965b828", + "path": "final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/PROCESS_START.json", + "projection": true, + "sha256": "8403e0196a6ce8e7acd357d537754e1eb7f481ffeedb81fd431255cb53c84a73" + }, + { + "bytes": 4654, + "original_bytes": 5815, + "original_sha256": "e74ec589139dc74b9f41dc87ec20442ef8c7b8ac6ec76d33c8777ddd8627e9e8", + "path": "final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/RECEIPT.json", + "projection": true, + "sha256": "c249ec7bd0fed331d96258b36a9e4af089d784140e42719db5c0cf9b2e108229" + }, + { + "bytes": 407, + "original_bytes": 407, + "original_sha256": "05cb22c2799737b3959a2e5b35d05757330c8bb2a15546bad2452468746bb0f5", + "path": "final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/START.json", + "projection": false, + "sha256": "05cb22c2799737b3959a2e5b35d05757330c8bb2a15546bad2452468746bb0f5" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/stdout.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 2851, + "original_bytes": 4012, + "original_sha256": "0b6a4dfcd18494bc55f7bc2568e14733a50a645c215f771a8191247fb525d6c7", + "path": "final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/PREFLIGHT.json", + "projection": true, + "sha256": "52704dc461f1d32ec5b7d7ded37695445ece6cf65fd22e58c90296c594cda142" + }, + { + "bytes": 2873, + "original_bytes": 4034, + "original_sha256": "99279d6d35e042cbb66b710ab2cb0d073bd9d9ebc5aa21e0dff936de2a2c000b", + "path": "final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/PROCESS_START.json", + "projection": true, + "sha256": "ccc8f5436c938728cf44fccbfcf11cf9b52edbb622b38e346c6b2d123a484c07" + }, + { + "bytes": 4870, + "original_bytes": 6031, + "original_sha256": "799656ceacdbbb31a30b235ed1ee0af7874774ac754f79b0bf02b6acd62e673f", + "path": "final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/RECEIPT.json", + "projection": true, + "sha256": "03789a7f3c92065706530159e63a786459b97b0181153b0e7e75fcfafbb44088" + }, + { + "bytes": 410, + "original_bytes": 410, + "original_sha256": "409dc9ca2d6fee8ceaf2f84f6d4ec3fde34caff74513d3cf19a446f1a4d29e2f", + "path": "final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/START.json", + "projection": false, + "sha256": "409dc9ca2d6fee8ceaf2f84f6d4ec3fde34caff74513d3cf19a446f1a4d29e2f" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/stdout.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 2993, + "original_bytes": 4154, + "original_sha256": "f957119bf0c226b0a8455d0c7e52aa0ace3c90c2de03b1305648200daa384f5d", + "path": "final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/PREFLIGHT.json", + "projection": true, + "sha256": "97c4188fbebdea61a1a4e18715ab3f6f58765fbf40993d9b770c8a016ea1f2ec" + }, + { + "bytes": 3015, + "original_bytes": 4176, + "original_sha256": "6b33e07eaba7d661d2e7eae0f6f6f44d8d36aa4942c4a7c7de1a1d60a36d7ddc", + "path": "final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/PROCESS_START.json", + "projection": true, + "sha256": "f290923631612a5f693d38159fcb0721e7df3661f99ffe3d3ac16e46358fbab3" + }, + { + "bytes": 5116, + "original_bytes": 6277, + "original_sha256": "323942805f07c479d847d9fd94a666c06dd9be7efcd0e6651d35a35af032fd93", + "path": "final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/RECEIPT.json", + "projection": true, + "sha256": "9b0a311cbb1c8747a10ccac903f809ec74a202d08a415879bcc6f47b03dbfc01" + }, + { + "bytes": 414, + "original_bytes": 414, + "original_sha256": "f9594cf54d44659541417bb3f50b187afa1baf1ad50cf6f1a98803df2b1c1549", + "path": "final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/START.json", + "projection": false, + "sha256": "f9594cf54d44659541417bb3f50b187afa1baf1ad50cf6f1a98803df2b1c1549" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/stdout.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 3098, + "original_bytes": 4259, + "original_sha256": "0cf8d33320ec661553f1f9a3fe7ebd4ece3a21f4dd45e23f039fd8a68fa04227", + "path": "final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/PREFLIGHT.json", + "projection": true, + "sha256": "824a69e418b225bbbc760364a38332bc7da2c2875e0ee706717bf101a9559e47" + }, + { + "bytes": 3120, + "original_bytes": 4281, + "original_sha256": "df181f7bed56723b4fc57aa89e0fa2d5c815a52c7ec67d61d3a1ae7fddc930eb", + "path": "final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/PROCESS_START.json", + "projection": true, + "sha256": "fe021499dca7d9f08cda1a932bd72a6855eba163e1c6078fa17eefb9e9cac032" + }, + { + "bytes": 5327, + "original_bytes": 6488, + "original_sha256": "5a36871eb48ea16068bbe700964f656820d4b7861a33fc86f20c5b5b96c79570", + "path": "final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/RECEIPT.json", + "projection": true, + "sha256": "5ad23437ef742a6bfeac4b2df741f025e83a260f4639edab9b2511e1a3fcdda9" + }, + { + "bytes": 414, + "original_bytes": 414, + "original_sha256": "7e15470010edb8330dff9fdeab9962091d0dab25b5ca11256e996684abe0622a", + "path": "final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/START.json", + "projection": false, + "sha256": "7e15470010edb8330dff9fdeab9962091d0dab25b5ca11256e996684abe0622a" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 30642, + "original_bytes": 30642, + "original_sha256": "062a8168ad5b05f1238ea8fd516d7fc5a806941cf77480b6de6837921c294386", + "path": "final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stdout.txt", + "projection": false, + "sha256": "062a8168ad5b05f1238ea8fd516d7fc5a806941cf77480b6de6837921c294386" + }, + { + "bytes": 3067, + "original_bytes": 4066, + "original_sha256": "4df404cb55e9d4c76d4bf5fa65cbec53291fa6ff64dcf0766fe96e46e2d9fcc3", + "path": "final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/PREFLIGHT.json", + "projection": true, + "sha256": "a45734de1b6fdb41084dfea873c8b7535ffeff9e7928449d63911275b3a2a0b2" + }, + { + "bytes": 3089, + "original_bytes": 4088, + "original_sha256": "9851c640ea25b034b8e89682af5b536569471587361b73a851a19c5fb149bd02", + "path": "final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/PROCESS_START.json", + "projection": true, + "sha256": "7cfccd579f51952bf7ce9536bbb9fd48f5e4fd6eb5184d1915648a429db56c80" + }, + { + "bytes": 5294, + "original_bytes": 6293, + "original_sha256": "0c0322d5a37980b74d1bf20c8e5bf6463f4d672761a6b121aa6f249b57becad4", + "path": "final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/RECEIPT.json", + "projection": true, + "sha256": "421b7897fe7dc7b30c4b82b2b307900aa22a73b7134d4dd28cbec31f5d4fbbfd" + }, + { + "bytes": 415, + "original_bytes": 415, + "original_sha256": "b456580ce02d862446f88f8df041317461b95d6692e4fa2912a7dd388f9a76e9", + "path": "final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/START.json", + "projection": false, + "sha256": "b456580ce02d862446f88f8df041317461b95d6692e4fa2912a7dd388f9a76e9" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 34, + "original_bytes": 34, + "original_sha256": "8e31a3a3001f93627db850f58fccdfac385f45d769f57b760168d54b406326b6", + "path": "final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/stdout.txt", + "projection": false, + "sha256": "8e31a3a3001f93627db850f58fccdfac385f45d769f57b760168d54b406326b6" + }, + { + "bytes": 3067, + "original_bytes": 4066, + "original_sha256": "bdfd94de0f0729c35ab05e99444086272e6f4c1874bdf16a94e60f08cc560d30", + "path": "final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/PREFLIGHT.json", + "projection": true, + "sha256": "8265c57c7e151702b2c5a199f3782c8d9a48685204b843aa22830cfaf0343890" + }, + { + "bytes": 3089, + "original_bytes": 4088, + "original_sha256": "967ca82be68d46d2bd4c7067121ec9e443cbb6ab3f8f6d77539337f927ff498f", + "path": "final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/PROCESS_START.json", + "projection": true, + "sha256": "dad792b149eb0f24f0a3238aad2f878b6bc8d007f7be75efdb12f4ca1ea304ab" + }, + { + "bytes": 5300, + "original_bytes": 6299, + "original_sha256": "1466292a0c9b147da2b920d1184443c7d3ee5fddbeef8b799f88e21dfe1fb150", + "path": "final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/RECEIPT.json", + "projection": true, + "sha256": "78b8bdcbb84c20f87971086fa854d77b7686b04489f4e8fdecdb2941a8969777" + }, + { + "bytes": 415, + "original_bytes": 415, + "original_sha256": "2f697a2694f06982be294c084b5e93498c6fccee59272e04f0fe1f73f63c0094", + "path": "final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/START.json", + "projection": false, + "sha256": "2f697a2694f06982be294c084b5e93498c6fccee59272e04f0fe1f73f63c0094" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 34, + "original_bytes": 34, + "original_sha256": "b1e64047e463a6b3b98984c683782da30469da75d5854c5f8f52f4d4576b2261", + "path": "final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/stdout.txt", + "projection": false, + "sha256": "b1e64047e463a6b3b98984c683782da30469da75d5854c5f8f52f4d4576b2261" + }, + { + "bytes": 17297, + "original_bytes": 17297, + "original_sha256": "14c82931a8528019e0fd5b745937ef1f776d5689965ba9de8735c2dbd12bbbf8", + "path": "final_master.py", + "projection": false, + "sha256": "14c82931a8528019e0fd5b745937ef1f776d5689965ba9de8735c2dbd12bbbf8" + }, + { + "bytes": 2633, + "original_bytes": 2825, + "original_sha256": "8ca6e056a828a1867dab0109b3368627e9be88417835534f791775ecebe8acf1", + "path": "negative-final/RECEIPT.json", + "projection": true, + "sha256": "ab07637701a402b01a3cefec698f5b787cb2ba2a11f0d1a049fd0bafa9922ad0" + }, + { + "bytes": 2126, + "original_bytes": 2318, + "original_sha256": "39479747c5581e8f646717a86d3659497c04de752c540e532ec53883d3e80ad4", + "path": "negative-final/START.json", + "projection": true, + "sha256": "151e0337b301dd10c9f1ef214e70b460fa19b430de9fd58ed21a6e121efcc438" + }, + { + "bytes": 0, + "original_bytes": 0, + "original_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "path": "negative-final/stderr.txt", + "projection": false, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 760, + "original_bytes": 841, + "original_sha256": "103fca1879ac4965b80766263cab5f18f64dbe46ddbb9de70aef49976fbdafd8", + "path": "negative-final/stdout.txt", + "projection": true, + "sha256": "35fe5b685302629f86172dd886dfa9e21b82503a2b630820b36c706069bdecbc" + }, + { + "bytes": 989, + "original_bytes": 989, + "original_sha256": "d685f2dff3c915cc2e3ea1db25aed672a5fc9c1886237366bf122e92c05d3f32", + "path": "negative-project/WithoutClosedLPC.lean", + "projection": false, + "sha256": "d685f2dff3c915cc2e3ea1db25aed672a5fc9c1886237366bf122e92c05d3f32" + }, + { + "bytes": 4087, + "original_bytes": 4087, + "original_sha256": "53a84ed98df9b694d75cae29460c5e9cb79150e04ad318afcae94297a5c4e8e8", + "path": "prepare_final_inputs.py", + "projection": false, + "sha256": "53a84ed98df9b694d75cae29460c5e9cb79150e04ad318afcae94297a5c4e8e8" + }, + { + "bytes": 8985, + "original_bytes": 8985, + "original_sha256": "4ac26c31950c367d911f0d8cb2e67afd2d187eebea815040f40547b2824dfa1c", + "path": "reviews/MAIN_SOURCE_REVIEW.md", + "projection": false, + "sha256": "4ac26c31950c367d911f0d8cb2e67afd2d187eebea815040f40547b2824dfa1c" + }, + { + "bytes": 29790, + "original_bytes": 29871, + "original_sha256": "c20a21fa16a4a865b613f50b447c55a2283fffeefc5c08e7dca01d727124a35f", + "path": "reviews/NONAUTHOR_REVIEW.md", + "projection": true, + "sha256": "c395480f3bc0908738809f31fa4ec7f03b985fae6287ab008b7a7f454e816edf" + }, + { + "bytes": 12020, + "original_bytes": 12218, + "original_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "path": "run_final_phase.py", + "projection": true, + "sha256": "d857db08d3785aa90f2df5b4e3ce48f263ce702fa4c7b23c576903a223ac652f" + }, + { + "bytes": 1538, + "original_bytes": 1538, + "original_sha256": "8cb8a75b384c0c84f1a000f217616a3d99710b34bf2e04237b65f220ff9302ce", + "path": "run_final_sequence.py", + "projection": false, + "sha256": "8cb8a75b384c0c84f1a000f217616a3d99710b34bf2e04237b65f220ff9302ce" + }, + { + "bytes": 3271, + "original_bytes": 3271, + "original_sha256": "ba020c1e347dbb643416d546d6274282f0d7ccede580d300dd5b99c93acc9c99", + "path": "run_negative.py", + "projection": false, + "sha256": "ba020c1e347dbb643416d546d6274282f0d7ccede580d300dd5b99c93acc9c99" + } + ], + "meaning": "All source/proof bytes exact. Only local path prefixes in execution/review records are replaced with symbolic roots. Embedded original hashes bind native bytes, not changed projected text; this manifest distinguishes both. No scientific promotion.", + "schema": "c294-public-projection-v1" +} diff --git a/frontiers/critical_level_attainment_20261020/PUBLIC_SOURCE_BINDINGS.json b/frontiers/critical_level_attainment_20261020/PUBLIC_SOURCE_BINDINGS.json new file mode 100644 index 000000000..186d27dc1 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/PUBLIC_SOURCE_BINDINGS.json @@ -0,0 +1,65 @@ +{ + "schema": "c294-public-source-bindings-v1", + "sources": [ + { + "module": "Lifetime", + "repository": "d6g8k5htny-coder/Math-", + "commit": "9a16ac956dc7add74a7a0a691545053b4ab3f18d", + "path": "specifications/lean_statements_20261010/Specifications/Lifetime.lean", + "url": "https://github.com/d6g8k5htny-coder/Math-/blob/9a16ac956dc7add74a7a0a691545053b4ab3f18d/specifications/lean_statements_20261010/Specifications/Lifetime.lean", + "bytes": 51383, + "sha256": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "git_blob": "f2508f7f2e3fd42f22f5aa52bc5ead5ff9e73b9a", + "source_method": "Exact native source SHA and Git blob verified; current Main preflight tree binding" + }, + { + "module": "TorusTopology", + "repository": "d6g8k5htny-coder/Math-", + "commit": "9a16ac956dc7add74a7a0a691545053b4ab3f18d", + "path": "companions/torus_filtration_20261011/TorusTopology.lean", + "url": "https://github.com/d6g8k5htny-coder/Math-/blob/9a16ac956dc7add74a7a0a691545053b4ab3f18d/companions/torus_filtration_20261011/TorusTopology.lean", + "bytes": 12257, + "sha256": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1", + "git_blob": "ed678ea322fe5315b3aaff44e4e2f06b018399d8", + "source_method": "Exact native source SHA and Git blob verified; current Main preflight tree binding" + }, + { + "module": "SuperlevelBar", + "repository": "d6g8k5htny-coder/Math-", + "commit": "9a16ac956dc7add74a7a0a691545053b4ab3f18d", + "path": "companions/torus_filtration_20261011/SuperlevelBar.lean", + "url": "https://github.com/d6g8k5htny-coder/Math-/blob/9a16ac956dc7add74a7a0a691545053b4ab3f18d/companions/torus_filtration_20261011/SuperlevelBar.lean", + "bytes": 15309, + "sha256": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "git_blob": "b047384e20306ee030154885536c531633b88bd8", + "source_method": "Exact native source SHA and Git blob verified; current Main preflight tree binding" + }, + { + "module": "MorseFiniteCritical", + "repository": "d6g8k5htny-coder/Math-", + "commit": "0ea97aff489f9420632b4cee81ad82dbec5fe88e", + "path": "frontiers/morse_finite_critical_20261018/final-project/MorseFiniteCritical.lean", + "url": "https://github.com/d6g8k5htny-coder/Math-/blob/0ea97aff489f9420632b4cee81ad82dbec5fe88e/frontiers/morse_finite_critical_20261018/final-project/MorseFiniteCritical.lean", + "bytes": 9445, + "sha256": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "git_blob": "989fabc6e8f04b0c4a36dff9b21d33b1299f7b92", + "source_method": "Exact immutable C293 PR482 head, raw-byte and Git-blob verified; draft unmerged dependency, not asserted on default Main" + }, + { + "module": "ClosedSuperlevel", + "repository": "d6g8k5htny-coder/Math-", + "commit": "9a16ac956dc7add74a7a0a691545053b4ab3f18d", + "path": "companions/torus_filtration_20261011/ClosedSuperlevel.lean", + "url": "https://github.com/d6g8k5htny-coder/Math-/blob/9a16ac956dc7add74a7a0a691545053b4ab3f18d/companions/torus_filtration_20261011/ClosedSuperlevel.lean", + "bytes": 8088, + "sha256": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "git_blob": "a4323cb50fb2d5861c4e6240a18684bfb566fb80", + "source_method": "Exact native source SHA and Git blob verified; current Main preflight tree binding" + } + ], + "lean": "4.34.1", + "mathlib_commit": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "preflight_utc": "2026-10-20T08:17:24Z", + "cut_scope": "Current Main means only this explicit preflight cut; later publication head may differ. Frozen input identities remain explicit.", + "execution_scope": "C294 execution status is recorded separately in final receipts; source custody alone is not a build, kernel replay or theorem acceptance." +} diff --git a/frontiers/critical_level_attainment_20261020/README.md b/frontiers/critical_level_attainment_20261020/README.md new file mode 100644 index 000000000..f5df90ad6 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/README.md @@ -0,0 +1,47 @@ +# C294: conditional path attainment at the actual death height + +For a literal smooth, periodic Morse-distinct field, C294 derives a strictly older critical endpoint and a path whose minimum equals the **actual C263 superlevel-bar death height**, provided the actual closed death superlevel is locally path connected. That local path connectivity is an explicit geometric hypothesis and remains to be derived from the literal Morse data. This is one formal dependency toward the ordinary-persistence bridge, not completion of that bridge. + +Let delta be superlevelBar_deathHeight g M on the actual period-lattice quotient. The two public theorems in [CriticalLevelAttainment.lean](final-project/CriticalLevelAttainment.lean) are: + +- TorusCriticalAttainment.quotient_death_attainment: a quotient critical point Q with F(Q)>g(M), a path from the actual projection of M to Q, F>=delta along the path, and equality F=delta at some parameter. +- TorusCriticalAttainment.euclidean_death_attainment: a prescribed-start lift from M to an actual literal critical point y, with g(y)>g(M) and the same attained minimum delta. + +Neither the endpoint nor a path, finite event list, saddle pairing or attained death is an input. C293's actual finite projected critical set supplies a single older endpoint across all strict subdeath levels. Compact connected intersection plus the explicit closed-level LPC hypothesis supplies the path. C263's strict-clearance exclusion forces equality at death. The Euclidean endpoint is chosen by lifting this one final path, rather than silently fixing representatives across earlier lifts. + +## Exact statement and scope + +Inputs retain positive L, all natural dimensions d, literal IsSmooth, IsLPeriodic, IsMorseDistinct and nonessential superlevelBar_isEssential. The extra premise is: + +```lean +LocallyPathConnectedSpace + {q : torus_quotient d L hL // + superlevelBar_deathHeight g M ≤ descendedHeight d L hL g hperiodic q} +``` + +The full Morse predicate is retained; the finite-critical-set dependency uses its nondegeneracy part. A nondegenerate starting maximum is not assumed or proved by this conditional unit, and strict death drop is not a conclusion. Ambient torus LPC alone does not discharge the closed-subtype premise. + +[Scope and unresolved bridge](SCOPE.md), [author argument](AUTHOR_NOTES.md), [root mathematical check](evidence/ROOT_MATHEMATICAL_CHECK.md) and [exact nonauthor review](reviews/NONAUTHOR_REVIEW.md) explain the proof, inference controls and exposure. The actual Morse-to-closed-LPC theorem, strict death drop, full trap/frontier/ceiling adapter, elder pairing, once-counted exhaustive bars, field-first sampling, all-small-bars converse and regional shrinking multiple-witness collision estimate remain open. No stochastic normalizer or limit order is changed. + +## Actual local formal evidence + +The frozen inventory is SHA256 **a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d**. The main proof is14338bytes, SHA256 **ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12**, Git blob1579751ec03c14f3dfd90df98db7a37d8ca74e09. + +- Seven fresh serial builds into an initially empty isolated output directory passed: Lifetime, TorusTopology, SuperlevelBar, ClosedSuperlevel, MorseFiniteCritical, CriticalLevelAttainment, CriticalLevelAxiomAudit. Both new modules used warnings-as-errors. +- Two standard named-module leanchecker replays passed: CriticalLevelAttainment and CriticalLevelAxiomAudit. These use imported dependencies; they are not --fresh or external independent replays. +- The complete module-origin axiom census contains235 unique declarations, including generated/private declarations:103/38/25/32/20/17 across those six source/proof modules. Every transitive axiom is among propext, Classical.choice, Quot.sound. The13 explicit new declarations are not confused with the17 module-origin declarations. +- The actual omitted-LPC fixture was rejected with a type mismatch showing the missing LocallyPathConnectedSpace input, rc1 without timeout. Sources and imported objects were unchanged. This checks the implemented conditional interface; it is not a counterexample to the open Morse-to-LPC theorem. + +Full final commands, streams and receipts are in final-runs/, negative-final/, FINAL_SEQUENCE_RESULT.json and the frozen audit source. [Replay guide](REPLAY.md) describes the pinned Lean4.34.1/Mathlib environment and actual limits. Dependency checks reuse83897 previously hashed artifacts through exact pathset and unchanged metadata; they do not claim a full fresh cache rehash. [Execution history](evidence/EXECUTION_HISTORY.md) retains the distinction between failed development attempts, source-bound object reuse during development and these fresh final builds. The private archive preserves complete native development attempts and original receipts. + +## Sources, ownership and delivery + +[Public source bindings](PUBLIC_SOURCE_BINDINGS.json) identify all five immutable formal inputs. C293's MorseFiniteCritical source is pinned to unmerged PR482 head0ea97aff489f9420632b4cee81ad82dbec5fe88e. No claim is made that it is on default Main. Existing companion, C258 component-kernel, production registration and C293 hosted-engineering owners retain their scopes. This package only adds frontiers/critical_level_attainment_20261020/. + +This source package records local formal execution. **LOCAL_ONLY_NOT_REGISTERED_IN_HOSTED_FORMAL** applies to the new modules. Existing hosted jobs may verify their registered targets; actual exact-head hosted results, raw GitHub-byte readback, one private archive's raw readback, final artifact master and R17 registration are reported in the later terminal delivery record. Publication of this source package alone does not establish those later steps. The immutable private archive is accompanied by external final custody/master records to avoid a circular self-receipt. + +Public text records replace local filesystem prefixes with symbolic roots. PUBLIC_PROJECTION.json separately records native and projected hashes; Lean source bytes are unchanged. Embedded native receipt hashes continue to refer to the original native bytes, not to the projected text. + +Proof author: OpenAI Codex /root/adapter_feasibility_c292. Separate nonauthor reviewer: OpenAI Codex /root/c292_geometry_review, with prior C292/C293 and design/source exposure disclosed. Root01a0bbb5 coordinated, authored controls and performed execution/custody; /root/current_pr_triage_c292 audited ownership/source routes and adapted packaging. All are AI work delegated for Dylan Roy. Organizational independence0, human review0, scientific effect NONE. No personal human review by Dylan is claimed. + +[Owner mandate](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OWNER_MANDATE_20261015.md) · [Standing delegation](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OP-AUTONOMY-20260923-v2.1.md). diff --git a/frontiers/critical_level_attainment_20261020/REPLAY.md b/frontiers/critical_level_attainment_20261020/REPLAY.md new file mode 100644 index 000000000..dee053c92 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/REPLAY.md @@ -0,0 +1,114 @@ +# Replaying C294 conditional death-level attainment + +This command/interface guide accompanies the actual local final verification: seven isolated builds, two standard named-module kernel replays, the complete235-declaration axiom census and the omitted-LPC rejection passed. FINAL_SEQUENCE_RESULT.json and negative-final/RECEIPT.json provide the actual execution records. Frozen inventory SHA256 a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d binds the inputs. Mathematical review and later publication/custody results are separate records. + +The explicit actual closed-superlevel LPC admission remains open. No supplied path, finite event list, full elder/barcode theorem, stochastic Morse admission, scientific acceptance or hosted C294 registration is inferred. + +## Pinned inputs and runtime + +Five immutable sources in SOURCE_INPUTS.json: Lifetime, TorusTopology, SuperlevelBar, ClosedSuperlevel, MorseFiniteCritical. Two new modules: CriticalLevelAttainment, CriticalLevelAxiomAudit. SOURCE_INPUTS records safe relative project_path/input_path, size, SHA-256 and Git blob for each input; actual freeze/receipts bind all seven sources. + +- Lean **4.34.1**, retained Darwin aarch64 runtime. +- Mathlib **d13f23b723b8a846827a245b89c10fc7d3f11612**. +- Pinned project lake-manifest.json SHA-256 **d63753befccc21923783a5085148e3ff028d97134ea52f5a08bd87ecf1b0b043**; toolchain SHA-256 **d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b**. +- lean executable SHA-256 **1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554**. +- leanchecker executable SHA-256 **cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35**. +- C291 dependency inventory baseline SHA-256 **b78b6e0f99bd38c633ae2677c55698363b1290e6d4318e505991c8df259ae2e3**. + +The runtime/cache locations are explicit in run_final_phase.py. Its runtime() checks the exact executable and manifest bytes and every manifest package's pinned HEAD; only actual existing compiled package roots enter the import path. It deliberately permits pinned packages such as Cli that have no compiled Lean root, matching C291's baseline. This is not a fresh package rebuild or provenance authentication of the entire cached import closure. + +LEAN_PATH begins with this package's isolated **final-build**, followed by existing pinned dependency build/lib/lean paths. The retained Lean installation supplies its runtime core. Environment strips inherited LEAN/LAKE/LD_/DYLD_ variables, pins PATH to the explicit runtime bin plus system paths, sets LEAN_NUM_THREADS=2 and uses a per-phase temporary directory. No shared-cache object is an output destination. + +## Final preparation and serial phase commands + +The following are the command shapes root executed from the native C294 directory after source freeze under the fresh claim. Replay only in a separate fresh destination; the delivered directories and once-only receipts must be preserved. Do not run the driver and then repeat individual phases. + +```sh +python3 -B prepare_final_inputs.py --freeze +python3 -B run_final_sequence.py +python3 -B run_negative.py +``` + +Preparation requires absent final-project/final-build/final inventory, writes a unique append-only record under final-prepare-attempts/, checks all seven exact sources, derives the local import DAG, copies source bytes into fresh final-project and creates empty isolated final-build. FINAL_SOURCE_INVENTORY binds the preparer, phase runner, unique start record, source hashes/order/imports, dependency inventory and C291 baseline. evidence/FINAL_BUILD_INITIALIZATION records empty outputs and dependency reuse. A legacy FINAL_PREPARE_START is not required or overwritten. + +The expected frozen order and the driver's concrete phase CLI are: + +```sh +python3 -B run_final_phase.py build Lifetime +python3 -B run_final_phase.py build TorusTopology +python3 -B run_final_phase.py build SuperlevelBar +python3 -B run_final_phase.py build ClosedSuperlevel +python3 -B run_final_phase.py build MorseFiniteCritical +python3 -B run_final_phase.py build CriticalLevelAttainment +python3 -B run_final_phase.py build CriticalLevelAxiomAudit +python3 -B run_final_phase.py kernel CriticalLevelAttainment +python3 -B run_final_phase.py kernel CriticalLevelAxiomAudit +``` + +The serial driver reads inventory.build_order, appends only the two NEW kernel phases and stops at the first unresolved failure. All compiler runners share lean-slot.lock with development run_lean.py; do not bypass it with parallel manual commands. + +Underlying build command shapes, with placeholders denoting the runner's pinned/isolated absolute locations: + +```text +/lean -j2 -M4096 -o /Lifetime.olean /Lifetime.lean +/lean -j2 -M4096 -o /TorusTopology.olean /TorusTopology.lean +/lean -j2 -M4096 -o /SuperlevelBar.olean /SuperlevelBar.lean +/lean -j2 -M4096 -o /ClosedSuperlevel.olean /ClosedSuperlevel.lean +/lean -j2 -M4096 -o /MorseFiniteCritical.olean /MorseFiniteCritical.lean +/lean -j2 -M4096 -DwarningAsError=true -o /CriticalLevelAttainment.olean /CriticalLevelAttainment.lean +/lean -j2 -M4096 -DwarningAsError=true -o /CriticalLevelAxiomAudit.olean /CriticalLevelAxiomAudit.lean +/leanchecker -v CriticalLevelAttainment +/leanchecker -v CriticalLevelAxiomAudit +``` + +These are **standard named-module kernel replays against imported dependencies**, not --fresh, independent/external verification, a fresh all-import closure replay or hosted execution. Each fresh phase directory retains START/PREFLIGHT/PROCESS_START/RECEIPT and complete stdout/stderr. Receipt binds executable, runner, frozen source inventory, actual command, source/object/dependency before-and-after identities, exit/timeout and process-reaping observations. + +Configured caps are **600s per ordinary build/kernel phase**, **900s for the audit build**, **600s for N1**. These are bounded settings, not observed passes. Root set the600s cap before freeze after an immutable-input development load reached240s; the900s audit allowance follows retained earlier audit experience. Thread/memory settings remain2/-M4096. Actual elapsed time, return codes and failures must come from receipts. + +## Complete measured audit + +CriticalLevelAxiomAudit enumerates module-origin declarations with exporting disabled, including generated/private helpers, for exactly these six source/proof modules: +Lifetime, TorusTopology, SuperlevelBar, ClosedSuperlevel, MorseFiniteCritical, CriticalLevelAttainment. + +Markers: +```text +ATTAINMENT_AUDIT_MODULE COUNT +ATTAINMENT_AUDIT_DECL AXIOMS [] +ATTAINMENT_AUDIT_STANDARD_ONLY_PASS COUNT +``` + +ATTAINMENT_AUDIT_PROGRESS on stderr is progress only. Actual module record totals must equal their emitted declaration counts; names must be globally unique; total must equal all parsed records. Every transitive axiom list must be a subset of propext, Classical.choice, Quot.sound. Both public targets must occur in the explicit required-name array and census: +TorusCriticalAttainment.quotient_death_attainment and TorusCriticalAttainment.euclidean_death_attainment. + +**Measured result:235 unique declarations, all standard-only.** Module counts are103/38/25/32/20/17 in the listed order. Actual stdout SHA256062a8168ad5b05f1238ea8fd516d7fc5a806941cf77480b6de6837921c294386. Root bound final_master.py to this measured count and actual frozen inventory; no C293 count or verdict was transferred. + +## N1: omit the actual closed-LPC premise + +Actual fixture: negative-project/WithoutClosedLPC.lean. Its purpose is to invoke the actual final attainment theorem while omitting its explicit closed-level LPC input, not to supply the path as an assumption. + +```text +/lean -j2 -M4096 /negative-project/WithoutClosedLPC.lean +``` + +run_negative.py uses the same slot/runtime/imported objects and captures full stdout/stderr. A successful negative-control **result** requires a nonzero compiler exit without timeout, actual type mismatch containing **LocallyPathConnectedSpace**, no unknown-module/identifier/syntax/object-file failure, and unchanged frozen sources/imported sources/objects. Mere command failure is not success. The receipt also binds the fixture, negative runner, Lean executable and inventory. Root binds ROOT_ACCEPTANCE.closed_lpc_diagnostic_token to the actual observed symbol. **N1 observed result:** expected type-mismatch rejection, rc1,74.2482s, no timeout, actual LocallyPathConnectedSpace input displayed; source and imported objects unchanged. Diagnostic stdout SHA256103fca1879ac4965b80766263cab5f18f64dbe46ddbb9de70aef49976fbdafd8. + +## Metadata reuse, failures and final artifact steps + +Dependencies use the hash-verified C291 baseline and exact pathset. At identical size/mtime_ns/inode, prior byte digests are explicitly reused. Changed metadata triggers byte hashing and requires the same digest; a changed pathset/hash fails closed. Receipts report reused counts and rehashed deltas. This does not claim a full fresh dependency rehash, source rebuild or absence of all possible undetectable metadata-preserving mutation. No shared-cache bytes are copied or written. + +Retain all development failures/streams/receipts, source-attempt snapshots and interrupted preparation records. Do not clear final outputs or restart the once-only driver after failure. Any actual correction needs a documented successor receipt and only the affected/unfinished work; old results are not rewritten. + +After exact-source mathematical review and acceptance, root may finalize documentation and run, in their appropriate later stages: +```sh +python3 -B prepare_publication.py +python3 -B build_packet.py +python3 -B final_master.py +``` +These are **not three immediate commands**: publication raw/Git-object readback and applicable hosted-job evidence must precede private packet construction; private upload/native raw download equality must precede the once-only artifact master. See evidence/MASTER_CONTRACT.md and PACKAGING_ADAPTATION.md for exact interfaces. + +Private output is C294_CRITICAL_LEVEL_ATTAINMENT_DELIVERY.zip using canonical C288 builder SHA-25688d6e30182ae682d27f4d156f6c935f8373168ca6ff14d3141cd69c4b036d3a3. Public prefix is frontiers/critical_level_attainment_20261020/. Public text projection records native/projected hashes separately and forbids changes to Lean bytes. Private packet preserves complete development/native evidence, objects and compressed native dependency inventory. + +Exact mathematical review is recorded separately in reviews/NONAUTHOR_REVIEW.md. Publication, hosted, private custody and final master are later stages, reported by the terminal delivery rather than claimed by this command guide. Existing registered hosted checks do not execute C294's new modules; new_formal_execution stays LOCAL_ONLY_NOT_REGISTERED_IN_HOSTED_FORMAL unless a separately owned registration and actual execution establish otherwise. Artifact binding is not mathematical/scientific acceptance. + +[Owner mandate](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OWNER_MANDATE_20261015.md) and [standing delegation](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OP-AUTONOMY-20260923-v2.1.md) accompany this handoff. + diff --git a/frontiers/critical_level_attainment_20261020/ROOT_ACCEPTANCE.json b/frontiers/critical_level_attainment_20261020/ROOT_ACCEPTANCE.json new file mode 100644 index 000000000..7690bf595 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/ROOT_ACCEPTANCE.json @@ -0,0 +1,22 @@ +{ + "verdict": "ACCEPT_SCOPED_FORMAL", + "accepted_utc": "2026-10-20T09:02:35.734802+00:00", + "source_sha256": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "source_inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "review_path": "reviews/NONAUTHOR_REVIEW.md", + "review_sha256": "c20a21fa16a4a865b613f50b447c55a2283fffeefc5c08e7dca01d727124a35f", + "author": "OpenAI Codex /root/adapter_feasibility_c292", + "reviewer": "OpenAI Codex /root/c292_geometry_review", + "root": "OpenAI Codex /root; original chat01a0bbb5-2fcb-77f0-b78b-4d220ddd7ab2", + "exposure": "Reviewer previously reviewed C292/C293, advised finite-endpoint compact-intersection proof shape, read candidates/final sources and exact receipts; did not author proof or run Lean. Root authored controls and performed final execution/custody. Same-provider delegated AI work for Dylan Roy; no Dylan personal human review.", + "organizational_independence_credit": 0, + "human_review_credit": 0, + "scientific_effect": "NONE", + "closed_lpc_diagnostic_token": "LocallyPathConnectedSpace", + "local_build_count": 7, + "standard_named_module_kernel_count": 2, + "actual_module_origin_census": 235, + "negative_control": "PASS expected omitted-LPC type mismatch, rc1/noTimeout/exactfrozenobjects", + "scope": "Conditional actual C263 closed-death path and literal older critical endpoint; actual closed-subtype LPC remains an explicit premise. No full ordinary-persistence/stochastic/count/regional-collision closure.", + "later_gates": "Publication/native bytes/hosted existing targets/private custody/final artifact master/R17 delivery remain separate; this acceptance is not their completion." +} diff --git a/frontiers/critical_level_attainment_20261020/SCOPE.md b/frontiers/critical_level_attainment_20261020/SCOPE.md new file mode 100644 index 000000000..b6ad2883f --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/SCOPE.md @@ -0,0 +1,31 @@ +# C294 scope and unresolved bridge + +The target is one conditional deterministic formalization of C292 sections6–7 on the actual C263 period-lattice quotient. It retains the literal Lifetime predicates IsSmooth, IsLPeriodic and IsMorseDistinct, a positive period L, and a nonessential literal C263 superlevel bar starting at the prescribed point M. The extra geometric hypothesis is LocallyPathConnectedSpace of the actual subtype whose descended height is at least the literal C263 death height. + +The target conclusion derives a single strictly older quotient critical endpoint, a path from the actual projection of M staying at or above that death height, and equality with the death height at some point of that path. Its Euclidean lift starts at the prescribed M, derives the actual endpoint's literal fderiv-zero criticality, preserves strict olderness and the same height inequalities/equality. Uniformity before lifting concerns the quotient endpoint, not a silently fixed Euclidean representative across separate lifts. + +No fixed older endpoint, finite event list, inverse certificate, desired path, attained death or paired saddle is a premise. The finite critical set comes from the exact unchanged C293 theorem. The death value is the original C263 supremum, not a newly selected critical level. Existing closed components, torus projection/descent/lifting and clearance facts retain their source meanings. + +The statement holds for all natural dimensions when its premises hold; it does not require or establish that M is a nondegenerate maximum, and it does not prove strict death drop. A dimension-zero nonessential instance is vacuous. Full IsMorseDistinct is retained, although the finite-set dependency uses nondegeneracy rather than distinct critical heights. There is no random-field sampling, asymptotic parameter, normalization or limit exchange in this deterministic unit. + +## What remains open + +- Deriving local path connectivity of the actual closed superlevel from literal smooth periodic Morse hypotheses. Ambient torus local path connectivity does not pass automatically to closed subspaces. +- Formal strict death drop and the full C292 trap/frontier/ceiling adapter into the already existing ordinary-H0 direct-summand theorem. +- Identification or uniqueness of an elder-paired saddle, relation to branch adjacency, exhaustive once-counted finite bars and an all-small-bars converse. +- Almost-sure Morse admission, field-first sampling, measurability, local weighted critical-pair/contact-integral to actual bar-law transfer, and regional shrinking multiple-witness collisions. Global factorial bounds do not close the regional node. +- Production formal registration, provider/organization-independent alignment, and scientific acceptance. Local compilation, kernel replay, artifact checks and hosted engineering checks each retain their actual separate scope. + +## Negative and interface boundaries + +WithoutClosedLPC.lean deliberately omits the last explicit local-path-connectivity argument when invoking the actual final Euclidean theorem. A successful build of that negative would be a failure of this guard. The required failure is a type mismatch exposing the missing premise; a timeout, import, syntax or unknown-identifier error does not qualify. This tests the implemented interface and is not a counterexample to the separately open Morse-to-LPC theorem. + +The compactness argument must keep strict olderness through a finite critical endpoint set. An arbitrary convergent sequence of values greater than the starting height can converge to that height; passing to an unconstrained endpoint limit is insufficient. Connected compact limiting sets also need not be path connected: the topologist's sine continuum illustrates the invalid general inference. These are targeted logical negative controls, not counterexamples satisfying every literal Morse premise of the proposed unconditional adapter. + +## Attribution and ownership + +Proof implementation: OpenAI Codex /root/adapter_feasibility_c292. Root01a0bbb5 coordinates, writes the execution/audit controls and checks source/custody. Exact-source nonauthor review is attributed in reviews/NONAUTHOR_REVIEW.md when complete, including prior C292/C293 and design exposure. All work is delegated work for Dylan Roy; no human review by Dylan is claimed. Same-provider review has organizational-independence credit0 and human-review credit0. Scientific effect NONE. + +The C258 component-kernel owner, Claude companion/source owner, production gate/registration owner and C293 hosted-engineering PR485 owner keep their separate scopes. This additive package consumes exact frozen inputs; it does not modify their original paths or acquire their claims. C292/C293 completed deliveries are dependencies, not reopened leaves. + +[Owner mandate](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OWNER_MANDATE_20261015.md) and [standing delegation](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OP-AUTONOMY-20260923-v2.1.md) govern routine authorized work alongside the live workflow. Specific no-merge/access/source-deletion boundaries of this run remain in force. diff --git a/frontiers/critical_level_attainment_20261020/evidence/EXECUTION_HISTORY.md b/frontiers/critical_level_attainment_20261020/evidence/EXECUTION_HISTORY.md new file mode 100644 index 000000000..6a1d231b0 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/evidence/EXECUTION_HISTORY.md @@ -0,0 +1,35 @@ +# C294 execution history and retained negative evidence + +Actual proof implementation/development executor: OpenAI Codex /root/adapter_feasibility_c292. Root01a0bbb5 authored final controls, invoked final phases and owns final evidence/custody. All work is delegated for Dylan Roy; no personal human review by Dylan is claimed. + +## Development attempts + +| Run | Source SHA256 | Exit | Timeout | Seconds | Receipt SHA256 | +|---|---|---:|---|---:|---| +| 20261020T082209Z-Lifetime-be126ae1 | 90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6 | -15 | True | 240.0295 | 07448c4e67f191c44d8ff52a62b59c8224712341f2fc46e30ae20f5d478b8489 | +| 20261020T082609Z-ClosedSuperlevel-cefbd055 | 90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2 | -15 | True | 240.0559 | d2a2841596a4279fdd1af33b3090e8db2f63cec12b50a1d01bbfdb53c113b6a2 | +| 20261020T083009Z-SuperlevelBar-e3876495 | 346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9 | 0 | False | 204.6059 | b638b8703284cef71f270f125d827f5ed1b223f8e10e0d98b12d23bffab8f16f | +| 20261020T083334Z-CriticalLevelAttainment-378d0cb0 | 3dc8ab1b19f52b89baef806265d5a3eb7b81bd2f245e4257ebecdac075b4ed6a | 1 | False | 92.7446 | 8e2b8766f4f39d193eca8fd61a485e301421579b7505add7a0bb6d7c2179197c | +| 20261020T083651Z-CriticalLevelAttainment-f7c5472f | 38f5a01c7758a6ed46e9f2f983497fe79c600aab1a77802f849ef1037afd4c9f | 1 | False | 75.0378 | db712d50c1d9f434bff3ca85c132ebcbe8918986f4f3f4724ccdf4afc3006161 | +| 20261020T083827Z-CriticalLevelAttainment-02ea9eb3 | e07de40b119266d750dab90878df04f55cab26c09bf251d065400d0871af6503 | 1 | False | 67.3441 | ad3beaa4ea9c31b5d4c6bebc54962b63529718bd07135927f13a53222bcab511 | +| 20261020T084025Z-CriticalLevelAttainment-deeba258 | ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12 | 0 | False | 73.7225 | e64482068df7b48ac984c156054188b09b4ef865b504e6d1faa39334875aab1c | + +All seven development receipts, complete stdout/stderr and exact source-attempt snapshots are retained in the private native packet. The two240s unchanged-input timeouts are runtime/import failures, not disproved mathematical statements. The three main-source nonzero exits are genuine elaboration failures, repaired through source changes; they are not successful builds. The fourth main-source attempt is the actual clean development pass. No failed attempt was deleted or overwritten. + +The retained sample of the SuperlevelBar process at08:32:59 located active stacks in importModules/finalizeImport/lean_runtime_mark_persistent/lean_mark_persistent, with the frontend waiting on the header task. This is sampled runtime evidence of import overhead, not a proof of the cause of every timeout. The later fresh SuperlevelBar build passed in204.6059s. + +Four exact input objects were reused for development only: Lifetime, TorusTopology and MorseFiniteCritical from C293; ClosedSuperlevel from its older source-bound build. DEVELOPMENT_OBJECT_REUSE.json and CLOSED_SUPERLEVEL_OBJECT_REUSE.json in evidence/ bind source and object hashes to actual prior receipts. This reuse is not represented as a new C294 build. + +## Stable-input verification + +Root then froze seven source files under FINAL_SOURCE_INVENTORY.json SHA256 a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d and created an empty isolated final-build directory. run_final_sequence.py runs seven builds and two standard named-module kernel replays serially and stops on an unresolved failure. Actual outcomes, command/executable identities and unchanged-source/object checks are in FINAL_SEQUENCE_RESULT.json and all final-runs receipts. This history does not substitute author development success for those final results. + +Final ordinary phase allowance600s and audit900s were fixed before freeze, informed by the retained import timeout and prior C291/C293 audit durations; no memory/thread expansion was made. Dependency checks explicitly reuse83897 baseline byte hashes when exact paths, size, mtime_ns and inode match, rehashing metadata deltas. This is not a fresh all-dependency byte census or cache rebuild. + +N1 uses only final objects and omits the actual closed-subtype LPC input. Its actual receipt and diagnostic are in negative-final/. An expected type mismatch is an interface guard, not a counterexample to the separate Morse-to-LPC theorem. Standard named-module kernel replay is against imported dependencies, not --fresh or independent external replay. + +## Delivery boundaries + +Final artifact master runs once after source/review/publication/hosted/private-custody inputs stabilize. Its result is recorded separately after archive creation and cannot be embedded circularly in that same immutable archive. Any final stable-input failure remains evidence and requires a scoped correction; no silent reset/retry is authorized by this document. + +Full current Lean source, final build/kernel streams, full axiom output, omitted-premise diagnostic, source/review identities and replay controls are published with explicit local-path projection. Original native bytes and development failures remain in one private archive; the projection manifest distinguishes changed text hashes from native receipt hashes. Existing hosted CI covers its actual registered targets; C294 new formal execution remains local until separately registered and observed. Scientific effect NONE. diff --git a/frontiers/critical_level_attainment_20261020/evidence/FINAL_BUILD_INITIALIZATION.json b/frontiers/critical_level_attainment_20261020/evidence/FINAL_BUILD_INITIALIZATION.json new file mode 100644 index 000000000..879b478f1 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/evidence/FINAL_BUILD_INITIALIZATION.json @@ -0,0 +1,12 @@ +{ + "utc": "2026-10-20T08:43:07.506410+00:00", + "initial_objects": [], + "build_was_created_empty": true, + "dependency_reuse": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "prepare_start_record": "$C294_ROOT/final-prepare-attempts/2026-10-20T084258.355017_0000-4f2675bdddb74318b5624e5d370117c4.json", + "prepare_start_sha256": "ba4d3513666bd0bf33ae2206a03d70fa2f0372fc28809c0cbdd580bb1601bfed" +} diff --git a/frontiers/critical_level_attainment_20261020/evidence/MASTER_CONTRACT.md b/frontiers/critical_level_attainment_20261020/evidence/MASTER_CONTRACT.md new file mode 100644 index 000000000..9ba9e4758 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/evidence/MASTER_CONTRACT.md @@ -0,0 +1,15 @@ +# C294 final verification contract + +This unit is conditional critical-death-level attainment, not the complete C292 adapter. Its final applicable verification consists of seven isolated Lean builds from exact source bytes (Lifetime, TorusTopology, SuperlevelBar, ClosedSuperlevel, MorseFiniteCritical, CriticalLevelAttainment, CriticalLevelAxiomAudit), standard named-module kernel replay of the two new modules, and one intentionally ill-typed invocation of the actual final attainment theorem with the explicit closed-superlevel local-path-connectivity premise omitted. The negative must fail for that premise, not an import, syntax, timeout or process error. If the actual source DAG changes, revise this contract before freezing. + +The complete axiom census covers every declaration by module origin in all six source/proof modules, including generated/private helpers. Only propext, Classical.choice and Quot.sound are allowed. The audit module has no mathematical theorem claim; its command execution must complete and name both public target declarations. The total count is measured from final execution, not guessed. + +Root will perform substantive mathematical/source review and obtain an exact-source nonauthor review with actual exposure and attribution. No author self-check or model agreement substitutes for that review. The inference of closed-level local path connectivity from literal Morse hypotheses remains open and cannot be removed by documentation. + +After sources are stable, execute the final build/kernel sequence once. Development failures are retained. Rerun only inputs affected by an actual change or an unresolved failed phase, with a distinct receipt and honest reason. Imported runtime/dependency bytes use the hash-verified C291 baseline and explicit unchanged-metadata reuse; metadata changes trigger byte rehash, not an automatic cache recrawl or a claim of fresh dependency rebuilding. + +After full public evidence, applicable hosted-check readbacks and one private archive with exact raw-byte download are available, run the artifact master once on the final stable inputs. It verifies exact source/object/receipt/review bindings, audit completeness, negative diagnostics, public raw and Git-object identities, actual hosted scope, canonical archive manifest and native/remote archive equality. The artifact master does not invoke Lean or confer mathematical/scientific acceptance. A failure is retained and stops delivery until corrected under a documented successor verification. + +Hosted checks must be described by their actual registered target scope. No C294 hosted formal execution, external fresh kernel replay, production registration, complete finite ordinary-bar theorem, stochastic sampling, bar counting, all-small-bars converse or regional collision closure is inferred. No merge, Release, access/sharing change or source deletion is part of this unit. + +Before final freeze, the ordinary phase/N1 timeout was set to600seconds after C294 immutable Lifetime development attempt20261020T082209Z-Lifetime-be126ae1 hit240.03seconds, rc-15, empty stdout/stderr and unchanged source. The failed attempt is retained. Audit build retains the previously justified900seconds. All phases stay serial, two threads, Lean memory limit4096; this is bounded local execution, not a resource benchmark. diff --git a/frontiers/critical_level_attainment_20261020/evidence/MEASURED_AXIOM_CENSUS.json b/frontiers/critical_level_attainment_20261020/evidence/MEASURED_AXIOM_CENSUS.json new file mode 100644 index 000000000..07698c7fe --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/evidence/MEASURED_AXIOM_CENSUS.json @@ -0,0 +1,36 @@ +{ + "utc": "2026-10-20T08:55:01.926987+00:00", + "method": "Validate actual final audit output using final_master.validate_audit only; final master main not invoked", + "stdout_path": "final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stdout.txt", + "stdout_sha256": "062a8168ad5b05f1238ea8fd516d7fc5a806941cf77480b6de6837921c294386", + "census": { + "Lifetime": [ + 103, + 103 + ], + "TorusTopology": [ + 38, + 38 + ], + "SuperlevelBar": [ + 25, + 25 + ], + "ClosedSuperlevel": [ + 32, + 32 + ], + "MorseFiniteCritical": [ + 20, + 20 + ], + "CriticalLevelAttainment": [ + 17, + 17 + ] + }, + "unique_declarations": 235, + "all_standard_only": true, + "final_master_sha256": "14c82931a8528019e0fd5b745937ef1f776d5689965ba9de8735c2dbd12bbbf8", + "scientific_effect": "NONE" +} diff --git a/frontiers/critical_level_attainment_20261020/evidence/PREPUBLICATION_DELTA_20261020T085749Z.md b/frontiers/critical_level_attainment_20261020/evidence/PREPUBLICATION_DELTA_20261020T085749Z.md new file mode 100644 index 000000000..ed16bd14a --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/evidence/PREPUBLICATION_DELTA_20261020T085749Z.md @@ -0,0 +1,14 @@ +# C294 prepublication delta — 20261020T085749Z + +Bounded remote observation **08:56:46–08:57:49 UTC,20October2026**, under parent C294 claim2afaffe8-cf58-4bc7-9824-7585f9feb788/WE2392. Root owns publication. No CI/Lean, freeze, remote mutation, foreign-writer work or Drive crawl. + +**Current exact base:** `8c226134ac0a0169dbb43311082e5353ed5c922c`. **Actual Git tree:** `380a91eb1db34ae297d0e15806705ab29844582d`. The Main commit and complete untruncated3147-entry tree were freshly read because Main advanced since08:17. Its only changed leaf is tests/test_retrofit_record_check.py, blob b02c230ec2ad312436d2697e7288171469e9d8d0, from merged test-only486. [Native commit](https://github.com/d6g8k5htny-coder/Math-/commit/8c226134ac0a0169dbb43311082e5353ed5c922c); [486 integration release pointer6287211981](https://github.com/d6g8k5htny-coder/main/issues/419#issuecomment-6287211981). + +Current open collection is **29PRs**, complete short100-item page, with identical initial/final number/head/base sets. **29 exact-head+base inventories reused,0refreshed**;486 alone closed.686 changed-file occurrences/674 unique paths. No default-tree or open-PR current/previous-filename match for **frontiers/critical_level_attainment_20261020/**. + +All five consumed blob/size identities match: Lifetime f2508f7f2e3fd42f22f5aa52bc5ead5ff9e73b9a; TorusTopology ed678ea322fe5315b3aaff44e4e2f06b018399d8; SuperlevelBar b047384e20306ee030154885536c531633b88bd8; ClosedSuperlevel a4323cb50fb2d5861c4e6240a18684bfb566fb80; MorseFiniteCritical989fabc6e8f04b0c4a36dff9b21d33b1299f7b92. First four are canonical current-Main inputs, with no open path contender. **MorseFiniteCritical is explicitly from still-open/draft/unmerged PR482 at unchanged0ea97aff489f9420632b4cee81ad82dbec5fe88e**. Its own expected added path is a consumed immutable dependency, not an input edit or C294 contender. No new raw-source/compiler run is claimed. + +Math419 since08:19 returned only own [pickup6286648588](https://github.com/d6g8k5htny-coder/Math-/pull/419#issuecomment-6286648588) and [checkpoint6287055243](https://github.com/d6g8k5htny-coder/Math-/pull/419#issuecomment-6287055243). Main419 current body names no later successor;11comments since08:40 contain own checkpoint and unrelated461/query47/486 coordination. Final inclusive tails returned only the already-read boundary comments. **No equivalent geometry claim or stop found in these bounded deltas.** C258, companion, production-registration and PR485 boundaries remain. Already-routed485 AMEND and Main460 R03 proposal are not duplicated. + +No scoped path/source/coordination blocker found. This is **not** theorem acceptance, a global claim absence certificate or publication. Parent retains R17/lease control and final N1/review/custody decisions. Use the new8c226134 base/tree; if refs or elapsed delay make it stale before creation, reconcile that delta. Full native tree,29 inventories, source objects and actual board records are retained in the matching JSON. Earlier08:17 evidence is preserved. + diff --git a/frontiers/critical_level_attainment_20261020/evidence/ROOT_MATHEMATICAL_CHECK.md b/frontiers/critical_level_attainment_20261020/evidence/ROOT_MATHEMATICAL_CHECK.md new file mode 100644 index 000000000..b58eb5282 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/evidence/ROOT_MATHEMATICAL_CHECK.md @@ -0,0 +1,33 @@ +# Root source-level mathematical check — C294 + +Executor: OpenAI Codex /root, original session01a0bbb5-2fcb-77f0-b78b-4d220ddd7ab2, delegated work for Dylan Roy. Root coordinates and authored execution/audit controls; this is not the separate nonauthor review and has no organizational or human independence credit. + +Read source: CriticalLevelAttainment.lean,14338bytes, SHA256 ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12, Git blob1579751ec03c14f3dfd90df98db7a37d8ca74e09. Frozen seven-source inventory SHA256 a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d. This note checks the argument and interfaces; final execution/review/custody outcomes are separate records. + +## Statement and source fidelity + +For the actual period-lattice quotient X, F is torus_descend of the original field g, with the literal IsLPeriodic lattice formula transported definitionally. The start is the actual projection m of prescribed M. The height delta is the literal C263 superlevelBar_deathHeight g M; nonessentiality is the original predicate. The public result keeps smoothness, periodicity, Morse-distinctness and positive period. The extra hypothesis is exactly local path connectivity of the subtype {q : X // delta <= F q}. No new chosen death, endpoint, event list, path, saddle or trap is supplied. + +C293 supplies finiteness of the full image of all literal fderiv-zero critical points. It is an explicit immutable unmerged PR482 dependency, not a claim that current default Main contains that module. The five original inputs are copied without edits. + +## Argument checked + +1. For every a=a}. +2. K_a is closed in the compact actual quotient, hence compact. Its continuous-height maximum Q_a has F(Q_a)>g(M)>=delta>a. The component is a neighborhood of Q_a because the ambient quotient is locally connected and Q_a lies strictly inside the height threshold. Thus Q_a is a quotient local maximum. Pullback through the actual projection yields literal fderiv-zero criticality. The main theorem retains smooth g; the helper's use of the fderiv convention is not a substitute for smoothness. +3. The finite set C of actual critical classes with F>g(M) is compact. Each C intersect K_a is nonempty. The family is downward directed by max(a,b) ...`), as `ZerothHomotopy.lift` requires here. +-/ + +noncomputable section + +open CategoryTheory + +universe w v u + +namespace TorusFiltration +/-- The increasing closed-superlevel family, with parameter `t = -h`. -/ +def superlevel_set {X : Type*} (g : X → ℝ) (t : ℝ) : Set X := + {x | -t ≤ g x} + +/-- Control: the point at the threshold belongs to the closed superlevel. +Changing `≤` to `<` invalidates this statement. -/ +theorem superlevel_control_closed_endpoint (b : ℝ) : + () ∈ superlevel_set (fun _ : Unit => b) (-b) := by + simp [superlevel_set] + +/-- Control: the strict condition fails at that same threshold. -/ +theorem superlevel_control_strict_endpoint (b : ℝ) : + ¬ (-(-b) < (fun _ : Unit => b) ()) := by + simp + +/-- Control: at parameter `1` the constant height `0` is present. +Changing `-t` to `t` invalidates this statement. -/ +theorem superlevel_control_parameter_sign : + () ∈ superlevel_set (fun _ : Unit => (0 : ℝ)) 1 := by + norm_num [superlevel_set] + +/-- Control: inclusion cannot run from parameter `1` back to `-1`. -/ +theorem superlevel_control_inclusion_direction : + ¬ superlevel_set (fun _ : Unit => (0 : ℝ)) 1 ⊆ + superlevel_set (fun _ : Unit => (0 : ℝ)) (-1) := by + intro h + have hc := h superlevel_control_parameter_sign + norm_num [superlevel_set] at hc + +/-- A global maximum has no strictly higher endpoint, regardless of paths. -/ +theorem superlevel_control_essential {X : Type*} (g : X → ℝ) (M : X) + (hM : ∀ y, g y ≤ g M) : ¬ ∃ y, g M < g y := by + rintro ⟨y, hy⟩ + exact (not_lt_of_ge (hM y)) hy + +/-- Increasing parameters give increasing closed superlevels. -/ +theorem superlevel_mono {X : Type*} (g : X → ℝ) {s t : ℝ} (hst : s ≤ t) : + superlevel_set g s ⊆ superlevel_set g t := by + intro x hx + exact le_trans (neg_le_neg hst) hx + +/-- Each level is closed when the function is continuous. -/ +theorem superlevel_isClosed {X : Type*} [TopologicalSpace X] + (g : X → ℝ) (hg : Continuous g) (t : ℝ) : IsClosed (superlevel_set g t) := by + exact isClosed_le continuous_const hg + +/-- Continuity of the inclusion is independent of continuity of the height function. -/ +def superlevel_inclusion {X : Type w} [TopologicalSpace X] + (g : X → ℝ) {s t : ℝ} (hst : s ≤ t) : + C(superlevel_set g s, superlevel_set g t) := + ContinuousMap.inclusion (superlevel_mono g hst) + +theorem superlevel_inclusion_id {X : Type w} [TopologicalSpace X] + (g : X → ℝ) (t : ℝ) : + superlevel_inclusion g (le_refl t) = ContinuousMap.id (superlevel_set g t) := by + ext x + rfl + +theorem superlevel_inclusion_comp {X : Type w} [TopologicalSpace X] + (g : X → ℝ) {r s t : ℝ} (hrs : r ≤ s) (hst : s ≤ t) : + (superlevel_inclusion g hst).comp (superlevel_inclusion g hrs) = + superlevel_inclusion g (hrs.trans hst) := by + ext x + rfl + +/-- Point membership at its own height; this is not a component-birth theorem. -/ +theorem superlevel_mem_at_own_height {X : Type*} (g : X → ℝ) (x : X) : + x ∈ superlevel_set g (-g x) := by + simp [superlevel_set] + +theorem superlevel_neg_height {X : Type*} (g : X → ℝ) (h : ℝ) : + superlevel_set g (-h) = {x | h ≤ g x} := by + ext x + simp [superlevel_set] + +/-- An explicit threshold countercontrol; it is not a compact Morse counterexample. -/ +theorem superlevel_control_strict_thresholds : + (∀ h : ℝ, h < 0 → ∃ k : ℝ, h < k ∧ k < 0) ∧ + ¬ ∃ k : ℝ, 0 ≤ k ∧ k < 0 := by + constructor + · intro h hh + exact ⟨h / 2, by linarith, by linarith⟩ + · rintro ⟨k, hk, hk'⟩ + exact (not_lt_of_ge hk) hk' + +/-- The induced map on actual path-component quotients. -/ +def superlevel_componentMap {X Y : Type w} [TopologicalSpace X] [TopologicalSpace Y] + (f : C(X, Y)) : ZerothHomotopy X → ZerothHomotopy Y := + ZerothHomotopy.lift (fun x => ZerothHomotopy.mk (f x)) + (fun _ _ p => ZerothHomotopy.sound (p.map f.continuous)) + +theorem superlevel_componentMap_mk {X Y : Type w} + [TopologicalSpace X] [TopologicalSpace Y] (f : C(X, Y)) (x : X) : + superlevel_componentMap f (ZerothHomotopy.mk x) = ZerothHomotopy.mk (f x) := rfl + +theorem superlevel_componentMap_id {X : Type w} [TopologicalSpace X] : + superlevel_componentMap (ContinuousMap.id X) = id := by + funext q + obtain ⟨x, rfl⟩ := ZerothHomotopy.mk_surjective q + rfl + +theorem superlevel_componentMap_comp {X Y Z : Type w} + [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] + (f : C(X, Y)) (g : C(Y, Z)) : + superlevel_componentMap (g.comp f) = + superlevel_componentMap g ∘ superlevel_componentMap f := by + funext q + obtain ⟨x, rfl⟩ := ZerothHomotopy.mk_surjective q + rfl + +def superlevel_componentInclusion {X : Type w} [TopologicalSpace X] + (g : X → ℝ) {s t : ℝ} (hst : s ≤ t) : + ZerothHomotopy (superlevel_set g s) → ZerothHomotopy (superlevel_set g t) := + superlevel_componentMap (superlevel_inclusion g hst) + +theorem superlevel_componentInclusion_id {X : Type w} [TopologicalSpace X] + (g : X → ℝ) (t : ℝ) : superlevel_componentInclusion g (le_refl t) = id := by + funext q + obtain ⟨x, rfl⟩ := ZerothHomotopy.mk_surjective q + rfl + +theorem superlevel_componentInclusion_comp {X : Type w} [TopologicalSpace X] + (g : X → ℝ) {r s t : ℝ} (hrs : r ≤ s) (hst : s ≤ t) : + superlevel_componentInclusion g (hrs.trans hst) = + superlevel_componentInclusion g hst ∘ superlevel_componentInclusion g hrs := by + funext q + obtain ⟨x, rfl⟩ := ZerothHomotopy.mk_surjective q + rfl + +/-- Actual component equality is precisely a path in the ambient closed superlevel. -/ +theorem superlevel_component_eq_iff_joinedIn {X : Type w} [TopologicalSpace X] + (g : X → ℝ) (t : ℝ) (x y : superlevel_set g t) : + ZerothHomotopy.mk x = ZerothHomotopy.mk y ↔ + JoinedIn (superlevel_set g t) x.val y.val := by + constructor + · intro h + have hxy : Joined x y := Quotient.exact h + exact (joinedIn_iff_joined x.property y.property).2 hxy + · intro h + obtain ⟨p⟩ := (joinedIn_iff_joined x.property y.property).1 h + exact ZerothHomotopy.sound p + +/-- The topological filtration in the preorder category of real numbers. -/ +def superlevel_filtration {X : Type w} [TopologicalSpace X] + (g : X → ℝ) : ℝ ⥤ TopCat.{w} where + obj t := TopCat.of (superlevel_set g t) + map f := TopCat.ofHom (superlevel_inclusion g (leOfHom f)) + map_id t := by + ext x + rfl + map_comp f k := by + ext x + rfl + +variable {C : Type u} [Category.{v} C] + [CategoryTheory.Limits.HasCoproducts.{w} C] + [Preadditive C] [CategoryWithHomology C] + +/-- Actual singular H0 with coefficient object R, including the inclusion maps. -/ +def superlevel_h0Filtration {X : Type w} [TopologicalSpace X] + (g : X → ℝ) (R : C) : ℝ ⥤ C := + superlevel_filtration g ⋙ (AlgebraicTopology.singularHomologyFunctor C 0).obj R + +/-- This target includes the actual H0 definition in the transitive dependency audit. -/ +theorem superlevel_h0Filtration_map_id {X : Type w} [TopologicalSpace X] + (g : X → ℝ) (R : C) (t : ℝ) : + (superlevel_h0Filtration g R).map (𝟙 t) = + 𝟙 ((superlevel_h0Filtration g R).obj t) := + (superlevel_h0Filtration g R).map_id t + +theorem superlevel_h0Filtration_map_comp {X : Type w} [TopologicalSpace X] + (g : X → ℝ) (R : C) {r s t : ℝ} (f : r ⟶ s) (k : s ⟶ t) : + (superlevel_h0Filtration g R).map (f ≫ k) = + (superlevel_h0Filtration g R).map f ≫ (superlevel_h0Filtration g R).map k := + (superlevel_h0Filtration g R).map_comp f k + +end TorusFiltration \ No newline at end of file diff --git a/frontiers/critical_level_attainment_20261020/final-project/CriticalLevelAttainment.lean b/frontiers/critical_level_attainment_20261020/final-project/CriticalLevelAttainment.lean new file mode 100644 index 000000000..1579751ec --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-project/CriticalLevelAttainment.lean @@ -0,0 +1,281 @@ +import MorseFiniteCritical +import SuperlevelBar +import ClosedSuperlevel + +/-! +# Conditional attainment at the literal C263 death height + +The fixed older critical endpoint is derived from C293 and compact topology. +The only additional geometric premise is local path connectivity of the actual +closed death superlevel. This file does not derive that premise from Morse data, +prove strict death drop, or identify an elder saddle or an exhaustive barcode. +-/ + +noncomputable section + +open Set Topology +open UniversalLaw.Spec.Lifetime TorusFiltration TorusMorseFinite + +namespace TorusCriticalAttainment + +/-- The lattice formula is identical in the two frozen source predicates. -/ +theorem periodic_transport {d : ℕ} {L : ℝ} {g : E d → ℝ} + (hperiodic : IsLPeriodic d L g) : torus_isPeriodic d L g := by + simpa only [IsLPeriodic, torus_isPeriodic, latticeVec, torus_latticeVec] using hperiodic + +def descendedHeight (d : ℕ) (L : ℝ) (hL : 0 < L) (g : E d → ℝ) + (hperiodic : IsLPeriodic d L g) : torus_quotient d L hL → ℝ := + torus_descend d L hL g (periodic_transport hperiodic) + +@[simp] theorem descendedHeight_proj (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : E d → ℝ) (hperiodic : IsLPeriodic d L g) (x : E d) : + descendedHeight d L hL g hperiodic (torus_proj d L hL x) = g x := rfl + +theorem descendedHeight_continuous {d : ℕ} {L : ℝ} (hL : 0 < L) + {g : E d → ℝ} (hperiodic : IsLPeriodic d L g) (hsmooth : IsSmooth d g) : + Continuous (descendedHeight d L hL g hperiodic) := + torus_descend_continuous d L hL g (periodic_transport hperiodic) + ((hsmooth 0).continuous) + +/-- Closed connected components of a closed subspace, viewed in the ambient space. -/ +theorem closed_connectedComponentIn {X : Type*} [TopologicalSpace X] + {s : Set X} (hs : IsClosed s) (x : X) : + IsClosed (connectedComponentIn s x) := by + by_cases hx : x ∈ s + · rw [connectedComponentIn_eq_image hx] + exact hs.isClosedEmbedding_subtypeVal.isClosedMap _ isClosed_connectedComponent + · rw [connectedComponentIn_eq_empty hx] + exact isClosed_empty + +/-- Compact directed intersection connectedness; the members need not be path connected. +This auxiliary lemma uses the compact-Hausdorff separation argument, not compactness of paths. -/ +theorem preconnected_iInter_of_directed {X ι : Type*} [TopologicalSpace X] + [CompactSpace X] [T2Space X] [Nonempty ι] (K : ι → Set X) + (hclosed : ∀ i, IsClosed (K i)) (hconnected : ∀ i, IsPreconnected (K i)) + (hdirected : Directed (· ⊇ ·) K) : IsPreconnected (⋂ i, K i) := by + rw [isPreconnected_iff_subset_of_fully_disjoint_closed (isClosed_iInter hclosed)] + intro a b ha hb hcover hab + obtain ⟨u, v, hu, hv, hau, hbv, huv⟩ := normal_separation ha hb hab + have hd : Disjoint (u ∪ v)ᶜ (⋂ i, K i) := + disjoint_compl_left_iff_subset.mpr (hcover.trans (union_subset_union hau hbv)) + obtain ⟨i, hi⟩ := (hu.union hv).isClosed_compl.isCompact.elim_directed_family_closed + K hclosed hd hdirected + have hKi : K i ⊆ u ∪ v := disjoint_compl_left_iff_subset.mp hi + rcases (hconnected i).subset_or_subset hu hv huv hKi with hKu | hKv + · left + intro x hx + rcases hcover hx with hxa | hxb + · exact hxa + · exact False.elim (Set.disjoint_left.mp huv (hKu (mem_iInter.mp hx i)) (hbv hxb)) + · right + intro x hx + rcases hcover hx with hxa | hxb + · exact False.elim (Set.disjoint_left.mp huv (hau hxa) (hKv (mem_iInter.mp hx i))) + · exact hxb + +/-- Closedness of the actual lattice gives the actual quotient its Hausdorff topology. -/ +theorem quotient_t2 (d : ℕ) (L : ℝ) (hL : 0 < L) : + T2Space (torus_quotient d L hL) := by + let : IsClosed ((torus_periodLattice d L hL).toAddSubgroup : Set (E d)) := + (torus_periodLattice d L hL).toAddSubgroup.isClosed_of_discreteTopology + infer_instance + +/-- Ambient local path connectivity descends to C263's actual quotient. -/ +theorem quotient_locallyPathConnectedSpace (d : ℕ) (L : ℝ) (hL : 0 < L) : + LocallyPathConnectedSpace (torus_quotient d L hL) := by + exact inferInstanceAs (LocallyPathConnectedSpace (Quotient _)) + +/-- A component maximum strictly inside a superlevel is a local maximum. +Ambient local connectedness suffices; the closed superlevel need not be locally connected. -/ +theorem component_maximum_isLocalMax {X : Type*} [TopologicalSpace X] + [LocallyConnectedSpace X] (F : X → ℝ) (hF : Continuous F) + (a : ℝ) (x q : X) (hq : q ∈ connectedComponentIn {y | a ≤ F y} x) + (haq : a < F q) (hmax : IsMaxOn F (connectedComponentIn {y | a ≤ F y} x) q) : + IsLocalMax F q := by + apply hmax.isLocalMax + rw [connectedComponentIn_eq hq] + apply connectedComponentIn_mem_nhds + exact Filter.mem_of_superset ((isOpen_lt continuous_const hF).mem_nhds haq) + (fun y hy => show a ≤ F y from (show a < F y from hy).le) + +/-- A quotient local maximum pulls back to a literal critical point. +No manifold derivative on the quotient is introduced. -/ +theorem localMax_mem_quotientCriticalSet {d : ℕ} {L : ℝ} (hL : 0 < L) + {g : E d → ℝ} (hperiodic : IsLPeriodic d L g) + (q : torus_quotient d L hL) + (hq : IsLocalMax (descendedHeight d L hL g hperiodic) q) : + q ∈ quotientCriticalSet d L hL g := by + obtain ⟨x, rfl⟩ := torus_proj_surjective d L hL q + refine ⟨x, ?_, rfl⟩ + exact (hq.comp_continuous (torus_proj_continuous d L hL).continuousAt).fderiv_eq_zero + +/-- The actual strict cut puts an older critical point in every closed component +strictly below the literal death height. -/ +theorem older_critical_in_component (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : E d → ℝ) (hsmooth : IsSmooth d g) (hperiodic : IsLPeriodic d L g) + (M : E d) (hnonessential : ¬ superlevelBar_isEssential g M) + (a : ℝ) (ha : a < superlevelBar_deathHeight g M) : + ∃ Q ∈ quotientCriticalSet d L hL g, + g M < descendedHeight d L hL g hperiodic Q ∧ + Q ∈ connectedComponentIn {q | a ≤ descendedHeight d L hL g hperiodic q} + (torus_proj d L hL M) := by + let X := torus_quotient d L hL + let F := descendedHeight d L hL g hperiodic + let m := torus_proj d L hL M + let A : Set X := {q | a ≤ F q} + let K := connectedComponentIn A m + let : CompactSpace X := ⟨torus_compact d L hL⟩ + let : LocallyPathConnectedSpace X := quotient_locallyPathConnectedSpace d L hL + have hF : Continuous F := descendedHeight_continuous hL hperiodic hsmooth + have hg : Continuous g := (hsmooth 0).continuous + have hA : IsClosed A := by + simpa only [A, ← superlevel_neg_height] using superlevel_isClosed F hF (-a) + have hK : IsCompact K := (closed_connectedComponentIn hA m).isCompact + have hm : m ∈ A := (ha.le.trans (superlevelBar_death_le_start g hg M hnonessential)) + obtain ⟨y, hy, γ, hγ⟩ := (superlevelBar_strict_cut g hg M hnonessential a).mp ha + have hpath : JoinedIn A m (torus_proj d L hL y) := + ⟨γ.map (torus_proj_continuous d L hL), fun t => (hγ t).le⟩ + have hyK : torus_proj d L hL y ∈ K := by + rw [show K = connectedComponentIn A m from rfl, connectedComponentIn_eq_image hm] + exact ⟨⟨torus_proj d L hL y, hpath.target_mem⟩, + pathComponent_subset_component _ (mem_pathComponent_iff.mpr hpath.joined_subtype), rfl⟩ + obtain ⟨Q, hQ, hmax⟩ := hK.exists_isMaxOn ⟨m, mem_connectedComponentIn hm⟩ hF.continuousOn + have hQolder : g M < F Q := hy.trans_le (hmax hyK) + have haQ : a < F Q := + ha.trans_le (superlevelBar_death_le_start g hg M hnonessential) |>.trans hQolder + have hlocal : IsLocalMax F Q := component_maximum_isLocalMax F hF a m Q hQ haQ hmax + exact ⟨Q, localMax_mem_quotientCriticalSet hL hperiodic Q hlocal, hQolder, hQ⟩ + +/-- Main conditional theorem. The endpoint, its strict older height, the path, and +its attained minimum are conclusions. Only closed-level LPC is an extra geometric input. -/ +theorem quotient_death_attainment (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : E d → ℝ) (hsmooth : IsSmooth d g) (hperiodic : IsLPeriodic d L g) + (hmorse : IsMorseDistinct d L g) (M : E d) + (hnonessential : ¬ superlevelBar_isEssential g M) + (hclosedLPC : LocallyPathConnectedSpace + {q : torus_quotient d L hL // + superlevelBar_deathHeight g M ≤ descendedHeight d L hL g hperiodic q}) : + ∃ Q ∈ quotientCriticalSet d L hL g, + g M < descendedHeight d L hL g hperiodic Q ∧ + ∃ γ : Path (torus_proj d L hL M) Q, + (∀ t : unitInterval, + superlevelBar_deathHeight g M ≤ descendedHeight d L hL g hperiodic (γ t)) ∧ + ∃ t : unitInterval, + descendedHeight d L hL g hperiodic (γ t) = superlevelBar_deathHeight g M := by + let X := torus_quotient d L hL + let F := descendedHeight d L hL g hperiodic + let m := torus_proj d L hL M + let δ := superlevelBar_deathHeight g M + let I := Set.Iio δ + let A : Set X := {q | δ ≤ F q} + let K : I → Set X := fun a => connectedComponentIn {q | a.val ≤ F q} m + let C : Set X := quotientCriticalSet d L hL g ∩ {q | g M < F q} + let : CompactSpace X := ⟨torus_compact d L hL⟩ + let : T2Space X := quotient_t2 d L hL + let : Nonempty I := ⟨⟨δ - 1, by change δ - 1 < δ; linarith⟩⟩ + let : LocallyPathConnectedSpace A := hclosedLPC + have hF : Continuous F := descendedHeight_continuous hL hperiodic hsmooth + have hg : Continuous g := (hsmooth 0).continuous + have hmA : m ∈ A := superlevelBar_death_le_start g hg M hnonessential + have hmK : ∀ a : I, m ∈ K a := by + intro a + apply mem_connectedComponentIn + change a.val ≤ F m + exact (show a.val < δ from a.property).le.trans hmA + have hKclosed : ∀ a : I, IsClosed (K a) := fun a => + closed_connectedComponentIn (isClosed_le continuous_const hF) m + have hKconnected : ∀ a : I, IsPreconnected (K a) := fun _ => + isPreconnected_connectedComponentIn + have hKdirected : Directed (· ⊇ ·) K := by + intro a b + refine ⟨⟨max a.val b.val, ?_⟩, ?_, ?_⟩ + · change max a.val b.val < δ + exact max_lt a.property b.property + · apply connectedComponentIn_mono m + intro q h + change a.val ≤ F q + change max a.val b.val ≤ F q at h + exact (le_max_left a.val b.val).trans h + · apply connectedComponentIn_mono m + intro q h + change b.val ≤ F q + change max a.val b.val ≤ F q at h + exact (le_max_right a.val b.val).trans h + have hCcompact : IsCompact C := + ((quotientCriticalSet_finite d L hL g hsmooth hperiodic hmorse).subset + inter_subset_left).isCompact + have hCK : ∀ a : I, (C ∩ K a).Nonempty := by + intro a + obtain ⟨Q, hQ, hQolder, hQK⟩ := + older_critical_in_component d L hL g hsmooth hperiodic M hnonessential a.val a.property + exact ⟨Q, ⟨hQ, hQolder⟩, hQK⟩ + have hCinter : (C ∩ ⋂ a : I, K a).Nonempty := by + by_contra hn + have hd : Disjoint C (⋂ a : I, K a) := by + exact Set.disjoint_iff_inter_eq_empty.mpr (Set.not_nonempty_iff_eq_empty.mp hn) + obtain ⟨a, ha⟩ := hCcompact.elim_directed_family_closed K hKclosed hd hKdirected + exact (Set.not_nonempty_iff_eq_empty.mpr ha.inter_eq) (hCK a) + obtain ⟨Q, hQC, hQinter⟩ := hCinter + have hinterA : (⋂ a : I, K a) ⊆ A := by + intro q hq + by_contra hn + have hlt : F q < δ := lt_of_not_ge hn + obtain ⟨a, hqa, haδ⟩ := exists_between hlt + have hqa' := connectedComponentIn_subset {q | a ≤ F q} m + (mem_iInter.mp hq ⟨a, haδ⟩) + exact (not_le_of_gt hqa) hqa' + have hconn : IsPreconnected (⋂ a : I, K a) := + preconnected_iInter_of_directed K hKclosed hKconnected hKdirected + have hQcomp : Q ∈ connectedComponentIn A m := + hconn.subset_connectedComponentIn (mem_iInter.mpr hmK) hinterA hQinter + have hQA : Q ∈ A := hinterA hQinter + have hsubcomp : (⟨Q, hQA⟩ : A) ∈ connectedComponent (⟨m, hmA⟩ : A) := by + rw [connectedComponentIn_eq_image hmA] at hQcomp + obtain ⟨q, hq, hqQ⟩ := hQcomp + have heq : q = (⟨Q, hQA⟩ : A) := Subtype.ext hqQ + rwa [heq] at hq + have hjoined : Joined (⟨m, hmA⟩ : A) (⟨Q, hQA⟩ : A) := by + rw [← pathComponent_eq_connectedComponent] at hsubcomp + exact mem_pathComponent_iff.mp hsubcomp + obtain ⟨p⟩ := hjoined + let γ : Path m Q := p.map continuous_subtype_val + have hγ : ∀ t : unitInterval, δ ≤ F (γ t) := fun t => (p t).property + have hattain : ∃ t : unitInterval, F (γ t) = δ := by + by_contra hn + have hstrict : ∀ t : unitInterval, δ < F (γ t) := by + intro t + exact lt_of_le_of_ne (hγ t) (fun heq => hn ⟨t, heq.symm⟩) + have heuc := (torus_strict_higher_path_iff d L hL g + (periodic_transport hperiodic) M δ).mpr ⟨Q, hQC.2, γ, hstrict⟩ + exact superlevelBar_death_not_mem_clearance g hg M hnonessential heuc + exact ⟨Q, hQC.1, hQC.2, γ, hγ, hattain⟩ + +/-- Prescribed-start lift of the attained path, including literal criticality +of the actual lifted endpoint. -/ +theorem euclidean_death_attainment (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : E d → ℝ) (hsmooth : IsSmooth d g) (hperiodic : IsLPeriodic d L g) + (hmorse : IsMorseDistinct d L g) (M : E d) + (hnonessential : ¬ superlevelBar_isEssential g M) + (hclosedLPC : LocallyPathConnectedSpace + {q : torus_quotient d L hL // + superlevelBar_deathHeight g M ≤ descendedHeight d L hL g hperiodic q}) : + ∃ y : E d, IsCriticalPoint d g y ∧ g M < g y ∧ + ∃ Γ : Path M y, + (∀ t : unitInterval, superlevelBar_deathHeight g M ≤ g (Γ t)) ∧ + ∃ t : unitInterval, g (Γ t) = superlevelBar_deathHeight g M := by + obtain ⟨Q, hQ, hQolder, γ, hγ, t, ht⟩ := + quotient_death_attainment d L hL g hsmooth hperiodic hmorse M hnonessential hclosedLPC + obtain ⟨y, Γ, hy, hΓ⟩ := torus_path_lift_from d L hL γ + have hheight : g y = descendedHeight d L hL g hperiodic Q := + congrArg (descendedHeight d L hL g hperiodic) hy + have hcritical : IsCriticalPoint d g y := by + have hzero := (mem_quotientCriticalSet_iff hL hperiodic Q).mp hQ + rw [← hy] at hzero + exact hzero + have hvalues : ∀ s : unitInterval, + g (Γ s) = descendedHeight d L hL g hperiodic (γ s) := + fun s => congrArg (descendedHeight d L hL g hperiodic) (hΓ s) + exact ⟨y, hcritical, (by rw [hheight]; exact hQolder), Γ, + fun s => (hvalues s).symm ▸ hγ s, t, (hvalues t).trans ht⟩ + +end TorusCriticalAttainment diff --git a/frontiers/critical_level_attainment_20261020/final-project/CriticalLevelAxiomAudit.lean b/frontiers/critical_level_attainment_20261020/final-project/CriticalLevelAxiomAudit.lean new file mode 100644 index 000000000..60111767e --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-project/CriticalLevelAxiomAudit.lean @@ -0,0 +1,56 @@ +import CriticalLevelAttainment +import Lean.Elab.Command +import Lean.Util.CollectAxioms + +/-! Complete module-origin census for C294 and all five immutable local inputs. +Includes generated and private declarations. Only the standard axioms are allowed. +Command success is scoped execution evidence, not scientific promotion. -/ + +#print axioms TorusCriticalAttainment.quotient_death_attainment +#print axioms TorusCriticalAttainment.euclidean_death_attainment +#check @TorusCriticalAttainment.quotient_death_attainment +#check @TorusCriticalAttainment.euclidean_death_attainment + +open Lean Elab Command in +run_cmd do + let env := (← getEnv).setExporting false + let allowed : Array Name := #[`propext, `Classical.choice, `Quot.sound] + let modules : Array Name := #[`Lifetime, `TorusTopology, `SuperlevelBar, + `ClosedSuperlevel, `MorseFiniteCritical, `CriticalLevelAttainment] + let constants := env.constants.toList + let mut allNames : Array Name := #[] + for modName in modules do + let some idx := env.getModuleIdx? modName + | throwError "missing audited module: {modName}" + let names := (constants.filterMap fun (name, _) => + if env.getModuleIdxFor? name == some idx then some name else none).toArray.qsort Name.lt + if names.isEmpty then throwError "empty declaration inventory: {modName}" + liftIO <| IO.eprintln s!"ATTAINMENT_AUDIT_PROGRESS {modName} COUNT {names.size}" + logInfo m!"ATTAINMENT_AUDIT_MODULE {modName} COUNT {names.size}" + for name in names do + if (env.checked.get.find? name).isNone then + throwError "missing kernel declaration: {name}" + let axs ← Lean.collectAxioms name + logInfo m!"ATTAINMENT_AUDIT_DECL {name} AXIOMS {axs}" + for ax in axs do + unless allowed.contains ax do + throwError "forbidden transitive axiom {ax} in {name}" + allNames := allNames.push name + let required : Array Name := #[ + `UniversalLaw.Spec.Lifetime.IsSmooth, + `UniversalLaw.Spec.Lifetime.IsMorseDistinct, + `UniversalLaw.Spec.Lifetime.IsCriticalPoint, + `TorusFiltration.torus_proj, + `TorusFiltration.torus_compact, + `TorusFiltration.torus_path_lift_from, + `TorusFiltration.superlevelBar_deathHeight, + `TorusFiltration.superlevelBar_strict_cut, + `TorusFiltration.superlevelBar_death_not_mem_clearance, + `TorusMorseFinite.quotientCriticalSet_finite, + `TorusMorseFinite.mem_quotientCriticalSet_iff, + `TorusCriticalAttainment.quotient_death_attainment, + `TorusCriticalAttainment.euclidean_death_attainment] + for name in required do + unless allNames.contains name do + throwError "required declaration omitted from audit: {name}" + logInfo m!"ATTAINMENT_AUDIT_STANDARD_ONLY_PASS COUNT {allNames.size}" diff --git a/frontiers/critical_level_attainment_20261020/final-project/Lifetime.lean b/frontiers/critical_level_attainment_20261020/final-project/Lifetime.lean new file mode 100644 index 000000000..f2508f7f2 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-project/Lifetime.lean @@ -0,0 +1,634 @@ +import Mathlib + +/-! +# Lifetime-track statements: parent Theorems A, B, C, the bounded remainder R and the +# planar elder lower bound / density gap (statements only) + +Scientific effect: NONE. Formal progress of every declaration here: `specified`. +Organizational-independence credit of this transcription: 0 (Anthropic / Claude). + +This module states, as `Prop`-valued definitions, the shapes of the parent lifetime +results (1.1), (1.2), (1.3) of UNIFORM_MATRIX_CAP_AND_LIFETIME.md, of the bounded +remainder (R1) of LIFETIME_REMAINDER.md, and of the planar lower bound (E2), the +two-sided rate (E4) and the compact-window density gap (E11) of +ELDER_LOWER_AND_DENSITY_GAP.md. Every statement is parametrised by interface objects +(the Gaussian field, the superlevel-bar / elder-partner relation, and the typed pair law +probability `p_r(b,k,R)`); it is a statement about whatever objects satisfy those +interfaces, and the identification of those objects with the objects of the source texts +is not part of the statement. + +This module is self-contained: it imports only Mathlib and re-declares, verbatim up to +the namespace, the shared objects of `Specifications/Field.lean` (covariance, field +interface, critical points, Hessian inertia, pairs, superlevel bars, density versions). +The duplication is deliberate at this layer and is recorded as such. + +What this module does not establish. It consists only of definitions and structures; +it states nothing as a result and proves nothing: none of the parent results, the +remainder bound or the planar bounds is shown here, and no kernel receipt about them +exists. It does not transcribe the explicit Gaussian/angular integral (15.2) for the +leading coefficient `c_{d,L}` (the coefficient is characterised only through the +leading-term asymptotics of (1.3)); it does not transcribe the regression law +`Q_{r,b,k,R}`, the typed weight `W_r`, the full normalizer `Z_r` or the marked Kac-Rice +representation (all informal in the source and taken as the interface field `p`); it +does not transcribe the reading-rule amendments bound to the parent (congruence erratum, +Section 9 replacement v1.1, wording W1, embedding radius `r < L/(4 sqrt 2)`), nor the +marked-cylinder cap support; it asserts no numerical `C`, `r_*`, `z_*`, `ell_*` or +coefficient value; it does not state Theorem A as consumed by Theorem R; and it does +not state the compact-window `O(ell^(2/3))` difference for the unrestricted densities. +The planar statements (E4) and (E11) carry the parent upper bound (1.1), for the same +typed pair law at `d = 2`, as an explicit hypothesis, as the source does ("If the precise +Theorem A upper bound in [LP] is consumed"; its Section 4 says the upper half of (E11) +consumes the parent upper bound already identified there); the direct lower bound (E2) is +unconditional, as in the source. +Nothing here promotes, reclassifies or discharges any claim, premise or obligation of +the registers; the landing disposition `REVIEWED_SCOPED` (lifetime-remainder) and the +graph classification and review disposition recorded for +`math.uniform-matrix-cap-lifetime` are transcribed from the registers by the statement +register, never re-derived here; alignment of these statements with the sources is +PENDING_INDEPENDENT_REVIEW. + +Sources (Layer 0, byte-pinned, `d6g8k5htny-coder/Math-`): +* `lifetime-parent`: commit `c39164254ad1529ed49543743598d5dcb24bab98`, path + `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md`, + sha256 `9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7`. +* `lifetime-remainder`: commit `760340e921ac4ceda296b8118da936f1133e956e`, path + `frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md`, + sha256 `380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a`. +* `elder-lower-density-gap`: commit `6c020d6a72936632f2055122e71a7818a4ff497e`, path + `frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md`, + sha256 `8ce05a43bde8e0d718f09e2da1ffe75d3ec5893489254afdbf5b58b602cdba0c`. +-/ + +namespace UniversalLaw.Spec.Lifetime + +open MeasureTheory + +/-! ### Shared objects, re-declared from `Specifications/Field.lean` (same text, this +namespace). The duplication is deliberate: modules of this packet import only Mathlib. -/ + +/-- The ambient Euclidean space `R^d` in which the torus `X = R^d/(L Z^d)` is realised +by `L`-periodic functions. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "On the flat torus X = R^d/(L Z^d), let f be the centered stationary Gaussian field of variance one with covariance" +Interface: none; this is the ambient space `EuclideanSpace ℝ (Fin d)`. +Does not claim: that the torus is represented by any quotient type; periodicity is a hypothesis on functions. -/ +abbrev E (d : ℕ) : Type := EuclideanSpace ℝ (Fin d) + +/-- The lattice vector `L n` for `n ∈ Z^d`, written in the standard coordinate vectors. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "K_L(z) = sum_{n in Z^d} exp(-|z+Ln|^2/2)" +Interface: none. +Does not claim: anything beyond the definition of the vector `L n`. -/ +noncomputable def latticeVec (d : ℕ) (L : ℝ) (n : Fin d → ℤ) : E d := + ∑ i, EuclideanSpace.single i (L * (n i : ℝ)) + +/-- The unnormalised periodized Gaussian (theta) sum `sum_{n in Z^d} exp(-|z+Ln|^2/2)`, +written as a `tsum` over `Z^d`. If the family were not summable the `tsum` would be `0`; +summability is a hypothesis field of `GaussianFieldInterface`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "K_L(z) = sum_{n in Z^d} exp(-|z+Ln|^2/2)" +Interface: summability of the family is the field `GaussianFieldInterface.summable`, not derived here. +Does not claim: convergence of the sum. -/ +noncomputable def thetaSum (d : ℕ) (L : ℝ) (z : E d) : ℝ := + ∑' n : Fin d → ℤ, Real.exp (-(‖z + latticeVec d L n‖ ^ 2) / 2) + +/-- The periodized Gaussian covariance +`K_L(z) = sum_n exp(-|z+Ln|^2/2) / sum_n exp(-|Ln|^2/2)`; the denominator is the theta +sum at `z = 0`, so `K_L(0) = 1` (variance one) whenever that denominator is nonzero (the +summability field is meant to provide this; not shown here). + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "K_L(z) = sum_{n in Z^d} exp(-|z+Ln|^2/2)" +Interface: summability of both theta sums is the field `GaussianFieldInterface.summable`. +Does not claim: positivity of the Fourier coefficients (Section 2 of the source) or any property of `K_L` beyond its definition. -/ +noncomputable def periodicCovariance (d : ℕ) (L : ℝ) (z : E d) : ℝ := + thetaSum d L z / thetaSum d L 0 + +/-- The `K_L`-quadratic form `sum_{i,j} a_i a_j K_L(x_i - x_j)` of a finite real linear +combination `sum_i a_i f(x_i)` of point evaluations: its variance under a centred +stationary field with covariance `K_L`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "let f be the centered stationary Gaussian field of variance one with covariance" +Interface: nonnegativity of this form is the field `GaussianFieldInterface.quad_nonneg`. +Does not claim: positive definiteness (Section 2 of the source). -/ +noncomputable def covQuadForm (d : ℕ) (L : ℝ) {m : ℕ} (x : Fin m → E d) (a : Fin m → ℝ) : ℝ := + ∑ i, ∑ j, a i * a j * periodicCovariance d L (x i - x j) + +/-- `L`-periodicity of a function on `R^d`: invariance under every lattice translation. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "On the flat torus X = R^d/(L Z^d), let f be the centered stationary Gaussian field of variance one with covariance" +Interface: none; this is the defining predicate of a function on the torus. +Does not claim: anything about the field. -/ +def IsLPeriodic (d : ℕ) (L : ℝ) (g : E d → ℝ) : Prop := + ∀ (x : E d) (n : Fin d → ℤ), g (x + latticeVec d L n) = g x + +/-- Smoothness of a sample path: `C^n` for every finite `n` (written without `⊤`). + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "In particular the field has a smooth version and all finite moments of its global derivative suprema exist." +Interface: smoothness of every sample path is the field `GaussianFieldInterface.smooth`. +Does not claim: existence of a smooth version, or moment bounds on derivative suprema. -/ +def IsSmooth (d : ℕ) (g : E d → ℝ) : Prop := + ∀ n : ℕ, ContDiff ℝ n g + +/-- Interface for the centred stationary Gaussian field of variance one on the torus +`R^d/(L Z^d)` with covariance `K_L`. The field is GIVEN: its probability space, its sample +paths, their smoothness and periodicity, the Gaussian law of every finite real linear +combination of point evaluations (law `gaussianReal 0 v` with `v` the `K_L`-quadratic +form) and the covariance identity are hypothesis fields, as is summability of the theta +sums. Existence of such an object is not asserted. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "On the flat torus X = R^d/(L Z^d), let f be the centered stationary Gaussian field of variance one with covariance" +Interface: every field of this structure is a given property of the field, never derived. +Does not claim: existence or uniqueness in law of the field; the Fourier representation and positive spectrum of Section 2; almost-sure Morse genericity of Section 8. -/ +structure GaussianFieldInterface (d : ℕ) (L : ℝ) where + /-- The underlying probability space (sample space). -/ + Ω : Type + -- Its sigma-algebra (square-bracket field, as in Mathlib's bundled categories). It is not + -- registered for typeclass resolution after this declaration; consumers bring it into + -- scope with `haveI := G.mΩ`. + [mΩ : MeasurableSpace Ω] + /-- The probability measure `P`. -/ + P : Measure Ω + -- `P` is a probability measure (square-bracket field). + [isProb : IsProbabilityMeasure P] + /-- The sample paths `ω ↦ f_ω : R^d → ℝ`. -/ + F : Ω → E d → ℝ + /-- Section 2 clause: "the field has a smooth version"; every sample path is smooth. -/ + smooth : ∀ ω, IsSmooth d (F ω) + /-- Section 1 clause: the field lives "On the flat torus X = R^d/(L Z^d)"; every sample path + is `L`-periodic. -/ + periodic : ∀ ω, IsLPeriodic d L (F ω) + /-- Section 1 clause: the theta sums defining `K_L` converge (taken as a hypothesis). -/ + summable : ∀ z : E d, Summable (fun n : Fin d → ℤ => Real.exp (-(‖z + latticeVec d L n‖ ^ 2) / 2)) + /-- The `K_L`-quadratic form is nonnegative (so it is a variance). -/ + quad_nonneg : ∀ {m : ℕ} (x : Fin m → E d) (a : Fin m → ℝ), 0 ≤ covQuadForm d L x a + /-- Section 1 clause: "the centered stationary Gaussian field of variance one with covariance" + `K_L`; every finite real linear combination of point evaluations has the centred Gaussian + law whose variance is the `K_L`-quadratic form. -/ + gaussian : ∀ {m : ℕ} (x : Fin m → E d) (a : Fin m → ℝ), + Measure.map (fun ω => ∑ i, a i * F ω (x i)) P = + ProbabilityTheory.gaussianReal 0 ⟨covQuadForm d L x a, quad_nonneg x a⟩ + /-- Covariance identity `E[f(x) f(y)] = K_L(x - y)` (centred, stationary). -/ + covariance : ∀ x y : E d, ∫ ω, F ω x * F ω y ∂P = periodicCovariance d L (x - y) + +/-- The Hessian of `g` at `x` as a bilinear form, through the second iterated Fréchet +derivative: `hessian d g x v w = D^2 g(x)[v, w]`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "A maximum has d negative Hessian eigenvalues; the relevant saddle has d-1 negative and one positive eigenvalue." +Interface: none. +Does not claim: symmetry of the form (true for `C^2` functions, not stated here). -/ +noncomputable def hessian (d : ℕ) (g : E d → ℝ) (x v w : E d) : ℝ := + iteratedFDeriv ℝ 2 g x ![v, w] + +/-- Critical point: vanishing Fréchet derivative (`grad f = 0`). + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "grad f(M)=grad f(S)=0." +Interface: none. +Does not claim: differentiability of `g` at `x` (if `g` is not differentiable, `fderiv` is `0`). -/ +def IsCriticalPoint (d : ℕ) (g : E d → ℝ) (x : E d) : Prop := + fderiv ℝ g x = 0 + +/-- Sylvester-inertia encoding of "the Hessian at `x` is nondegenerate with exactly `j` +negative and `d - j` positive eigenvalues": there are complementary subspaces `V`, `W` of +dimensions `j` and `d - j` on which the Hessian form is negative definite, respectively +positive definite. Intended to agree with the eigenvalue count for symmetric (`C^2`) +Hessians; not shown here. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "The index counts negative eigenvalues." +Interface: none. +Does not claim: equivalence with an eigenvalue count for a non-symmetric form. -/ +def HessianHasInertia (d : ℕ) (g : E d → ℝ) (x : E d) (j : ℕ) : Prop := + ∃ V W : Submodule ℝ (E d), IsCompl V W ∧ + Module.finrank ℝ V = j ∧ Module.finrank ℝ W = d - j ∧ + (∀ v ∈ V, v ≠ 0 → hessian d g x v v < 0) ∧ + (∀ w ∈ W, w ≠ 0 → 0 < hessian d g x w w) + +/-- Nondegenerate local maximum: a critical point whose Hessian has `d` negative +eigenvalues (negative definite). + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "A maximum has d negative Hessian eigenvalues; the relevant saddle has d-1 negative and one positive eigenvalue." +Interface: none. +Does not claim: that every local maximum of a sample path is nondegenerate (Morse genericity is Section 8 of the source). -/ +def IsNondegMax (d : ℕ) (g : E d → ℝ) (x : E d) : Prop := + IsCriticalPoint d g x ∧ HessianHasInertia d g x d + +/-- Index-(d-1) saddle: a critical point whose Hessian has `d - 1` negative and one +positive eigenvalue. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "A maximum has d negative Hessian eigenvalues; the relevant saddle has d-1 negative and one positive eigenvalue." +Interface: none. +Does not claim: that such a saddle is a merging saddle of any superlevel bar. -/ +def IsIndexSaddle (d : ℕ) (g : E d → ℝ) (x : E d) : Prop := + IsCriticalPoint d g x ∧ HessianHasInertia d g x (d - 1) + +/-- The pin `M = -(r/2) u` of the embedded local cylinder with axial unit vector `u`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "M=-(r/2)u, S=(r/2)u," +Interface: none. +Does not claim: that `u` is a unit vector; this pin is an auxiliary definition consumed by no statement of this packet (the typed pair law `p` is a primitive), so it is attached to no claim. -/ +noncomputable def pinM (d : ℕ) (r : ℝ) (u : E d) : E d := + -((r / 2) • u) + +/-- The pin `S = (r/2) u` of the embedded local cylinder with axial unit vector `u`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "M=-(r/2)u, S=(r/2)u," +Interface: none. +Does not claim: that `u` is a unit vector; this pin is an auxiliary definition consumed by no statement of this packet (the typed pair law `p` is a primitive), so it is attached to no claim. -/ +noncomputable def pinS (d : ℕ) (r : ℝ) (u : E d) : E d := + (r / 2) • u + +/-- Torus distance between two points of `R^d`: the infimum over the lattice of +`|x - y + L n|`. For `L > 0` it is intended to vanish exactly when `x` and `y` represent the +same torus point; not shown here. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "Count ordered maximum/saddle pairs with 00, and let nu_eld^all(ell) count all finite ordinary superlevel H0 persistence bars, both in expectation per unit volume." +Interface: none. +Does not claim: that the height gap of an elder pair is the persistence of a bar in any persistence module. -/ +def heightGap (d : ℕ) (g : E d → ℝ) (M S : E d) : ℝ := + g M - g S + +/-- Scaled gap `(f(M) - f(S)) / distance^3` of an ordered pair, with the torus distance. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "Count ordered maximum/saddle pairs with 00, and let nu_eld^all(ell) count all finite ordinary superlevel H0 persistence bars, both in expectation per unit volume." +Interface: none. +Does not claim: positivity of the height gap (added separately where the source requires it). -/ +def IsCandidatePair (d : ℕ) (L : ℝ) (g : E d → ℝ) (M S : E d) : Prop := + IsNondegMax d g M ∧ IsIndexSaddle d g S ∧ 0 < torusDist d L M S + +/-- Morse genericity with distinct critical values on the torus: every critical point is +nondegenerate (has some inertia) and critical points at distinct torus positions have +distinct critical values. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "Countable exhaustion now proves that Q is almost surely Morse with distinct critical values." +Interface: none; used only as a hypothesis of the elder-partner interface clause. +Does not claim: that sample paths are almost surely Morse (Section 8 of the source). -/ +def IsMorseDistinct (d : ℕ) (L : ℝ) (g : E d → ℝ) : Prop := + (∀ x : E d, IsCriticalPoint d g x → ∃ j : ℕ, HessianHasInertia d g x j) ∧ + (∀ x y : E d, IsCriticalPoint d g x → IsCriticalPoint d g y → + 0 < torusDist d L x y → g x ≠ g y) + +/-- Interface for the superlevel-set H0 persistence objects used by the lifetime track: +the maximin death height `d_f(M)`, the essential (global-maximum) class, and the ordinary +elder death partner relation. These are GIVEN relations; the fields transcribe the source +clauses that characterise them on smooth periodic functions, and the elder relation is +pinned only on the Morse distinct-value locus, exactly as the source does. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "On the Morse distinct-value locus it expresses ordinary elder death at S; an essential maximum has no older endpoint." +Interface: `deathHeight`, `IsEssential`, `ElderPartner` are given; `deathHeight_maximin`, `essential_iff`, `elderPartner_iff` are their hypothesis clauses. +Does not claim: Borel measurability of the elder event (Section 8 / the Section 9 replacement), identification with a persistence-module elder rule, or any behaviour off the Morse distinct-value locus. -/ +structure SuperlevelBarInterface (d : ℕ) (L : ℝ) where + /-- Section 8 clause: the maximin connection level + `d_f(M)=sup_{gamma(0)=M, f(gamma(1))>f(M)} min_t f(gamma(t))`. -/ + deathHeight : (E d → ℝ) → E d → ℝ + /-- The essential class: the global maximum, which "has no older endpoint" and whose + superlevel H0 bar is not finite. -/ + IsEssential : (E d → ℝ) → E d → Prop + /-- Section 1 clause: "the global ordinary superlevel elder death partner of M is S". -/ + ElderPartner : (E d → ℝ) → E d → E d → Prop + /-- `M` is essential exactly when no point is strictly higher (so the supremum in the + maximin is over an empty set, "equal to -infinity"). -/ + essential_iff : ∀ (g : E d → ℝ), IsSmooth d g → IsLPeriodic d L g → + ∀ M : E d, IsEssential g M ↔ ∀ y : E d, g y ≤ g M + /-- Section 8 maximin clause, in the form `h < d_f(M)` iff some path from `M` to a strictly + higher point stays strictly above `h`. -/ + deathHeight_maximin : ∀ (g : E d → ℝ), IsSmooth d g → IsLPeriodic d L g → + ∀ M : E d, ¬ IsEssential g M → ∀ h : ℝ, + h < deathHeight g M ↔ + ∃ y : E d, g M < g y ∧ ∃ γ : Path M y, ∀ t : unitInterval, h < g (γ t) + /-- Section 8 / Section 14 clause: on the Morse distinct-value locus, "equality + d_f(M)=f(S)" with `M` a nondegenerate maximum and `S` an index-(d-1) saddle "expresses + ordinary elder death at S". -/ + elderPartner_iff : ∀ (g : E d → ℝ), IsSmooth d g → IsLPeriodic d L g → IsMorseDistinct d L g → + ∀ M S : E d, ElderPartner g M S ↔ + (IsNondegMax d g M ∧ IsIndexSaddle d g S ∧ ¬ IsEssential g M ∧ deathHeight g M = g S) + +/-- Finite ordinary superlevel H0 bar, as an ordered pair: a nondegenerate maximum `M` +(birth) with its ordinary elder death partner `S`, an index-(d-1) saddle at positive torus +distance. The essential global-maximum class is excluded because `ElderPartner` requires +`¬ IsEssential` on the Morse locus. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "each finite superlevel H0 bar has exactly one local-maximum birth and one index-(d-1) merging-saddle death." +Interface: `I : SuperlevelBarInterface d L` is given. +Does not claim: the identification of these pairs with bars of a persistence module; that the count of such pairs equals the finite-bar count off the Morse locus. -/ +def IsFiniteBar (d : ℕ) (L : ℝ) (I : SuperlevelBarInterface d L) (g : E d → ℝ) (M S : E d) : Prop := + IsCandidatePair d L g M S ∧ 0 < heightGap d g M S ∧ I.ElderPartner g M S + +/-- The set of pairs of a population `Pair` with both points in the fundamental domain and +lifetime (height gap) in `A`; `Pair g M S` is the membership predicate of the population. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "Let nu_cand(ell) be their expected lifetime density per unit volume; let nu_eld(ell) count only pairs which are actual ordinary elder partners." +Interface: the population predicate `Pair` is a parameter. +Does not claim: finiteness of this set (a field of the density-version predicate). -/ +def pairSet (d : ℕ) (L : ℝ) (Pair : (E d → ℝ) → E d → E d → Prop) (g : E d → ℝ) (A : Set ℝ) : + Set (E d × E d) := + {p | p.1 ∈ FundDomain d L ∧ p.2 ∈ FundDomain d L ∧ Pair g p.1 p.2 ∧ heightGap d g p.1 p.2 ∈ A} + +/-- Number of pairs of the population with lifetime in `A` and base points in the +fundamental domain (`Set.ncard`, which is `0` for an infinite set). + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "Let nu_cand(ell) be their expected lifetime density per unit volume; let nu_eld(ell) count only pairs which are actual ordinary elder partners." +Interface: the population predicate `Pair` is a parameter. +Does not claim: finiteness of the counted set. -/ +noncomputable def pairCount (d : ℕ) (L : ℝ) (Pair : (E d → ℝ) → E d → E d → Prop) + (g : E d → ℝ) (A : Set ℝ) : ℕ := + Set.ncard (pairSet d L Pair g A) + +/-- `ν` is a VERSION of the expected per-unit-volume lifetime density of the population +`Pair` under the field `G`: it is nonnegative and measurable, the pair sets are almost +surely finite with integrable counts, `ν` is integrable on every Borel `A ⊆ (0, ∞)`, and +`∫_A ν = E[#pairs with lifetime in A and base point in [0,L)^d] / L^d` for every such `A`. +The source's densities are only defined up to such versions. The sigma-algebra of the sample +space is brought into scope by the inlined term-level `haveI := G.mΩ` (a square-bracket +field of a bundled record is not registered for typeclass resolution after the declaration). + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "These densities admit versions with" +Interface: the field `G` and the population predicate `Pair` are given; the Kac-Rice representation of the expectation (Sections 9-10 of the source) is NOT used; the density is characterised only by the integral identity. +Does not claim: existence of a version; the weighted Kac-Rice identity; the radial ledger (10.2). Measurability of the pair count as a function of the sample is REQUIRED by the predicate (through `Integrable`, hence `AEStronglyMeasurable`), not established here. -/ +def IsLifetimeDensityVersion (d : ℕ) (L : ℝ) (G : GaussianFieldInterface d L) + (Pair : (E d → ℝ) → E d → E d → Prop) (ν : ℝ → ℝ) : Prop := + haveI := G.mΩ + (∀ ℓ : ℝ, 0 ≤ ν ℓ) ∧ Measurable ν ∧ + (∀ A : Set ℝ, MeasurableSet A → A ⊆ Set.Ioi 0 → + (∀ᵐ ω ∂G.P, (pairSet d L Pair (G.F ω) A).Finite) ∧ + Integrable (fun ω => ((pairCount d L Pair (G.F ω) A : ℕ) : ℝ)) G.P ∧ + IntegrableOn ν A ∧ + ∫ ℓ in A, ν ℓ = (∫ ω, ((pairCount d L Pair (G.F ω) A : ℕ) : ℝ) ∂G.P) / L ^ d) + +/-! ### Populations of pairs -/ + +/-- Compact-window population of Theorem B: ordered maximum / index-(d-1)-saddle pairs with +`0 < distance <= ρ`, birth `f(M)` in `B = [bLo, bHi]` and scaled gap in `K = [kLo, kHi]`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "Count ordered maximum/saddle pairs with 00, and let nu_eld^all(ell) count all finite ordinary superlevel H0 persistence bars, both in expectation per unit volume." +Interface: none beyond the shared predicates. +Does not claim: anything about the off-diagonal (far) population separately (Section 14 of the source). -/ +def IsUnrestrictedPair (d : ℕ) (L : ℝ) (g : E d → ℝ) (M S : E d) : Prop := + IsCandidatePair d L g M S ∧ 0 < heightGap d g M S + +/-! ### The typed pair law as an interface -/ + +/-- Interface for the weighted regression (typed pair) law: the only object consumed by the +statements is the probability `p_r(b,k,R)` that the global ordinary superlevel elder death +partner of the pinned maximum `M = -(r/2)u` is the pinned saddle `S = (r/2)u`, under the +law `Q^W = (W_r/Z_r) Q_{r,b,k,R}` with `W_r = |det H_M det H_S| 1{H_M<0, index(H_S)=d-1}`. +That law, its weight, its normalizer and the regression construction are informal in the +source and are NOT transcribed; `p` is a GIVEN function of radius `r`, birth `b`, gap mark +`k` and orthonormal frame `R` with values in `[0, 1]`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "Let p_r(b,k,R) be the Q^W probability that the **global ordinary superlevel elder death partner** of M is S." +Interface: `p` is given; its only hypothesis fields are the bounds `0 ≤ p ≤ 1`. The parameters `G` and `I` record which field and which elder relation the law refers to; no field ties `p` to them. +Does not claim: existence of the regression law, the typed weight, the full normalizer `Z_r > 0`, or that `p` is the probability of any event under any measure declared here; that `p` depends on `G` or `I` in any way (no field mentions them; they only record which field and elder relation the law is meant to refer to). -/ +structure PairLawInterface (d : ℕ) (L : ℝ) (G : GaussianFieldInterface d L) + (I : SuperlevelBarInterface d L) where + /-- Section 1 clause: "Let p_r(b,k,R) be the Q^W probability that the global ordinary + superlevel elder death partner of M is S." -/ + p : ℝ → ℝ → ℝ → OrthonormalBasis (Fin d) ℝ (E d) → ℝ + /-- `p` is a probability: nonnegative. -/ + p_nonneg : ∀ (r b k : ℝ) (R : OrthonormalBasis (Fin d) ℝ (E d)), 0 ≤ p r b k R + /-- `p` is a probability: at most one. -/ + p_le_one : ∀ (r b k : ℝ) (R : OrthonormalBasis (Fin d) ℝ (E d)), p r b k R ≤ 1 + +/-! ### The parent statements (1.1), (1.2), (1.3) -/ + +/-- Shape of Theorem A (1.1), uniform selection candidate: for fixed `d ≥ 2`, `L > 0`, +compact `B = [bLo, bHi]` and `K = [kLo, kHi]` with `0 < kLo ≤ kHi`, there exist `r_* > 0` +and `C` (quantified OUTSIDE the universal quantifiers over `r`, `b`, `k` and the frame) +such that `0 <= 1 - p_r(b,k,R) <= C r^3` for all `0 < r ≤ r_*`, `b ∈ B`, `k ∈ K` and all +orthonormal frames `R`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "There exist r_*>0 and C 0` and +windows `B`, `K` of positive length with `kLo > 0`, there are a distance cutoff `r_* > 0`, a +constant `c_{B,K} > 0` and a constant `C_{B,K}` such that the compact-window candidate and +elder lifetime densities admit versions `νc`, `νe` with `νc(ℓ) ~ c_{B,K} ℓ^(-1/3)`, +`νe(ℓ) ~ c_{B,K} ℓ^(-1/3)` as `ℓ ↓ 0` (filter `nhdsWithin 0 (Set.Ioi 0)`) and +`0 ≤ νc(ℓ) - νe(ℓ) ≤ C_{B,K} ℓ^(2/3)` for all sufficiently small `ℓ > 0`. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "0 <= nu_cand(ell)-nu_eld(ell) <= C_{B,K} ell^(2/3)," +Interface: `G` and `I` are given; "versions" are any `νc`, `νe` satisfying `IsLifetimeDensityVersion` (integral identity), not a Kac-Rice representation; the coefficient `c_{B,K}` is existential, not the Gaussian integral (11.3). +Does not claim: the parent result or its proof; the exact coefficient formula (11.3); existence of the versions; that the cutoff `r_*` is the one of (1.1); any numerical constant; nonauthor review or acceptance. -/ +def ParentCompactWindowDensityB (d : ℕ) (L : ℝ) (G : GaussianFieldInterface d L) + (I : SuperlevelBarInterface d L) (bLo bHi kLo kHi : ℝ) : Prop := + 2 ≤ d → 0 < L → bLo < bHi → 0 < kLo → kLo < kHi → + ∃ rStar : ℝ, 0 < rStar ∧ ∃ c : ℝ, 0 < c ∧ ∃ C : ℝ, ∃ νc νe : ℝ → ℝ, + IsLifetimeDensityVersion d L G (IsWindowPair d L rStar bLo bHi kLo kHi) νc ∧ + IsLifetimeDensityVersion d L G (IsWindowElderPair d L rStar bLo bHi kLo kHi I) νe ∧ + Asymptotics.IsEquivalent (nhdsWithin (0 : ℝ) (Set.Ioi 0)) νc + (fun ℓ : ℝ => c * ℓ ^ ((-1 : ℝ) / 3)) ∧ + Asymptotics.IsEquivalent (nhdsWithin (0 : ℝ) (Set.Ioi 0)) νe + (fun ℓ : ℝ => c * ℓ ^ ((-1 : ℝ) / 3)) ∧ + ∃ ℓStar : ℝ, 0 < ℓStar ∧ ∀ ℓ : ℝ, 0 < ℓ → ℓ ≤ ℓStar → + 0 ≤ νc ℓ - νe ℓ ∧ νc ℓ - νe ℓ ≤ C * ℓ ^ ((2 : ℝ) / 3) + +/-- `c` is a leading coefficient of the unrestricted finite-lifetime densities: `c > 0` and +versions `νc`, `νe` of the unrestricted candidate density and of the finite ordinary +superlevel H0 bar density satisfy `νc(ℓ) ~ c ℓ^(-1/3)` and `νe(ℓ) ~ c ℓ^(-1/3)` as `ℓ ↓ 0`. +The essential global-maximum class is excluded from `νe` through `IsFiniteBar`. This is the +conclusion of (1.3) for a given `c`; it characterises `c_{d,L}` by its leading-term role, +not by the integral (13.6)/(15.2). + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "There is a positive finite constant c_{d,L} such that" +Interface: `G` and `I` are given; versions are characterised by the integral identity only. +Does not claim: the explicit Gaussian/angular representation (15.2) of `c_{d,L}`; uniqueness of `c` (which follows from the asymptotics but is not stated); existence of versions. -/ +def IsUnrestrictedLeadingCoefficient (d : ℕ) (L : ℝ) (G : GaussianFieldInterface d L) + (I : SuperlevelBarInterface d L) (c : ℝ) : Prop := + 0 < c ∧ ∃ νc νe : ℝ → ℝ, + IsLifetimeDensityVersion d L G (IsUnrestrictedPair d L) νc ∧ + IsLifetimeDensityVersion d L G (IsFiniteBar d L I) νe ∧ + Asymptotics.IsEquivalent (nhdsWithin (0 : ℝ) (Set.Ioi 0)) νc + (fun ℓ : ℝ => c * ℓ ^ ((-1 : ℝ) / 3)) ∧ + Asymptotics.IsEquivalent (nhdsWithin (0 : ℝ) (Set.Ioi 0)) νe + (fun ℓ : ℝ => c * ℓ ^ ((-1 : ℝ) / 3)) + +/-- Shape of Theorem C (1.3), unrestricted finite-lifetime leading density candidate: for +fixed `d ≥ 2` and `L > 0` there is a positive finite constant `c_{d,L}` such that the +unrestricted candidate density and the finite ordinary superlevel H0 bar density (all birth +heights, all positive gap marks, all separations; essential global maximum excluded) admit +versions with `ν(ℓ) ~ c_{d,L} ℓ^(-1/3)` as `ℓ ↓ 0`. Leading term only. + +Source: d6g8k5htny-coder/Math- commit c39164254ad1529ed49543743598d5dcb24bab98 path imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md sha256 9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7 +Anchor: "nu_cand^all(ell) ~ c_{d,L} ell^(-1/3)," +Interface: `G` and `I` are given; versions are characterised by the integral identity only. +Does not claim: the parent result or its proof (dominated convergence of Section 13, off-diagonal bound (14.1)); the representation (15.2); the compact-window `O(ell^(2/3))` difference for the unrestricted densities; any numerical enclosure of `c_{d,L}` (the SIDE24 coefficient track is separate); nonauthor review or acceptance. -/ +def ParentUnrestrictedLeadingDensityC (d : ℕ) (L : ℝ) (G : GaussianFieldInterface d L) + (I : SuperlevelBarInterface d L) : Prop := + 2 ≤ d → 0 < L → ∃ c : ℝ, IsUnrestrictedLeadingCoefficient d L G I c + +/-! ### The bounded remainder (R1) -/ + +/-- Shape of Theorem R (R1), bounded unrestricted short-lifetime remainder: for fixed +`d ≥ 2`, `L > 0` and with `c = c_{d,L}` the parent leading coefficient (characterised here +by `IsUnrestrictedLeadingCoefficient`), there are `ell_* > 0` and `C` such that versions of +the unrestricted candidate and finite-bar densities satisfy, for `0 < ℓ ≤ ell_*`, +`|νc(ℓ) - c ℓ^(-1/3)| ≤ C`, `0 ≤ νc(ℓ) - νe(ℓ) ≤ C` and `|νe(ℓ) - c ℓ^(-1/3)| ≤ C`. +The `O(1)` remainder is stated with an explicit absolute-value bound. + +Source: d6g8k5htny-coder/Math- commit 760340e921ac4ceda296b8118da936f1133e956e path frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md sha256 380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a +Anchor: "|nu_cand(ell)-c ell^(-1/3)| <= C," +Interface: `G` and `I` are given; `c` is any real satisfying the parent leading-coefficient property (the source says the coefficient "is exactly the parent's equation (15.2)"; that integral is not transcribed, so `c` is pinned through (1.3) instead); versions are characterised by the integral identity only. The statement does not mention the typed pair law: Theorem R does not consume (1.1). +Does not claim: the result or its proof (quadratic determinant cancellation (R7), coupling (R4), cap-loss bound (R12)); convergence of the remainder; a second coefficient; numerical `C` or `ell_*`; the compact-window `O(ell^(2/3))` difference without cutoffs; the parent interfaces it imports (D1-A-E); nonauthor review or acceptance. If no `c` satisfies the parent property the statement holds vacuously; that is a transcription of its dependency on (1.3), not a claim. -/ +def RemainderBoundedR1 (d : ℕ) (L : ℝ) (G : GaussianFieldInterface d L) + (I : SuperlevelBarInterface d L) : Prop := + 2 ≤ d → 0 < L → ∀ c : ℝ, IsUnrestrictedLeadingCoefficient d L G I c → + ∃ ℓStar : ℝ, 0 < ℓStar ∧ ∃ C : ℝ, ∃ νc νe : ℝ → ℝ, + IsLifetimeDensityVersion d L G (IsUnrestrictedPair d L) νc ∧ + IsLifetimeDensityVersion d L G (IsFiniteBar d L I) νe ∧ + ∀ ℓ : ℝ, 0 < ℓ → ℓ ≤ ℓStar → + |νc ℓ - c * ℓ ^ ((-1 : ℝ) / 3)| ≤ C ∧ + 0 ≤ νc ℓ - νe ℓ ∧ νc ℓ - νe ℓ ≤ C ∧ + |νe ℓ - c * ℓ ^ ((-1 : ℝ) / 3)| ≤ C + +/-! ### Planar elder lower bound and density gap (d = 2) -/ + +/-- Shape of the planar direct lower bound (E2): on the fixed planar torus (`d = 2`), with +birth `b` in a fixed compact interval, `k ∈ [kLo, kHi]` with `kLo > 0` and frames ranging +over `O(2)`, there are `c > 0` and `r_* > 0` such that `1 - p_r(b,k,R) ≥ c r^3` for all +`0 < r ≤ r_*`, uniformly in `b`, `k` and the frame. + +Source: d6g8k5htny-coder/Math- commit 6c020d6a72936632f2055122e71a7818a4ff497e path frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md sha256 8ce05a43bde8e0d718f09e2da1ffe75d3ec5893489254afdbf5b58b602cdba0c +Anchor: "1-p_r(b,k,R) >= c r^3, 0 0` there are a distance cutoff +`r_* > 0`, constants `c_{B,K} > 0`, `C_{B,K}` and `ell_* > 0` such that versions of the +compact-window candidate and ordinary elder densities satisfy +`c_{B,K} ℓ^(2/3) ≤ νc(ℓ) - νe(ℓ) ≤ C_{B,K} ℓ^(2/3)` for all `0 < ℓ ≤ ell_*`. The parent upper +input is an explicit hypothesis, not folded into the conclusion. The lower half, which the +source derives from (E2) alone, is stated under the same hypothesis because the source displays +(E11) as one two-sided inequality; that is a hypothesis the source does not need for the lower +half, recorded here as such. + +Source: d6g8k5htny-coder/Math- commit 6c020d6a72936632f2055122e71a7818a4ff497e path frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md sha256 8ce05a43bde8e0d718f09e2da1ffe75d3ec5893489254afdbf5b58b602cdba0c +Anchor: " <= C_{B,K} ell^(2/3). (E11)" +Interface: `G`, `I` and `PL` are given; the hypothesis `ParentUniformSelectionA 2 L G I PL bLo bHi kLo kHi` is the consumed parent upper input (a statement shape, not the parent result); versions are characterised by the integral identity only; the weighted Kac-Rice / radial ledger of [LP, Sections 9-11] that the source consumes is not transcribed. The interface does not determine `p` or the field: the Prop is a predicate on the interface objects, not a closed statement about the source's objects; nothing is asserted about its universal closure over all inhabitants, and `specified` refers to the statement shape at the source's object, which is not constructed. +Does not claim: the result or its proof; the upper half independently of the parent (1.1); the parent (1.1) itself; the lower half without the hypothesis (the source has it from (E2) alone); sharpness of the `O(1)` remainder of (R1); removal of the compact-mark restriction; that the cutoff `r_*` is the one of (1.1); any numerical constant; nonauthor review or acceptance. -/ +def PlanarDensityGapE11 (L : ℝ) (G : GaussianFieldInterface 2 L) (I : SuperlevelBarInterface 2 L) + (PL : PairLawInterface 2 L G I) (bLo bHi kLo kHi : ℝ) : Prop := + ParentUniformSelectionA 2 L G I PL bLo bHi kLo kHi → + (0 < L → bLo < bHi → 0 < kLo → kLo < kHi → + ∃ rStar : ℝ, 0 < rStar ∧ ∃ c : ℝ, 0 < c ∧ ∃ C : ℝ, ∃ ℓStar : ℝ, 0 < ℓStar ∧ + ∃ νc νe : ℝ → ℝ, + IsLifetimeDensityVersion 2 L G (IsWindowPair 2 L rStar bLo bHi kLo kHi) νc ∧ + IsLifetimeDensityVersion 2 L G (IsWindowElderPair 2 L rStar bLo bHi kLo kHi I) νe ∧ + ∀ ℓ : ℝ, 0 < ℓ → ℓ ≤ ℓStar → + c * ℓ ^ ((2 : ℝ) / 3) ≤ νc ℓ - νe ℓ ∧ νc ℓ - νe ℓ ≤ C * ℓ ^ ((2 : ℝ) / 3)) + +end UniversalLaw.Spec.Lifetime diff --git a/frontiers/critical_level_attainment_20261020/final-project/MorseFiniteCritical.lean b/frontiers/critical_level_attainment_20261020/final-project/MorseFiniteCritical.lean new file mode 100644 index 000000000..989fabc6e --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-project/MorseFiniteCritical.lean @@ -0,0 +1,223 @@ +import Lifetime +import TorusTopology + +/-! +# Finite literal critical set on the actual period-lattice quotient + +C293: deterministic formal composition of the finite-critical-set step of C292. +The inputs below are the literal Lifetime predicates and C263 torus projection. +No finite event list, inverse certificate, Morse normal form or closed-level path +is supplied as a hypothesis. +-/ + +noncomputable section + +open Set Topology +open UniversalLaw.Spec.Lifetime +open TorusFiltration + +namespace TorusMorseFinite + +theorem literal_hessian_eq_fderiv {d : ℕ} (g : E d → ℝ) + (x v w : E d) : + hessian d g x v w = fderiv ℝ (fderiv ℝ g) x v w := by + simp [hessian, iteratedFDeriv_two_apply] + +theorem literal_hessian_symmetric {d : ℕ} {g : E d → ℝ} + (hsmooth : IsSmooth d g) (x v w : E d) : + hessian d g x v w = hessian d g x w v := by + rw [literal_hessian_eq_fderiv, literal_hessian_eq_fderiv] + exact ((hsmooth 2).contDiffAt.isSymmSndFDerivAt (by simp)).eq v w + +theorem inertia_fderiv_injective {d : ℕ} {g : E d → ℝ} + (hsmooth : IsSmooth d g) {x : E d} {j : ℕ} + (hinertia : HessianHasInertia d g x j) : + Function.Injective (fderiv ℝ (fderiv ℝ g) x) := by + let B := fderiv ℝ (fderiv ℝ g) x + have hz : ∀ z : E d, B z = 0 → z = 0 := by + intro z hzero + obtain ⟨V, W, hcompl, _, _, hneg, hpos⟩ := hinertia + obtain ⟨v, w, hv, hw, hvw⟩ := + Submodule.codisjoint_iff_exists_add_eq.mp hcompl.codisjoint z + have hBv : B v v + B w v = 0 := by + have h := congrArg (fun A : E d →L[ℝ] ℝ => A v) hzero + simpa only [← hvw, map_add, add_apply, zero_apply] using h + have hBw : B v w + B w w = 0 := by + have h := congrArg (fun A : E d →L[ℝ] ℝ => A w) hzero + simpa only [← hvw, map_add, add_apply, zero_apply] using h + have hsym : B w v = B v w := by + simpa only [B, ← literal_hessian_eq_fderiv] using + literal_hessian_symmetric hsmooth x w v + have heq : hessian d g x v v = hessian d g x w w := by + simp only [literal_hessian_eq_fderiv] + change B v v = B w w + linarith + have hv0 : v = 0 := by + by_contra hv0 + have hn := hneg v hv hv0 + by_cases hw0 : w = 0 + · have hww : hessian d g x w w = 0 := by + simp [hw0, literal_hessian_eq_fderiv] + linarith + · have hp := hpos w hw hw0 + linarith + have hw0 : w = 0 := by + by_contra hw0 + have hp := hpos w hw hw0 + have hvv : hessian d g x v v = 0 := by + simp [hv0, literal_hessian_eq_fderiv] + linarith + simpa [hv0, hw0] using hvw.symm + intro u v huv + have hzero : B (u - v) = 0 := by simp [map_sub, huv, B] + exact sub_eq_zero.mp (hz (u - v) hzero) + +theorem inertia_fderiv_equiv {d : ℕ} {g : E d → ℝ} + (hsmooth : IsSmooth d g) {x : E d} {j : ℕ} + (hinertia : HessianHasInertia d g x j) : + ∃ e : E d ≃L[ℝ] (E d →L[ℝ] ℝ), + (e : E d →L[ℝ] (E d →L[ℝ] ℝ)) = fderiv ℝ (fderiv ℝ g) x := by + let J : E d ≃L[ℝ] (E d →L[ℝ] ℝ) := + (InnerProductSpace.toDual ℝ (E d)).toContinuousLinearEquiv + let B := fderiv ℝ (fderiv ℝ g) x + let A : E d →L[ℝ] E d := J.symm.toContinuousLinearMap.comp B + have hA : Function.Injective A := + J.symm.injective.comp (inertia_fderiv_injective hsmooth hinertia) + let eA : E d ≃L[ℝ] E d := + (LinearEquiv.ofInjectiveEndo A.toLinearMap hA).toContinuousLinearEquiv + refine ⟨eA.trans J, ?_⟩ + apply ContinuousLinearMap.ext + intro v + change J (J.symm (B v)) = B v + exact J.apply_symm_apply (B v) + +theorem literal_critical_isolated {d : ℕ} {g : E d → ℝ} + (hsmooth : IsSmooth d g) {x : E d} + (hcritical : IsCriticalPoint d g x) {j : ℕ} + (hinertia : HessianHasInertia d g x j) : + ∃ U : Set (E d), IsOpen U ∧ x ∈ U ∧ + ∀ y ∈ U, IsCriticalPoint d g y → y = x := by + obtain ⟨e, he⟩ := inertia_fderiv_equiv hsmooth hinertia + have hD : ContDiff ℝ 1 (fderiv ℝ g) := + (contDiff_succ_iff_fderiv.mp (hsmooth 2)).2.2 + have hderiv : HasFDerivAt (fderiv ℝ g) + (e : E d →L[ℝ] (E d →L[ℝ] ℝ)) x := by + rw [he] + exact (hD.differentiable (by norm_num) x).hasFDerivAt + let p := hD.contDiffAt.toOpenPartialHomeomorph (fderiv ℝ g) hderiv (by norm_num) + have hxp : x ∈ p.source := + hD.contDiffAt.mem_toOpenPartialHomeomorph_source hderiv (by norm_num) + refine ⟨p.source, p.open_source, hxp, ?_⟩ + intro y hy hcy + apply p.injOn hy hxp + change fderiv ℝ g y = fderiv ℝ g x + exact hcy.trans hcritical.symm + +theorem literal_fderiv_periodic {d : ℕ} {L : ℝ} {g : E d → ℝ} + (hperiodic : IsLPeriodic d L g) (x : E d) (k : Fin d → ℤ) : + fderiv ℝ g (x + torus_latticeVec d L k) = fderiv ℝ g x := by + have heq : (fun y : E d => g (y + torus_latticeVec d L k)) = g := by + funext y + simpa only [torus_latticeVec, latticeVec] using hperiodic y k + rw [← fderiv_comp_add_right, heq] + +theorem literal_fderiv_respects {d : ℕ} {L : ℝ} (hL : 0 < L) + {g : E d → ℝ} (hperiodic : IsLPeriodic d L g) (x y : E d) + (hxy : QuotientAddGroup.leftRel (torus_periodLattice d L hL).toAddSubgroup x y) : + fderiv ℝ g x = fderiv ℝ g y := by + have hq : torus_proj d L hL x = torus_proj d L hL y := Quotient.sound hxy + obtain ⟨k, rfl⟩ := (torus_proj_eq_iff d L hL x y).mp hq + exact (literal_fderiv_periodic hperiodic x k).symm + +def quotientDerivative (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : E d → ℝ) (hperiodic : IsLPeriodic d L g) : + torus_quotient d L hL → (E d →L[ℝ] ℝ) := + Quotient.lift (fderiv ℝ g) (literal_fderiv_respects hL hperiodic) + +@[simp] theorem quotientDerivative_proj (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : E d → ℝ) (hperiodic : IsLPeriodic d L g) (x : E d) : + quotientDerivative d L hL g hperiodic (torus_proj d L hL x) = + fderiv ℝ g x := rfl + +theorem quotientDerivative_continuous {d : ℕ} {L : ℝ} (hL : 0 < L) + {g : E d → ℝ} (hperiodic : IsLPeriodic d L g) + (hsmooth : IsSmooth d g) : + Continuous (quotientDerivative d L hL g hperiodic) := + ((hsmooth 1).continuous_fderiv (by norm_num)).quotient_lift + (literal_fderiv_respects hL hperiodic) + +/-- The full image of all literal critical points, on C263's actual quotient. -/ +def quotientCriticalSet (d : ℕ) (L : ℝ) (hL : 0 < L) (g : E d → ℝ) : + Set (torus_quotient d L hL) := + torus_proj d L hL '' {x : E d | IsCriticalPoint d g x} + +theorem mem_quotientCriticalSet_iff {d : ℕ} {L : ℝ} (hL : 0 < L) + {g : E d → ℝ} (hperiodic : IsLPeriodic d L g) + (q : torus_quotient d L hL) : + q ∈ quotientCriticalSet d L hL g ↔ + quotientDerivative d L hL g hperiodic q = 0 := by + constructor + · rintro ⟨x, hx, rfl⟩ + exact hx + · intro hq + obtain ⟨x, rfl⟩ := torus_proj_surjective d L hL q + exact ⟨x, hq, rfl⟩ + +theorem quotientCriticalSet_closed {d : ℕ} {L : ℝ} (hL : 0 < L) + {g : E d → ℝ} (hperiodic : IsLPeriodic d L g) + (hsmooth : IsSmooth d g) : + IsClosed (quotientCriticalSet d L hL g) := by + have heq : quotientCriticalSet d L hL g = + {q | quotientDerivative d L hL g hperiodic q = 0} := by + ext q + exact mem_quotientCriticalSet_iff hL hperiodic q + rw [heq] + exact isClosed_eq (quotientDerivative_continuous hL hperiodic hsmooth) continuous_const + +theorem quotientCriticalSet_discrete {d : ℕ} {L : ℝ} (hL : 0 < L) + {g : E d → ℝ} (hperiodic : IsLPeriodic d L g) + (hsmooth : IsSmooth d g) + (hmorse : ∀ x : E d, IsCriticalPoint d g x → + ∃ j : ℕ, HessianHasInertia d g x j) : + IsDiscrete (quotientCriticalSet d L hL g) := by + rw [isDiscrete_iff_forall_mem_exists_isOpen] + rintro q ⟨x, hx, rfl⟩ + obtain ⟨j, hj⟩ := hmorse x hx + obtain ⟨U, hU, hxU, hiso⟩ := literal_critical_isolated hsmooth hx hj + refine ⟨torus_proj d L hL '' U, + (torus_proj_isCoveringMap d L hL).isOpenMap U hU, ?_⟩ + ext q + constructor + · rintro ⟨⟨y, hy, rfl⟩, hcy⟩ + have hyc : IsCriticalPoint d g y := + (mem_quotientCriticalSet_iff hL hperiodic _).mp hcy + have hyx := hiso y hy hyc + simp [hyx] + · intro hq + have hqx := Set.mem_singleton_iff.mp hq + subst q + exact ⟨⟨x, hxU, rfl⟩, ⟨x, hx, rfl⟩⟩ + +/-- Core finiteness only needs nondegeneracy at critical points; distinct heights +are not used. No finiteness conclusion is supplied in the assumptions. -/ +theorem quotientCriticalSet_finite_of_inertia {d : ℕ} {L : ℝ} (hL : 0 < L) + {g : E d → ℝ} (hsmooth : IsSmooth d g) + (hperiodic : IsLPeriodic d L g) + (hmorse : ∀ x : E d, IsCriticalPoint d g x → + ∃ j : ℕ, HessianHasInertia d g x j) : + (quotientCriticalSet d L hL g).Finite := by + have hc : IsCompact (quotientCriticalSet d L hL g) := by + simpa only [Set.univ_inter] using + (torus_compact d L hL).inter_right + (quotientCriticalSet_closed hL hperiodic hsmooth) + exact hc.finite (quotientCriticalSet_discrete hL hperiodic hsmooth hmorse) + +/-- C292-facing theorem on the literal Morse-distinct locus. The result in fact +holds for every natural dimension; C292 may instantiate it at its `d ≥ 1`. -/ +theorem quotientCriticalSet_finite (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : E d → ℝ) (hsmooth : IsSmooth d g) + (hperiodic : IsLPeriodic d L g) (hmorse : IsMorseDistinct d L g) : + (quotientCriticalSet d L hL g).Finite := + quotientCriticalSet_finite_of_inertia hL hsmooth hperiodic hmorse.1 + +end TorusMorseFinite diff --git a/frontiers/critical_level_attainment_20261020/final-project/SuperlevelBar.lean b/frontiers/critical_level_attainment_20261020/final-project/SuperlevelBar.lean new file mode 100644 index 000000000..b047384e2 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-project/SuperlevelBar.lean @@ -0,0 +1,299 @@ +import Mathlib + +/-! +# C263 total strict-clearance cut for continuous Euclidean heights + +Proves: total essentiality, strict-clearance set and real death value with an +explicit empty-set value zero; an unconditional bound for clearance members; +nonemptiness for continuous nonessential inputs; strict witness improvement; +the exact strict supremum cut, guarded death bound and cut uniqueness. + +Method: the starting endpoint bounds every clearance; a straight path and the +attained minimum on its compact unit-interval parameter supply a lower witness +and a uniform strict margin; conditional real supremum laws identify the cut. + +Does not establish: an inhabitant of the separately owned Field or Lifetime +record, an elder relation, Morse endpoint attainment, ordinary H0 bar pairing, +finite-bar counts, a Gaussian field or weighted law, or scientific acceptance. +The scalar zero on an empty set is a default, not an essential-bar death. + +Authored by OpenAI/Codex c262_lean_source_review, now acting as C263 implementer, +delegated for Dylan Roy. Source/design-exposed; organizational independence 0; +no human review. Consumes C260 prose SHA-256 +d2462639df32364e6fc8b0fea0703106c668cedb0aa7bb00e139aa81561bd845. +Target pin: Lean 4.34.1 / Mathlib d13f23b723b8a846827a245b89c10fc7d3f11612. +Elaboration, kernel audit and executed controls are recorded in separate +source-bound receipts; this text makes no execution claim. + +Compile fix at the pin (Anthropic/Claude lane, companion owner; handoff bytes +SHA-256 d74dc8b2c25eff5b90ce7133e51a0888c7885cae24ca6d5e648bc514089637a8 did not +elaborate with `-DwarningAsError=true`): in `superlevelBar_death_eq_sSup_of_nonempty` +the simp lemma `if_pos` (deprecated in Lean core since 2026-07-21) is replaced by +its successor `ite_eq_left`, the same statement; no other byte changes. +-/ + +noncomputable section + +namespace TorusFiltration + +/-- Proves: the ambient type is real Euclidean space in the stated dimension. +Method: a type abbreviation. Does not establish: a positive-dimensional or +periodic quotient-space hypothesis. -/ +abbrev superlevelBar_E (d : ℕ) := EuclideanSpace ℝ (Fin d) + +/-- Proves: the essentiality datum is total. Method: global order comparison. +Does not establish: an actual persistence interpretation off the guarded locus. -/ +def superlevelBar_isEssential {d : ℕ} (g : superlevelBar_E d → ℝ) + (M : superlevelBar_E d) : Prop := + ∀ y, g y ≤ g M + +/-- Proves: a total strict-clearance set with the source's existential endpoint. +Method: quantify over actual paths and every parameter, including endpoints. +Does not establish: a path attaining the supremum with closed inequalities. -/ +def superlevelBar_clearanceSet {d : ℕ} (g : superlevelBar_E d → ℝ) + (M : superlevelBar_E d) : Set ℝ := + {h | ∃ y, g M < g y ∧ ∃ γ : Path M y, ∀ t : unitInterval, h < g (γ t)} + +/-- Proves: the death datum is a total real number with explicit empty default. +Method: nonempty conditional supremum; boundedness is proved below. +Does not establish: a finite death for an essential class. -/ +def superlevelBar_deathHeight {d : ℕ} (g : superlevelBar_E d → ℝ) + (M : superlevelBar_E d) : ℝ := by + classical + exact if (superlevelBar_clearanceSet g M).Nonempty then + sSup (superlevelBar_clearanceSet g M) else 0 + +/-- Proves: essentiality is exactly global maximality for these total data. +Method: unfold the defining proposition. Does not establish: agreement with +an independently defined essential persistence class. -/ +theorem superlevelBar_essential_iff {d : ℕ} (g : superlevelBar_E d → ℝ) + (M : superlevelBar_E d) : + superlevelBar_isEssential g M ↔ ∀ y, g y ≤ g M := Iff.rfl + +/-- Proves: an unconditional strict bound on each clearance member. +Method: evaluate its path at zero. Does not establish: an unconditional bound +on the default death value when the clearance set is empty. -/ +theorem superlevelBar_mem_lt_start {d : ℕ} (g : superlevelBar_E d → ℝ) + (M : superlevelBar_E d) {h : ℝ} (hh : h ∈ superlevelBar_clearanceSet g M) : + h < g M := by + obtain ⟨y, hy, γ, hγ⟩ := hh + have hzero := hγ (0 : unitInterval) + simpa only [γ.source] using hzero + +/-- Proves: the clearance set is bounded above, including when empty. +Method: the initial height bounds each member. Does not establish: that the +empty-set default death value obeys the same bound. -/ +theorem superlevelBar_clearance_bddAbove {d : ℕ} (g : superlevelBar_E d → ℝ) + (M : superlevelBar_E d) : BddAbove (superlevelBar_clearanceSet g M) := by + exact ⟨g M, fun h hh => (superlevelBar_mem_lt_start g M hh).le⟩ + +/-- Proves: essentiality forces the clearance set to be empty. +Method: contradict the required strictly higher endpoint. +Does not establish: a converse for arbitrary discontinuous heights. -/ +theorem superlevelBar_clearance_empty_of_essential {d : ℕ} + (g : superlevelBar_E d → ℝ) (M : superlevelBar_E d) + (hM : superlevelBar_isEssential g M) : superlevelBar_clearanceSet g M = ∅ := by + ext h + constructor + · rintro ⟨y, hy, γ, hγ⟩ + exact False.elim ((not_lt_of_ge (hM y)) hy) + · intro hh + exact False.elim hh + +/-- Proves: an empty clearance set selects the declared real value zero. +Method: simplify the conditional definition. Does not establish: a geometric +death event or finite persistence interval at that zero. -/ +theorem superlevelBar_death_eq_zero_of_empty {d : ℕ} + (g : superlevelBar_E d → ℝ) (M : superlevelBar_E d) + (he : superlevelBar_clearanceSet g M = ∅) : superlevelBar_deathHeight g M = 0 := by + classical + simp [superlevelBar_deathHeight, he] + +/-- Proves: essential inputs have the declared zero default. +Method: essentiality implies empty clearance, then use the empty branch. +Does not establish: an essential-bar death height. -/ +theorem superlevelBar_death_eq_zero_of_essential {d : ℕ} + (g : superlevelBar_E d → ℝ) (M : superlevelBar_E d) + (hM : superlevelBar_isEssential g M) : superlevelBar_deathHeight g M = 0 := by + exact superlevelBar_death_eq_zero_of_empty g M + (superlevelBar_clearance_empty_of_essential g M hM) + +/-- Proves: nonempty clearance selects its real supremum in the total data. +Method: simplify the nonempty conditional branch. Does not establish: +nonemptiness without a witness or a regularity hypothesis. -/ +theorem superlevelBar_death_eq_sSup_of_nonempty {d : ℕ} + (g : superlevelBar_E d → ℝ) (M : superlevelBar_E d) + (hne : (superlevelBar_clearanceSet g M).Nonempty) : + superlevelBar_deathHeight g M = sSup (superlevelBar_clearanceSet g M) := by + classical + simp only [superlevelBar_deathHeight, ite_eq_left hne] + +/-- Proves: a continuous height attains a minimum along each actual path. +Method: compact unit interval and the extreme-value theorem. +Does not establish: a minimum over all paths or an optimal path. -/ +theorem superlevelBar_path_minimum {d : ℕ} (g : superlevelBar_E d → ℝ) + (hg : Continuous g) {M y : superlevelBar_E d} (γ : Path M y) : + ∃ t₀ : unitInterval, ∀ t : unitInterval, g (γ t₀) ≤ g (γ t) := by + obtain ⟨t₀, ht₀, hmin⟩ := + (isCompact_univ : IsCompact (Set.univ : Set unitInterval)).exists_isMinOn + (show (Set.univ : Set unitInterval).Nonempty from ⟨0, Set.mem_univ _⟩) + (hg.comp γ.continuous).continuousOn + exact ⟨t₀, fun t => hmin (Set.mem_univ t)⟩ + +/-- Proves: nonessential continuous inputs have a nonempty clearance set. +Method: a higher endpoint, Path.segment, and minimum minus one. +Does not establish: compactness of the whole Euclidean domain. -/ +theorem superlevelBar_clearance_nonempty {d : ℕ} (g : superlevelBar_E d → ℝ) + (hg : Continuous g) (M : superlevelBar_E d) + (hM : ¬ superlevelBar_isEssential g M) : + (superlevelBar_clearanceSet g M).Nonempty := by + classical + have hhigh : ∃ y, g M < g y := by + by_contra hn + apply hM + intro y + exact le_of_not_gt (fun hy => hn ⟨y, hy⟩) + obtain ⟨y, hy⟩ := hhigh + let γ : Path M y := Path.segment M y + obtain ⟨t₀, hmin⟩ := superlevelBar_path_minimum g hg γ + refine ⟨g (γ t₀) - 1, y, hy, γ, ?_⟩ + intro t + have ht := hmin t + linarith + +/-- Proves: for continuous heights, clearance is nonempty exactly off the +essential locus. Method: the higher witness endpoint and the straight-path +construction. Does not establish: this equivalence without continuity. -/ +theorem superlevelBar_clearance_nonempty_iff {d : ℕ} + (g : superlevelBar_E d → ℝ) (hg : Continuous g) (M : superlevelBar_E d) : + (superlevelBar_clearanceSet g M).Nonempty ↔ ¬ superlevelBar_isEssential g M := by + constructor + · rintro ⟨h, y, hy, γ, hγ⟩ hM + exact (not_lt_of_ge (hM y)) hy + · exact superlevelBar_clearance_nonempty g hg M + +/-- Proves: any smaller threshold than an existing clearance is a clearance. +Method: reuse the same endpoint and path and compose strict inequalities. +Does not establish: strict improvement to a larger threshold. -/ +theorem superlevelBar_clearance_downward {d : ℕ} (g : superlevelBar_E d → ℝ) + (M : superlevelBar_E d) {h c : ℝ} (hhc : h < c) + (hc : c ∈ superlevelBar_clearanceSet g M) : h ∈ superlevelBar_clearanceSet g M := by + obtain ⟨y, hy, γ, hγ⟩ := hc + exact ⟨y, hy, γ, fun t => hhc.trans (hγ t)⟩ + +/-- Proves: each strict witness has a larger strict witness on its same path. +Method: attained minimum and a midpoint below it. +Does not establish: a witness with clearance strictly above the supremum. -/ +theorem superlevelBar_clearance_improve {d : ℕ} (g : superlevelBar_E d → ℝ) + (hg : Continuous g) (M : superlevelBar_E d) {h : ℝ} + (hh : h ∈ superlevelBar_clearanceSet g M) : + ∃ c : ℝ, h < c ∧ c ∈ superlevelBar_clearanceSet g M := by + obtain ⟨y, hy, γ, hγ⟩ := hh + obtain ⟨t₀, hmin⟩ := superlevelBar_path_minimum g hg γ + have hmargin := hγ t₀ + refine ⟨(h + g (γ t₀)) / 2, ?_, y, hy, γ, ?_⟩ + · linarith + · intro t + have ht := hmin t + linarith + +/-- Proves: the exact strict cut for continuous nonessential inputs. +Method: least-upper-bound property, downward closure and strict improvement. +Does not establish: closed-threshold attainment at the death height. -/ +theorem superlevelBar_strict_cut {d : ℕ} (g : superlevelBar_E d → ℝ) + (hg : Continuous g) (M : superlevelBar_E d) + (hM : ¬ superlevelBar_isEssential g M) (h : ℝ) : + h < superlevelBar_deathHeight g M ↔ h ∈ superlevelBar_clearanceSet g M := by + classical + have hne := superlevelBar_clearance_nonempty g hg M hM + rw [superlevelBar_death_eq_sSup_of_nonempty g M hne] + constructor + · intro hlt + have hex : ∃ c ∈ superlevelBar_clearanceSet g M, h < c := by + by_contra hn + have hub : ∀ c ∈ superlevelBar_clearanceSet g M, c ≤ h := by + intro c hc + exact le_of_not_gt (fun hhc => hn ⟨c, hc, hhc⟩) + exact (not_le_of_gt hlt) (csSup_le hne hub) + obtain ⟨c, hc, hhc⟩ := hex + exact superlevelBar_clearance_downward g M hhc hc + · intro hh + obtain ⟨c, hhc, hc⟩ := superlevelBar_clearance_improve g hg M hh + exact hhc.trans_le (le_csSup (superlevelBar_clearance_bddAbove g M) hc) + +/-- Proves: the death value is at most the initial height when clearance is +nonempty. Method: the supremum is at most this upper bound. +Does not establish: the bound on the empty default branch. -/ +theorem superlevelBar_death_le_start_of_nonempty {d : ℕ} + (g : superlevelBar_E d → ℝ) (M : superlevelBar_E d) + (hne : (superlevelBar_clearanceSet g M).Nonempty) : + superlevelBar_deathHeight g M ≤ g M := by + rw [superlevelBar_death_eq_sSup_of_nonempty g M hne] + exact csSup_le hne (fun h hh => (superlevelBar_mem_lt_start g M hh).le) + +/-- Proves: the death upper bound for continuous nonessential inputs. +Method: establish nonempty clearance and apply its guarded supremum bound. +Does not establish: a strict inequality or an attained optimal path. -/ +theorem superlevelBar_death_le_start {d : ℕ} (g : superlevelBar_E d → ℝ) + (hg : Continuous g) (M : superlevelBar_E d) + (hM : ¬ superlevelBar_isEssential g M) : superlevelBar_deathHeight g M ≤ g M := by + exact superlevelBar_death_le_start_of_nonempty g M + (superlevelBar_clearance_nonempty g hg M hM) + +/-- Proves: the clearance set is the open lower interval below death on the +continuous nonessential locus. Method: extensionality and the strict cut. +Does not establish: a closed-threshold path at the excluded endpoint. -/ +theorem superlevelBar_clearance_eq_Iio {d : ℕ} (g : superlevelBar_E d → ℝ) + (hg : Continuous g) (M : superlevelBar_E d) + (hM : ¬ superlevelBar_isEssential g M) : + superlevelBar_clearanceSet g M = Set.Iio (superlevelBar_deathHeight g M) := by + ext h + exact (superlevelBar_strict_cut g hg M hM h).symm + +/-- Proves: death is not a strict clearance for continuous nonessential inputs. +Method: the cut would otherwise imply that death is strictly below itself. +Does not establish: failure or success of closed-threshold attainment. -/ +theorem superlevelBar_death_not_mem_clearance {d : ℕ} + (g : superlevelBar_E d → ℝ) (hg : Continuous g) (M : superlevelBar_E d) + (hM : ¬ superlevelBar_isEssential g M) : + superlevelBar_deathHeight g M ∉ superlevelBar_clearanceSet g M := by + intro hh + have hlt := (superlevelBar_strict_cut g hg M hM (superlevelBar_deathHeight g M)).2 hh + exact (lt_irrefl _) hlt + +/-- Proves: uniqueness of a real number with this strict cut on the valid locus. +Method: evaluate either cut at the competing endpoint. +Does not establish: equality of arbitrary total interface records off that locus. -/ +theorem superlevelBar_cut_unique {d : ℕ} (g : superlevelBar_E d → ℝ) + (hg : Continuous g) (M : superlevelBar_E d) + (hM : ¬ superlevelBar_isEssential g M) (a : ℝ) + (ha : ∀ h : ℝ, h < a ↔ h ∈ superlevelBar_clearanceSet g M) : + a = superlevelBar_deathHeight g M := by + apply le_antisymm + · by_contra hn + have hlt : superlevelBar_deathHeight g M < a := lt_of_not_ge hn + exact superlevelBar_death_not_mem_clearance g hg M hM ((ha _).1 hlt) + · by_contra hn + have hlt : a < superlevelBar_deathHeight g M := lt_of_not_ge hn + have hc := (superlevelBar_strict_cut g hg M hM a).1 hlt + exact (lt_irrefl a) ((ha a).2 hc) + +/-- Proves: any constant height selects the zero default at every point. +Method: every point is globally maximal, hence essential in these data. +Does not establish: any finite ordinary bar for that constant height. -/ +theorem superlevelBar_death_const (d : ℕ) (b : ℝ) (M : superlevelBar_E d) : + superlevelBar_deathHeight (fun _ : superlevelBar_E d => b) M = 0 := by + apply superlevelBar_death_eq_zero_of_essential + intro y + exact le_rfl + +/-- Proves: the essential default forbids an unconditional death/start bound. +Method: constant height minus one has empty clearance and death zero. +Does not establish: any finite ordinary bar on a constant field. -/ +theorem superlevelBar_control_negative_essential (d : ℕ) (M : superlevelBar_E d) : + superlevelBar_deathHeight (fun _ : superlevelBar_E d => (-1 : ℝ)) M = 0 ∧ + ¬ superlevelBar_deathHeight (fun _ : superlevelBar_E d => (-1 : ℝ)) M ≤ (-1 : ℝ) := by + rw [superlevelBar_death_const d (-1) M] + norm_num + +end TorusFiltration diff --git a/frontiers/critical_level_attainment_20261020/final-project/TorusTopology.lean b/frontiers/critical_level_attainment_20261020/final-project/TorusTopology.lean new file mode 100644 index 000000000..ed678ea32 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-project/TorusTopology.lean @@ -0,0 +1,247 @@ +import Mathlib + +/-! +# The actual period-lattice quotient and specified-start path compatibility + +C254 proposed source. Compilation and kernel audit: NOT_RUN. +The ambient space and lattice-vector formula below are exactly those in the +source-bound Field.lean; this module does not import or alter that owner's file. +All quotient, compactness, covering and descent properties are constructed. +The final lift endpoint is existential. No critical-level attainment is claimed. +Compile fixes at the pin (Lean v4.34.1, Mathlib d13f23b7), no statement altered: `Basis` → `Module.Basis`, `Basis.unitsSMul_apply` → `Module.Basis.unitsSMul_apply`, lattice discreteness passed via `SetLike.isDiscrete_iff_discreteTopology.mpr` instead of `DiscreteTopology.isDiscrete`, quotient path-connectedness via `inferInstanceAs (PathConnectedSpace (Quotient _))` instead of `infer_instance`. +Three unused simp arguments (`PiLp.single_apply` twice, `hij`) removed from `torus_basis_sum_eq_latticeVec` so the +file elaborates with warnings as errors; namespace `TorusFiltration` in this companion (handoff: `ResearchFormalCoreR1`). +-/ + +noncomputable section + +open Topology + +namespace TorusFiltration +abbrev torus_E (d : ℕ) := EuclideanSpace ℝ (Fin d) + +/-- The exact `Field.latticeVec` formula, retained without any coordinate rescaling. -/ +def torus_latticeVec (d : ℕ) (L : ℝ) (n : Fin d → ℤ) : torus_E d := + ∑ i, EuclideanSpace.single i (L * (n i : ℝ)) + +theorem torus_field_latticeVec_formula (d : ℕ) (L : ℝ) (n : Fin d → ℤ) : + torus_latticeVec d L n = ∑ i, EuclideanSpace.single i (L * (n i : ℝ)) := rfl + +def torus_periodBasis (d : ℕ) (L : ℝ) (hL : 0 < L) : + Module.Basis (Fin d) ℝ (torus_E d) := + (EuclideanSpace.basisFun (Fin d) ℝ).toBasis.unitsSMul + (fun _ => Units.mk0 L hL.ne') + +def torus_periodLattice (d : ℕ) (L : ℝ) (hL : 0 < L) : Submodule ℤ (torus_E d) := + Submodule.span ℤ (Set.range (torus_periodBasis d L hL)) + +abbrev torus_quotient (d : ℕ) (L : ℝ) (hL : 0 < L) := + torus_E d ⧸ (torus_periodLattice d L hL).toAddSubgroup + +def torus_proj (d : ℕ) (L : ℝ) (hL : 0 < L) : torus_E d → torus_quotient d L hL := + QuotientAddGroup.mk + +/-- Concrete adapter from integer basis coefficients to Field's exact vector formula. -/ +theorem torus_basis_sum_eq_latticeVec (d : ℕ) (L : ℝ) (hL : 0 < L) + (n : Fin d → ℤ) : + ∑ i, n i • torus_periodBasis d L hL i = torus_latticeVec d L n := by + classical + unfold torus_latticeVec + apply Finset.sum_congr rfl + intro i hi + ext j + by_cases hij : i = j + · subst j + simp [torus_periodBasis, Module.Basis.unitsSMul_apply, OrthonormalBasis.coe_toBasis, + EuclideanSpace.basisFun_apply, Units.smul_def, PiLp.smul_apply, + zsmul_eq_mul, mul_comm] + · simp [torus_periodBasis, Module.Basis.unitsSMul_apply, OrthonormalBasis.coe_toBasis, + EuclideanSpace.basisFun_apply, Units.smul_def, PiLp.smul_apply, + Ne.symm hij] + +theorem torus_lattice_mem_iff (d : ℕ) (L : ℝ) (hL : 0 < L) (x : torus_E d) : + x ∈ torus_periodLattice d L hL ↔ ∃ n : Fin d → ℤ, torus_latticeVec d L n = x := by + classical + change x ∈ Submodule.span ℤ (Set.range (torus_periodBasis d L hL)) ↔ _ + rw [Submodule.mem_span_range_iff_exists_fun] + simp only [torus_basis_sum_eq_latticeVec] + +instance torus_lattice_discrete (d : ℕ) (L : ℝ) (hL : 0 < L) : + DiscreteTopology (torus_periodLattice d L hL) := by + unfold torus_periodLattice + infer_instance + +instance torus_lattice_addSubgroup_discrete (d : ℕ) (L : ℝ) (hL : 0 < L) : + DiscreteTopology (torus_periodLattice d L hL).toAddSubgroup := by + unfold torus_periodLattice + infer_instance + +instance torus_lattice_isZLattice (d : ℕ) (L : ℝ) (hL : 0 < L) : + IsZLattice ℝ (torus_periodLattice d L hL) := by + unfold torus_periodLattice + infer_instance + +theorem torus_proj_surjective (d : ℕ) (L : ℝ) (hL : 0 < L) : + Function.Surjective (torus_proj d L hL) := QuotientAddGroup.mk_surjective + +theorem torus_proj_continuous (d : ℕ) (L : ℝ) (hL : 0 < L) : + Continuous (torus_proj d L hL) := continuous_quotient_mk' + +theorem torus_proj_eq_iff (d : ℕ) (L : ℝ) (hL : 0 < L) (x y : torus_E d) : + torus_proj d L hL x = torus_proj d L hL y ↔ + ∃ n : Fin d → ℤ, y = x + torus_latticeVec d L n := by + change (QuotientAddGroup.mk x : torus_quotient d L hL) = QuotientAddGroup.mk y ↔ _ + rw [QuotientAddGroup.eq] + change -x + y ∈ torus_periodLattice d L hL ↔ _ + rw [torus_lattice_mem_iff] + constructor + · rintro ⟨n, hn⟩ + exact ⟨n, by rw [hn]; abel⟩ + · rintro ⟨n, rfl⟩ + exact ⟨n, by abel⟩ + +/-- Duplicate representatives have exactly the same quotient image. -/ +theorem torus_control_lattice_translate (d : ℕ) (L : ℝ) (hL : 0 < L) + (x : torus_E d) (n : Fin d → ℤ) : + torus_proj d L hL (x + torus_latticeVec d L n) = torus_proj d L hL x := + ((torus_proj_eq_iff d L hL x _).2 ⟨n, rfl⟩).symm + +theorem torus_proj_isCoveringMap (d : ℕ) (L : ℝ) (hL : 0 < L) : + IsCoveringMap (torus_proj d L hL) := + ((torus_periodLattice d L hL).toAddSubgroup.isAddQuotientCoveringMap_of_comm + (SetLike.isDiscrete_iff_discreteTopology.mpr + (torus_lattice_addSubgroup_discrete d L hL))).isCoveringMap + +theorem torus_compact (d : ℕ) (L : ℝ) (hL : 0 < L) : + IsCompact (Set.univ : Set (torus_quotient d L hL)) := by + have hc := IsZLattice.isCompact_range_of_periodic (torus_periodLattice d L hL) + (torus_proj d L hL) (torus_proj_continuous d L hL) + (fun z w hw => QuotientAddGroup.mk_add_of_mem z hw) + rwa [Set.range_eq_univ.mpr (torus_proj_surjective d L hL)] at hc + +theorem torus_pathConnectedSpace (d : ℕ) (L : ℝ) (hL : 0 < L) : + PathConnectedSpace (torus_quotient d L hL) := by + exact inferInstanceAs <| PathConnectedSpace (Quotient _) + +/-- Exact Field periodicity predicate with the literal lattice-vector adapter above. -/ +def torus_isPeriodic (d : ℕ) (L : ℝ) (g : torus_E d → ℝ) : Prop := + ∀ (x : torus_E d) (n : Fin d → ℤ), g (x + torus_latticeVec d L n) = g x + +theorem torus_field_periodic_formula (d : ℕ) (L : ℝ) (g : torus_E d → ℝ) : + torus_isPeriodic d L g ↔ + ∀ (x : EuclideanSpace ℝ (Fin d)) (n : Fin d → ℤ), + g (x + ∑ i, EuclideanSpace.single i (L * (n i : ℝ))) = g x := Iff.rfl + +theorem torus_periodic_respects (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : torus_E d → ℝ) (hg : torus_isPeriodic d L g) (x y : torus_E d) + (hxy : QuotientAddGroup.leftRel (torus_periodLattice d L hL).toAddSubgroup x y) : + g x = g y := by + have hq : torus_proj d L hL x = torus_proj d L hL y := Quotient.sound hxy + obtain ⟨n, rfl⟩ := (torus_proj_eq_iff d L hL x y).1 hq + exact (hg x n).symm + +def torus_descend (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : torus_E d → ℝ) (hg : torus_isPeriodic d L g) : torus_quotient d L hL → ℝ := + Quotient.lift g (torus_periodic_respects d L hL g hg) + +theorem torus_descend_proj (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : torus_E d → ℝ) (hg : torus_isPeriodic d L g) (x : torus_E d) : + torus_descend d L hL g hg (torus_proj d L hL x) = g x := rfl + +theorem torus_descend_continuous (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : torus_E d → ℝ) (hg : torus_isPeriodic d L g) (hgc : Continuous g) : + Continuous (torus_descend d L hL g hg) := + hgc.quotient_lift (torus_periodic_respects d L hL g hg) + +/-- Lift from a prescribed representative; the endpoint is determined existentially. -/ +theorem torus_path_lift_from (d : ℕ) (L : ℝ) (hL : 0 < L) + {M : torus_E d} {y : torus_quotient d L hL} + (γ : Path (torus_proj d L hL M) y) : + ∃ z : torus_E d, ∃ Γ : Path M z, + torus_proj d L hL z = y ∧ + ∀ t : unitInterval, torus_proj d L hL (Γ t) = γ t := by + let cov := torus_proj_isCoveringMap d L hL + let Γ := cov.liftPath γ M γ.source + refine ⟨Γ 1, ⟨Γ, cov.liftPath_zero γ M γ.source, rfl⟩, ?_, ?_⟩ + · exact (congrFun (cov.liftPath_lifts γ M γ.source) 1).trans γ.target + · intro t + exact congrFun (cov.liftPath_lifts γ M γ.source) t + +/-- Control: a constant projected path cannot be lifted from M to a different lift. +This refutes replacing the existential endpoint by an arbitrary chosen representative. -/ +theorem torus_control_constant_path_endpoint (d : ℕ) (L : ℝ) (hL : 0 < L) + {M z : torus_E d} (Γ : Path M z) + (hΓ : ∀ t : unitInterval, torus_proj d L hL (Γ t) = torus_proj d L hL M) : z = M := by + have heq : (Γ : unitInterval → torus_E d) = fun _ => M := + (torus_proj_isCoveringMap d L hL).eq_of_comp_eq Γ.continuous continuous_const + (funext hΓ) 0 Γ.source + exact Γ.target.symm.trans (congrFun heq 1) + +/-- Combining the duplicate-image and uniqueness controls gives a direct rejection +of any different preselected endpoint for a constant quotient path. -/ +theorem torus_control_no_arbitrary_endpoint (d : ℕ) (L : ℝ) (hL : 0 < L) + (M : torus_E d) (n : Fin d → ℤ) (hn : torus_latticeVec d L n ≠ 0) : + torus_proj d L hL (M + torus_latticeVec d L n) = torus_proj d L hL M ∧ + ¬ ∃ Γ : Path M (M + torus_latticeVec d L n), + ∀ t : unitInterval, torus_proj d L hL (Γ t) = torus_proj d L hL M := by + refine ⟨torus_control_lattice_translate d L hL M n, ?_⟩ + rintro ⟨Γ, hΓ⟩ + have heq := torus_control_constant_path_endpoint d L hL Γ hΓ + apply hn + exact add_left_cancel (show M + torus_latticeVec d L n = M + 0 by simpa using heq) + +/-- Higher-endpoint compatibility for any scalar path predicate, including strict +and closed thresholds. No conclusion here asserts critical-level attainment. -/ +theorem torus_higher_path_iff (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : torus_E d → ℝ) (hg : torus_isPeriodic d L g) (M : torus_E d) (P : ℝ → Prop) : + (∃ y : torus_E d, g M < g y ∧ ∃ γ : Path M y, ∀ t : unitInterval, P (g (γ t))) ↔ + (∃ y : torus_quotient d L hL, + torus_descend d L hL g hg (torus_proj d L hL M) < torus_descend d L hL g hg y ∧ + ∃ γ : Path (torus_proj d L hL M) y, + ∀ t : unitInterval, P (torus_descend d L hL g hg (γ t))) := by + constructor + · rintro ⟨y, hy, γ, hγ⟩ + exact ⟨torus_proj d L hL y, hy, γ.map (torus_proj_continuous d L hL), hγ⟩ + · rintro ⟨y, hy, γ, hγ⟩ + obtain ⟨z, Γ, hz, hΓ⟩ := torus_path_lift_from d L hL γ + refine ⟨z, ?_, Γ, ?_⟩ + · have hz' := congrArg (torus_descend d L hL g hg) hz + change g z = torus_descend d L hL g hg y at hz' + change g M < torus_descend d L hL g hg y at hy + rwa [← hz'] at hy + · intro t + have ht := hγ t + rw [← hΓ t] at ht + exact ht + +theorem torus_strict_higher_path_iff (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : torus_E d → ℝ) (hg : torus_isPeriodic d L g) (M : torus_E d) (h : ℝ) : + (∃ y : torus_E d, g M < g y ∧ ∃ γ : Path M y, ∀ t : unitInterval, h < g (γ t)) ↔ + (∃ y : torus_quotient d L hL, + torus_descend d L hL g hg (torus_proj d L hL M) < torus_descend d L hL g hg y ∧ + ∃ γ : Path (torus_proj d L hL M) y, + ∀ t : unitInterval, h < torus_descend d L hL g hg (γ t)) := + torus_higher_path_iff d L hL g hg M (fun a => h < a) + +theorem torus_closed_higher_path_iff (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : torus_E d → ℝ) (hg : torus_isPeriodic d L g) (M : torus_E d) (h : ℝ) : + (∃ y : torus_E d, g M < g y ∧ ∃ γ : Path M y, ∀ t : unitInterval, h ≤ g (γ t)) ↔ + (∃ y : torus_quotient d L hL, + torus_descend d L hL g hg (torus_proj d L hL M) < torus_descend d L hL g hg y ∧ + ∃ γ : Path (torus_proj d L hL M) y, + ∀ t : unitInterval, h ≤ torus_descend d L hL g hg (γ t)) := + torus_higher_path_iff d L hL g hg M (fun a => h ≤ a) + +theorem torus_global_max_iff (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : torus_E d → ℝ) (hg : torus_isPeriodic d L g) (M : torus_E d) : + (∀ y : torus_E d, g y ≤ g M) ↔ + ∀ y : torus_quotient d L hL, + torus_descend d L hL g hg y ≤ torus_descend d L hL g hg (torus_proj d L hL M) := by + constructor + · intro h y + obtain ⟨z, rfl⟩ := torus_proj_surjective d L hL y + exact h z + · intro h y + exact h (torus_proj d L hL y) + +end TorusFiltration \ No newline at end of file diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/PREFLIGHT.json new file mode 100644 index 000000000..dd41e6873 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/PREFLIGHT.json @@ -0,0 +1,49 @@ +{ + "kind": "build", + "module": "Lifetime", + "started_utc": "2026-10-20T08:43:13.247291+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": {}, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/Lifetime.olean", + "$C294_ROOT/final-project/Lifetime.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/PROCESS_START.json new file mode 100644 index 000000000..2d7799899 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/PROCESS_START.json @@ -0,0 +1,50 @@ +{ + "kind": "build", + "module": "Lifetime", + "started_utc": "2026-10-20T08:43:13.247291+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": {}, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/Lifetime.olean", + "$C294_ROOT/final-project/Lifetime.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 61706 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/RECEIPT.json new file mode 100644 index 000000000..fb40eaa3b --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/RECEIPT.json @@ -0,0 +1,80 @@ +{ + "kind": "build", + "module": "Lifetime", + "started_utc": "2026-10-20T08:43:13.247291+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": {}, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/Lifetime.olean", + "$C294_ROOT/final-project/Lifetime.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 61706, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "produced_objects": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4" + }, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:44:50.301891+00:00", + "seconds": 97.056366333 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/START.json new file mode 100644 index 000000000..65ad9e574 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/START.json @@ -0,0 +1,11 @@ +{ + "kind": "build", + "module": "Lifetime", + "started_utc": "2026-10-20T08:43:13.247291+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084313Z-build-Lifetime-f6a32f33/stdout.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/PREFLIGHT.json new file mode 100644 index 000000000..4684ea4be --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/PREFLIGHT.json @@ -0,0 +1,51 @@ +{ + "kind": "build", + "module": "TorusTopology", + "started_utc": "2026-10-20T08:44:50.383880+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/TorusTopology.olean", + "$C294_ROOT/final-project/TorusTopology.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/PROCESS_START.json new file mode 100644 index 000000000..670df0f12 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/PROCESS_START.json @@ -0,0 +1,52 @@ +{ + "kind": "build", + "module": "TorusTopology", + "started_utc": "2026-10-20T08:44:50.383880+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/TorusTopology.olean", + "$C294_ROOT/final-project/TorusTopology.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 61837 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/RECEIPT.json new file mode 100644 index 000000000..45fded04f --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/RECEIPT.json @@ -0,0 +1,83 @@ +{ + "kind": "build", + "module": "TorusTopology", + "started_utc": "2026-10-20T08:44:50.383880+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/TorusTopology.olean", + "$C294_ROOT/final-project/TorusTopology.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 61837, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125", + "produced_objects": { + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:46:21.857196+00:00", + "seconds": 91.47423625 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/START.json new file mode 100644 index 000000000..b390dd498 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/START.json @@ -0,0 +1,11 @@ +{ + "kind": "build", + "module": "TorusTopology", + "started_utc": "2026-10-20T08:44:50.383880+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084450Z-build-TorusTopology-d84fe754/stdout.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/PREFLIGHT.json new file mode 100644 index 000000000..7d0db3a3b --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/PREFLIGHT.json @@ -0,0 +1,52 @@ +{ + "kind": "build", + "module": "SuperlevelBar", + "started_utc": "2026-10-20T08:46:21.947031+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/SuperlevelBar.olean", + "$C294_ROOT/final-project/SuperlevelBar.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/PROCESS_START.json new file mode 100644 index 000000000..d97b5f7e1 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/PROCESS_START.json @@ -0,0 +1,53 @@ +{ + "kind": "build", + "module": "SuperlevelBar", + "started_utc": "2026-10-20T08:46:21.947031+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/SuperlevelBar.olean", + "$C294_ROOT/final-project/SuperlevelBar.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 61940 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/RECEIPT.json new file mode 100644 index 000000000..52217c627 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/RECEIPT.json @@ -0,0 +1,85 @@ +{ + "kind": "build", + "module": "SuperlevelBar", + "started_utc": "2026-10-20T08:46:21.947031+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/SuperlevelBar.olean", + "$C294_ROOT/final-project/SuperlevelBar.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 61940, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "produced_objects": { + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086" + }, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:47:47.788807+00:00", + "seconds": 85.84263524999999 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/START.json new file mode 100644 index 000000000..5478e094b --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/START.json @@ -0,0 +1,11 @@ +{ + "kind": "build", + "module": "SuperlevelBar", + "started_utc": "2026-10-20T08:46:21.947031+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084621Z-build-SuperlevelBar-238d9b84/stdout.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/PREFLIGHT.json new file mode 100644 index 000000000..901c144c5 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/PREFLIGHT.json @@ -0,0 +1,53 @@ +{ + "kind": "build", + "module": "ClosedSuperlevel", + "started_utc": "2026-10-20T08:47:47.878239+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/ClosedSuperlevel.olean", + "$C294_ROOT/final-project/ClosedSuperlevel.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/PROCESS_START.json new file mode 100644 index 000000000..946605d8a --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/PROCESS_START.json @@ -0,0 +1,54 @@ +{ + "kind": "build", + "module": "ClosedSuperlevel", + "started_utc": "2026-10-20T08:47:47.878239+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/ClosedSuperlevel.olean", + "$C294_ROOT/final-project/ClosedSuperlevel.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 61986 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/RECEIPT.json new file mode 100644 index 000000000..b0a208847 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/RECEIPT.json @@ -0,0 +1,87 @@ +{ + "kind": "build", + "module": "ClosedSuperlevel", + "started_utc": "2026-10-20T08:47:47.878239+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/ClosedSuperlevel.olean", + "$C294_ROOT/final-project/ClosedSuperlevel.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 61986, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "produced_objects": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37" + }, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:49:07.987593+00:00", + "seconds": 80.110136708 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/START.json new file mode 100644 index 000000000..4dbf12ab5 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/START.json @@ -0,0 +1,11 @@ +{ + "kind": "build", + "module": "ClosedSuperlevel", + "started_utc": "2026-10-20T08:47:47.878239+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084747Z-build-ClosedSuperlevel-92d589b7/stdout.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/PREFLIGHT.json new file mode 100644 index 000000000..16fce5526 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/PREFLIGHT.json @@ -0,0 +1,54 @@ +{ + "kind": "build", + "module": "MorseFiniteCritical", + "started_utc": "2026-10-20T08:49:08.077285+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/MorseFiniteCritical.olean", + "$C294_ROOT/final-project/MorseFiniteCritical.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/PROCESS_START.json new file mode 100644 index 000000000..f87bb8f6c --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/PROCESS_START.json @@ -0,0 +1,55 @@ +{ + "kind": "build", + "module": "MorseFiniteCritical", + "started_utc": "2026-10-20T08:49:08.077285+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/MorseFiniteCritical.olean", + "$C294_ROOT/final-project/MorseFiniteCritical.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62010 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/RECEIPT.json new file mode 100644 index 000000000..52f2536ee --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/RECEIPT.json @@ -0,0 +1,89 @@ +{ + "kind": "build", + "module": "MorseFiniteCritical", + "started_utc": "2026-10-20T08:49:08.077285+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-o", + "$C294_ROOT/final-build/MorseFiniteCritical.olean", + "$C294_ROOT/final-project/MorseFiniteCritical.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62010, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "produced_objects": { + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2" + }, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:50:31.198998+00:00", + "seconds": 83.12238695799999 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/START.json new file mode 100644 index 000000000..faa448bab --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/START.json @@ -0,0 +1,11 @@ +{ + "kind": "build", + "module": "MorseFiniteCritical", + "started_utc": "2026-10-20T08:49:08.077285+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T084908Z-build-MorseFiniteCritical-17f9406a/stdout.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/PREFLIGHT.json new file mode 100644 index 000000000..8f9b5f7d4 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/PREFLIGHT.json @@ -0,0 +1,56 @@ +{ + "kind": "build", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:50:31.295097+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-DwarningAsError=true", + "-o", + "$C294_ROOT/final-build/CriticalLevelAttainment.olean", + "$C294_ROOT/final-project/CriticalLevelAttainment.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/PROCESS_START.json new file mode 100644 index 000000000..427b3faf4 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/PROCESS_START.json @@ -0,0 +1,57 @@ +{ + "kind": "build", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:50:31.295097+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-DwarningAsError=true", + "-o", + "$C294_ROOT/final-build/CriticalLevelAttainment.olean", + "$C294_ROOT/final-project/CriticalLevelAttainment.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62061 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/RECEIPT.json new file mode 100644 index 000000000..6bdedd9ec --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/RECEIPT.json @@ -0,0 +1,92 @@ +{ + "kind": "build", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:50:31.295097+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-DwarningAsError=true", + "-o", + "$C294_ROOT/final-build/CriticalLevelAttainment.olean", + "$C294_ROOT/final-project/CriticalLevelAttainment.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62061, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "produced_objects": { + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235" + }, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:51:55.474646+00:00", + "seconds": 84.180266125 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/START.json new file mode 100644 index 000000000..b8c39f2c5 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/START.json @@ -0,0 +1,11 @@ +{ + "kind": "build", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:50:31.295097+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085031Z-build-CriticalLevelAttainment-333ded49/stdout.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/PREFLIGHT.json new file mode 100644 index 000000000..9c21c310a --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/PREFLIGHT.json @@ -0,0 +1,57 @@ +{ + "kind": "build", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:51:55.565139+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 900, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-DwarningAsError=true", + "-o", + "$C294_ROOT/final-build/CriticalLevelAxiomAudit.olean", + "$C294_ROOT/final-project/CriticalLevelAxiomAudit.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/PROCESS_START.json new file mode 100644 index 000000000..362181638 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/PROCESS_START.json @@ -0,0 +1,58 @@ +{ + "kind": "build", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:51:55.565139+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 900, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-DwarningAsError=true", + "-o", + "$C294_ROOT/final-build/CriticalLevelAxiomAudit.olean", + "$C294_ROOT/final-project/CriticalLevelAxiomAudit.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62093 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/RECEIPT.json new file mode 100644 index 000000000..1fd0755bf --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/RECEIPT.json @@ -0,0 +1,94 @@ +{ + "kind": "build", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:51:55.565139+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 900, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "-DwarningAsError=true", + "-o", + "$C294_ROOT/final-build/CriticalLevelAxiomAudit.olean", + "$C294_ROOT/final-project/CriticalLevelAxiomAudit.lean" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62093, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "produced_objects": { + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030" + }, + "stdout_sha256": "062a8168ad5b05f1238ea8fd516d7fc5a806941cf77480b6de6837921c294386", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:53:36.122537+00:00", + "seconds": 100.557345416 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/START.json new file mode 100644 index 000000000..50b8db198 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/START.json @@ -0,0 +1,11 @@ +{ + "kind": "build", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:51:55.565139+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 900, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stdout.txt new file mode 100644 index 000000000..b630aeacc --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stdout.txt @@ -0,0 +1,437 @@ +'TorusCriticalAttainment.quotient_death_attainment' depends on axioms: [propext, Classical.choice, Quot.sound] +'TorusCriticalAttainment.euclidean_death_attainment' depends on axioms: [propext, Classical.choice, Quot.sound] +TorusCriticalAttainment.quotient_death_attainment : ∀ (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : UniversalLaw.Spec.Lifetime.E d → ℝ), + UniversalLaw.Spec.Lifetime.IsSmooth d g → + ∀ (hperiodic : UniversalLaw.Spec.Lifetime.IsLPeriodic d L g), + UniversalLaw.Spec.Lifetime.IsMorseDistinct d L g → + ∀ (M : UniversalLaw.Spec.Lifetime.E d), + ¬TorusFiltration.superlevelBar_isEssential g M → + LocallyPathConnectedSpace + { q // + TorusFiltration.superlevelBar_deathHeight g M ≤ + TorusCriticalAttainment.descendedHeight d L hL g hperiodic q } → + ∃ Q ∈ TorusMorseFinite.quotientCriticalSet d L hL g, + g M < TorusCriticalAttainment.descendedHeight d L hL g hperiodic Q ∧ + ∃ γ, + (∀ (t : ↑unitInterval), + TorusFiltration.superlevelBar_deathHeight g M ≤ + TorusCriticalAttainment.descendedHeight d L hL g hperiodic (γ t)) ∧ + ∃ t, + TorusCriticalAttainment.descendedHeight d L hL g hperiodic (γ t) = + TorusFiltration.superlevelBar_deathHeight g M +TorusCriticalAttainment.euclidean_death_attainment : ∀ (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : UniversalLaw.Spec.Lifetime.E d → ℝ), + UniversalLaw.Spec.Lifetime.IsSmooth d g → + ∀ (hperiodic : UniversalLaw.Spec.Lifetime.IsLPeriodic d L g), + UniversalLaw.Spec.Lifetime.IsMorseDistinct d L g → + ∀ (M : UniversalLaw.Spec.Lifetime.E d), + ¬TorusFiltration.superlevelBar_isEssential g M → + LocallyPathConnectedSpace + { q // + TorusFiltration.superlevelBar_deathHeight g M ≤ + TorusCriticalAttainment.descendedHeight d L hL g hperiodic q } → + ∃ y, + UniversalLaw.Spec.Lifetime.IsCriticalPoint d g y ∧ + g M < g y ∧ + ∃ Γ, + (∀ (t : ↑unitInterval), TorusFiltration.superlevelBar_deathHeight g M ≤ g (Γ t)) ∧ + ∃ t, g (Γ t) = TorusFiltration.superlevelBar_deathHeight g M +ATTAINMENT_AUDIT_MODULE Lifetime COUNT 103 +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.E AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.FundDomain AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.HessianHasInertia AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsCandidatePair AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsCriticalPoint AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsFiniteBar AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsIndexSaddle AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsLPeriodic AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsLifetimeDensityVersion AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsMorseDistinct AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsNondegMax AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsSmooth AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsUnrestrictedLeadingCoefficient AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsUnrestrictedPair AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsWindowElderPair AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsWindowPair AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.ParentCompactWindowDensityB AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.ParentUniformSelectionA AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.ParentUnrestrictedLeadingDensityC AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PlanarDensityGapE11 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PlanarElderLowerE2 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PlanarTwoSidedRateE4 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.RemainderBoundedR1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.covQuadForm AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.heightGap AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.hessian AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.latticeVec AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.pairCount AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.pairSet AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.periodicCovariance AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.pinM AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.pinS AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.scaledGap AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.thetaSum AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.torusDist AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.F AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.P AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface._sizeOf_1 AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface._sizeOf_inst AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.casesOn AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.covariance AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.ctorIdx AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.gaussian AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.isProb AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.mk AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.mΩ AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.noConfusion AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.noConfusionType AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.periodic AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.quad_nonneg AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.rec AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.recOn AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.smooth AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.summable AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.Ω AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsLifetimeDensityVersion._proof_1 AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface._sizeOf_1 AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface._sizeOf_inst AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.casesOn AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.ctorIdx AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.mk AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.noConfusion AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.noConfusionType AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.p AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.p_le_one AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.p_nonneg AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.rec AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.recOn AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.ParentCompactWindowDensityB._proof_1 AXIOMS [propext] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.ElderPartner AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.IsEssential AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface._sizeOf_1 AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface._sizeOf_inst AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.casesOn AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.ctorIdx AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.deathHeight AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.deathHeight_maximin AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.elderPartner_iff AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.essential_iff AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.mk AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.noConfusion AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.noConfusionType AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.rec AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.recOn AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.thetaSum._proof_1 AXIOMS [propext] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.mk._flat_ctor AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.mk.inj AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.mk.injEq AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.mk.noConfusion AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.GaussianFieldInterface.mk.sizeOf_spec AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.mk._flat_ctor AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.mk.inj AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.mk.injEq AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.mk.noConfusion AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.PairLawInterface.mk.sizeOf_spec AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.mk._flat_ctor AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.mk.inj AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.mk.injEq AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.mk.noConfusion AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.SuperlevelBarInterface.mk.sizeOf_spec AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_MODULE TorusTopology COUNT 38 +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_E AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_basis_sum_eq_latticeVec AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_closed_higher_path_iff AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_compact AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_control_constant_path_endpoint AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_control_lattice_translate AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_control_no_arbitrary_endpoint AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_descend AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_descend_continuous AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_descend_proj AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_field_latticeVec_formula AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_field_periodic_formula AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_global_max_iff AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_higher_path_iff AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_isPeriodic AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_latticeVec AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_lattice_addSubgroup_discrete AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_lattice_discrete AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_lattice_isZLattice AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_lattice_mem_iff AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_pathConnectedSpace AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_path_lift_from AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_periodBasis AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_periodLattice AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_periodic_respects AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_proj AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_proj_continuous AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_proj_eq_iff AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_proj_isCoveringMap AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_proj_surjective AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_quotient AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_strict_higher_path_iff AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_pathConnectedSpace._proof_1_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_periodBasis._proof_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_periodBasis.congr_simp AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_periodBasis.eq_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_proj_eq_iff._abel_1_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_proj_eq_iff._abel_1_2 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_MODULE SuperlevelBar COUNT 25 +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_E AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_clearanceSet AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_clearance_bddAbove AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_clearance_downward AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_clearance_empty_of_essential AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_clearance_eq_Iio AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_clearance_improve AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_clearance_nonempty AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_clearance_nonempty_iff AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_control_negative_essential AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_cut_unique AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_deathHeight AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_death_const AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_death_eq_sSup_of_nonempty AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_death_eq_zero_of_empty AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_death_eq_zero_of_essential AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_death_le_start AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_death_le_start_of_nonempty AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_death_not_mem_clearance AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_essential_iff AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_isEssential AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_mem_lt_start AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_path_minimum AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_strict_cut AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevelBar_deathHeight.eq_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_MODULE ClosedSuperlevel COUNT 32 +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_componentInclusion AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_componentInclusion_comp AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_componentInclusion_id AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_componentMap AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_componentMap_comp AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_componentMap_id AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_componentMap_mk AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_component_eq_iff_joinedIn AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_control_closed_endpoint AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_control_essential AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_control_inclusion_direction AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_control_parameter_sign AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_control_strict_endpoint AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_control_strict_thresholds AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_filtration AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_h0Filtration AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_h0Filtration_map_comp AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_h0Filtration_map_id AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_inclusion AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_inclusion_comp AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_inclusion_id AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_isClosed AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_mem_at_own_height AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_mono AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_neg_height AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_set AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_componentMap._proof_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_filtration._proof_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_filtration._proof_2 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_filtration._proof_3 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_filtration._proof_4 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.superlevel_set.eq_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_MODULE MorseFiniteCritical COUNT 20 +ATTAINMENT_AUDIT_DECL TorusMorseFinite.inertia_fderiv_equiv AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.inertia_fderiv_injective AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.literal_critical_isolated AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.literal_fderiv_periodic AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.literal_fderiv_respects AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.literal_hessian_eq_fderiv AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.literal_hessian_symmetric AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.mem_quotientCriticalSet_iff AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.quotientCriticalSet AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.quotientCriticalSet_closed AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.quotientCriticalSet_discrete AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.quotientCriticalSet_finite AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.quotientCriticalSet_finite_of_inertia AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.quotientDerivative AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.quotientDerivative_continuous AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.quotientDerivative_proj AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_latticeVec.eq_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusMorseFinite.inertia_fderiv_injective._simp_1_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.hessian.eq_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.latticeVec.eq_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_MODULE CriticalLevelAttainment COUNT 17 +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.closed_connectedComponentIn AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.component_maximum_isLocalMax AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.descendedHeight AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.descendedHeight_continuous AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.descendedHeight_proj AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.euclidean_death_attainment AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.localMax_mem_quotientCriticalSet AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.older_critical_in_component AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.periodic_transport AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.preconnected_iInter_of_directed AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.quotient_death_attainment AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.quotient_locallyPathConnectedSpace AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.quotient_t2 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.older_critical_in_component._simp_1_1 AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusCriticalAttainment.quotient_locallyPathConnectedSpace._proof_1_1 AXIOMS [propext, + Classical.choice, + Quot.sound] +ATTAINMENT_AUDIT_DECL TorusFiltration.torus_isPeriodic.eq_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_DECL UniversalLaw.Spec.Lifetime.IsLPeriodic.eq_1 AXIOMS [propext, Classical.choice, Quot.sound] +ATTAINMENT_AUDIT_STANDARD_ONLY_PASS COUNT 235 +ATTAINMENT_AUDIT_PROGRESS Lifetime COUNT 103 +ATTAINMENT_AUDIT_PROGRESS TorusTopology COUNT 38 +ATTAINMENT_AUDIT_PROGRESS SuperlevelBar COUNT 25 +ATTAINMENT_AUDIT_PROGRESS ClosedSuperlevel COUNT 32 +ATTAINMENT_AUDIT_PROGRESS MorseFiniteCritical COUNT 20 +ATTAINMENT_AUDIT_PROGRESS CriticalLevelAttainment COUNT 17 diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/PREFLIGHT.json new file mode 100644 index 000000000..4f089e875 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/PREFLIGHT.json @@ -0,0 +1,54 @@ +{ + "kind": "kernel", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:53:36.226044+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/leanchecker", + "-v", + "CriticalLevelAttainment" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/PROCESS_START.json new file mode 100644 index 000000000..4699037d8 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/PROCESS_START.json @@ -0,0 +1,55 @@ +{ + "kind": "kernel", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:53:36.226044+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/leanchecker", + "-v", + "CriticalLevelAttainment" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62139 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/RECEIPT.json new file mode 100644 index 000000000..afcef044f --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/RECEIPT.json @@ -0,0 +1,91 @@ +{ + "kind": "kernel", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:53:36.226044+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/leanchecker", + "-v", + "CriticalLevelAttainment" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62139, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "produced_objects": { + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235" + }, + "stdout_sha256": "8e31a3a3001f93627db850f58fccdfac385f45d769f57b760168d54b406326b6", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:54:50.024998+00:00", + "seconds": 73.79954475 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/START.json new file mode 100644 index 000000000..f2ac1f461 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/START.json @@ -0,0 +1,11 @@ +{ + "kind": "kernel", + "module": "CriticalLevelAttainment", + "started_utc": "2026-10-20T08:53:36.226044+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/stdout.txt new file mode 100644 index 000000000..4a2e34ea7 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133/stdout.txt @@ -0,0 +1 @@ +replaying CriticalLevelAttainment diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/PREFLIGHT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/PREFLIGHT.json new file mode 100644 index 000000000..fb6fbed30 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/PREFLIGHT.json @@ -0,0 +1,54 @@ +{ + "kind": "kernel", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:54:50.092416+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/leanchecker", + "-v", + "CriticalLevelAxiomAudit" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/PROCESS_START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/PROCESS_START.json new file mode 100644 index 000000000..9f3ecfa50 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/PROCESS_START.json @@ -0,0 +1,55 @@ +{ + "kind": "kernel", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:54:50.092416+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/leanchecker", + "-v", + "CriticalLevelAxiomAudit" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62173 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/RECEIPT.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/RECEIPT.json new file mode 100644 index 000000000..3fd6eccfc --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/RECEIPT.json @@ -0,0 +1,91 @@ +{ + "kind": "kernel", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:54:50.092416+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PASS", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_before": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "command": [ + "$LEAN_RUNTIME/bin/leanchecker", + "-v", + "CriticalLevelAxiomAudit" + ], + "process_path": "$LEAN_RUNTIME/bin:/usr/bin:/bin:/usr/sbin:/sbin", + "lean_path": [ + "$C294_ROOT/final-build", + "$PINNED_PROJECT/.lake/packages/plausible/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/LeanSearchClient/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/importGraph/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/proofwidgets/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/aesop/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/Qq/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/batteries/.lake/build/lib/lean", + "$PINNED_PROJECT/.lake/packages/mathlib/.lake/build/lib/lean" + ], + "executable_sha256": "cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35", + "resolved_lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "child_pid": 62173, + "returncode": 0, + "timed_out": false, + "source_after": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_after": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "dependency_after": { + "reused": 83897, + "rehashed": [], + "mode": "C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash" + }, + "source_unchanged": true, + "imported_objects_unchanged": true, + "object_sha256": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "produced_objects": { + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030" + }, + "stdout_sha256": "b1e64047e463a6b3b98984c683782da30469da75d5854c5f8f52f4d4576b2261", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "process_reaped": true, + "ended_utc": "2026-10-20T08:56:01.499767+00:00", + "seconds": 71.40805300000001 +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/START.json b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/START.json new file mode 100644 index 000000000..a5df524e2 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/START.json @@ -0,0 +1,11 @@ +{ + "kind": "kernel", + "module": "CriticalLevelAxiomAudit", + "started_utc": "2026-10-20T08:54:50.092416+00:00", + "runner_sha256": "089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9", + "kernel_scope": "standard named-module replay against imported dependencies; not --fresh/external verification", + "scientific_effect": "NONE", + "timeout_seconds": 600, + "threads": 2, + "status": "PREFLIGHT" +} diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/stderr.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/stdout.txt b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/stdout.txt new file mode 100644 index 000000000..e1ee80167 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final-runs/20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689/stdout.txt @@ -0,0 +1 @@ +replaying CriticalLevelAxiomAudit diff --git a/frontiers/critical_level_attainment_20261020/final_master.py b/frontiers/critical_level_attainment_20261020/final_master.py new file mode 100644 index 000000000..6290233b1 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/final_master.py @@ -0,0 +1,195 @@ +"""Once-only C294 artifact binding; no compiler/network. Contract: evidence/MASTER_CONTRACT.md. +Existing build/kernel receipts are evidence inputs, not proof execution by this master. +Only subprocess: exact canonical delivery builder's read-only `verify` operation. +""" +from pathlib import Path +from datetime import datetime, timezone +import hashlib, json, re, subprocess, sys, zipfile + +ROOT = Path(__file__).resolve().parent +MODULES = ['Lifetime', 'TorusTopology', 'SuperlevelBar', 'ClosedSuperlevel', 'MorseFiniteCritical', 'CriticalLevelAttainment', 'CriticalLevelAxiomAudit'] +NEW = MODULES[-2:] +TARGETS = {'TorusCriticalAttainment.quotient_death_attainment', 'TorusCriticalAttainment.euclidean_death_attainment'} +AUDIT_COUNT = 235 +BUILDER = '88d6e30182ae682d27f4d156f6c935f8373168ca6ff14d3141cd69c4b036d3a3' +FROZEN = 'a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d' +EXES = {'build': '1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554', + 'kernel': 'cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35'} +checks, observed = [], {} +digest = lambda b: hashlib.sha256(b).hexdigest() +blob = lambda b: hashlib.sha1(b'blob ' + str(len(b)).encode() + b'\0' + b).hexdigest() +now = lambda: datetime.now(timezone.utc).isoformat() + +def check(name, ok): + checks.append({'name': name, 'pass': bool(ok)}) + if not ok: raise ValueError(name) + +def read(path): + p = ROOT / path + check('regular nonsymlink: ' + str(p), p.is_file() and all(not q.is_symlink() for q in [p, *p.parents])) + b = p.read_bytes(); h = digest(b) + check('stable reread: ' + str(p), p not in observed or observed[p] == h) + observed[p] = h + return b + +def document(path): return json.loads(read(path)) +def local_name(name): + p = Path(name) + check('safe relative member: ' + name, not p.is_absolute() and '..' not in p.parts and bool(p.parts)) + return p + + + +def validate_audit(audit): + """Measure the complete six-module census; never infer it from a guessed total.""" + check('audit total bound', isinstance(AUDIT_COUNT, int) and not isinstance(AUDIT_COUNT, bool) and AUDIT_COUNT > 0) + census, names, section = {}, [], None + pattern = r'^ATTAINMENT_AUDIT_MODULE (?P\S+) COUNT (?P\d+)$|^ATTAINMENT_AUDIT_DECL (?P\S+) AXIOMS \[(?P[^\[\]]{0,4096})\]' + for match in re.finditer(pattern, audit, re.MULTILINE): + if match['module'] is not None: + section = match['module'] + check('unique census module ' + section, section not in census) + census[section] = [int(match['count']), 0] + else: + check('census declaration has module', section in census) + axioms = {x.strip() for x in match['axioms'].split(',') if x.strip()} + check('standard axioms: ' + match['name'], axioms <= {'propext', 'Classical.choice', 'Quot.sound'}) + names.append(match['name']); census[section][1] += 1 + totals = re.findall(r'^ATTAINMENT_AUDIT_STANDARD_ONLY_PASS COUNT (\d+)$', audit, re.MULTILINE) + check('complete measured declaration census', + set(census) == set(MODULES[:-1]) and all(a == b and a > 0 for a, b in census.values()) + and len(names) == len(set(names)) == audit.count('ATTAINMENT_AUDIT_DECL ') == AUDIT_COUNT + and totals == [str(len(names))]) + required_text = read('final-project/CriticalLevelAxiomAudit.lean').decode().split('let required : Array Name := #[', 1)[1].split(']', 1)[0] + required = set(re.findall(r'`([A-Za-z0-9_.]+)', required_text)) + check('all required declarations including both attainment targets', TARGETS <= required <= set(names)) + return census, names + + +def verify(): + check('master identity', digest(read(Path(__file__))) == document('FINAL_MASTER_START.json')['master_sha256']) + read('evidence/MASTER_CONTRACT.md') + inv = document('FINAL_SOURCE_INVENTORY.json'); ih = digest(read('FINAL_SOURCE_INVENTORY.json')) + check('frozen SHA bound', re.fullmatch('[0-9a-f]{64}', FROZEN) is not None) + check('audit count bound', isinstance(AUDIT_COUNT, int) and not isinstance(AUDIT_COUNT, bool) and AUDIT_COUNT > 0) + check('exact frozen inventory', ih == FROZEN) + prepare_start = Path(inv['prepare_start_record']) + check('preparation start locator', prepare_start.is_absolute() and prepare_start.parent == ROOT/'final-prepare-attempts') + check('preparation start and preparer binding', digest(read(prepare_start)) == inv['prepare_start_sha256'] + and digest(read('prepare_final_inputs.py')) == inv['preparer_sha256']) + initialization = document('evidence/FINAL_BUILD_INITIALIZATION.json') + check('empty final-build initialization binding', initialization['prepare_start_record'] == str(prepare_start) + and initialization['prepare_start_sha256'] == inv['prepare_start_sha256'] + and initialization['initial_objects'] == [] and initialization['build_was_created_empty'] is True) + src = {r['name']: r['sha256'] for r in inv['sources']} + check('exact seven source identities', len(inv['sources']) == 7 and set(src) == {m + '.lean' for m in MODULES}) + check('exact isolated source pathset', {p.name for p in (ROOT/'final-project').iterdir()} == set(src)) + for r in inv['sources']: + for base in ['project', 'final-project']: + b = read(Path(base)/r['name']); check(base + '/' + r['name'], len(b) == r['bytes'] and digest(b) == r['sha256']) + inputs = document('SOURCE_INPUTS.json')['sources'] + check('exact five immutable source inputs', len(inputs) == 5 and {Path(r['project_path']).name for r in inputs} == {m+'.lean' for m in MODULES[:5]}) + for r in inputs: + b = read(local_name(r['project_path'])) + check(r['project_path'] + ': SHA and Git blob', len(b) == r['bytes'] and digest(b) == r['sha256'] == src[Path(r['project_path']).name] and blob(b) == r['git_blob'] and b == read(local_name(r['input_path']))) + check('frozen phase runner', digest(read('run_final_phase.py')) == inv['runner_sha256']) + dep = document('FINAL_DEPENDENCY_ARTIFACTS.json') + check('bound dependency inventory', observed[ROOT/'FINAL_DEPENDENCY_ARTIFACTS.json'] == inv['dependency_artifact_inventory_sha256']) + check('initial dependency reuse binding', initialization['dependency_reuse'] == dep['reuse_delta']) + seq = document('FINAL_SEQUENCE_RESULT.json'); start = document('FINAL_SEQUENCE_START.json') + phases = [('build', m) for m in MODULES] + [('kernel', m) for m in NEW] + check('once sequence completed', seq['status'] == 'PASS_FROZEN_BUILD_AND_STANDARD_KERNEL_REPLAY' and seq['inventory_sha256'] == start['inventory_sha256'] == ih) + check('sequence driver binding', start['driver_sha256'] == digest(read('run_final_sequence.py'))) + check('exact nine successful phases', [(r['kind'], r['module']) for r in seq['phases']] == phases and all(r['returncode'] == 0 for r in seq['phases'])) + paths = sorted((ROOT/'final-runs').glob('*/RECEIPT.json')); rows = [document(p) for p in paths] + check('exact nine unique final receipts', len(rows) == 9 and len({(r['kind'], r['module']) for r in rows}) == 9) + receipts = {(r['kind'], r['module']): (p.parent, r) for p, r in zip(paths, rows)} + check('receipt phase set', set(receipts) == set(phases)) + known = {}; audit = '' + for kind, module in phases: + folder, r = receipts[kind, module]; label = kind + ':' + module + check(label + ': successful exact execution', r['status'] == 'PASS' and r['returncode'] == 0 and r['timed_out'] is False and r['process_reaped'] is True and r['inventory_sha256'] == ih and r['runner_sha256'] == inv['runner_sha256'] and r['executable_sha256'] == EXES[kind]) + check(label + ': stable sources and imported objects', r['source_before'] == r['source_after'] == src and r['source_unchanged'] is True and r['imported_objects_unchanged'] is True and r['objects_before'] == known) + for phase in ['before', 'after']: + d = r['dependency_' + phase]; check(label + ': dependency census ' + phase, d['reused'] + len(d['rehashed']) == len(dep['artifacts'])) + for stream in ['stdout', 'stderr']: + b = read(folder/(stream + '.txt')); check(label + ':' + stream, digest(b) == r[stream + '_sha256']) + if kind == 'build' and module != 'CriticalLevelAxiomAudit': check(label + ': clean ' + stream, b == b'') + if kind == 'build': + produced = r['produced_objects']; allowed = {module+s for s in ['.olean', '.olean.private', '.olean.server', '.ir', '.ir.sig']} + check(label + ': module outputs', module+'.olean' in produced and set(produced) <= allowed and not set(produced) & set(known)) + if module in NEW: check(label + ': warnings as errors', '-DwarningAsError=true' in r['command']) + known.update(produced) + if module == 'CriticalLevelAxiomAudit': audit = read(folder/'stdout.txt').decode() + else: check(label + ': standard named-module kernel', r['command'][1:] == ['-v', module] and Path(r['command'][0]).name == 'leanchecker' and '--fresh' not in r['command']) + check(label + ': output binding', r['objects_after'] == known and r['object_sha256'] == known[module+'.olean']) + check('final object pathset', {p.name for p in (ROOT/'final-build').iterdir()} == set(known)) + for name, h in known.items(): check(name + ': current object', digest(read(Path('final-build')/name)) == h) + census, names = validate_audit(audit) + a = document('ROOT_ACCEPTANCE.json') + lpc_token = a.get('closed_lpc_diagnostic_token', '') + check('bound actual closed-LPC diagnostic token', isinstance(lpc_token, str) and len(lpc_token.strip()) >= 4 and not lpc_token.startswith('PENDING')) + n = document('negative-final/RECEIPT.json'); text = '' + for stream in ['stdout', 'stderr']: + b = read('negative-final/' + stream + '.txt'); check('N1 ' + stream, digest(b) == n[stream+'_sha256']); text += b.decode() + check('N1 actual missing-premise rejection', n['status'] == 'PASS_EXPECTED_MISSING_PREMISE_REJECTION' and n['returncode'] != 0 and n['timed_out'] is False and n['diagnostic_match'] is True and 'type mismatch' in text.lower() and lpc_token in text and not any(x in text.lower() for x in ['unknown module', 'unknown identifier', 'unexpected token', 'object file'])) + check('N1 frozen bindings', n['inventory_sha256'] == ih and n['source_before'] == src and n['objects_before'] == known and n['lean_sha256'] == EXES['build'] and all(n[k] is True for k in ['source_unchanged', 'imported_sources_unchanged', 'imported_objects_unchanged']) and n['source_sha256'] == digest(read('negative-project/WithoutClosedLPC.lean')) and n['runner_sha256'] == digest(read('run_negative.py'))) + a = document('ROOT_ACCEPTANCE.json') + check('scoped exact formal acceptance', a['verdict'] == 'ACCEPT_SCOPED_FORMAL' and a['source_sha256'] == src['CriticalLevelAttainment.lean'] and a['source_inventory_sha256'] == ih and a['review_sha256'] == digest(read(local_name(a['review_path'])))) + check('actual nonauthor reviewer identity', all(isinstance(a.get(k), str) and a[k].strip() for k in ['author', 'reviewer', 'root', 'exposure']) and a['author'] != a['reviewer']) + check('no independent or scientific credit', a['organizational_independence_credit'] == 0 and a['human_review_credit'] == 0 and a['scientific_effect'] == 'NONE') + gh = document('GITHUB_READBACK.json'); files = gh['files']; published = set() + check('standalone public scope', gh['path_prefix'] == 'frontiers/critical_level_attainment_20261020/' and re.fullmatch('[0-9a-f]{40}', gh['head']) is not None) + for r in files: + p = local_name(r['relative_path']); check('unique published path', str(p) not in published); published.add(str(p)); b = read(Path('publication-package')/p) + check(str(p)+': native/remote/tree bytes', len(b) == r['bytes'] and digest(b) == r['sha256'] == r['remote_sha256'] and r['raw_byte_match'] is True and blob(b) == r['git_blob'] == r['tree_blob']) + check('complete publication file set', published == {str(p.relative_to(ROOT/'publication-package')) for p in (ROOT/'publication-package').rglob('*') if p.is_file()} and set(src.values()) <= {r['sha256'] for r in files}) + ci = document('HOSTED_CI_READBACK.json'); jobs = ci['jobs'] + check('exact head three successful hosted jobs', ci['head'] == gh['head'] and len(jobs) == len({j['id'] for j in jobs}) == 3 and all(j['head_sha'] == gh['head'] and j['status'] == 'completed' and j['conclusion'] == 'success' for j in jobs)) + check('native hosted repository/run/attempt and job roles', ci['repository'] == gh['repository'] == 'd6g8k5htny-coder/Math-' + and set(j['name'] for j in jobs) == {'downstream-replay', 'formal / formal-evidence', 'math-downstream-gates'} + and all(str(j['run_id']) == str(ci['run_id']) and str(j['run_attempt']) == str(ci['run_attempt']) for j in jobs)) + binding = dict(checked_commit=ci['tested_merge'], repository=ci['repository'], run_id=str(ci['run_id']), + run_attempt=str(ci['run_attempt']), receipt_sha256=ci['receipt_sha256']) + check('formal and aggregate original receipt binding', re.fullmatch('[0-9a-f]{64}', ci['receipt_sha256']) is not None + and all(str(ci[key][k]) == str(v) for key in ['formal_receipt_binding', 'aggregate_binding'] for k, v in binding.items())) + native_receipt = ci['formal_original_receipt_printed'] + check('original registered-formal receipt identity', native_receipt['checked_commit'] == ci['tested_merge'] + and native_receipt['repository'] == ci['repository'] and str(native_receipt['workflow_run_id']) == str(ci['run_id']) + and str(native_receipt['workflow_run_attempt']) == str(ci['run_attempt']) and native_receipt['scientific_effect'] == 'NONE') + check('local-only new formal execution', ci['new_formal_execution'] == 'LOCAL_ONLY_NOT_REGISTERED_IN_HOSTED_FORMAL' and ci['scientific_effect'] == 'NONE') + tool = ROOT.parent/'continuation288/PACKET/TOOLS/research_delivery.py'; check('canonical builder', digest(read(tool)) == BUILDER) + archive = ROOT/'C294_CRITICAL_LEVEL_ATTAINMENT_DELIVERY.zip'; raw = read(archive) + run = subprocess.run([sys.executable, '-B', str(tool), 'verify', str(archive)], capture_output=True, text=True, timeout=120) + check('canonical archive verification', run.returncode == 0) + with zipfile.ZipFile(archive) as z: + manifest = json.loads(z.read('DELIVERY_MANIFEST.json')); members = [r['filename'] for r in manifest['files']] + check('exact unique archive members', len(members) == len(set(members)) and len(z.namelist()) == len(set(z.namelist())) and set(z.namelist()) == set(members) | {'DELIVERY_MANIFEST.json'}) + check('complete native packet set', set(members) == {str(p.relative_to(ROOT/'PACKET')) for p in (ROOT/'PACKET').rglob('*') if p.is_file()}) + for r in manifest['files']: + b = z.read(r['filename']); check(r['filename']+': archive/native equality', len(b) == r['size'] and digest(b) == r['sha256'] and b == read(Path('PACKET')/local_name(r['filename']))) + custody = document('PRIVATE_CUSTODY_RECEIPT.json') + check('private exact uploaded/downloaded archive', custody['owner_only'] is True and custody['actual_raw_download_equal'] is True and custody['bytes'] == len(raw) and custody['sha256'] == digest(raw) and read('REMOTE_READBACK.zip') == raw) + for p, h in list(observed.items()): check('final stable bytes: '+str(p), p.is_file() and all(not q.is_symlink() for q in [p, *p.parents]) and digest(p.read_bytes()) == h) + check('final source/object pathsets', {p.name for p in (ROOT/'final-project').iterdir()} == set(src) and {p.name for p in (ROOT/'final-build').iterdir()} == set(known)) + check('final publication/packet pathsets', published == {str(p.relative_to(ROOT/'publication-package')) for p in (ROOT/'publication-package').rglob('*') if p.is_file()} and set(members) == {str(p.relative_to(ROOT/'PACKET')) for p in (ROOT/'PACKET').rglob('*') if p.is_file()}) + return {'axiom_census': census, 'axiom_count': len(names), 'canonical_verify_stdout': run.stdout, 'canonical_verify_stderr': run.stderr} + +def main(): + start, output = ROOT/'FINAL_MASTER_START.json', ROOT/'FINAL_MASTER.json' + if start.exists() or output.exists(): + print('REFUSED: final master already started; prior evidence preserved', file=sys.stderr); return 1 + try: + with start.open('x') as f: json.dump({'started_utc': now(), 'master_sha256': digest(Path(__file__).read_bytes()), 'scientific_effect': 'NONE'}, f, indent=2) + except FileExistsError: return 1 + report = {'status': 'HOLD_ARTIFACT_VERIFICATION', 'scientific_effect': 'NONE'} + try: + report.update(verify()); report['status'] = 'PASS_ARTIFACT_VERIFICATION_NOT_THEOREM_PROOF' + except BaseException as exc: report['error'] = repr(exc) + report.update(finished_utc=now(), checks=checks, check_count=len(checks), observed_sha256={str(p): h for p, h in observed.items()}) + with output.open('x') as f: json.dump(report, f, indent=2, sort_keys=True); f.write('\n') + print(json.dumps({'status': report['status'], 'checks': len(checks)})) + return 0 if report['status'].startswith('PASS_') else 1 + +if __name__ == '__main__': raise SystemExit(main()) + diff --git a/frontiers/critical_level_attainment_20261020/negative-final/RECEIPT.json b/frontiers/critical_level_attainment_20261020/negative-final/RECEIPT.json new file mode 100644 index 000000000..14f008943 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/negative-final/RECEIPT.json @@ -0,0 +1,45 @@ +{ + "started_utc": "2026-10-20T08:56:06.994502+00:00", + "source_sha256": "d685f2dff3c915cc2e3ea1db25aed672a5fc9c1886237366bf122e92c05d3f32", + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "$C294_ROOT/negative-project/WithoutClosedLPC.lean" + ], + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "runner_sha256": "ba020c1e347dbb643416d546d6274282f0d7ccede580d300dd5b99c93acc9c99", + "timeout_seconds": 600, + "meaning": "Interface rejection for the omitted actual closed-level LPC input; not a counterexample to the open Morse-to-LPC implication.", + "ended_utc": "2026-10-20T08:57:21.244688+00:00", + "seconds": 74.24818608400001, + "returncode": 1, + "timed_out": false, + "child_pid": 62259, + "diagnostic_match": true, + "source_unchanged": true, + "imported_sources_unchanged": true, + "imported_objects_unchanged": true, + "stdout_sha256": "103fca1879ac4965b80766263cab5f18f64dbe46ddbb9de70aef49976fbdafd8", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "status": "PASS_EXPECTED_MISSING_PREMISE_REJECTION" +} diff --git a/frontiers/critical_level_attainment_20261020/negative-final/START.json b/frontiers/critical_level_attainment_20261020/negative-final/START.json new file mode 100644 index 000000000..a57a61db8 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/negative-final/START.json @@ -0,0 +1,33 @@ +{ + "started_utc": "2026-10-20T08:56:06.994502+00:00", + "source_sha256": "d685f2dff3c915cc2e3ea1db25aed672a5fc9c1886237366bf122e92c05d3f32", + "command": [ + "$LEAN_RUNTIME/bin/lean", + "-j2", + "-M4096", + "$C294_ROOT/negative-project/WithoutClosedLPC.lean" + ], + "source_before": { + "ClosedSuperlevel.lean": "90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2", + "CriticalLevelAttainment.lean": "ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12", + "CriticalLevelAxiomAudit.lean": "4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358", + "Lifetime.lean": "90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6", + "MorseFiniteCritical.lean": "95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b", + "SuperlevelBar.lean": "346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9", + "TorusTopology.lean": "ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1" + }, + "objects_before": { + "ClosedSuperlevel.olean": "fb5b7385a442a7e0a9b9bf7911fa2fd65b95870b60a71d8e38031852bf1d9d37", + "CriticalLevelAttainment.olean": "ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235", + "CriticalLevelAxiomAudit.olean": "7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030", + "Lifetime.olean": "b3e14c2951b452222ca0c7b1448458cf785225971da704e4e3e6f0cc93107da4", + "MorseFiniteCritical.olean": "34ff2a9ed529609dd48a22204b8eacc66eeb943805e2d6e8dee4481cde8ef4e2", + "SuperlevelBar.olean": "e3034e68ec9141f26498835ecb4b08b4268d1c89e56b09ec85151e555fae8086", + "TorusTopology.olean": "ccb13e9469d55da8b5202706a1f013fa7a2755b2184542b8a0534f722d993125" + }, + "lean_sha256": "1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554", + "inventory_sha256": "a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d", + "runner_sha256": "ba020c1e347dbb643416d546d6274282f0d7ccede580d300dd5b99c93acc9c99", + "timeout_seconds": 600, + "meaning": "Interface rejection for the omitted actual closed-level LPC input; not a counterexample to the open Morse-to-LPC implication." +} diff --git a/frontiers/critical_level_attainment_20261020/negative-final/stderr.txt b/frontiers/critical_level_attainment_20261020/negative-final/stderr.txt new file mode 100644 index 000000000..e69de29bb diff --git a/frontiers/critical_level_attainment_20261020/negative-final/stdout.txt b/frontiers/critical_level_attainment_20261020/negative-final/stdout.txt new file mode 100644 index 000000000..764a744fb --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/negative-final/stdout.txt @@ -0,0 +1,17 @@ +$C294_ROOT/negative-project/WithoutClosedLPC.lean:19:2: error: Type mismatch + euclidean_death_attainment d L hL g hsmooth hperiodic hmorse M hnonessential +has type + LocallyPathConnectedSpace { q // superlevelBar_deathHeight g M ≤ descendedHeight d L hL g hperiodic q } → + ∃ y, + IsCriticalPoint d g y ∧ + g M < g y ∧ + ∃ Γ, + (∀ (t : ↑unitInterval), superlevelBar_deathHeight g M ≤ g (Γ t)) ∧ + ∃ t, g (Γ t) = superlevelBar_deathHeight g M +but is expected to have type + ∃ y, + IsCriticalPoint d g y ∧ + g M < g y ∧ + ∃ Γ, + (∀ (t : ↑unitInterval), superlevelBar_deathHeight g M ≤ g (Γ t)) ∧ + ∃ t, g (Γ t) = superlevelBar_deathHeight g M diff --git a/frontiers/critical_level_attainment_20261020/negative-project/WithoutClosedLPC.lean b/frontiers/critical_level_attainment_20261020/negative-project/WithoutClosedLPC.lean new file mode 100644 index 000000000..e54b142b7 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/negative-project/WithoutClosedLPC.lean @@ -0,0 +1,19 @@ +import CriticalLevelAttainment + +/-! N1: deliberately omit the actual closed-superlevel LPC premise. +Expected result: a type mismatch showing the unconsumed LPC argument, never a +syntax/import error. This is an interface guard, not a mathematical counterexample +to the separately open implication from the literal Morse assumptions to LPC. -/ + +noncomputable section +open Set Topology UniversalLaw.Spec.Lifetime TorusFiltration TorusCriticalAttainment + +example (d : ℕ) (L : ℝ) (hL : 0 < L) + (g : E d → ℝ) (hsmooth : IsSmooth d g) (hperiodic : IsLPeriodic d L g) + (hmorse : IsMorseDistinct d L g) (M : E d) + (hnonessential : ¬ superlevelBar_isEssential g M) : + ∃ y : E d, IsCriticalPoint d g y ∧ g M < g y ∧ + ∃ Γ : Path M y, + (∀ t : unitInterval, superlevelBar_deathHeight g M ≤ g (Γ t)) ∧ + ∃ t : unitInterval, g (Γ t) = superlevelBar_deathHeight g M := + euclidean_death_attainment d L hL g hsmooth hperiodic hmorse M hnonessential diff --git a/frontiers/critical_level_attainment_20261020/prepare_final_inputs.py b/frontiers/critical_level_attainment_20261020/prepare_final_inputs.py new file mode 100644 index 000000000..87aa1aefb --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/prepare_final_inputs.py @@ -0,0 +1,60 @@ +"""C294 seven-source freeze and metadata-delta reuse; run only on root's frozen inputs.""" +import fcntl, hashlib, json, shutil, sys, uuid +from run_final_phase import ROOT, PROJECT, BUILD, C291, MODULES, NEW, BASE_SHA, require, now, sha, stamp, write, runtime, dependencies + + +def main(): + require(sys.argv[1:] == ['--freeze'], 'usage: prepare_final_inputs.py --freeze (root-authorized freeze only)') + with (ROOT / 'lean-slot.lock').open('a+') as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + require(not PROJECT.exists() and not BUILD.exists(), 'final directories already exist') + require(not (ROOT / 'FINAL_SOURCE_INVENTORY.json').exists(), 'final inventory exists') + attempts = ROOT / 'final-prepare-attempts'; attempts.mkdir(exist_ok=True) + require(not attempts.is_symlink(), 'unsafe preparation record directory') + legacy = ROOT / 'FINAL_PREPARE_START.json' + prior = {'path': str(legacy), 'sha256': sha(legacy)} if legacy.is_file() else None + start_record = attempts / (now().replace(':', '').replace('+', '_') + '-' + uuid.uuid4().hex + '.json') + write(start_record, {'started_utc': now(), 'prior_legacy_start': prior, + 'status': 'STARTED; missing final inventory means interrupted preparation; no overwrite/retry cleanup'}) + sources, imports = [], {} + for m in MODULES: + p = ROOT / 'project' / (m + '.lean'); before = stamp(p); digest = sha(p) + require(stamp(p) == before, 'source changed during hash') + sources.append({'name': p.name, 'sha256': digest, 'bytes': before[0]}) + imports[m] = [n for line in p.read_text().splitlines() if line.startswith('import ') + for n in line[7:].split() if n in MODULES] + order, pending = [], list(MODULES) + while pending: + available = [m for m in pending if set(imports[m]) <= set(order)] + require(available, 'local import cycle') + for m in available: + order.append(m); pending.remove(m) + original = C291 / 'FINAL_DEPENDENCY_ARTIFACTS.json' + original_raw = original.read_bytes() + require(hashlib.sha256(original_raw).hexdigest() == BASE_SHA, 'C291 dependency inventory bytes changed') + baseline = json.loads(original_raw); roots, _ = runtime() + require(roots == baseline['roots'], 'dependency roots differ from C291') + checked, delta = dependencies(baseline) + checked.update(c291_inventory_sha256=BASE_SHA, checked_utc=now(), reuse_delta=delta) + dep_path = ROOT / 'FINAL_DEPENDENCY_ARTIFACTS.json'; write(dep_path, checked) + PROJECT.mkdir(); BUILD.mkdir() + for item in sources: + src = ROOT / 'project' / item['name'] + require(sha(src) == item['sha256'], 'source changed during freeze') + shutil.copyfile(src, PROJECT / item['name']) + require(sha(PROJECT / item['name']) == item['sha256'], 'source copy mismatch') + inv = {'frozen_utc': now(), 'prepare_start_record': str(start_record), + 'prepare_start_sha256': sha(start_record), 'prior_legacy_start': prior, 'sources': sources, 'build_order': order, 'local_imports': imports, + 'new_modules': NEW, 'runner_sha256': sha(ROOT / 'run_final_phase.py'), + 'preparer_sha256': sha(ROOT / 'prepare_final_inputs.py'), + 'dependency_artifact_inventory_sha256': sha(dep_path), 'c291_inventory_sha256': BASE_SHA, + 'scientific_effect': 'NONE', 'execution_provenance': 'LOCAL; no hosted qualification'} + write(ROOT / 'evidence/FINAL_BUILD_INITIALIZATION.json', {'utc': now(), 'initial_objects': [], + 'build_was_created_empty': not any(BUILD.iterdir()), 'dependency_reuse': delta, + 'prepare_start_record': str(start_record), 'prepare_start_sha256': sha(start_record)}) + write(ROOT / 'FINAL_SOURCE_INVENTORY.json', inv) + print(json.dumps({'stage': 'FROZEN', 'modules': order, 'dependency_reuse': delta}), flush=True) + + +if __name__ == '__main__': + main() diff --git a/frontiers/critical_level_attainment_20261020/reviews/MAIN_SOURCE_REVIEW.md b/frontiers/critical_level_attainment_20261020/reviews/MAIN_SOURCE_REVIEW.md new file mode 100644 index 000000000..0d32de861 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/reviews/MAIN_SOURCE_REVIEW.md @@ -0,0 +1,55 @@ +# C294 current-source and contender-path audit + +**Disposition: bounded source/path preflight only. No mathematical verdict.** + +Actual executor: OpenAI Codex, delegated subagent `/root/current_pr_triage_c292` in the parent research continuation. This executor read prior C292/C293 records and current native GitHub metadata, authored the bounded audit evidence and adapted C294 packaging/master scripts. It is source/history/design exposed and same-provider as the proof-author lane; it is not an independent or blind mathematical reviewer. Organizational-independence credit **0**, human-review credit **0**, scientific effect **NONE**. Shared GitHub owner-account attribution does not imply Dylan personally performed this audit. The conditional attainment proof was not substantively reviewed in this unit. + +## Exact reviewed cut + +The complete open-PR/path/source revalidation ended **2026-10-20 08:17:24 UTC**, at Math Main **`9a16ac956dc7add74a7a0a691545053b4ab3f18d`**. Earlier source-bridge triage began08:09:28Z. These were bounded sequential observations, not an atomic snapshot or a later publication clearance. This report was written afterward from the retained observations; no new remote read was used to write it. + +Native source: [Math Main at the reviewed commit](https://github.com/d6g8k5htny-coder/Math-/tree/9a16ac956dc7add74a7a0a691545053b4ab3f18d). Full native inventories/pagination and source objects are retained in `evidence/PUBLICATION_PATH_PREFLIGHT.json`; the fuller audit and policy delta are in `evidence/TRIAGE_AND_PREFLIGHT.md`. + +The native current collection contained **30 open Math PRs**. I reused **26 complete file lists with identical head AND base identities** and refreshed only **486,485,483,482** (1,4,8,78 paths respectively). Each refreshed count equaled native PR changed_files and ended on a short100-file page. The combined complete inventory had **687 changed-file occurrences /675 unique paths**. Both filename and previous_filename were checked. The final collection had exactly the same number/head/base set; Main was unchanged. The current default tree was untruncated,3147 entries. + +## Prefix and five consumed sources + +No open PR at that cut added, changed, deleted or renamed anything under **`frontiers/critical_level_attainment_20261020/`**, and that prefix did not exist in the reviewed Main tree. The proposed new unit is confined to that additive prefix. This is a by-path absence finding, not proof of global absence of mathematically equivalent work or an ownership transfer. + +The actual five C294 immutable consumed inputs are: + +| Module | Bytes | SHA-256 | Git blob | +|---|---:|---|---| +| Lifetime |51383|90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6|f2508f7f2e3fd42f22f5aa52bc5ead5ff9e73b9a| +| TorusTopology |12257|ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1|ed678ea322fe5315b3aaff44e4e2f06b018399d8| +| SuperlevelBar |15309|346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9|b047384e20306ee030154885536c531633b88bd8| +| ClosedSuperlevel |8088|90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2|a4323cb50fb2d5861c4e6240a18684bfb566fb80| +| MorseFiniteCritical |9445|95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b|989fabc6e8f04b0c4a36dff9b21d33b1299f7b92| + +`SOURCE_INPUTS.json` binds their actual input_path/project_path copies and native identities. Lifetime/TorusTopology/MorseFiniteCritical are consumed from the exact C293 source package. SuperlevelBar is the frozen C292 companion input; ClosedSuperlevel is the exact retained companion input used by the elder runtime. The hash statements here distinguish those local frozen bytes from a new compiler execution or theorem review. + +Canonical ElderBridge, TorusTopology, SuperlevelBar and Lifetime blobs matched across reviewed Main9a16ac95, C292 landing **c055af07b9a349db4bdc2acf2033e0f27b450605**, and C293 source head **0ea97aff489f9420632b4cee81ad82dbec5fe88e**. C292's retained input copies matched too. ElderBridge blob is **a59ee9daab7b67eafd7e4f806b27244bcc5caed1**,3683B; it is an unchanged interface reference, **not a sixth imported C294 source module**. + +No current open PR at the reviewed cut edited the four canonical input paths checked by the complete inventory. The five C293 Lean additions belong to PR482, which remains an unmerged immutable source dependency; use of its input bytes does not claim a source merge. Its five additions plus477's identical Lifetime snapshot were the only six matching module-basename occurrences in the open diff inventory. + +## Preserved owner and review boundaries + +- **C258 component kernel:** preserve [pickup6114716011](https://github.com/d6g8k5htny-coder/Math-/pull/419#issuecomment-6114716011), UUIDbe00b435-ab38-4b29-b10d-822adae905c4/WE1907, and [unreleased recovery status6126472707](https://github.com/d6g8k5htny-coder/Math-/pull/419#issuecomment-6126472707). This audit neither releases nor duplicates that kernel. Its allocation excludes the separate Morse/path-lift/geometric adapter route. No ComponentKernel.lean path in reviewed Main is not proof that unpublished recovery bytes or helpers do not exist. +- **Claude companion source/registration:** [allocation6114655970](https://github.com/d6g8k5htny-coder/Math-/pull/419#issuecomment-6114655970) retains Anthropic Claude session_01Cz7WZybv8znP64SpPj6sWY's companion route. C294 consumes fixed input bytes; no TorusTopology, SuperlevelBar, ClosedSuperlevel, OrdinaryH0 or companion workflow edit is implied. +- **Elder source/result:** Root01a11cbf's [475 terminal release6243065360](https://github.com/d6g8k5htny-coder/Math-/pull/475#issuecomment-6243065360) completed the source/integration stage. Existing ElderTrap and one-summand results remain reusable dependencies. Their source integration or provider-distinct replay is not hosted registration. +- **Production formal/elder registration:** the reviewed [Math312 disposition](https://github.com/d6g8k5htny-coder/Math-/pull/312) retains OpenAI/GPT-5.6 Sol, round11-gate-hardening-20261005. The [elder compatibility handoff6243161277](https://github.com/d6g8k5htny-coder/Math-/pull/312#issuecomment-6243161277) does not transfer production gate, manifest, binding or Lake-root ownership. +- **C293/Math485:** C293's own delivery/closeout is complete and is not reopened. The separate [hosted engineering PR485](https://github.com/d6g8k5htny-coder/Math-/pull/485), head a5f613807505ba0c717b7b8d38bec7abf3ad0dfc stacked on482, keeps its own author/integration route. [Test-only AMEND6279832520](https://github.com/d6g8k5htny-coder/Math-/pull/485#issuecomment-6279832520) was personally released by its reviewer and is already routed by [Main419/6280950075](https://github.com/d6g8k5htny-coder/main/issues/419#issuecomment-6280950075); do not duplicate it or infer author availability from an errored chat. Historical successful checks do not qualify a new current-Main composition. +- **Other routed engineering:** Main460's later hosted-controls proposal [6286559841](https://github.com/d6g8k5htny-coder/main/issues/419#issuecomment-6286559841) is already ATW/R03 work; no duplicate. + +These historical allocations plus current exact paths define boundaries, not a blanket assertion that every historical claim is resolved. Parent owns current R17/Main-board reconciliation and C294 claim2392/2afaffe8-cf58-4bc7-9824-7585f9feb788. + +## Limits and required next freshness check + +This audit performed **no source/ref/workflow mutation, new claim, review submission, CI rerun or credential retry**. Its later local writes were explicitly delegated audit/packaging evidence, not changes to consumed proof/companion/kernel/registration source. It establishes no whole-project closure, mathematical acceptance, theorem correctness, local Morse normal form, closed-superlevel LPC, complete C292 formal adapter, all-bars result, stochastic transfer, count/collision closure or scientific promotion. + +C294's intended result remains conditional on explicit **actual closed-superlevel local path connectivity**; this audit does not discharge that admission or replace it with a supplied path or event list. A separate substantive exact-source nonauthor mathematical review remains required. + +**Before publication, perform a fresh bounded read** of current Main/ref/tree, the exact final candidate prefix and five input identities, changed/new open-PR head/base file inventories, and current related ownership/claims. Reuse unchanged exact identities, refresh deltas, and bind that later check to the actual final candidate. The08:17:24Z cut is not that future clearance. + +[Owner mandate](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OWNER_MANDATE_20261015.md) and [standing delegation](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OP-AUTONOMY-20260923-v2.1.md) accompany this handoff; links do not prove recipient reading. + diff --git a/frontiers/critical_level_attainment_20261020/reviews/NONAUTHOR_REVIEW.md b/frontiers/critical_level_attainment_20261020/reviews/NONAUTHOR_REVIEW.md new file mode 100644 index 000000000..d08c47c8e --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/reviews/NONAUTHOR_REVIEW.md @@ -0,0 +1,246 @@ +# C294 exact-source nonauthor mathematical and formal-evidence review + +**Verdict: ACCEPT_SCOPED_FORMAL.** + +The accepted result is the conditional deterministic attainment theorem in the exact source identified below: from the literal smooth periodic Morse field, a positive period, literal nonessentiality at a prescribed start, and explicit local path connectedness of the actual closed death superlevel, it constructs a strictly older critical endpoint and a path that stays at or above the literal C263 death and attains it. Its Euclidean lift starts at the prescribed point and has a literal critical endpoint. + +This verdict covers substantive source reasoning, exact interfaces, the observed seven isolated local builds, two standard named-module kernel replays, complete six-module axiom census, and the actual omitted-LPC rejection. It does not discharge the Morse-to-closed-superlevel-LPC implication, strict death drop, the full C292 trap/ordinary-H0 adapter, exhaustive bars, probabilistic transfer, scientific acceptance, hosted registration, or subsequent publication/private custody. + +No must-fix mathematical, interface, or observed execution-evidence finding remains for that scope. + +## Reviewer, authorship, and exposure + +Reviewer: OpenAI Codex delegated agent `/root/c292_geometry_review`, acting for Dylan Roy. Proof implementation: OpenAI Codex `/root/adapter_feasibility_c292`. Root `/root` coordinates and authored the execution/audit/negative controls. The separate current-source/path audit belongs to `/root/current_pr_triage_c292` and is not this mathematical review. + +The reviewer previously reviewed C292 and C293, inspected their exact prerequisite sources, and suggested the finite-endpoint/compact-intersection/conditional-LPC mathematical proof shape before implementation. The reviewer then read two development candidates, their diff, the stable full source, relevant pinned Mathlib APIs, and the final records. This is a nonauthor review with prior mathematical design and source exposure, not a blind review. + +The reviewer did not author or modify Lean proofs, audit or negative fixtures, runner/preparer/master source, or root documents, and did not execute Lean or a kernel checker. Reviewer actions were read-only source/evidence inspection, independent byte/hash and record-consistency checks, independent parsing of the complete raw axiom stream, and writing review reports. No remote post or publication action was performed by this reviewer. + +Provider/organization independence credit: **0**. Human review credit: **0**. No personal review by Dylan is claimed. Scientific effect: **NONE**. + +Earlier review records remain intact: + +| Record | SHA-256 | +| --- | --- | +| `reviews/PREFLIGHT_REVIEW.md` | `0fe1ae9d7206897fff7bfc28ccac8c8a421bd1c457788594b674fe658b9a81cf` | +| `reviews/CANDIDATE_REVIEW_38f5a01c.md` | `c82587ca3f49a445bc1d85fb3cd49568f0d10a1ff36a35a03f62062f9258169c` | +| `reviews/CANDIDATE_ADDENDUM_ec4b6ceb.md` | `7db802098e542bf7c3473a0c2f524018c1ff67e3caaa881125e0055612df07d7` | + +This final review supersedes their pending final-execution status for the exact frozen source; it does not erase their narrower historical scope or any failed development attempt. + +## Exact source and inventory binding + +All local relative paths in this report are relative to `$C294_ROOT/`. + +Main source: `final-project/CriticalLevelAttainment.lean`, **14,338 bytes**, SHA-256 **`ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12`**, Git blob **`1579751ec03c14f3dfd90df98db7a37d8ca74e09`**. The author project and preserved stable attempt copy have the same bytes. + +Frozen seven-source inventory: `FINAL_SOURCE_INVENTORY.json`, SHA-256 **`a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d`**, frozen at `2026-10-20T08:43:07.492616+00:00`. + +| Frozen module | Bytes | SHA-256 | +| --- | ---: | --- | +| `Lifetime.lean` | 51383 | `90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6` | +| `TorusTopology.lean` | 12257 | `ddb145b3f791c181d4f2a51e54e711937297bd6476ba55bcd5252b7ddb57cfe1` | +| `SuperlevelBar.lean` | 15309 | `346eea948e18d5904422904006827930e27d3141ccbc19ee8ac2c24bcf65a4a9` | +| `ClosedSuperlevel.lean` | 8088 | `90d1481b75d9c6d14e462c3fbf0bf7c7cdd0efb9eaad68d6732400658753b1c2` | +| `MorseFiniteCritical.lean` | 9445 | `95a660134eda49eecfe6181884bd23b4e4ca210e228d2463de29e5f821df047b` | +| `CriticalLevelAttainment.lean` | 14338 | `ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12` | +| `CriticalLevelAxiomAudit.lean` | 2719 | `4b1586855ad431821b1e2a56c3a8b1d5b21850417f73a1da3e0ade8efad96358` | + +The reviewer independently matched the frozen file hashes to this inventory. The five immutable `project/` and `inputs/` pairs also match their bound source hashes. `SOURCE_INPUTS.json`, SHA-256 `ac1e1a30f554acde9f336aacfb0cbb6bae02b093a705a4de4c3edc8ab86fb0bf`, identifies these exact local source copies and their Git blobs. Mathlib is pinned to `d13f23b723b8a846827a245b89c10fc7d3f11612`. + +C293 is consumed as an exact immutable source dependency; this review does not assert that its unmerged source PR is in current default Main. The source/path agent's remote cut and later parent-reported publication refresh are separate observations. The reviewer independently checked local source identities and relevant semantics, not the entire remote repository or all unpublished owner artifacts. + +## Literal theorem interface + +The public results are `TorusCriticalAttainment.quotient_death_attainment` and `TorusCriticalAttainment.euclidean_death_attainment`. Their assumptions are: + +1. Natural dimension `d`, real period `L`, and `0 < L`. +2. The actual Euclidean field `g`, with literal `UniversalLaw.Spec.Lifetime.IsSmooth`, `IsLPeriodic`, and `IsMorseDistinct`. +3. A specified Euclidean start `M`. +4. Literal `¬ TorusFiltration.superlevelBar_isEssential g M`. +5. Explicit `LocallyPathConnectedSpace` of the actual subtype + `{q : torus_quotient d L hL // superlevelBar_deathHeight g M ≤ descendedHeight d L hL g hperiodic q}`. + +`descendedHeight` is the existing `torus_descend` with a proved transport between the two identical lattice-periodicity formulas. The start is the actual `torus_proj M`. The death is the original `superlevelBar_deathHeight g M`, not a newly chosen level or an assumed critical value. The critical set is C293's full image of literal `fderiv ℝ g x = 0` points. + +The quotient conclusion supplies an actual critical class `Q` with strictly older height, a path from `torus_proj M` to `Q`, its pointwise closed death lower bound, and an equality with death at some path point. The Euclidean theorem supplies an actual `y` with `IsCriticalPoint d g y`, `g M < g y`, and a `Path M y` with the same bound and attainment. + +There is no hypothesis supplying a fixed older endpoint, finite event list, path, death attainment, trap, saddle pairing, or barcode result. No section variable or helper introduces such a hidden premise. In particular, importing Lifetime's interface structures does not instantiate or consume their desired elder-pair conclusions. + +The closed-level LPC premise is substantive and remains explicit in both source statements and the actual final printed signatures. Ambient torus LPC is separately derived from the quotient instance and is used only where appropriate. It is not treated as an instance for the closed death subtype. + +The final public API is conditional. Its proof internally selects one older endpoint in every closed subdeath component before converting connectedness to a path; it does not export a separate unconditional uniform-endpoint theorem. The final single closed path also stays strictly above every level less than death, but this consequence retains the conditional path theorem's hypotheses. + +The theorem does not require `M` to be a nondegenerate maximum and does not prove strict death drop. C263's non-strict `death ≤ g M` is sufficient for this unit. Natural dimension zero is allowed, with a vacuous nonessential case. Full `IsMorseDistinct` is retained, although C293 finiteness uses its nondegeneracy part rather than distinct critical heights. + +## Substantive mathematical reconstruction + +### Component maxima produce actual older critical points + +Write `X` for the actual compact quotient, `F` for descended height, `m = torus_proj M`, and `delta` for literal death. For each real `a < delta`, C263's guarded death bound gives `a < delta ≤ g M`. The actual strict-cut theorem provides a Euclidean path to some `y` with `g M < g y`, staying strictly above `a`. + +Projecting that path places `torus_proj y` in the closed connected component `K_a` of `m` inside `{F ≥ a}`. The implementation uses `JoinedIn`, its subtype path, and path-component containment in the connected component. It does not assume the whole closed level is path connected. + +`closed_connectedComponentIn` proves that a component of a closed subtype is closed in the ambient space. Actual torus compactness makes `K_a` compact, and it is nonempty because it contains `m`. A continuous maximum `Q_a` on `K_a` has value at least that of the projected older witness. Consequently `F Q_a > g M ≥ delta > a`. + +The crucial local-maximum argument is valid for these closed components. Since `Q_a` lies strictly above the threshold, `{F ≥ a}` is a neighborhood of `Q_a`. Ambient local connectedness gives that its connected component is a neighborhood as well, via the pinned Mathlib `connectedComponentIn_mem_nhds`. A maximum on this neighborhood is a local maximum of `F` in `X`. + +Candidate `quotient_locallyPathConnectedSpace` derives ambient quotient LPC from the quotient topology, supplying ambient local connectedness for this step. No LPC assertion about the closed death level is used here. + +The local maximum pulls back along the continuous projection to a Euclidean local maximum, whose literal derivative is zero. This yields membership in the actual projected critical set. The local-max helper lacks a smoothness hypothesis because the inherited `fderiv` convention also makes the derivative zero at nondifferentiability; the public theorem separately assumes literal smoothness. It does not substitute a nonsmooth formal zero for the public smooth-field premise. + +### Finite selection preserves strict olderness + +Let `C` be the actual projected critical set intersected with `{q | g M < F q}`. C293 makes the full critical set finite, so `C` is finite and compact. The proof does not assert that the strict older region is closed. + +For each `a < delta`, the preceding construction shows `C ∩ K_a` is nonempty. The family `K_a` is directed downward: the level `max a b` remains less than delta, and its component is contained in the components at both lower levels. The stable source explicitly unfolds the subtype inequalities and has the correct reverse-inclusion direction. + +If `C` missed `⋂ K_a`, compact directed-family elimination would make it miss one `K_a`, a contradiction. Thus one point `Q` lies in `C` and in every `K_a`. Its strict olderness and literal critical membership are retained by membership in the finite set `C`, not by passing a strict inequality through an arbitrary convergent sequence. + +### Compact intersection connectedness is proved separately from path connectedness + +The generic helper `preconnected_iInter_of_directed` assumes a compact Hausdorff ambient space, a nonempty index type, closed preconnected members, and a downward-directed family. It proves preconnectedness of their intersection by compact-Hausdorff separation. + +A cover of the closed intersection by disjoint closed sets has disjoint open neighborhoods by normality. The compact complement of their union misses the intersection; directed-family elimination therefore places some entire `K_a` in the union. Preconnectedness puts that `K_a` in one open side. The original closed cover and disjointness then place the whole intersection in the corresponding closed side. This is the required preconnectedness characterization. + +The helper does not require a nonempty intersection, because the empty set is preconnected. The actual application explicitly retains both `m` and `Q` in the intersection. Hausdorffness of the actual quotient is derived from closedness of its discrete period lattice. + +The intersection lies inside `{F ≥ delta}`: a point of value below delta would admit a real `a` strictly between its value and delta, contradicting membership in `K_a`. Thus a preconnected set containing both endpoints lies in the actual closed death superlevel. + +This establishes their connected-component relation in that subtype. Only then does the explicit closed-subtype LPC premise identify connected and path components. Mapping the resulting subtype path back to the quotient preserves endpoints and the pointwise lower bound. No false general claim that a compact connected set is path connected is used. + +### Literal death attainment is a conclusion + +Suppose the resulting closed path never equalled delta. Its existing lower bound would then make all values strictly greater than delta. The existing torus/Euclidean strict-higher-path equivalence would place delta itself in the literal clearance set. This contradicts `superlevelBar_death_not_mem_clearance`. + +The result therefore gives an actual equality at a path point together with the global lower bound. This is attainment of that path's minimum. It does not assume death is an attained level, invoke a different maximin definition, or infer a critical saddle at the attaining point. + +### Criticality is proved at the actual lifted endpoint + +`torus_path_lift_from` lifts the final quotient path from the prescribed `M`, returning an existential endpoint `y` and `torus_proj y = Q`. The theorem does not preselect an arbitrary lattice representative. Applying descended height to the projection and path-lift equalities preserves strict older height and every path value. + +C293's `mem_quotientCriticalSet_iff` gives zero descended derivative at `Q`. Substituting the actual endpoint projection reduces this to `fderiv ℝ g y = 0`, establishing literal criticality of the endpoint produced by the lift. The same lifted path and the previously obtained time establish exact death attainment. + +## Compatibility with existing component and elder APIs + +The preflight inspected exact `ClosedSuperlevel.lean` and `OrdinaryH0.lean` blobs `a4323cb50fb2d5861c4e6240a18684bfb566fb80` and `7bc5f80028271e0e33d857e60496ca4cadaa9364`, respectively. Their relevant declarations identify path-component equality or ordinary H0 point-difference vanishing with `JoinedIn`; they do not construct the limiting death-level path from subdeath paths. + +The existing ElderTrap record contains `closed_path` as a field. The inspected elder boundary/clearance adapters consume a supplied older closed path and trap geometry. C294 does not use those inputs to derive the missing path circularly. Its formal addition is the conditional endpoint/attainment construction and the compact-topology argument, not a new conventional mathematical discovery beyond C292. + +The local C258 prose dependency allocation and the parent/path-agent inventories do not establish universal absence of equivalent unpublished work. Existing component-kernel, companion/source, production-registration, and C293 engineering owners retain their scopes. This review grants no ownership transfer. + +## Final local execution records + +`FINAL_SEQUENCE_RESULT.json`, 2,179 bytes, SHA-256 `38f9d6ec096c3ce6136c5a2a9b514b172b226baffcf3356ba94df3976cfd8cab`, reports `PASS_FROZEN_BUILD_AND_STANDARD_KERNEL_REPLAY` for nine serial phases. The sequence ran from `2026-10-20T08:43:13.224447+00:00` to `2026-10-20T08:56:01.524659+00:00`. + +The reviewer checked every terminal receipt, its actual output stream hashes, the exact frozen source map, the sequential imported-object/produced-object chain, and current final object hashes. Every phase returned 0 without timeout, recorded reaped execution and unchanged source/imported objects, and matched the same frozen inventory. There are exactly seven build receipts and two kernel receipts. + +| Phase and module | Final run directory | Seconds | Receipt SHA-256 | +| --- | --- | ---: | --- | +| Build Lifetime | `20261020T084313Z-build-Lifetime-f6a32f33` | 97.0564 | `f2a6d46be92dcf11e26af3d7bbdc052cd5f16f58f697790ffd0fa0328d8e9a68` | +| Build TorusTopology | `20261020T084450Z-build-TorusTopology-d84fe754` | 91.4742 | `db6d742d26a8bda5c1d9b60612bdb9d7c76d1a8a8299628ca9cc5aac854c7e2d` | +| Build SuperlevelBar | `20261020T084621Z-build-SuperlevelBar-238d9b84` | 85.8426 | `8737621e1c2e2d34e6c68d452f3d19a693960ff3a066b431194ec480a45ebbb9` | +| Build ClosedSuperlevel | `20261020T084747Z-build-ClosedSuperlevel-92d589b7` | 80.1101 | `e74ec589139dc74b9f41dc87ec20442ef8c7b8ac6ec76d33c8777ddd8627e9e8` | +| Build MorseFiniteCritical | `20261020T084908Z-build-MorseFiniteCritical-17f9406a` | 83.1224 | `799656ceacdbbb31a30b235ed1ee0af7874774ac754f79b0bf02b6acd62e673f` | +| Build CriticalLevelAttainment | `20261020T085031Z-build-CriticalLevelAttainment-333ded49` | 84.1803 | `323942805f07c479d847d9fd94a666c06dd9be7efcd0e6651d35a35af032fd93` | +| Build CriticalLevelAxiomAudit | `20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3` | 100.5573 | `5a36871eb48ea16068bbe700964f656820d4b7861a33fc86f20c5b5b96c79570` | +| Kernel CriticalLevelAttainment | `20261020T085336Z-kernel-CriticalLevelAttainment-c93b2133` | 73.7995 | `0c0322d5a37980b74d1bf20c8e5bf6463f4d672761a6b121aa6f249b57becad4` | +| Kernel CriticalLevelAxiomAudit | `20261020T085450Z-kernel-CriticalLevelAxiomAudit-efc3c689` | 71.4081 | `1466292a0c9b147da2b920d1184443c7d3ee5fddbeef8b799f88e21dfe1fb150` | + +Each row's receipt is `final-runs//RECEIPT.json`. + +The final build directory was created empty according to the inspected preparer and initialization record. The final sequence rebuilt all five immutable local inputs and both new modules. The two new builds used `-DwarningAsError=true`; the immutable input builds did not add that flag. All non-audit build stdout/stderr streams are empty. The audit stdout contains its requested signatures/census/progress, and its stderr is empty. + +The two kernel commands are `leanchecker -v CriticalLevelAttainment` and `leanchecker -v CriticalLevelAxiomAudit`. Each stdout names the module being replayed and each stderr is empty. These are **standard named-module kernel replays against imported dependencies**, not `--fresh`, an external replay, or fresh verification of every imported module. + +The new output object SHA-256 values are: + +- `CriticalLevelAttainment.olean`: `ea5f6a80ee778ec7708ddc1775cfbf829372127958a0db23efc7a7e1c7d5e235`. +- `CriticalLevelAxiomAudit.olean`: `7703c951a828d5deb5eb0635fefd6105eed5671bb37c605dc28f2043e7665030`. + +Actual Lean executable SHA-256: `1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554`. Actual leanchecker executable SHA-256: `cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35`. + +The dependency inventory `FINAL_DEPENDENCY_ARTIFACTS.json` has SHA-256 `834e1c65f1c32e1b6660ae2fda385e46e741cc371b05652d407d0b173ad04476` and contains **83,897 artifacts totaling 8,418,477,755 bytes**. It reuses the bound C291 byte hashes under exact path, size, mtime_ns, and inode matches, with metadata changes requiring byte rehash. The freeze and all final phase records report 83,897 reused entries and zero rehashes. This is explicitly **not a fresh full dependency-byte census or dependency rebuild**. The reviewer verified the inventory binding and records, not an independent reread of those 8.4 GB. + +## Complete actual axiom census + +Raw output: `final-runs/20261020T085155Z-build-CriticalLevelAxiomAudit-eafd87e3/stdout.txt`, **30,642 bytes**, SHA-256 **`062a8168ad5b05f1238ea8fd516d7fc5a806941cf77480b6de6837921c294386`**. + +The reviewer read the full stream in bounded chunks, then independently parsed all declaration records, including multiline axiom arrays, and checked module totals, uniqueness, record-marker counts, and the permitted axiom set. This did not invoke Lean or root's validator. + +| Origin module | Reported count | Independently parsed count | +| --- | ---: | ---: | +| Lifetime | 103 | 103 | +| TorusTopology | 38 | 38 | +| SuperlevelBar | 25 | 25 | +| ClosedSuperlevel | 32 | 32 | +| MorseFiniteCritical | 20 | 20 | +| CriticalLevelAttainment | 17 | 17 | +| **Total** | **235** | **235 unique** | + +The source audit enumerates all constants by module origin in the non-exporting environment, including generated/private declarations, checks that they are kernel declarations, and collects transitive axioms. It does not restrict itself to an authored-name prefix. The new module's 17 census declarations comprise its 13 explicit declarations plus generated helpers/equations, including equations whose namespace reflects an imported definition. + +Every actual record uses only `propext`, `Classical.choice`, and `Quot.sound`; no additional axiom appears. Both target `#print axioms` results name those same three standard axioms. The final printed target signatures retain the exact closed-level LPC premise and the literal desired conclusion. The module-origin census does not treat the imported interface structures' fields as global assumptions establishing the missing research results. + +Root's `evidence/MEASURED_AXIOM_CENSUS.json`, SHA-256 `6e8d850e396b964694bd7033d6e5be1fd4639ccf335328ff49ef72396d28387c`, agrees with the independently inspected raw output. Its validator count is supporting engineering evidence; the acceptance here rests on the actual source and raw records as well. + +## Actual negative control and mathematical boundary checks + +The executable N1 fixture is `negative-project/WithoutClosedLPC.lean`, 989 bytes, SHA-256 **`d685f2dff3c915cc2e3ea1db25aed672a5fc9c1886237366bf122e92c05d3f32`**. It calls the actual Euclidean theorem with every argument through nonessentiality while deliberately omitting its final explicit closed-superlevel LPC argument. + +The observed final receipt is `negative-final/RECEIPT.json`, 2,825 bytes, SHA-256 **`8ca6e056a828a1867dab0109b3368627e9be88417835534f791775ecebe8acf1`**. It ran from `2026-10-20T08:56:06.994502+00:00` to `2026-10-20T08:57:21.244688+00:00`, returned **1**, did not time out, and took **74.248186084 seconds**. Its status is `PASS_EXPECTED_MISSING_PREMISE_REJECTION`. + +Actual stdout is 841 bytes with SHA-256 **`103fca1879ac4965b80766263cab5f18f64dbe46ddbb9de70aef49976fbdafd8`**. Stderr is empty. The reviewer read the full diagnostic and verified its receipt hashes and source/object/inventory bindings. + +The diagnostic at fixture line 19 is the intended type mismatch: the partial theorem application has type + +`LocallyPathConnectedSpace {q // death ≤ descendedHeight q} →` the existential conclusion, + +while the fixture expects the existential conclusion itself. It is not an import, unknown-identifier, syntax, timeout, or process failure. The frozen sources, negative source, and imported final objects remain unchanged. This checks the actual exported interface; it does **not** disprove the separately open formal implication from literal Morse data to that LPC premise. + +Other substantive negative checks are mathematical/interface checks, not newly executed C294 control modules: + +- A sequence of values strictly above the start height may converge to the start height. The proof avoids this invalid strict-inequality limit by choosing from the finite older critical set. +- Compact connected spaces need not be path connected; the closed topologist's sine continuum is a generic caution. The proof uses a separately supplied LPC property of the actual closed death subtype. This is not presented as a counterexample satisfying literal smooth Morse torus hypotheses. +- A path to an older endpoint that stayed strictly above literal death would contradict the actual C263 death-clearance exclusion. The proof uses this contradiction to derive equality somewhere. +- The existing torus arbitrary-endpoint control prevents treating a quotient lift as ending at any chosen lattice representative. The implementation uses the actual existential lift endpoint and proves its criticality. +- The inherited negative-essential C263 constant example explains why the nonessential guard cannot simply be omitted from a general death-at-most-start assertion. It is not a Morse counterexample. + +No separate C294 controls module was added or claimed. The new executable control is exactly N1; the remaining checks concern the source logic and inherited APIs. + +## Execution engineering and retained history + +The reviewer read the complete final phase runner, preparer, sequence driver, negative runner, and current artifact-master source. Their inspected identities are: + +| File | SHA-256 | +| --- | --- | +| `run_final_phase.py` | `089f11f1cc677892ff9e4a4c43427d1a20d0f4186dae8ab1fe4199c295d726f9` | +| `prepare_final_inputs.py` | `53a84ed98df9b694d75cae29460c5e9cb79150e04ad318afcae94297a5c4e8e8` | +| `run_final_sequence.py` | `8cb8a75b384c0c84f1a000f217616a3d99710b34bf2e04237b65f220ff9302ce` | +| `run_negative.py` | `ba020c1e347dbb643416d546d6274282f0d7ccede580d300dd5b99c93acc9c99` | +| `final_master.py` | `14c82931a8528019e0fd5b745937ef1f776d5689965ba9de8735c2dbd12bbbf8` | + +The observed runner checks the frozen source set, executable and dependency identities, same-freeze import-object receipts, absent prior target outputs before a fresh build, pre/post source/object consistency, and terminal process state. It serializes execution, binds outputs to exact receipts, preserves failed attempts, and rejects implicit reruns over existing module outputs. The preparer creates isolated empty final directories and derives the local build order from the exact imports. The driver stops at an unresolved phase failure. + +The artifact master's source uses complete multiline audit parsing and checks its record-marker count, uniqueness, module counts, standard axioms, required targets, nine-phase object chain, negative diagnostic, exact review binding, and later delivery inputs. No source-level blocker was found in this inspected engineering scope. Its eventual execution and public/private custody inputs have **not** been accepted by this review; no master execution was performed by the reviewer. Its archive verifier and later hosted/publication checks are artifact gates, not mathematical proof. + +The inspected contract `evidence/MASTER_CONTRACT.md` has SHA-256 `b727da20efcf4f3b7cb11731af40bb97b1ec3bf93eb9d856ca3585d2860e85c2`. `SCOPE.md` has SHA-256 `505556eba193ebe2e3e064c76ebbcf056c5557d5e220f84c673b1394bce6d7ff`. Root's mathematical check has SHA-256 `ec2034b3abc7998015edf8b2c74f435ada9cf199320b6ad072f4cb2d122b5439`, and its execution-history record has SHA-256 `8f434fa12a8e9e59ad3609b29c289abf430212bee6073a32266ae71f169d297c`. Their stated theorem and evidence boundaries agree with the actual source/records inspected here. + +The retained development history includes two unchanged-input 240-second timeouts, a successful development SuperlevelBar build, three genuine main-source elaboration failures, and the final clean development success. The reviewer inspected all three main-source failure diagnostics/receipts and the clean stable-source receipt; the immutable-input timeouts and development object-reuse route are documented in root's retained history and are not represented as new successful C294 input builds. The later final sequence did freshly build all seven local modules. + +The successful stable development receipt has SHA-256 `e64482068df7b48ac984c156054188b09b4ef865b504e6d1faa39334875aab1c`, return code 0, 73.722536833 seconds, unchanged `ec4b6ceb...` source, and empty streams. It is distinct from the final frozen build receipt. The final successful source differs from reviewed candidate `38f5a01c...` only by explicit subtype-inequality elaboration in directedness; no theorem hypothesis or conclusion changed. + +## Accepted scope and unresolved work + +The substantive argument is sound for the stated conditional theorem, its interfaces retain the literal source meanings, and the actual final formal records support that exact artifact. The LPC premise has not been silently inherited, the older endpoint is genuinely derived, strict olderness survives selection, the closed path attains the literal death, and the lifted endpoint's criticality is proved at the endpoint actually produced. + +The following remain outside this acceptance: + +- Formal derivation of local path connectedness of the actual closed superlevel from literal smooth Morse data. +- Formal strict death drop, closed trap construction with ceiling/frontier bounds, and the full C292 adapter into the existing ordinary-H0 direct-summand result. +- Identification/uniqueness of an elder saddle, branch-adjacency equivalence, exhaustive once-counted finite bars, and an all-small-bars converse. +- Almost-sure Morse admission, field-first sampling, measurability, weighted critical-pair/contact-integral transfer, and regional shrinking multiple-witness collision closure. +- Fresh verification of all imports, provider/organization-independent replay or review, human review, production formal registration, and scientific promotion. +- Publication refresh, hosted engineering results, private upload/download custody, or final artifact-master execution occurring after this review. + +Acceptance is **ACCEPT_SCOPED_FORMAL for source `ec4b6ceb9475143434c25269bccc45cdd627d83af359609007001c9284bb9a12` under inventory `a819e8a4cf37b3b3527dd32045fc08c5dd5967022c2d70c1ee009add352a1f2d`**, with the exact evidence and limitations above. A later source or relevant evidence change requires a new bound assessment; this verdict does not transfer automatically to changed bytes or broader claims. diff --git a/frontiers/critical_level_attainment_20261020/run_final_phase.py b/frontiers/critical_level_attainment_20261020/run_final_phase.py new file mode 100644 index 000000000..8fe94e499 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/run_final_phase.py @@ -0,0 +1,218 @@ +"""C294 serial isolated build / standard named-module kernel replay (not --fresh).""" +from pathlib import Path +from datetime import datetime, timezone +import fcntl, hashlib, json, os, signal, stat, subprocess, sys, time, uuid + +ROOT = Path(__file__).resolve().parent +PROJECT, BUILD = ROOT / 'final-project', ROOT / 'final-build' +C291 = ROOT.parent / 'continuation291' +CACHE = Path('$PINNED_PROJECT') +BIN = Path('$LEAN_RUNTIME/bin') +MODULES = ['Lifetime', 'TorusTopology', 'SuperlevelBar', 'ClosedSuperlevel', 'MorseFiniteCritical', 'CriticalLevelAttainment', 'CriticalLevelAxiomAudit'] +NEW = MODULES[5:] +BASE_SHA = 'b78b6e0f99bd38c633ae2677c55698363b1290e6d4318e505991c8df259ae2e3' +MANIFEST_SHA = 'd63753befccc21923783a5085148e3ff028d97134ea52f5a08bd87ecf1b0b043' +EXE_SHA = {'lean': '1b370cfcbf44e80d1b004ab1b1ab9a4c73951f9f7c242140bcff9bc577576554', + 'leanchecker': 'cfde41cb11dde58c84e9c60c551fd104bb2fc1104ad44dca932a923120272a35'} +# C294 immutable Lifetime development load hit240s with empty diagnostics. +# Set a bounded600s final phase cap before freezing; no thread/memory expansion. +TIMEOUT = 600 + + +def require(ok, message): + if not ok: + raise RuntimeError(message) + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def sha(p): + h = hashlib.sha256() + with p.open('rb') as f: + for b in iter(lambda: f.read(1024 * 1024), b''): + h.update(b) + return h.hexdigest() + + +def stamp(p): + s = p.lstat() + require(stat.S_ISREG(s.st_mode) and s.st_nlink == 1, 'nonregular/hardlinked file: ' + str(p)) + return [s.st_size, s.st_mtime_ns, s.st_ino] + + +def write(p, data): + with p.open('x') as f: + f.write(json.dumps(data, indent=2) + '\n') + + +def dependency_paths(roots): + paths = [] + for root in map(Path, roots): + require(root.is_dir() and all(not p.is_symlink() for p in [root, *root.parents]), 'unsafe dependency root') + for p in root.rglob('*'): + require(not p.is_symlink(), 'dependency symlink: ' + str(p)) + if p.is_file() and ('.olean' in p.name or '.so' in p.name or p.name.endswith(('.ir', '.ir.sig', '.dylib', '.dll'))): + paths.append(str(p)) + return sorted(set(paths)) + + +def dependencies(baseline): + """Reuse bytes only at identical size/mtime_ns/inode; hash metadata deltas.""" + rows = baseline['artifacts'] + expected_paths = sorted(v['path'] for v in rows) + require(len(expected_paths) == len(set(expected_paths)), 'duplicate baseline dependency path') + require(dependency_paths(baseline['roots']) == expected_paths, 'dependency pathset changed') + result, delta = [], [] + for row in rows: + p = Path(row['path']); before = stamp(p) + if before != row['stat']: + digest = sha(p) + require(stamp(p) == before, 'dependency changed while hashing: ' + str(p)) + delta.append({'path': str(p), 'old_stat': row['stat'], 'stat': before, 'sha256': digest}) + require(digest == row['sha256'], 'dependency bytes changed: ' + str(p)) + result.append(dict(row, stat=before)) + require(dependency_paths(baseline['roots']) == expected_paths, 'dependency pathset changed during check') + return dict(baseline, artifacts=result), {'reused': len(rows) - len(delta), 'rehashed': delta, + 'mode': 'C291 byte hashes plus unchanged metadata reuse; changed metadata rehashed; NOT full fresh byte rehash'} + + +def runtime(): + for name, digest in EXE_SHA.items(): + stamp(BIN / name); require(sha(BIN / name) == digest, 'executable identity: ' + name) + manifest = CACHE / 'lake-manifest.json' + manifest_raw = manifest.read_bytes() + require(hashlib.sha256(manifest_raw).hexdigest() == MANIFEST_SHA, 'manifest identity changed') + roots, paths = [str(BIN.parent / 'lib/lean')], [str(BUILD)] + for dep in json.loads(manifest_raw)['packages']: + p = CACHE / '.lake/packages' / dep['name'] + require((p / '.git/HEAD').read_text().strip() == dep['rev'], 'dependency revision: ' + dep['name']) + root = p / '.lake/build/lib' + # Match C291: every package revision is pinned, but Cli has no compiled lib. + if root.is_dir(): + roots.append(str(root)) + if (root / 'lean').is_dir(): + paths.append(str(root / 'lean')) + return roots, paths + + +def source_map(): + require(PROJECT.is_dir() and not PROJECT.is_symlink(), 'final project missing/unsafe') + require({p.name for p in PROJECT.iterdir()} == {m + '.lean' for m in MODULES}, 'final source pathset changed') + return {p.name: sha(p) for p in sorted(PROJECT.iterdir()) if stamp(p)} + + +def objects(): + require(BUILD.is_dir() and not BUILD.is_symlink(), 'final build missing/unsafe') + result = {} + for p in sorted(BUILD.iterdir()): + stamp(p) + require(any(is_object(p.name, m) for m in MODULES), 'unexpected final build path: ' + p.name) + result[p.name] = sha(p) + return result + + +def is_object(name, module): + return name in {module + s for s in ('.olean', '.olean.private', '.olean.server', '.ir', '.ir.sig')} + + +def main(): + require(len(sys.argv) == 3 and sys.argv[1] in ('build', 'kernel') and sys.argv[2] in MODULES, + 'usage: run_final_phase.py build|kernel Module') + kind, module = sys.argv[1:] + # Prior C293 audit exceeded its development 240s cap; C291 required458.5s. + # Reuse the final900s audit allowance, not an assertion of a C294 failure. + timeout = 900 if kind == 'build' and module == 'CriticalLevelAxiomAudit' else TIMEOUT + with (ROOT / 'lean-slot.lock').open('a+') as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + run = ROOT / 'final-runs' / (datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ') + '-' + kind + '-' + module + '-' + uuid.uuid4().hex[:8]) + run.mkdir(parents=True); (run / 'tmp').mkdir() + receipt = {'kind': kind, 'module': module, 'started_utc': now(), 'runner_sha256': sha(Path(__file__)), + 'kernel_scope': 'standard named-module replay against imported dependencies; not --fresh/external verification', + 'scientific_effect': 'NONE', 'timeout_seconds': timeout, 'threads': 2, 'status': 'PREFLIGHT'} + write(run / 'START.json', receipt) + good = False; proc = None; start = time.monotonic() + try: + inv_path = ROOT / 'FINAL_SOURCE_INVENTORY.json'; inv_raw = inv_path.read_bytes() + inv_hash = hashlib.sha256(inv_raw).hexdigest(); inv = json.loads(inv_raw) + require(inv['runner_sha256'] == receipt['runner_sha256'], 'runner changed after freeze') + dep_path = ROOT / 'FINAL_DEPENDENCY_ARTIFACTS.json' + dep_raw = dep_path.read_bytes() + require(hashlib.sha256(dep_raw).hexdigest() == inv['dependency_artifact_inventory_sha256'], 'dependency inventory changed') + baseline = json.loads(dep_raw); roots, paths = runtime() + require(roots == baseline['roots'], 'dependency roots changed') + _, dep_before = dependencies(baseline) + before = source_map(); expected = {v['name']: v['sha256'] for v in inv['sources']} + require(before == expected, 'frozen sources changed') + prior = objects(); known = {} + for p in sorted((ROOT / 'final-runs').glob('*/RECEIPT.json')): + v = json.loads(p.read_text()) + if v.get('kind') == 'build' and v.get('status') == 'PASS' and v.get('inventory_sha256') == inv_hash: + known.update(v['produced_objects']) + require(all(known.get(n) == h for n, h in prior.items()), 'object lacks same-freeze successful build receipt') + require(all(m + '.olean' in prior for m in inv['local_imports'][module]), 'local imports not built') + out = BUILD / (module + '.olean') + require(kind != 'kernel' or out.is_file(), 'kernel requires final object') + require(kind != 'build' or not any(is_object(n, module) for n in prior), 'module already has outputs; no implicit retry') + command = ([str(BIN / 'lean'), '-j2', '-M4096'] + (['-DwarningAsError=true'] if module in NEW else []) + + ['-o', str(out), str(PROJECT / (module + '.lean'))]) if kind == 'build' else [str(BIN / 'leanchecker'), '-v', module] + env = {k: v for k, v in os.environ.items() if not k.startswith(('LEAN', 'LAKE', 'LD_', 'DYLD_'))} + env.update(PATH=os.pathsep.join([str(BIN), '/usr/bin', '/bin', '/usr/sbin', '/sbin']), + LEAN_PATH=os.pathsep.join(paths), LEAN_NUM_THREADS='2', TMPDIR=str(run / 'tmp')) + receipt.update(inventory_sha256=inv_hash, source_before=before, objects_before=prior, + dependency_before=dep_before, command=command, process_path=env['PATH'], lean_path=paths, + executable_sha256=sha(Path(command[0])), resolved_lean_sha256=sha(BIN / 'lean')) + write(run / 'PREFLIGHT.json', receipt) + with (run / 'stdout.txt').open('xb') as stdout, (run / 'stderr.txt').open('xb') as stderr: + proc = subprocess.Popen(command, cwd=PROJECT, env=env, stdout=stdout, stderr=stderr, start_new_session=True) + receipt['child_pid'] = proc.pid; write(run / 'PROCESS_START.json', receipt) + timed_out = False + try: + code = proc.wait(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True; os.killpg(proc.pid, signal.SIGTERM) + try: + code = proc.wait(timeout=5) + except subprocess.TimeoutExpired: + os.killpg(proc.pid, signal.SIGKILL); code = proc.wait() + receipt.update(returncode=code, timed_out=timed_out) + after, current = source_map(), objects() + unchanged = all(current.get(n) == h for n, h in prior.items()) + allowed = set(prior) | ({n for n in current if is_object(n, module)} if kind == 'build' else set()) + _, dep_after = dependencies(baseline) + receipt.update(source_after=after, objects_after=current, dependency_after=dep_after, + source_unchanged=after == before, imported_objects_unchanged=unchanged and set(current) == allowed) + require(sha(inv_path) == inv_hash and sha(dep_path) == inv['dependency_artifact_inventory_sha256'], 'inventory changed during phase') + good = code == 0 and not timed_out and after == before and unchanged and set(current) == allowed and out.is_file() + if good: + receipt['object_sha256'] = sha(out) + receipt['produced_objects'] = {n: h for n, h in current.items() if is_object(n, module)} + except Exception as exc: + receipt['integrity_or_execution_error'] = repr(exc) + finally: + if proc is not None and proc.poll() is None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + try: + proc.wait(timeout=5) + receipt['emergency_child_cleanup'] = True + except subprocess.TimeoutExpired: + receipt['cleanup_error'] = 'SIGKILL sent; child not reaped within5seconds' + good = False + for stream in ('stdout', 'stderr'): + p = run / (stream + '.txt') + if not p.exists(): + p.touch(exist_ok=False) + receipt[stream + '_sha256'] = sha(p) + receipt['process_reaped'] = proc is None or proc.poll() is not None + receipt.update(status='PASS' if good else 'HOLD', ended_utc=now(), seconds=time.monotonic() - start) + write(run / 'RECEIPT.json', receipt) + print(json.dumps({'status': receipt['status'], 'run': str(run)}), flush=True) + return 0 if good else 1 + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/frontiers/critical_level_attainment_20261020/run_final_sequence.py b/frontiers/critical_level_attainment_20261020/run_final_sequence.py new file mode 100644 index 000000000..7e5a30f05 --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/run_final_sequence.py @@ -0,0 +1,27 @@ +"""Run each stable-input final phase once; stop on the first unresolved failure.""" +from pathlib import Path +import json, subprocess, sys +from run_final_phase import ROOT, NEW, now, sha, write, require + +def main(): + invp=ROOT/'FINAL_SOURCE_INVENTORY.json' + inv=json.loads(invp.read_text()) + require(not (ROOT/'FINAL_SEQUENCE_START.json').exists(), 'sequence already started') + write(ROOT/'FINAL_SEQUENCE_START.json',{'started_utc':now(),'inventory_sha256':sha(invp), + 'driver_sha256':sha(Path(__file__)),'scientific_effect':'NONE'}) + result={'started_utc':now(),'inventory_sha256':sha(invp),'phases':[],'scientific_effect':'NONE'} + phases=[('build',m) for m in inv['build_order']]+[('kernel',m) for m in NEW] + for kind,module in phases: + start=now() + print(json.dumps({'stage':'STARTING','kind':kind,'module':module}),flush=True) + code=subprocess.run([sys.executable,'-B',str(ROOT/'run_final_phase.py'),kind,module],cwd=ROOT).returncode + result['phases'].append({'kind':kind,'module':module,'started_utc':start,'ended_utc':now(),'returncode':code}) + if code: + result['status']='HOLD_FAILED_PHASE';break + else: result['status']='PASS_FROZEN_BUILD_AND_STANDARD_KERNEL_REPLAY' + result['ended_utc']=now() + write(ROOT/'FINAL_SEQUENCE_RESULT.json',result) + print(json.dumps({'status':result['status'],'phases':len(result['phases'])}),flush=True) + return 0 if result['status'].startswith('PASS_') else 1 + +if __name__=='__main__':raise SystemExit(main()) diff --git a/frontiers/critical_level_attainment_20261020/run_negative.py b/frontiers/critical_level_attainment_20261020/run_negative.py new file mode 100644 index 000000000..9a6e84cfa --- /dev/null +++ b/frontiers/critical_level_attainment_20261020/run_negative.py @@ -0,0 +1,49 @@ +"""One missing-closed-LPC-premise rejection against the actual final compiled theorem.""" +from pathlib import Path +import fcntl, json, os, signal, subprocess, time +from run_final_phase import ROOT, PROJECT, BUILD, BIN, require, now, sha, write, runtime, source_map, objects + +def main(): + with (ROOT / 'lean-slot.lock').open('a+') as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + run = ROOT / 'negative-final' + run.mkdir() + src = ROOT / 'negative-project/WithoutClosedLPC.lean' + source_sha = sha(src) + frozen_sources, frozen_objects = source_map(), objects() + require('CriticalLevelAttainment.olean' in frozen_objects, 'actual final theorem not built') + _, paths = runtime() + env = {k:v for k,v in os.environ.items() if not k.startswith(('LEAN','LAKE','LD_','DYLD_'))} + env.update(PATH=os.pathsep.join([str(BIN),'/usr/bin','/bin']), LEAN_PATH=os.pathsep.join(paths), LEAN_NUM_THREADS='2') + command = [str(BIN/'lean'), '-j2', '-M4096', str(src)] + r = {'started_utc':now(), 'source_sha256':source_sha, 'command':command, + 'source_before':frozen_sources, 'objects_before':frozen_objects, + 'lean_sha256':sha(BIN/'lean'), 'inventory_sha256':sha(ROOT/'FINAL_SOURCE_INVENTORY.json'), + 'runner_sha256':sha(Path(__file__)), 'timeout_seconds':600, + 'meaning':'Interface rejection for the omitted actual closed-level LPC input; not a counterexample to the open Morse-to-LPC implication.'} + write(run/'START.json',r) + start=time.monotonic() + with (run/'stdout.txt').open('xb') as out, (run/'stderr.txt').open('xb') as err: + p=subprocess.Popen(command,cwd=src.parent,env=env,stdout=out,stderr=err,start_new_session=True) + timedout=False + try: code=p.wait(timeout=600) + except subprocess.TimeoutExpired: + timedout=True; os.killpg(p.pid,signal.SIGTERM) + try: code=p.wait(timeout=5) + except subprocess.TimeoutExpired: os.killpg(p.pid,signal.SIGKILL); code=p.wait() + text=(run/'stdout.txt').read_text()+(run/'stderr.txt').read_text() + diagnostic=('type mismatch' in text.lower() and 'LocallyPathConnectedSpace' in text and + not any(s in text.lower() for s in ['unknown module','unknown identifier','unexpected token','object file'])) + good=(code!=0 and not timedout and diagnostic and sha(src)==source_sha and + source_map()==frozen_sources and objects()==frozen_objects) + r.update(ended_utc=now(),seconds=time.monotonic()-start,returncode=code,timed_out=timedout, + child_pid=p.pid,diagnostic_match=diagnostic,source_unchanged=sha(src)==source_sha, + imported_sources_unchanged=source_map()==frozen_sources, + imported_objects_unchanged=objects()==frozen_objects, + stdout_sha256=sha(run/'stdout.txt'),stderr_sha256=sha(run/'stderr.txt'), + status='PASS_EXPECTED_MISSING_PREMISE_REJECTION' if good else 'HOLD') + write(run/'RECEIPT.json',r) + print(json.dumps({'status':r['status'],'seconds':r['seconds']}),flush=True) + return 0 if good else 1 + +if __name__=='__main__': raise SystemExit(main()) diff --git a/frontiers/regular_point_chart_20261020/README.md b/frontiers/regular_point_chart_20261020/README.md new file mode 100644 index 000000000..f6af6b350 --- /dev/null +++ b/frontiers/regular_point_chart_20261020/README.md @@ -0,0 +1,35 @@ +# C296: regular scalar chart at a noncritical point + +C296 instantiates Mathlib's finite-dimensional implicit-function chart for the +literal C294 project space `E d` and a smooth scalar function `g : E d → ℝ` at +a point `x` satisfying `¬ IsCriticalPoint d g x`. + +The production module proves that the derivative has full scalar range, derives +the strict derivative from the project's `IsSmooth` predicate, and exposes an +`OpenPartialHomeomorph (E d) (ℝ × (fderiv ℝ g x).ker)`. Its first coordinate is +exactly `g`; it sends `x` to `(g x, 0)`; and those points are members of the +chart's source and target. + +This is a local regular-point tool only. It does not construct a chart at a +critical point, prove a Morse normal form, transport local path connectivity +through a quotient or half-space, or remove C294's explicit +`LocallyPathConnectedSpace` premise. Scientific effect is **NONE**. + +## Reproduction + +From this directory, with the pinned toolchain available: + +```text +lake build RegularPointChart RegularPointChartInterface +lake env lean -E warning RegularPointChart.lean +lake env lean -E warning RegularPointChartInterface.lean +lake env leanchecker RegularPointChart +lake env leanchecker RegularPointChartInterface +lake env lean RegularPointChartAxiomAudit.lean +``` + +`WithoutNoncriticality.lean` is a negative fixture and must fail with a type +mismatch requiring `¬ IsCriticalPoint`. See `RESULTS.md` for hosted identities +and `SCOPE.md` for the exact boundary. + +[Owner mandate](https://github.com/d6g8k5htny-coder/main/blob/b665307520948308a53d190d7341bf301df3b3a2/governance/OWNER_MANDATE_20261015.md) · [Standing delegation](https://github.com/d6g8k5htny-coder/main/blob/main/governance/OP-AUTONOMY-20260923-v2.1.md) diff --git a/frontiers/regular_point_chart_20261020/REPAIR_20261024.md b/frontiers/regular_point_chart_20261020/REPAIR_20261024.md new file mode 100644 index 000000000..894b0f61c --- /dev/null +++ b/frontiers/regular_point_chart_20261020/REPAIR_20261024.md @@ -0,0 +1,50 @@ +# C296 audit and dependency-trigger repair + +Engineering successor to Math- PR488 head +`762a6f30e7131b7b2cc02ad2d80113de9263bd4c`, addressing review +`5635610588` and threads `4365149299`, `4365149322`, `4365149354`. +The dated README/RESULTS remain historical evidence, not receipts for this repair. + +The workflow now names the exact consumed C294 `Lifetime.lean` path. The +manifest binds the updated workflow and audit, test harness, unchanged +classifier and its tests, and this scope note. The workflow checks those +digests before building. Regenerate digests whenever an included input changes. + +The audit discovers declarations originating in `RegularPointChart` and checks +that all seven original required names are present. For every discovered name, +it requires a kernel declaration and rejects transitive axioms outside +`propext`, `Classical.choice`, and `Quot.sound`. Its inventory includes generated +declarations belonging to that module; it does not claim to enumerate every +declaration in imported Mathlib. It does inspect the transitive axiom closure +of each audited declaration, including axioms reached through imports. + +The hosted test harness runs actual Lean on disposable audit copies, retaining +stdout, stderr and return codes under `.lake/c296-audit-evidence` and printing +reviewable output into the job log. It tests the production positive case, +forbidden transitive axioms, missing required target, empty inventory, weakened +allowlist, and setup/syntax errors. A printing-only control preserves the old +audit behavior and demonstrates why printed reports are not enforcement. +An unknown declaration already makes Lean fail; completeness is instead tested +by omitting an existing required declaration from the audited inventory. + +The original chart/interface proofs, consumed Lifetime, compiler/mathlib pins, +noncriticality control, classifier and classifier tests are unchanged. +The separately reviewed classifier-composition proposal is not adopted here. + +Execution and attribution: OpenAI Codex root chat +`01a0bbb5-2fcb-77f0-b78b-4d220ddd7ab2` authored the repair; delegated +OpenAI Codex `/root/c299_timeout_scope_audit` authored the test harness. +Separate nonauthor review and current-candidate hosted receipts belong in the +PR discussion. This source note itself asserts neither review nor execution. +Dylan Roy did not personally perform a human review. No organizational or +blind independence is claimed for same-provider delegated review. + +Local Lean execution remains unavailable after the retained `/proc` denial; +no local retry or bypass is part of this repair. The isolated source stage and +native Git publication are not a working local repository checkout. Hosted +results must identify the actual run, attempt, head and tested merge commit. + +This is a draft engineering repair, not default-main integration, theorem +completion, alignment approval, or scientific promotion. All hypotheses, +ordinary-persistence bridges and regional collision obligations remain open. +No merge, Ready transition or deployment is part of this delivery. diff --git a/frontiers/regular_point_chart_20261020/RESULTS.md b/frontiers/regular_point_chart_20261020/RESULTS.md new file mode 100644 index 000000000..719488d47 --- /dev/null +++ b/frontiers/regular_point_chart_20261020/RESULTS.md @@ -0,0 +1,49 @@ +# C296 hosted results + +## Source identities + +- base and PR target: Math- PR #487 head + `7af365e8c8db1ae0275d4efe08a70a678f153ca2`; +- implementation GREEN head: `4aaddf42c474eee783f08b0350e705cea2cff181`; +- production Git blob: `77a75a4611040973ad355aff40555a808f1816e7`; +- positive-interface blob: `4885f7a0e8fdb7f1d3ab308991b043c438dbb8ef`; +- negative-control blob: `dd97a6073da0ea9bf87a19cb910daea2b46ca365`; +- axiom-audit blob: `2d77d76781209655c1a02478f5dccc827d573a78`; +- exact external C294 `Lifetime.lean` blob: + `f2508f7f2e3fd42f22f5aa52bc5ead5ff9e73b9a`; +- Lean `v4.34.1`, commit `5045d0056413266e57c625dcd7c365b10e377c52`; +- Mathlib `d13f23b723b8a846827a245b89c10fc7d3f11612`; +- workflow action `leanprover/lean-action@f061402b660e0c34644504b324e830f2991d4865`. + +`SOURCE_SHA256SUMS` binds the complete implementation, interface/control, +toolchain/dependency, workflow, and consumed C294 source bytes. + +## Verified execution + +GitHub Actions run +[39415169578](https://github.com/d6g8k5htny-coder/Math-/actions/runs/39415169578), +job `118602321184`, succeeded at the implementation GREEN head. + +- `Lifetime`, `RegularPointChart`, and `RegularPointChartInterface` built; +- production and interface passed Lean `-E warning` rechecks; +- standalone `leanchecker` passed for both named new modules; +- all seven audited declarations reported only `propext`, + `Classical.choice`, and `Quot.sound`; +- the omitted-noncriticality fixture exited nonzero with the intended type + mismatch: `regularPointChart hg` still required + `¬ IsCriticalPoint d g ...`; +- the exact GREEN-head repository downstream hard gate passed in run + [39415169606](https://github.com/d6g8k5htny-coder/Math-/actions/runs/39415169606). + +Earlier runs preserve setup and harness failures rather than suppressing them: +`39412669016`, `39413381712`, `39413746410`, `39414329053`, and +`39414753347`. The valid RED is run `39412930269`, job `118594890340`, which +built the exact consumed source and rejected the missing chart declarations. + +## Limits + +Local Lean execution was unavailable because the downloaded Lean 4.34.1 runtime +could not read `/proc//exe` in this environment. No runtime patch or bypass +was attempted. Hosted checks are execution evidence, not scientific acceptance, +external independent replay, correspondence review, or authorization to merge. +Scientific effect remains **NONE**. diff --git a/frontiers/regular_point_chart_20261020/RegularPointChart.lean b/frontiers/regular_point_chart_20261020/RegularPointChart.lean new file mode 100644 index 000000000..77a75a461 --- /dev/null +++ b/frontiers/regular_point_chart_20261020/RegularPointChart.lean @@ -0,0 +1,64 @@ +import Lifetime + +/-! +# Regular scalar chart at a noncritical point + +The construction is the finite-dimensional scalar specialization of Mathlib's +strict implicit-function chart. It uses noncriticality only to prove that the +derivative has full range. +-/ + +namespace UniversalLaw.Spec.Lifetime + +variable {d : ℕ} {g : E d → ℝ} {x : E d} + +/-- At a noncritical point, the scalar derivative has full range. -/ +theorem regularPointDerivative_range_eq_top (hx : ¬ IsCriticalPoint d g x) : + (fderiv ℝ g x).range = ⊤ := by + have hne : (fderiv ℝ g x).toLinearMap ≠ 0 := by + intro hzero + apply hx + unfold IsCriticalPoint + ext y + have hy := LinearMap.congr_fun hzero y + simpa using hy + exact Module.Dual.range_eq_top_of_ne_zero hne + +/-- Smoothness supplies the strict derivative used by the chart. -/ +theorem regularPointHasStrictFDerivAt (hg : IsSmooth d g) : + HasStrictFDerivAt g (fderiv ℝ g x) x := + (hg 1).hasStrictFDerivAt (by norm_num) + +/-- The literal local scalar chart at a noncritical point. -/ +noncomputable def regularPointChart (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) : + OpenPartialHomeomorph (E d) (ℝ × (fderiv ℝ g x).ker) := + (regularPointHasStrictFDerivAt hg).implicitToOpenPartialHomeomorph + g (fderiv ℝ g x) (regularPointDerivative_range_eq_top hx) + +/-- The chart's first coordinate is exactly `g`, globally as a function equality. -/ +@[simp] +theorem regularPointChart_fst (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) (y : E d) : + (regularPointChart hg hx y).1 = g y := by + exact HasStrictFDerivAt.implicitToOpenPartialHomeomorph_fst + (regularPointHasStrictFDerivAt hg) (regularPointDerivative_range_eq_top hx) y + +/-- The chart sends the base point to `(g x, 0)`. -/ +@[simp] +theorem regularPointChart_self (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) : + regularPointChart hg hx x = (g x, 0) := by + exact HasStrictFDerivAt.implicitToOpenPartialHomeomorph_self + (regularPointHasStrictFDerivAt hg) (regularPointDerivative_range_eq_top hx) + +/-- The base point belongs to the chart source. -/ +theorem mem_regularPointChart_source (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) : + x ∈ (regularPointChart hg hx).source := by + exact HasStrictFDerivAt.mem_implicitToOpenPartialHomeomorph_source + (regularPointHasStrictFDerivAt hg) (regularPointDerivative_range_eq_top hx) + +/-- The image base point belongs to the chart target. -/ +theorem mem_regularPointChart_target (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) : + (g x, 0) ∈ (regularPointChart hg hx).target := by + exact HasStrictFDerivAt.mem_implicitToOpenPartialHomeomorph_target + (regularPointHasStrictFDerivAt hg) (regularPointDerivative_range_eq_top hx) + +end UniversalLaw.Spec.Lifetime diff --git a/frontiers/regular_point_chart_20261020/RegularPointChartAxiomAudit.lean b/frontiers/regular_point_chart_20261020/RegularPointChartAxiomAudit.lean new file mode 100644 index 000000000..8fcd26db2 --- /dev/null +++ b/frontiers/regular_point_chart_20261020/RegularPointChartAxiomAudit.lean @@ -0,0 +1,40 @@ +import RegularPointChart +import Lean.Elab.Command +import Lean.Util.CollectAxioms + +/-! Enforce the standard-axiom policy over the complete module-origin census. +The required inventory prevents omission of any of the seven original targets. +This is an engineering audit, not independent alignment or scientific acceptance. -/ + +open Lean Elab Command in +run_cmd do + let env := (← getEnv).setExporting false + let allowed : List Name := [`propext, `Classical.choice, `Quot.sound] + let some idx := env.getModuleIdx? `RegularPointChart + | throwError "C296_AXIOM_MISSING_MODULE RegularPointChart" + let constants := env.constants.toList + let names := (constants.filterMap fun (name, _) => + if env.getModuleIdxFor? name == some idx then some name else none).toArray.qsort Name.lt + let audited := names + if audited.isEmpty then throwError "C296_AXIOM_EMPTY RegularPointChart" + let required : Array Name := #[ + `UniversalLaw.Spec.Lifetime.regularPointDerivative_range_eq_top, + `UniversalLaw.Spec.Lifetime.regularPointHasStrictFDerivAt, + `UniversalLaw.Spec.Lifetime.regularPointChart, + `UniversalLaw.Spec.Lifetime.regularPointChart_fst, + `UniversalLaw.Spec.Lifetime.regularPointChart_self, + `UniversalLaw.Spec.Lifetime.mem_regularPointChart_source, + `UniversalLaw.Spec.Lifetime.mem_regularPointChart_target] + for name in required do + unless audited.contains name do + throwError "C296_AXIOM_MISSING_TARGET {name}" + for name in audited do + if (env.checked.get.find? name).isNone then + throwError "C296_AXIOM_MISSING_KERNEL_DECL {name}" + let axs ← Lean.collectAxioms name + let axiomText := String.intercalate ", " (axs.toList.map fun ax => ax.toString) + logInfo m!"C296_AXIOM_DECL {name.toString} AXIOMS [{axiomText}]" + for ax in axs do + unless allowed.contains ax do + throwError "C296_AXIOM_FORBIDDEN {ax} in {name}" + logInfo m!"C296_AXIOM_POLICY_PASS COUNT {audited.size}" diff --git a/frontiers/regular_point_chart_20261020/RegularPointChartInterface.lean b/frontiers/regular_point_chart_20261020/RegularPointChartInterface.lean new file mode 100644 index 000000000..4885f7a0e --- /dev/null +++ b/frontiers/regular_point_chart_20261020/RegularPointChartInterface.lean @@ -0,0 +1,33 @@ +import RegularPointChart + +open scoped Topology + +namespace UniversalLaw.Spec.Lifetime + +noncomputable section + +variable {d : ℕ} {g : E d → ℝ} {x : E d} + +example (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) : + OpenPartialHomeomorph (E d) (ℝ × (fderiv ℝ g x).ker) := + regularPointChart hg hx + +example (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) (y : E d) : + (regularPointChart hg hx y).1 = g y := + regularPointChart_fst hg hx y + +example (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) : + regularPointChart hg hx x = (g x, 0) := + regularPointChart_self hg hx + +example (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) : + x ∈ (regularPointChart hg hx).source := + mem_regularPointChart_source hg hx + +example (hg : IsSmooth d g) (hx : ¬ IsCriticalPoint d g x) : + (g x, 0) ∈ (regularPointChart hg hx).target := + mem_regularPointChart_target hg hx + +end + +end UniversalLaw.Spec.Lifetime diff --git a/frontiers/regular_point_chart_20261020/SCOPE.md b/frontiers/regular_point_chart_20261020/SCOPE.md new file mode 100644 index 000000000..6021c2aba --- /dev/null +++ b/frontiers/regular_point_chart_20261020/SCOPE.md @@ -0,0 +1,42 @@ +# C296 scope + +## Exact claim + +For arbitrary `d`, `g : E d → ℝ`, and `x : E d`, the packet consumes: + +- `hg : IsSmooth d g`; +- `hx : ¬ IsCriticalPoint d g x`. + +It proves the literal derivative range equality, the strict derivative, and the +regular scalar chart with its first-coordinate, base-point, source-membership, +and target-membership identities. The derivative is exactly +`fderiv ℝ g x`; it is not replaced by an abstract equivalent. + +## Logical boundary + +Noncriticality is used to show that the continuous linear functional is +nonzero, then `Module.Dual.range_eq_top_of_ne_zero` yields scalar surjectivity. +Smoothness at order one supplies `HasStrictFDerivAt`. Mathlib's existing +`HasStrictFDerivAt.implicitToOpenPartialHomeomorph` supplies the chart. + +The equality of the first coordinate with `g` is global as an equality of the +underlying chart function. Inverse and homeomorphism properties remain +restricted to the chart source and target. No global product decomposition is +claimed. + +## Explicit exclusions + +- no chart or normal form at a critical point; +- no Morse lemma formalization; +- no proof that a closed superlevel is locally path connected; +- no quotient, half-space, or relative-LPC transport; +- no removal or weakening of C294 premises; +- no stochastic, persistence-pairing, registry, acceptance, or integration + transition. + +`WithoutNoncriticality.lean` omits only `hx`. A qualifying negative result is a +nonzero Lean exit with a type mismatch exposing `¬ IsCriticalPoint`; timeout, +setup, syntax, import, or unknown-production-identifier errors do not qualify. + +The exact C294 `Lifetime.lean` is consumed in place through a read-only Lake +library. Existing C294 bytes are not copied or modified. diff --git a/frontiers/regular_point_chart_20261020/SOURCE_SHA256SUMS b/frontiers/regular_point_chart_20261020/SOURCE_SHA256SUMS new file mode 100644 index 000000000..5ef615162 --- /dev/null +++ b/frontiers/regular_point_chart_20261020/SOURCE_SHA256SUMS @@ -0,0 +1,13 @@ +b9b8bdb81de2b3e16c036bc672e1cb78e3d400c02af68b89e827e3e59d8a870f ../../.github/workflows/c296-regular-point-chart.yml +90f4892608e953ecc696bb32ea159d1c178ceb8a1c6edfd11acfceb14af462c6 ../critical_level_attainment_20261020/final-project/Lifetime.lean +5568c8d6e03f7064cd5924ebe2814ae746100505ae31789d5c975902528f9fa2 RegularPointChart.lean +d87cc945b859472417ce9ef1c197a34f5ea4b63e65a857ce24316f435288e051 RegularPointChartInterface.lean +da7256bbe6baa41e2fda6888d80b72dce73c27eac5ad641ad9b875243370acf7 WithoutNoncriticality.lean +1d5ea6e816a580dde7298640eeb27664adb247cbaa347ff0184edf7f6d514a43 RegularPointChartAxiomAudit.lean +3c154a9b908e97ae98c8f2ac0062be391bde49c13f8d436fedbbc8b1b9d88213 lakefile.toml +a5f438c3066ea36abd201994397d4b75234b7fff52d2ef8de9dea64f874baf6b lake-manifest.json +d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b lean-toolchain +7f27ef40f7c7d76138df0fd8ca376a8a8ea09f5b44a174882ffad0de912e6576 scripts/classify_negative.sh +54f06670e9f5bb3bc7fe20d3cc3e2bf118633bf797011d3f7251bc6da16742ae scripts/test_negative_classifier.sh +aa269dec1f012a059bc7192dcadc5a1ab14f16ad9415fdbcd87faa225ee31920 scripts/test_axiom_audit.py +db85b47b9841e50749b50190cff57ddaadf28c4baaad34f9d05533cff8b6629c REPAIR_20261024.md diff --git a/frontiers/regular_point_chart_20261020/WithoutNoncriticality.lean b/frontiers/regular_point_chart_20261020/WithoutNoncriticality.lean new file mode 100644 index 000000000..dd97a6073 --- /dev/null +++ b/frontiers/regular_point_chart_20261020/WithoutNoncriticality.lean @@ -0,0 +1,17 @@ +import RegularPointChart + +namespace UniversalLaw.Spec.Lifetime + +noncomputable section + +variable {d : ℕ} {g : E d → ℝ} {x : E d} + +-- This must be rejected: smoothness alone does not provide the required +-- `¬ IsCriticalPoint d g x` argument. +example (hg : IsSmooth d g) : + OpenPartialHomeomorph (E d) (ℝ × (fderiv ℝ g x).ker) := + regularPointChart hg + +end + +end UniversalLaw.Spec.Lifetime diff --git a/frontiers/regular_point_chart_20261020/lake-manifest.json b/frontiers/regular_point_chart_20261020/lake-manifest.json new file mode 100644 index 000000000..8ceb35d8b --- /dev/null +++ b/frontiers/regular_point_chart_20261020/lake-manifest.json @@ -0,0 +1,118 @@ +{ + "version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": [ + { + "name": "plausible", + "url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "name": "LeanSearchClient", + "url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "name": "importGraph", + "url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "e928b72544873815af278d38681b31c0293588e3", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "name": "proofwidgets", + "url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.lean" + }, + { + "name": "aesop", + "url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "name": "Qq", + "url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "name": "batteries", + "url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "name": "Cli", + "url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", + "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "name": "mathlib", + "url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, + "scope": "", + "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "manifestFile": "lake-manifest.json", + "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean" + } + ], + "name": "c296_regular_point_chart", + "lakeDir": ".lake", + "fixedToolchain": true +} + diff --git a/frontiers/regular_point_chart_20261020/lakefile.toml b/frontiers/regular_point_chart_20261020/lakefile.toml new file mode 100644 index 000000000..96f302070 --- /dev/null +++ b/frontiers/regular_point_chart_20261020/lakefile.toml @@ -0,0 +1,18 @@ +name = "c296_regular_point_chart" +version = "0.1.0" +defaultTargets = ["RegularPointChartInterface"] + +[[require]] +name = "mathlib" +git = "https://github.com/leanprover-community/mathlib4.git" +rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + +[[lean_lib]] +name = "Lifetime" +srcDir = "../critical_level_attainment_20261020/final-project" + +[[lean_lib]] +name = "RegularPointChart" + +[[lean_lib]] +name = "RegularPointChartInterface" diff --git a/frontiers/regular_point_chart_20261020/lean-toolchain b/frontiers/regular_point_chart_20261020/lean-toolchain new file mode 100644 index 000000000..ba8ebf2db --- /dev/null +++ b/frontiers/regular_point_chart_20261020/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.34.1 diff --git a/frontiers/regular_point_chart_20261020/scripts/classify_negative.sh b/frontiers/regular_point_chart_20261020/scripts/classify_negative.sh new file mode 100644 index 000000000..a481c4eda --- /dev/null +++ b/frontiers/regular_point_chart_20261020/scripts/classify_negative.sh @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +set -euo pipefail + +if [[ "$#" -ne 2 ]]; then + echo "usage: $0 LOG EXIT_STATUS" >&2 + exit 2 +fi + +log="$1" +status="$2" + +[[ "$status" =~ ^[0-9]+$ ]] || { + echo "negative classifier: invalid exit status" >&2 + exit 2 +} + +if [[ "$status" -eq 0 ]]; then + echo "negative classifier: fixture unexpectedly succeeded" >&2 + exit 1 +fi + +if [[ "$status" -eq 124 || "$status" -eq 137 || "$status" -eq 143 ]]; then + echo "negative classifier: rejected timeout/termination exit status" >&2 + exit 1 +fi + +if grep -Eiq \ + 'unknown (module|package|identifier)|invalid import|failed to (resolve|load|fetch|clone|download)|cannot find|no such file|file not found|command not found|fatal: unable to access|could not resolve host|HTTP[^[:alnum:]]*(403|404|5[0-9][0-9])|parser error|syntax error|invalid syntax|unexpected (token|identifier|end)|expected token|timed? ?out|timeout|killed|out of memory|oom|memory exhausted|resource temporarily unavailable|no space left|signal 9|exit code 137' \ + "$log"; then + echo "negative classifier: rejected setup/syntax/resource failure" >&2 + exit 1 +fi + +grep -Eq 'WithoutNoncriticality\.lean:[0-9]+:[0-9]+: error: Type mismatch' "$log" +grep -Eq '¬[[:space:]]*IsCriticalPoint' "$log" +grep -Fq '→ OpenPartialHomeomorph' "$log" + +echo "negative classifier: intended missing-noncriticality type mismatch" diff --git a/frontiers/regular_point_chart_20261020/scripts/test_axiom_audit.py b/frontiers/regular_point_chart_20261020/scripts/test_axiom_audit.py new file mode 100644 index 000000000..f6aaf7694 --- /dev/null +++ b/frontiers/regular_point_chart_20261020/scripts/test_axiom_audit.py @@ -0,0 +1,322 @@ +"""Hosted real-Lean controls for the C296 axiom policy; no scientific acceptance. + +Run from the package after its pinned dependencies and RegularPointChart build +exist. Every fixture is a separate source copy under .lake/c296-audit-evidence; +production Lean sources are never changed. This script does not install tools. +""" + +import hashlib +import json +import os +from pathlib import Path +import re +import signal +import subprocess +import sys +import tempfile +import time + + +ROOT = Path(__file__).resolve().parents[1] +AUDIT = ROOT / "RegularPointChartAxiomAudit.lean" +PREFIX = "UniversalLaw.Spec.Lifetime." +REQUIRED = ( + PREFIX + "regularPointDerivative_range_eq_top", + PREFIX + "regularPointHasStrictFDerivAt", + PREFIX + "regularPointChart", + PREFIX + "regularPointChart_fst", + PREFIX + "regularPointChart_self", + PREFIX + "mem_regularPointChart_source", + PREFIX + "mem_regularPointChart_target", +) +ALLOWED = {"propext", "Classical.choice", "Quot.sound"} +AUDITED_ANCHOR = " let audited := names\n" +ALLOWLIST_ANCHOR = ( + " let allowed : List Name := [`propext, `Classical.choice, `Quot.sound]\n" +) +BLOCK_ANCHOR = "open Lean Elab Command in\nrun_cmd do\n" +CONTAMINATION = ( + "axiom C296Forbidden : False\n" + "theorem C296Contaminated : False := C296Forbidden\n\n" +) +TIMEOUT_SECONDS = 90 +MAX_READ_BYTES = 4 * 1024 * 1024 + + +class ControlFailure(RuntimeError): + """An expected semantic behavior was absent, distinct from process setup.""" + + +def require(condition, message): + if not condition: + raise ControlFailure(message) + + +def replace_once(source, old, new): + require(source.count(old) == 1, "fixture anchor missing or nonunique: " + repr(old)) + return source.replace(old, new, 1) + + +def sha(path): + digest = hashlib.sha256() + with path.open("rb") as stream: + for block in iter(lambda: stream.read(65536), b""): + digest.update(block) + return digest.hexdigest() + + +def source_snapshot(): + paths = [p for p in ROOT.iterdir() if p.is_file()] + paths += [p for p in (ROOT / "scripts").iterdir() if p.is_file()] + paths += [ROOT.parent / "critical_level_attainment_20261020/final-project/Lifetime.lean", + ROOT.parents[1] / ".github/workflows/c296-regular-point-chart.yml"] + return {str(p.relative_to(ROOT.parents[1])): sha(p) for p in sorted(paths)} + + +def save_json(path, value): + path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8") + + +def emit_evidence(directory, report): + # The hosted job has no artifact upload: retain readable evidence in its log + # even when a semantic validator fails. Raw files remain unchanged on disk. + for record in report["processes"]: + for stream in ("stdout", "stderr"): + path = directory / (record["case"] + "." + stream) + with path.open("rb") as handle: + raw = handle.read(MAX_READ_BYTES) + metadata = {"case": record["case"], "stream": stream, + "sha256": record[stream + "_sha256"], + "total_bytes": record[stream + "_bytes"], + "emitted_bytes": len(raw), + "truncated": record[stream + "_bytes"] > len(raw), + "decoding": "utf-8 with replacement for invalid bytes"} + print("=== C296_AUDIT_STREAM_BEGIN " + json.dumps(metadata, sort_keys=True) + " ===") + decoded = raw.decode("utf-8", "replace") + print(decoded, end="" if decoded.endswith("\n") else "\n") + print("=== C296_AUDIT_STREAM_END " + record["case"] + " " + stream + " ===") + print("=== C296_AUDIT_RESULT_BEGIN ===") + print(json.dumps(report, indent=2, sort_keys=True)) + print("=== C296_AUDIT_RESULT_END ===") + + +def stop_child(process): + if process.poll() is not None: + return + try: + os.killpg(process.pid, signal.SIGTERM) + except ProcessLookupError: + pass + try: + process.wait(timeout=5) + except subprocess.TimeoutExpired: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait(timeout=5) + + +def run_lean(directory, label, source, report): + source_path = directory / (label + ".lean") + source_path.write_text(source, encoding="utf-8") + stdout_path = directory / (label + ".stdout") + stderr_path = directory / (label + ".stderr") + command = ["lake", "env", "lean", str(source_path)] + record = {"case": label, "command": command, "cwd": str(ROOT), + "source_sha256": sha(source_path), "timeout_seconds": TIMEOUT_SECONDS, + "timed_out": False, "spawn_error": None, "cleanup_error": None, + "exit_code": None, "classification": "NOT_CLASSIFIED"} + process = None + started = time.monotonic() + with stdout_path.open("xb") as stdout, stderr_path.open("xb") as stderr: + try: + process = subprocess.Popen(command, cwd=ROOT, stdout=stdout, stderr=stderr, + start_new_session=True) + try: + record["exit_code"] = process.wait(timeout=TIMEOUT_SECONDS) + except subprocess.TimeoutExpired: + record["timed_out"] = True + except OSError as error: + record["spawn_error"] = repr(error) + finally: + if process is not None: + try: + stop_child(process) + except (OSError, subprocess.TimeoutExpired) as error: + record["cleanup_error"] = repr(error) + record["exit_code"] = process.poll() + record["duration_seconds"] = time.monotonic() - started + for name, path in (("stdout", stdout_path), ("stderr", stderr_path)): + record[name + "_bytes"] = path.stat().st_size + record[name + "_sha256"] = sha(path) + report["processes"].append(record) + save_json(directory / (label + ".receipt.json"), record) + save_json(directory / "RESULT.json", report) + require(not record["timed_out"], label + ": PROCESS_TIMEOUT, not a policy rejection") + require(record["spawn_error"] is None, label + ": PROCESS_SETUP_FAILURE") + require(record["cleanup_error"] is None, label + ": PROCESS_CLEANUP_FAILURE") + require(max(record["stdout_bytes"], record["stderr_bytes"]) <= MAX_READ_BYTES, + label + ": OUTPUT_LIMIT, not a policy rejection") + stdout = stdout_path.read_bytes().decode("utf-8", "strict") + stderr = stderr_path.read_bytes().decode("utf-8", "strict") + return record, stdout, stderr, source_path + + +def policy_records(stdout): + declarations = {} + for line in stdout.splitlines(): + match = re.search(r"(?:^|: info: )C296_AXIOM_DECL (\S+) AXIOMS \[([^\]]*)\]$", line) + if match: + name, axioms = match.groups() + require(name not in declarations, "duplicate audit declaration: " + name) + declarations[name] = {a.strip() for a in axioms.split(",") if a.strip()} + return declarations + + +def successful_audit(result, allowed=ALLOWED): + record, stdout, stderr, _ = result + require(record["exit_code"] == 0, record["case"] + ": audit did not succeed") + require(stderr == "" and "error:" not in stdout, + record["case"] + ": successful audit has error output") + declarations = policy_records(stdout) + require(set(REQUIRED) <= set(declarations), "successful audit omitted a required target") + counts = re.findall(r"(?:^|: info: )C296_AXIOM_POLICY_PASS COUNT ([0-9]+)$", stdout, re.M) + require(len(counts) == 1 and int(counts[0]) == len(declarations), + "missing or inconsistent audit completion inventory") + for name, axioms in declarations.items(): + require(axioms <= allowed, "successful audit admitted forbidden axioms at " + name) + return declarations + + +def policy_rejection(result, marker, detail=None): + record, stdout, stderr, source_path = result + require(record["exit_code"] == 1, record["case"] + ": expected policy exit 1") + require(stderr == "", record["case"] + ": policy diagnostic unexpectedly on stderr") + # An intended exception must be the sole error at this exact fixture source. + errors = [line for line in stdout.splitlines() if "error:" in line] + pattern = re.escape(str(source_path)) + r":\d+:\d+: error: " + re.escape(marker) + r"(?:\s.*)?$" + require(len(errors) == 1 and re.fullmatch(pattern, errors[0]) is not None, + record["case"] + ": unrelated/setup/syntax error is not the policy rejection") + require("C296_AXIOM_POLICY_PASS" not in stdout, "rejected audit printed a success marker") + if detail is not None: + require(detail in errors[0], record["case"] + ": wrong policy witness") + + +def classified_failure(result, diagnostic_pattern, classification): + record, stdout, stderr, source_path = result + require(record["exit_code"] == 1, classification + ": wrong exit status") + require(stderr == "", classification + ": unexpected stderr") + errors = [line for line in stdout.splitlines() if "error:" in line] + prefix = re.escape(str(source_path)) + r":\d+:\d+: error: " + require(len(errors) == 1 and re.match(prefix, errors[0]) is not None, + classification + ": missing source-bound error") + require(re.search(diagnostic_pattern, errors[0]) is not None, + classification + ": unexpected diagnostic") + require("C296_AXIOM_" not in stdout, classification + ": masquerading as policy output") + try: + policy_rejection(result, "C296_AXIOM_FORBIDDEN", "C296Forbidden") + except ControlFailure: + return + raise ControlFailure(classification + ": incorrectly accepted as a policy rejection") + + +def main(): + evidence = ROOT / ".lake/c296-audit-evidence" + evidence.mkdir(parents=True, exist_ok=True) + directory = Path(tempfile.mkdtemp(prefix="run-", dir=evidence)) + report = {"schema_version": 1, "status": "FAIL", "scientific_effect": "NONE", + "python_optimized": bool(sys.flags.optimize), "processes": [], + "controls": [], "evidence_directory": str(directory)} + before = source_snapshot() + report["source_before"] = before + save_json(directory / "RESULT.json", report) + + def check(label, source, validator, classification): + result = run_lean(directory, label, source, report) + validator(result) + result[0]["classification"] = classification + save_json(directory / (label + ".receipt.json"), result[0]) + report["controls"].append({"case": label, "classification": classification}) + save_json(directory / "RESULT.json", report) + return result + + try: + candidate = AUDIT.read_text(encoding="utf-8") + print_only = "import RegularPointChart\n\n" + "\n".join( + "#print axioms " + name for name in REQUIRED) + "\n" + # This is the original seven-print audit plus one explicit contamination + # witness. Its rc0 must demonstrate the old policy defect, not setup RED. + old_contaminated = print_only + "\n" + CONTAMINATION + "#print axioms C296Contaminated\n" + + def old_printing_only(result): + record, stdout, stderr, _ = result + require(record["exit_code"] == 0 and stderr == "" and "error:" not in stdout, + "printing-only baseline must elaborate successfully") + require(all(name in stdout for name in REQUIRED), "baseline target output missing") + require(re.search(r"C296Contaminated[^\n]*depends on axioms[^\n]*C296Forbidden", stdout) + is not None, "baseline did not expose the transitive forbidden axiom") + require("C296_AXIOM_POLICY_PASS" not in stdout, "baseline was not printing-only") + + check("printing-only-forbidden", old_contaminated, old_printing_only, + "BASELINE_POLICY_DEFECT_OBSERVED_EXIT_ZERO") + check("positive", candidate, successful_audit, "COMPLETE_ALLOWED_INVENTORY") + contaminated = replace_once(candidate, BLOCK_ANCHOR, CONTAMINATION + BLOCK_ANCHOR) + contaminated = replace_once(contaminated, AUDITED_ANCHOR, + " let audited := names.push `C296Contaminated\n") + check("forbidden", contaminated, + lambda r: policy_rejection(r, "C296_AXIOM_FORBIDDEN", "C296Forbidden"), + "TRANSITIVE_FORBIDDEN_AXIOM_REJECTED") + missing = replace_once(candidate, AUDITED_ANCHOR, + " let audited := names.filter (· != `" + REQUIRED[-1] + ")\n") + check("missing-target", missing, + lambda r: policy_rejection(r, "C296_AXIOM_MISSING_TARGET", REQUIRED[-1]), + "MISSING_REQUIRED_TARGET_REJECTED") + empty = replace_once(candidate, AUDITED_ANCHOR, " let audited := (#[] : Array Name)\n") + check("empty-inventory", empty, lambda r: policy_rejection(r, "C296_AXIOM_EMPTY"), + "EMPTY_AUDITED_INVENTORY_REJECTED") + weakened = replace_once(contaminated, ALLOWLIST_ANCHOR, + ALLOWLIST_ANCHOR.rstrip("\n")[:-1] + ", `C296Forbidden]\n") + + def kill_allowlist_mutant(result): + declarations = successful_audit(result, ALLOWED | {"C296Forbidden"}) + require("C296Forbidden" in declarations.get("C296Contaminated", set()), + "allowlist mutant did not exercise transitive contamination") + try: + policy_rejection(result, "C296_AXIOM_FORBIDDEN", "C296Forbidden") + except ControlFailure as error: + report["allowlist_mutant_rejection_failure"] = str(error) + return + raise ControlFailure("forbidden-axiom control failed to kill weakened allowlist") + + check("allowlist-weakened", weakened, kill_allowlist_mutant, + "WEAKENED_ALLOWLIST_KILLED_BY_FORBIDDEN_CONTROL") + check("setup-failure", "import C296FixtureMissingModuleNeverPublished\n", + lambda r: classified_failure(r, + r"unknown module prefix 'C296FixtureMissingModuleNeverPublished'|" + r"object file .*C296FixtureMissingModuleNeverPublished.*does not exist", + "SETUP_FAILURE"), "SETUP_FAILURE_NOT_POLICY_REJECTION") + check("syntax-failure", "import RegularPointChart\ndef C296Broken : Nat := )\n", + lambda r: classified_failure(r, r"unexpected token '\)'", "SYNTAX_FAILURE"), + "SYNTAX_FAILURE_NOT_POLICY_REJECTION") + require(len(report["controls"]) == 8, "incomplete audit-control campaign") + report["status"] = "PASS_ENGINEERING_CONTROLS_ONLY" + except Exception as error: + report["failure"] = type(error).__name__ + ": " + str(error) + finally: + after = source_snapshot() + report["source_after"] = after + report["production_sources_unchanged"] = before == after + if before != after: + report["status"] = "FAIL" + report["source_failure"] = "production source bytes changed" + save_json(directory / "RESULT.json", report) + emit_evidence(directory, report) + print(json.dumps({"status": report["status"], "evidence_directory": str(directory), + "controls_completed": len(report["controls"]), + "scientific_effect": "NONE"}, sort_keys=True)) + return 0 if report["status"] == "PASS_ENGINEERING_CONTROLS_ONLY" else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/frontiers/regular_point_chart_20261020/scripts/test_negative_classifier.sh b/frontiers/regular_point_chart_20261020/scripts/test_negative_classifier.sh new file mode 100644 index 000000000..cd0bc960a --- /dev/null +++ b/frontiers/regular_point_chart_20261020/scripts/test_negative_classifier.sh @@ -0,0 +1,114 @@ +#!/usr/bin/env bash +set -euo pipefail + +classifier="$(dirname "$0")/classify_negative.sh" +tmp="$(mktemp -d)" +trap 'rm -rf "$tmp"' EXIT + +expect_pass() { + local name="$1" status="$2" log="$3" + if ! bash "$classifier" "$log" "$status"; then + echo "expected pass: $name" >&2 + exit 1 + fi +} + +expect_fail() { + local name="$1" status="$2" log="$3" + if bash "$classifier" "$log" "$status"; then + echo "expected rejection: $name" >&2 + exit 1 + fi +} + +cat > "$tmp/intended.log" <<'EOF' +WithoutNoncriticality.lean:13:2: error: Type mismatch + regularPointChart hSmooth ?_ x +has type + ¬IsCriticalPoint d g x → OpenPartialHomeomorph (E d) (ℝ × ker) +EOF +expect_pass intended 1 "$tmp/intended.log" + +cat > "$tmp/syntax-token.log" <<'EOF' +WithoutNoncriticality.lean:13:2: error: unexpected token 'end'; expected term +-- IsCriticalPoint regularPointChart +EOF +expect_fail syntax-token 1 "$tmp/syntax-token.log" + +cat > "$tmp/resource-token.log" <<'EOF' +regularPointChart noncritical +lake env lean: Killed +fatal: out of memory +EOF +expect_fail resource-token 137 "$tmp/resource-token.log" + +cat > "$tmp/setup-token.log" <<'EOF' +noncritical regularPointChart +error: unknown module prefix 'Mathlib' +EOF +expect_fail setup-token 1 "$tmp/setup-token.log" + +expect_fail unexpected-success 0 "$tmp/intended.log" +expect_fail resource-exit-status 137 "$tmp/intended.log" + +expect_usage() { + local name="$1" status="$2" log="$3" rc=0 + bash "$classifier" "$log" "$status" || rc=$? + if [[ "$rc" -ne 2 ]]; then + echo "expected usage error (exit 2): $name" >&2 + exit 1 + fi +} + +# Each control below keeps all three intended markers, so only the check +# under test can reject it. +with_intended() { + local out="$1"; shift + cat "$tmp/intended.log" > "$out" + printf '%s\n' "$@" >> "$out" +} + +for sig in \ + "error: unknown package 'Mathlib'" \ + "error: invalid import: Foo" \ + "error: failed to fetch dependency" \ + "error: cannot find module Foo" \ + "no such file or directory" \ + "error: file not found: Foo.lean" \ + "lake: command not found" \ + "fatal: unable to access 'https://example.invalid/'" \ + "could not resolve host: example.invalid" \ + "HTTP 403" \ + "parser error" \ + "syntax error" \ + "invalid syntax" \ + "unexpected identifier" \ + "expected token" \ + "operation timed out" \ + "lake env lean: Killed" \ + "fatal: out of memory" \ + "OOM" \ + "memory exhausted" \ + "resource temporarily unavailable" \ + "no space left on device" \ + "terminated by signal 9" \ + "exit code 137"; do + with_intended "$tmp/signature.log" "$sig" + expect_fail "intended-plus: $sig" 1 "$tmp/signature.log" +done + +for st in 124 143; do + expect_fail "resource-exit-status-$st" "$st" "$tmp/intended.log" +done + +sed '/error: Type mismatch/d' "$tmp/intended.log" > "$tmp/no-mismatch.log" +expect_fail missing-type-mismatch 1 "$tmp/no-mismatch.log" +sed 's/error: Type mismatch/error: unsolved goals/' "$tmp/intended.log" > "$tmp/other-error.log" +expect_fail other-error-kind 1 "$tmp/other-error.log" +sed 's/¬IsCriticalPoint/IsCriticalPoint/' "$tmp/intended.log" > "$tmp/no-negation.log" +expect_fail missing-negated-premise 1 "$tmp/no-negation.log" +sed 's/→ OpenPartialHomeomorph/→ PartialEquiv/' "$tmp/intended.log" > "$tmp/no-chart.log" +expect_fail missing-chart-codomain 1 "$tmp/no-chart.log" +expect_usage non-numeric-status x "$tmp/intended.log" + +echo "negative classifier mutation tests: PASS"