Independent verification: exact enclosure of the pivot-566+554 T74 complex root behind the top pending kappa claims (no new kappa)

research/t74-k554-root-enclosure/README.md

@@ -0,0 +1,78 @@
+# Independent enclosure of the pivot-566+554 T74 complex root
+
+**Independent verification of a pending supplier number. No new κ, no change to the selected record, and no check of the outer reduction.**
+
+The open claims from https://github.com/CrocSwap/integer-mult-bounds/pull/1800 to https://github.com/CrocSwap/integer-mult-bounds/pull/1928 all price the same pending complex supplier: the pivot-566 stack with the pivot-554 helper-donor kernel (lineage https://github.com/CrocSwap/integer-mult-bounds/pull/1625 and https://github.com/CrocSwap/integer-mult-bounds/pull/1672). At their "free ε → 1" point, κ approaches this supplier's complex moment root b. https://github.com/CrocSwap/integer-mult-bounds/pull/1928 takes b as its certified native endpoint minus 10^-10010. Up to now, the only certificates of that endpoint came from the authors' own engines.
+
+This package checks the endpoint with code that shares no algorithm with those engines.
+
+## Object
+
+Both pinned PR heads record the same data in `new/SPEC.json`:
+
+- global profile `{1:1560432, 2:336336, 3:278724, 4:84912, 5:54612, 8:5328, 48:22748}`, m = 73, live W = 66304;
+- native and conservative endpoints on a 10^-70 grid (https://github.com/CrocSwap/integer-mult-bounds/pull/1672, head `b8ab040d`) and on a 10^-10000 grid (https://github.com/CrocSwap/integer-mult-bounds/pull/1928, head `07e4e423`).
+
+`extract_inputs.py` copies these fields, the two provider profiles, the provider counts, the idle remainder and each PR's headline κ into [INPUTS.json](INPUTS.json), with the Git blob and SHA-256 of each source file. With the pull refs fetched, `extract_inputs.py --check` rebuilds the file byte for byte.
+
+The moment definitions come from the repository's written review, not from code. The native moment is `sum_r H[r] (r/m)^(1-x) / W` ([native-complex-moment552/PROOF.md](../native-complex-moment552/PROOF.md)). The conservative model adds the inherited fallback of `32 m^2 N` rank-one children on a 10^-16 fraction, N = number of children ([three-stage-cover-assembly.tex](../../notes/three-stage-cover-assembly.tex), line 24). An endpoint e on a 10^-d grid is certified when M(e) < 1 < M(e + 10^-d).
+
+## Method
+
+`verify.py` uses only the standard library and imports nothing from the repository or from either PR.
+
+- **Logs.** Write A = ln(16/15), B = ln(25/24), C = ln(81/80); each is 2 atanh(1/31), 2 atanh(1/49) or 2 atanh(1/161). Then ln 2 = 7A + 5B + 3C, ln 3 = 11A + 8B + 5C and ln 5 = 16A + 12B + 7C. The verifier checks these identities exactly from the prime factorizations. ln 73 = 3 ln 2 + 2 ln 3 + 2 atanh(1/145). Every rank here is 5-smooth, so each ln(73/r) is a nonnegative integer combination of four atanh series.
+- **Exp.** Halve the argument s times, sum a Taylor polynomial with an explicit tail bound, then square s times.
+- **Rounding.** Every quantity is an integer multiple of 2^-bits rounded outward. The final test compares two exact integers. A sign that the enclosure cannot decide counts as failure; precision is raised at most twice and never turns an undecided sign into a pass.
+
+The authors' engines use a Mercator series and binary range reduction with atanh((x-1)/(x+1)) (`code/fine_mercator.py`, `code/fine_moment.py`). Earlier independent audits used a prime-by-prime log chain (pending-claims-independent-pricing) or binary reduction (pr1407-complex-moment-audit-seed39). This package uses neither.
+
+## Result
+
+`PASS_T74_K554_ROOT_ENCLOSURE_INDEPENDENT`, about 15 s on Python 3.12.
+
+- **Brackets.** All four pass: native and conservative, at both grids. The 10^-70 cases decide at 360 bits and the 10^-10000 cases at 33,347 bits, without precision refinement.
+- **Nesting.** For both models, the 10^-70 endpoint of https://github.com/CrocSwap/integer-mult-bounds/pull/1672 equals the 10^-70 floor of the 10^-10000 endpoint of https://github.com/CrocSwap/integer-mult-bounds/pull/1928.
+- **Profile composition.** At both heads, 249 gauge44 calls and 417 extra calls with their recorded per-call profiles, plus 22,748 idle rank-48 children, sum to the global profile. Rank mass is 4,816,512 and the deficit is 73 × 66,304 − 4,816,512 = 23,680.
+- **Headline κ.** The κ of https://github.com/CrocSwap/integer-mult-bounds/pull/1928 (`outer/OUTER-CLAIM.json`) lies 2.003 × 10^-10010 below the native endpoint, as its stated choice of b implies. The κ of https://github.com/CrocSwap/integer-mult-bounds/pull/1672 (`new/SPEC.json`, 47-inequality outer) lies 2.817 × 10^-6 below.
+- **Controls.** All ten are rejected. At 10^-70: next grid point as endpoint, previous grid point as endpoint, one child moved from rank 1 to rank 2, m = 72, W − 1, conservative endpoint without the surcharge, native endpoint with the surcharge. At 10^-10000: the first two and the surcharge-omission control again.
+
+The optional `crosscheck_decimal.py` (about 4 to 5 minutes) repeats the 10^-10000 case with Python's `decimal` ln and exp at 10,060 digits. It finds all seven log values inside the enclosures and the same four signs. `decimal` rounds to nearest, so this corroborates the result but does not certify it.
+
+## Reproduce
+
+From the repository root:
+
+```sh
+python3 scripts/research_package.py --package research/t74-k554-root-enclosure --check-only
+python3.12 scripts/research_package.py --package research/t74-k554-root-enclosure
+python3.12 -B research/t74-k554-root-enclosure/crosscheck_decimal.py   # optional, slow
+git fetch origin pull/1672/head pull/1928/head
+python3 research/t74-k554-root-enclosure/extract_inputs.py --check     # optional, needs the pull refs
+```
+
+`verify.py --write` regenerates [RESULT.json](RESULT.json); without it the run must reproduce the file byte for byte.
+
+## Scope
+
+This checks one number per model and grid, plus the arithmetic that composes the profile. The following are taken as given:
+
+- the global profile and the per-call provider profiles (no replay of words, owners or hosting);
+- the moment model and the native, surcharge-free complex recurrence, from the review of CrocSwap/integer-mult-bounds#552 and CrocSwap/integer-mult-bounds#559;
+- the outer reduction from b to κ, the fine source-prime padding and the ε → 1 transfer (see https://github.com/CrocSwap/integer-mult-bounds/pull/1797 for an audit of the CrocSwap/integer-mult-bounds#1786 lemmas on a different supplier);
+- all inherited all-size/compiler, realization, hosting, precision/tape, exact-recovery, analytic and bit H1-H5 assumptions.
+
+It is a finite check of recorded endpoints, not a proof of any multiplication theorem.
+
+## Open next questions
+
+The structured list is in [TASK.json](TASK.json).
+
+1. **Outer ledger of https://github.com/CrocSwap/integer-mult-bounds/pull/1928.** Does `outer/LEDGER.json` follow from the endpoint certified here, checked by code that does not import `outer/*.py`? This package certifies b only. A first step is to re-derive the slack list from `outer/RETUNED-SLACKS.md` and the CrocSwap/integer-mult-bounds#1673 note and compare each slack exactly. Nothing blocks it.
+2. **Profile against the emitted program.** Does the global profile equal the one emitted by the T74 hosted template and owner map? The seed78 emitted-ledger rebuild could be adapted to the two-provider layout (249 + 417 calls). The PR's template and owner archives are reproduced externally, so a maintainer replay capsule would make this cheap.
+
+## Credit
+
+Supplier construction: mdumitrean (https://github.com/CrocSwap/integer-mult-bounds/pull/1625, pivot-566 kernel), Jeremy Kothe (https://github.com/CrocSwap/integer-mult-bounds/pull/1672 and the refinement chain to https://github.com/CrocSwap/integer-mult-bounds/pull/1928), Rohan Arun (https://github.com/CrocSwap/integer-mult-bounds/pull/1319, T74 fill) and the lineage credited in those PRs. Outer: Vlado Vojdanovski (https://github.com/CrocSwap/integer-mult-bounds/pull/1673) and chafreaky (https://github.com/CrocSwap/integer-mult-bounds/pull/1786). The moment definitions are from the review of CrocSwap/integer-mult-bounds#552 and CrocSwap/integer-mult-bounds#559 and `notes/three-stage-cover-assembly.tex`. The audit pattern follows Sagar Thakrar's frontier1094-emitted-ledger-seed78 and the selected-suppliers-de-diagnostic and pr1407-complex-moment-audit-seed39 packages.
+
+Prepared by Aaron Wang, with help from opencode. New material is Apache-2.0.

research/t74-k554-root-enclosure/RESULT.json

@@ -0,0 +1,84 @@
+{
+ "brackets": {
+  "pr1672/conservative": {
+   "bits": 360,
+   "endpoint_side": -1,
+   "next_side": 1,
+   "on_grid": true,
+   "pass": true
+  },
+  "pr1672/native": {
+   "bits": 360,
+   "endpoint_side": -1,
+   "next_side": 1,
+   "on_grid": true,
+   "pass": true
+  },
+  "pr1928/conservative": {
+   "bits": 33347,
+   "endpoint_side": -1,
+   "next_side": 1,
+   "on_grid": true,
+   "pass": true
+  },
+  "pr1928/native": {
+   "bits": 33347,
+   "endpoint_side": -1,
+   "next_side": 1,
+   "on_grid": true,
+   "pass": true
+  }
+ },
+ "controls": {
+  "pr1672": {
+   "conservative_endpoint_without_surcharge": true,
+   "dimension_72": true,
+   "live_minus_one": true,
+   "native_endpoint_with_surcharge": true,
+   "next_grid_as_endpoint": true,
+   "one_child_rank1_to_rank2": true,
+   "previous_grid_as_endpoint": true
+  },
+  "pr1928": {
+   "conservative_endpoint_without_surcharge": true,
+   "next_grid_as_endpoint": true,
+   "previous_grid_as_endpoint": true
+  }
+ },
+ "headline_kappa_below_native_endpoint": {
+  "pr1672": {
+   "below": true,
+   "endpoint_minus_kappa": "2.816845103e-6"
+  },
+  "pr1928": {
+   "below": true,
+   "endpoint_minus_kappa": "2.003359509e-10010"
+  }
+ },
+ "inputs_sha256": "609c486efb1fe1e03ff2c84ba11085b231b9372e81fb2650bda821ce84e6e1ae",
+ "ledgers": {
+  "pr1672": {
+   "calls": 666,
+   "children": 2343092,
+   "deficit": 23680,
+   "rank_mass": 4816512
+  },
+  "pr1928": {
+   "calls": 666,
+   "children": 2343092,
+   "deficit": 23680,
+   "rank_mass": 4816512
+  }
+ },
+ "m": 73,
+ "nesting": {
+  "conservative": {
+   "coarse_equals_floor_of_fine": true
+  },
+  "native": {
+   "coarse_equals_floor_of_fine": true
+  }
+ },
+ "scope": "Native and conservative complex moment brackets and the profile composition only. The outer reduction that turns the endpoint into each headline kappa is not checked here.",
+ "status": "PASS_T74_K554_ROOT_ENCLOSURE_INDEPENDENT"
+}

research/t74-k554-root-enclosure/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "base_commit": "ae95f60feec79897b153dba6459bb3f9fd4d7b8e",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "research/native-complex-moment552/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "9adf304048b62c6db9250a611a8d4b0b60ed8276",
+      "sha256": "d5d498edc56fdef8c5798af7f5ec66948bd2f66c553b9efe366cdaab01bd3453"
+    },
+    {
+      "path": "notes/three-stage-cover-assembly.tex",
+      "usage": "provenance",
+      "git_blob": "983ffb6ac8fb9117360cd0797c00c05dfa071c9d",
+      "sha256": "ccf34a6d37c4af14bebeab15be50ab204eb1caebe546385520050ec30089441d"
+    }
+  ]
+}

