From e62185fe81deae8cf65c9313366f2da425e969a5 Mon Sep 17 00:00:00 2001 From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com> Date: Mon, 9 Nov 2026 15:23:45 -0600 Subject: [PATCH 1/4] Specify bounded SDGA scope and observer contracts before implementation Freeze99 source bindings and1137literal public targets. Require20offline+1pinned-source controls in both modes. Initial absent sdga_scope import is absence evidence only; qualification remains BLOCKED and scientific effect NONE. --- .github/workflows/sdga-scope-contract.yml | 100 + DECISIONS.md | 23 + docs/cbz/SDGA_COMPONENT_DESIGN.md | 51 + ...2026-11-09-sdga-task1-scope-classifiers.md | 79 + tests/fixtures/sdga_scope/lake-manifest.json | 117 ++ tests/fixtures/sdga_scope/lakefile.toml | 219 ++ tests/fixtures/sdga_scope/lean-toolchain | 1 + tests/fixtures/sdga_scope/scope-f532.json | 1836 +++++++++++++++++ .../sdga_scope/source-scope-projection.json | 1312 ++++++++++++ tests/sdga_source_observation.py | 44 + tests/test_sdga_scope.py | 431 ++++ 11 files changed, 4213 insertions(+) create mode 100644 .github/workflows/sdga-scope-contract.yml create mode 100644 docs/cbz/SDGA_COMPONENT_DESIGN.md create mode 100644 docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md create mode 100644 tests/fixtures/sdga_scope/lake-manifest.json create mode 100644 tests/fixtures/sdga_scope/lakefile.toml create mode 100644 tests/fixtures/sdga_scope/lean-toolchain create mode 100644 tests/fixtures/sdga_scope/scope-f532.json create mode 100644 tests/fixtures/sdga_scope/source-scope-projection.json create mode 100644 tests/sdga_source_observation.py create mode 100644 tests/test_sdga_scope.py diff --git a/.github/workflows/sdga-scope-contract.yml b/.github/workflows/sdga-scope-contract.yml new file mode 100644 index 000000000..6bf13a937 --- /dev/null +++ b/.github/workflows/sdga-scope-contract.yml @@ -0,0 +1,100 @@ +name: sdga-scope-contract + +on: + pull_request: + push: + branches: + - main + workflow_dispatch: + +permissions: + contents: read + +jobs: + observe-scope: + runs-on: ubuntu-24.04 + timeout-minutes: 20 + defaults: + run: + shell: bash + working-directory: main + env: + SDGA_PINNED_MATH_ROOT: ${{ github.workspace }}/Math-source + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 + with: + path: main + fetch-depth: 0 + persist-credentials: false + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 + with: + repository: d6g8k5htny-coder/Math- + ref: f532c3e2d91a0c7679a37c733741660917a9b21b + path: Math-source + fetch-depth: 1 + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 + with: + python-version: "3.11" + - name: Guard and record exact source identities + run: | + python3 - <<'PY' + import hashlib, json, os, subprocess + from pathlib import Path + def git(root, expression): + return subprocess.check_output( + ["git", "-C", str(root), "rev-parse", "--verify", expression], + text=True).strip() + math = Path(os.environ["SDGA_PINNED_MATH_ROOT"]) + commit, tree = git(math, "HEAD^{commit}"), git(math, "HEAD^{tree}") + if commit != "f532c3e2d91a0c7679a37c733741660917a9b21b" or tree != "b713ebf4d444f0f0a304e50302b1fe616155201a": + raise SystemExit("Pinned Math source identity mismatch") + with open(os.environ["GITHUB_ENV"], "a", encoding="utf-8") as stream: + stream.write("SDGA_OBSERVED_MATH_COMMIT=" + commit + "\n") + stream.write("SDGA_OBSERVED_MATH_TREE=" + tree + "\n") + identity = dict(main_commit=git(Path("."), "HEAD^{commit}"), + main_tree=git(Path("."), "HEAD^{tree}"), + math_commit=commit, math_tree=tree, + profile_sha256=hashlib.sha256(Path("tests/fixtures/sdga_scope/scope-f532.json").read_bytes()).hexdigest(), + run_id=os.environ["GITHUB_RUN_ID"], + attempt=os.environ["GITHUB_RUN_ATTEMPT"], + scientific_effect="NONE", qualification="BLOCKED") + raw = json.dumps(identity, sort_keys=True) + "\n" + Path(os.environ["RUNNER_TEMP"], "sdga-source-identities.json").write_text(raw) + print(raw, end="") + PY + - name: Run pure scope contracts normally + run: | + set -euo pipefail + python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v 2>&1 | tee "$RUNNER_TEMP/sdga-scope-normal.log" + grep -Eq '^Ran 20 tests in ' "$RUNNER_TEMP/sdga-scope-normal.log" + - name: Run pure scope contracts optimized + if: ${{ !cancelled() }} + run: | + set -euo pipefail + python3 -B -O -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v 2>&1 | tee "$RUNNER_TEMP/sdga-scope-optimized.log" + grep -Eq '^Ran 20 tests in ' "$RUNNER_TEMP/sdga-scope-optimized.log" + - name: Observe original pinned source normally + if: ${{ !cancelled() }} + run: | + set -euo pipefail + python3 -B -S tests/sdga_source_observation.py -v 2>&1 | tee "$RUNNER_TEMP/sdga-source-normal.log" + grep -Eq '^Ran 1 test in ' "$RUNNER_TEMP/sdga-source-normal.log" + - name: Observe original pinned source optimized + if: ${{ !cancelled() }} + run: | + set -euo pipefail + python3 -B -O -S tests/sdga_source_observation.py -v 2>&1 | tee "$RUNNER_TEMP/sdga-source-optimized.log" + grep -Eq '^Ran 1 test in ' "$RUNNER_TEMP/sdga-source-optimized.log" + - name: Retain source identities and original results + if: always() + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4 + with: + name: sdga-scope-contract-${{ github.run_id }}-${{ github.run_attempt }} + path: | + ${{ runner.temp }}/sdga-source-identities.json + ${{ runner.temp }}/sdga-scope-normal.log + ${{ runner.temp }}/sdga-scope-optimized.log + ${{ runner.temp }}/sdga-source-normal.log + ${{ runner.temp }}/sdga-source-optimized.log + if-no-files-found: warn diff --git a/DECISIONS.md b/DECISIONS.md index 37edcafb5..aff162111 100644 --- a/DECISIONS.md +++ b/DECISIONS.md @@ -129,3 +129,26 @@ Append-only. Historical source outcomes remain in their original records. | 2026-11-09 20:00 | 2 | B/testing, CI | Print bounded fields from original prepared-Node results and the helper-control log footers in CI, so counts and source/fixture identities are directly inspectable even when the local artifact reader cannot start. Preserve all original artifacts and grading behavior; no result is synthesized from a PASS line. | Yes | First hosted run `42687230494`, job `129397179313`, at head `63ae24f10de2e04c18c452923dff524d17b86cb7` succeeded and uploaded artifact `13705427515`; exact artifact case counts were not yet independently read. [Prepared regression contract](docs/cbz/NODE_FORMAL_FIXTURE_20261109.md). | | 2026-11-09 20:36 | 2 | C/integration | Compose the prepared Node regression repair with current canonical records and the compatible three-file entry-routing delivery from Main #781. Preserve the full current Main decision prefix, all Node decisions, and the original Claude commits through ordered parents; leave peer refs untouched. Fresh source-exposed engineering review found no technical findings; GitHub returns no actual review submission, so no approval or scientific independence is inferred. Require fresh checks on the complete composition before protected merge. | Yes | Main `7738e4c2e0881dd952772421877d9854364d272f`; Node head `962923a12f82e88f54ece180fbabdf05934aae78`; entry-routing head `fd08c3f77b0e13e310a424f8fd38d2df6b28d7af` and original `f2f3bd6a01e7f549b8706d9b2a362e037d5c6827`; Main #781/#784. | | 2026-11-09 20:40 | 2 | C/integration | Preserve the newly landed inventory oracle-provenance repair while composing the Node and entry-routing deliveries with current Main. Keep all upstream files and the complete current ledger prefix, all prior Node decisions, and original entry-delivery lineage. Earlier Node component passes remain bound to their prior compositions; require fresh protected checks on this one. | Yes | Main #785 merge `c81b7572f3c690338db9d66fdea582fc68f4a73f`; prior Node head `54ff4cc9c9a5d8f11badcc311028dc86d09d938c`; Main #784. | + +## 2026-11-09 — SDGA bounded observer contract, before implementation + +- Phase2 / LayerB. Prepare an isolated test-first draft on Main1902 for the + fixed Mathf532 SDGA source:99 module/path/source bindings and1137 literal + written public targets, distinct from the complete compiled population. + Root read the design/plan/contracts and accepted the bounded observer + approach after a separate pinned-Lean API feasibility review. +- Task1 provides20 pure contract methods plus one explicit mandatory pinned + source control, all required in normal and optimized modes. The pinned + control stays outside ordinary offline discovery and fails on unavailable + inputs; no new dormant skip or optional coverage is added. A read-only + component workflow guards Math commit/tree, hashes original inputs and all + 99 selected sources, and retains original source/result evidence. +- The production module is deliberately absent in the initial draft. Expected + import failure is implementation-absence evidence only, never an adverse + rejection, mutation kill, Lean observation or gate pass. Root will observe + actual hosted absence before authorizing the minimal pure implementation. +- Qualification/classification remainBLOCKED and scientific_effectNONE. + Unknown type semantics, declaration roles and execution/kernel coverage + remain explicit. Later private/all-part inventory, missing-fatal axiom + traversal and exact sequential replay require their own real Lean controls. + No proof source, bound, disposition or scientific status is changed. diff --git a/docs/cbz/SDGA_COMPONENT_DESIGN.md b/docs/cbz/SDGA_COMPONENT_DESIGN.md new file mode 100644 index 000000000..1decd319d --- /dev/null +++ b/docs/cbz/SDGA_COMPONENT_DESIGN.md @@ -0,0 +1,51 @@ +# SDGA fresh-owned component observer + +Status: design only. Task 1 supplies source-scope and protocol contracts, not Lean execution or qualification. + +The source is Math commit f532c3e2d91a0c7679a37c733741660917a9b21b, tree b713ebf4d444f0f0a304e50302b1fe616155201a, package frontiers/source_derivative_gaussian_20261025. Scope is exactly 67 production modules, 25 ordinary inputs and seven elder inputs. The 1,137 literal written public targets are a separate population from all compiled declarations. The documented target split is 1,128 Prop and nine data targets; actual compiled observations must reconcile it. + +## Boundaries + +- scientific_effect is always NONE. qualification and classification_status remain BLOCKED in this milestone. +- No full G2–G4, final CBZ, proof-closure, parent-application or scientific-status claim. +- Historical manifest status/catalog prose is not admission authority. The projection fixture contains only source_modules, targets, inherited_input_count and the selected 99 source hashes. +- Exact type semantics and full declaration roles remain unresolved. Emit type displays and bind original compiled object parts; do not call displays a lossless or canonical type representation. +- Task 1 validates declared receipt fields only. Matching caller assertions cannot authenticate execution. Later execution requires independently measured source/tool/object/log identities. +- No default PASS path, arbitrary configured command, implicit retry, source modification or whole-federation orchestration. + +## Minimal later observer + +A Python adapter consumes the frozen scope profile. One Lean collector imports the exact 99 modules at private visibility and enumerates actual module ownership, including foreign namespaces, private declarations, generated declarations, definitions, data, inductives, constructors and recursors. It loads and binds all exported/server/private object parts. Each part must reconcile constNames with ConstantInfo names in length, identity and duplicates; the most private part must contain earlier parts. Reconcile all final declaration rows and per-module counts. Enumerate extraConstNames or block explicitly. + +Use a strict transitive axiom traversal following Lean's ConstantInfo cases, with missing lookups fatal. Reject every owned axiom declaration even if its name resembles an approved axiom. Audit all owned constants and the literal public targets against only propext, Classical.choice and Quot.sound. Report observed Prop/data using Lean's type judgment, not ConstantInfo kind. All unreviewed roles and exact type semantics remain BLOCKED. + +Start from fresh owned outputs. Reuse only verified external dependencies from the pinned Math formal package cache. Verify nine revisions, their resolved dependency/object-part identities and toolchain before/after; never expose formal/.lake/build or another package's owned objects. In particular, ResearchFormalCoreR1 input names must resolve to the fresh SDGA build. Bind source, cache, resolved paths and artifacts before/after. + +Reuse Main cbz/contributions/math514/kernel_replay/ExactReplay.lean, blob 400f3853d50df7ea2a9b4bb2fc1de302626f2efa, observed at f1ef3a2. Its interface is CBZ_KERNEL_REPLAY_MODULE plus CBZ_KERNEL_REPLAY_OLEAN; invoke as a Lean file, not lean --run, because imported LeanChecker defines main. Run one exact module per process, sequentially. It uses upstream replayFromImports; unsafe/partial constants are skipped upstream and must be reported as uncovered and block all-owned kernel qualification. + +Pinned Lean 4.34.1 is release commit 5045d0056413266e57c625dcd7c365b10e377c52. Existing formal-lean.yml blob b9165ec9ce50337087ea19cad148fe68eb15b037 supplies accepted read-only setup using lean-action 24581d74d674803a25a81b10b059c5c0cdd344c6, build/test/lint/auto-config false, mathlib cache true and GitHub cache false. Use two Lean threads and one kernel process at a time. LEAN_NUM_THREADS=2 does not cap Lake's parallel processes, and this Lake has no assumed -j option; build scheduling/resource controls require separate review before execution. + +Preserve actual commands, UTC/monotonic times, exits/signals/timeouts, peak resource observations, stream hashes, object-part hashes and native run/attempt identity on success and failure. Missing, stale, skipped, timed-out, cancelled, drifted or unsupported stages cannot receive pass credit. No execution is part of Task 1. + +## Task 1 files + +- tools/sdga_scope.py: future standard-library scope extraction, Name/protocol validation and blocked classifiers. Deliberately absent from the initial RED draft. +- tests/test_sdga_scope.py: 20 pure API contracts discovered by ordinary Main test discovery; initial ImportError is absence evidence, not an adverse-control kill. +- tests/sdga_source_observation.py: one mandatory pinned-source control, invoked explicitly; missing required source environment fails. +- tests/fixtures/sdga_scope/: frozen profile, three small original configuration inputs, labelled source-scope projection. +- docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md: executable test-first handoff. + +Original source bytes and MCP provenance are preserved outside the public staging tree in scratch. The full original manifest exceeds 2 MiB; a 2 MiB input limit would reject the actual source. + +## Mandatory control organization + +The pinned-source control is outside ordinary test_*.py discovery so ordinary Main runs do not acquire a dormant skip. Coverage is preserved: the dedicated read-only component workflow always checks out pinned Math, guards its exact commit/tree, supplies all three required environment values and runs all 21 controls in each Python mode. Missing environment values fail; there is no optional enable flag or skip. + +Required commands are: + + python3 -m unittest discover -s tests -p 'test_sdga_scope.py' -v + python3 tests/sdga_source_observation.py -v + python3 -O -m unittest discover -s tests -p 'test_sdga_scope.py' -v + python3 -O tests/sdga_source_observation.py -v + +All four workflow matrix cells are mandatory: 20 offline contracts plus one pinned-source control in normal mode, and the same 21 in optimized mode. Ordinary discovery runs the 20 pure methods only. This organization change removes conditional coverage; it does not drop the original input/source hash assertions or confer execution qualification. diff --git a/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md b/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md new file mode 100644 index 000000000..d987d00bd --- /dev/null +++ b/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md @@ -0,0 +1,79 @@ +# SDGA Task 1 Scope and Classifiers Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox syntax for tracking. + +**Goal:** Extract and validate the frozen SDGA source scope and strictly classify declared inventory/receipt fields while every qualification remains BLOCKED. + +**Architecture:** A small Python 3.11 standard-library module has no process, Git, network, Lean, filesystem-write or retry capability. Pure functions consume caller-provided bytes/dictionaries. Original-source verification and offline projection tests remain distinguishable. + +**Tech Stack:** Python 3.11+, unittest, hashlib, json and tomllib. + +**Spec:** docs/cbz/SDGA_COMPONENT_DESIGN.md + +## Global Constraints + +- Math source: f532c3e2d91a0c7679a37c733741660917a9b21b; tree b713ebf4d444f0f0a304e50302b1fe616155201a. +- Exactly 99 module/path/hash/role bindings: 67 production, 25 ordinary inputs, seven elder inputs. +- Preserve the literal ordered 1,137-target vector, including Unicode. Its UTF-8 newline-terminated vector SHA256 is 2c22d5ba939ed6cf74669a99a23ad8337ec9a54abcafb3bf43ef5799e5536cae. +- scientific_effect=NONE, qualification=BLOCKED and classification_status=BLOCKED for all Task 1 outputs. +- No type AST serializer, Lean execution, proof changes, role admission, artifact authentication, generic orchestrator or external writes. +- Reject bool where an integer is required. Do not normalize Unicode or collapse numeric/string Name components. +- Initial missing-module import is valid absence evidence only. It provides no adverse-rejection or mutation credit. +- The dedicated read-only component workflow always checks out pinned Math and executes all 20 offline methods plus the one explicit pinned-source method in both normal and optimized Python. No optional coverage, skipTest, conditional disable or selective green matrix. +- Do not add a placeholder production scaffold. Root publishes the immutable test-first draft, captures hosted RED, then authorizes implementation. + +## Review Focus + +1. The real manifest exceeds 2 MiB; the pinned-source test must read and hash the original successfully. +2. Two distinct Unicode spellings and quoted-dot/numeric Name components must remain distinct. +3. Exported/server/private cumulative parts may repeat a name across parts; duplicates within a part or mismatched parallel tables must fail. +4. Empty stdout/stderr may be valid; bind their measured hashes rather than requiring nonempty logs. +5. Expected receipt fields must be supplied independently in later execution; Task 1 reports declared-fields validity only. + +## Task 1: Pure scope and fail-closed classifiers + +**Files** +- Create later: tools/sdga_scope.py +- Test first: tests/test_sdga_scope.py (20 pure API methods) +- Test first: tests/sdga_source_observation.py (one mandatory explicit pinned-source method; outside test_*.py discovery) +- Frozen data: tests/fixtures/sdga_scope/{scope-f532.json,lakefile.toml,lake-manifest.json,lean-toolchain,source-scope-projection.json} + +**Interfaces** +- ScopeError(ValueError), NameProtocolError(ValueError), InventoryProtocolError(ValueError); each exposes stable string attribute code. +- extract_scope(raw_inputs: dict[str, bytes], profile: dict, observed_identity: dict) -> dict +- verify_source_files(scope: dict, source_files: dict[str, bytes]) -> None +- encode_name(name: tuple[str | int, ...]) -> str +- decode_name(encoded: str) -> tuple[str | int, ...] +- parse_inventory(text: str) -> dict +- classify_inventory(inventory: dict, scope: dict) -> dict +- classify_receipt(receipt: dict, expected: dict) -> dict + +extract_scope validates exact four input keys and each raw length/SHA256/Git-blob binding from profile.inputs before parsing, then exact source identity against profile.source, pinned toolchain, dependency lock, package name, default production roots, the 25+7 input roots, source-module reconciliation, unique target strings and selected source hashes. It reconciles exact module/path/hash/role rows, dependency pins, target vector and counts with the profile; it returns modules [{module,path,role,source_sha256}], targets, source, scientific_effect, qualification and classification_status. Reject duplicate JSON keys, absolute/escaping source paths and duplicate/colliding module identities. Frozen profile comparisons live in tests and the later fixed adapter; accepting a caller profile is not provenance authentication. Scope error codes are INPUT_BINDING, SOURCE_IDENTITY, MODULE_SCOPE, TARGET_SCOPE, DEPENDENCY_SCOPE, TOOLCHAIN_SCOPE, SOURCE_BINDING, PATH_SCOPE and JSON_PROTOCOL. + +verify_source_files requires exactly the scope's selected relative file set and compares every raw source SHA256. It performs no path reads itself. + +Names use the existing lossless component convention: anonymous is empty, string components are s followed by lowercase UTF-8 hex, numeric components are n followed by canonical nonnegative decimal; components separated by /. Preserve empty string components and Unicode code points exactly. Declaration/module identities must be nonanonymous even though the codec supports anonymous. + +Inventory is strict JSONL, one header first and one end last, no noise/blank records/trailing records/duplicate JSON keys or nonfinite numbers. Schema 1 header has scope_id. Module rows have name, const_count, object_parts and extra_const_names. Each part has level (exported/server/private), sha256, const_names and constant_names; order is increasing visibility, exported first, unique levels, equal parallel vectors with unique names, earlier names contained in the last part. Declaration rows have module,name,kind,is_prop,is_private,unsafe,partial,type_display,object_part_sha256,axioms. Kinds: theorem,definition,opaque,axiom,inductive,constructor,recursor,quotient. Type display is explanatory only. All booleans must be actual booleans. Declaration rows exactly cover each module's last-part names and count; object binding must match its last part. End has module_count,declaration_count,axioms. End axiom vector is the exact union of row vectors. Return normalized scope_id/modules/declarations/axioms without dropping unknown constants. Reject unknown protocol fields; permit only a final newline, not blank records. + +classify_inventory checks scope ID/exact modules and targets, production ownership of targets, observed Prop/data counts, owned axioms, forbidden axioms, unsupported extras and unsafe/partial replay skips. Findings are dictionaries with code and name; names are lossless encoded where applicable. No namespace-prefix filtering. Return counts (owned_declarations,public_targets,proposition_targets,data_targets), findings and fixed BLOCKED/NONE fields. Unresolved blockers are EXACT_TYPE_SEMANTICS_UNRESOLVED, FULL_DECLARATION_ROLES_UNRESOLVED, EXECUTION_NOT_OBSERVED and KERNEL_COVERAGE_UNESTABLISHED, even for valid fixtures. Finding codes tested are MODULE_SCOPE, TARGET_SCOPE, TARGET_OWNER, TARGET_KIND_COUNTS, UNSUPPORTED_EXTRAS, UNSAFE_REPLAY_SKIP, PARTIAL_REPLAY_SKIP, FORBIDDEN_AXIOM and OWNED_AXIOM. + +classify_receipt checks exact source/tool/profile/cache/object/log/run/attempt/module bindings and required step coverage. Positive result binding_status=DECLARED_FIELDS_VALID; adverse result binding_status=INVALID with stable findings. Require signal and timed_out fields explicitly; zero integer exit, null signal, false timeout and nonnegative numeric resource/time fields for every required step. Reject bool exit, source/cache drift, missing/extra/duplicate steps, missing object/module coverage and unsafe/partial skips. It returns execution_authenticated=false and never qualification PASS. For a single defective fixture return exactly its designated code. Deterministic validation priority is RECEIPT_SCHEMA, STEP_COVERAGE, STEP_FAILED, SOURCE_DRIFT, CACHE_DRIFT, MODULE_COVERAGE, REPLAY_SKIPPED, RECEIPT_BINDING. Names/notes may identify the defective field. Use the same four fixed unresolved blockers as the inventory classifier. + +- [ ] Step 1: Publish the 20 pure API methods, explicit pinned-source control and immutable fixtures without tools/sdga_scope.py. Keep tests/sdga_source_observation.py outside ordinary test_*.py discovery. +- [ ] Step 2: On the hosted draft always check out pinned Math, guard native commit/tree and set SDGA_PINNED_MATH_ROOT, SDGA_OBSERVED_MATH_COMMIT and SDGA_OBSERVED_MATH_TREE. Execute all four mandatory commands below as independent matrix cells; preserve complete output and exact head/attempt. ModuleNotFoundError for sdga_scope is the expected initial absence observation, not adverse-control credit. + + python3 -m unittest discover -s tests -p 'test_sdga_scope.py' -v + python3 tests/sdga_source_observation.py -v + python3 -O -m unittest discover -s tests -p 'test_sdga_scope.py' -v + python3 -O tests/sdga_source_observation.py -v +- [ ] Step 3: After root authorization, implement only the interfaces above using standard-library parsing and explicit checks, never Python assert for validation. +- [ ] Step 4: Run all four mandatory commands again. Exactly 20 offline methods and one explicit pinned-source method must pass in each mode, with no skips. No production fixture or expected hash may be rewritten to accommodate an observed result. +- [ ] Step 5: Review the explicit pinned-source results from both modes. Required environment checks must fail if unavailable; the original assertions still independently hash all four raw inputs and all 99 source files before comparing extracted scope. Preserve raw output and native source bindings. Every component workflow run must include these results. +- [ ] Step 6: Review the exact diff and evidence. Do not claim Lean execution, real axiom closure, replay coverage or mutation kills from Task 1. Root decides integration; this plan authorizes no commit/ref/PR action. + +Later milestones need genuine tiny Lean positive/adverse controls, private-level all-part collection, strict missing-fatal axiom traversal and exact named replay before their own admission. Those are deliberately outside this Task 1. + +## Test organization rationale + +The original pinned-source method moved intact to tests/sdga_source_observation.py except that its optional skip became required environment assertions. It imports shared ContractCase/fixtures/API helpers from test_sdga_scope. Ordinary discovery therefore adds 20 pure contracts and no dormant skip. The dedicated component matrix retains all 21 controls in each mode and cannot claim complete Task 1 coverage from the offline subset alone. diff --git a/tests/fixtures/sdga_scope/lake-manifest.json b/tests/fixtures/sdga_scope/lake-manifest.json new file mode 100644 index 000000000..9fe133235 --- /dev/null +++ b/tests/fixtures/sdga_scope/lake-manifest.json @@ -0,0 +1,117 @@ +{ + "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": "source_smooth_realization", + "lakeDir": ".lake", + "fixedToolchain": true +} diff --git a/tests/fixtures/sdga_scope/lakefile.toml b/tests/fixtures/sdga_scope/lakefile.toml new file mode 100644 index 000000000..b4955b68b --- /dev/null +++ b/tests/fixtures/sdga_scope/lakefile.toml @@ -0,0 +1,219 @@ +name = "source_derivative_gaussian" +version = "0.1.0" +defaultTargets = ["SourceDerivativeGaussian", "ContactJetCovariance", "SourceContactCovariance", "SourceConfluentPins", "SourceContactSchur", "SourceDerivativeContinuity", "ConfluentIntegralIdentities", "SourceEndpointRegression", "GaussianRegressionLimits", "SourceEndpointParameters", "SourceContactEndpointParameters", "SourceConfluentLimits", "SourcePhysicalEndpointKernel", "SourceEndpointEstimates", "SourceSmoothConditionalKernel", "SourceSmoothPalm", "GaussianWeightedMajorants", "SourceConditionalMajorant", "SourcePinCurvatureBounds", "ScalarProductCurvatureBound", "SourceCurvatureDecomposition", "SourceWeightedCurvatureBound", "SourcePinPreservingQuartic", "SourceSmoothTopology", "SourceRawPinConditioning", "SourceQuarticCaptureAlgebra", "SourceMorseIncidence", "SourceSmoothParameterSpace", "SourceLifetimePairFiniteness", "SourceCompactTargetMoments", "AdaptiveFoldScalarBarrier", "AdaptiveFoldTransverseRidge", "AdaptiveFoldBoundaryPath", "SourceAdaptiveFoldChart", "SourceAdaptiveFoldEstimates", "SourceActualFoldDeath", "SourceActualFoldTorus", "SourceActualFoldH0", "SourceFoldWeightedProbability", "SourceGapPinCurvature", "SourceAllTargetCurvatureResidual", "SourceGapWeightedNumerator", "SourceCompactGapNormalizer", "SourceCompactFoldWeightedProbability", "SourceActualFoldCandidate", "SourceFinitePinKernel", "SourceFiniteTrig", "SourceRemoteJetWitness", "SourceRemoteJetGaussian", "SourceEndpointHessianWitness", "SourceH0OlderClearance", "SourceEndpointHessianGaussian", "SourceTwoRemoteFirstJetWitness", "SourceIntrinsicH0Interface", "SourceTwoRemoteFirstJetGaussian", "SourceIntrinsicH0WeightedProbability", "SourceRawPinFreeCoordinates", "SourceFramedConfluentCovariance", "SourceGapConditionalMorseDistinct", "SourceActualMorseLocalModel", "SourceActualTorusSuperlevelLocalBasis", "SourceActualTorusRegularSlab", "SourceActualFiniteSuperlevelComponents", "SourceActualQuotientSaddleCollar", "SourceActualSaddleUppercuts", "SourceActualRegularLocalCollar", "SourceActualLowerSeparation"] + +[[require]] +name = "mathlib" +git = "https://github.com/leanprover-community/mathlib4.git" +rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + +[[lean_lib]] +name = "SourceDerivativeInputs" +srcDir = "inputs" +roots = ["GaussianSeriesFoundation", "SpectralWeights", "SourceFourierSeries", "SourceC4", "SourceGaussianLaw", "SourceLattice", "SourceKernel", "SourceCovariance", "SourceTorus", "SourceTorusC4", "SourceSmooth", "SourceSmoothCarrier", "ResearchFormalCoreR1.DeterminantMoment", "ResearchFormalCoreR1.GaussianScalarMoments", "ResearchFormalCoreR1.GaussianJetMoments", "ResearchFormalCoreR1.GaussianNormalizer", "ResearchFormalCoreR1.EndpointGaussianMoments", "ResearchFormalCoreR1.NormalizerFloor", "ResearchFormalCoreR1.EndpointNormalizerBridge", "ResearchFormalCoreR1.GaussianCoupling", "ResearchFormalCoreR1.GaussianNormalizerLimit", "ResearchFormalCoreR1.PalmReweighting", "ResearchFormalCoreR1.GaussianRegressionKernel", "Lifetime", "SourceLifetimeGeometry"] + +[[lean_lib]] +name = "SourceDerivativeGaussian" + +[[lean_lib]] +name = "ContactJetCovariance" + +[[lean_lib]] +name = "SourceContactCovariance" + +[[lean_lib]] +name = "SourceConfluentPins" + +[[lean_lib]] +name = "SourceContactSchur" + +[[lean_lib]] +name = "SourceDerivativeContinuity" + +[[lean_lib]] +name = "ConfluentIntegralIdentities" + +[[lean_lib]] +name = "SourceEndpointRegression" + +[[lean_lib]] +name = "GaussianRegressionLimits" + +[[lean_lib]] +name = "SourceEndpointParameters" + +[[lean_lib]] +name = "SourceContactEndpointParameters" + +[[lean_lib]] +name = "SourceConfluentLimits" + +[[lean_lib]] +name = "SourcePhysicalEndpointKernel" + +[[lean_lib]] +name = "SourceEndpointEstimates" + +[[lean_lib]] +name = "SourceSmoothConditionalKernel" + +[[lean_lib]] +name = "SourceSmoothPalm" + +[[lean_lib]] +name = "GaussianWeightedMajorants" + +[[lean_lib]] +name = "SourceConditionalMajorant" + +[[lean_lib]] +name = "SourcePinCurvatureBounds" + +[[lean_lib]] +name = "ScalarProductCurvatureBound" + +[[lean_lib]] +name = "SourceCurvatureDecomposition" + +[[lean_lib]] +name = "SourceWeightedCurvatureBound" + +[[lean_lib]] +name = "SourcePinPreservingQuartic" + +[[lean_lib]] +name = "SourceSmoothTopology" + +[[lean_lib]] +name = "SourceRawPinConditioning" + +[[lean_lib]] +name = "SourceQuarticCaptureAlgebra" + +[[lean_lib]] +name = "SourceMorseIncidence" + +[[lean_lib]] +name = "SourceSmoothParameterSpace" + +[[lean_lib]] +name = "SourceLifetimePairFiniteness" + +[[lean_lib]] +name = "SourceCompactTargetMoments" + +[[lean_lib]] +name = "AdaptiveFoldScalarBarrier" + +[[lean_lib]] +name = "AdaptiveFoldTransverseRidge" + +[[lean_lib]] +name = "AdaptiveFoldBoundaryPath" + +[[lean_lib]] +name = "SourceAdaptiveFoldChart" + +[[lean_lib]] +name = "SourceAdaptiveFoldEstimates" + +[[lean_lib]] +name = "SourceElderInputs" +srcDir = "inputs/elder" +roots = ["SuperlevelBar", "ElderClearance", "ReusedCompactFrontier", "ClosedSuperlevel", "OrdinaryH0", "ElderInterval", "ElderBridge"] + +[[lean_lib]] +name = "SourceActualFoldDeath" + +[[lean_lib]] +name = "SourceActualFoldTorus" + +[[lean_lib]] +name = "SourceActualFoldH0" + +[[lean_lib]] +name = "SourceFoldWeightedProbability" + +[[lean_lib]] +name = "SourceGapPinCurvature" + +[[lean_lib]] +name = "SourceAllTargetCurvatureResidual" + +[[lean_lib]] +name = "SourceGapWeightedNumerator" + +[[lean_lib]] +name = "SourceCompactGapNormalizer" + +[[lean_lib]] +name = "SourceCompactFoldWeightedProbability" + +[[lean_lib]] +name = "SourceActualFoldCandidate" + +[[lean_lib]] +name = "SourceFinitePinKernel" + +[[lean_lib]] +name = "SourceFiniteTrig" + +[[lean_lib]] +name = "SourceRemoteJetWitness" + +[[lean_lib]] +name = "SourceRemoteJetGaussian" + +[[lean_lib]] +name = "SourceEndpointHessianWitness" + +[[lean_lib]] +name = "SourceH0OlderClearance" + +[[lean_lib]] +name = "SourceEndpointHessianGaussian" + +[[lean_lib]] +name = "SourceTwoRemoteFirstJetWitness" + +[[lean_lib]] +name = "SourceIntrinsicH0Interface" + +[[lean_lib]] +name = "SourceTwoRemoteFirstJetGaussian" + +[[lean_lib]] +name = "SourceIntrinsicH0WeightedProbability" + +[[lean_lib]] +name = "SourceRawPinFreeCoordinates" + +[[lean_lib]] +name = "SourceFramedConfluentCovariance" + +[[lean_lib]] +name = "SourceGapConditionalMorseDistinct" + +[[lean_lib]] +name = "SourceActualMorseLocalModel" + +[[lean_lib]] +name = "SourceActualTorusSuperlevelLocalBasis" + +[[lean_lib]] +name = "SourceActualTorusRegularSlab" + +[[lean_lib]] +name = "SourceActualFiniteSuperlevelComponents" + +[[lean_lib]] +name = "SourceActualQuotientSaddleCollar" + +[[lean_lib]] +name = "SourceActualSaddleUppercuts" + +[[lean_lib]] +name = "SourceActualRegularLocalCollar" + +[[lean_lib]] +name = "SourceActualLowerSeparation" diff --git a/tests/fixtures/sdga_scope/lean-toolchain b/tests/fixtures/sdga_scope/lean-toolchain new file mode 100644 index 000000000..ba8ebf2db --- /dev/null +++ b/tests/fixtures/sdga_scope/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.34.1 diff --git a/tests/fixtures/sdga_scope/scope-f532.json b/tests/fixtures/sdga_scope/scope-f532.json new file mode 100644 index 000000000..4c6b4ea59 --- /dev/null +++ b/tests/fixtures/sdga_scope/scope-f532.json @@ -0,0 +1,1836 @@ +{ + "schema": 1, + "scope_id": "math-f532-sdga", + "scientific_effect": "NONE", + "qualification": "BLOCKED", + "source": { + "repository": "d6g8k5htny-coder/Math-", + "commit": "f532c3e2d91a0c7679a37c733741660917a9b21b", + "tree": "b713ebf4d444f0f0a304e50302b1fe616155201a", + "package": "frontiers/source_derivative_gaussian_20261025" + }, + "inputs": { + "lakefile.toml": { + "git_blob": "b4955b68b300c16869d01b56145b6c1a059b26db", + "sha256": "32505e663fea5a9bc69c51dd93306853800a29fc8cb01df395cdb436b5d23b3f", + "bytes": 6581, + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/f532c3e2d91a0c7679a37c733741660917a9b21b/frontiers/source_derivative_gaussian_20261025/lakefile.toml" + }, + "lake-manifest.json": { + "git_blob": "9fe1332352893f5f89e74b550a25ee187b871ed3", + "sha256": "4cc60e1f98fc3a46bccafe6b8315445d950ca1db55ceba26fdebe3a45eafe59a", + "bytes": 3558, + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/f532c3e2d91a0c7679a37c733741660917a9b21b/frontiers/source_derivative_gaussian_20261025/lake-manifest.json" + }, + "lean-toolchain": { + "git_blob": "ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5", + "sha256": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b", + "bytes": 25, + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/f532c3e2d91a0c7679a37c733741660917a9b21b/frontiers/source_derivative_gaussian_20261025/lean-toolchain" + }, + "SOURCE_MANIFEST.json": { + "git_blob": "cc7425b0f95f2bdc53a01395cac2f3eede566f7c", + "sha256": "f72f78c07267653cadd49cc76200d1f54440de769d02ba9e5490e142b434993d", + "bytes": 2097345, + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/f532c3e2d91a0c7679a37c733741660917a9b21b/frontiers/source_derivative_gaussian_20261025/SOURCE_MANIFEST.json" + } + }, + "modules": [ + { + "module": "SourceDerivativeGaussian", + "path": "SourceDerivativeGaussian.lean", + "role": "production", + "source_sha256": "c9754debcbf2aab7ff8d9604f2c13726723e8a8c1921ae68f83349205e43885d" + }, + { + "module": "ContactJetCovariance", + "path": "ContactJetCovariance.lean", + "role": "production", + "source_sha256": "50df0281c580ac7af018713a38c6bdd5dd34b52e3834b573165045bc64acd49d" + }, + { + "module": "SourceContactCovariance", + "path": "SourceContactCovariance.lean", + "role": "production", + "source_sha256": "4189cbaf4c18c55f21e3af2c96b0b2842d83161f44596eb691c507dcc1a439c8" + }, + { + "module": "SourceConfluentPins", + "path": "SourceConfluentPins.lean", + "role": "production", + "source_sha256": "41e1ea1ef4f9960307552a8271a5c04d2b72d94736b98eb601b51669ed603c3f" + }, + { + "module": "SourceContactSchur", + "path": "SourceContactSchur.lean", + "role": "production", + "source_sha256": "2fe122a50ec1889b579558d80086251d87ed0cec2420d268ab1d04f6bfff4409" + }, + { + "module": "SourceDerivativeContinuity", + "path": "SourceDerivativeContinuity.lean", + "role": "production", + "source_sha256": "552511e0aee227133b7d067faeceaab9c43c0094b07d68b8eddab0ab2419775e" + }, + { + "module": "ConfluentIntegralIdentities", + "path": "ConfluentIntegralIdentities.lean", + "role": "production", + "source_sha256": "0324d7556d485cd360a513587199354fa1f3863d15cf06b52c86e362de5e56b8" + }, + { + "module": "SourceEndpointRegression", + "path": "SourceEndpointRegression.lean", + "role": "production", + "source_sha256": "67e68553e004adc3b1b6beb987b3e7ad477b4541d96fec22ee481facd2038fce" + }, + { + "module": "GaussianRegressionLimits", + "path": "GaussianRegressionLimits.lean", + "role": "production", + "source_sha256": "26c403ea1104fbce89f5c2833f603edd4d2703669d8a94a77b2c9a2a06b572be" + }, + { + "module": "SourceEndpointParameters", + "path": "SourceEndpointParameters.lean", + "role": "production", + "source_sha256": "efc88ac59217ab1960d5518abcd9f16a71b42080a2810f1e337eeb2f686c1e3a" + }, + { + "module": "SourceContactEndpointParameters", + "path": "SourceContactEndpointParameters.lean", + "role": "production", + "source_sha256": "da5337a7814a008eaa8b8a98c0df4daf3efb1bc347789a2f75efc63c9c258d01" + }, + { + "module": "SourceConfluentLimits", + "path": "SourceConfluentLimits.lean", + "role": "production", + "source_sha256": "1635a05bbd5b56608bc0a1a04eb4404c2df4601f1255f5846c1342a597bf5b0b" + }, + { + "module": "SourcePhysicalEndpointKernel", + "path": "SourcePhysicalEndpointKernel.lean", + "role": "production", + "source_sha256": "689ced2a760b38333b0224f19af52812d0057527d5a790ba50116cb5f07b7e3a" + }, + { + "module": "SourceEndpointEstimates", + "path": "SourceEndpointEstimates.lean", + "role": "production", + "source_sha256": "d1f08d80d06d1ac08afbdd700370059fd8eaf0d4e483916e742efcdd1f664598" + }, + { + "module": "SourceSmoothConditionalKernel", + "path": "SourceSmoothConditionalKernel.lean", + "role": "production", + "source_sha256": "664892acb12d40e5bf20075e1ef633efdd4a54ae1308c714308eab3a4deaa517" + }, + { + "module": "SourceSmoothPalm", + "path": "SourceSmoothPalm.lean", + "role": "production", + "source_sha256": "1b1d47b640b541195dad1472a07fa9490f203bd1619b1759b29587a0effe631d" + }, + { + "module": "GaussianWeightedMajorants", + "path": "GaussianWeightedMajorants.lean", + "role": "production", + "source_sha256": "3bde84aa83d02b364ca17f242cc5dbca83908c02f2f75649075d7da6a3d1bfd0" + }, + { + "module": "SourceConditionalMajorant", + "path": "SourceConditionalMajorant.lean", + "role": "production", + "source_sha256": "07ae7796e461a2ee59a757b37a3e64f7ed31c76d26a3b40825f23170fcb4e691" + }, + { + "module": "SourcePinCurvatureBounds", + "path": "SourcePinCurvatureBounds.lean", + "role": "production", + "source_sha256": "b19a673aa594d1d5ef929cc598f0a142efb56c10b78c4634c92a8a749d1f1d51" + }, + { + "module": "ScalarProductCurvatureBound", + "path": "ScalarProductCurvatureBound.lean", + "role": "production", + "source_sha256": "fb77c9a4eaf165a39c6c06535fbb3f3f164bca12ddbc2f29b01a33e512564b71" + }, + { + "module": "SourceCurvatureDecomposition", + "path": "SourceCurvatureDecomposition.lean", + "role": "production", + "source_sha256": "ba9011f17a8bf6c1a7d32d248a464a49c04d1836e9e4f2f3ec3190fad8b6d503" + }, + { + "module": "SourceWeightedCurvatureBound", + "path": "SourceWeightedCurvatureBound.lean", + "role": "production", + "source_sha256": "9926f650c8fb9baf13261ba7ea1d01bd7a5cfb95c7175163888c42a62934a3f9" + }, + { + "module": "SourcePinPreservingQuartic", + "path": "SourcePinPreservingQuartic.lean", + "role": "production", + "source_sha256": "8e23717ef98518b6d701db921d1f17958c3dee2c893745cafa7aa6172f1621d9" + }, + { + "module": "SourceSmoothTopology", + "path": "SourceSmoothTopology.lean", + "role": "production", + "source_sha256": "ba57c81708056b22e9fc17285969b43fe968e758f2e957bbbef75af7cf82d0ae" + }, + { + "module": "SourceRawPinConditioning", + "path": "SourceRawPinConditioning.lean", + "role": "production", + "source_sha256": "77e521c7fc3fc3da1c922a4ef547b065be58b232b321480948c8fe50d76c2aa5" + }, + { + "module": "SourceQuarticCaptureAlgebra", + "path": "SourceQuarticCaptureAlgebra.lean", + "role": "production", + "source_sha256": "ba338bba6fdd6fae70f5379c8ff58a424237baf090672a7e3303691ff2f0209a" + }, + { + "module": "SourceMorseIncidence", + "path": "SourceMorseIncidence.lean", + "role": "production", + "source_sha256": "b93fe8f7856d4e632b3ff823788469720ae0814440bbec744fde099d4f29f127" + }, + { + "module": "SourceSmoothParameterSpace", + "path": "SourceSmoothParameterSpace.lean", + "role": "production", + "source_sha256": "b98a5aab4e27d943dd08eb12291fbc0056e7d54d9f7e8f53a255f8863f9c510c" + }, + { + "module": "SourceLifetimePairFiniteness", + "path": "SourceLifetimePairFiniteness.lean", + "role": "production", + "source_sha256": "36bf363f88d450a61052086c5d7eb799d12dd58ce4b74c1c083a056991606081" + }, + { + "module": "SourceCompactTargetMoments", + "path": "SourceCompactTargetMoments.lean", + "role": "production", + "source_sha256": "4fc28898f09381b4bfd0a15324556d2f3cb68f4b39063aa3acf12db7759ccfc8" + }, + { + "module": "AdaptiveFoldScalarBarrier", + "path": "AdaptiveFoldScalarBarrier.lean", + "role": "production", + "source_sha256": "cfe6a63a789ae085c2351d9d0be9bcf998f911d8c2e80bb01e1dd9e2b74c30d5" + }, + { + "module": "AdaptiveFoldTransverseRidge", + "path": "AdaptiveFoldTransverseRidge.lean", + "role": "production", + "source_sha256": "715b01c2ae3b6e2bceb4196e53361530c8c9c69550e7cf675904cd5661b3de20" + }, + { + "module": "AdaptiveFoldBoundaryPath", + "path": "AdaptiveFoldBoundaryPath.lean", + "role": "production", + "source_sha256": "b3a196c31c0c7957119907ea864c33b937d1a783bc7109390d3ca24a644e0570" + }, + { + "module": "SourceAdaptiveFoldChart", + "path": "SourceAdaptiveFoldChart.lean", + "role": "production", + "source_sha256": "074921959ffdaa0aa8a7d377dca5b7678f5ed964e52a3ad027b051f4c7f9a073" + }, + { + "module": "SourceAdaptiveFoldEstimates", + "path": "SourceAdaptiveFoldEstimates.lean", + "role": "production", + "source_sha256": "980d8f238a085c6fc56bfffd0af278bcc248fb2f523c15662b603957b36c8a20" + }, + { + "module": "SourceActualFoldDeath", + "path": "SourceActualFoldDeath.lean", + "role": "production", + "source_sha256": "ee84ce7a775ae8163ec9309a0841757ce2990576adfd7186d4ad5bc8ac4de0d0" + }, + { + "module": "SourceActualFoldTorus", + "path": "SourceActualFoldTorus.lean", + "role": "production", + "source_sha256": "d2ca01d1f881852372c371215c30216bee7d917fdf2eaafbbd097f8c840e20c6" + }, + { + "module": "SourceActualFoldH0", + "path": "SourceActualFoldH0.lean", + "role": "production", + "source_sha256": "7d54c2cc08751365cc71949016fcbdd64872e5fbc4f67baea1fdd526a4e86cfd" + }, + { + "module": "SourceFoldWeightedProbability", + "path": "SourceFoldWeightedProbability.lean", + "role": "production", + "source_sha256": "58b77d6c0886fb5ef005749f468648d3c3ce6c99905f89963bf99c4ebee763d0" + }, + { + "module": "SourceGapPinCurvature", + "path": "SourceGapPinCurvature.lean", + "role": "production", + "source_sha256": "67f6c671e4ed8a7cb8557fc6027403f4fd1e94cba984e672eaa3ceb94ab8847e" + }, + { + "module": "SourceAllTargetCurvatureResidual", + "path": "SourceAllTargetCurvatureResidual.lean", + "role": "production", + "source_sha256": "4ae29bc3f2f206cca558df3f78853061cf4892499ac918e40253edd68d44371f" + }, + { + "module": "SourceGapWeightedNumerator", + "path": "SourceGapWeightedNumerator.lean", + "role": "production", + "source_sha256": "b2fedf3739884ff716d11c85ebcf5de328fc76bc2a5bed31e8ea72c61d2f87a3" + }, + { + "module": "SourceCompactGapNormalizer", + "path": "SourceCompactGapNormalizer.lean", + "role": "production", + "source_sha256": "d0f9319ac2ca792a9733659453583f4f71acc7ccccbcaba4ba1942566516065a" + }, + { + "module": "SourceCompactFoldWeightedProbability", + "path": "SourceCompactFoldWeightedProbability.lean", + "role": "production", + "source_sha256": "97e6c694b62d90f6b723b0e510691e019f763ff26ebba743664d596dc72223b9" + }, + { + "module": "SourceActualFoldCandidate", + "path": "SourceActualFoldCandidate.lean", + "role": "production", + "source_sha256": "a03d6cc83ec35971d8e67a0ccb3032681eed76ca056a075bbd3bbddff7727e0e" + }, + { + "module": "SourceFinitePinKernel", + "path": "SourceFinitePinKernel.lean", + "role": "production", + "source_sha256": "d45fbf6ca2d7a2c3e54a8edcd5d5c482497751ec1c3d820a1a198a204c8ce5d1" + }, + { + "module": "SourceFiniteTrig", + "path": "SourceFiniteTrig.lean", + "role": "production", + "source_sha256": "d0f0dea0b2f8296d129a3759271076848e35dd5a4b1ab2f5f0cee58837c72b14" + }, + { + "module": "SourceRemoteJetWitness", + "path": "SourceRemoteJetWitness.lean", + "role": "production", + "source_sha256": "c7dcc70330f0385bdd5c3aef105d54db0f9c0155824251f4fb61cac3640649cf" + }, + { + "module": "SourceRemoteJetGaussian", + "path": "SourceRemoteJetGaussian.lean", + "role": "production", + "source_sha256": "65694d00f575333b3b896338ecaf047ce8e166fbb8eddc03bd0836cce521a034" + }, + { + "module": "SourceEndpointHessianWitness", + "path": "SourceEndpointHessianWitness.lean", + "role": "production", + "source_sha256": "45f69d75cb4418b239f6402d0552da546bccc127e3102fac7da7d4c30324ae8f" + }, + { + "module": "SourceH0OlderClearance", + "path": "SourceH0OlderClearance.lean", + "role": "production", + "source_sha256": "6e42bb33d81e0a76fc0abb409b4f4811b7e91fe07d1398300e2e9792f29e794a" + }, + { + "module": "SourceEndpointHessianGaussian", + "path": "SourceEndpointHessianGaussian.lean", + "role": "production", + "source_sha256": "b9900b7553f7722241137f8f0cba08862b19ae415253a9a14bfd7c9b53c3e613" + }, + { + "module": "SourceTwoRemoteFirstJetWitness", + "path": "SourceTwoRemoteFirstJetWitness.lean", + "role": "production", + "source_sha256": "b523da924513fc312c5432c241fc031d4fbe3567fbeedbba981f36dd798574a4" + }, + { + "module": "SourceIntrinsicH0Interface", + "path": "SourceIntrinsicH0Interface.lean", + "role": "production", + "source_sha256": "a08a920ff0fac854c14a5040018b793e5cd99e1646f1bcec15c36fe27db071ef" + }, + { + "module": "SourceTwoRemoteFirstJetGaussian", + "path": "SourceTwoRemoteFirstJetGaussian.lean", + "role": "production", + "source_sha256": "4677ada085e7c53b4e9b4fd2160bcffc326e6a73b20cbb6cb7540ee3aece2a91" + }, + { + "module": "SourceIntrinsicH0WeightedProbability", + "path": "SourceIntrinsicH0WeightedProbability.lean", + "role": "production", + "source_sha256": "14eefa9f0572e215a9170c1b3206e67b60d1e6f3861f36c66ca6701cf19a4f46" + }, + { + "module": "SourceRawPinFreeCoordinates", + "path": "SourceRawPinFreeCoordinates.lean", + "role": "production", + "source_sha256": "82be00780c7070e999a47d397e4fe047535bd1d5b349efe82e252ccd5cd52cd4" + }, + { + "module": "SourceFramedConfluentCovariance", + "path": "SourceFramedConfluentCovariance.lean", + "role": "production", + "source_sha256": "0912fa1101b1ea17c9e2dd1d083fdd1cc50a3891585aaf0622b69f7415824b36" + }, + { + "module": "SourceGapConditionalMorseDistinct", + "path": "SourceGapConditionalMorseDistinct.lean", + "role": "production", + "source_sha256": "8baf597fa98ce8f79489e82227951e0f4fd1a960e65589278be8a82f35ce5213" + }, + { + "module": "SourceActualMorseLocalModel", + "path": "SourceActualMorseLocalModel.lean", + "role": "production", + "source_sha256": "d6776bd34a2ae1371c2af8fbfcc54d2a536e7c96b2e4db517a5f4a81b4128cd5" + }, + { + "module": "SourceActualTorusSuperlevelLocalBasis", + "path": "SourceActualTorusSuperlevelLocalBasis.lean", + "role": "production", + "source_sha256": "f52c247c1fb8956eebb166badf62de550566a0c2e4f56f5bda30bf5a5531d04c" + }, + { + "module": "SourceActualTorusRegularSlab", + "path": "SourceActualTorusRegularSlab.lean", + "role": "production", + "source_sha256": "14c900c4e81be9b9ffc85e56fe9c3f191ae8405670d15d0e151a766751b6a23b" + }, + { + "module": "SourceActualFiniteSuperlevelComponents", + "path": "SourceActualFiniteSuperlevelComponents.lean", + "role": "production", + "source_sha256": "e63abe693a6d23e5679adbb7110cb7b569bd3171db596d470f32b8566bc01a5c" + }, + { + "module": "SourceActualQuotientSaddleCollar", + "path": "SourceActualQuotientSaddleCollar.lean", + "role": "production", + "source_sha256": "e0e0a0f77bd75bbbd8994d620ee43b18b2edd50d7649cd8cb9837e7148762265" + }, + { + "module": "SourceActualSaddleUppercuts", + "path": "SourceActualSaddleUppercuts.lean", + "role": "production", + "source_sha256": "d292c767e789b98a6fbb56e5c21ec8867979faa832a97c1e79c79c899b777129" + }, + { + "module": "SourceActualRegularLocalCollar", + "path": "SourceActualRegularLocalCollar.lean", + "role": "production", + "source_sha256": "82823ac4360cbfb6eda057eb9fc212c870842703a14f5222454df70f19ed0d96" + }, + { + "module": "SourceActualLowerSeparation", + "path": "SourceActualLowerSeparation.lean", + "role": "production", + "source_sha256": "e72ed4f92e7867dc210b771e6afb4548cfad679e8b38795110fa6fd76a15e121" + }, + { + "module": "GaussianSeriesFoundation", + "path": "inputs/GaussianSeriesFoundation.lean", + "role": "input", + "source_sha256": "feea566d5aeba58459bd4a1f20f070bdcd80ee30712817324cdd594e3e232c95" + }, + { + "module": "SpectralWeights", + "path": "inputs/SpectralWeights.lean", + "role": "input", + "source_sha256": "92af14a2d83304de3f8576ee10b3d376587e93c4464f8c715b8d2e32360f44b0" + }, + { + "module": "SourceFourierSeries", + "path": "inputs/SourceFourierSeries.lean", + "role": "input", + "source_sha256": "5f145e8e8693bfe4d1554092c8258dbda4f17f8e078c503029e4e8ff2c018014" + }, + { + "module": "SourceC4", + "path": "inputs/SourceC4.lean", + "role": "input", + "source_sha256": "b15e53b825c2e2d6af2af18182da227d8794dddcc3e1b29611a913f89a889397" + }, + { + "module": "SourceGaussianLaw", + "path": "inputs/SourceGaussianLaw.lean", + "role": "input", + "source_sha256": "a60ab6099d3cef0eeecaefa9e35d95ec14ec54ffd6c89e42dfcf6170907166e8" + }, + { + "module": "SourceLattice", + "path": "inputs/SourceLattice.lean", + "role": "input", + "source_sha256": "c644305a426bc876f609c055ce999b8008f028c67a1091639d919f4122981b7b" + }, + { + "module": "SourceKernel", + "path": "inputs/SourceKernel.lean", + "role": "input", + "source_sha256": "5fa3abc8fb0db0c14c67b4ee840e659cdf80f7d22c9fd4cb5e6c1c7b204fbd21" + }, + { + "module": "SourceCovariance", + "path": "inputs/SourceCovariance.lean", + "role": "input", + "source_sha256": "30560009582659a100637b5510c657cf1fa762f68a37bae8fab42c1eeee6aee5" + }, + { + "module": "SourceTorus", + "path": "inputs/SourceTorus.lean", + "role": "input", + "source_sha256": "02857b44552ab0e51a756b3b095c4ba43f8168ac332b069acb5bc8146d337eef" + }, + { + "module": "SourceTorusC4", + "path": "inputs/SourceTorusC4.lean", + "role": "input", + "source_sha256": "b67b13030389dea4521e8e2afcac30ea44f84abd65c374bf208067b288fc64a1" + }, + { + "module": "SourceSmooth", + "path": "inputs/SourceSmooth.lean", + "role": "input", + "source_sha256": "12ad7263267a970bd5d5c95d7c7aa62d9c971f7beebf28f1aa7ed16d3a112f1b" + }, + { + "module": "SourceSmoothCarrier", + "path": "inputs/SourceSmoothCarrier.lean", + "role": "input", + "source_sha256": "5defdf223e85e7ccd23b5a903a1a306fe7f723727eb6aabf62eef523ef8639ed" + }, + { + "module": "ResearchFormalCoreR1.DeterminantMoment", + "path": "inputs/ResearchFormalCoreR1/DeterminantMoment.lean", + "role": "input", + "source_sha256": "661b73c3f21c6d2529f5e09ce426d89c01939ab27a5cc868db3802c7e66ea82d" + }, + { + "module": "ResearchFormalCoreR1.GaussianScalarMoments", + "path": "inputs/ResearchFormalCoreR1/GaussianScalarMoments.lean", + "role": "input", + "source_sha256": "71ce88ad2c97891858a5196f3293907bdffdd2341dfbace24204f2318c7510df" + }, + { + "module": "ResearchFormalCoreR1.GaussianJetMoments", + "path": "inputs/ResearchFormalCoreR1/GaussianJetMoments.lean", + "role": "input", + "source_sha256": "f2e785975aee6915848fe78dc3ecde02b8f13a0a1fb56ae3771e4c727c723360" + }, + { + "module": "ResearchFormalCoreR1.GaussianNormalizer", + "path": "inputs/ResearchFormalCoreR1/GaussianNormalizer.lean", + "role": "input", + "source_sha256": "32b7202cba2a9a0e0ed603d1a6db9ba2031714375b4e955614d5a40826a14aeb" + }, + { + "module": "ResearchFormalCoreR1.EndpointGaussianMoments", + "path": "inputs/ResearchFormalCoreR1/EndpointGaussianMoments.lean", + "role": "input", + "source_sha256": "c6351881326491ce30f1a266ea60e44c5adb8b3a1e5882c90575c67e459479d1" + }, + { + "module": "ResearchFormalCoreR1.NormalizerFloor", + "path": "inputs/ResearchFormalCoreR1/NormalizerFloor.lean", + "role": "input", + "source_sha256": "428eefd71b8c64fc4bcb208d9f73658058f29765f01a01c591f20a2d2359ec3e" + }, + { + "module": "ResearchFormalCoreR1.EndpointNormalizerBridge", + "path": "inputs/ResearchFormalCoreR1/EndpointNormalizerBridge.lean", + "role": "input", + "source_sha256": "36eab3b805fcba5160cb7e286dbd7f96940b0c6a85b464aad5fdad2f624ceb7e" + }, + { + "module": "ResearchFormalCoreR1.GaussianCoupling", + "path": "inputs/ResearchFormalCoreR1/GaussianCoupling.lean", + "role": "input", + "source_sha256": "426a53c139215650e961601c12f3cc1e09069520c5ebb96234a29483280551bb" + }, + { + "module": "ResearchFormalCoreR1.GaussianNormalizerLimit", + "path": "inputs/ResearchFormalCoreR1/GaussianNormalizerLimit.lean", + "role": "input", + "source_sha256": "12c98054b5bcf47f4619c624ef5e91c37f316d7c4848f560279d1f1e96fe0049" + }, + { + "module": "ResearchFormalCoreR1.PalmReweighting", + "path": "inputs/ResearchFormalCoreR1/PalmReweighting.lean", + "role": "input", + "source_sha256": "d34e422693f1d449bfcaf9c844c99c8fef4f19503312d3677ca525bd2d67c4d6" + }, + { + "module": "ResearchFormalCoreR1.GaussianRegressionKernel", + "path": "inputs/ResearchFormalCoreR1/GaussianRegressionKernel.lean", + "role": "input", + "source_sha256": "66d4fbee044a1a0c0b434bcd7614e220fad21d1ac275ce9b01070a66c5780460" + }, + { + "module": "Lifetime", + "path": "inputs/Lifetime.lean", + "role": "input", + "source_sha256": "371365f9bb17fbe1491c38bb00359300ea76641d3b5693d8feb11bb2c3fad51e" + }, + { + "module": "SourceLifetimeGeometry", + "path": "inputs/SourceLifetimeGeometry.lean", + "role": "input", + "source_sha256": "8ec4b18959055f20d849337e44a70d0c5b39b7959b54cb4d7b6c2a473ee0612d" + }, + { + "module": "SuperlevelBar", + "path": "inputs/elder/SuperlevelBar.lean", + "role": "input", + "source_sha256": "f328d66d7240469f080c8bbf83f7259677fee21593465977e23a95685667ebd9" + }, + { + "module": "ElderClearance", + "path": "inputs/elder/ElderClearance.lean", + "role": "input", + "source_sha256": "d3d78472881059546402218cc77792eeef00755c222bb02499d69abd3b5cd57e" + }, + { + "module": "ReusedCompactFrontier", + "path": "inputs/elder/ReusedCompactFrontier.lean", + "role": "input", + "source_sha256": "29d77453ef7c3cd216521a8ac84639aa30daf5a1d4061785a826b2c2d42d23db" + }, + { + "module": "ClosedSuperlevel", + "path": "inputs/elder/ClosedSuperlevel.lean", + "role": "input", + "source_sha256": "51cb46da0f1aae823fd91ec5e93c6edcd694d72f0a40d7a83686fee66c8ffffa" + }, + { + "module": "OrdinaryH0", + "path": "inputs/elder/OrdinaryH0.lean", + "role": "input", + "source_sha256": "3e91484d8b8499bee94c652a13dbab957712a180d4644e5ea5915082a79836f5" + }, + { + "module": "ElderInterval", + "path": "inputs/elder/ElderInterval.lean", + "role": "input", + "source_sha256": "69daa2e2a6afbdedde20d0c3b1ecdb52e2626da8ad49138b9db388b41ee71491" + }, + { + "module": "ElderBridge", + "path": "inputs/elder/ElderBridge.lean", + "role": "input", + "source_sha256": "6b0be1116f6b357b0ffbda202c572c27c2788b98bee639e228375a5ebeea1fa9" + } + ], + "targets": [ + "I4SourceDerivativeGaussian.derivativeCoefficient_summable", + "I4SourceDerivativeGaussian.smoothSourceField_derivative_series", + "I4SourceDerivativeGaussian.scalarSeries_finiteVector_hasGaussianLaw", + "I4SourceDerivativeGaussian.smoothSourceField_derivativeVector_hasGaussianLaw", + "I4SourceDerivativeGaussian.smoothSourceField_derivative_covariance", + "I4ContactGram.contactWitness_transpose_mulVec_eq_zero", + "I4ContactGram.contactWitness_transpose_injective", + "I4ContactGram.contactWitness_amplitude_transpose_injective", + "I4ContactGram.coefficient_product_summable", + "I4ContactGram.coefficientGram_quadratic_hasSum", + "I4ContactGram.coefficientGram_posDef_of_separating", + "I4ContactGram.contact_coefficientGram_posDef", + "I4ContactGram.contact_schur_pos", + "I4SourceContact.sourceContactVector_hasGaussianLaw", + "I4SourceContact.sourceContactCoefficient_summable", + "I4SourceContact.sourceContactCovariance_eq_coefficientGram", + "I4SourceContact.sourceContactMode_nonzero_frequency", + "I4SourceContact.sourceContactAmplitude_pos", + "I4SourceContact.sourceContact_selected_columns", + "I4SourceContact.sourceContactCovariance_posDef", + "I4SourceConfluentPins.rawTransform_confluentTransform", + "I4SourceConfluentPins.confluentTransform_rawTransform", + "I4SourceConfluentPins.confluentEquiv_apply", + "I4SourceConfluentPins.confluentEquiv_symm_apply", + "I4SourceConfluentPins.prescribed_target", + "I4SourceConfluentPins.rawPins_hasGaussianLaw", + "I4SourceConfluentPins.confluentPins_hasGaussianLaw", + "I4SourceConfluentPins.rawPinsWithHessians_hasGaussianLaw", + "I4SourceContact.sourceContactBlockEquiv_inl", + "I4SourceContact.sourceContactBlockEquiv_inr", + "I4SourceContact.sourceContactCovariance_block_identity", + "I4SourceContact.sourcePinCovariance_posDef", + "I4SourceContact.sourcePinCovariance_isUnit", + "I4SourceContact.sourceContactQVariance_eq_variance", + "I4SourceContact.sourceContactSchur_pos", + "I4SourceContact.contact_residual_variance_of_isUnit_covariance", + "I4SourceContact.sourceContactResidual_variance", + "I4SourceContact.sourceContactResidual_variance_pos", + "I4SourceDerivativeContinuity.derivativeMajorant_nonneg", + "I4SourceDerivativeContinuity.derivativeMajorant_summable", + "I4SourceDerivativeContinuity.derivativeCoefficient_bound", + "I4SourceDerivativeContinuity.derivativeCoefficient_continuous", + "I4SourceDerivativeContinuity.smoothSourceField_derivative_covariance_continuous", + "I4SourceDerivativeContinuity.smoothSourceField_derivative_integral_zero", + "I4ConfluentIntegralIdentities.pin3_integral", + "I4ConfluentIntegralIdentities.pin4_integral", + "I4ConfluentIntegralIdentities.pin5_integral", + "I4ConfluentIntegralIdentities.adjusted_second_left", + "I4ConfluentIntegralIdentities.adjusted_second_right", + "I4ConfluentIntegralIdentities.adjusted_transverse_left", + "I4ConfluentIntegralIdentities.adjusted_transverse_right", + "I4SourceEndpointRegression.sourceConfluentPinsAt_eq", + "I4SourceEndpointRegression.endpointObservationMap_actual", + "I4SourceEndpointRegression.sourcePins_adjusted_hasGaussianLaw", + "I4SourceEndpointRegression.sourceRegressionMapAt_apply", + "I4SourceEndpointRegression.sourceRegressionMapAt_single", + "I4SourceEndpointRegression.sourceRegression_normal_equations", + "I4SourceEndpointRegression.sourceEndpointKernel_markov", + "I4SourceEndpointRegression.sourceEndpointKernel_measurable", + "I4SourceEndpointRegression.sourceEndpointKernel_apply", + "I4SourceEndpointRegression.sourceEndpointKernel_hasCondDistrib", + "I4SourceEndpointRegression.sourceEndpointKernel_spec", + "I4SourceEndpointRegression.sourceAdjustedEndpoints_on_pin_fiber", + "I4SourceEndpointRegression.sourceAdjustedEndpoints_on_prescribed", + "I4GaussianRegressionLimits.regression_parameter_limits", + "I4GaussianRegressionLimits.regression_uniform_bounds", + "I4SourceEndpointParameters.smoothSourceField_derivative_integral_zero", + "I4SourceEndpointParameters.rawPinsWithHessians_integral_zero", + "I4SourceEndpointParameters.rawPinsWithHessians_integral_vector_zero", + "I4SourceEndpointParameters.sourcePins_adjusted_integral_zero", + "I4SourceEndpointParameters.sourceConfluentPinsAt_integral_zero", + "I4SourceEndpointParameters.sourceAdjustedEndpoints_integral_zero", + "I4SourceEndpointParameters.sourceEndpointResidual_integral_zero", + "I4SourceEndpointParameters.sourceEndpointResidual_covariance", + "I4SourceEndpointParameters.finiteGaussian_law_parameters", + "I4SourceEndpointParameters.sourceEndpointResidual_hasGaussianLaw", + "I4SourceEndpointParameters.sourceEndpointPosterior_hasGaussianLaw", + "I4SourceEndpointParameters.sourceEndpointPosterior_integral", + "I4SourceEndpointParameters.sourceEndpointPosterior_covariance", + "I4SourceEndpointParameters.sourceEndpointKernel_eq_map_posterior", + "I4SourceEndpointParameters.sourceEndpointKernel_isGaussian", + "I4SourceEndpointParameters.sourceEndpointSchurAt_posSemidef", + "I4SourceEndpointParameters.sourceEndpointKernel_eq_multivariateGaussian", + "I4SourceEndpointParameters.sourceEndpointKernel_integral", + "I4SourceEndpointParameters.sourceEndpointKernel_covariance", + "I4SourceContact.sourceContactEndpointMean_contact", + "I4SourceContact.sourceContactEndpointSchur_covariance", + "I4SourceContact.sourceContactEndpointSchur_posSemidef", + "I4SourceContact.sourceContactEndpointSchur_contact", + "I4SourceContact.sourceContactEndpointSchur_four_four_eq_schur", + "I4SourceContact.sourceContactEndpointSchur_referenceVariance_pos", + "I4SourceConfluentLimits.rawPinsWithHessians_series", + "I4SourceConfluentLimits.pinCoefficient_summable", + "I4SourceConfluentLimits.adjustedCoefficient_summable", + "I4SourceConfluentLimits.sourceConfluentPinsAt_series", + "I4SourceConfluentLimits.sourceAdjustedEndpoints_series", + "I4SourceConfluentLimits.sourcePinCovarianceAt_coefficient", + "I4SourceConfluentLimits.sourceCrossCovarianceAt_coefficient", + "I4SourceConfluentLimits.sourceEndpointCovarianceAt_coefficient", + "I4ModeCurveChains.mode_smooth", + "I4ModeCurveChains.axis_iteratedDeriv", + "I4ModeCurveChains.axis_transverse_smooth", + "I4ModeCurveChains.axis_transverse_iteratedDeriv", + "I4ModeCurveChains.modeH_eq", + "I4ModeCurveChains.modeF_C3", + "I4ModeCurveChains.modeH_C2", + "I4ModeCurveChains.modeF_deriv", + "I4ModeCurveChains.modeF_second", + "I4ModeCurveChains.modeF_third", + "I4ModeCurveChains.modeH_deriv", + "I4ModeCurveChains.modeH_second", + "I4SourceConfluentLimits.rawDerivativeCoefficient_explicit", + "I4SourceConfluentLimits.pinCoefficient_explicit", + "I4SourceConfluentLimits.adjustedCoefficient_explicit", + "I4WeightedModeIntegrals.weighted_integrand_bound", + "I4WeightedModeIntegrals.weightedDerivativeIntegral_continuous", + "I4WeightedModeIntegrals.weightedDerivativeIntegral_norm_le", + "I4WeightedModeIntegrals.weightedDerivativeIntegral_zero", + "I4SourceConfluentLimits.peano_kernel_masses", + "I4SourceConfluentLimits.pinCoefficient_eq_regularized", + "I4SourceConfluentLimits.adjustedCoefficient_eq_regularized", + "I4ContactCoefficientLimits.contactPinCoefficient_summable", + "I4ContactCoefficientLimits.contactAdjustedCoefficient_summable", + "I4ContactCoefficientLimits.sourcePinVector_eq_contactSeries", + "I4ContactCoefficientLimits.sourceContactEndpointVector_eq_contactSeries", + "I4ContactCoefficientLimits.sourcePinCovariance_eq_contactCoefficientGram", + "I4ContactCoefficientLimits.sourceContactEndpointCrossCovariance_eq_contactCoefficientGram", + "I4ContactCoefficientLimits.sourceContactEndpointCovariance_eq_contactCoefficientGram", + "I4SourceConfluentLimits.confluentModeMajorant_nonneg", + "I4SourceConfluentLimits.confluentModeMajorant_summable", + "I4SourceConfluentLimits.regularizedPinCoefficient_bound", + "I4SourceConfluentLimits.regularizedAdjustedCoefficient_bound", + "I4SourceConfluentLimits.regularizedPinCoefficient_continuous", + "I4SourceConfluentLimits.regularizedAdjustedCoefficient_continuous", + "I4SourceConfluentLimits.regularizedPinCoefficient_zero", + "I4SourceConfluentLimits.regularizedAdjustedCoefficient_zero", + "I4SourceConfluentLimits.regularizedPinCovariance_continuous", + "I4SourceConfluentLimits.regularizedCrossCovariance_continuous", + "I4SourceConfluentLimits.regularizedEndpointCovariance_continuous", + "I4SourceConfluentLimits.sourcePinCovarianceAt_eq_regularized", + "I4SourceConfluentLimits.sourceCrossCovarianceAt_eq_regularized", + "I4SourceConfluentLimits.sourceEndpointCovarianceAt_eq_regularized", + "I4SourceConfluentLimits.regularizedPinCovariance_zero", + "I4SourceConfluentLimits.regularizedCrossCovariance_zero", + "I4SourceConfluentLimits.regularizedEndpointCovariance_zero", + "I4SourceConfluentLimits.sourcePinCovarianceAt_tendsto", + "I4SourceConfluentLimits.sourceCrossCovarianceAt_tendsto", + "I4SourceConfluentLimits.sourceEndpointCovarianceAt_tendsto", + "I4SourcePhysicalEndpointKernel.sourceNormalizedEndpoints_eq_adjusted", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_markov", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_measurable", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_apply", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_hasCondDistrib", + "I4SourcePhysicalEndpointKernel.sourcePhysicalCorrection_prescribed", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_at_prescribed", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_integral", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_spec", + "I4SourceEndpointEstimates.sourcePhysicalCoordinates_apply", + "I4SourceEndpointEstimates.sourcePhysicalCoordinates_continuous", + "I4SourceEndpointEstimates.sourcePhysicalCoordinates_inverse", + "I4SourceEndpointEstimates.sourceEndpointWeight_measurable", + "I4SourceEndpointEstimates.sourceEndpointWeight_nonneg", + "I4SourceEndpointEstimates.sourceEndpointWeight_eq_continuous", + "I4SourceEndpointEstimates.sourceEndpointLaw_isProbabilityMeasure", + "I4SourceEndpointEstimates.sourceEndpointLaw_euclidean_hasLaw", + "I4SourceEndpointEstimates.sourceEndpointLaw_physical_marginal", + "I4SourceEndpointEstimates.sourceEndpointLaw_weight_integral", + "I4SourceEndpointEstimates.sourceEndpointLaw_second_moment_of_parameter_bounds", + "I4SourceEndpointEstimates.sourceEndpointLaw_weight_square_integrable", + "I4SourceEndpointEstimates.sourceEndpointLaw_weight_integrable", + "I4SourceEndpointEstimates.sourcePrescribedPins_tendsto", + "I4SourceEndpointEstimates.sourceEndpoint_weighted_event_bound_of_estimates", + "I4SourceEndpointEstimates.sourceEndpoint_parameter_limits", + "I4SourceEndpointEstimates.sourceEndpoint_uniform_parameter_bounds", + "I4SourceEndpointEstimates.sourceEndpoint_normalizer_floor", + "I4SourceEndpointEstimates.sourceEndpoint_estimates", + "I4SourceEndpointEstimates.sourceEndpoint_estimates_and_weighted_events", + "I4SourceEndpointEstimates.sourcePhysicalEndpointLaw_eq", + "I4SourceEndpointEstimates.sourcePhysicalEndpointLaw_isProbabilityMeasure", + "I4SourceEndpointEstimates.sourcePhysicalEndpointKernel_eventually_hasCondDistrib", + "I4SourceEndpointEstimates.sourcePhysicalEndpointWeightedProbability_eq", + "I4SourceEndpointEstimates.sourcePhysicalEndpoint_estimates_and_weighted_events", + "I4SourceSmoothConditional.exists_measurable_sampleProjection", + "I4SourceSmoothConditional.goodSample_add", + "I4SourceSmoothConditional.goodSample_neg", + "I4SourceSmoothConditional.derivativeCoefficient_weighted_summable", + "I4SourceSmoothConditional.finiteCoefficient_weighted_summable", + "I4SourceSmoothConditional.pinCoefficient_weighted_summable", + "I4SourceSmoothConditional.adjustedCoefficient_weighted_summable", + "I4SourceSmoothConditional.sourceConfluentPinsAt_measurable", + "I4SourceSmoothConditional.sourceAdjustedEndpoints_measurable", + "I4SourceSmoothConditional.pinLift_zero", + "I4SourceSmoothConditional.pinLift_add", + "I4SourceSmoothConditional.pinLift_neg", + "I4SourceSmoothConditional.pinLift_goodSample", + "I4SourceSmoothConditional.pinLift_measurable", + "I4SourceSmoothConditional.addLift_val", + "I4SourceSmoothConditional.addLift_measurable", + "I4SourceSmoothConditional.posteriorSample_val", + "I4SourceSmoothConditional.posteriorSample_measurable", + "I4SourceSmoothConditional.scalarSeries_add_finiteShift", + "I4SourceSmoothConditional.sourceConfluentPinsAt_addLift", + "I4SourceSmoothConditional.sourceAdjustedEndpoints_addLift", + "I4SourceSmoothConditional.sourceConfluentPinsAt_posteriorSample", + "I4SourceSmoothConditional.sourceAdjustedEndpoints_posteriorSample", + "I4SourceSmoothConditional.sourceSmoothKernel_isMarkov", + "I4SourceSmoothConditional.sourceSmoothKernel_measurable", + "I4SourceSmoothConditional.sourceSmoothKernel_apply", + "I4SourceSmoothConditional.sourceSmoothKernel_pin_map", + "I4SourceSmoothConditional.sourceSmoothKernel_pin_fiber", + "I4SourceSmoothConditional.sourceSmoothKernel_endpoint_map", + "I4SourceSmoothConditional.scalarSeries_finite_hasGaussianLaw", + "I4SourceSmoothConditional.scalarSeries_single", + "I4SourceSmoothConditional.scalarSeries_coordinate_covariance", + "I4SourceSmoothConditional.pin_coefficient_covariance", + "I4SourceSmoothConditional.pin_finite_coefficients_hasGaussianLaw", + "I4SourceSmoothConditional.finiteLift_apply", + "I4SourceSmoothConditional.pin_residual_finite_hasGaussianLaw", + "I4SourceSmoothConditional.coefficient_hasGaussianLaw", + "I4SourceSmoothConditional.residualCoefficient_zero_covariance", + "I4SourceSmoothConditional.residualCoefficient_finite_indepFun", + "I4SourceSmoothConditional.residualCoefficient_indepFun", + "I4SourceSmoothConditional.sourceNormalizedEndpoints_measurable", + "I4SourceSmoothConditional.sourceSmoothKernel_physical_endpoint_map", + "I4SourceSmoothConditional.sourceSmoothKernel_physical_prescribed_map", + "I4SourceSmoothConditional.posteriorSample_self", + "I4SourceSmoothConditional.posteriorSample_eq_addLift_residual", + "I4SourceSmoothConditional.addLift_observation_residual", + "I4SourceSmoothConditional.posteriorSample_zero_inclusion", + "I4SourceSmoothConditional.posteriorSample_zero_indepFun", + "I4SourceSmoothConditional.sourceSmoothKernel_hasCondDistrib", + "I4SourceSmoothConditional.sourceSmoothKernel_map_hasCondDistrib", + "I4SourceSmoothConditional.smoothSourceField_measurable", + "I4SourceSmoothConditional.sourceSmoothKernel_field_hasCondDistrib", + "I4SourceSmoothConditional.sourceSmoothKernel_eventually_hasCondDistrib", + "I4SourceSmoothConditional.sourceSmoothKernel_eventually_map_hasCondDistrib", + "I4SourceSmoothPalm.withDensity_map_comp", + "I4SourceSmoothPalm.prwMeasure_map_comp", + "I4SourceSmoothPalm.prwMeasure_absolutelyContinuous", + "I4SourceSmoothPalm.prwMeasure_ae_of_ae", + "I4SourceSmoothPalm.prwMeasure_ae_weight_pos", + "I4SourceSmoothPalm.sourceSmoothLaw_isProbabilityMeasure", + "I4SourceSmoothPalm.rawPins_prescribed_iff", + "I4SourceSmoothPalm.sourceSmoothLaw_raw_pin_fiber", + "I4SourceSmoothPalm.sourceRawPins_measurable", + "I4SourceSmoothPalm.sourceSmoothLaw_raw_pin_fiber_ae", + "I4SourceSmoothPalm.raw_pin_fiber_of_absolutelyContinuous", + "I4SourceSmoothPalm.prwMeasure_raw_pin_fiber", + "I4SourceSmoothPalm.sourceRawHM_eq_normalized", + "I4SourceSmoothPalm.sourceRawHS_eq_normalized", + "I4SourceSmoothPalm.sourceSmoothWeight_eq", + "I4SourceSmoothPalm.sourceSmoothWeight_nonneg", + "I4SourceSmoothPalm.sourceSmoothWeight_measurable", + "I4SourceSmoothPalm.sourceSmoothWeight_pos_iff", + "I4SourceSmoothPalm.sourceSmoothTyped_measurableSet", + "I4SourceSmoothPalm.sourceSmoothLaw_endpoint_hasLaw", + "I4SourceSmoothPalm.sourceSmoothLaw_weight_square_integrable", + "I4SourceSmoothPalm.sourceSmoothLaw_weight_integral", + "I4SourceSmoothPalm.sourceSmoothLaw_weight_square_integral", + "I4SourceSmoothPalm.sourceSmoothWeightedLaw_endpoint_map", + "I4SourceSmoothPalm.sourceSmooth_weighted_event_bound_of_estimates", + "I4SourceSmoothPalm.sourceSmoothWeightedLaw_typed", + "I4SourceSmoothPalm.sourceSmoothWeightedLaw_raw_pins", + "I4SourceSmoothPalm.sourceSmoothPalm_estimates", + "I4GaussianMajorant.standardAbsMoment_integrable", + "I4GaussianMajorant.weightedAbsSeries_nonneg", + "I4GaussianMajorant.weightedAbsSeries_measurable", + "I4GaussianMajorant.weightedAbsSeries_memLp_bound", + "I4GaussianMajorant.weightedAbsSeries_ae_summable", + "I4GaussianMajorant.weightedAbsSeries_moment", + "I4GaussianMajorant.weightedAbsSeries_exp_bound", + "I4GaussianMajorant.weightedAbsSeries_upper_tail", + "I4SourceConditionalMajorant.sampleMajorant_nonneg", + "I4SourceConditionalMajorant.derivativeMajorant_weighted_summable", + "I4SourceConditionalMajorant.confluentMajorant_weighted_summable", + "I4SourceConditionalMajorant.pinCoefficient_abs_le", + "I4SourceConditionalMajorant.sourceConfluentPins_abs_le", + "I4SourceConditionalMajorant.pinLift_abs_le", + "I4SourceConditionalMajorant.posterior_sampleMajorant_le", + "I4SourceConditionalMajorant.sourceInverse_prescribed_uniform_bounds", + "I4SourceConditionalMajorant.smoothSourceField_global_derivative_bound", + "I4SourceConditionalMajorant.sampleMajorant_measurable", + "I4SourceConditionalMajorant.sourceDerivativeMajorant_measurable", + "I4SourceConditionalMajorant.sampleMajorant_add", + "I4SourceConditionalMajorant.sampleMajorant_const_mul", + "I4SourceConditionalMajorant.sourceDerivativeMajorant_uniform_domination", + "I4SourceConditionalMajorant.source_coordinate_hasLaw", + "I4SourceConditionalMajorant.sampleMajorant_prior_moment", + "I4SourceConditionalMajorant.sourceConditionalDerivative_moments", + "I4SourceConditionalMajorant.sourceConditionalDerivative_cutoff_tail", + "I4SourceConditionalMajorant.sourceConditionalDerivative_gaussian_upper_tail", + "I4SourceConditionalMajorant.sourceWeightedDerivative_cutoff_tail", + "I4PeanoErrorBounds.abs_weighted_integral_le", + "I4PeanoErrorBounds.abs_weighted_integral_sub_mass_le", + "I4PeanoErrorBounds.peanoCubic_nonneg", + "I4PeanoErrorBounds.scaled_lipschitz_center_error", + "I4PeanoErrorBounds.cubic_pin_pointwise_error", + "I4PeanoErrorBounds.left_weighted_error", + "I4PeanoErrorBounds.right_weighted_error", + "I4SourcePinCurvatureBounds.sourceQ_eq_sourceContactQ", + "I4SourcePinCurvatureBounds.sourceA_eq_sourceContactA", + "I4SourcePinCurvatureBounds.sourceDerivativeMajorant_nonneg", + "I4SourcePinCurvatureBounds.sourceGammaRadius_measurable", + "I4SourcePinCurvatureBounds.one_le_sourceGammaRadius", + "I4SourcePinCurvatureBounds.sourceGammaRadius_nonneg", + "I4SourcePinCurvatureBounds.sourceDerivativeMajorant_le_radius", + "I4SourcePinCurvatureBounds.orderModeBound_mono", + "I4SourcePinCurvatureBounds.sourceDerivativeMajorant_mono", + "I4SourcePinCurvatureBounds.sourceGammaRadius_le_fifth", + "I4SourcePinCurvatureBounds.sourceGammaRadius_moments", + "I4SourcePinCurvatureBounds.directionX_norm_le_one", + "I4SourcePinCurvatureBounds.directionY_norm_le_one", + "I4SourcePinCurvatureBounds.axis_point_sub_norm_le", + "I4SourcePinCurvatureBounds.axis_derivative_lipschitz", + "I4SourcePinCurvatureBounds.source_axis_derivative_abs_le", + "I4SourcePinCurvatureBounds.sourceF_third_continuous", + "I4SourcePinCurvatureBounds.sourceH_second_continuous", + "I4SourcePinCurvatureBounds.sourceF_third_lipschitz", + "I4SourcePinCurvatureBounds.sourceH_second_lipschitz", + "I4SourcePinCurvatureBounds.sourceQCurve_lipschitz", + "I4SourcePinCurvatureBounds.sourceF_third_abs_le", + "I4SourcePinCurvatureBounds.sourceH_second_abs_le", + "I4SourcePinCurvatureBounds.sourceQCurve_abs_le", + "I4SourcePinCurvatureBounds.sourceF_C3", + "I4SourcePinCurvatureBounds.sourceH_C2", + "I4SourcePinCurvatureBounds.sourceF_deriv", + "I4SourcePinCurvatureBounds.sourceF_second", + "I4SourcePinCurvatureBounds.sourceH_deriv", + "I4SourcePinCurvatureBounds.sourceH_second_zero", + "I4SourcePinCurvatureBounds.source_pin3_eq", + "I4SourcePinCurvatureBounds.source_pin4_eq", + "I4SourcePinCurvatureBounds.source_pin5_eq", + "I4SourcePinCurvatureBounds.source_normalized_peano", + "I4SourcePinCurvatureBounds.endpoint_det_abs_le", + "I4SourcePinCurvatureBounds.endpointWeight_curvature_le", + "I4SourcePinCurvatureBounds.strict_endpoint_transverse_neg", + "I4SourcePinCurvatureBounds.curvature_slab_of_upper", + "I4SourcePinCurvatureBounds.sourceQCurve_zero", + "I4SourcePinCurvatureBounds.sourceQ_abs_le", + "I4SourcePinCurvatureBounds.sourceA_abs_le", + "I4SourcePinCurvatureBounds.source_normalized_endpoint_errors", + "I4SourcePinCurvatureBounds.sourceGammaRadius_ge_third_fourth", + "I4SourcePinCurvatureBounds.source_normalized_endpoint_first_four_bounds", + "I4SourcePinCurvatureBounds.sourceQ_measurable", + "I4SourcePinCurvatureBounds.sourceA_measurable", + "I4SourcePinCurvatureBounds.source_normalized_determinant_bounds", + "I4SourcePinCurvatureBounds.sourceSmoothWeight_curvature_bound", + "I4SourcePinCurvatureBounds.source_positive_weight_curvature_upper", + "I4SourcePinCurvatureBounds.source_bad_curvature_slab", + "I4SourcePinCurvatureBounds.source_prescribed_pin_constraints_ae", + "I4SourcePinCurvatureBounds.sourceSmoothLaw_curvature_bound_ae", + "I4SourcePinCurvatureBounds.source_curvature_estimates", + "I4SourcePinCurvatureBounds.source_normalized_endpoint_errors_all", + "I4SourcePinCurvatureBounds.sourceSmoothLaw_endpoint_errors_ae", + "I4SourcePinCurvatureBounds.source_endpoint_error_estimates", + "I4ScalarProductCurvature.regular_bounds", + "I4ScalarProductCurvature.scalar_product_tube_integral_bound", + "I4ScalarProductCurvature.scalar_product_regular_integral_bound", + "I4SourceCurvatureDecomposition.curvatureCoefficient_summable", + "I4SourceCurvatureDecomposition.sourceContactQ_series", + "I4SourceCurvatureDecomposition.curvatureCoefficient_weighted_summable", + "I4SourceCurvatureDecomposition.curvatureCross_coefficient", + "I4SourceCurvatureDecomposition.curvatureVariance_prior_coefficient", + "I4SourceCurvatureDecomposition.curvatureResidualCoefficient_summable", + "I4SourceCurvatureDecomposition.curvatureDirection_summable", + "I4SourceCurvatureDecomposition.curvatureBeta_normal", + "I4SourceCurvatureDecomposition.curvatureResidual_pin_orthogonal", + "I4SourceCurvatureDecomposition.curvatureResidual_q_pairing", + "I4SourceCurvatureDecomposition.curvatureResidual_normSquared", + "I4SourceCurvatureDecomposition.curvatureDirection_pin_orthogonal", + "I4SourceCurvatureDecomposition.curvatureSigma_pos", + "I4SourceCurvatureDecomposition.curvatureSigma_sq", + "I4SourceCurvatureDecomposition.curvatureDirection_normSquared", + "I4SourceCurvatureDecomposition.curvatureDirection_q_pairing", + "I4SourceCurvatureDecomposition.curvatureResidualCoefficient_weighted_summable", + "I4SourceCurvatureDecomposition.curvatureDirection_weighted_summable", + "I4SourceCurvatureDecomposition.curvatureZ_eq", + "I4SourceCurvatureDecomposition.unitDirection_measurable", + "I4SourceCurvatureDecomposition.unitDirection_hasLaw", + "I4SourceCurvatureDecomposition.unitDirection_coefficient_covariance", + "I4SourceCurvatureDecomposition.unitDirectionCoefficientResidual_zero_covariance", + "I4SourceCurvatureDecomposition.unitDirection_finiteCoefficients_hasGaussianLaw", + "I4SourceCurvatureDecomposition.finiteDirectionLift_apply", + "I4SourceCurvatureDecomposition.unitDirection_finiteResidual_hasGaussianLaw", + "I4SourceCurvatureDecomposition.unitDirection_scalar_finiteResidual_hasGaussianLaw", + "I4SourceCurvatureDecomposition.unitDirectionCoefficientResidual_finite_indepFun", + "I4SourceCurvatureDecomposition.unitDirectionCoefficientResidual_indepFun", + "I4SourceCurvatureDecomposition.regularizedCurvatureCross_continuous", + "I4SourceCurvatureDecomposition.regularizedCurvatureCross_zero", + "I4SourceCurvatureDecomposition.curvatureCross_tendsto", + "I4SourceCurvatureDecomposition.curvaturePinInverse_tendsto", + "I4SourceCurvatureDecomposition.curvatureBeta_tendsto", + "I4SourceCurvatureDecomposition.curvatureVariance_tendsto", + "I4SourceCurvatureDecomposition.curvatureMean_prescribed_tendsto", + "I4SourceCurvatureDecomposition.curvature_uniform_parameter_bounds", + "I4SourceCurvatureDecomposition.curvatureZ_measurable", + "I4SourceCurvatureDecomposition.sourceContactQ_measurable", + "I4SourceCurvatureDecomposition.curvatureZ_hasLaw", + "I4SourceCurvatureDecomposition.curvatureDirection_goodSample", + "I4SourceCurvatureDecomposition.curvatureShift_val", + "I4SourceCurvatureDecomposition.curvatureShift_measurable", + "I4SourceCurvatureDecomposition.curvatureResidualSample_measurable", + "I4SourceCurvatureDecomposition.curvatureResidualLaw_isProbabilityMeasure", + "I4SourceCurvatureDecomposition.sourceConfluentPinsAt_curvatureShift", + "I4SourceCurvatureDecomposition.sourceContactQ_curvatureShift", + "I4SourceCurvatureDecomposition.curvatureZ_curvatureShift", + "I4SourceCurvatureDecomposition.curvatureResidualSample_pins", + "I4SourceCurvatureDecomposition.curvatureResidualSample_Z", + "I4SourceCurvatureDecomposition.curvatureResidualSample_inclusion", + "I4SourceCurvatureDecomposition.curvatureResidualSample_indepFun", + "I4SourceCurvatureDecomposition.curvatureResidualSample_joint_map", + "I4SourceCurvatureDecomposition.sourceContactQ_posteriorSample", + "I4SourceCurvatureDecomposition.sourceContactQ_posteriorSample_Z", + "I4SourceCurvatureDecomposition.sourceContactQ_posteriorResidual", + "I4SourceCurvatureDecomposition.curvaturePosterior_reconstruction", + "I4SourceCurvatureDecomposition.curvatureReconstruct_measurable", + "I4SourceCurvatureDecomposition.curvatureReconstruct_pins", + "I4SourceCurvatureDecomposition.curvatureReconstruct_Q", + "I4SourceCurvatureDecomposition.curvatureReconstruct_residual_image", + "I4SourceCurvatureDecomposition.curvatureDirectionEnvelope_nonneg", + "I4SourceCurvatureDecomposition.curvatureDirectionEnvelope_summable", + "I4SourceCurvatureDecomposition.curvatureDirectionEnvelope_weighted_summable", + "I4SourceCurvatureDecomposition.curvatureDirection_envelope_at", + "I4SourceCurvatureDecomposition.curvatureDirection_uniform_envelope", + "I4SourceCurvatureDecomposition.curvatureAffine_gaussian", + "I4SourceCurvatureDecomposition.curvatureResidual_curvature_joint_map", + "I4SourceCurvatureDecomposition.sourceSmoothKernel_eq_curvatureProduct", + "I4SourceCurvatureDecomposition.sourceSmoothKernel_eq_curvatureProduct_swap", + "I4GaussianVarianceFloor.gaussianPDFReal_le_of_variance_floor", + "I4GaussianVarianceFloor.gaussianReal_interval_mass_le_of_variance_floor", + "I4SourceCurvatureDecomposition.curvatureScalarLaw_isProbabilityMeasure", + "I4SourceCurvatureDecomposition.curvatureReconstruct_swap_measurable", + "I4SourceCurvatureDecomposition.curvatureReconstruct_hasLaw", + "I4SourceCurvatureDecomposition.curvatureScalarLaw_interval_mass_uniform", + "I4SourceCurvatureDecomposition.sourceSmoothKernel_eventually_curvatureProduct", + "I4SourceCurvatureDecomposition.curvatureResidualRadius_measurable", + "I4SourceCurvatureDecomposition.one_le_curvatureResidualRadius", + "I4SourceCurvatureDecomposition.sourceContactQ_posterior_abs_le_radius", + "I4SourceCurvatureDecomposition.curvatureEnvelopeTotal_nonneg", + "I4SourceCurvatureDecomposition.sourceDerivativeMajorant_curvatureShift", + "I4SourceCurvatureDecomposition.sourceGammaRadius_curvatureShift", + "I4SourceCurvatureDecomposition.sourceDerivativeMajorant_curvatureReconstruct", + "I4SourceCurvatureDecomposition.sourceGammaRadius_curvatureReconstruct", + "I4SourceCurvatureDecomposition.curvaturePosterior_residual_eq_shift", + "I4SourceCurvatureDecomposition.curvatureResidualRadius_image_bound", + "I4SourceCurvatureDecomposition.curvatureResidualRadius_moment_bound", + "I4SourceCurvatureDecomposition.curvatureResidualRadius_uniform_bounds", + "I4SourceCurvatureDecomposition.curvatureReconstruct_joint_measurable", + "I4SourceCurvatureDecomposition.curvaturePin_finiteCoefficients_hasGaussianLaw", + "I4SourceWeightedCurvature.sourceRegularityBad_measurable", + "I4SourceWeightedCurvature.sourceRegularityBad_base_bound", + "I4SourceWeightedCurvature.sourceRegularityBad_weighted_cubic", + "I4SourceWeightedCurvature.sourceQ_measurable_actual", + "I4SourceWeightedCurvature.sourceCurvatureSlab_measurable", + "I4SourceWeightedCurvature.sourceRegularCurvatureSlab_measurable", + "I4SourceWeightedCurvature.sourceCurvatureOneSided_measurable", + "I4SourceWeightedCurvature.sourceRegularCurvatureSlab_weighted_of_numerator", + "I4SourceWeightedCurvature.sourceCurvatureUnion_reduce", + "I4SourceWeightedCurvature.sourceRegularCurvatureSlab_numerator_of_product", + "I4SourceWeightedCurvature.sourceCurvatureUnion_weighted_cubic_of_numerator", + "I4SourceWeightedCurvature.sourceRegularCurvatureSlab_numerator", + "I4SourceWeightedCurvature.sourceWeightedCurvature_bound", + "I4SourceWeightedCurvature.sourceWeightedCurvature_slab_bound", + "I4ActualQuarticTransfer.peanoCubic_first_moment", + "I4ActualQuarticTransfer.peanoCubic_normalized_second_moment", + "I4ActualQuarticTransfer.symmetric_cubic_pin_second_order", + "I4ActualQuarticTransfer.endpoint_taylor_low_coefficients", + "I4ActualQuarticTransfer.corrected_axial_constant", + "I4ActualQuarticTransfer.scalar_taylor_remainder", + "I4ActualQuarticTransfer.scalarTaylor_one", + "I4ActualQuarticTransfer.scalarTaylor_three", + "I4ActualQuarticTransfer.scalarTaylor_two", + "I4ActualQuarticTransfer.scalar_taylor_one_bound", + "I4ActualQuarticTransfer.scalar_taylor_three_bound", + "I4ActualQuarticTransfer.scalar_taylor_two_bound", + "I4ActualQuarticTransfer.smooth_iteratedDeriv", + "I4ActualQuarticTransfer.iteratedDeriv_iteratedDeriv", + "I4ActualQuarticTransfer.sourceF_smooth", + "I4ActualQuarticTransfer.sourceH_smooth", + "I4ActualQuarticTransfer.sourceF_iteratedDeriv_abs_le", + "I4ActualQuarticTransfer.sourceH_iteratedDeriv_abs_le", + "I4SourcePinPreservingQuartic.pi_norm_le_euclidean_norm", + "I4SourcePinPreservingQuartic.euclidean_two_norm_sq", + "I4SourcePinPreservingQuartic.euclidean_two_norm_le_abs_sum", + "I4SourcePinPreservingQuartic.euclidean_two_norm_le_two_mul", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_apply", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_norm_le_of_sqsum", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_norm_le_two_mul", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_offdiag_norm_le", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_symmetric_norm_le_abs_sum", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_symmetric_norm_le_three_mul", + "I4SourcePinPreservingQuartic.line_iteratedDeriv", + "I4SourcePinPreservingQuartic.derivativeComponent_smooth", + "I4SourcePinPreservingQuartic.derivativeComponent_iteratedFDeriv", + "I4SourcePinPreservingQuartic.line_gradient_iteratedDeriv", + "I4SourcePinPreservingQuartic.source_derivative_abs_le", + "I4SourcePinPreservingQuartic.source_line_gradient_taylor", + "I4SourcePinPreservingQuartic.modeCoefficient_analytic_order", + "I4SourcePinPreservingQuartic.source_derivative_comp_perm", + "I4SourcePinPreservingQuartic.source_axial_third_error", + "I4SourcePinPreservingQuartic.source_low_pin_coefficients", + "I4SourcePinPreservingQuartic.coordinateDirection_zero", + "I4SourcePinPreservingQuartic.coordinateDirection_one", + "I4SourcePinPreservingQuartic.hessianMatrix_apply", + "I4SourcePinPreservingQuartic.coordinate_decomposition", + "I4SourcePinPreservingQuartic.hasFDerivAt_gradientEuclidean", + "I4SourcePinPreservingQuartic.gradientEuclidean_eq_components", + "I4SourcePinPreservingQuartic.hasFDerivAt_scaledGradientEuclidean", + "I4SourcePinPreservingQuartic.scaledGradientEuclidean_eq_components", + "I4SourcePinPreservingQuartic.hessianEntry_eq_derivativeComponent", + "I4SourcePinPreservingQuartic.hessianEntry_smooth", + "I4SourcePinPreservingQuartic.line_hessian_iteratedDeriv", + "I4SourcePinPreservingQuartic.source_line_hessian_taylor", + "I4SourcePinPreservingQuartic.one_le_quarticFstar", + "I4SourcePinPreservingQuartic.quarticWidth_pos", + "I4SourcePinPreservingQuartic.cutoff_raw_regularity", + "I4SourcePinPreservingQuartic.cutoff_scaled_error_budget", + "I4SourcePinPreservingQuartic.cutoff_adaptive_tolerance", + "I4SourcePinPreservingQuartic.cutoff_quarticWidth_tolerance", + "I4SourcePinPreservingQuartic.cutoff_curvature_threshold", + "I4SourcePinPreservingQuartic.certificate_width_geometry", + "I4SourcePinPreservingQuartic.source_origin_derivative_abs_le", + "I4SourcePinPreservingQuartic.sourceRawU_abs_le", + "I4SourcePinPreservingQuartic.sourceRawRadius_one_le", + "I4SourcePinPreservingQuartic.sourceRawRadius_le_majorants", + "I4SourcePinPreservingQuartic.sourceRawRadius_le_global", + "I4SourcePinPreservingQuartic.sourcePhysicalPins_ae", + "I4SourcePinPreservingQuartic.sourcePhysicalPins_eventually", + "I4SourcePinPreservingQuartic.sourceScaledGradient_eq", + "I4SourcePinPreservingQuartic.sourceScaledGradient_hasFDerivAt", + "I4SourcePinPreservingQuartic.source_third_ppx_expansion", + "I4SourcePinPreservingQuartic.source_third_ppy_expansion", + "I4SourcePinPreservingQuartic.source_fourth_pppx_expansion", + "I4SourcePinPreservingQuartic.source_fourth_pppy_expansion", + "I4SourcePinPreservingQuartic.source_second_p_basis", + "I4SourcePinPreservingQuartic.source_third_p_basis_basis", + "I4SourcePinPreservingQuartic.source_fourth_pp_basis_basis", + "I4SourcePinPreservingQuartic.hasFDerivAt_pinPreservingQuartic", + "I4SourcePinPreservingQuartic.fderiv_pinPreservingQuartic", + "I4SourcePinPreservingQuartic.sourceGradientTaylorRaw_sub_quartic_zero", + "I4SourcePinPreservingQuartic.sourceGradientTaylorRaw_sub_quartic_one", + "I4SourcePinPreservingQuartic.sourceHessianTaylor_sub_quarticJacobian", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_sub", + "I4SourcePinPreservingQuartic.coordinateDirection_norm_le_one", + "I4SourcePinPreservingQuartic.sourceScaledGradientRaw_apply", + "I4SourcePinPreservingQuartic.source_scaled_gradient_taylor_coordinate_error", + "I4SourcePinPreservingQuartic.source_scaled_gradient_taylor_error", + "I4SourcePinPreservingQuartic.source_scaled_hessian_taylor_coordinate_error", + "I4SourcePinPreservingQuartic.source_scaled_hessian_taylor_error", + "I4SourcePinPreservingQuartic.coefficient_vector_error_le", + "I4SourcePinPreservingQuartic.coefficient_matrix_error_le", + "I4SourcePinPreservingQuartic.sourceGradientTaylor_quartic_error_le", + "I4SourcePinPreservingQuartic.sourceHessianTaylor_quartic_error_le", + "I4SourcePinPreservingQuartic.sourceScaledPotential_hasGradientAt", + "I4SourcePinPreservingQuartic.sourceScaledGradient_eq_gradient", + "I4SourcePinPreservingQuartic.sourceScaledGradient_smooth", + "I4SourcePinPreservingQuartic.pinPreservingQuartic_pins", + "I4SourcePinPreservingQuartic.sourceScaledGradient_pins", + "I4SourcePinPreservingQuartic.sourceQuartic_value_comparison", + "I4SourcePinPreservingQuartic.sourceQuartic_operator_comparison", + "I4SourcePinPreservingQuartic.sourceQuartic_C1_comparison", + "I4SourcePinPreservingQuartic.sourceQuartic_cutoff_tolerance", + "I4SourcePinPreservingQuartic.sourceQuartic_curvature_threshold", + "I4SourcePinPreservingQuartic.sourceQuartic_C1_comparison_ae", + "I4SourcePinPreservingQuartic.sourceQuartic_C1_estimates", + "I4SourcePinPreservingQuartic.sourceRawU_abs_le_radius", + "I4SourcePinPreservingQuartic.sourceQuartic_Fstar_le_radius", + "I4SourcePinPreservingQuartic.sourceQuartic_width_size", + "I4SourcePinPreservingQuartic.sourceQuartic_width_geometry", + "I4SourcePinPreservingQuartic.quartic_strip_in_ball_two", + "I4SourcePinPreservingQuartic.quartic_endpoint_ball_in_ball_two", + "I4SourcePinPreservingQuartic.quartic_axis_endpoint_norm", + "I4SourcePinPreservingQuartic.sourceQuartic_cutoff_estimates", + "I4SourcePinPreservingQuartic.sourceQuartic_weighted_C1_estimates", + "I4SourcePinPreservingQuartic.sourceQuartic_weighted_cutoff_estimates", + "I4SourceSmoothTopology.modeCoefficient_contDiff", + "I4SourceSmoothTopology.modeDerivativeBCF_norm_le", + "I4SourceSmoothTopology.sourceDerivativeBCF_summable", + "I4SourceSmoothTopology.sourceDerivativeBCF_apply", + "I4SourceSmoothTopology.stronglyMeasurable_of_countable_hasSum", + "I4SourceSmoothTopology.sourceDerivativeBCF_stronglyMeasurable", + "I4SourceSmoothTopology.sourceDerivativeBCF_borel", + "I4SourceSmoothTopology.sourceFiniteJet_stronglyMeasurable", + "I4SourceSmoothTopology.sourceFiniteJet_borel", + "I4SourceSmoothTopology.modeDerivativeBCF_apply", + "I4SourceSmoothTopology.sourceDerivativeBCF_tendstoUniformly", + "I4SourceSmoothTopology.jetRestriction_continuous", + "I4SourceSmoothTopology.jetRestriction_norm_le", + "I4SourceSmoothTopology.sourceRestrictedJet_apply", + "I4SourceSmoothTopology.sourceRestrictedJet_stronglyMeasurable", + "I4SourceSmoothTopology.sourceRestrictedJet_borel", + "I4SourceSmoothTopology.sourceFiniteJet_dist_le_iff", + "I4SourceSmoothTopology.sourceFiniteJet_eq_iff_field_eq", + "I4SourceSmoothTopology.smoothSourceField_lattice_periodic", + "I4SourceSmoothTopology.sourceDerivativeBCF_lattice_periodic", + "I4SourceSmoothTopology.sourceFiniteJet_mem_compatible", + "I4SourceSmoothTopology.compatiblePeriodicJets_witness_unique", + "I4SourceSmoothTopology.derivativeMeasurableSpace", + "I4SourceSmoothTopology.derivativeBorelSpace", + "I4SourceSmoothTopology.finiteJetMeasurableSpace", + "I4SourceSmoothTopology.finiteJetBorelSpace", + "I4SourceSmoothTopology.sourceCompatibleJet_measurable", + "I4SourceSmoothTopology.sourceCompatibleJet_borel", + "I4SourceSmoothTopology.sourceDerivativeBCF_hasCondDistrib", + "I4SourceSmoothTopology.sourceFiniteJet_hasCondDistrib", + "I4SourceSmoothTopology.sourceCompatibleJet_hasCondDistrib", + "I4SourceSmoothTopology.sourceFiniteJet_functional_hasCondDistrib", + "I4SourceSmoothTopology.sourceDerivativeBCF_functional_hasCondDistrib", + "I4SourceSmoothTopology.sourceCompatibleJet_functional_hasCondDistrib", + "I4SourceSmoothTopology.sourceDerivativeBCF_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceFiniteJet_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceCompatibleJet_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceFiniteJet_functional_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceDerivativeBCF_functional_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceCompatibleJet_functional_eventually_hasCondDistrib", + "I4SourceRawPinConditioning.rawPinCoefficient_summable", + "I4SourceRawPinConditioning.rawPins_series", + "I4SourceRawPinConditioning.rawPins_measurable", + "I4SourceRawPinConditioning.rawPinCovariance_coefficient", + "I4SourceRawPinConditioning.confluentMatrix_mulVec", + "I4SourceRawPinConditioning.confluentMatrix_isUnit", + "I4SourceRawPinConditioning.pinCoefficient_eq_confluentMatrix", + "I4SourceRawPinConditioning.sourceConfluentPinsAt_eq_matrix", + "I4SourceRawPinConditioning.rawPinCovariance_congruence", + "I4SourceRawPinConditioning.rawPinCovariance_isUnit", + "I4SourceRawPinConditioning.rawPinLift_goodSample", + "I4SourceRawPinConditioning.rawPinLift_measurable", + "I4SourceRawPinConditioning.pinLift_confluent_eq_raw", + "I4SourceRawPinConditioning.rawPosteriorSample_val", + "I4SourceRawPinConditioning.rawPosteriorSample_measurable", + "I4SourceRawPinConditioning.rawPosteriorSample_eq_posteriorSample", + "I4SourceRawPinConditioning.rawPinKernel_isMarkov", + "I4SourceRawPinConditioning.rawPinKernel_apply", + "I4SourceRawPinConditioning.rawPinKernel_eq_confluent", + "I4SourceRawPinConditioning.rawPinKernel_eq_comap", + "I4SourceRawPinConditioning.rawPosteriorSample_rawPins", + "I4SourceRawPinConditioning.rawPinKernel_pin_map", + "I4SourceRawPinConditioning.rawPinKernel_pin_fiber", + "I4SourceRawPinConditioning.rawPinKernel_hasCondDistrib", + "I4SourceRawPinConditioning.rawPinKernel_map_hasCondDistrib", + "I4SourceRawPinConditioning.rawPinCovariance_eventually_isUnit", + "I4SourceRawPinConditioning.rawPinKernel_eventually_hasCondDistrib", + "I4SourceRawPinConditioning.rawPinKernel_prescribed", + "I4SourceRawPinConditioning.rawPrescribedWeightedMeasure_eq", + "I4SourceRawPinConditioning.rawPrescribedWeightedMeasure_estimates", + "I4QuarticCaptureAlgebra.rawRadius_one_le", + "I4QuarticCaptureAlgebra.rawRadius_pos", + "I4QuarticCaptureAlgebra.rawRadius_sum_abs_eq", + "I4QuarticCaptureAlgebra.rawRadius_coord_abs_le_sub_one", + "I4QuarticCaptureAlgebra.rawRadius_coord_abs_le", + "I4QuarticCaptureAlgebra.captureWidth_pos", + "I4QuarticCaptureAlgebra.captureFstar_le_radius", + "I4QuarticCaptureAlgebra.captureWidth_radius_le", + "I4QuarticCaptureAlgebra.captureWidth_le", + "I4QuarticCaptureAlgebra.captureWidth_le_one_sixteenth", + "I4QuarticCaptureAlgebra.captureWidth_radius_le_one_sixtyfourth", + "I4QuarticCaptureAlgebra.capture_r_le_width", + "I4QuarticCaptureAlgebra.captureSigma_pos", + "I4QuarticCaptureAlgebra.captureSigma_le", + "I4QuarticCaptureAlgebra.four_captureWidth_le_captureSigma", + "I4QuarticCaptureAlgebra.quartic_transverse_forcing_bound", + "I4QuarticCaptureAlgebra.quartic_transverse_remainder_bound", + "I4QuarticCaptureAlgebra.quartic_axial_remainder_bound", + "I4QuarticCaptureAlgebra.quartic_strip_upper", + "I4QuarticCaptureAlgebra.quartic_strip_lower", + "I4QuarticCaptureAlgebra.quartic_central_transit", + "I4QuarticCaptureAlgebra.euclidean_component_error_le", + "I4QuarticCaptureAlgebra.capture_strip_in_ball_two", + "I4QuarticCaptureAlgebra.source_component_error_le", + "I4QuarticCaptureAlgebra.source_actual_strip_gates", + "I4QuarticCaptureAlgebra.source_actual_central_gate", + "I4QuarticCaptureAlgebra.source_actual_gates_estimates", + "I4QuarticCaptureAlgebra.source_actual_weighted_gates_estimates", + "I4ActualSourceMorse.incidence_noninjective_of_normal_equations", + "I4ActualSourceMorse.incidence_det_eq_zero_of_normal_equations", + "I4ActualSourceMorse.twoChannelIncidence_hasFDerivAt", + "I4ActualSourceMorse.twoChannelIncidence_differentiableAt", + "I4ActualSourceMorse.twoChannelIncidence_critical_identity", + "I4ActualSourceMorse.channelDiagonal_injective", + "I4ActualSourceMorse.twoChannelGradientFamily_hasFDerivAt", + "I4ActualSourceMorse.twoChannelIncidence_spatial_snd_eq_zero", + "I4ActualSourceMorse.twoChannelIncidence_spatial_normal_equation", + "I4ActualSourceMorse.twoChannelIncidence_eq_of_critical", + "I4ActualSourceMorse.twoChannelDegenerateCriticalParameters_subset_image", + "I4ActualSourceMorse.twoChannelIncidence_det_eq_zero_on_degenerate", + "I4ActualSourceMorse.twoChannelDegenerateIncidence_image_haar_null", + "I4ActualSourceMorse.twoChannelDegenerateCriticalParameters_haar_null", + "I4ActualSourceMorse.channelSwap_involutive", + "I4ActualSourceMorse.channelSwap_gradient_identity", + "I4ActualSourceMorse.channelSwap_image_null", + "I4ActualSourceMorse.gaussian_two_absolutelyContinuous", + "I4ActualSourceMorse.gaussian_four_grouped_absolutelyContinuous", + "I4ActualSourceMorse.four_trigonometric_patches_cover", + "I4ActualSourceMorse.cosineGradientChannel_differentiable", + "I4ActualSourceMorse.sineGradientChannel_differentiable", + "I4ActualSourceMorse.selectedTrigonometricChannel_differentiable", + "I4ActualSourceMorse.unusedTrigonometricChannel_differentiable", + "I4ActualSourceMorse.trigonometricChannelSwap_gradient_function_identity", + "I4ActualSourceMorse.trigonometricDegenerateCriticalParameters_subset_patch_union", + "I4ActualSourceMorse.trigonometricDegenerateCriticalParameters_haar_null", + "I4ActualSourceMorse.trigonometricDegenerateCriticalParameters_gaussian_null", + "I4ActualSourceMorse.eraseCoefficients_measurable", + "I4ActualSourceMorse.eraseSample_measurable", + "I4ActualSourceMorse.actual_derivative_finite_split", + "I4ActualSourceMorse.finite_block_indep_erased", + "I4ActualSourceMorse.finite_block_law", + "I4ActualSourceMorse.actual_finite_block_law", + "I4ActualSourceMorse.actual_finite_block_indep_erased", + "I4ActualSourceMorse.replaceSample_measurable", + "I4ActualSourceMorse.replaceSample_compose", + "I4ActualSourceMorse.replaceSample_read_self", + "I4ActualSourceMorse.replaceSample_reconstruct", + "I4ActualSourceMorse.replaceSample_event_measurable", + "I4ActualSourceMorse.eraseSample_eq_replaceSample_zero", + "I4ActualSourceMorse.replaceSample_read_erased", + "I4ActualSourceMorse.actual_erased_block_joint_map", + "I4ActualSourceMorse.actual_finite_replacement_ae", + "I4ActualSourceMorse.groupFour_measurable", + "I4ActualSourceMorse.groupFour_measurePreserving", + "I4ActualSourceMorse.groupFour_gaussian_measurePreserving", + "I4ActualSourceMorse.actual_four_coordinate_law", + "I4ActualSourceMorse.actualGroupedFour_measurable", + "I4ActualSourceMorse.actualGroupedFour_map_eq", + "I4ActualSourceMorse.actualGroupedFour_measurePreserving", + "I4ActualSourceMorse.compact_positive_iff_dense_nat_floor", + "I4ActualSourceMorse.measurableSet_forall_pos_of_compact", + "I4ActualSourceMorse.measurableSet_forall_mem_pos_of_isCompact", + "I4ActualSourceMorse.sourceDerivative_eval_measurable", + "I4ActualSourceMorse.sourceDerivative_spatial_continuous", + "I4ActualSourceMorse.sourceMorseDiscriminant_eval_measurable", + "I4ActualSourceMorse.sourceMorseDiscriminant_spatial_continuous", + "I4ActualSourceMorse.sourceMorseCube_isCompact", + "I4ActualSourceMorse.sourceMorseCube_event_measurable", + "I4ActualSourceMorse.coordinateGradient_differentiable", + "I4ActualSourceMorse.coordinateGradient_fderiv_apply", + "I4ActualSourceMorse.coordinateGradient_singular_of_hessian_discriminant_zero", + "I4ActualSourceMorse.fourMode_eq", + "I4ActualSourceMorse.sourceContactAmplitude_four_pairs", + "I4ActualSourceMorse.fourModeCoefficient_eq", + "I4ActualSourceMorse.coordinate_cos_hasFDerivAt", + "I4ActualSourceMorse.coordinate_sin_hasFDerivAt", + "I4ActualSourceMorse.fourMode_hasFDerivAt", + "I4ActualSourceMorse.fourGradient_rightInverse", + "I4ActualSourceMorse.fourGradient_surjective", + "I4ActualSourceMorse.fourMode_fderiv", + "I4ActualSourceMorse.fourModePerturbation_hasFDerivAt", + "I4ActualSourceMorse.fourModePerturbation_gradient", + "I4ActualSourceMorse.fourModePerturbation_gradient_surjective", + "I4ActualSourceMorse.fourMode_injective", + "I4ActualSourceMorse.fourAddSample_measurable", + "I4ActualSourceMorse.actual_derivative_fourAdd", + "I4ActualSourceMorse.actual_coordinateGradient_fourAdd", + "I4ActualSourceMorse.fourReindex_measurePreserving", + "I4ActualSourceMorse.fourCoefficientLift_at", + "I4ActualSourceMorse.replaceSample_fourModeSet", + "I4ActualSourceMorse.sourceMorseAmplitude_ne_zero", + "I4ActualSourceMorse.sourceC_ne_zero", + "I4ActualSourceMorse.actual_coordinateGradient_replace", + "I4ActualSourceMorse.morseDirectionX_eq", + "I4ActualSourceMorse.morseDirectionY_eq", + "I4ActualSourceMorse.sourceMorseDiscriminant_nonpos", + "I4ActualSourceMorse.actual_four_replacement_bad_null", + "I4ActualSourceMorse.smoothLaw_ae_sourceMorseCube", + "I4ActualSourceMorse.smoothLaw_ae_sourceMorseCompact", + "I4ActualSourceMorse.smoothLaw_ae_sourceMorse", + "I4ActualSourceMorse.coordinateGradient_det_eq", + "I4ActualSourceMorse.sourceMorseDiscriminant_eq", + "I4ActualSourceMorse.coordinateGradient_contDiff", + "I4ActualSourceMorse.sourceMorse_regular", + "I4ActualSourceMorse.regular_zero_isolated", + "I4ActualSourceMorse.finite_regular_zeros_on_compact", + "I4ActualSourceMorse.smoothLaw_ae_finite_sourceCriticalCube", + "I4SourceSmoothParameterSpace.parameterWeight_nonneg", + "I4SourceSmoothParameterSpace.parameterWeight_mul_abs_summable", + "I4SourceSmoothParameterSpace.weightedCarrier_memℓp", + "I4SourceSmoothParameterSpace.weightedCarrier_apply", + "I4SourceSmoothParameterSpace.weightedCarrier_norm", + "I4SourceSmoothParameterSpace.weightedCarrier_norm_eq_radius_sub_one", + "I4SourceSmoothParameterSpace.weightedCarrier_stronglyMeasurable", + "I4SourceSmoothParameterSpace.weightedCarrier_borel", + "I4SourceSmoothParameterSpace.smoothParameter_complete", + "I4SourceSmoothParameterSpace.smoothParameter_separable", + "I4SourceSmoothParameterSpace.smoothParameter_polish", + "I4SourceSmoothParameterSpace.parameterWeight_pos", + "I4SourceSmoothParameterSpace.parameterWeight_dominates", + "I4SourceSmoothParameterSpace.parameter_abs_summable", + "I4SourceSmoothParameterSpace.weighted_mode_derivative_bound", + "I4SourceSmoothParameterSpace.weightedFourierField_contDiff", + "I4SourceSmoothParameterSpace.weightedFourierField_derivative", + "I4SourceSmoothParameterSpace.l1Synthesis_norm_le", + "I4SourceSmoothParameterSpace.l1Synthesis_apply", + "I4SourceSmoothParameterSpace.l1Synthesis_summable", + "I4SourceSmoothParameterSpace.coherentBCFSemi", + "I4SourceSmoothParameterSpace.coherentBCFAdd", + "I4SourceSmoothParameterSpace.coherentBCFModule", + "I4SourceSmoothParameterSpace.coherentJetSemi", + "I4SourceSmoothParameterSpace.coherentJetAdd", + "I4SourceSmoothParameterSpace.coherentJetModule", + "I4SourceSmoothParameterSpace.normalizedModeDerivative_norm_le", + "I4SourceSmoothParameterSpace.parameterDerivativeCLM_norm_le", + "I4SourceSmoothParameterSpace.parameterJetCLM_norm_le", + "I4SourceSmoothParameterSpace.parameterJet_continuous", + "I4SourceSmoothParameterSpace.parameterDerivativeCLM_apply", + "I4SourceSmoothParameterSpace.actual_parameter_field_eq", + "I4SourceSmoothParameterSpace.actual_parameter_jet_eq", + "I4SourceSmoothParameterSpace.weightedFourierField_periodic", + "I4SourceSmoothParameterSpace.parameterField_contDiff", + "I4SourceSmoothParameterSpace.parameterField_derivative", + "I4SourceSmoothParameterSpace.parameterField_actual", + "I4SourceSmoothParameterSpace.parameterField_periodic", + "I4SourceSmoothParameterSpace.parameterJet_norm_le", + "I4SourceSmoothParameterSpace.parameterField_derivative_norm_le", + "I4SourceSmoothParameterSpace.parameterMeasurableSpace", + "I4SourceSmoothParameterSpace.parameterBorelSpace", + "I4SourceSmoothParameterSpace.weightedCarrier_hasCondDistrib", + "I4SourceSmoothParameterSpace.weightedCarrier_functional_hasCondDistrib", + "I4SourceSmoothParameterSpace.weightedCarrier_eventually_hasCondDistrib", + "I4SourceSmoothParameterSpace.weightedCarrier_functional_eventually_hasCondDistrib", + "I4SourceSmoothParameterSpace.coordinateGradientCLM_apply", + "I4SourceSmoothParameterSpace.gradientTensorContraction_apply", + "I4SourceSmoothParameterSpace.parameterGradientTensorBCF_continuous", + "I4SourceSmoothParameterSpace.gradientPi_iteratedFDeriv", + "I4SourceSmoothParameterSpace.parameterGradientTensorBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradientBCF_continuous", + "I4SourceSmoothParameterSpace.parameterGradientBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradientDerivativeBCF_continuous", + "I4SourceSmoothParameterSpace.parameterGradientDerivativeBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradient_spatial_C2", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanBCF_continuous", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradientEuclidean_spatial_C2", + "I4SourceSmoothParameterSpace.parameterGradientJet_continuous", + "I4SourceSmoothParameterSpace.parameterGradientJet_apply", + "I4SourceSmoothParameterSpace.parameterGradient_actual", + "I4SourceSmoothParameterSpace.parameterGradientDerivative_actual", + "I4SourceSmoothParameterSpace.parameterGradientEuclidean_actual", + "I4SourceSmoothParameterSpace.euclideanDerivativeContraction_apply", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanDerivativeBCF_continuous", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanDerivativeBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanDerivative_actual", + "I4SourceSmoothParameterSpace.parameterEuclideanC1Family_continuous", + "I4SourceLifetimePairFiniteness.actual_critical_coordinateGradient_zero", + "I4SourceLifetimePairFiniteness.coordinates_fundDomain_mem_sourceMorseCube", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_criticalFundDomain", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_pairSet_of_critical", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_candidatePairSet", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_windowPairSet", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_windowElderPairSet", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_unrestrictedPairSet", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_finiteBarPairSet", + "I4SourceCompactTargetMoments.sourceInverse_target_uniform_bounds", + "I4SourceCompactTargetMoments.sourceGammaRadius_allTarget_domination", + "I4SourceCompactTargetMoments.sampleMajorant_affine_integrable_pow", + "I4SourceCompactTargetMoments.sourceGammaRadius_allTarget_moments", + "I4SourceCompactTargetMoments.sourceGapPins_one_sixth", + "I4SourceCompactTargetMoments.sourceGapLaw_one_sixth", + "I4SourceCompactTargetMoments.sourceGapPins_eq_confluent", + "I4SourceCompactTargetMoments.sourceGapLaw_eq_rawPinKernel", + "I4SourceCompactTargetMoments.sourceGapPins_norm_le", + "I4SourceCompactTargetMoments.sourceGapLaw_height_moments", + "AdaptiveFoldScalar.q_hasDerivAt", + "AdaptiveFoldScalar.primitive_hasDerivAt", + "AdaptiveFoldScalar.integral_q_left", + "AdaptiveFoldScalar.integral_q_right", + "AdaptiveFoldScalar.scalarBarrier_of_convex", + "AdaptiveFoldScalar.scalarBarrier_of_secondDerivative", + "AdaptiveFoldTransverseRidge.abs_bilinear_graph_vector_le", + "AdaptiveFoldTransverseRidge.abs_neg_div_le_of_le_neg", + "AdaptiveFoldTransverseRidge.bilinear_graph_vector", + "AdaptiveFoldTransverseRidge.c2_full_derivative_jets", + "AdaptiveFoldTransverseRidge.clm_graph_vector", + "AdaptiveFoldTransverseRidge.clm_vertical_vector", + "AdaptiveFoldTransverseRidge.contDiffOn_of_unique_zero", + "AdaptiveFoldTransverseRidge.contDiffOn_partialY", + "AdaptiveFoldTransverseRidge.exists_structural_collar", + "AdaptiveFoldTransverseRidge.exists_unique_c2_transverse_ridge", + "AdaptiveFoldTransverseRidge.exists_unique_c2_transverse_ridge_with_jets", + "AdaptiveFoldTransverseRidge.exists_unique_c2_zero", + "AdaptiveFoldTransverseRidge.hasDerivAt_slice", + "AdaptiveFoldTransverseRidge.profile_derivative_jets", + "AdaptiveFoldTransverseRidge.root_abs_le_center_div", + "AdaptiveFoldTransverseRidge.slice_unique_root", + "AdaptiveFoldTransverseRidge.vertical_isInvertible", + "AdaptiveFoldTransverseRidge.zero_graph_center_bound", + "AdaptiveFoldTransverseRidge.zero_graph_derivative_bounds", + "AdaptiveFoldTransverseRidge.zero_graph_derivative_formulas", + "AdaptiveFoldTransverseRidge.zero_graph_first_chain", + "AdaptiveFoldTransverseRidge.zero_graph_second_chain", + "AdaptiveFoldBoundaryPath.profileSlopeSecond_error", + "AdaptiveFoldBoundaryPath.exists_transverse_ridge_scalar_barrier", + "AdaptiveFoldBoundaryPath.quadratic_loss_of_second_derivative", + "AdaptiveFoldBoundaryPath.vertical_quadratic_loss", + "AdaptiveFoldBoundaryPath.frontier_leftBox_sides", + "AdaptiveFoldBoundaryPath.side_drop_le", + "AdaptiveFoldBoundaryPath.pathX_mem", + "AdaptiveFoldBoundaryPath.exists_transverse_ridge_boundary_path", + "I4ActualFoldChartJets.coordMap_apply", + "I4ActualFoldChartJets.chartMap_apply", + "I4ActualFoldChartJets.V_contDiff", + "I4ActualFoldChartJets.pullback_jet", + "I4ActualFoldChartJets.Vx_eq", + "I4ActualFoldChartJets.Vy_eq", + "I4ActualFoldChartJets.axial_third_eq", + "I4ActualFoldChartJets.transverse_center_eq", + "I4ActualFoldChartJets.curve_deriv", + "I4ActualFoldChartJets.curve_iteratedDeriv_three", + "I4SourceAdaptiveFoldChart.chart_endpointM", + "I4SourceAdaptiveFoldChart.chart_endpointS", + "I4SourceAdaptiveFoldChart.actualFoldPotential_gap", + "I4SourceAdaptiveFoldChart.normalized_axial_peano", + "I4SourceAdaptiveFoldChart.actualFoldPotential_smooth", + "I4SourceAdaptiveFoldChart.actualFoldPotential_C4", + "I4SourceAdaptiveFoldChart.actualFoldPotential_Vx", + "I4SourceAdaptiveFoldChart.actualFoldPotential_Vy", + "I4SourceAdaptiveFoldChart.actualFoldPotential_axial_third", + "I4SourceAdaptiveFoldChart.actualFoldPotential_transverse_center", + "I4SourceAdaptiveFoldChart.actualFoldPotential_gradient_pins", + "I4SourceAdaptiveFoldChart.actualFoldPotential_normalized_data_of_rawPins", + "I4SourceAdaptiveFoldChart.sourceGapLaw_and_posterior_normalized_fold_data", + "I4SourceAdaptiveFoldChart.sourceGapLaw_normalized_fold_data", + "I4SourceAdaptiveFoldChart.rawPosteriorSample_normalized_fold_data", + "I4ActualFoldNumeric.numerical_budget", + "I4ActualFoldTwoPin.two_pin_abs_le_on_J", + "I4ActualFoldTwoPin.two_pin_bounds_on_J", + "I4SourceAdaptiveFoldEstimates.actual_Hy_eq_Gx", + "I4SourceAdaptiveFoldEstimates.actual_Vx_second", + "I4SourceAdaptiveFoldEstimates.actual_Vy_second", + "I4SourceAdaptiveFoldEstimates.actual_axial_pointwise_error", + "I4SourceAdaptiveFoldEstimates.actual_component_second", + "I4SourceAdaptiveFoldEstimates.actual_coordinate_oscillation", + "I4SourceAdaptiveFoldEstimates.actual_fourth_coordinate_bound", + "I4SourceAdaptiveFoldEstimates.actual_fourth_norm_bound", + "I4SourceAdaptiveFoldEstimates.actual_jet_norm_bound", + "I4SourceAdaptiveFoldEstimates.actual_second_lipschitz", + "I4SourceAdaptiveFoldEstimates.actual_second_swap", + "I4SourceAdaptiveFoldEstimates.actual_structural_rectangle", + "I4SourceAdaptiveFoldEstimates.actual_third_lipschitz", + "I4SourceAdaptiveFoldEstimates.actual_third_norm_bound", + "I4SourceAdaptiveFoldEstimates.axes_norm", + "I4SourceAdaptiveFoldEstimates.component_first", + "I4SourceAdaptiveFoldEstimates.component_first_as_second", + "I4SourceAdaptiveFoldEstimates.component_jet", + "I4SourceAdaptiveFoldEstimates.component_second", + "I4SourceAdaptiveFoldEstimates.component_smooth", + "I4SourceAdaptiveFoldEstimates.coord_norm_le", + "I4SourceAdaptiveFoldEstimates.hasDerivAt_xslice", + "I4SourceAdaptiveFoldEstimates.hasDerivAt_xslice_component", + "I4SourceAdaptiveFoldEstimates.jet_lipschitz", + "I4SourceAdaptiveFoldEstimates.normalized_peano_mass", + "I4SourceAdaptiveFoldEstimates.point_norm_sub_le", + "I4SourceAdaptiveFoldEstimates.second_component_bound", + "I4SourceAdaptiveFoldEstimates.second_component_smooth", + "I4SourceAdaptiveFoldEstimates.sourceGapLaw_actual_rectangle_boundary_path", + "I4SourceAdaptiveFoldEstimates.sourceGapLaw_structural_rectangle", + "I4SourceAdaptiveFoldEstimates.sourceT_one_le", + "I4SourceAdaptiveFoldEstimates.source_scale_le", + "I4SourceAdaptiveFoldEstimates.vertical_boundary_signs", + "I4SourceActualFoldDeath.actualField_pullback", + "I4SourceActualFoldDeath.physicalChart_M", + "I4SourceActualFoldDeath.scaled_rectangle_death", + "I4SourceActualFoldDeath.sourceGapLaw_actual_death_clearance", + "I4SourceActualFoldDeath.actual_rectangle_death", + "I4SourceActualFoldDeath.physicalChart_S", + "I4SourceActualFoldDeath.actualField_continuous", + "I4SourceActualFoldDeath.physicalChart_apply", + "SourceActualFoldTorus.torusProjection2L_continuous", + "SourceActualFoldTorus.torusProjection2L_open", + "SourceActualFoldTorus.torusProjection2L_surjective", + "SourceActualFoldTorus.sourceTorus2L_t2", + "SourceActualFoldTorus.actualTorusField_pullback", + "SourceActualFoldTorus.actualTorusField_continuous", + "SourceActualFoldTorus.torusPhysicalMap_continuous", + "SourceActualFoldTorus.torusPhysicalMap_open", + "SourceActualFoldTorus.actualTorusField_physical_pullback", + "SourceActualFoldTorus.strictClearanceSet_eq_C263", + "SourceActualFoldTorus.TorusTrapData.strictClearanceSet_eq_Iio", + "SourceActualFoldTorus.TorusTrapData.strictClearanceDeath_eq", + "SourceActualFoldTorus.scaled_rectangle_trap", + "SourceActualFoldTorus.torusPhysicalMap_M", + "SourceActualFoldTorus.torusPhysicalMap_S", + "SourceActualFoldTorus.torusPhysicalMap_field_eq", + "SourceActualFoldTorus.actual_rectangle_torus", + "SourceActualFoldTorus.sourceGapLaw_actual_torus_trap_clearance", + "SourceActualFoldTorus.sourceGapLaw_actual_torus_clearance", + "SourceActualFoldH0.fold_interval_endpoints", + "SourceActualFoldH0.h0Section_retraction", + "SourceActualFoldH0.sourceGapLaw_actual_torus_h0", + "SourceActualFoldH0.sourceGapLaw_actual_torus_trap_h0", + "SourceActualFoldH0.toElderTrap", + "SourceFoldWeightedProbability.cutoff_failure_inclusion", + "SourceFoldWeightedProbability.sourceCutoffA_nonneg", + "SourceFoldWeightedProbability.sourceCutoffEps_pos", + "SourceFoldWeightedProbability.sourceFoldGood_compl_subset", + "SourceFoldWeightedProbability.sourceFoldGood_measurable", + "SourceFoldWeightedProbability.sourceFoldWeightedLaw_absolutelyContinuous", + "SourceFoldWeightedProbability.sourceFoldWeightedLaw_eq", + "SourceFoldWeightedProbability.sourceFoldWeightedProbability_bound", + "SourceFoldWeightedProbability.sourceFoldWeightedProbability_h0", + "SourceFoldWeightedProbability.sourceKappa_measurable", + "SourceFoldWeightedProbability.sourceKappa_one_sixth", + "SourceFoldWeightedProbability.sourceScale_pos", + "SourceFoldWeightedProbability.sourceT_eq_scale", + "SourceFoldWeightedProbability.sourceT_measurable", + "I4SourceGapPinCurvature.sourceGapLaw_curvature_bounds", + "I4SourceGapPinCurvature.sourceSmoothKernel_curvature_bounds_ae", + "I4SourceGapPinCurvature.sourceSmoothWeight_curvature_bound", + "I4SourceGapPinCurvature.sourceSmoothWeight_radius_bound", + "I4SourceGapPinCurvature.source_bad_curvature_slab", + "I4SourceGapPinCurvature.source_normalized_determinant_bounds", + "I4SourceGapPinCurvature.source_normalized_first_four_bound", + "I4SourceGapPinCurvature.source_normalized_first_four_third_bound", + "I4SourceGapPinCurvature.source_normalized_transverse_errors", + "I4SourceGapPinCurvature.source_positive_weight_curvature_upper", + "I4SourceAllTargetCurvatureResidual.one_le_allTargetCurvatureResidualRadius", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_uniform_bounds", + "I4SourceAllTargetCurvatureResidual.sourceDerivativeMajorant_allTarget_curvatureReconstruct", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_gap_height_moments", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_prescribed", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_measurable", + "I4SourceAllTargetCurvatureResidual.sourceContactQ_posterior_abs_le_allTargetRadius", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_moment_bound", + "I4SourceAllTargetCurvatureResidual.sourceGammaRadius_allTarget_curvatureReconstruct", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_image_bound", + "I4SourceGapWeightedNumerator.sourceGapLaw_regular_numerator", + "I4SourceGapWeightedNumerator.sourceGapLaw_regularity_numerator", + "I4SourceGapWeightedNumerator.sourceBadUnion_integral_le", + "I4SourceGapWeightedNumerator.sourceGapLaw_bad_union_numerator", + "I4SourceGapWeightedNumerator.sourceGapLaw_weight_integrable", + "I4SourceGapWeightedNumerator.sourceGapLaw_regular_numerator_of_product", + "I4SourceGapWeightedNumerator.sourceGapLaw_regularity_base_bound", + "I4SourceGapWeightedNumerator.sourceGapLaw_compact_moments", + "SourceCompactGapNormalizer.cubic_pin_pointwise_error_target", + "SourceCompactGapNormalizer.endpointWeight_gap_floor", + "SourceCompactGapNormalizer.gaussianCompactLowerConstant_pos", + "SourceCompactGapNormalizer.gaussianPDFReal_lower_compact", + "SourceCompactGapNormalizer.gaussianReal_Icc_lower_compact", + "SourceCompactGapNormalizer.sourceCompactGoodEvent_mass", + "SourceCompactGapNormalizer.sourceCompactGoodEvent_measurable", + "SourceCompactGapNormalizer.sourceGapLaw_compact_normalizer", + "SourceCompactGapNormalizer.sourceGapLaw_negative_interval_mass", + "SourceCompactGapNormalizer.sourceGapLaw_q_hasLaw", + "SourceCompactGapNormalizer.sourceGap_curvatureMean_bound", + "SourceCompactGapNormalizer.sourceSmoothWeight_gap_floor", + "SourceCompactGapNormalizer.source_normalized_gap_axial_errors", + "SourceCompactFoldWeightedProbability.sourceCompactCutoffA_nonneg", + "SourceCompactFoldWeightedProbability.sourceCompactFoldGood_compl_subset", + "SourceCompactFoldWeightedProbability.sourceCompactFoldGood_measurable", + "SourceCompactFoldWeightedProbability.sourceCompactFoldWeightedLaw_absolutelyContinuous", + "SourceCompactFoldWeightedProbability.sourceCompactFoldWeightedProbability_bound", + "SourceCompactFoldWeightedProbability.sourceCompactFoldWeightedProbability_h0", + "SourceCompactFoldWeightedProbability.varying_cutoff_failure_inclusion", + "I4SourceActualFoldCandidate.actual_critical_of_coordinate_pins", + "I4SourceActualFoldCandidate.actual_endpoint_schur_signs", + "I4SourceActualFoldCandidate.actual_hessian_complete_square", + "I4SourceActualFoldCandidate.actual_hessian_coordinates", + "I4SourceActualFoldCandidate.actual_hessian_physical", + "I4SourceActualFoldCandidate.actual_planar_hessian_quadratic", + "I4SourceActualFoldCandidate.actual_rawPins_critical", + "I4SourceActualFoldCandidate.actual_rawPins_heights", + "I4SourceActualFoldCandidate.actual_rawPins_ridge_candidate", + "I4SourceActualFoldCandidate.actual_rawPins_ridge_types", + "I4SourceActualFoldCandidate.actual_torus_lifetime_pullback", + "I4SourceActualFoldCandidate.coordinates_endpointLiftM", + "I4SourceActualFoldCandidate.coordinates_endpointLiftS", + "I4SourceActualFoldCandidate.derivative_zero_of_coordinate_pins", + "I4SourceActualFoldCandidate.endpointLiftM_apply", + "I4SourceActualFoldCandidate.endpointLiftS_apply", + "I4SourceActualFoldCandidate.endpoint_lifts_lattice_lower", + "I4SourceActualFoldCandidate.endpoint_lifts_sub_norm", + "I4SourceActualFoldCandidate.endpoint_lifts_torusDist", + "I4SourceActualFoldCandidate.endpoint_lifts_torusDist_unit_ne_radius", + "I4SourceActualFoldCandidate.endpoint_lifts_torusDist_unit_zero", + "I4SourceActualFoldCandidate.endpoint_schur_signs", + "I4SourceActualFoldCandidate.hessianHasInertia_one_of_diag", + "I4SourceActualFoldCandidate.hessianHasInertia_two_of_diag", + "I4SourceActualFoldCandidate.interface_values_eq_actual", + "I4SourceActualFoldCandidate.planar_bilinear_quadratic", + "I4SourceActualFoldCandidate.planar_quadratic_complete_square", + "I4SourceActualFoldCandidate.planar_vector_decomposition", + "I4SourceActualFoldCandidate.ridge_profileSlopeFirst_eq_schur", + "I4SourceActualFoldCandidate.sourceGapLaw_actual_candidate_death_h0", + "I4SourceActualFoldCandidate.torusProjection_endpointLiftM", + "I4SourceActualFoldCandidate.torusProjection_endpointLiftS", + "I4SourceFinitePinKernel.finitePairing_residualCoefficient", + "I4SourceFinitePinKernel.residualCoefficient_summable", + "I4SourceFinitePinKernel.coefficientGram_posDef_of_finite_kernel_rightInverse", + "I4SourceFinitePinKernel.finiteShiftSample_val", + "I4SourceFinitePinKernel.rawPins_finiteShiftSample", + "I4SourceFinitePinKernel.rawPosteriorSample_finiteShiftSample", + "I4SourceFiniteTrig.eval_constant", + "I4SourceFiniteTrig.eval_append", + "I4SourceFiniteTrig.eval_scale", + "I4SourceFiniteTrig.eval_translate", + "I4SourceFiniteTrig.eval_mul", + "I4SourceFiniteTrig.toSource_eval", + "I4SourceFiniteTrig.toSource_derivative", + "I4SourceRemoteJetWitness.localGerm_jet2", + "I4SourceRemoteJetWitness.jet2_mul", + "I4SourceRemoteJetWitness.jet2_interpolate_mul", + "I4SourceRemoteJetWitness.actual_finite_remoteJet_witnesses", + "I4SourceRemoteJetWitness.actual_remote_residual_coefficientGram_posDef", + "I4SourceRemoteJetGaussian.remoteJet_rawPosteriorSample", + "I4SourceRemoteJetGaussian.rawPinKernel_remoteJet_eq_multivariateGaussian", + "I4SourceRemoteJetGaussian.remoteResidualCovariance_posDef", + "I4SourceRemoteJetGaussian.rawPinKernel_remoteJet_conditional_uniform", + "I4SourceEndpointHessianWitness.actual_finite_endpointHessian_witnesses", + "I4SourceEndpointHessianWitness.actual_endpointHessian_residual_coefficientGram_posDef", + "I4SourceH0OlderClearance.h0OlderClearance_iff_strictClearance", + "I4SourceH0OlderClearance.h0OlderClearance_realCover_iff_lt_death", + "I4SourceH0OlderClearance.sourceGapLaw_h0OlderClearance_uniform", + "I4SourceEndpointHessianGaussian.rawPinKernel_endpointHessian_eq_multivariateGaussian", + "I4SourceEndpointHessianGaussian.endpointHessianCovariance_posDef", + "I4SourceEndpointHessianGaussian.rawPinKernel_ae_endpointHessian_det_ne_zero", + "I4SourceTwoRemoteFirstJetWitness.actual_finite_twoRemoteFirstJet_witnesses", + "I4SourceTwoRemoteFirstJetWitness.actual_twoRemoteFirstJet_residual_coefficientGram_posDef", + "I4SourceIntrinsicH0Interface.h0Interface_cut_death_eq_C263", + "I4SourceIntrinsicH0Interface.h0Interface_morse_compatibility", + "I4SourceIntrinsicH0Interface.sourceGapLaw_intrinsic_h0_finiteBar_uniform", + "I4SourceTwoRemoteFirstJetGaussian.rawPinKernel_twoRemoteFirstJet_eq_multivariateGaussian", + "I4SourceTwoRemoteFirstJetGaussian.twoRemoteResidualCovariance_posDef", + "I4SourceIntrinsicH0WeightedProbability.sourceIntrinsicFiniteBarEvent_measurable", + "I4SourceIntrinsicH0WeightedProbability.sourceIntrinsicFiniteBarProbability_uniform", + "I4SourceRawPinFreeCoordinates.freeMaps_measurable", + "I4SourceRawPinFreeCoordinates.freeResidual_freeCoordinate_joint_map", + "I4SourceRawPinFreeCoordinates.rawPosteriorSample_free_reconstruction", + "I4SourceFramedConfluentCovariance.framedConfluentVector_actual", + "I4SourceFramedConfluentCovariance.framedConfluent_family_bounds", + "I4SourceFramedConfluentCovariance.framedConfluent_covariance_uniform_floor", + "I4SourceGapConditionalMorseDistinct.sourceGapLaw_ae_isMorseDistinct", + "I4SourceActualMorseLocalModel.actualSource_c1_quadratic_localModel", + "I4SourceActualTorusSuperlevelLocalBasis.actualSource_torus_closedSuperlevel_localPathConnectedBasis", + "I4SourceActualTorusRegularSlab.actualSource_closedSlab_componentInclusion_bijective", + "I4SourceActualFiniteSuperlevelComponents.actualSource_finite_closedSuperlevel_components", + "I4SourceActualQuotientSaddleCollar.actualSource_quotient_saddle_local_collar", + "I4SourceActualSaddleUppercuts.actualSource_quotient_saddle_uniform_closed_uppercuts", + "I4SourceActualRegularLocalCollar.actualSource_quotient_regular_local_collar", + "I4SourceActualLowerSeparation.actualSource_closedSuperlevel_componentInclusion_locally_injective" + ], + "target_vector_sha256": "2c22d5ba939ed6cf74669a99a23ad8337ec9a54abcafb3bf43ef5799e5536cae", + "expected_counts": { + "production_modules": 67, + "input_modules": 32, + "ordinary_inputs": 25, + "elder_inputs": 7, + "public_targets": 1137, + "proposition_targets": 1128, + "data_targets": 9 + }, + "dependency_pins": [ + { + "name": "plausible", + "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c" + }, + { + "name": "LeanSearchClient", + "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707" + }, + { + "name": "importGraph", + "rev": "e928b72544873815af278d38681b31c0293588e3" + }, + { + "name": "proofwidgets", + "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5" + }, + { + "name": "aesop", + "rev": "355695d523e41d0554926416cba2a2b3544fbbc9" + }, + { + "name": "Qq", + "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259" + }, + { + "name": "batteries", + "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2" + }, + { + "name": "Cli", + "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204" + }, + { + "name": "mathlib", + "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612" + } + ], + "lean_release_commit": "5045d0056413266e57c625dcd7c365b10e377c52", + "unresolved": [ + "EXACT_TYPE_SEMANTICS", + "FULL_DECLARATION_ROLES", + "ALL_PARTS_COMPILED_COVERAGE", + "EXECUTION" + ], + "fixture_projection": { + "file": "source-scope-projection.json", + "sha256": "f0675a25b6e351b3ab838879cc584b5a2d61b53faece0478397c0f73ead9ba32", + "bytes": 85471, + "purpose": "Offline extraction fixture only; original raw manifest hash remains mandatory for pinned-checkout evidence." + }, + "module_vector_sha256": "4446aeee839a661d2452fa8f1c0992ee2f581d7623b94e490511b047c5b75111", + "selected_source_hashes_verification": "Declared in immutable source manifest; actual 99 file bytes require the separate pinned-checkout test." +} diff --git a/tests/fixtures/sdga_scope/source-scope-projection.json b/tests/fixtures/sdga_scope/source-scope-projection.json new file mode 100644 index 000000000..a04b1a1fe --- /dev/null +++ b/tests/fixtures/sdga_scope/source-scope-projection.json @@ -0,0 +1,1312 @@ +{ + "source_modules": [ + "SourceDerivativeGaussian.lean", + "ContactJetCovariance.lean", + "SourceContactCovariance.lean", + "SourceConfluentPins.lean", + "SourceContactSchur.lean", + "SourceDerivativeContinuity.lean", + "ConfluentIntegralIdentities.lean", + "SourceEndpointRegression.lean", + "GaussianRegressionLimits.lean", + "SourceEndpointParameters.lean", + "SourceContactEndpointParameters.lean", + "SourceConfluentLimits.lean", + "SourcePhysicalEndpointKernel.lean", + "SourceEndpointEstimates.lean", + "SourceSmoothConditionalKernel.lean", + "SourceSmoothPalm.lean", + "GaussianWeightedMajorants.lean", + "SourceConditionalMajorant.lean", + "SourcePinCurvatureBounds.lean", + "ScalarProductCurvatureBound.lean", + "SourceCurvatureDecomposition.lean", + "SourceWeightedCurvatureBound.lean", + "SourcePinPreservingQuartic.lean", + "SourceSmoothTopology.lean", + "SourceRawPinConditioning.lean", + "SourceQuarticCaptureAlgebra.lean", + "SourceMorseIncidence.lean", + "SourceSmoothParameterSpace.lean", + "SourceLifetimePairFiniteness.lean", + "SourceCompactTargetMoments.lean", + "AdaptiveFoldScalarBarrier.lean", + "AdaptiveFoldTransverseRidge.lean", + "AdaptiveFoldBoundaryPath.lean", + "SourceAdaptiveFoldChart.lean", + "SourceAdaptiveFoldEstimates.lean", + "SourceActualFoldDeath.lean", + "SourceActualFoldTorus.lean", + "SourceActualFoldH0.lean", + "SourceFoldWeightedProbability.lean", + "SourceGapPinCurvature.lean", + "SourceAllTargetCurvatureResidual.lean", + "SourceGapWeightedNumerator.lean", + "SourceCompactGapNormalizer.lean", + "SourceCompactFoldWeightedProbability.lean", + "SourceActualFoldCandidate.lean", + "SourceFinitePinKernel.lean", + "SourceFiniteTrig.lean", + "SourceRemoteJetWitness.lean", + "SourceRemoteJetGaussian.lean", + "SourceEndpointHessianWitness.lean", + "SourceH0OlderClearance.lean", + "SourceEndpointHessianGaussian.lean", + "SourceTwoRemoteFirstJetWitness.lean", + "SourceIntrinsicH0Interface.lean", + "SourceTwoRemoteFirstJetGaussian.lean", + "SourceIntrinsicH0WeightedProbability.lean", + "SourceRawPinFreeCoordinates.lean", + "SourceFramedConfluentCovariance.lean", + "SourceGapConditionalMorseDistinct.lean", + "SourceActualMorseLocalModel.lean", + "SourceActualTorusSuperlevelLocalBasis.lean", + "SourceActualTorusRegularSlab.lean", + "SourceActualFiniteSuperlevelComponents.lean", + "SourceActualQuotientSaddleCollar.lean", + "SourceActualSaddleUppercuts.lean", + "SourceActualRegularLocalCollar.lean", + "SourceActualLowerSeparation.lean" + ], + "targets": [ + "I4SourceDerivativeGaussian.derivativeCoefficient_summable", + "I4SourceDerivativeGaussian.smoothSourceField_derivative_series", + "I4SourceDerivativeGaussian.scalarSeries_finiteVector_hasGaussianLaw", + "I4SourceDerivativeGaussian.smoothSourceField_derivativeVector_hasGaussianLaw", + "I4SourceDerivativeGaussian.smoothSourceField_derivative_covariance", + "I4ContactGram.contactWitness_transpose_mulVec_eq_zero", + "I4ContactGram.contactWitness_transpose_injective", + "I4ContactGram.contactWitness_amplitude_transpose_injective", + "I4ContactGram.coefficient_product_summable", + "I4ContactGram.coefficientGram_quadratic_hasSum", + "I4ContactGram.coefficientGram_posDef_of_separating", + "I4ContactGram.contact_coefficientGram_posDef", + "I4ContactGram.contact_schur_pos", + "I4SourceContact.sourceContactVector_hasGaussianLaw", + "I4SourceContact.sourceContactCoefficient_summable", + "I4SourceContact.sourceContactCovariance_eq_coefficientGram", + "I4SourceContact.sourceContactMode_nonzero_frequency", + "I4SourceContact.sourceContactAmplitude_pos", + "I4SourceContact.sourceContact_selected_columns", + "I4SourceContact.sourceContactCovariance_posDef", + "I4SourceConfluentPins.rawTransform_confluentTransform", + "I4SourceConfluentPins.confluentTransform_rawTransform", + "I4SourceConfluentPins.confluentEquiv_apply", + "I4SourceConfluentPins.confluentEquiv_symm_apply", + "I4SourceConfluentPins.prescribed_target", + "I4SourceConfluentPins.rawPins_hasGaussianLaw", + "I4SourceConfluentPins.confluentPins_hasGaussianLaw", + "I4SourceConfluentPins.rawPinsWithHessians_hasGaussianLaw", + "I4SourceContact.sourceContactBlockEquiv_inl", + "I4SourceContact.sourceContactBlockEquiv_inr", + "I4SourceContact.sourceContactCovariance_block_identity", + "I4SourceContact.sourcePinCovariance_posDef", + "I4SourceContact.sourcePinCovariance_isUnit", + "I4SourceContact.sourceContactQVariance_eq_variance", + "I4SourceContact.sourceContactSchur_pos", + "I4SourceContact.contact_residual_variance_of_isUnit_covariance", + "I4SourceContact.sourceContactResidual_variance", + "I4SourceContact.sourceContactResidual_variance_pos", + "I4SourceDerivativeContinuity.derivativeMajorant_nonneg", + "I4SourceDerivativeContinuity.derivativeMajorant_summable", + "I4SourceDerivativeContinuity.derivativeCoefficient_bound", + "I4SourceDerivativeContinuity.derivativeCoefficient_continuous", + "I4SourceDerivativeContinuity.smoothSourceField_derivative_covariance_continuous", + "I4SourceDerivativeContinuity.smoothSourceField_derivative_integral_zero", + "I4ConfluentIntegralIdentities.pin3_integral", + "I4ConfluentIntegralIdentities.pin4_integral", + "I4ConfluentIntegralIdentities.pin5_integral", + "I4ConfluentIntegralIdentities.adjusted_second_left", + "I4ConfluentIntegralIdentities.adjusted_second_right", + "I4ConfluentIntegralIdentities.adjusted_transverse_left", + "I4ConfluentIntegralIdentities.adjusted_transverse_right", + "I4SourceEndpointRegression.sourceConfluentPinsAt_eq", + "I4SourceEndpointRegression.endpointObservationMap_actual", + "I4SourceEndpointRegression.sourcePins_adjusted_hasGaussianLaw", + "I4SourceEndpointRegression.sourceRegressionMapAt_apply", + "I4SourceEndpointRegression.sourceRegressionMapAt_single", + "I4SourceEndpointRegression.sourceRegression_normal_equations", + "I4SourceEndpointRegression.sourceEndpointKernel_markov", + "I4SourceEndpointRegression.sourceEndpointKernel_measurable", + "I4SourceEndpointRegression.sourceEndpointKernel_apply", + "I4SourceEndpointRegression.sourceEndpointKernel_hasCondDistrib", + "I4SourceEndpointRegression.sourceEndpointKernel_spec", + "I4SourceEndpointRegression.sourceAdjustedEndpoints_on_pin_fiber", + "I4SourceEndpointRegression.sourceAdjustedEndpoints_on_prescribed", + "I4GaussianRegressionLimits.regression_parameter_limits", + "I4GaussianRegressionLimits.regression_uniform_bounds", + "I4SourceEndpointParameters.smoothSourceField_derivative_integral_zero", + "I4SourceEndpointParameters.rawPinsWithHessians_integral_zero", + "I4SourceEndpointParameters.rawPinsWithHessians_integral_vector_zero", + "I4SourceEndpointParameters.sourcePins_adjusted_integral_zero", + "I4SourceEndpointParameters.sourceConfluentPinsAt_integral_zero", + "I4SourceEndpointParameters.sourceAdjustedEndpoints_integral_zero", + "I4SourceEndpointParameters.sourceEndpointResidual_integral_zero", + "I4SourceEndpointParameters.sourceEndpointResidual_covariance", + "I4SourceEndpointParameters.finiteGaussian_law_parameters", + "I4SourceEndpointParameters.sourceEndpointResidual_hasGaussianLaw", + "I4SourceEndpointParameters.sourceEndpointPosterior_hasGaussianLaw", + "I4SourceEndpointParameters.sourceEndpointPosterior_integral", + "I4SourceEndpointParameters.sourceEndpointPosterior_covariance", + "I4SourceEndpointParameters.sourceEndpointKernel_eq_map_posterior", + "I4SourceEndpointParameters.sourceEndpointKernel_isGaussian", + "I4SourceEndpointParameters.sourceEndpointSchurAt_posSemidef", + "I4SourceEndpointParameters.sourceEndpointKernel_eq_multivariateGaussian", + "I4SourceEndpointParameters.sourceEndpointKernel_integral", + "I4SourceEndpointParameters.sourceEndpointKernel_covariance", + "I4SourceContact.sourceContactEndpointMean_contact", + "I4SourceContact.sourceContactEndpointSchur_covariance", + "I4SourceContact.sourceContactEndpointSchur_posSemidef", + "I4SourceContact.sourceContactEndpointSchur_contact", + "I4SourceContact.sourceContactEndpointSchur_four_four_eq_schur", + "I4SourceContact.sourceContactEndpointSchur_referenceVariance_pos", + "I4SourceConfluentLimits.rawPinsWithHessians_series", + "I4SourceConfluentLimits.pinCoefficient_summable", + "I4SourceConfluentLimits.adjustedCoefficient_summable", + "I4SourceConfluentLimits.sourceConfluentPinsAt_series", + "I4SourceConfluentLimits.sourceAdjustedEndpoints_series", + "I4SourceConfluentLimits.sourcePinCovarianceAt_coefficient", + "I4SourceConfluentLimits.sourceCrossCovarianceAt_coefficient", + "I4SourceConfluentLimits.sourceEndpointCovarianceAt_coefficient", + "I4ModeCurveChains.mode_smooth", + "I4ModeCurveChains.axis_iteratedDeriv", + "I4ModeCurveChains.axis_transverse_smooth", + "I4ModeCurveChains.axis_transverse_iteratedDeriv", + "I4ModeCurveChains.modeH_eq", + "I4ModeCurveChains.modeF_C3", + "I4ModeCurveChains.modeH_C2", + "I4ModeCurveChains.modeF_deriv", + "I4ModeCurveChains.modeF_second", + "I4ModeCurveChains.modeF_third", + "I4ModeCurveChains.modeH_deriv", + "I4ModeCurveChains.modeH_second", + "I4SourceConfluentLimits.rawDerivativeCoefficient_explicit", + "I4SourceConfluentLimits.pinCoefficient_explicit", + "I4SourceConfluentLimits.adjustedCoefficient_explicit", + "I4WeightedModeIntegrals.weighted_integrand_bound", + "I4WeightedModeIntegrals.weightedDerivativeIntegral_continuous", + "I4WeightedModeIntegrals.weightedDerivativeIntegral_norm_le", + "I4WeightedModeIntegrals.weightedDerivativeIntegral_zero", + "I4SourceConfluentLimits.peano_kernel_masses", + "I4SourceConfluentLimits.pinCoefficient_eq_regularized", + "I4SourceConfluentLimits.adjustedCoefficient_eq_regularized", + "I4ContactCoefficientLimits.contactPinCoefficient_summable", + "I4ContactCoefficientLimits.contactAdjustedCoefficient_summable", + "I4ContactCoefficientLimits.sourcePinVector_eq_contactSeries", + "I4ContactCoefficientLimits.sourceContactEndpointVector_eq_contactSeries", + "I4ContactCoefficientLimits.sourcePinCovariance_eq_contactCoefficientGram", + "I4ContactCoefficientLimits.sourceContactEndpointCrossCovariance_eq_contactCoefficientGram", + "I4ContactCoefficientLimits.sourceContactEndpointCovariance_eq_contactCoefficientGram", + "I4SourceConfluentLimits.confluentModeMajorant_nonneg", + "I4SourceConfluentLimits.confluentModeMajorant_summable", + "I4SourceConfluentLimits.regularizedPinCoefficient_bound", + "I4SourceConfluentLimits.regularizedAdjustedCoefficient_bound", + "I4SourceConfluentLimits.regularizedPinCoefficient_continuous", + "I4SourceConfluentLimits.regularizedAdjustedCoefficient_continuous", + "I4SourceConfluentLimits.regularizedPinCoefficient_zero", + "I4SourceConfluentLimits.regularizedAdjustedCoefficient_zero", + "I4SourceConfluentLimits.regularizedPinCovariance_continuous", + "I4SourceConfluentLimits.regularizedCrossCovariance_continuous", + "I4SourceConfluentLimits.regularizedEndpointCovariance_continuous", + "I4SourceConfluentLimits.sourcePinCovarianceAt_eq_regularized", + "I4SourceConfluentLimits.sourceCrossCovarianceAt_eq_regularized", + "I4SourceConfluentLimits.sourceEndpointCovarianceAt_eq_regularized", + "I4SourceConfluentLimits.regularizedPinCovariance_zero", + "I4SourceConfluentLimits.regularizedCrossCovariance_zero", + "I4SourceConfluentLimits.regularizedEndpointCovariance_zero", + "I4SourceConfluentLimits.sourcePinCovarianceAt_tendsto", + "I4SourceConfluentLimits.sourceCrossCovarianceAt_tendsto", + "I4SourceConfluentLimits.sourceEndpointCovarianceAt_tendsto", + "I4SourcePhysicalEndpointKernel.sourceNormalizedEndpoints_eq_adjusted", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_markov", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_measurable", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_apply", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_hasCondDistrib", + "I4SourcePhysicalEndpointKernel.sourcePhysicalCorrection_prescribed", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_at_prescribed", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_integral", + "I4SourcePhysicalEndpointKernel.sourcePhysicalEndpointKernel_spec", + "I4SourceEndpointEstimates.sourcePhysicalCoordinates_apply", + "I4SourceEndpointEstimates.sourcePhysicalCoordinates_continuous", + "I4SourceEndpointEstimates.sourcePhysicalCoordinates_inverse", + "I4SourceEndpointEstimates.sourceEndpointWeight_measurable", + "I4SourceEndpointEstimates.sourceEndpointWeight_nonneg", + "I4SourceEndpointEstimates.sourceEndpointWeight_eq_continuous", + "I4SourceEndpointEstimates.sourceEndpointLaw_isProbabilityMeasure", + "I4SourceEndpointEstimates.sourceEndpointLaw_euclidean_hasLaw", + "I4SourceEndpointEstimates.sourceEndpointLaw_physical_marginal", + "I4SourceEndpointEstimates.sourceEndpointLaw_weight_integral", + "I4SourceEndpointEstimates.sourceEndpointLaw_second_moment_of_parameter_bounds", + "I4SourceEndpointEstimates.sourceEndpointLaw_weight_square_integrable", + "I4SourceEndpointEstimates.sourceEndpointLaw_weight_integrable", + "I4SourceEndpointEstimates.sourcePrescribedPins_tendsto", + "I4SourceEndpointEstimates.sourceEndpoint_weighted_event_bound_of_estimates", + "I4SourceEndpointEstimates.sourceEndpoint_parameter_limits", + "I4SourceEndpointEstimates.sourceEndpoint_uniform_parameter_bounds", + "I4SourceEndpointEstimates.sourceEndpoint_normalizer_floor", + "I4SourceEndpointEstimates.sourceEndpoint_estimates", + "I4SourceEndpointEstimates.sourceEndpoint_estimates_and_weighted_events", + "I4SourceEndpointEstimates.sourcePhysicalEndpointLaw_eq", + "I4SourceEndpointEstimates.sourcePhysicalEndpointLaw_isProbabilityMeasure", + "I4SourceEndpointEstimates.sourcePhysicalEndpointKernel_eventually_hasCondDistrib", + "I4SourceEndpointEstimates.sourcePhysicalEndpointWeightedProbability_eq", + "I4SourceEndpointEstimates.sourcePhysicalEndpoint_estimates_and_weighted_events", + "I4SourceSmoothConditional.exists_measurable_sampleProjection", + "I4SourceSmoothConditional.goodSample_add", + "I4SourceSmoothConditional.goodSample_neg", + "I4SourceSmoothConditional.derivativeCoefficient_weighted_summable", + "I4SourceSmoothConditional.finiteCoefficient_weighted_summable", + "I4SourceSmoothConditional.pinCoefficient_weighted_summable", + "I4SourceSmoothConditional.adjustedCoefficient_weighted_summable", + "I4SourceSmoothConditional.sourceConfluentPinsAt_measurable", + "I4SourceSmoothConditional.sourceAdjustedEndpoints_measurable", + "I4SourceSmoothConditional.pinLift_zero", + "I4SourceSmoothConditional.pinLift_add", + "I4SourceSmoothConditional.pinLift_neg", + "I4SourceSmoothConditional.pinLift_goodSample", + "I4SourceSmoothConditional.pinLift_measurable", + "I4SourceSmoothConditional.addLift_val", + "I4SourceSmoothConditional.addLift_measurable", + "I4SourceSmoothConditional.posteriorSample_val", + "I4SourceSmoothConditional.posteriorSample_measurable", + "I4SourceSmoothConditional.scalarSeries_add_finiteShift", + "I4SourceSmoothConditional.sourceConfluentPinsAt_addLift", + "I4SourceSmoothConditional.sourceAdjustedEndpoints_addLift", + "I4SourceSmoothConditional.sourceConfluentPinsAt_posteriorSample", + "I4SourceSmoothConditional.sourceAdjustedEndpoints_posteriorSample", + "I4SourceSmoothConditional.sourceSmoothKernel_isMarkov", + "I4SourceSmoothConditional.sourceSmoothKernel_measurable", + "I4SourceSmoothConditional.sourceSmoothKernel_apply", + "I4SourceSmoothConditional.sourceSmoothKernel_pin_map", + "I4SourceSmoothConditional.sourceSmoothKernel_pin_fiber", + "I4SourceSmoothConditional.sourceSmoothKernel_endpoint_map", + "I4SourceSmoothConditional.scalarSeries_finite_hasGaussianLaw", + "I4SourceSmoothConditional.scalarSeries_single", + "I4SourceSmoothConditional.scalarSeries_coordinate_covariance", + "I4SourceSmoothConditional.pin_coefficient_covariance", + "I4SourceSmoothConditional.pin_finite_coefficients_hasGaussianLaw", + "I4SourceSmoothConditional.finiteLift_apply", + "I4SourceSmoothConditional.pin_residual_finite_hasGaussianLaw", + "I4SourceSmoothConditional.coefficient_hasGaussianLaw", + "I4SourceSmoothConditional.residualCoefficient_zero_covariance", + "I4SourceSmoothConditional.residualCoefficient_finite_indepFun", + "I4SourceSmoothConditional.residualCoefficient_indepFun", + "I4SourceSmoothConditional.sourceNormalizedEndpoints_measurable", + "I4SourceSmoothConditional.sourceSmoothKernel_physical_endpoint_map", + "I4SourceSmoothConditional.sourceSmoothKernel_physical_prescribed_map", + "I4SourceSmoothConditional.posteriorSample_self", + "I4SourceSmoothConditional.posteriorSample_eq_addLift_residual", + "I4SourceSmoothConditional.addLift_observation_residual", + "I4SourceSmoothConditional.posteriorSample_zero_inclusion", + "I4SourceSmoothConditional.posteriorSample_zero_indepFun", + "I4SourceSmoothConditional.sourceSmoothKernel_hasCondDistrib", + "I4SourceSmoothConditional.sourceSmoothKernel_map_hasCondDistrib", + "I4SourceSmoothConditional.smoothSourceField_measurable", + "I4SourceSmoothConditional.sourceSmoothKernel_field_hasCondDistrib", + "I4SourceSmoothConditional.sourceSmoothKernel_eventually_hasCondDistrib", + "I4SourceSmoothConditional.sourceSmoothKernel_eventually_map_hasCondDistrib", + "I4SourceSmoothPalm.withDensity_map_comp", + "I4SourceSmoothPalm.prwMeasure_map_comp", + "I4SourceSmoothPalm.prwMeasure_absolutelyContinuous", + "I4SourceSmoothPalm.prwMeasure_ae_of_ae", + "I4SourceSmoothPalm.prwMeasure_ae_weight_pos", + "I4SourceSmoothPalm.sourceSmoothLaw_isProbabilityMeasure", + "I4SourceSmoothPalm.rawPins_prescribed_iff", + "I4SourceSmoothPalm.sourceSmoothLaw_raw_pin_fiber", + "I4SourceSmoothPalm.sourceRawPins_measurable", + "I4SourceSmoothPalm.sourceSmoothLaw_raw_pin_fiber_ae", + "I4SourceSmoothPalm.raw_pin_fiber_of_absolutelyContinuous", + "I4SourceSmoothPalm.prwMeasure_raw_pin_fiber", + "I4SourceSmoothPalm.sourceRawHM_eq_normalized", + "I4SourceSmoothPalm.sourceRawHS_eq_normalized", + "I4SourceSmoothPalm.sourceSmoothWeight_eq", + "I4SourceSmoothPalm.sourceSmoothWeight_nonneg", + "I4SourceSmoothPalm.sourceSmoothWeight_measurable", + "I4SourceSmoothPalm.sourceSmoothWeight_pos_iff", + "I4SourceSmoothPalm.sourceSmoothTyped_measurableSet", + "I4SourceSmoothPalm.sourceSmoothLaw_endpoint_hasLaw", + "I4SourceSmoothPalm.sourceSmoothLaw_weight_square_integrable", + "I4SourceSmoothPalm.sourceSmoothLaw_weight_integral", + "I4SourceSmoothPalm.sourceSmoothLaw_weight_square_integral", + "I4SourceSmoothPalm.sourceSmoothWeightedLaw_endpoint_map", + "I4SourceSmoothPalm.sourceSmooth_weighted_event_bound_of_estimates", + "I4SourceSmoothPalm.sourceSmoothWeightedLaw_typed", + "I4SourceSmoothPalm.sourceSmoothWeightedLaw_raw_pins", + "I4SourceSmoothPalm.sourceSmoothPalm_estimates", + "I4GaussianMajorant.standardAbsMoment_integrable", + "I4GaussianMajorant.weightedAbsSeries_nonneg", + "I4GaussianMajorant.weightedAbsSeries_measurable", + "I4GaussianMajorant.weightedAbsSeries_memLp_bound", + "I4GaussianMajorant.weightedAbsSeries_ae_summable", + "I4GaussianMajorant.weightedAbsSeries_moment", + "I4GaussianMajorant.weightedAbsSeries_exp_bound", + "I4GaussianMajorant.weightedAbsSeries_upper_tail", + "I4SourceConditionalMajorant.sampleMajorant_nonneg", + "I4SourceConditionalMajorant.derivativeMajorant_weighted_summable", + "I4SourceConditionalMajorant.confluentMajorant_weighted_summable", + "I4SourceConditionalMajorant.pinCoefficient_abs_le", + "I4SourceConditionalMajorant.sourceConfluentPins_abs_le", + "I4SourceConditionalMajorant.pinLift_abs_le", + "I4SourceConditionalMajorant.posterior_sampleMajorant_le", + "I4SourceConditionalMajorant.sourceInverse_prescribed_uniform_bounds", + "I4SourceConditionalMajorant.smoothSourceField_global_derivative_bound", + "I4SourceConditionalMajorant.sampleMajorant_measurable", + "I4SourceConditionalMajorant.sourceDerivativeMajorant_measurable", + "I4SourceConditionalMajorant.sampleMajorant_add", + "I4SourceConditionalMajorant.sampleMajorant_const_mul", + "I4SourceConditionalMajorant.sourceDerivativeMajorant_uniform_domination", + "I4SourceConditionalMajorant.source_coordinate_hasLaw", + "I4SourceConditionalMajorant.sampleMajorant_prior_moment", + "I4SourceConditionalMajorant.sourceConditionalDerivative_moments", + "I4SourceConditionalMajorant.sourceConditionalDerivative_cutoff_tail", + "I4SourceConditionalMajorant.sourceConditionalDerivative_gaussian_upper_tail", + "I4SourceConditionalMajorant.sourceWeightedDerivative_cutoff_tail", + "I4PeanoErrorBounds.abs_weighted_integral_le", + "I4PeanoErrorBounds.abs_weighted_integral_sub_mass_le", + "I4PeanoErrorBounds.peanoCubic_nonneg", + "I4PeanoErrorBounds.scaled_lipschitz_center_error", + "I4PeanoErrorBounds.cubic_pin_pointwise_error", + "I4PeanoErrorBounds.left_weighted_error", + "I4PeanoErrorBounds.right_weighted_error", + "I4SourcePinCurvatureBounds.sourceQ_eq_sourceContactQ", + "I4SourcePinCurvatureBounds.sourceA_eq_sourceContactA", + "I4SourcePinCurvatureBounds.sourceDerivativeMajorant_nonneg", + "I4SourcePinCurvatureBounds.sourceGammaRadius_measurable", + "I4SourcePinCurvatureBounds.one_le_sourceGammaRadius", + "I4SourcePinCurvatureBounds.sourceGammaRadius_nonneg", + "I4SourcePinCurvatureBounds.sourceDerivativeMajorant_le_radius", + "I4SourcePinCurvatureBounds.orderModeBound_mono", + "I4SourcePinCurvatureBounds.sourceDerivativeMajorant_mono", + "I4SourcePinCurvatureBounds.sourceGammaRadius_le_fifth", + "I4SourcePinCurvatureBounds.sourceGammaRadius_moments", + "I4SourcePinCurvatureBounds.directionX_norm_le_one", + "I4SourcePinCurvatureBounds.directionY_norm_le_one", + "I4SourcePinCurvatureBounds.axis_point_sub_norm_le", + "I4SourcePinCurvatureBounds.axis_derivative_lipschitz", + "I4SourcePinCurvatureBounds.source_axis_derivative_abs_le", + "I4SourcePinCurvatureBounds.sourceF_third_continuous", + "I4SourcePinCurvatureBounds.sourceH_second_continuous", + "I4SourcePinCurvatureBounds.sourceF_third_lipschitz", + "I4SourcePinCurvatureBounds.sourceH_second_lipschitz", + "I4SourcePinCurvatureBounds.sourceQCurve_lipschitz", + "I4SourcePinCurvatureBounds.sourceF_third_abs_le", + "I4SourcePinCurvatureBounds.sourceH_second_abs_le", + "I4SourcePinCurvatureBounds.sourceQCurve_abs_le", + "I4SourcePinCurvatureBounds.sourceF_C3", + "I4SourcePinCurvatureBounds.sourceH_C2", + "I4SourcePinCurvatureBounds.sourceF_deriv", + "I4SourcePinCurvatureBounds.sourceF_second", + "I4SourcePinCurvatureBounds.sourceH_deriv", + "I4SourcePinCurvatureBounds.sourceH_second_zero", + "I4SourcePinCurvatureBounds.source_pin3_eq", + "I4SourcePinCurvatureBounds.source_pin4_eq", + "I4SourcePinCurvatureBounds.source_pin5_eq", + "I4SourcePinCurvatureBounds.source_normalized_peano", + "I4SourcePinCurvatureBounds.endpoint_det_abs_le", + "I4SourcePinCurvatureBounds.endpointWeight_curvature_le", + "I4SourcePinCurvatureBounds.strict_endpoint_transverse_neg", + "I4SourcePinCurvatureBounds.curvature_slab_of_upper", + "I4SourcePinCurvatureBounds.sourceQCurve_zero", + "I4SourcePinCurvatureBounds.sourceQ_abs_le", + "I4SourcePinCurvatureBounds.sourceA_abs_le", + "I4SourcePinCurvatureBounds.source_normalized_endpoint_errors", + "I4SourcePinCurvatureBounds.sourceGammaRadius_ge_third_fourth", + "I4SourcePinCurvatureBounds.source_normalized_endpoint_first_four_bounds", + "I4SourcePinCurvatureBounds.sourceQ_measurable", + "I4SourcePinCurvatureBounds.sourceA_measurable", + "I4SourcePinCurvatureBounds.source_normalized_determinant_bounds", + "I4SourcePinCurvatureBounds.sourceSmoothWeight_curvature_bound", + "I4SourcePinCurvatureBounds.source_positive_weight_curvature_upper", + "I4SourcePinCurvatureBounds.source_bad_curvature_slab", + "I4SourcePinCurvatureBounds.source_prescribed_pin_constraints_ae", + "I4SourcePinCurvatureBounds.sourceSmoothLaw_curvature_bound_ae", + "I4SourcePinCurvatureBounds.source_curvature_estimates", + "I4SourcePinCurvatureBounds.source_normalized_endpoint_errors_all", + "I4SourcePinCurvatureBounds.sourceSmoothLaw_endpoint_errors_ae", + "I4SourcePinCurvatureBounds.source_endpoint_error_estimates", + "I4ScalarProductCurvature.regular_bounds", + "I4ScalarProductCurvature.scalar_product_tube_integral_bound", + "I4ScalarProductCurvature.scalar_product_regular_integral_bound", + "I4SourceCurvatureDecomposition.curvatureCoefficient_summable", + "I4SourceCurvatureDecomposition.sourceContactQ_series", + "I4SourceCurvatureDecomposition.curvatureCoefficient_weighted_summable", + "I4SourceCurvatureDecomposition.curvatureCross_coefficient", + "I4SourceCurvatureDecomposition.curvatureVariance_prior_coefficient", + "I4SourceCurvatureDecomposition.curvatureResidualCoefficient_summable", + "I4SourceCurvatureDecomposition.curvatureDirection_summable", + "I4SourceCurvatureDecomposition.curvatureBeta_normal", + "I4SourceCurvatureDecomposition.curvatureResidual_pin_orthogonal", + "I4SourceCurvatureDecomposition.curvatureResidual_q_pairing", + "I4SourceCurvatureDecomposition.curvatureResidual_normSquared", + "I4SourceCurvatureDecomposition.curvatureDirection_pin_orthogonal", + "I4SourceCurvatureDecomposition.curvatureSigma_pos", + "I4SourceCurvatureDecomposition.curvatureSigma_sq", + "I4SourceCurvatureDecomposition.curvatureDirection_normSquared", + "I4SourceCurvatureDecomposition.curvatureDirection_q_pairing", + "I4SourceCurvatureDecomposition.curvatureResidualCoefficient_weighted_summable", + "I4SourceCurvatureDecomposition.curvatureDirection_weighted_summable", + "I4SourceCurvatureDecomposition.curvatureZ_eq", + "I4SourceCurvatureDecomposition.unitDirection_measurable", + "I4SourceCurvatureDecomposition.unitDirection_hasLaw", + "I4SourceCurvatureDecomposition.unitDirection_coefficient_covariance", + "I4SourceCurvatureDecomposition.unitDirectionCoefficientResidual_zero_covariance", + "I4SourceCurvatureDecomposition.unitDirection_finiteCoefficients_hasGaussianLaw", + "I4SourceCurvatureDecomposition.finiteDirectionLift_apply", + "I4SourceCurvatureDecomposition.unitDirection_finiteResidual_hasGaussianLaw", + "I4SourceCurvatureDecomposition.unitDirection_scalar_finiteResidual_hasGaussianLaw", + "I4SourceCurvatureDecomposition.unitDirectionCoefficientResidual_finite_indepFun", + "I4SourceCurvatureDecomposition.unitDirectionCoefficientResidual_indepFun", + "I4SourceCurvatureDecomposition.regularizedCurvatureCross_continuous", + "I4SourceCurvatureDecomposition.regularizedCurvatureCross_zero", + "I4SourceCurvatureDecomposition.curvatureCross_tendsto", + "I4SourceCurvatureDecomposition.curvaturePinInverse_tendsto", + "I4SourceCurvatureDecomposition.curvatureBeta_tendsto", + "I4SourceCurvatureDecomposition.curvatureVariance_tendsto", + "I4SourceCurvatureDecomposition.curvatureMean_prescribed_tendsto", + "I4SourceCurvatureDecomposition.curvature_uniform_parameter_bounds", + "I4SourceCurvatureDecomposition.curvatureZ_measurable", + "I4SourceCurvatureDecomposition.sourceContactQ_measurable", + "I4SourceCurvatureDecomposition.curvatureZ_hasLaw", + "I4SourceCurvatureDecomposition.curvatureDirection_goodSample", + "I4SourceCurvatureDecomposition.curvatureShift_val", + "I4SourceCurvatureDecomposition.curvatureShift_measurable", + "I4SourceCurvatureDecomposition.curvatureResidualSample_measurable", + "I4SourceCurvatureDecomposition.curvatureResidualLaw_isProbabilityMeasure", + "I4SourceCurvatureDecomposition.sourceConfluentPinsAt_curvatureShift", + "I4SourceCurvatureDecomposition.sourceContactQ_curvatureShift", + "I4SourceCurvatureDecomposition.curvatureZ_curvatureShift", + "I4SourceCurvatureDecomposition.curvatureResidualSample_pins", + "I4SourceCurvatureDecomposition.curvatureResidualSample_Z", + "I4SourceCurvatureDecomposition.curvatureResidualSample_inclusion", + "I4SourceCurvatureDecomposition.curvatureResidualSample_indepFun", + "I4SourceCurvatureDecomposition.curvatureResidualSample_joint_map", + "I4SourceCurvatureDecomposition.sourceContactQ_posteriorSample", + "I4SourceCurvatureDecomposition.sourceContactQ_posteriorSample_Z", + "I4SourceCurvatureDecomposition.sourceContactQ_posteriorResidual", + "I4SourceCurvatureDecomposition.curvaturePosterior_reconstruction", + "I4SourceCurvatureDecomposition.curvatureReconstruct_measurable", + "I4SourceCurvatureDecomposition.curvatureReconstruct_pins", + "I4SourceCurvatureDecomposition.curvatureReconstruct_Q", + "I4SourceCurvatureDecomposition.curvatureReconstruct_residual_image", + "I4SourceCurvatureDecomposition.curvatureDirectionEnvelope_nonneg", + "I4SourceCurvatureDecomposition.curvatureDirectionEnvelope_summable", + "I4SourceCurvatureDecomposition.curvatureDirectionEnvelope_weighted_summable", + "I4SourceCurvatureDecomposition.curvatureDirection_envelope_at", + "I4SourceCurvatureDecomposition.curvatureDirection_uniform_envelope", + "I4SourceCurvatureDecomposition.curvatureAffine_gaussian", + "I4SourceCurvatureDecomposition.curvatureResidual_curvature_joint_map", + "I4SourceCurvatureDecomposition.sourceSmoothKernel_eq_curvatureProduct", + "I4SourceCurvatureDecomposition.sourceSmoothKernel_eq_curvatureProduct_swap", + "I4GaussianVarianceFloor.gaussianPDFReal_le_of_variance_floor", + "I4GaussianVarianceFloor.gaussianReal_interval_mass_le_of_variance_floor", + "I4SourceCurvatureDecomposition.curvatureScalarLaw_isProbabilityMeasure", + "I4SourceCurvatureDecomposition.curvatureReconstruct_swap_measurable", + "I4SourceCurvatureDecomposition.curvatureReconstruct_hasLaw", + "I4SourceCurvatureDecomposition.curvatureScalarLaw_interval_mass_uniform", + "I4SourceCurvatureDecomposition.sourceSmoothKernel_eventually_curvatureProduct", + "I4SourceCurvatureDecomposition.curvatureResidualRadius_measurable", + "I4SourceCurvatureDecomposition.one_le_curvatureResidualRadius", + "I4SourceCurvatureDecomposition.sourceContactQ_posterior_abs_le_radius", + "I4SourceCurvatureDecomposition.curvatureEnvelopeTotal_nonneg", + "I4SourceCurvatureDecomposition.sourceDerivativeMajorant_curvatureShift", + "I4SourceCurvatureDecomposition.sourceGammaRadius_curvatureShift", + "I4SourceCurvatureDecomposition.sourceDerivativeMajorant_curvatureReconstruct", + "I4SourceCurvatureDecomposition.sourceGammaRadius_curvatureReconstruct", + "I4SourceCurvatureDecomposition.curvaturePosterior_residual_eq_shift", + "I4SourceCurvatureDecomposition.curvatureResidualRadius_image_bound", + "I4SourceCurvatureDecomposition.curvatureResidualRadius_moment_bound", + "I4SourceCurvatureDecomposition.curvatureResidualRadius_uniform_bounds", + "I4SourceCurvatureDecomposition.curvatureReconstruct_joint_measurable", + "I4SourceCurvatureDecomposition.curvaturePin_finiteCoefficients_hasGaussianLaw", + "I4SourceWeightedCurvature.sourceRegularityBad_measurable", + "I4SourceWeightedCurvature.sourceRegularityBad_base_bound", + "I4SourceWeightedCurvature.sourceRegularityBad_weighted_cubic", + "I4SourceWeightedCurvature.sourceQ_measurable_actual", + "I4SourceWeightedCurvature.sourceCurvatureSlab_measurable", + "I4SourceWeightedCurvature.sourceRegularCurvatureSlab_measurable", + "I4SourceWeightedCurvature.sourceCurvatureOneSided_measurable", + "I4SourceWeightedCurvature.sourceRegularCurvatureSlab_weighted_of_numerator", + "I4SourceWeightedCurvature.sourceCurvatureUnion_reduce", + "I4SourceWeightedCurvature.sourceRegularCurvatureSlab_numerator_of_product", + "I4SourceWeightedCurvature.sourceCurvatureUnion_weighted_cubic_of_numerator", + "I4SourceWeightedCurvature.sourceRegularCurvatureSlab_numerator", + "I4SourceWeightedCurvature.sourceWeightedCurvature_bound", + "I4SourceWeightedCurvature.sourceWeightedCurvature_slab_bound", + "I4ActualQuarticTransfer.peanoCubic_first_moment", + "I4ActualQuarticTransfer.peanoCubic_normalized_second_moment", + "I4ActualQuarticTransfer.symmetric_cubic_pin_second_order", + "I4ActualQuarticTransfer.endpoint_taylor_low_coefficients", + "I4ActualQuarticTransfer.corrected_axial_constant", + "I4ActualQuarticTransfer.scalar_taylor_remainder", + "I4ActualQuarticTransfer.scalarTaylor_one", + "I4ActualQuarticTransfer.scalarTaylor_three", + "I4ActualQuarticTransfer.scalarTaylor_two", + "I4ActualQuarticTransfer.scalar_taylor_one_bound", + "I4ActualQuarticTransfer.scalar_taylor_three_bound", + "I4ActualQuarticTransfer.scalar_taylor_two_bound", + "I4ActualQuarticTransfer.smooth_iteratedDeriv", + "I4ActualQuarticTransfer.iteratedDeriv_iteratedDeriv", + "I4ActualQuarticTransfer.sourceF_smooth", + "I4ActualQuarticTransfer.sourceH_smooth", + "I4ActualQuarticTransfer.sourceF_iteratedDeriv_abs_le", + "I4ActualQuarticTransfer.sourceH_iteratedDeriv_abs_le", + "I4SourcePinPreservingQuartic.pi_norm_le_euclidean_norm", + "I4SourcePinPreservingQuartic.euclidean_two_norm_sq", + "I4SourcePinPreservingQuartic.euclidean_two_norm_le_abs_sum", + "I4SourcePinPreservingQuartic.euclidean_two_norm_le_two_mul", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_apply", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_norm_le_of_sqsum", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_norm_le_two_mul", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_offdiag_norm_le", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_symmetric_norm_le_abs_sum", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_symmetric_norm_le_three_mul", + "I4SourcePinPreservingQuartic.line_iteratedDeriv", + "I4SourcePinPreservingQuartic.derivativeComponent_smooth", + "I4SourcePinPreservingQuartic.derivativeComponent_iteratedFDeriv", + "I4SourcePinPreservingQuartic.line_gradient_iteratedDeriv", + "I4SourcePinPreservingQuartic.source_derivative_abs_le", + "I4SourcePinPreservingQuartic.source_line_gradient_taylor", + "I4SourcePinPreservingQuartic.modeCoefficient_analytic_order", + "I4SourcePinPreservingQuartic.source_derivative_comp_perm", + "I4SourcePinPreservingQuartic.source_axial_third_error", + "I4SourcePinPreservingQuartic.source_low_pin_coefficients", + "I4SourcePinPreservingQuartic.coordinateDirection_zero", + "I4SourcePinPreservingQuartic.coordinateDirection_one", + "I4SourcePinPreservingQuartic.hessianMatrix_apply", + "I4SourcePinPreservingQuartic.coordinate_decomposition", + "I4SourcePinPreservingQuartic.hasFDerivAt_gradientEuclidean", + "I4SourcePinPreservingQuartic.gradientEuclidean_eq_components", + "I4SourcePinPreservingQuartic.hasFDerivAt_scaledGradientEuclidean", + "I4SourcePinPreservingQuartic.scaledGradientEuclidean_eq_components", + "I4SourcePinPreservingQuartic.hessianEntry_eq_derivativeComponent", + "I4SourcePinPreservingQuartic.hessianEntry_smooth", + "I4SourcePinPreservingQuartic.line_hessian_iteratedDeriv", + "I4SourcePinPreservingQuartic.source_line_hessian_taylor", + "I4SourcePinPreservingQuartic.one_le_quarticFstar", + "I4SourcePinPreservingQuartic.quarticWidth_pos", + "I4SourcePinPreservingQuartic.cutoff_raw_regularity", + "I4SourcePinPreservingQuartic.cutoff_scaled_error_budget", + "I4SourcePinPreservingQuartic.cutoff_adaptive_tolerance", + "I4SourcePinPreservingQuartic.cutoff_quarticWidth_tolerance", + "I4SourcePinPreservingQuartic.cutoff_curvature_threshold", + "I4SourcePinPreservingQuartic.certificate_width_geometry", + "I4SourcePinPreservingQuartic.source_origin_derivative_abs_le", + "I4SourcePinPreservingQuartic.sourceRawU_abs_le", + "I4SourcePinPreservingQuartic.sourceRawRadius_one_le", + "I4SourcePinPreservingQuartic.sourceRawRadius_le_majorants", + "I4SourcePinPreservingQuartic.sourceRawRadius_le_global", + "I4SourcePinPreservingQuartic.sourcePhysicalPins_ae", + "I4SourcePinPreservingQuartic.sourcePhysicalPins_eventually", + "I4SourcePinPreservingQuartic.sourceScaledGradient_eq", + "I4SourcePinPreservingQuartic.sourceScaledGradient_hasFDerivAt", + "I4SourcePinPreservingQuartic.source_third_ppx_expansion", + "I4SourcePinPreservingQuartic.source_third_ppy_expansion", + "I4SourcePinPreservingQuartic.source_fourth_pppx_expansion", + "I4SourcePinPreservingQuartic.source_fourth_pppy_expansion", + "I4SourcePinPreservingQuartic.source_second_p_basis", + "I4SourcePinPreservingQuartic.source_third_p_basis_basis", + "I4SourcePinPreservingQuartic.source_fourth_pp_basis_basis", + "I4SourcePinPreservingQuartic.hasFDerivAt_pinPreservingQuartic", + "I4SourcePinPreservingQuartic.fderiv_pinPreservingQuartic", + "I4SourcePinPreservingQuartic.sourceGradientTaylorRaw_sub_quartic_zero", + "I4SourcePinPreservingQuartic.sourceGradientTaylorRaw_sub_quartic_one", + "I4SourcePinPreservingQuartic.sourceHessianTaylor_sub_quarticJacobian", + "I4SourcePinPreservingQuartic.matrixLinearEuclidean_sub", + "I4SourcePinPreservingQuartic.coordinateDirection_norm_le_one", + "I4SourcePinPreservingQuartic.sourceScaledGradientRaw_apply", + "I4SourcePinPreservingQuartic.source_scaled_gradient_taylor_coordinate_error", + "I4SourcePinPreservingQuartic.source_scaled_gradient_taylor_error", + "I4SourcePinPreservingQuartic.source_scaled_hessian_taylor_coordinate_error", + "I4SourcePinPreservingQuartic.source_scaled_hessian_taylor_error", + "I4SourcePinPreservingQuartic.coefficient_vector_error_le", + "I4SourcePinPreservingQuartic.coefficient_matrix_error_le", + "I4SourcePinPreservingQuartic.sourceGradientTaylor_quartic_error_le", + "I4SourcePinPreservingQuartic.sourceHessianTaylor_quartic_error_le", + "I4SourcePinPreservingQuartic.sourceScaledPotential_hasGradientAt", + "I4SourcePinPreservingQuartic.sourceScaledGradient_eq_gradient", + "I4SourcePinPreservingQuartic.sourceScaledGradient_smooth", + "I4SourcePinPreservingQuartic.pinPreservingQuartic_pins", + "I4SourcePinPreservingQuartic.sourceScaledGradient_pins", + "I4SourcePinPreservingQuartic.sourceQuartic_value_comparison", + "I4SourcePinPreservingQuartic.sourceQuartic_operator_comparison", + "I4SourcePinPreservingQuartic.sourceQuartic_C1_comparison", + "I4SourcePinPreservingQuartic.sourceQuartic_cutoff_tolerance", + "I4SourcePinPreservingQuartic.sourceQuartic_curvature_threshold", + "I4SourcePinPreservingQuartic.sourceQuartic_C1_comparison_ae", + "I4SourcePinPreservingQuartic.sourceQuartic_C1_estimates", + "I4SourcePinPreservingQuartic.sourceRawU_abs_le_radius", + "I4SourcePinPreservingQuartic.sourceQuartic_Fstar_le_radius", + "I4SourcePinPreservingQuartic.sourceQuartic_width_size", + "I4SourcePinPreservingQuartic.sourceQuartic_width_geometry", + "I4SourcePinPreservingQuartic.quartic_strip_in_ball_two", + "I4SourcePinPreservingQuartic.quartic_endpoint_ball_in_ball_two", + "I4SourcePinPreservingQuartic.quartic_axis_endpoint_norm", + "I4SourcePinPreservingQuartic.sourceQuartic_cutoff_estimates", + "I4SourcePinPreservingQuartic.sourceQuartic_weighted_C1_estimates", + "I4SourcePinPreservingQuartic.sourceQuartic_weighted_cutoff_estimates", + "I4SourceSmoothTopology.modeCoefficient_contDiff", + "I4SourceSmoothTopology.modeDerivativeBCF_norm_le", + "I4SourceSmoothTopology.sourceDerivativeBCF_summable", + "I4SourceSmoothTopology.sourceDerivativeBCF_apply", + "I4SourceSmoothTopology.stronglyMeasurable_of_countable_hasSum", + "I4SourceSmoothTopology.sourceDerivativeBCF_stronglyMeasurable", + "I4SourceSmoothTopology.sourceDerivativeBCF_borel", + "I4SourceSmoothTopology.sourceFiniteJet_stronglyMeasurable", + "I4SourceSmoothTopology.sourceFiniteJet_borel", + "I4SourceSmoothTopology.modeDerivativeBCF_apply", + "I4SourceSmoothTopology.sourceDerivativeBCF_tendstoUniformly", + "I4SourceSmoothTopology.jetRestriction_continuous", + "I4SourceSmoothTopology.jetRestriction_norm_le", + "I4SourceSmoothTopology.sourceRestrictedJet_apply", + "I4SourceSmoothTopology.sourceRestrictedJet_stronglyMeasurable", + "I4SourceSmoothTopology.sourceRestrictedJet_borel", + "I4SourceSmoothTopology.sourceFiniteJet_dist_le_iff", + "I4SourceSmoothTopology.sourceFiniteJet_eq_iff_field_eq", + "I4SourceSmoothTopology.smoothSourceField_lattice_periodic", + "I4SourceSmoothTopology.sourceDerivativeBCF_lattice_periodic", + "I4SourceSmoothTopology.sourceFiniteJet_mem_compatible", + "I4SourceSmoothTopology.compatiblePeriodicJets_witness_unique", + "I4SourceSmoothTopology.derivativeMeasurableSpace", + "I4SourceSmoothTopology.derivativeBorelSpace", + "I4SourceSmoothTopology.finiteJetMeasurableSpace", + "I4SourceSmoothTopology.finiteJetBorelSpace", + "I4SourceSmoothTopology.sourceCompatibleJet_measurable", + "I4SourceSmoothTopology.sourceCompatibleJet_borel", + "I4SourceSmoothTopology.sourceDerivativeBCF_hasCondDistrib", + "I4SourceSmoothTopology.sourceFiniteJet_hasCondDistrib", + "I4SourceSmoothTopology.sourceCompatibleJet_hasCondDistrib", + "I4SourceSmoothTopology.sourceFiniteJet_functional_hasCondDistrib", + "I4SourceSmoothTopology.sourceDerivativeBCF_functional_hasCondDistrib", + "I4SourceSmoothTopology.sourceCompatibleJet_functional_hasCondDistrib", + "I4SourceSmoothTopology.sourceDerivativeBCF_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceFiniteJet_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceCompatibleJet_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceFiniteJet_functional_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceDerivativeBCF_functional_eventually_hasCondDistrib", + "I4SourceSmoothTopology.sourceCompatibleJet_functional_eventually_hasCondDistrib", + "I4SourceRawPinConditioning.rawPinCoefficient_summable", + "I4SourceRawPinConditioning.rawPins_series", + "I4SourceRawPinConditioning.rawPins_measurable", + "I4SourceRawPinConditioning.rawPinCovariance_coefficient", + "I4SourceRawPinConditioning.confluentMatrix_mulVec", + "I4SourceRawPinConditioning.confluentMatrix_isUnit", + "I4SourceRawPinConditioning.pinCoefficient_eq_confluentMatrix", + "I4SourceRawPinConditioning.sourceConfluentPinsAt_eq_matrix", + "I4SourceRawPinConditioning.rawPinCovariance_congruence", + "I4SourceRawPinConditioning.rawPinCovariance_isUnit", + "I4SourceRawPinConditioning.rawPinLift_goodSample", + "I4SourceRawPinConditioning.rawPinLift_measurable", + "I4SourceRawPinConditioning.pinLift_confluent_eq_raw", + "I4SourceRawPinConditioning.rawPosteriorSample_val", + "I4SourceRawPinConditioning.rawPosteriorSample_measurable", + "I4SourceRawPinConditioning.rawPosteriorSample_eq_posteriorSample", + "I4SourceRawPinConditioning.rawPinKernel_isMarkov", + "I4SourceRawPinConditioning.rawPinKernel_apply", + "I4SourceRawPinConditioning.rawPinKernel_eq_confluent", + "I4SourceRawPinConditioning.rawPinKernel_eq_comap", + "I4SourceRawPinConditioning.rawPosteriorSample_rawPins", + "I4SourceRawPinConditioning.rawPinKernel_pin_map", + "I4SourceRawPinConditioning.rawPinKernel_pin_fiber", + "I4SourceRawPinConditioning.rawPinKernel_hasCondDistrib", + "I4SourceRawPinConditioning.rawPinKernel_map_hasCondDistrib", + "I4SourceRawPinConditioning.rawPinCovariance_eventually_isUnit", + "I4SourceRawPinConditioning.rawPinKernel_eventually_hasCondDistrib", + "I4SourceRawPinConditioning.rawPinKernel_prescribed", + "I4SourceRawPinConditioning.rawPrescribedWeightedMeasure_eq", + "I4SourceRawPinConditioning.rawPrescribedWeightedMeasure_estimates", + "I4QuarticCaptureAlgebra.rawRadius_one_le", + "I4QuarticCaptureAlgebra.rawRadius_pos", + "I4QuarticCaptureAlgebra.rawRadius_sum_abs_eq", + "I4QuarticCaptureAlgebra.rawRadius_coord_abs_le_sub_one", + "I4QuarticCaptureAlgebra.rawRadius_coord_abs_le", + "I4QuarticCaptureAlgebra.captureWidth_pos", + "I4QuarticCaptureAlgebra.captureFstar_le_radius", + "I4QuarticCaptureAlgebra.captureWidth_radius_le", + "I4QuarticCaptureAlgebra.captureWidth_le", + "I4QuarticCaptureAlgebra.captureWidth_le_one_sixteenth", + "I4QuarticCaptureAlgebra.captureWidth_radius_le_one_sixtyfourth", + "I4QuarticCaptureAlgebra.capture_r_le_width", + "I4QuarticCaptureAlgebra.captureSigma_pos", + "I4QuarticCaptureAlgebra.captureSigma_le", + "I4QuarticCaptureAlgebra.four_captureWidth_le_captureSigma", + "I4QuarticCaptureAlgebra.quartic_transverse_forcing_bound", + "I4QuarticCaptureAlgebra.quartic_transverse_remainder_bound", + "I4QuarticCaptureAlgebra.quartic_axial_remainder_bound", + "I4QuarticCaptureAlgebra.quartic_strip_upper", + "I4QuarticCaptureAlgebra.quartic_strip_lower", + "I4QuarticCaptureAlgebra.quartic_central_transit", + "I4QuarticCaptureAlgebra.euclidean_component_error_le", + "I4QuarticCaptureAlgebra.capture_strip_in_ball_two", + "I4QuarticCaptureAlgebra.source_component_error_le", + "I4QuarticCaptureAlgebra.source_actual_strip_gates", + "I4QuarticCaptureAlgebra.source_actual_central_gate", + "I4QuarticCaptureAlgebra.source_actual_gates_estimates", + "I4QuarticCaptureAlgebra.source_actual_weighted_gates_estimates", + "I4ActualSourceMorse.incidence_noninjective_of_normal_equations", + "I4ActualSourceMorse.incidence_det_eq_zero_of_normal_equations", + "I4ActualSourceMorse.twoChannelIncidence_hasFDerivAt", + "I4ActualSourceMorse.twoChannelIncidence_differentiableAt", + "I4ActualSourceMorse.twoChannelIncidence_critical_identity", + "I4ActualSourceMorse.channelDiagonal_injective", + "I4ActualSourceMorse.twoChannelGradientFamily_hasFDerivAt", + "I4ActualSourceMorse.twoChannelIncidence_spatial_snd_eq_zero", + "I4ActualSourceMorse.twoChannelIncidence_spatial_normal_equation", + "I4ActualSourceMorse.twoChannelIncidence_eq_of_critical", + "I4ActualSourceMorse.twoChannelDegenerateCriticalParameters_subset_image", + "I4ActualSourceMorse.twoChannelIncidence_det_eq_zero_on_degenerate", + "I4ActualSourceMorse.twoChannelDegenerateIncidence_image_haar_null", + "I4ActualSourceMorse.twoChannelDegenerateCriticalParameters_haar_null", + "I4ActualSourceMorse.channelSwap_involutive", + "I4ActualSourceMorse.channelSwap_gradient_identity", + "I4ActualSourceMorse.channelSwap_image_null", + "I4ActualSourceMorse.gaussian_two_absolutelyContinuous", + "I4ActualSourceMorse.gaussian_four_grouped_absolutelyContinuous", + "I4ActualSourceMorse.four_trigonometric_patches_cover", + "I4ActualSourceMorse.cosineGradientChannel_differentiable", + "I4ActualSourceMorse.sineGradientChannel_differentiable", + "I4ActualSourceMorse.selectedTrigonometricChannel_differentiable", + "I4ActualSourceMorse.unusedTrigonometricChannel_differentiable", + "I4ActualSourceMorse.trigonometricChannelSwap_gradient_function_identity", + "I4ActualSourceMorse.trigonometricDegenerateCriticalParameters_subset_patch_union", + "I4ActualSourceMorse.trigonometricDegenerateCriticalParameters_haar_null", + "I4ActualSourceMorse.trigonometricDegenerateCriticalParameters_gaussian_null", + "I4ActualSourceMorse.eraseCoefficients_measurable", + "I4ActualSourceMorse.eraseSample_measurable", + "I4ActualSourceMorse.actual_derivative_finite_split", + "I4ActualSourceMorse.finite_block_indep_erased", + "I4ActualSourceMorse.finite_block_law", + "I4ActualSourceMorse.actual_finite_block_law", + "I4ActualSourceMorse.actual_finite_block_indep_erased", + "I4ActualSourceMorse.replaceSample_measurable", + "I4ActualSourceMorse.replaceSample_compose", + "I4ActualSourceMorse.replaceSample_read_self", + "I4ActualSourceMorse.replaceSample_reconstruct", + "I4ActualSourceMorse.replaceSample_event_measurable", + "I4ActualSourceMorse.eraseSample_eq_replaceSample_zero", + "I4ActualSourceMorse.replaceSample_read_erased", + "I4ActualSourceMorse.actual_erased_block_joint_map", + "I4ActualSourceMorse.actual_finite_replacement_ae", + "I4ActualSourceMorse.groupFour_measurable", + "I4ActualSourceMorse.groupFour_measurePreserving", + "I4ActualSourceMorse.groupFour_gaussian_measurePreserving", + "I4ActualSourceMorse.actual_four_coordinate_law", + "I4ActualSourceMorse.actualGroupedFour_measurable", + "I4ActualSourceMorse.actualGroupedFour_map_eq", + "I4ActualSourceMorse.actualGroupedFour_measurePreserving", + "I4ActualSourceMorse.compact_positive_iff_dense_nat_floor", + "I4ActualSourceMorse.measurableSet_forall_pos_of_compact", + "I4ActualSourceMorse.measurableSet_forall_mem_pos_of_isCompact", + "I4ActualSourceMorse.sourceDerivative_eval_measurable", + "I4ActualSourceMorse.sourceDerivative_spatial_continuous", + "I4ActualSourceMorse.sourceMorseDiscriminant_eval_measurable", + "I4ActualSourceMorse.sourceMorseDiscriminant_spatial_continuous", + "I4ActualSourceMorse.sourceMorseCube_isCompact", + "I4ActualSourceMorse.sourceMorseCube_event_measurable", + "I4ActualSourceMorse.coordinateGradient_differentiable", + "I4ActualSourceMorse.coordinateGradient_fderiv_apply", + "I4ActualSourceMorse.coordinateGradient_singular_of_hessian_discriminant_zero", + "I4ActualSourceMorse.fourMode_eq", + "I4ActualSourceMorse.sourceContactAmplitude_four_pairs", + "I4ActualSourceMorse.fourModeCoefficient_eq", + "I4ActualSourceMorse.coordinate_cos_hasFDerivAt", + "I4ActualSourceMorse.coordinate_sin_hasFDerivAt", + "I4ActualSourceMorse.fourMode_hasFDerivAt", + "I4ActualSourceMorse.fourGradient_rightInverse", + "I4ActualSourceMorse.fourGradient_surjective", + "I4ActualSourceMorse.fourMode_fderiv", + "I4ActualSourceMorse.fourModePerturbation_hasFDerivAt", + "I4ActualSourceMorse.fourModePerturbation_gradient", + "I4ActualSourceMorse.fourModePerturbation_gradient_surjective", + "I4ActualSourceMorse.fourMode_injective", + "I4ActualSourceMorse.fourAddSample_measurable", + "I4ActualSourceMorse.actual_derivative_fourAdd", + "I4ActualSourceMorse.actual_coordinateGradient_fourAdd", + "I4ActualSourceMorse.fourReindex_measurePreserving", + "I4ActualSourceMorse.fourCoefficientLift_at", + "I4ActualSourceMorse.replaceSample_fourModeSet", + "I4ActualSourceMorse.sourceMorseAmplitude_ne_zero", + "I4ActualSourceMorse.sourceC_ne_zero", + "I4ActualSourceMorse.actual_coordinateGradient_replace", + "I4ActualSourceMorse.morseDirectionX_eq", + "I4ActualSourceMorse.morseDirectionY_eq", + "I4ActualSourceMorse.sourceMorseDiscriminant_nonpos", + "I4ActualSourceMorse.actual_four_replacement_bad_null", + "I4ActualSourceMorse.smoothLaw_ae_sourceMorseCube", + "I4ActualSourceMorse.smoothLaw_ae_sourceMorseCompact", + "I4ActualSourceMorse.smoothLaw_ae_sourceMorse", + "I4ActualSourceMorse.coordinateGradient_det_eq", + "I4ActualSourceMorse.sourceMorseDiscriminant_eq", + "I4ActualSourceMorse.coordinateGradient_contDiff", + "I4ActualSourceMorse.sourceMorse_regular", + "I4ActualSourceMorse.regular_zero_isolated", + "I4ActualSourceMorse.finite_regular_zeros_on_compact", + "I4ActualSourceMorse.smoothLaw_ae_finite_sourceCriticalCube", + "I4SourceSmoothParameterSpace.parameterWeight_nonneg", + "I4SourceSmoothParameterSpace.parameterWeight_mul_abs_summable", + "I4SourceSmoothParameterSpace.weightedCarrier_memℓp", + "I4SourceSmoothParameterSpace.weightedCarrier_apply", + "I4SourceSmoothParameterSpace.weightedCarrier_norm", + "I4SourceSmoothParameterSpace.weightedCarrier_norm_eq_radius_sub_one", + "I4SourceSmoothParameterSpace.weightedCarrier_stronglyMeasurable", + "I4SourceSmoothParameterSpace.weightedCarrier_borel", + "I4SourceSmoothParameterSpace.smoothParameter_complete", + "I4SourceSmoothParameterSpace.smoothParameter_separable", + "I4SourceSmoothParameterSpace.smoothParameter_polish", + "I4SourceSmoothParameterSpace.parameterWeight_pos", + "I4SourceSmoothParameterSpace.parameterWeight_dominates", + "I4SourceSmoothParameterSpace.parameter_abs_summable", + "I4SourceSmoothParameterSpace.weighted_mode_derivative_bound", + "I4SourceSmoothParameterSpace.weightedFourierField_contDiff", + "I4SourceSmoothParameterSpace.weightedFourierField_derivative", + "I4SourceSmoothParameterSpace.l1Synthesis_norm_le", + "I4SourceSmoothParameterSpace.l1Synthesis_apply", + "I4SourceSmoothParameterSpace.l1Synthesis_summable", + "I4SourceSmoothParameterSpace.coherentBCFSemi", + "I4SourceSmoothParameterSpace.coherentBCFAdd", + "I4SourceSmoothParameterSpace.coherentBCFModule", + "I4SourceSmoothParameterSpace.coherentJetSemi", + "I4SourceSmoothParameterSpace.coherentJetAdd", + "I4SourceSmoothParameterSpace.coherentJetModule", + "I4SourceSmoothParameterSpace.normalizedModeDerivative_norm_le", + "I4SourceSmoothParameterSpace.parameterDerivativeCLM_norm_le", + "I4SourceSmoothParameterSpace.parameterJetCLM_norm_le", + "I4SourceSmoothParameterSpace.parameterJet_continuous", + "I4SourceSmoothParameterSpace.parameterDerivativeCLM_apply", + "I4SourceSmoothParameterSpace.actual_parameter_field_eq", + "I4SourceSmoothParameterSpace.actual_parameter_jet_eq", + "I4SourceSmoothParameterSpace.weightedFourierField_periodic", + "I4SourceSmoothParameterSpace.parameterField_contDiff", + "I4SourceSmoothParameterSpace.parameterField_derivative", + "I4SourceSmoothParameterSpace.parameterField_actual", + "I4SourceSmoothParameterSpace.parameterField_periodic", + "I4SourceSmoothParameterSpace.parameterJet_norm_le", + "I4SourceSmoothParameterSpace.parameterField_derivative_norm_le", + "I4SourceSmoothParameterSpace.parameterMeasurableSpace", + "I4SourceSmoothParameterSpace.parameterBorelSpace", + "I4SourceSmoothParameterSpace.weightedCarrier_hasCondDistrib", + "I4SourceSmoothParameterSpace.weightedCarrier_functional_hasCondDistrib", + "I4SourceSmoothParameterSpace.weightedCarrier_eventually_hasCondDistrib", + "I4SourceSmoothParameterSpace.weightedCarrier_functional_eventually_hasCondDistrib", + "I4SourceSmoothParameterSpace.coordinateGradientCLM_apply", + "I4SourceSmoothParameterSpace.gradientTensorContraction_apply", + "I4SourceSmoothParameterSpace.parameterGradientTensorBCF_continuous", + "I4SourceSmoothParameterSpace.gradientPi_iteratedFDeriv", + "I4SourceSmoothParameterSpace.parameterGradientTensorBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradientBCF_continuous", + "I4SourceSmoothParameterSpace.parameterGradientBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradientDerivativeBCF_continuous", + "I4SourceSmoothParameterSpace.parameterGradientDerivativeBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradient_spatial_C2", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanBCF_continuous", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradientEuclidean_spatial_C2", + "I4SourceSmoothParameterSpace.parameterGradientJet_continuous", + "I4SourceSmoothParameterSpace.parameterGradientJet_apply", + "I4SourceSmoothParameterSpace.parameterGradient_actual", + "I4SourceSmoothParameterSpace.parameterGradientDerivative_actual", + "I4SourceSmoothParameterSpace.parameterGradientEuclidean_actual", + "I4SourceSmoothParameterSpace.euclideanDerivativeContraction_apply", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanDerivativeBCF_continuous", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanDerivativeBCF_apply", + "I4SourceSmoothParameterSpace.parameterGradientEuclideanDerivative_actual", + "I4SourceSmoothParameterSpace.parameterEuclideanC1Family_continuous", + "I4SourceLifetimePairFiniteness.actual_critical_coordinateGradient_zero", + "I4SourceLifetimePairFiniteness.coordinates_fundDomain_mem_sourceMorseCube", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_criticalFundDomain", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_pairSet_of_critical", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_candidatePairSet", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_windowPairSet", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_windowElderPairSet", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_unrestrictedPairSet", + "I4SourceLifetimePairFiniteness.smoothLaw_ae_finite_finiteBarPairSet", + "I4SourceCompactTargetMoments.sourceInverse_target_uniform_bounds", + "I4SourceCompactTargetMoments.sourceGammaRadius_allTarget_domination", + "I4SourceCompactTargetMoments.sampleMajorant_affine_integrable_pow", + "I4SourceCompactTargetMoments.sourceGammaRadius_allTarget_moments", + "I4SourceCompactTargetMoments.sourceGapPins_one_sixth", + "I4SourceCompactTargetMoments.sourceGapLaw_one_sixth", + "I4SourceCompactTargetMoments.sourceGapPins_eq_confluent", + "I4SourceCompactTargetMoments.sourceGapLaw_eq_rawPinKernel", + "I4SourceCompactTargetMoments.sourceGapPins_norm_le", + "I4SourceCompactTargetMoments.sourceGapLaw_height_moments", + "AdaptiveFoldScalar.q_hasDerivAt", + "AdaptiveFoldScalar.primitive_hasDerivAt", + "AdaptiveFoldScalar.integral_q_left", + "AdaptiveFoldScalar.integral_q_right", + "AdaptiveFoldScalar.scalarBarrier_of_convex", + "AdaptiveFoldScalar.scalarBarrier_of_secondDerivative", + "AdaptiveFoldTransverseRidge.abs_bilinear_graph_vector_le", + "AdaptiveFoldTransverseRidge.abs_neg_div_le_of_le_neg", + "AdaptiveFoldTransverseRidge.bilinear_graph_vector", + "AdaptiveFoldTransverseRidge.c2_full_derivative_jets", + "AdaptiveFoldTransverseRidge.clm_graph_vector", + "AdaptiveFoldTransverseRidge.clm_vertical_vector", + "AdaptiveFoldTransverseRidge.contDiffOn_of_unique_zero", + "AdaptiveFoldTransverseRidge.contDiffOn_partialY", + "AdaptiveFoldTransverseRidge.exists_structural_collar", + "AdaptiveFoldTransverseRidge.exists_unique_c2_transverse_ridge", + "AdaptiveFoldTransverseRidge.exists_unique_c2_transverse_ridge_with_jets", + "AdaptiveFoldTransverseRidge.exists_unique_c2_zero", + "AdaptiveFoldTransverseRidge.hasDerivAt_slice", + "AdaptiveFoldTransverseRidge.profile_derivative_jets", + "AdaptiveFoldTransverseRidge.root_abs_le_center_div", + "AdaptiveFoldTransverseRidge.slice_unique_root", + "AdaptiveFoldTransverseRidge.vertical_isInvertible", + "AdaptiveFoldTransverseRidge.zero_graph_center_bound", + "AdaptiveFoldTransverseRidge.zero_graph_derivative_bounds", + "AdaptiveFoldTransverseRidge.zero_graph_derivative_formulas", + "AdaptiveFoldTransverseRidge.zero_graph_first_chain", + "AdaptiveFoldTransverseRidge.zero_graph_second_chain", + "AdaptiveFoldBoundaryPath.profileSlopeSecond_error", + "AdaptiveFoldBoundaryPath.exists_transverse_ridge_scalar_barrier", + "AdaptiveFoldBoundaryPath.quadratic_loss_of_second_derivative", + "AdaptiveFoldBoundaryPath.vertical_quadratic_loss", + "AdaptiveFoldBoundaryPath.frontier_leftBox_sides", + "AdaptiveFoldBoundaryPath.side_drop_le", + "AdaptiveFoldBoundaryPath.pathX_mem", + "AdaptiveFoldBoundaryPath.exists_transverse_ridge_boundary_path", + "I4ActualFoldChartJets.coordMap_apply", + "I4ActualFoldChartJets.chartMap_apply", + "I4ActualFoldChartJets.V_contDiff", + "I4ActualFoldChartJets.pullback_jet", + "I4ActualFoldChartJets.Vx_eq", + "I4ActualFoldChartJets.Vy_eq", + "I4ActualFoldChartJets.axial_third_eq", + "I4ActualFoldChartJets.transverse_center_eq", + "I4ActualFoldChartJets.curve_deriv", + "I4ActualFoldChartJets.curve_iteratedDeriv_three", + "I4SourceAdaptiveFoldChart.chart_endpointM", + "I4SourceAdaptiveFoldChart.chart_endpointS", + "I4SourceAdaptiveFoldChart.actualFoldPotential_gap", + "I4SourceAdaptiveFoldChart.normalized_axial_peano", + "I4SourceAdaptiveFoldChart.actualFoldPotential_smooth", + "I4SourceAdaptiveFoldChart.actualFoldPotential_C4", + "I4SourceAdaptiveFoldChart.actualFoldPotential_Vx", + "I4SourceAdaptiveFoldChart.actualFoldPotential_Vy", + "I4SourceAdaptiveFoldChart.actualFoldPotential_axial_third", + "I4SourceAdaptiveFoldChart.actualFoldPotential_transverse_center", + "I4SourceAdaptiveFoldChart.actualFoldPotential_gradient_pins", + "I4SourceAdaptiveFoldChart.actualFoldPotential_normalized_data_of_rawPins", + "I4SourceAdaptiveFoldChart.sourceGapLaw_and_posterior_normalized_fold_data", + "I4SourceAdaptiveFoldChart.sourceGapLaw_normalized_fold_data", + "I4SourceAdaptiveFoldChart.rawPosteriorSample_normalized_fold_data", + "I4ActualFoldNumeric.numerical_budget", + "I4ActualFoldTwoPin.two_pin_abs_le_on_J", + "I4ActualFoldTwoPin.two_pin_bounds_on_J", + "I4SourceAdaptiveFoldEstimates.actual_Hy_eq_Gx", + "I4SourceAdaptiveFoldEstimates.actual_Vx_second", + "I4SourceAdaptiveFoldEstimates.actual_Vy_second", + "I4SourceAdaptiveFoldEstimates.actual_axial_pointwise_error", + "I4SourceAdaptiveFoldEstimates.actual_component_second", + "I4SourceAdaptiveFoldEstimates.actual_coordinate_oscillation", + "I4SourceAdaptiveFoldEstimates.actual_fourth_coordinate_bound", + "I4SourceAdaptiveFoldEstimates.actual_fourth_norm_bound", + "I4SourceAdaptiveFoldEstimates.actual_jet_norm_bound", + "I4SourceAdaptiveFoldEstimates.actual_second_lipschitz", + "I4SourceAdaptiveFoldEstimates.actual_second_swap", + "I4SourceAdaptiveFoldEstimates.actual_structural_rectangle", + "I4SourceAdaptiveFoldEstimates.actual_third_lipschitz", + "I4SourceAdaptiveFoldEstimates.actual_third_norm_bound", + "I4SourceAdaptiveFoldEstimates.axes_norm", + "I4SourceAdaptiveFoldEstimates.component_first", + "I4SourceAdaptiveFoldEstimates.component_first_as_second", + "I4SourceAdaptiveFoldEstimates.component_jet", + "I4SourceAdaptiveFoldEstimates.component_second", + "I4SourceAdaptiveFoldEstimates.component_smooth", + "I4SourceAdaptiveFoldEstimates.coord_norm_le", + "I4SourceAdaptiveFoldEstimates.hasDerivAt_xslice", + "I4SourceAdaptiveFoldEstimates.hasDerivAt_xslice_component", + "I4SourceAdaptiveFoldEstimates.jet_lipschitz", + "I4SourceAdaptiveFoldEstimates.normalized_peano_mass", + "I4SourceAdaptiveFoldEstimates.point_norm_sub_le", + "I4SourceAdaptiveFoldEstimates.second_component_bound", + "I4SourceAdaptiveFoldEstimates.second_component_smooth", + "I4SourceAdaptiveFoldEstimates.sourceGapLaw_actual_rectangle_boundary_path", + "I4SourceAdaptiveFoldEstimates.sourceGapLaw_structural_rectangle", + "I4SourceAdaptiveFoldEstimates.sourceT_one_le", + "I4SourceAdaptiveFoldEstimates.source_scale_le", + "I4SourceAdaptiveFoldEstimates.vertical_boundary_signs", + "I4SourceActualFoldDeath.actualField_pullback", + "I4SourceActualFoldDeath.physicalChart_M", + "I4SourceActualFoldDeath.scaled_rectangle_death", + "I4SourceActualFoldDeath.sourceGapLaw_actual_death_clearance", + "I4SourceActualFoldDeath.actual_rectangle_death", + "I4SourceActualFoldDeath.physicalChart_S", + "I4SourceActualFoldDeath.actualField_continuous", + "I4SourceActualFoldDeath.physicalChart_apply", + "SourceActualFoldTorus.torusProjection2L_continuous", + "SourceActualFoldTorus.torusProjection2L_open", + "SourceActualFoldTorus.torusProjection2L_surjective", + "SourceActualFoldTorus.sourceTorus2L_t2", + "SourceActualFoldTorus.actualTorusField_pullback", + "SourceActualFoldTorus.actualTorusField_continuous", + "SourceActualFoldTorus.torusPhysicalMap_continuous", + "SourceActualFoldTorus.torusPhysicalMap_open", + "SourceActualFoldTorus.actualTorusField_physical_pullback", + "SourceActualFoldTorus.strictClearanceSet_eq_C263", + "SourceActualFoldTorus.TorusTrapData.strictClearanceSet_eq_Iio", + "SourceActualFoldTorus.TorusTrapData.strictClearanceDeath_eq", + "SourceActualFoldTorus.scaled_rectangle_trap", + "SourceActualFoldTorus.torusPhysicalMap_M", + "SourceActualFoldTorus.torusPhysicalMap_S", + "SourceActualFoldTorus.torusPhysicalMap_field_eq", + "SourceActualFoldTorus.actual_rectangle_torus", + "SourceActualFoldTorus.sourceGapLaw_actual_torus_trap_clearance", + "SourceActualFoldTorus.sourceGapLaw_actual_torus_clearance", + "SourceActualFoldH0.fold_interval_endpoints", + "SourceActualFoldH0.h0Section_retraction", + "SourceActualFoldH0.sourceGapLaw_actual_torus_h0", + "SourceActualFoldH0.sourceGapLaw_actual_torus_trap_h0", + "SourceActualFoldH0.toElderTrap", + "SourceFoldWeightedProbability.cutoff_failure_inclusion", + "SourceFoldWeightedProbability.sourceCutoffA_nonneg", + "SourceFoldWeightedProbability.sourceCutoffEps_pos", + "SourceFoldWeightedProbability.sourceFoldGood_compl_subset", + "SourceFoldWeightedProbability.sourceFoldGood_measurable", + "SourceFoldWeightedProbability.sourceFoldWeightedLaw_absolutelyContinuous", + "SourceFoldWeightedProbability.sourceFoldWeightedLaw_eq", + "SourceFoldWeightedProbability.sourceFoldWeightedProbability_bound", + "SourceFoldWeightedProbability.sourceFoldWeightedProbability_h0", + "SourceFoldWeightedProbability.sourceKappa_measurable", + "SourceFoldWeightedProbability.sourceKappa_one_sixth", + "SourceFoldWeightedProbability.sourceScale_pos", + "SourceFoldWeightedProbability.sourceT_eq_scale", + "SourceFoldWeightedProbability.sourceT_measurable", + "I4SourceGapPinCurvature.sourceGapLaw_curvature_bounds", + "I4SourceGapPinCurvature.sourceSmoothKernel_curvature_bounds_ae", + "I4SourceGapPinCurvature.sourceSmoothWeight_curvature_bound", + "I4SourceGapPinCurvature.sourceSmoothWeight_radius_bound", + "I4SourceGapPinCurvature.source_bad_curvature_slab", + "I4SourceGapPinCurvature.source_normalized_determinant_bounds", + "I4SourceGapPinCurvature.source_normalized_first_four_bound", + "I4SourceGapPinCurvature.source_normalized_first_four_third_bound", + "I4SourceGapPinCurvature.source_normalized_transverse_errors", + "I4SourceGapPinCurvature.source_positive_weight_curvature_upper", + "I4SourceAllTargetCurvatureResidual.one_le_allTargetCurvatureResidualRadius", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_uniform_bounds", + "I4SourceAllTargetCurvatureResidual.sourceDerivativeMajorant_allTarget_curvatureReconstruct", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_gap_height_moments", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_prescribed", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_measurable", + "I4SourceAllTargetCurvatureResidual.sourceContactQ_posterior_abs_le_allTargetRadius", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_moment_bound", + "I4SourceAllTargetCurvatureResidual.sourceGammaRadius_allTarget_curvatureReconstruct", + "I4SourceAllTargetCurvatureResidual.allTargetCurvatureResidualRadius_image_bound", + "I4SourceGapWeightedNumerator.sourceGapLaw_regular_numerator", + "I4SourceGapWeightedNumerator.sourceGapLaw_regularity_numerator", + "I4SourceGapWeightedNumerator.sourceBadUnion_integral_le", + "I4SourceGapWeightedNumerator.sourceGapLaw_bad_union_numerator", + "I4SourceGapWeightedNumerator.sourceGapLaw_weight_integrable", + "I4SourceGapWeightedNumerator.sourceGapLaw_regular_numerator_of_product", + "I4SourceGapWeightedNumerator.sourceGapLaw_regularity_base_bound", + "I4SourceGapWeightedNumerator.sourceGapLaw_compact_moments", + "SourceCompactGapNormalizer.cubic_pin_pointwise_error_target", + "SourceCompactGapNormalizer.endpointWeight_gap_floor", + "SourceCompactGapNormalizer.gaussianCompactLowerConstant_pos", + "SourceCompactGapNormalizer.gaussianPDFReal_lower_compact", + "SourceCompactGapNormalizer.gaussianReal_Icc_lower_compact", + "SourceCompactGapNormalizer.sourceCompactGoodEvent_mass", + "SourceCompactGapNormalizer.sourceCompactGoodEvent_measurable", + "SourceCompactGapNormalizer.sourceGapLaw_compact_normalizer", + "SourceCompactGapNormalizer.sourceGapLaw_negative_interval_mass", + "SourceCompactGapNormalizer.sourceGapLaw_q_hasLaw", + "SourceCompactGapNormalizer.sourceGap_curvatureMean_bound", + "SourceCompactGapNormalizer.sourceSmoothWeight_gap_floor", + "SourceCompactGapNormalizer.source_normalized_gap_axial_errors", + "SourceCompactFoldWeightedProbability.sourceCompactCutoffA_nonneg", + "SourceCompactFoldWeightedProbability.sourceCompactFoldGood_compl_subset", + "SourceCompactFoldWeightedProbability.sourceCompactFoldGood_measurable", + "SourceCompactFoldWeightedProbability.sourceCompactFoldWeightedLaw_absolutelyContinuous", + "SourceCompactFoldWeightedProbability.sourceCompactFoldWeightedProbability_bound", + "SourceCompactFoldWeightedProbability.sourceCompactFoldWeightedProbability_h0", + "SourceCompactFoldWeightedProbability.varying_cutoff_failure_inclusion", + "I4SourceActualFoldCandidate.actual_critical_of_coordinate_pins", + "I4SourceActualFoldCandidate.actual_endpoint_schur_signs", + "I4SourceActualFoldCandidate.actual_hessian_complete_square", + "I4SourceActualFoldCandidate.actual_hessian_coordinates", + "I4SourceActualFoldCandidate.actual_hessian_physical", + "I4SourceActualFoldCandidate.actual_planar_hessian_quadratic", + "I4SourceActualFoldCandidate.actual_rawPins_critical", + "I4SourceActualFoldCandidate.actual_rawPins_heights", + "I4SourceActualFoldCandidate.actual_rawPins_ridge_candidate", + "I4SourceActualFoldCandidate.actual_rawPins_ridge_types", + "I4SourceActualFoldCandidate.actual_torus_lifetime_pullback", + "I4SourceActualFoldCandidate.coordinates_endpointLiftM", + "I4SourceActualFoldCandidate.coordinates_endpointLiftS", + "I4SourceActualFoldCandidate.derivative_zero_of_coordinate_pins", + "I4SourceActualFoldCandidate.endpointLiftM_apply", + "I4SourceActualFoldCandidate.endpointLiftS_apply", + "I4SourceActualFoldCandidate.endpoint_lifts_lattice_lower", + "I4SourceActualFoldCandidate.endpoint_lifts_sub_norm", + "I4SourceActualFoldCandidate.endpoint_lifts_torusDist", + "I4SourceActualFoldCandidate.endpoint_lifts_torusDist_unit_ne_radius", + "I4SourceActualFoldCandidate.endpoint_lifts_torusDist_unit_zero", + "I4SourceActualFoldCandidate.endpoint_schur_signs", + "I4SourceActualFoldCandidate.hessianHasInertia_one_of_diag", + "I4SourceActualFoldCandidate.hessianHasInertia_two_of_diag", + "I4SourceActualFoldCandidate.interface_values_eq_actual", + "I4SourceActualFoldCandidate.planar_bilinear_quadratic", + "I4SourceActualFoldCandidate.planar_quadratic_complete_square", + "I4SourceActualFoldCandidate.planar_vector_decomposition", + "I4SourceActualFoldCandidate.ridge_profileSlopeFirst_eq_schur", + "I4SourceActualFoldCandidate.sourceGapLaw_actual_candidate_death_h0", + "I4SourceActualFoldCandidate.torusProjection_endpointLiftM", + "I4SourceActualFoldCandidate.torusProjection_endpointLiftS", + "I4SourceFinitePinKernel.finitePairing_residualCoefficient", + "I4SourceFinitePinKernel.residualCoefficient_summable", + "I4SourceFinitePinKernel.coefficientGram_posDef_of_finite_kernel_rightInverse", + "I4SourceFinitePinKernel.finiteShiftSample_val", + "I4SourceFinitePinKernel.rawPins_finiteShiftSample", + "I4SourceFinitePinKernel.rawPosteriorSample_finiteShiftSample", + "I4SourceFiniteTrig.eval_constant", + "I4SourceFiniteTrig.eval_append", + "I4SourceFiniteTrig.eval_scale", + "I4SourceFiniteTrig.eval_translate", + "I4SourceFiniteTrig.eval_mul", + "I4SourceFiniteTrig.toSource_eval", + "I4SourceFiniteTrig.toSource_derivative", + "I4SourceRemoteJetWitness.localGerm_jet2", + "I4SourceRemoteJetWitness.jet2_mul", + "I4SourceRemoteJetWitness.jet2_interpolate_mul", + "I4SourceRemoteJetWitness.actual_finite_remoteJet_witnesses", + "I4SourceRemoteJetWitness.actual_remote_residual_coefficientGram_posDef", + "I4SourceRemoteJetGaussian.remoteJet_rawPosteriorSample", + "I4SourceRemoteJetGaussian.rawPinKernel_remoteJet_eq_multivariateGaussian", + "I4SourceRemoteJetGaussian.remoteResidualCovariance_posDef", + "I4SourceRemoteJetGaussian.rawPinKernel_remoteJet_conditional_uniform", + "I4SourceEndpointHessianWitness.actual_finite_endpointHessian_witnesses", + "I4SourceEndpointHessianWitness.actual_endpointHessian_residual_coefficientGram_posDef", + "I4SourceH0OlderClearance.h0OlderClearance_iff_strictClearance", + "I4SourceH0OlderClearance.h0OlderClearance_realCover_iff_lt_death", + "I4SourceH0OlderClearance.sourceGapLaw_h0OlderClearance_uniform", + "I4SourceEndpointHessianGaussian.rawPinKernel_endpointHessian_eq_multivariateGaussian", + "I4SourceEndpointHessianGaussian.endpointHessianCovariance_posDef", + "I4SourceEndpointHessianGaussian.rawPinKernel_ae_endpointHessian_det_ne_zero", + "I4SourceTwoRemoteFirstJetWitness.actual_finite_twoRemoteFirstJet_witnesses", + "I4SourceTwoRemoteFirstJetWitness.actual_twoRemoteFirstJet_residual_coefficientGram_posDef", + "I4SourceIntrinsicH0Interface.h0Interface_cut_death_eq_C263", + "I4SourceIntrinsicH0Interface.h0Interface_morse_compatibility", + "I4SourceIntrinsicH0Interface.sourceGapLaw_intrinsic_h0_finiteBar_uniform", + "I4SourceTwoRemoteFirstJetGaussian.rawPinKernel_twoRemoteFirstJet_eq_multivariateGaussian", + "I4SourceTwoRemoteFirstJetGaussian.twoRemoteResidualCovariance_posDef", + "I4SourceIntrinsicH0WeightedProbability.sourceIntrinsicFiniteBarEvent_measurable", + "I4SourceIntrinsicH0WeightedProbability.sourceIntrinsicFiniteBarProbability_uniform", + "I4SourceRawPinFreeCoordinates.freeMaps_measurable", + "I4SourceRawPinFreeCoordinates.freeResidual_freeCoordinate_joint_map", + "I4SourceRawPinFreeCoordinates.rawPosteriorSample_free_reconstruction", + "I4SourceFramedConfluentCovariance.framedConfluentVector_actual", + "I4SourceFramedConfluentCovariance.framedConfluent_family_bounds", + "I4SourceFramedConfluentCovariance.framedConfluent_covariance_uniform_floor", + "I4SourceGapConditionalMorseDistinct.sourceGapLaw_ae_isMorseDistinct", + "I4SourceActualMorseLocalModel.actualSource_c1_quadratic_localModel", + "I4SourceActualTorusSuperlevelLocalBasis.actualSource_torus_closedSuperlevel_localPathConnectedBasis", + "I4SourceActualTorusRegularSlab.actualSource_closedSlab_componentInclusion_bijective", + "I4SourceActualFiniteSuperlevelComponents.actualSource_finite_closedSuperlevel_components", + "I4SourceActualQuotientSaddleCollar.actualSource_quotient_saddle_local_collar", + "I4SourceActualSaddleUppercuts.actualSource_quotient_saddle_uniform_closed_uppercuts", + "I4SourceActualRegularLocalCollar.actualSource_quotient_regular_local_collar", + "I4SourceActualLowerSeparation.actualSource_closedSuperlevel_componentInclusion_locally_injective" + ], + "inherited_input_count": 32, + "files": { + "SourceDerivativeGaussian.lean": "c9754debcbf2aab7ff8d9604f2c13726723e8a8c1921ae68f83349205e43885d", + "ContactJetCovariance.lean": "50df0281c580ac7af018713a38c6bdd5dd34b52e3834b573165045bc64acd49d", + "SourceContactCovariance.lean": "4189cbaf4c18c55f21e3af2c96b0b2842d83161f44596eb691c507dcc1a439c8", + "SourceConfluentPins.lean": "41e1ea1ef4f9960307552a8271a5c04d2b72d94736b98eb601b51669ed603c3f", + "SourceContactSchur.lean": "2fe122a50ec1889b579558d80086251d87ed0cec2420d268ab1d04f6bfff4409", + "SourceDerivativeContinuity.lean": "552511e0aee227133b7d067faeceaab9c43c0094b07d68b8eddab0ab2419775e", + "ConfluentIntegralIdentities.lean": "0324d7556d485cd360a513587199354fa1f3863d15cf06b52c86e362de5e56b8", + "SourceEndpointRegression.lean": "67e68553e004adc3b1b6beb987b3e7ad477b4541d96fec22ee481facd2038fce", + "GaussianRegressionLimits.lean": "26c403ea1104fbce89f5c2833f603edd4d2703669d8a94a77b2c9a2a06b572be", + "SourceEndpointParameters.lean": "efc88ac59217ab1960d5518abcd9f16a71b42080a2810f1e337eeb2f686c1e3a", + "SourceContactEndpointParameters.lean": "da5337a7814a008eaa8b8a98c0df4daf3efb1bc347789a2f75efc63c9c258d01", + "SourceConfluentLimits.lean": "1635a05bbd5b56608bc0a1a04eb4404c2df4601f1255f5846c1342a597bf5b0b", + "SourcePhysicalEndpointKernel.lean": "689ced2a760b38333b0224f19af52812d0057527d5a790ba50116cb5f07b7e3a", + "SourceEndpointEstimates.lean": "d1f08d80d06d1ac08afbdd700370059fd8eaf0d4e483916e742efcdd1f664598", + "SourceSmoothConditionalKernel.lean": "664892acb12d40e5bf20075e1ef633efdd4a54ae1308c714308eab3a4deaa517", + "SourceSmoothPalm.lean": "1b1d47b640b541195dad1472a07fa9490f203bd1619b1759b29587a0effe631d", + "GaussianWeightedMajorants.lean": "3bde84aa83d02b364ca17f242cc5dbca83908c02f2f75649075d7da6a3d1bfd0", + "SourceConditionalMajorant.lean": "07ae7796e461a2ee59a757b37a3e64f7ed31c76d26a3b40825f23170fcb4e691", + "SourcePinCurvatureBounds.lean": "b19a673aa594d1d5ef929cc598f0a142efb56c10b78c4634c92a8a749d1f1d51", + "ScalarProductCurvatureBound.lean": "fb77c9a4eaf165a39c6c06535fbb3f3f164bca12ddbc2f29b01a33e512564b71", + "SourceCurvatureDecomposition.lean": "ba9011f17a8bf6c1a7d32d248a464a49c04d1836e9e4f2f3ec3190fad8b6d503", + "SourceWeightedCurvatureBound.lean": "9926f650c8fb9baf13261ba7ea1d01bd7a5cfb95c7175163888c42a62934a3f9", + "SourcePinPreservingQuartic.lean": "8e23717ef98518b6d701db921d1f17958c3dee2c893745cafa7aa6172f1621d9", + "SourceSmoothTopology.lean": "ba57c81708056b22e9fc17285969b43fe968e758f2e957bbbef75af7cf82d0ae", + "SourceRawPinConditioning.lean": "77e521c7fc3fc3da1c922a4ef547b065be58b232b321480948c8fe50d76c2aa5", + "SourceQuarticCaptureAlgebra.lean": "ba338bba6fdd6fae70f5379c8ff58a424237baf090672a7e3303691ff2f0209a", + "SourceMorseIncidence.lean": "b93fe8f7856d4e632b3ff823788469720ae0814440bbec744fde099d4f29f127", + "SourceSmoothParameterSpace.lean": "b98a5aab4e27d943dd08eb12291fbc0056e7d54d9f7e8f53a255f8863f9c510c", + "SourceLifetimePairFiniteness.lean": "36bf363f88d450a61052086c5d7eb799d12dd58ce4b74c1c083a056991606081", + "SourceCompactTargetMoments.lean": "4fc28898f09381b4bfd0a15324556d2f3cb68f4b39063aa3acf12db7759ccfc8", + "AdaptiveFoldScalarBarrier.lean": "cfe6a63a789ae085c2351d9d0be9bcf998f911d8c2e80bb01e1dd9e2b74c30d5", + "AdaptiveFoldTransverseRidge.lean": "715b01c2ae3b6e2bceb4196e53361530c8c9c69550e7cf675904cd5661b3de20", + "AdaptiveFoldBoundaryPath.lean": "b3a196c31c0c7957119907ea864c33b937d1a783bc7109390d3ca24a644e0570", + "SourceAdaptiveFoldChart.lean": "074921959ffdaa0aa8a7d377dca5b7678f5ed964e52a3ad027b051f4c7f9a073", + "SourceAdaptiveFoldEstimates.lean": "980d8f238a085c6fc56bfffd0af278bcc248fb2f523c15662b603957b36c8a20", + "SourceActualFoldDeath.lean": "ee84ce7a775ae8163ec9309a0841757ce2990576adfd7186d4ad5bc8ac4de0d0", + "SourceActualFoldTorus.lean": "d2ca01d1f881852372c371215c30216bee7d917fdf2eaafbbd097f8c840e20c6", + "SourceActualFoldH0.lean": "7d54c2cc08751365cc71949016fcbdd64872e5fbc4f67baea1fdd526a4e86cfd", + "SourceFoldWeightedProbability.lean": "58b77d6c0886fb5ef005749f468648d3c3ce6c99905f89963bf99c4ebee763d0", + "SourceGapPinCurvature.lean": "67f6c671e4ed8a7cb8557fc6027403f4fd1e94cba984e672eaa3ceb94ab8847e", + "SourceAllTargetCurvatureResidual.lean": "4ae29bc3f2f206cca558df3f78853061cf4892499ac918e40253edd68d44371f", + "SourceGapWeightedNumerator.lean": "b2fedf3739884ff716d11c85ebcf5de328fc76bc2a5bed31e8ea72c61d2f87a3", + "SourceCompactGapNormalizer.lean": "d0f9319ac2ca792a9733659453583f4f71acc7ccccbcaba4ba1942566516065a", + "SourceCompactFoldWeightedProbability.lean": "97e6c694b62d90f6b723b0e510691e019f763ff26ebba743664d596dc72223b9", + "SourceActualFoldCandidate.lean": "a03d6cc83ec35971d8e67a0ccb3032681eed76ca056a075bbd3bbddff7727e0e", + "SourceFinitePinKernel.lean": "d45fbf6ca2d7a2c3e54a8edcd5d5c482497751ec1c3d820a1a198a204c8ce5d1", + "SourceFiniteTrig.lean": "d0f0dea0b2f8296d129a3759271076848e35dd5a4b1ab2f5f0cee58837c72b14", + "SourceRemoteJetWitness.lean": "c7dcc70330f0385bdd5c3aef105d54db0f9c0155824251f4fb61cac3640649cf", + "SourceRemoteJetGaussian.lean": "65694d00f575333b3b896338ecaf047ce8e166fbb8eddc03bd0836cce521a034", + "SourceEndpointHessianWitness.lean": "45f69d75cb4418b239f6402d0552da546bccc127e3102fac7da7d4c30324ae8f", + "SourceH0OlderClearance.lean": "6e42bb33d81e0a76fc0abb409b4f4811b7e91fe07d1398300e2e9792f29e794a", + "SourceEndpointHessianGaussian.lean": "b9900b7553f7722241137f8f0cba08862b19ae415253a9a14bfd7c9b53c3e613", + "SourceTwoRemoteFirstJetWitness.lean": "b523da924513fc312c5432c241fc031d4fbe3567fbeedbba981f36dd798574a4", + "SourceIntrinsicH0Interface.lean": "a08a920ff0fac854c14a5040018b793e5cd99e1646f1bcec15c36fe27db071ef", + "SourceTwoRemoteFirstJetGaussian.lean": "4677ada085e7c53b4e9b4fd2160bcffc326e6a73b20cbb6cb7540ee3aece2a91", + "SourceIntrinsicH0WeightedProbability.lean": "14eefa9f0572e215a9170c1b3206e67b60d1e6f3861f36c66ca6701cf19a4f46", + "SourceRawPinFreeCoordinates.lean": "82be00780c7070e999a47d397e4fe047535bd1d5b349efe82e252ccd5cd52cd4", + "SourceFramedConfluentCovariance.lean": "0912fa1101b1ea17c9e2dd1d083fdd1cc50a3891585aaf0622b69f7415824b36", + "SourceGapConditionalMorseDistinct.lean": "8baf597fa98ce8f79489e82227951e0f4fd1a960e65589278be8a82f35ce5213", + "SourceActualMorseLocalModel.lean": "d6776bd34a2ae1371c2af8fbfcc54d2a536e7c96b2e4db517a5f4a81b4128cd5", + "SourceActualTorusSuperlevelLocalBasis.lean": "f52c247c1fb8956eebb166badf62de550566a0c2e4f56f5bda30bf5a5531d04c", + "SourceActualTorusRegularSlab.lean": "14c900c4e81be9b9ffc85e56fe9c3f191ae8405670d15d0e151a766751b6a23b", + "SourceActualFiniteSuperlevelComponents.lean": "e63abe693a6d23e5679adbb7110cb7b569bd3171db596d470f32b8566bc01a5c", + "SourceActualQuotientSaddleCollar.lean": "e0e0a0f77bd75bbbd8994d620ee43b18b2edd50d7649cd8cb9837e7148762265", + "SourceActualSaddleUppercuts.lean": "d292c767e789b98a6fbb56e5c21ec8867979faa832a97c1e79c79c899b777129", + "SourceActualRegularLocalCollar.lean": "82823ac4360cbfb6eda057eb9fc212c870842703a14f5222454df70f19ed0d96", + "SourceActualLowerSeparation.lean": "e72ed4f92e7867dc210b771e6afb4548cfad679e8b38795110fa6fd76a15e121", + "inputs/GaussianSeriesFoundation.lean": "feea566d5aeba58459bd4a1f20f070bdcd80ee30712817324cdd594e3e232c95", + "inputs/SpectralWeights.lean": "92af14a2d83304de3f8576ee10b3d376587e93c4464f8c715b8d2e32360f44b0", + "inputs/SourceFourierSeries.lean": "5f145e8e8693bfe4d1554092c8258dbda4f17f8e078c503029e4e8ff2c018014", + "inputs/SourceC4.lean": "b15e53b825c2e2d6af2af18182da227d8794dddcc3e1b29611a913f89a889397", + "inputs/SourceGaussianLaw.lean": "a60ab6099d3cef0eeecaefa9e35d95ec14ec54ffd6c89e42dfcf6170907166e8", + "inputs/SourceLattice.lean": "c644305a426bc876f609c055ce999b8008f028c67a1091639d919f4122981b7b", + "inputs/SourceKernel.lean": "5fa3abc8fb0db0c14c67b4ee840e659cdf80f7d22c9fd4cb5e6c1c7b204fbd21", + "inputs/SourceCovariance.lean": "30560009582659a100637b5510c657cf1fa762f68a37bae8fab42c1eeee6aee5", + "inputs/SourceTorus.lean": "02857b44552ab0e51a756b3b095c4ba43f8168ac332b069acb5bc8146d337eef", + "inputs/SourceTorusC4.lean": "b67b13030389dea4521e8e2afcac30ea44f84abd65c374bf208067b288fc64a1", + "inputs/SourceSmooth.lean": "12ad7263267a970bd5d5c95d7c7aa62d9c971f7beebf28f1aa7ed16d3a112f1b", + "inputs/SourceSmoothCarrier.lean": "5defdf223e85e7ccd23b5a903a1a306fe7f723727eb6aabf62eef523ef8639ed", + "inputs/ResearchFormalCoreR1/DeterminantMoment.lean": "661b73c3f21c6d2529f5e09ce426d89c01939ab27a5cc868db3802c7e66ea82d", + "inputs/ResearchFormalCoreR1/GaussianScalarMoments.lean": "71ce88ad2c97891858a5196f3293907bdffdd2341dfbace24204f2318c7510df", + "inputs/ResearchFormalCoreR1/GaussianJetMoments.lean": "f2e785975aee6915848fe78dc3ecde02b8f13a0a1fb56ae3771e4c727c723360", + "inputs/ResearchFormalCoreR1/GaussianNormalizer.lean": "32b7202cba2a9a0e0ed603d1a6db9ba2031714375b4e955614d5a40826a14aeb", + "inputs/ResearchFormalCoreR1/EndpointGaussianMoments.lean": "c6351881326491ce30f1a266ea60e44c5adb8b3a1e5882c90575c67e459479d1", + "inputs/ResearchFormalCoreR1/NormalizerFloor.lean": "428eefd71b8c64fc4bcb208d9f73658058f29765f01a01c591f20a2d2359ec3e", + "inputs/ResearchFormalCoreR1/EndpointNormalizerBridge.lean": "36eab3b805fcba5160cb7e286dbd7f96940b0c6a85b464aad5fdad2f624ceb7e", + "inputs/ResearchFormalCoreR1/GaussianCoupling.lean": "426a53c139215650e961601c12f3cc1e09069520c5ebb96234a29483280551bb", + "inputs/ResearchFormalCoreR1/GaussianNormalizerLimit.lean": "12c98054b5bcf47f4619c624ef5e91c37f316d7c4848f560279d1f1e96fe0049", + "inputs/ResearchFormalCoreR1/PalmReweighting.lean": "d34e422693f1d449bfcaf9c844c99c8fef4f19503312d3677ca525bd2d67c4d6", + "inputs/ResearchFormalCoreR1/GaussianRegressionKernel.lean": "66d4fbee044a1a0c0b434bcd7614e220fad21d1ac275ce9b01070a66c5780460", + "inputs/Lifetime.lean": "371365f9bb17fbe1491c38bb00359300ea76641d3b5693d8feb11bb2c3fad51e", + "inputs/SourceLifetimeGeometry.lean": "8ec4b18959055f20d849337e44a70d0c5b39b7959b54cb4d7b6c2a473ee0612d", + "inputs/elder/SuperlevelBar.lean": "f328d66d7240469f080c8bbf83f7259677fee21593465977e23a95685667ebd9", + "inputs/elder/ElderClearance.lean": "d3d78472881059546402218cc77792eeef00755c222bb02499d69abd3b5cd57e", + "inputs/elder/ReusedCompactFrontier.lean": "29d77453ef7c3cd216521a8ac84639aa30daf5a1d4061785a826b2c2d42d23db", + "inputs/elder/ClosedSuperlevel.lean": "51cb46da0f1aae823fd91ec5e93c6edcd694d72f0a40d7a83686fee66c8ffffa", + "inputs/elder/OrdinaryH0.lean": "3e91484d8b8499bee94c652a13dbab957712a180d4644e5ea5915082a79836f5", + "inputs/elder/ElderInterval.lean": "69daa2e2a6afbdedde20d0c3b1ecdb52e2626da8ad49138b9db388b41ee71491", + "inputs/elder/ElderBridge.lean": "6b0be1116f6b357b0ffbda202c572c27c2788b98bee639e228375a5ebeea1fa9" + } +} diff --git a/tests/sdga_source_observation.py b/tests/sdga_source_observation.py new file mode 100644 index 000000000..1385315ac --- /dev/null +++ b/tests/sdga_source_observation.py @@ -0,0 +1,44 @@ +"""Mandatory pinned-source control; run explicitly, outside ordinary test_*.py discovery.""" +from __future__ import annotations + +import hashlib +import json +import os +from pathlib import Path +import unittest + +from test_sdga_scope import ContractCase, FIXTURES, api, blob_id + + +class PinnedSourceObservation(ContractCase): + def test_original_raw_inputs_and_all_99_current_source_bytes(self): + required = ("SDGA_PINNED_MATH_ROOT", "SDGA_OBSERVED_MATH_COMMIT", + "SDGA_OBSERVED_MATH_TREE") + missing = [name for name in required if not os.environ.get(name)] + self.assertFalse(missing, "Required pinned-source environment unavailable: " + ", ".join(missing)) + root_value = os.environ["SDGA_PINNED_MATH_ROOT"] + profile = json.loads((FIXTURES / "scope-f532.json").read_text(encoding="utf-8")) + observed = dict(profile["source"], + commit=os.environ["SDGA_OBSERVED_MATH_COMMIT"], + tree=os.environ["SDGA_OBSERVED_MATH_TREE"]) + self.assertEqual(observed, profile["source"]) + package = Path(root_value) / profile["source"]["package"] + raw = {name: (package / name).read_bytes() for name in profile["inputs"]} + self.assertGreater(len(raw["SOURCE_MANIFEST.json"]), 2 * 1024 * 1024) + for name, value in raw.items(): + with self.subTest(input=name): + self.assertEqual(hashlib.sha256(value).hexdigest(), profile["inputs"][name]["sha256"]) + self.assertEqual(blob_id(value), profile["inputs"][name]["git_blob"]) + scope = api.extract_scope(raw, profile, observed) + self.assertEqual(scope["modules"], profile["modules"]) + self.assertEqual(scope["targets"], profile["targets"]) + sources = {x["path"]: (package / x["path"]).read_bytes() for x in profile["modules"]} + for row in profile["modules"]: + self.assertEqual(hashlib.sha256(sources[row["path"]]).hexdigest(), row["source_sha256"]) + self.assertIsNone(api.verify_source_files(scope, sources)) + self.assert_blocked(scope) + + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_sdga_scope.py b/tests/test_sdga_scope.py new file mode 100644 index 000000000..4db06eb46 --- /dev/null +++ b/tests/test_sdga_scope.py @@ -0,0 +1,431 @@ +"""Task 1 contracts only. Initial missing module is absence, never control credit.""" +from __future__ import annotations + +import copy +import hashlib +import json +from pathlib import Path +import sys +import unittest + +ROOT = Path(__file__).resolve().parents[1] +FIXTURES = Path(__file__).parent / "fixtures" / "sdga_scope" +sys.path.insert(0, str(ROOT / "tools")) +import sdga_scope as api # Deliberately absent in the immutable RED draft. + +H = hashlib.sha256(b"fixture-object").hexdigest() +EMPTY = hashlib.sha256(b"").hexdigest() +BLOCKERS = { + "EXACT_TYPE_SEMANTICS_UNRESOLVED", + "FULL_DECLARATION_ROLES_UNRESOLVED", + "EXECUTION_NOT_OBSERVED", + "KERNEL_COVERAGE_UNESTABLISHED", +} + + +def encoded(*components): + return "/".join("n" + str(x) if type(x) is int else "s" + x.encode("utf-8").hex() + for x in components) + + +ALPHA, BETA = encoded("Alpha"), encoded("Beta") +PUBLIC, DATA = encoded("Public", "p"), encoded("Public", "d") +PRIVATE = encoded("_private", "Alpha", 0, "hidden") +FOREIGN = encoded("Foreign", "generated") + + +def blob_id(raw): + return hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest() + + +def rebound(profile, raw_inputs): + result = copy.deepcopy(profile) + for name, raw in raw_inputs.items(): + result["inputs"][name].update( + sha256=hashlib.sha256(raw).hexdigest(), git_blob=blob_id(raw), bytes=len(raw)) + return result + + +def profile_and_projection(): + profile = json.loads((FIXTURES / "scope-f532.json").read_text(encoding="utf-8")) + raw = {name: (FIXTURES / name).read_bytes() + for name in ("lakefile.toml", "lake-manifest.json", "lean-toolchain")} + raw["SOURCE_MANIFEST.json"] = (FIXTURES / "source-scope-projection.json").read_bytes() + return rebound(profile, raw), raw + + +def fixture_scope(): + return { + "scope_id": "fixture-sdga", + "modules": [ + {"module": "Alpha", "path": "Alpha.lean", "role": "production", "source_sha256": H}, + {"module": "Beta", "path": "Beta.lean", "role": "production", "source_sha256": H}, + ], + "targets": ["Public.p", "Public.d"], + "expected_counts": {"public_targets": 2, "proposition_targets": 1, "data_targets": 1}, + } + + +def part(level, names): + return {"level": level, "sha256": H, "const_names": names, "constant_names": names[:]} + + +def declaration(module, name, kind="theorem", prop=True, private=False): + return {"record": "declaration", "module": module, "name": name, "kind": kind, + "is_prop": prop, "is_private": private, "unsafe": False, "partial": False, + "type_display": "True" if prop else "Nat", "object_part_sha256": H, "axioms": []} + + +def records(): + return [ + {"record": "header", "schema": 1, "scope_id": "fixture-sdga"}, + {"record": "module", "name": ALPHA, "const_count": 2, + "object_parts": [part("exported", [PUBLIC]), part("server", [PUBLIC]), + part("private", [PUBLIC, PRIVATE])], "extra_const_names": []}, + {"record": "module", "name": BETA, "const_count": 2, + "object_parts": [part("exported", [DATA, FOREIGN])], "extra_const_names": []}, + declaration(ALPHA, PUBLIC), + declaration(ALPHA, PRIVATE, private=True), + declaration(BETA, DATA, "definition", False), + declaration(BETA, FOREIGN, "definition", False), + {"record": "end", "module_count": 2, "declaration_count": 4, "axioms": []}, + ] + + +def transcript(rows): + return "\n".join(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + for row in rows) + "\n" + + +def step(name): + return {"name": name, "exit_code": 0, "signal": None, "timed_out": False, + "stdout_sha256": EMPTY, "stderr_sha256": EMPTY, + "started_utc": "2026-11-09T00:00:00Z", "ended_utc": "2026-11-09T00:00:01Z", + "duration_ns": 1000000000, "max_rss_kib": 1024} + + +def receipt(): + return { + "schema": 1, "scope_id": "fixture-sdga", "scientific_effect": "NONE", + "source": {"repository": "fixture/Math-", "commit": "1" * 40, "tree": "2" * 40}, + "adapter_sha256": H, "profile_sha256": H, + "run": {"repository": "fixture/main", "id": 10, "attempt": 1, "job_id": 20}, + "toolchain": {"commit": "5045d0056413266e57c625dcd7c365b10e377c52", + "lean_sha256": H, "lake_sha256": H}, + "inputs_before_sha256": H, "inputs_after_sha256": H, + "cache_before_sha256": H, "cache_after_sha256": H, + "owned_objects_sha256": H, "module_coverage": [ALPHA, BETA], + "unsafe_skipped": [], "partial_skipped": [], + "steps": [step("build"), step("inventory"), step("kernel:" + ALPHA), step("kernel:" + BETA)], + } + + +class ContractCase(unittest.TestCase): + def assert_blocked(self, result): + self.assertEqual(result["scientific_effect"], "NONE") + self.assertEqual(result["qualification"], "BLOCKED") + self.assertEqual(result["classification_status"], "BLOCKED") + + def scope_error(self, code, raw, profile, observed=None): + with self.assertRaises(api.ScopeError) as caught: + api.extract_scope(raw, profile, observed or profile["source"]) + self.assertEqual(caught.exception.code, code) + + def invalid_receipt(self, changed, expected, code): + result = api.classify_receipt(changed, expected) + self.assert_blocked(result) + self.assertEqual(result["binding_status"], "INVALID") + self.assertEqual({x["code"] for x in result["findings"]}, {code}) + + +class ScopeContracts(ContractCase): + def test_frozen_scope_matches_literal_vectors_and_all_99_bindings(self): + profile, raw = profile_and_projection() + scope = api.extract_scope(raw, profile, profile["source"]) + self.assert_blocked(scope) + self.assertEqual(scope["source"], profile["source"]) + self.assertEqual(scope["modules"], profile["modules"]) + self.assertEqual(scope["targets"], profile["targets"]) + self.assertEqual(len(scope["modules"]), 99) + self.assertEqual(sum(x["role"] == "production" for x in scope["modules"]), 67) + self.assertEqual(sum(x["role"] == "input" for x in scope["modules"]), 32) + self.assertEqual(len(scope["targets"]), 1137) + digest = hashlib.sha256(("\n".join(scope["targets"]) + "\n").encode("utf-8")).hexdigest() + self.assertEqual(digest, "2c22d5ba939ed6cf74669a99a23ad8337ec9a54abcafb3bf43ef5799e5536cae") + matrix = json.dumps(scope["modules"], ensure_ascii=False, separators=(",", ":")).encode("utf-8") + self.assertEqual(hashlib.sha256(matrix).hexdigest(), "4446aeee839a661d2452fa8f1c0992ee2f581d7623b94e490511b047c5b75111") + + def test_raw_input_and_identity_mismatch_refused_before_parsing(self): + profile, raw = profile_and_projection() + changed = dict(raw, **{"lakefile.toml": raw["lakefile.toml"] + b"\n"}) + self.scope_error("INPUT_BINDING", changed, profile) + wrong = dict(profile["source"], commit="0" * 40) + self.scope_error("SOURCE_IDENTITY", raw, profile, wrong) + + def test_duplicate_missing_or_changed_target_vector_refused(self): + profile, raw = profile_and_projection() + original = json.loads(raw["SOURCE_MANIFEST.json"]) + for targets in (original["targets"] + [original["targets"][0]], original["targets"][:-1], + ["I4SourceSmoothParameterSpace.weightedCarrier_memlp"] + original["targets"][1:]): + with self.subTest(target_count=len(targets)): + data = dict(original, targets=targets) + changed = dict(raw, **{"SOURCE_MANIFEST.json": json.dumps(data).encode()}) + self.scope_error("TARGET_SCOPE", changed, rebound(profile, changed)) + + def test_missing_module_duplicate_root_and_production_input_swap_refused(self): + profile, raw = profile_and_projection() + original = json.loads(raw["SOURCE_MANIFEST.json"]) + data = dict(original, source_modules=original["source_modules"][:-1]) + changed = dict(raw, **{"SOURCE_MANIFEST.json": json.dumps(data).encode()}) + self.scope_error("MODULE_SCOPE", changed, rebound(profile, changed)) + text = raw["lakefile.toml"].decode() + for replacement in ( + text.replace('"GaussianSeriesFoundation", "SpectralWeights"', + '"GaussianSeriesFoundation", "GaussianSeriesFoundation"', 1), + text.replace('name = "SourceDerivativeInputs"\nsrcDir = "inputs"', + 'name = "SourceDerivativeInputs"\nsrcDir = "."', 1), + ): + with self.subTest(replacement=replacement[:30]): + changed = dict(raw, **{"lakefile.toml": replacement.encode()}) + self.scope_error("MODULE_SCOPE", changed, rebound(profile, changed)) + + def test_pin_toolchain_and_selected_source_hash_changes_refused(self): + profile, raw = profile_and_projection() + changed = dict(raw, **{"lean-toolchain": b"leanprover/lean4:v4.33.0\n"}) + self.scope_error("TOOLCHAIN_SCOPE", changed, rebound(profile, changed)) + lock = json.loads(raw["lake-manifest.json"]) + lock["packages"][0]["rev"] = "0" * 40 + changed = dict(raw, **{"lake-manifest.json": json.dumps(lock).encode()}) + self.scope_error("DEPENDENCY_SCOPE", changed, rebound(profile, changed)) + data = json.loads(raw["SOURCE_MANIFEST.json"]) + data["files"][profile["modules"][0]["path"]] = "0" * 64 + changed = dict(raw, **{"SOURCE_MANIFEST.json": json.dumps(data).encode()}) + self.scope_error("SOURCE_BINDING", changed, rebound(profile, changed)) + + def test_historical_status_strings_cannot_confer_authority(self): + profile, raw = profile_and_projection() + data = json.loads(raw["SOURCE_MANIFEST.json"]) + data.update(scientific_effect="PROMOTED", goal_status="CLOSED", + qualification_role="PASS_ALL", compiled_inventory_admitted=True) + changed = dict(raw, **{"SOURCE_MANIFEST.json": json.dumps(data).encode()}) + scope = api.extract_scope(changed, rebound(profile, changed), profile["source"]) + self.assert_blocked(scope) + self.assertEqual(scope["targets"], profile["targets"]) + + def test_source_files_exact_set_and_raw_hashes(self): + raw = {"Alpha.lean": b"alpha", "Beta.lean": b"beta"} + scope = {"modules": [{"path": p, "source_sha256": hashlib.sha256(b).hexdigest()} + for p, b in raw.items()]} + self.assertIsNone(api.verify_source_files(scope, raw)) + for changed in ({}, dict(raw, **{"Alpha.lean": b"changed"}), + dict(raw, **{"Unexpected.lean": b"extra"})): + with self.subTest(keys=list(changed)): + with self.assertRaises(api.ScopeError): + api.verify_source_files(scope, changed) + + def test_missing_extra_input_duplicate_json_key_and_escaping_path_refused(self): + profile, raw = profile_and_projection() + missing = dict(raw); del missing["lean-toolchain"] + self.scope_error("INPUT_BINDING", missing, profile) + self.scope_error("INPUT_BINDING", dict(raw, unexpected=b"x"), profile) + text = raw["SOURCE_MANIFEST.json"].decode() + changed = dict(raw, **{"SOURCE_MANIFEST.json": + text.replace('"inherited_input_count": 32', + '"inherited_input_count": 32, "inherited_input_count": 32', 1).encode()}) + self.scope_error("JSON_PROTOCOL", changed, rebound(profile, changed)) + for path in ("../escape.lean", "/absolute.lean"): + data = json.loads(raw["SOURCE_MANIFEST.json"]) + data["source_modules"][0] = path + changed = dict(raw, **{"SOURCE_MANIFEST.json": json.dumps(data).encode()}) + self.scope_error("PATH_SCOPE", changed, rebound(profile, changed)) + + +class NameContracts(ContractCase): + def test_lossless_unicode_quoted_numeric_private_and_empty_components(self): + vectors = [ + (("I4SourceSmoothParameterSpace", "weightedCarrier_memℓp"), + encoded("I4SourceSmoothParameterSpace", "weightedCarrier_memℓp")), + (("a.b", 0, "x"), "s612e62/n0/s78"), + (("a", "b", "0"), "s61/s62/s30"), + (("_private", ".lake", "Alpha", 0, "hidden"), PRIVATE.replace("/s416c706861/", "/s2e6c616b65/s416c706861/")), + (("",), "s"), ((), ""), + ] + for name, wire in vectors: + with self.subTest(name=name): + self.assertEqual(api.encode_name(name), wire) + self.assertEqual(api.decode_name(wire), name) + distinct = [encoded("ℓ"), encoded("l"), encoded("é"), encoded("e\u0301"), + encoded("a.b"), encoded("a", "b"), encoded(0), encoded("0")] + self.assertEqual(len({api.decode_name(x) for x in distinct}), len(distinct)) + + def test_malformed_or_noncanonical_name_encodings_refused(self): + for wire in ("s0", "sGG", "sff", "sC3A9", "n", "n01", "n-1", "s61//s62", "/s61", "s61/"): + with self.subTest(wire=wire): + with self.assertRaises(api.NameProtocolError): + api.decode_name(wire) + for name in ((True,), (-1,), (1.5,)): + with self.subTest(name=name): + with self.assertRaises(api.NameProtocolError): + api.encode_name(name) + + +class InventoryContracts(ContractCase): + def test_complete_private_parts_foreign_namespace_and_data_are_retained(self): + inventory = api.parse_inventory(transcript(records())) + self.assertEqual(len(inventory["modules"]), 2) + self.assertEqual({x["name"] for x in inventory["declarations"]}, + {PUBLIC, PRIVATE, DATA, FOREIGN}) + self.assertEqual(inventory["axioms"], []) + result = api.classify_inventory(inventory, fixture_scope()) + self.assert_blocked(result) + self.assertEqual(result["findings"], []) + self.assertEqual(result["counts"], {"owned_declarations": 4, "public_targets": 2, + "proposition_targets": 1, "data_targets": 1}) + self.assertTrue(BLOCKERS.issubset(set(result["blockers"]))) + + def test_truncation_duplicate_keys_trailing_records_and_noise_refused(self): + good = records() + malformed = [ + transcript(good[:-1]), transcript(good + [good[0]]), + transcript([good[0], good[0]] + good[1:]), + transcript(good).replace('"schema":1', '"schema":1,"schema":1', 1), + transcript(good).replace('"const_count":2', '"const_count":true', 1), + transcript(good).replace('"const_count":2', '"const_count":NaN', 1), + "noise\n" + transcript(good), transcript(good) + "\n", + ] + for text in malformed: + with self.subTest(text=text[:70]): + with self.assertRaises(api.InventoryProtocolError): + api.parse_inventory(text) + + def test_module_part_length_identity_duplicates_visibility_and_rows_reconcile(self): + mutations = [] + x = records(); x[1]["object_parts"][-1]["constant_names"] = [PUBLIC]; mutations.append(x) + x = records(); x[1]["object_parts"][-1]["constant_names"] = [PRIVATE, PUBLIC]; mutations.append(x) + x = records(); x[1]["object_parts"][-1] = part("private", [PUBLIC, PUBLIC]); mutations.append(x) + x = records(); x[1]["object_parts"] = list(reversed(x[1]["object_parts"])); mutations.append(x) + x = records(); x[1]["const_count"] = 1; mutations.append(x) + x = records(); del x[4]; x[-1]["declaration_count"] = 3; mutations.append(x) + x = records(); x[4] = copy.deepcopy(x[3]); mutations.append(x) + x = records(); x[3]["object_part_sha256"] = "0" * 64; mutations.append(x) + for rows in mutations: + with self.subTest(rows=rows[1]): + with self.assertRaises(api.InventoryProtocolError): + api.parse_inventory(transcript(rows)) + + def test_scope_target_prop_data_extras_and_skip_findings_are_explicit(self): + for change, code in (("target", "TARGET_SCOPE"), ("data", "TARGET_KIND_COUNTS"), + ("extras", "UNSUPPORTED_EXTRAS"), ("unsafe", "UNSAFE_REPLAY_SKIP"), + ("partial", "PARTIAL_REPLAY_SKIP")): + rows, scope = records(), fixture_scope() + if change == "target": scope["targets"] = ["Public.absent", "Public.d"] + elif change == "data": rows[5]["is_prop"] = True + elif change == "extras": rows[1]["extra_const_names"] = [encoded("extra")] + else: rows[4][change] = True + result = api.classify_inventory(api.parse_inventory(transcript(rows)), scope) + self.assert_blocked(result) + self.assertIn(code, {x["code"] for x in result["findings"]}) + + def test_private_forbidden_axiom_and_owned_axiom_never_admitted(self): + rows = records() + rows[4]["axioms"] = [encoded("sorryAx")] + rows[-1]["axioms"] = [encoded("sorryAx")] + result = api.classify_inventory(api.parse_inventory(transcript(rows)), fixture_scope()) + self.assert_blocked(result) + self.assertIn({"code": "FORBIDDEN_AXIOM", "name": encoded("sorryAx")}, result["findings"]) + rows = records() + rows[4]["kind"] = "axiom" + rows[4]["axioms"] = [encoded("propext")] + rows[-1]["axioms"] = [encoded("propext")] + result = api.classify_inventory(api.parse_inventory(transcript(rows)), fixture_scope()) + self.assertIn({"code": "OWNED_AXIOM", "name": PRIVATE}, result["findings"]) + rows[-1]["axioms"] = [] + with self.assertRaises(api.InventoryProtocolError): + api.parse_inventory(transcript(rows)) + + def test_missing_scope_module_and_input_owned_target_are_reported(self): + rows = records() + rows = [row for row in rows if not + (row["record"] == "module" and row["name"] == BETA or + row["record"] == "declaration" and row["module"] == BETA)] + rows[-1].update(module_count=1, declaration_count=2) + result = api.classify_inventory(api.parse_inventory(transcript(rows)), fixture_scope()) + self.assertIn("MODULE_SCOPE", {x["code"] for x in result["findings"]}) + scope = fixture_scope() + scope["modules"][1]["role"] = "input" + result = api.classify_inventory(api.parse_inventory(transcript(records())), scope) + self.assertIn("TARGET_OWNER", {x["code"] for x in result["findings"]}) + self.assert_blocked(result) + + +class ReceiptContracts(ContractCase): + def test_positive_fixture_validates_declared_fields_without_execution_credit(self): + value = receipt() + result = api.classify_receipt(value, copy.deepcopy(value)) + self.assert_blocked(result) + self.assertEqual(result["binding_status"], "DECLARED_FIELDS_VALID") + self.assertEqual(result["findings"], []) + self.assertFalse(result["execution_authenticated"]) + self.assertTrue(BLOCKERS.issubset(set(result["blockers"]))) + + def test_source_tool_profile_object_log_and_attempt_binding_mismatches(self): + expected = receipt() + for path in ( + ("source", "commit"), ("source", "tree"), ("source", "repository"), + ("toolchain", "lean_sha256"), ("adapter_sha256",), ("profile_sha256",), + ("owned_objects_sha256",), ("run", "attempt"), ("run", "id"), ("run", "job_id"), + ): + changed = copy.deepcopy(expected) + cursor = changed + for key in path[:-1]: cursor = cursor[key] + old = cursor[path[-1]] + cursor[path[-1]] = (999 if type(old) is int else "0" * len(old) + if len(old) in (40, 64) else "other/Repository") + with self.subTest(path=path): + self.invalid_receipt(changed, expected, "RECEIPT_BINDING") + changed = copy.deepcopy(expected); changed["steps"][0]["stdout_sha256"] = H + self.invalid_receipt(changed, expected, "RECEIPT_BINDING") + + def test_missing_fields_drift_coverage_skips_and_step_failure_are_not_pass(self): + expected = receipt() + for change, code in ( + ("missing_signal", "RECEIPT_SCHEMA"), ("missing_timeout", "RECEIPT_SCHEMA"), + ("bool_exit", "RECEIPT_SCHEMA"), ("nonzero", "STEP_FAILED"), + ("signal", "STEP_FAILED"), ("timeout", "STEP_FAILED"), + ("drift", "SOURCE_DRIFT"), ("cache", "CACHE_DRIFT"), + ("coverage", "MODULE_COVERAGE"), ("unsafe", "REPLAY_SKIPPED"), + ("partial", "REPLAY_SKIPPED"), ("missing_step", "STEP_COVERAGE"), + ("duplicate_step", "STEP_COVERAGE"), ("negative_resource", "RECEIPT_SCHEMA"), + ): + changed = copy.deepcopy(expected) + if change == "missing_signal": del changed["steps"][0]["signal"] + elif change == "missing_timeout": del changed["steps"][0]["timed_out"] + elif change == "bool_exit": changed["steps"][0]["exit_code"] = True + elif change == "nonzero": changed["steps"][0]["exit_code"] = 1 + elif change == "signal": changed["steps"][0]["signal"] = 9 + elif change == "timeout": changed["steps"][0]["timed_out"] = True + elif change == "drift": changed["inputs_after_sha256"] = "0" * 64 + elif change == "cache": changed["cache_after_sha256"] = "0" * 64 + elif change == "coverage": changed["module_coverage"] = [ALPHA] + elif change == "unsafe": changed["unsafe_skipped"] = [PRIVATE] + elif change == "partial": changed["partial_skipped"] = [PRIVATE] + elif change == "missing_step": changed["steps"].pop() + elif change == "duplicate_step": changed["steps"].append(copy.deepcopy(changed["steps"][0])) + else: changed["steps"][0]["max_rss_kib"] = -1 + with self.subTest(change=change): + self.invalid_receipt(changed, expected, code) + + def test_missing_whole_identity_coverage_or_log_field_is_schema_failure(self): + expected = receipt() + for field in ("source", "toolchain", "profile_sha256", "run", "module_coverage", + "unsafe_skipped", "partial_skipped", "owned_objects_sha256"): + changed = copy.deepcopy(expected); del changed[field] + with self.subTest(field=field): + self.invalid_receipt(changed, expected, "RECEIPT_SCHEMA") + changed = copy.deepcopy(expected); del changed["steps"][0]["stdout_sha256"] + self.invalid_receipt(changed, expected, "RECEIPT_SCHEMA") + + + +if __name__ == "__main__": + unittest.main() From 4b773d198f95cc342d85bd097f903a50920a8fb0 Mon Sep 17 00:00:00 2001 From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com> Date: Mon, 9 Nov 2026 15:39:30 -0600 Subject: [PATCH 2/4] Implement pure SDGA scope and declared-protocol checks Preserve fixed99source/1137target profile and all21contract controls. Validate only declaredfields; keep qualification BLOCKED, scientific effect NONE and execution unauthenticated. Register exact verification commands; hosted results and review remain pending. --- DECISIONS.md | 17 ++ GOVERNANCE.md | 32 +++ TOOLING.md | 32 +++ tools/sdga_scope.py | 595 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 676 insertions(+) create mode 100644 tools/sdga_scope.py diff --git a/DECISIONS.md b/DECISIONS.md index aff162111..f44be3cb6 100644 --- a/DECISIONS.md +++ b/DECISIONS.md @@ -152,3 +152,20 @@ Append-only. Historical source outcomes remain in their original records. remain explicit. Later private/all-part inventory, missing-fatal axiom traversal and exact sequential replay require their own real Lean controls. No proof source, bound, disposition or scientific status is changed. + +## 2026-11-09 — observed SDGA implementation absence and pure candidate + +- Root independently read run42702101999/attempt1/job129449186722: both source + checkouts, Python and exactMathf532/treeb713 guard succeeded. All four normal/ + optimized commands failed solely importing absent sdga_scope. Pure loaders + ran one failed-import test each; intended20+1 bodies did not run. No adverse, + mutation, live, Lean or passing credit follows. +- Author was then authorized to implement only the pure standard-library + `tools/sdga_scope.py` APIs against unchanged contracts/profile/configs. The + source candidate has no process/Git/network/filesystem/Lean execution API; + all observations remainBLOCKED/NONE, receipt execution_authenticatedfalse. + Original raw/config/test hashes were not changed to accommodate output. +- Root registers the library and its exact20offline+1mandatorypinned controls + per mode, publishes the source candidate, and requires actual hosted results + plus fresh complete engineering source review before integration. This is + tooling toward fresh owned observations, not proof or scientific acceptance. diff --git a/GOVERNANCE.md b/GOVERNANCE.md index b90ad756c..6b7a60b5a 100644 --- a/GOVERNANCE.md +++ b/GOVERNANCE.md @@ -901,3 +901,35 @@ false-credit cases, source-mutant controls and corrected failed attempts remain in the evidence. No original test, bound or expected verdict is weakened. Maintenance owner: none; frozen profile, self-contained. Requalify changed source/profile inputs; do not convert this registration into global admission. + +## SDGA source and declared-protocol library candidate + +`tools/sdga_scope.py` is a standard-library Python3.11+ library for fixed SDGA +source extraction, lossless Name encoding, declared JSONL inventory consistency +and receipt-field validation. It executes no Git, process, network, filesystem +read/write or Lean operation. It serves source-bound inspection and tooling +soundness; it cannot authenticate execution, classify complete mathematical +roles or award G2--G4 or CBZ. All returned classification/qualification fields +remain `BLOCKED`, scientific effect `NONE`, and execution authentication false. + +From a Main checkout, run its20offline contracts in both modes: + +```sh +python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v +python3 -B -O -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v +``` + +The separately mandatory `tests/sdga_source_observation.py` must also run in +both modes after guarding exact Mathf532 commit/tree and setting its three +required source environment fields; missing inputs fail rather than skip. +The read-only `sdga-scope-contract` workflow performs that guard and all four +commands, binding original inputs and99sources and retaining original logs. +See [the design](docs/cbz/SDGA_COMPONENT_DESIGN.md) and +[the exact plan](docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md). + +Self-verification is pending actual current-source execution of all21controls +per mode and fresh engineering review. Initial hosted missing-module failures +remain implementation-absence evidence only. No Lean inventory/replay/axiom +observation is inferred from declared fixture fields. Maintenance owner: none; +this library is self-contained with immutable source profile and explicit +contracts. No source proof, bound, scientific status or gate threshold changes. diff --git a/TOOLING.md b/TOOLING.md index 53dc5278f..59310a2af 100644 --- a/TOOLING.md +++ b/TOOLING.md @@ -906,3 +906,35 @@ Fresh nine-checkout generate and verify each exited 0 with 27,826 entries, zero classifications and false certification flags. These receipts bind the repaired tool source and the recorded parent checkouts; they do not qualify a later candidate integration tree or award a final gate. + +## SDGA source and declared-protocol library candidate + +`tools/sdga_scope.py` is a standard-library Python3.11+ library for fixed SDGA +source extraction, lossless Name encoding, declared JSONL inventory consistency +and receipt-field validation. It executes no Git, process, network, filesystem +read/write or Lean operation. It serves source-bound inspection and tooling +soundness; it cannot authenticate execution, classify complete mathematical +roles or award G2--G4 or CBZ. All returned classification/qualification fields +remain `BLOCKED`, scientific effect `NONE`, and execution authentication false. + +From a Main checkout, run its20offline contracts in both modes: + +```sh +python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v +python3 -B -O -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v +``` + +The separately mandatory `tests/sdga_source_observation.py` must also run in +both modes after guarding exact Mathf532 commit/tree and setting its three +required source environment fields; missing inputs fail rather than skip. +The read-only `sdga-scope-contract` workflow performs that guard and all four +commands, binding original inputs and99sources and retaining original logs. +See [the design](docs/cbz/SDGA_COMPONENT_DESIGN.md) and +[the exact plan](docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md). + +Self-verification is pending actual current-source execution of all21controls +per mode and fresh engineering review. Initial hosted missing-module failures +remain implementation-absence evidence only. No Lean inventory/replay/axiom +observation is inferred from declared fixture fields. Maintenance owner: none; +this library is self-contained with immutable source profile and explicit +contracts. No source proof, bound, scientific status or gate threshold changes. diff --git a/tools/sdga_scope.py b/tools/sdga_scope.py new file mode 100644 index 000000000..d00a866e5 --- /dev/null +++ b/tools/sdga_scope.py @@ -0,0 +1,595 @@ +"""Pure SDGA source/protocol observations; this module never certifies execution. + +No process, Git, network, filesystem-read/write or Lean execution API is provided. +Caller-provided bindings are declarations, not independent provenance. +""" +from __future__ import annotations + +from datetime import datetime +import hashlib +import json +import math +import re +import tomllib + +__all__ = [ + "ScopeError", "NameProtocolError", "InventoryProtocolError", + "extract_scope", "verify_source_files", "encode_name", "decode_name", + "parse_inventory", "classify_inventory", "classify_receipt", +] + +_BLOCKERS = ( + "EXACT_TYPE_SEMANTICS_UNRESOLVED", + "FULL_DECLARATION_ROLES_UNRESOLVED", + "EXECUTION_NOT_OBSERVED", + "KERNEL_COVERAGE_UNESTABLISHED", +) +_INPUTS = {"lakefile.toml", "lake-manifest.json", "lean-toolchain", "SOURCE_MANIFEST.json"} +_LEAN = b"leanprover/lean4:v4.34.1\n" +_LEAN_COMMIT = "5045d0056413266e57c625dcd7c365b10e377c52" +_HASH = re.compile(r"[0-9a-f]{64}") +_GIT = re.compile(r"[0-9a-f]{40}") +_MODULE_COMPONENT = re.compile(r"[A-Za-z_][A-Za-z0-9_']*") +_KINDS = {"theorem", "definition", "opaque", "axiom", "inductive", + "constructor", "recursor", "quotient"} + + +class _ContractError(ValueError): + def __init__(self, code: str, message: str = ""): + self.code = code + super().__init__(code + (": " + message if message else "")) + + +class ScopeError(_ContractError): + """Source bytes or a declared source scope do not match their bindings.""" + + +class NameProtocolError(_ContractError): + """A lossless Name is malformed or noncanonical.""" + + +class InventoryProtocolError(_ContractError): + """No inventory has been accepted from this malformed transcript.""" + + +def _need(condition, error, code, note): + if not condition: + raise error(code, note) + + +def _nat(value): + return type(value) is int and value >= 0 + + +def _hex(value, pattern=_HASH): + return type(value) is str and pattern.fullmatch(value) is not None + + +def _blocked(): + return { + "scientific_effect": "NONE", + "qualification": "BLOCKED", + "classification_status": "BLOCKED", + "execution_authenticated": False, + "blockers": list(_BLOCKERS), + } + + +def _pairs(pairs): + result = {} + for key, value in pairs: + if key in result: + raise ValueError("duplicate JSON key: " + key) + result[key] = value + return result + + +def _finite_float(raw): + value = float(raw) + if not math.isfinite(value): + raise ValueError("nonfinite JSON number") + return value + + +def _constant(raw): + raise ValueError("nonfinite JSON constant: " + raw) + + +def _json(text, error, code): + try: + return json.loads(text, object_pairs_hook=_pairs, parse_float=_finite_float, + parse_constant=_constant) + except (ValueError, TypeError, RecursionError) as exc: + raise error(code, str(exc)) from exc + + +def _source_path(value): + _need(type(value) is str and bool(value), ScopeError, "PATH_SCOPE", "empty source path") + fields = value.split("/") + _need(not value.startswith("/") and "\\" not in value and "\0" not in value + and all(field not in ("", ".", "..") for field in fields) + and value.endswith(".lean"), + ScopeError, "PATH_SCOPE", "unsafe source path") + return value + + +def _module_name(value): + _need(type(value) is str and bool(value) + and all(_MODULE_COMPONENT.fullmatch(field) for field in value.split(".")), + ScopeError, "MODULE_SCOPE", "invalid module name") + return value + + +def _target_name(value): + _need(type(value) is str and bool(value), ScopeError, "TARGET_SCOPE", "empty target") + fields = value.split(".") + _need(all(field and (field[0].isalpha() or field[0] == "_") + and all(c.isalnum() or c in "_'" for c in field) for field in fields), + ScopeError, "TARGET_SCOPE", "unsupported dotted target name") + try: + value.encode("utf-8") + except UnicodeEncodeError as exc: + raise ScopeError("TARGET_SCOPE", "invalid target Unicode") from exc + return tuple(fields) + + +def extract_scope(raw_inputs: dict[str, bytes], profile: dict, + observed_identity: dict) -> dict: + """Check declared raw bindings and independently extract the frozen source scope.""" + _need(type(raw_inputs) is dict and set(raw_inputs) == _INPUTS + and type(profile) is dict and type(profile.get("inputs")) is dict + and set(profile["inputs"]) == _INPUTS, + ScopeError, "INPUT_BINDING", "exactly four bound inputs are required") + for name in sorted(_INPUTS): + raw, binding = raw_inputs[name], profile["inputs"][name] + _need(type(raw) is bytes and type(binding) is dict, + ScopeError, "INPUT_BINDING", name) + _need(_nat(binding.get("bytes")) and len(raw) == binding["bytes"] + and _hex(binding.get("sha256")) and _hex(binding.get("git_blob"), _GIT), + ScopeError, "INPUT_BINDING", name) + digest = hashlib.sha256(raw).hexdigest() + blob = hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest() + _need(digest == binding["sha256"] and blob == binding["git_blob"], + ScopeError, "INPUT_BINDING", name) + identity = profile.get("source") + _need(type(identity) is dict and type(observed_identity) is dict + and observed_identity == identity, + ScopeError, "SOURCE_IDENTITY", "source identity differs") + _need(raw_inputs["lean-toolchain"] == _LEAN + and profile.get("lean_release_commit") == _LEAN_COMMIT, + ScopeError, "TOOLCHAIN_SCOPE", "pinned Lean differs") + try: + config = tomllib.loads(raw_inputs["lakefile.toml"].decode("utf-8")) + except (ValueError, UnicodeError) as exc: + raise ScopeError("MODULE_SCOPE", "invalid TOML") from exc + manifest = _json(raw_inputs["SOURCE_MANIFEST.json"], ScopeError, "JSON_PROTOCOL") + lock = _json(raw_inputs["lake-manifest.json"], ScopeError, "JSON_PROTOCOL") + _need(type(manifest) is dict and type(lock) is dict, + ScopeError, "JSON_PROTOCOL", "JSON object required") + + packages = lock.get("packages") + _need(type(packages) is list and all(type(p) is dict for p in packages), + ScopeError, "DEPENDENCY_SCOPE", "missing package lock") + pins = [{"name": p.get("name"), "rev": p.get("rev")} for p in packages] + _need(pins == profile.get("dependency_pins") and len(pins) == 9 + and all(type(p["name"]) is str and _hex(p["rev"], _GIT) for p in pins) + and len({p["name"] for p in pins}) == len(pins), + ScopeError, "DEPENDENCY_SCOPE", "dependency pins differ") + mathlib = next((p["rev"] for p in pins if p["name"] == "mathlib"), None) + required = config.get("require") + _need(type(required) is list and len(required) == 1 + and type(required[0]) is dict and required[0].get("name") == "mathlib" + and required[0].get("rev") == mathlib + and required[0].get("git") == "https://github.com/leanprover-community/mathlib4.git", + ScopeError, "DEPENDENCY_SCOPE", "Mathlib requirement differs") + + sources = manifest.get("source_modules") + _need(type(sources) is list, ScopeError, "MODULE_SCOPE", "missing source modules") + for path in sources: + _source_path(path) + _need(config.get("name") == "source_derivative_gaussian", + ScopeError, "MODULE_SCOPE", "package name differs") + defaults, libraries = config.get("defaultTargets"), config.get("lean_lib") + _need(type(defaults) is list and type(libraries) is list + and all(type(lib) is dict for lib in libraries), + ScopeError, "MODULE_SCOPE", "missing library registration") + for name in defaults: + _module_name(name) + _need(len(defaults) == 67 and len(set(defaults)) == len(defaults), + ScopeError, "MODULE_SCOPE", "production roots differ") + by_name = {} + for lib in libraries: + name = _module_name(lib.get("name")) + _need(name not in by_name, ScopeError, "MODULE_SCOPE", "duplicate library") + by_name[name] = lib + _need(set(by_name) == set(defaults) | {"SourceDerivativeInputs", "SourceElderInputs"}, + ScopeError, "MODULE_SCOPE", "unexpected library registration") + rows = [] + for name in defaults: + lib = by_name[name] + _need(lib.get("srcDir", ".") == "." and lib.get("roots", [name]) == [name], + ScopeError, "MODULE_SCOPE", "production library changed") + rows.append({"module": name, "path": name.replace(".", "/") + ".lean", + "role": "production"}) + production_paths = [row["path"] for row in rows] + _need(sources == production_paths, ScopeError, "MODULE_SCOPE", + "source modules differ from production roots") + for library, directory, count in ( + ("SourceDerivativeInputs", "inputs", 25), + ("SourceElderInputs", "inputs/elder", 7), + ): + lib = by_name[library] + roots = lib.get("roots") + _need(lib.get("srcDir") == directory and type(roots) is list and len(roots) == count, + ScopeError, "MODULE_SCOPE", "input registration differs") + for name in roots: + _module_name(name) + rows.append({"module": name, "path": directory + "/" + name.replace(".", "/") + ".lean", + "role": "input"}) + _need(len(rows) == 99 and len({row["module"] for row in rows}) == 99 + and len({row["path"] for row in rows}) == 99 + and type(manifest.get("inherited_input_count")) is int + and manifest["inherited_input_count"] == 32, + ScopeError, "MODULE_SCOPE", "duplicate/missing input roots") + wanted = profile.get("modules") + _need(type(wanted) is list and all(type(row) is dict for row in wanted), + ScopeError, "MODULE_SCOPE", "missing frozen module matrix") + identities = [{key: row.get(key) for key in ("module", "path", "role")} for row in wanted] + _need(rows == identities, ScopeError, "MODULE_SCOPE", "module/path/role binding differs") + files = manifest.get("files") + _need(type(files) is dict, ScopeError, "SOURCE_BINDING", "missing source hashes") + for row, expected in zip(rows, wanted): + value = files.get(row["path"]) + _need(_hex(value) and value == expected.get("source_sha256"), + ScopeError, "SOURCE_BINDING", row["path"]) + row["source_sha256"] = value + matrix = json.dumps(rows, ensure_ascii=False, separators=(",", ":")).encode("utf-8") + _need(hashlib.sha256(matrix).hexdigest() == profile.get("module_vector_sha256"), + ScopeError, "SOURCE_BINDING", "module matrix digest differs") + + targets = manifest.get("targets") + _need(type(targets) is list and all(type(x) is str for x in targets), + ScopeError, "TARGET_SCOPE", "missing target vector") + for target in targets: + _target_name(target) + _need(len(targets) == 1137 and len(set(targets)) == len(targets) + and targets == profile.get("targets"), + ScopeError, "TARGET_SCOPE", "literal target vector differs") + vector = ("\n".join(targets) + "\n").encode("utf-8") + _need(hashlib.sha256(vector).hexdigest() == profile.get("target_vector_sha256"), + ScopeError, "TARGET_SCOPE", "target vector digest differs") + counts = profile.get("expected_counts") + expected_counts = {"production_modules": 67, "input_modules": 32, "ordinary_inputs": 25, + "elder_inputs": 7, "public_targets": 1137, + "proposition_targets": 1128, "data_targets": 9} + _need(type(counts) is dict and counts == expected_counts + and all(type(x) is int for x in counts.values()), + ScopeError, "MODULE_SCOPE", "frozen expected counts differ") + _need(type(profile.get("scope_id")) is str and bool(profile["scope_id"]), + ScopeError, "SOURCE_IDENTITY", "missing scope identity") + result = _blocked() + result.update(scope_id=profile["scope_id"], source=dict(identity), modules=rows, + targets=list(targets), expected_counts=dict(counts)) + return result + + +def verify_source_files(scope: dict, source_files: dict[str, bytes]) -> None: + """Check an exact caller-provided byte map; never read paths from the filesystem.""" + _need(type(scope) is dict and type(scope.get("modules")) is list + and type(source_files) is dict, + ScopeError, "SOURCE_BINDING", "source maps required") + expected = {} + for row in scope["modules"]: + _need(type(row) is dict, ScopeError, "SOURCE_BINDING", "invalid source row") + path = _source_path(row.get("path")) + _need(path not in expected and _hex(row.get("source_sha256")), + ScopeError, "SOURCE_BINDING", "duplicate/invalid source binding") + expected[path] = row["source_sha256"] + _need(set(source_files) == set(expected), ScopeError, "SOURCE_BINDING", + "selected source set differs") + for path, digest in expected.items(): + raw = source_files[path] + _need(type(raw) is bytes and hashlib.sha256(raw).hexdigest() == digest, + ScopeError, "SOURCE_BINDING", path) + + +def encode_name(name: tuple[str | int, ...]) -> str: + """Preserve string/numeric components and Unicode code points exactly.""" + _need(type(name) is tuple, NameProtocolError, "NAME_PROTOCOL", "tuple required") + encoded = [] + try: + for component in name: + if type(component) is str: + encoded.append("s" + component.encode("utf-8").hex()) + elif _nat(component): + encoded.append("n" + str(component)) + else: + raise NameProtocolError("NAME_PROTOCOL", "invalid component type/value") + except (UnicodeError, ValueError) as exc: + if isinstance(exc, NameProtocolError): + raise + raise NameProtocolError("NAME_PROTOCOL", str(exc)) from exc + return "/".join(encoded) + + +def decode_name(encoded: str) -> tuple[str | int, ...]: + _need(type(encoded) is str, NameProtocolError, "NAME_PROTOCOL", "string required") + if encoded == "": + return () + result = [] + try: + for component in encoded.split("/"): + if re.fullmatch(r"s(?:[0-9a-f]{2})*", component): + result.append(bytes.fromhex(component[1:]).decode("utf-8")) + elif re.fullmatch(r"n(?:0|[1-9][0-9]*)", component): + result.append(int(component[1:])) + else: + raise NameProtocolError("NAME_PROTOCOL", "noncanonical component") + except (UnicodeError, ValueError) as exc: + if isinstance(exc, NameProtocolError): + raise + raise NameProtocolError("NAME_PROTOCOL", str(exc)) from exc + return tuple(result) + + +def _wire_name(value): + try: + name = decode_name(value) + except NameProtocolError as exc: + raise InventoryProtocolError("INVENTORY_PROTOCOL", str(exc)) from exc + _need(bool(name), InventoryProtocolError, "INVENTORY_PROTOCOL", "anonymous identity") + return value + + +def _wire_names(value, unique=True): + _need(type(value) is list, InventoryProtocolError, "INVENTORY_PROTOCOL", "name list required") + for name in value: + _wire_name(name) + _need(not unique or len(set(value)) == len(value), + InventoryProtocolError, "INVENTORY_PROTOCOL", "duplicate identity") + return value + + +def _keys(value, keys): + _need(type(value) is dict and set(value) == set(keys), + InventoryProtocolError, "INVENTORY_PROTOCOL", "record fields differ") + + +def parse_inventory(text: str) -> dict: + """Strict declared JSONL inventory; parser acceptance does not prove collection.""" + _need(type(text) is str and bool(text), InventoryProtocolError, + "INVENTORY_PROTOCOL", "empty transcript") + lines = text.split("\n") + if lines[-1] == "": + lines.pop() + _need(all(lines), InventoryProtocolError, "INVENTORY_PROTOCOL", "blank record") + records = [_json(line, InventoryProtocolError, "INVENTORY_PROTOCOL") for line in lines] + _need(len(records) >= 3 and all(type(row) is dict for row in records), + InventoryProtocolError, "INVENTORY_PROTOCOL", "incomplete transcript") + header, end = records[0], records[-1] + _keys(header, ("record", "schema", "scope_id")) + _keys(end, ("record", "module_count", "declaration_count", "axioms")) + _need(header["record"] == "header" and type(header["schema"]) is int + and header["schema"] == 1 and type(header["scope_id"]) is str + and bool(header["scope_id"]) and end["record"] == "end", + InventoryProtocolError, "INVENTORY_PROTOCOL", "header/end required") + modules, declarations, by_module, by_name = [], [], {}, {} + for row in records[1:-1]: + kind = row.get("record") + if kind == "module": + _keys(row, ("record", "name", "const_count", "object_parts", "extra_const_names")) + name = _wire_name(row["name"]) + _need(name not in by_module and _nat(row["const_count"]), + InventoryProtocolError, "INVENTORY_PROTOCOL", "duplicate module or invalid count") + parts = row["object_parts"] + _need(type(parts) is list and bool(parts), InventoryProtocolError, + "INVENTORY_PROTOCOL", "object parts required") + levels = [] + for part in parts: + _keys(part, ("level", "sha256", "const_names", "constant_names")) + level = part["level"] + _need(type(level) is str and level in ("exported", "server", "private") + and _hex(part["sha256"]), + InventoryProtocolError, "INVENTORY_PROTOCOL", "invalid part") + levels.append(("exported", "server", "private").index(level)) + left, right = _wire_names(part["const_names"]), _wire_names(part["constant_names"]) + _need(left == right, InventoryProtocolError, "INVENTORY_PROTOCOL", + "parallel constant tables differ") + _need(levels[0] == 0 and levels == sorted(set(levels)), + InventoryProtocolError, "INVENTORY_PROTOCOL", "part visibility order differs") + final = parts[-1]["const_names"] + _need(row["const_count"] == len(final) + and all(set(part["const_names"]).issubset(final) for part in parts), + InventoryProtocolError, "INVENTORY_PROTOCOL", "part population differs") + _wire_names(row["extra_const_names"]) + modules.append(row) + by_module[name] = row + elif kind == "declaration": + _keys(row, ("record", "module", "name", "kind", "is_prop", "is_private", "unsafe", + "partial", "type_display", "object_part_sha256", "axioms")) + _wire_name(row["module"]) + name = _wire_name(row["name"]) + _need(name not in by_name and type(row["kind"]) is str and row["kind"] in _KINDS + and all(type(row[key]) is bool for key in ("is_prop", "is_private", "unsafe", "partial")) + and type(row["type_display"]) is str and bool(row["type_display"]) + and _hex(row["object_part_sha256"]), + InventoryProtocolError, "INVENTORY_PROTOCOL", "invalid/duplicate declaration") + _wire_names(row["axioms"]) + declarations.append(row) + by_name[name] = row + else: + raise InventoryProtocolError("INVENTORY_PROTOCOL", "unexpected record") + _need(bool(modules) and _nat(end["module_count"]) and _nat(end["declaration_count"]) + and end["module_count"] == len(modules) and end["declaration_count"] == len(declarations), + InventoryProtocolError, "INVENTORY_PROTOCOL", "terminal counts differ") + populations = {name: set() for name in by_module} + for row in declarations: + module = by_module.get(row["module"]) + _need(module is not None, InventoryProtocolError, "INVENTORY_PROTOCOL", "unknown owner") + _need(row["object_part_sha256"] == module["object_parts"][-1]["sha256"], + InventoryProtocolError, "INVENTORY_PROTOCOL", "declaration object binding differs") + populations[row["module"]].add(row["name"]) + for name, module in by_module.items(): + _need(populations[name] == set(module["object_parts"][-1]["const_names"]), + InventoryProtocolError, "INVENTORY_PROTOCOL", "declaration coverage differs") + axioms = _wire_names(end["axioms"]) + union = {name for row in declarations for name in row["axioms"]} + _need(set(axioms) == union, InventoryProtocolError, "INVENTORY_PROTOCOL", "axiom union differs") + return {"scope_id": header["scope_id"], "modules": modules, + "declarations": declarations, "axioms": axioms} + + +def classify_inventory(inventory: dict, scope: dict) -> dict: + """Classify declared fields only; unknown roles/types/coverage always block.""" + result = _blocked() + findings = set() + def flag(code, name): + findings.add((code, name)) + _need(type(inventory) is dict and type(scope) is dict + and all(key in inventory for key in ("scope_id", "modules", "declarations", "axioms")) + and type(scope.get("modules")) is list and type(scope.get("targets")) is list, + InventoryProtocolError, "INVENTORY_PROTOCOL", "parsed inventory and scope required") + expected_modules = {} + for row in scope["modules"]: + _need(type(row) is dict and row.get("role") in ("production", "input"), + ScopeError, "MODULE_SCOPE", "invalid scope module") + module = encode_name(tuple(_module_name(row.get("module")).split("."))) + _need(module not in expected_modules, ScopeError, "MODULE_SCOPE", "duplicate scope module") + expected_modules[module] = row + actual_modules = {row["name"] for row in inventory["modules"]} + if inventory["scope_id"] != scope.get("scope_id"): + flag("MODULE_SCOPE", "scope_id") + for name in actual_modules.symmetric_difference(expected_modules): + flag("MODULE_SCOPE", name) + wanted = {encode_name(_target_name(name)) for name in scope["targets"]} + _need(len(wanted) == len(scope["targets"]), ScopeError, "TARGET_SCOPE", "duplicate scope target") + declarations = {row["name"]: row for row in inventory["declarations"]} + for name in wanted - declarations.keys(): + flag("TARGET_SCOPE", name) + public = [declarations[name] for name in sorted(wanted & declarations.keys())] + for row in public: + owner = expected_modules.get(row["module"]) + if owner is None or owner["role"] != "production" or row["is_private"]: + flag("TARGET_OWNER", row["name"]) + propositions = sum(row["is_prop"] for row in public) + counts = {"owned_declarations": len(inventory["declarations"]), "public_targets": len(public), + "proposition_targets": propositions, "data_targets": len(public) - propositions} + expected_counts = scope.get("expected_counts", {}) + if any(counts[key] != expected_counts.get(key) for key in + ("public_targets", "proposition_targets", "data_targets")): + flag("TARGET_KIND_COUNTS", "targets") + for module in inventory["modules"]: + if module["extra_const_names"]: + flag("UNSUPPORTED_EXTRAS", module["name"]) + for row in inventory["declarations"]: + if row["kind"] == "axiom": + flag("OWNED_AXIOM", row["name"]) + if row["unsafe"]: + flag("UNSAFE_REPLAY_SKIP", row["name"]) + if row["partial"]: + flag("PARTIAL_REPLAY_SKIP", row["name"]) + allowed = {encode_name(("propext",)), encode_name(("Classical", "choice")), + encode_name(("Quot", "sound"))} + for name in set(inventory["axioms"]) - allowed: + flag("FORBIDDEN_AXIOM", name) + result.update(counts=counts, findings=[{"code": code, "name": name} + for code, name in sorted(findings)]) + return result + + +def _receipt_need(condition, note): + if not condition: + raise ValueError(note) + + +def _receipt_keys(value, keys): + _receipt_need(type(value) is dict and set(value) == set(keys), "receipt fields differ") + + +def _utc(value): + _receipt_need(type(value) is str and value.endswith("Z"), "UTC timestamp required") + return datetime.fromisoformat(value[:-1] + "+00:00") + + +def _receipt_schema(value): + _receipt_keys(value, ( + "schema", "scope_id", "scientific_effect", "source", "adapter_sha256", "profile_sha256", + "run", "toolchain", "inputs_before_sha256", "inputs_after_sha256", + "cache_before_sha256", "cache_after_sha256", "owned_objects_sha256", + "module_coverage", "unsafe_skipped", "partial_skipped", "steps", + )) + _receipt_need(type(value["schema"]) is int and value["schema"] == 1 + and type(value["scope_id"]) is str and bool(value["scope_id"]) + and value["scientific_effect"] == "NONE", "receipt schema/scope differs") + source = value["source"] + _receipt_keys(source, ("repository", "commit", "tree")) + _receipt_need(type(source["repository"]) is str and bool(source["repository"]) + and _hex(source["commit"], _GIT) and _hex(source["tree"], _GIT), "source schema") + run = value["run"] + _receipt_keys(run, ("repository", "id", "attempt", "job_id")) + _receipt_need(type(run["repository"]) is str and bool(run["repository"]) + and all(_nat(run[k]) and run[k] > 0 for k in ("id", "attempt", "job_id")), + "run schema") + toolchain = value["toolchain"] + _receipt_keys(toolchain, ("commit", "lean_sha256", "lake_sha256")) + _receipt_need(_hex(toolchain["commit"], _GIT) and _hex(toolchain["lean_sha256"]) + and _hex(toolchain["lake_sha256"]), "toolchain schema") + for key in ("adapter_sha256", "profile_sha256", "inputs_before_sha256", "inputs_after_sha256", + "cache_before_sha256", "cache_after_sha256", "owned_objects_sha256"): + _receipt_need(_hex(value[key]), "hash schema: " + key) + for key in ("module_coverage", "unsafe_skipped", "partial_skipped"): + _wire_names(value[key], unique=False) + _receipt_need(type(value["steps"]) is list, "step list required") + for step in value["steps"]: + _receipt_keys(step, ("name", "exit_code", "signal", "timed_out", "stdout_sha256", + "stderr_sha256", "started_utc", "ended_utc", "duration_ns", "max_rss_kib")) + _receipt_need(type(step["name"]) is str and bool(step["name"]) + and type(step["exit_code"]) is int + and (step["signal"] is None or _nat(step["signal"]) and step["signal"] > 0) + and type(step["timed_out"]) is bool + and _hex(step["stdout_sha256"]) and _hex(step["stderr_sha256"]) + and _nat(step["duration_ns"]) and _nat(step["max_rss_kib"]), + "step schema") + _receipt_need(_utc(step["ended_utc"]) >= _utc(step["started_utc"]), "backwards step UTC") + + +def classify_receipt(receipt: dict, expected: dict) -> dict: + """Validate declared bindings; expected must be independently measured for later use. + + Even identical caller assertions only produce DECLARED_FIELDS_VALID, never proof + of execution. No filesystem/log authentication or qualified result exists here. + """ + result = _blocked() + result.update(binding_status="INVALID", findings=[]) + def reject(code, name): + result["findings"] = [{"code": code, "name": name}] + return result + for name, value in (("receipt", receipt), ("expected", expected)): + try: + _receipt_schema(value) + except (ValueError, TypeError, KeyError, OverflowError) as exc: + return reject("RECEIPT_SCHEMA", name + ": " + str(exc)) + expected_names = [step["name"] for step in expected["steps"]] + names = [step["name"] for step in receipt["steps"]] + required = ["build", "inventory"] + ["kernel:" + name for name in expected["module_coverage"]] + if (expected_names != required or names != expected_names + or len(set(names)) != len(names)): + return reject("STEP_COVERAGE", "steps") + if any(step["exit_code"] != 0 or step["signal"] is not None or step["timed_out"] + for value in (receipt, expected) for step in value["steps"]): + return reject("STEP_FAILED", "steps") + if any(value["inputs_before_sha256"] != value["inputs_after_sha256"] + for value in (receipt, expected)): + return reject("SOURCE_DRIFT", "inputs") + if any(value["cache_before_sha256"] != value["cache_after_sha256"] + for value in (receipt, expected)): + return reject("CACHE_DRIFT", "cache") + coverage = receipt["module_coverage"] + if coverage != expected["module_coverage"] or len(set(coverage)) != len(coverage): + return reject("MODULE_COVERAGE", "modules") + if any(value["unsafe_skipped"] or value["partial_skipped"] for value in (receipt, expected)): + return reject("REPLAY_SKIPPED", "declarations") + if receipt != expected: + return reject("RECEIPT_BINDING", "expected") + result["binding_status"] = "DECLARED_FIELDS_VALID" + return result From f160a96d19e2fa0361959a3c0a6ab7ffe33e68df Mon Sep 17 00:00:00 2001 From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com> Date: Mon, 9 Nov 2026 15:50:40 -0600 Subject: [PATCH 3/4] Expose malformed UTC and empty receipt coverage before guards Retain original20pure+1pinned controls and unmodified production. Add4timestamp subcases and nonempty coverage contract. Observe actual semantic RED before minimal repair; all qualification remains BLOCKED. --- .github/workflows/sdga-scope-contract.yml | 4 ++-- DECISIONS.md | 18 ++++++++++++++++++ GOVERNANCE.md | 4 ++-- TOOLING.md | 4 ++-- ...2026-11-09-sdga-task1-scope-classifiers.md | 19 ++++++++++++++----- tests/test_sdga_scope.py | 17 +++++++++++++++++ 6 files changed, 55 insertions(+), 11 deletions(-) diff --git a/.github/workflows/sdga-scope-contract.yml b/.github/workflows/sdga-scope-contract.yml index 6bf13a937..993424f9c 100644 --- a/.github/workflows/sdga-scope-contract.yml +++ b/.github/workflows/sdga-scope-contract.yml @@ -67,13 +67,13 @@ jobs: run: | set -euo pipefail python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v 2>&1 | tee "$RUNNER_TEMP/sdga-scope-normal.log" - grep -Eq '^Ran 20 tests in ' "$RUNNER_TEMP/sdga-scope-normal.log" + grep -Eq '^Ran 22 tests in ' "$RUNNER_TEMP/sdga-scope-normal.log" - name: Run pure scope contracts optimized if: ${{ !cancelled() }} run: | set -euo pipefail python3 -B -O -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v 2>&1 | tee "$RUNNER_TEMP/sdga-scope-optimized.log" - grep -Eq '^Ran 20 tests in ' "$RUNNER_TEMP/sdga-scope-optimized.log" + grep -Eq '^Ran 22 tests in ' "$RUNNER_TEMP/sdga-scope-optimized.log" - name: Observe original pinned source normally if: ${{ !cancelled() }} run: | diff --git a/DECISIONS.md b/DECISIONS.md index f44be3cb6..ab5ff3dea 100644 --- a/DECISIONS.md +++ b/DECISIONS.md @@ -169,3 +169,21 @@ Append-only. Historical source outcomes remain in their original records. per mode, publishes the source candidate, and requires actual hosted results plus fresh complete engineering source review before integration. This is tooling toward fresh owned observations, not proof or scientific acceptance. + +## 2026-11-09 — SDGA source observations and reviewed receipt counterexamples + +- Actual4b773d198f95cc342d85bd097f903a50920a8fb0/tree56a08809af9b8879ca57f2bd508cb942c1d22dcc + componentrun42704583824/attempt1/job129457919403 passed20pure plus1pinned + source control in each Python mode,42 successful method records/no skips. + ExactMathf532/treeb713 and original rawinputs/all99source bindings were + guarded. This is declared source/protocol evidence, not Lean execution. +- Full source review identified date-only UTC acceptance by fromisoformat; + identical malformed receipt/expected timestamps could be declared valid. + Root also explicitly requires nonempty module coverage for this fixed + nonempty SDGA observer, including caller-declared fixture scope. +- Preserve the original20 contracts and add2 methods against unchanged + productiond00a866e55c5d20fd4aeb8d44e51fa471f1d1031: four malformed UTC + subcases expectRECEIPT_SCHEMA; both-empty coverage with build/inventory + expectsMODULE_COVERAGE. There are now22pure plus1mandatorypinned controls + per mode. Actual semantic RED must precede the minimal two guards. No + expected profile/source/config bytes or existing assertions are weakened. diff --git a/GOVERNANCE.md b/GOVERNANCE.md index 6b7a60b5a..dcec087e6 100644 --- a/GOVERNANCE.md +++ b/GOVERNANCE.md @@ -912,7 +912,7 @@ soundness; it cannot authenticate execution, classify complete mathematical roles or award G2--G4 or CBZ. All returned classification/qualification fields remain `BLOCKED`, scientific effect `NONE`, and execution authentication false. -From a Main checkout, run its20offline contracts in both modes: +From a Main checkout, run its22offline contracts in both modes: ```sh python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v @@ -927,7 +927,7 @@ commands, binding original inputs and99sources and retaining original logs. See [the design](docs/cbz/SDGA_COMPONENT_DESIGN.md) and [the exact plan](docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md). -Self-verification is pending actual current-source execution of all21controls +Self-verification is pending actual current-source execution of all23controls per mode and fresh engineering review. Initial hosted missing-module failures remain implementation-absence evidence only. No Lean inventory/replay/axiom observation is inferred from declared fixture fields. Maintenance owner: none; diff --git a/TOOLING.md b/TOOLING.md index 59310a2af..1b6f57a4c 100644 --- a/TOOLING.md +++ b/TOOLING.md @@ -917,7 +917,7 @@ soundness; it cannot authenticate execution, classify complete mathematical roles or award G2--G4 or CBZ. All returned classification/qualification fields remain `BLOCKED`, scientific effect `NONE`, and execution authentication false. -From a Main checkout, run its20offline contracts in both modes: +From a Main checkout, run its22offline contracts in both modes: ```sh python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v @@ -932,7 +932,7 @@ commands, binding original inputs and99sources and retaining original logs. See [the design](docs/cbz/SDGA_COMPONENT_DESIGN.md) and [the exact plan](docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md). -Self-verification is pending actual current-source execution of all21controls +Self-verification is pending actual current-source execution of all23controls per mode and fresh engineering review. Initial hosted missing-module failures remain implementation-absence evidence only. No Lean inventory/replay/axiom observation is inferred from declared fixture fields. Maintenance owner: none; diff --git a/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md b/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md index d987d00bd..5795855dc 100644 --- a/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md +++ b/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md @@ -19,7 +19,7 @@ - No type AST serializer, Lean execution, proof changes, role admission, artifact authentication, generic orchestrator or external writes. - Reject bool where an integer is required. Do not normalize Unicode or collapse numeric/string Name components. - Initial missing-module import is valid absence evidence only. It provides no adverse-rejection or mutation credit. -- The dedicated read-only component workflow always checks out pinned Math and executes all 20 offline methods plus the one explicit pinned-source method in both normal and optimized Python. No optional coverage, skipTest, conditional disable or selective green matrix. +- The dedicated read-only component workflow always checks out pinned Math and executes all 22 offline methods plus the one explicit pinned-source method in both normal and optimized Python. No optional coverage, skipTest, conditional disable or selective green matrix. - Do not add a placeholder production scaffold. Root publishes the immutable test-first draft, captures hosted RED, then authorizes implementation. ## Review Focus @@ -34,7 +34,7 @@ **Files** - Create later: tools/sdga_scope.py -- Test first: tests/test_sdga_scope.py (20 pure API methods) +- Test first: tests/test_sdga_scope.py (22 pure API methods) - Test first: tests/sdga_source_observation.py (one mandatory explicit pinned-source method; outside test_*.py discovery) - Frozen data: tests/fixtures/sdga_scope/{scope-f532.json,lakefile.toml,lake-manifest.json,lean-toolchain,source-scope-projection.json} @@ -60,7 +60,7 @@ classify_inventory checks scope ID/exact modules and targets, production ownersh classify_receipt checks exact source/tool/profile/cache/object/log/run/attempt/module bindings and required step coverage. Positive result binding_status=DECLARED_FIELDS_VALID; adverse result binding_status=INVALID with stable findings. Require signal and timed_out fields explicitly; zero integer exit, null signal, false timeout and nonnegative numeric resource/time fields for every required step. Reject bool exit, source/cache drift, missing/extra/duplicate steps, missing object/module coverage and unsafe/partial skips. It returns execution_authenticated=false and never qualification PASS. For a single defective fixture return exactly its designated code. Deterministic validation priority is RECEIPT_SCHEMA, STEP_COVERAGE, STEP_FAILED, SOURCE_DRIFT, CACHE_DRIFT, MODULE_COVERAGE, REPLAY_SKIPPED, RECEIPT_BINDING. Names/notes may identify the defective field. Use the same four fixed unresolved blockers as the inventory classifier. -- [ ] Step 1: Publish the 20 pure API methods, explicit pinned-source control and immutable fixtures without tools/sdga_scope.py. Keep tests/sdga_source_observation.py outside ordinary test_*.py discovery. +- [ ] Step 1: Publish the 22 pure API methods, explicit pinned-source control and immutable fixtures without tools/sdga_scope.py. Keep tests/sdga_source_observation.py outside ordinary test_*.py discovery. - [ ] Step 2: On the hosted draft always check out pinned Math, guard native commit/tree and set SDGA_PINNED_MATH_ROOT, SDGA_OBSERVED_MATH_COMMIT and SDGA_OBSERVED_MATH_TREE. Execute all four mandatory commands below as independent matrix cells; preserve complete output and exact head/attempt. ModuleNotFoundError for sdga_scope is the expected initial absence observation, not adverse-control credit. python3 -m unittest discover -s tests -p 'test_sdga_scope.py' -v @@ -68,7 +68,7 @@ classify_receipt checks exact source/tool/profile/cache/object/log/run/attempt/m python3 -O -m unittest discover -s tests -p 'test_sdga_scope.py' -v python3 -O tests/sdga_source_observation.py -v - [ ] Step 3: After root authorization, implement only the interfaces above using standard-library parsing and explicit checks, never Python assert for validation. -- [ ] Step 4: Run all four mandatory commands again. Exactly 20 offline methods and one explicit pinned-source method must pass in each mode, with no skips. No production fixture or expected hash may be rewritten to accommodate an observed result. +- [ ] Step 4: Run all four mandatory commands again. Exactly 22 offline methods and one explicit pinned-source method must pass in each mode, with no skips. No production fixture or expected hash may be rewritten to accommodate an observed result. - [ ] Step 5: Review the explicit pinned-source results from both modes. Required environment checks must fail if unavailable; the original assertions still independently hash all four raw inputs and all 99 source files before comparing extracted scope. Preserve raw output and native source bindings. Every component workflow run must include these results. - [ ] Step 6: Review the exact diff and evidence. Do not claim Lean execution, real axiom closure, replay coverage or mutation kills from Task 1. Root decides integration; this plan authorizes no commit/ref/PR action. @@ -76,4 +76,13 @@ Later milestones need genuine tiny Lean positive/adverse controls, private-level ## Test organization rationale -The original pinned-source method moved intact to tests/sdga_source_observation.py except that its optional skip became required environment assertions. It imports shared ContractCase/fixtures/API helpers from test_sdga_scope. Ordinary discovery therefore adds 20 pure contracts and no dormant skip. The dedicated component matrix retains all 21 controls in each mode and cannot claim complete Task 1 coverage from the offline subset alone. +The original pinned-source method moved intact to tests/sdga_source_observation.py except that its optional skip became required environment assertions. It imports shared ContractCase/fixtures/API helpers from test_sdga_scope. Ordinary discovery therefore adds 22 pure contracts and no dormant skip. The dedicated component matrix retains all 23 controls in each mode and cannot claim complete Task 1 coverage from the offline subset alone. + +## Targeted receipt regressions before repair + +The original 20 pure methods and pinned-source assertions remain unchanged. Add two pure methods, making 22 pure methods plus one mandatory pinned-source method per mode (46 method records across normal and optimized Python). + +- test_date_only_basic_or_incomplete_utc_rejected_when_bindings_match: date-only 2026-11-09Z, basic 20261109T000000Z, hour-only 2026-11-09T00Z and minute-only 2026-11-09T00:00Z in both receipt/expected must produce exactly RECEIPT_SCHEMA. Step timestamps require full extended UTC grammar YYYY-MM-DDTHH:MM:SS[.digits]Z and timezone-aware UTC parsing. +- test_empty_module_coverage_rejected_when_both_bindings_match: both arguments have empty module_coverage and only build/inventory steps; the result must be INVALID with exactly MODULE_COVERAGE. This fixed nonempty SDGA component scope does not admit empty coverage. + +Stage and execute these tests first against unchanged production blob d00a866e55c5d20fd4aeb8d44e51fa471f1d1031. No production repair is included in this revision. Root must observe the actual semantic failures before authorizing minimal UTC and nonempty-coverage checks. All result assertions retain BLOCKED/NONE; these are declared-field rejection controls, not Lean or scientific qualification. diff --git a/tests/test_sdga_scope.py b/tests/test_sdga_scope.py index 4db06eb46..b76f9c8c4 100644 --- a/tests/test_sdga_scope.py +++ b/tests/test_sdga_scope.py @@ -426,6 +426,23 @@ def test_missing_whole_identity_coverage_or_log_field_is_schema_failure(self): self.invalid_receipt(changed, expected, "RECEIPT_SCHEMA") + def test_date_only_basic_or_incomplete_utc_rejected_when_bindings_match(self): + for timestamp in ("2026-11-09Z", "20261109T000000Z", + "2026-11-09T00Z", "2026-11-09T00:00Z"): + value = receipt() + for item in value["steps"]: + item["started_utc"] = timestamp + item["ended_utc"] = timestamp + with self.subTest(timestamp=timestamp): + self.invalid_receipt(value, copy.deepcopy(value), "RECEIPT_SCHEMA") + + def test_empty_module_coverage_rejected_when_both_bindings_match(self): + value = receipt() + value["module_coverage"] = [] + value["steps"] = [step("build"), step("inventory")] + self.invalid_receipt(value, copy.deepcopy(value), "MODULE_COVERAGE") + + if __name__ == "__main__": unittest.main() From d561405d936e81d2f77e9308b4e176cb994c77aa Mon Sep 17 00:00:00 2001 From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com> Date: Mon, 9 Nov 2026 16:10:04 -0600 Subject: [PATCH 4/4] Guard UTC syntax and nonempty coverage; expose precision loss Preserve22prior controls, add23rd fraction-precision regression before final precision bound. Keep all outputs BLOCKED/NONE; fixed source profile and actual pinned-source checks unchanged. --- .github/workflows/sdga-scope-contract.yml | 4 ++-- DECISIONS.md | 21 ++++++++++++++++++ GOVERNANCE.md | 4 ++-- TOOLING.md | 4 ++-- ...2026-11-09-sdga-task1-scope-classifiers.md | 22 ++++++++++++++----- tests/test_sdga_scope.py | 11 ++++++++++ tools/sdga_scope.py | 13 +++++++---- 7 files changed, 63 insertions(+), 16 deletions(-) diff --git a/.github/workflows/sdga-scope-contract.yml b/.github/workflows/sdga-scope-contract.yml index 993424f9c..55757144a 100644 --- a/.github/workflows/sdga-scope-contract.yml +++ b/.github/workflows/sdga-scope-contract.yml @@ -67,13 +67,13 @@ jobs: run: | set -euo pipefail python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v 2>&1 | tee "$RUNNER_TEMP/sdga-scope-normal.log" - grep -Eq '^Ran 22 tests in ' "$RUNNER_TEMP/sdga-scope-normal.log" + grep -Eq '^Ran 23 tests in ' "$RUNNER_TEMP/sdga-scope-normal.log" - name: Run pure scope contracts optimized if: ${{ !cancelled() }} run: | set -euo pipefail python3 -B -O -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v 2>&1 | tee "$RUNNER_TEMP/sdga-scope-optimized.log" - grep -Eq '^Ran 22 tests in ' "$RUNNER_TEMP/sdga-scope-optimized.log" + grep -Eq '^Ran 23 tests in ' "$RUNNER_TEMP/sdga-scope-optimized.log" - name: Observe original pinned source normally if: ${{ !cancelled() }} run: | diff --git a/DECISIONS.md b/DECISIONS.md index ab5ff3dea..6aaa22ef0 100644 --- a/DECISIONS.md +++ b/DECISIONS.md @@ -187,3 +187,24 @@ Append-only. Historical source outcomes remain in their original records. expectsMODULE_COVERAGE. There are now22pure plus1mandatorypinned controls per mode. Actual semantic RED must precede the minimal two guards. No expected profile/source/config bytes or existing assertions are weakened. + +## 2026-11-09 — observed receipt RED, guarded candidate and UTC precision case + +- Root independently read run42706338390/attempt1/job129463995764 at f160a96: + both pure modes ran22 tests, original20 passed, exactly5 assertion failures + (four malformed UTC forms and both-empty coverage), zero errors/skips. + Both mandatory pinned-source tests passed. All five failures were actual + DECLARED_FIELDS_VALID versus INVALID, not setup or source failures. +- Author was authorized to require full aware UTC/calendar syntax and reject + empty coverage at its existing priority. All22 assertions and fixed source + fixtures remain unchanged. That guarded source is now paired with a further + precision case before the final bound is implemented: Python datetime + truncates fractions beyond six digits, potentially losing reversed instant + order. This observer explicitly supports at most microsecond UTC precision; + duration_ns remains a separate integer observation. +- Add one23rd pure method against unchanged candidate28ce8a145adc53fdc9f78007e871076d12081d46, + testing reversed seven- and nine-digit instants with matching declared + bindings. It must reject as RECEIPT_SCHEMA. There are now23pure+1pinned per + mode. Actual new semantic RED must precede the one-line precision limit. + No expected profile/config/source bytes or earlier test assertions changed. + Qualification remainsBLOCKED/NONE; no Lean or scientific credit follows. diff --git a/GOVERNANCE.md b/GOVERNANCE.md index dcec087e6..a0f872cf9 100644 --- a/GOVERNANCE.md +++ b/GOVERNANCE.md @@ -912,7 +912,7 @@ soundness; it cannot authenticate execution, classify complete mathematical roles or award G2--G4 or CBZ. All returned classification/qualification fields remain `BLOCKED`, scientific effect `NONE`, and execution authentication false. -From a Main checkout, run its22offline contracts in both modes: +From a Main checkout, run its23offline contracts in both modes: ```sh python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v @@ -927,7 +927,7 @@ commands, binding original inputs and99sources and retaining original logs. See [the design](docs/cbz/SDGA_COMPONENT_DESIGN.md) and [the exact plan](docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md). -Self-verification is pending actual current-source execution of all23controls +Self-verification is pending actual current-source execution of all24controls per mode and fresh engineering review. Initial hosted missing-module failures remain implementation-absence evidence only. No Lean inventory/replay/axiom observation is inferred from declared fixture fields. Maintenance owner: none; diff --git a/TOOLING.md b/TOOLING.md index 1b6f57a4c..5a266fa04 100644 --- a/TOOLING.md +++ b/TOOLING.md @@ -917,7 +917,7 @@ soundness; it cannot authenticate execution, classify complete mathematical roles or award G2--G4 or CBZ. All returned classification/qualification fields remain `BLOCKED`, scientific effect `NONE`, and execution authentication false. -From a Main checkout, run its22offline contracts in both modes: +From a Main checkout, run its23offline contracts in both modes: ```sh python3 -B -S -m unittest discover -s tests -p 'test_sdga_scope.py' -v @@ -932,7 +932,7 @@ commands, binding original inputs and99sources and retaining original logs. See [the design](docs/cbz/SDGA_COMPONENT_DESIGN.md) and [the exact plan](docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md). -Self-verification is pending actual current-source execution of all23controls +Self-verification is pending actual current-source execution of all24controls per mode and fresh engineering review. Initial hosted missing-module failures remain implementation-absence evidence only. No Lean inventory/replay/axiom observation is inferred from declared fixture fields. Maintenance owner: none; diff --git a/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md b/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md index 5795855dc..073e538d2 100644 --- a/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md +++ b/docs/superpowers/plans/2026-11-09-sdga-task1-scope-classifiers.md @@ -19,7 +19,7 @@ - No type AST serializer, Lean execution, proof changes, role admission, artifact authentication, generic orchestrator or external writes. - Reject bool where an integer is required. Do not normalize Unicode or collapse numeric/string Name components. - Initial missing-module import is valid absence evidence only. It provides no adverse-rejection or mutation credit. -- The dedicated read-only component workflow always checks out pinned Math and executes all 22 offline methods plus the one explicit pinned-source method in both normal and optimized Python. No optional coverage, skipTest, conditional disable or selective green matrix. +- The dedicated read-only component workflow always checks out pinned Math and executes all 23 offline methods plus the one explicit pinned-source method in both normal and optimized Python. No optional coverage, skipTest, conditional disable or selective green matrix. - Do not add a placeholder production scaffold. Root publishes the immutable test-first draft, captures hosted RED, then authorizes implementation. ## Review Focus @@ -34,7 +34,7 @@ **Files** - Create later: tools/sdga_scope.py -- Test first: tests/test_sdga_scope.py (22 pure API methods) +- Test first: tests/test_sdga_scope.py (23 pure API methods) - Test first: tests/sdga_source_observation.py (one mandatory explicit pinned-source method; outside test_*.py discovery) - Frozen data: tests/fixtures/sdga_scope/{scope-f532.json,lakefile.toml,lake-manifest.json,lean-toolchain,source-scope-projection.json} @@ -60,7 +60,7 @@ classify_inventory checks scope ID/exact modules and targets, production ownersh classify_receipt checks exact source/tool/profile/cache/object/log/run/attempt/module bindings and required step coverage. Positive result binding_status=DECLARED_FIELDS_VALID; adverse result binding_status=INVALID with stable findings. Require signal and timed_out fields explicitly; zero integer exit, null signal, false timeout and nonnegative numeric resource/time fields for every required step. Reject bool exit, source/cache drift, missing/extra/duplicate steps, missing object/module coverage and unsafe/partial skips. It returns execution_authenticated=false and never qualification PASS. For a single defective fixture return exactly its designated code. Deterministic validation priority is RECEIPT_SCHEMA, STEP_COVERAGE, STEP_FAILED, SOURCE_DRIFT, CACHE_DRIFT, MODULE_COVERAGE, REPLAY_SKIPPED, RECEIPT_BINDING. Names/notes may identify the defective field. Use the same four fixed unresolved blockers as the inventory classifier. -- [ ] Step 1: Publish the 22 pure API methods, explicit pinned-source control and immutable fixtures without tools/sdga_scope.py. Keep tests/sdga_source_observation.py outside ordinary test_*.py discovery. +- [ ] Step 1: Publish the 23 pure API methods, explicit pinned-source control and immutable fixtures without tools/sdga_scope.py. Keep tests/sdga_source_observation.py outside ordinary test_*.py discovery. - [ ] Step 2: On the hosted draft always check out pinned Math, guard native commit/tree and set SDGA_PINNED_MATH_ROOT, SDGA_OBSERVED_MATH_COMMIT and SDGA_OBSERVED_MATH_TREE. Execute all four mandatory commands below as independent matrix cells; preserve complete output and exact head/attempt. ModuleNotFoundError for sdga_scope is the expected initial absence observation, not adverse-control credit. python3 -m unittest discover -s tests -p 'test_sdga_scope.py' -v @@ -68,7 +68,7 @@ classify_receipt checks exact source/tool/profile/cache/object/log/run/attempt/m python3 -O -m unittest discover -s tests -p 'test_sdga_scope.py' -v python3 -O tests/sdga_source_observation.py -v - [ ] Step 3: After root authorization, implement only the interfaces above using standard-library parsing and explicit checks, never Python assert for validation. -- [ ] Step 4: Run all four mandatory commands again. Exactly 22 offline methods and one explicit pinned-source method must pass in each mode, with no skips. No production fixture or expected hash may be rewritten to accommodate an observed result. +- [ ] Step 4: Run all four mandatory commands again. Exactly 23 offline methods and one explicit pinned-source method must pass in each mode, with no skips. No production fixture or expected hash may be rewritten to accommodate an observed result. - [ ] Step 5: Review the explicit pinned-source results from both modes. Required environment checks must fail if unavailable; the original assertions still independently hash all four raw inputs and all 99 source files before comparing extracted scope. Preserve raw output and native source bindings. Every component workflow run must include these results. - [ ] Step 6: Review the exact diff and evidence. Do not claim Lean execution, real axiom closure, replay coverage or mutation kills from Task 1. Root decides integration; this plan authorizes no commit/ref/PR action. @@ -76,13 +76,23 @@ Later milestones need genuine tiny Lean positive/adverse controls, private-level ## Test organization rationale -The original pinned-source method moved intact to tests/sdga_source_observation.py except that its optional skip became required environment assertions. It imports shared ContractCase/fixtures/API helpers from test_sdga_scope. Ordinary discovery therefore adds 22 pure contracts and no dormant skip. The dedicated component matrix retains all 23 controls in each mode and cannot claim complete Task 1 coverage from the offline subset alone. +The original pinned-source method moved intact to tests/sdga_source_observation.py except that its optional skip became required environment assertions. It imports shared ContractCase/fixtures/API helpers from test_sdga_scope. Ordinary discovery therefore adds 23 pure contracts and no dormant skip. The dedicated component matrix retains all 24 controls in each mode and cannot claim complete Task 1 coverage from the offline subset alone. ## Targeted receipt regressions before repair The original 20 pure methods and pinned-source assertions remain unchanged. Add two pure methods, making 22 pure methods plus one mandatory pinned-source method per mode (46 method records across normal and optimized Python). -- test_date_only_basic_or_incomplete_utc_rejected_when_bindings_match: date-only 2026-11-09Z, basic 20261109T000000Z, hour-only 2026-11-09T00Z and minute-only 2026-11-09T00:00Z in both receipt/expected must produce exactly RECEIPT_SCHEMA. Step timestamps require full extended UTC grammar YYYY-MM-DDTHH:MM:SS[.digits]Z and timezone-aware UTC parsing. +- test_date_only_basic_or_incomplete_utc_rejected_when_bindings_match: date-only 2026-11-09Z, basic 20261109T000000Z, hour-only 2026-11-09T00Z and minute-only 2026-11-09T00:00Z in both receipt/expected must produce exactly RECEIPT_SCHEMA. Step timestamps require full extended UTC grammar YYYY-MM-DDTHH:MM:SS[.fraction]Z (one to six ASCII fractional digits) and timezone-aware UTC parsing. - test_empty_module_coverage_rejected_when_both_bindings_match: both arguments have empty module_coverage and only build/inventory steps; the result must be INVALID with exactly MODULE_COVERAGE. This fixed nonempty SDGA component scope does not admit empty coverage. Stage and execute these tests first against unchanged production blob d00a866e55c5d20fd4aeb8d44e51fa471f1d1031. No production repair is included in this revision. Root must observe the actual semantic failures before authorizing minimal UTC and nonempty-coverage checks. All result assertions retain BLOCKED/NONE; these are declared-field rejection controls, not Lean or scientific qualification. + +## UTC fractional precision regression before the one-line bound + +Current mandatory counts are 23 pure methods plus one explicit pinned-source method per Python mode: 24 per mode, 48 records across normal and optimized Python. The preceding 22 pure methods, pinned-source assertions, profile and configuration remain unchanged. + +The UTC wire grammar is YYYY-MM-DDTHH:MM:SS[.fraction]Z with one to six ASCII decimal digits when a fraction is present. This precision matches Python datetime; duration_ns remains a separate observation. Longer fractions are invalid rather than truncated. + +Add test_submicrosecond_utc_fractions_rejected_when_bindings_match. Its seven- and nine-digit matching receipt/expected pairs have reversed instants below microsecond precision; both must be INVALID with exactly RECEIPT_SCHEMA, while BLOCKED/NONE remain fixed. + +Publish and execute this test first against unchanged production blob 28ce8a145adc53fdc9f78007e871076d12081d46. No production change is part of this revision. Root must inspect actual semantic RED before authorizing the single regex bound from [0-9]+ to [0-9]{1,6}. Do not weaken prior tests, identities or expected hashes. diff --git a/tests/test_sdga_scope.py b/tests/test_sdga_scope.py index b76f9c8c4..ee8a4c181 100644 --- a/tests/test_sdga_scope.py +++ b/tests/test_sdga_scope.py @@ -443,6 +443,17 @@ def test_empty_module_coverage_rejected_when_both_bindings_match(self): self.invalid_receipt(value, copy.deepcopy(value), "MODULE_COVERAGE") + def test_submicrosecond_utc_fractions_rejected_when_bindings_match(self): + for fraction in ("0000001", "000000001"): + value = receipt() + for item in value["steps"]: + # datetime truncation makes these reversed instants compare equal. + item["started_utc"] = "2026-11-09T00:00:00." + fraction + "Z" + item["ended_utc"] = "2026-11-09T00:00:00." + "0" * len(fraction) + "Z" + with self.subTest(fractional_digits=len(fraction)): + self.invalid_receipt(value, copy.deepcopy(value), "RECEIPT_SCHEMA") + + if __name__ == "__main__": unittest.main() diff --git a/tools/sdga_scope.py b/tools/sdga_scope.py index d00a866e5..28ce8a145 100644 --- a/tools/sdga_scope.py +++ b/tools/sdga_scope.py @@ -5,7 +5,7 @@ """ from __future__ import annotations -from datetime import datetime +from datetime import datetime, timezone import hashlib import json import math @@ -507,8 +507,12 @@ def _receipt_keys(value, keys): def _utc(value): - _receipt_need(type(value) is str and value.endswith("Z"), "UTC timestamp required") - return datetime.fromisoformat(value[:-1] + "+00:00") + _receipt_need(type(value) is str and re.fullmatch( + r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?Z", value + ) is not None, "full extended UTC timestamp required") + parsed = datetime.fromisoformat(value[:-1] + "+00:00") + _receipt_need(parsed.tzinfo == timezone.utc, "aware UTC timestamp required") + return parsed def _receipt_schema(value): @@ -585,7 +589,8 @@ def reject(code, name): for value in (receipt, expected)): return reject("CACHE_DRIFT", "cache") coverage = receipt["module_coverage"] - if coverage != expected["module_coverage"] or len(set(coverage)) != len(coverage): + if (not coverage or not expected["module_coverage"] + or coverage != expected["module_coverage"] or len(set(coverage)) != len(coverage)): return reject("MODULE_COVERAGE", "modules") if any(value["unsafe_skipped"] or value["partial_skipped"] for value in (receipt, expected)): return reject("REPLAY_SKIPPED", "declarations")