research/t74-k554-root-enclosure/TASK.json

@@ -0,0 +1,65 @@
+{
+  "schema_version": 1,
+  "task_id": "independent-moment",
+  "priority_revision": 3,
+  "base_commit": "ae95f60feec79897b153dba6459bb3f9fd4d7b8e",
+  "original_card": {
+    "id": "independent-moment",
+    "question": "Can one selected pricing or assembly claim be checked by a genuinely independent exact implementation?",
+    "starting_points": [
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Reconstruct the rank ledger from original operations rather than trusting its aggregate.",
+      "Implement certified moment inequalities through a different exact enclosure method."
+    ],
+    "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Record the selected certificate and complex_profile rather than taking a PR headline as input.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Recompute one small part of the ledger or one certified enclosure using an independent implementation.",
+    "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.",
+    "allowed_variations": [
+      "Reconstruct either a source ledger or a numeric enclosure with a different method."
+    ],
+    "scope_change_triggers": [
+      "Importing the primary function and calling its output independent verification."
+    ],
+    "overlap_terms": [
+      "independent moment",
+      "rank histogram",
+      "exact enclosure"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Independent exact enclosure of the complex moment root of the pending pivot-566+554 T74 supplier (profile {1:1560432, 2:336336, 3:278724, 4:84912, 5:54612, 8:5328, 48:22748}, m=73, W=66304): native and conservative brackets at the 1e-70 endpoints of CrocSwap/integer-mult-bounds#1672 (head b8ab040d) and the 1e-10000 endpoints of CrocSwap/integer-mult-bounds#1928 (head 07e4e423), their nesting, the provider/idle profile composition, and the position of each PR's headline kappa below the native endpoint.",
+  "scope_change_reason": "The selected CrocSwap/integer-mult-bounds#1094 ledger, both moment endpoints, invoice and outer slacks already have independent checks (frontier1094-emitted-ledger-seed78, selected-suppliers-de-diagnostic, pr1407-complex-moment-audit-seed39, CrocSwap/integer-mult-bounds#1735). The card's enclosure method is applied instead to the supplier root behind the highest open claims (CrocSwap/integer-mult-bounds#1800 through CrocSwap/integer-mult-bounds#1928), where kappa tends to this root at the free epsilon -> 1 point and no independent enclosure was found.",
+  "bottleneck_link": "Every pending claim from CrocSwap/integer-mult-bounds#1800 to CrocSwap/integer-mult-bounds#1928 takes this certified native endpoint as b; an error in it would propagate to all of them. This package checks that number by a code-disjoint method. It does not check the outer reduction, the construction or admission, and it does not change kappa.",
+  "budget_minutes": 120,
+  "stop_rule": "Stop when both models' brackets pass at both grids with all semantic controls rejected, or report the first bracket that fails or stays undecided at four times the default precision.",
+  "outcome": "completed",
+  "evidence": "RESULT.json: four brackets pass (1e-70 at 360 bits; 1e-10000 at 33347 bits, no refinement needed); the 1e-70 endpoints equal the 1e-70 floors of the 1e-10000 endpoints for both models; both PR heads' provider profiles (249 gauge44 + 417 extra calls) plus 22748 idle rank-48 children sum to the global profile, rank mass 4816512, deficit 23680; CrocSwap/integer-mult-bounds#1928's headline kappa is 2.003e-10010 below its native endpoint, CrocSwap/integer-mult-bounds#1672's is 2.817e-6 below. 10 semantic controls rejected. Optional crosscheck_decimal.py (decimal at 10060 digits) agrees on all 7 log enclosures and 4 signs.",
+  "author": "Aaron Wang",
+  "ai_assistance": "Substantial: prepared with help from opencode (agent harness) for analysis, code and packaging.",
+  "open_questions": [
+    {
+      "question": "Does the capped/fine-padding outer ledger of CrocSwap/integer-mult-bounds#1928 (outer/LEDGER.json) follow from the endpoint certified here, checked by code that does not import outer/*.py?",
+      "why_it_matters": "This package certifies b only; the headline kappa also depends on the outer slacks and the epsilon -> 1 transfer.",
+      "first_step": "Re-derive the slack list from outer/RETUNED-SLACKS.md and the CrocSwap/integer-mult-bounds#1673 note, and compare each slack exactly with outer/LEDGER.json.",
+      "blocked_by": "None; CrocSwap/integer-mult-bounds#1797 covers the CrocSwap/integer-mult-bounds#1786 transfer lemmas on a different supplier, not this ledger."
+    },
+    {
+      "question": "Does the global profile used here equal the profile emitted by the CrocSwap/integer-mult-bounds#1928 hosted template and owner map?",
+      "why_it_matters": "This package takes the SPEC.json global profile and provider profiles as data; frontier1094-emitted-ledger-seed78 shows how to rebuild such a profile from emitted programs.",
+      "first_step": "Adapt the seed78 emitted-ledger rebuild to the T74 two-provider layout (249 gauge44, 417 extra calls) on CrocSwap/integer-mult-bounds#1928's committed template.",
+      "blocked_by": "CrocSwap/integer-mult-bounds#1928's GLOBAL-TEMPLATE and OWNERS archives are reproduced externally; a maintainer replay capsule would make this cheap."
+    }
+  ]
+}

research/t74-k554-root-enclosure/VERIFY.json

@@ -0,0 +1,27 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "INPUTS.json pin; exact log-identity check; profile composition for both PR heads; native and conservative brackets at 1e-70 (PR1672) and 1e-10000 (PR1928); nesting of the two grids; headline kappa below the native endpoint; 10 semantic controls rejected; RESULT.json byte-equal"
+    },
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/test_package.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "log and exp enclosures against float, fail-closed low precision, 1e-70 brackets, 7 controls, ledger control, input pin"
+    }
+  ]
+}

research/t74-k554-root-enclosure/crosscheck_decimal.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""Optional third implementation (about 4-5 minutes): Python's decimal ln/exp at 10,060 digits.
+
+Checks that decimal's ln(73/r) lies inside each verify.py log enclosure at the
+PR1928 precision, and that decimal gives the same four moment signs. decimal
+rounds to nearest, so this is corroboration, not a certificate; verify.py is
+the certificate. Aaron Wang, with help from opencode. Apache-2.0.
+"""
+from decimal import Decimal, getcontext
+from fractions import Fraction as Q
+import verify as V
+
+getcontext().prec = 10060
+src = V.load_inputs()['sources']['pr1928']
+bits = V.default_bits(10000)
+scale = Decimal(2) ** bits
+for r, (lo, hi) in V.log_table(73, (1, 2, 3, 4, 5, 8, 48), bits).items():
+    ln = (Decimal(73) / Decimal(r)).ln()
+    assert Decimal(lo) / scale <= ln <= Decimal(hi) / scale, r
+prof = {int(r): int(n) for r, n in src['global_profile'].items()}
+W, N = int(src['live']), sum(prof.values())
+
+
+def moment_minus_one(x, surcharge):
+    x = Decimal(x.numerator) / Decimal(x.denominator)
+    s = sum(Decimal(r * n) / Decimal(73 * W) * (x * (Decimal(73) / Decimal(r)).ln()).exp() for r, n in prof.items())
+    if surcharge:
+        s += Decimal(32 * 73 * N) / (Decimal(10) ** 16 * W) * (x * Decimal(73).ln()).exp()
+    return s - 1
+
+
+g = Q(1, 10 ** 10000)
+for field, surcharge in (('complex_lower', False), ('conservative_complex_lower', True)):
+    e = Q(src[field])
+    assert moment_minus_one(e, surcharge) < 0 < moment_minus_one(e + g, surcharge), field
+print('PASS_DECIMAL_CROSSCHECK | 7 log enclosures | 4 moment signs agree')