Independent verification: selected complex moments via integer root bounds

research/pr626-root-moment/CERTIFICATE.json

@@ -0,0 +1,74 @@
+{
+  "status": "PASS_PR626_ROOT_MOMENT",
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "assignment_seed": 83,
+  "method": {
+    "dyadic_exponent_depth": 163,
+    "fixed_point_bits": 256
+  },
+  "profile": {
+    "1": 181659,
+    "2": 30016,
+    "3": 31104,
+    "4": 11520,
+    "5": 5040,
+    "6": 576,
+    "8": 576,
+    "37": 1,
+    "48": 2215
+  },
+  "calls": 72,
+  "children": 262707,
+  "rank_mass": 520704,
+  "live": 7168,
+  "m": 73,
+  "deficit": 2560,
+  "endpoints": [
+    {
+      "model": "native",
+      "saving": "65528268492323474503/40000000000000000000000",
+      "surcharge": false,
+      "accept": true,
+      "moment_minus_one": [
+        "-142148128976149550642076438100564568550607937383060524668453/60589831782675021682119447899586069414933465256081744101542733238316655867911471104",
+        "-142148128976149550642076422578022239048204750929254255060721/60589831782675021682119447899586069414933465256081744101542733238316655867911471104"
+      ]
+    },
+    {
+      "model": "native",
+      "saving": "102387919519255428911/62500000000000000000000",
+      "surcharge": false,
+      "accept": false,
+      "moment_minus_one": [
+        "39341639264698531015594468476523892300347883131076602280515/60589831782675021682119447899586069414933465256081744101542733238316655867911471104",
+        "4917704908087316376949310499883277725343883698117466480821/7573728972834377710264930987448258676866683157010218012692841654789581983488933888"
+      ]
+    },
+    {
+      "model": "conservative",
+      "saving": "327641341885943404413/200000000000000000000000",
+      "surcharge": true,
+      "accept": true,
+      "moment_minus_one": [
+        "-7584806818011483336044970520975726853599569129252809770770868404804637991/2704903204583706325094618209802949527452386841789363575961729162424850708388904960000000000000000",
+        "-5309364772608038335231478879603560999692429459824325047240653309000586691/1893432243208594427566232746862064669216670789252554503173210413697395495872233472000000000000000"
+      ]
+    },
+    {
+      "model": "conservative",
+      "saving": "819103354714858511033/500000000000000000000000",
+      "surcharge": true,
+      "accept": false,
+      "moment_minus_one": [
+        "724380969857440184294200186627014950008216568952753541271477820204572631/3786864486417188855132465493724129338433341578505109006346420827394790991744466944000000000000000",
+        "226369053080450057591937861495597045519610759456746973780156523470890111/1183395152005371517228895466788790418260419243282846564483256508560872184920145920000000000000000"
+      ]
+    }
+  ],
+  "controls": {
+    "integer_power_comparisons": 1743,
+    "kernel_mutants": 2,
+    "rejected_power_inputs": 5,
+    "mathematical_controls": 6
+  }
+}

research/pr626-root-moment/CLAIM.json

@@ -0,0 +1,47 @@
+{
+  "track": "independent verification or formalization",
+  "assignment_seed": 83,
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "claimed_at": "2026-10-13T01:28:00-03:00",
+  "expected_finish": "2026-10-13T02:05:00-03:00",
+  "object": "PR626 selected complex profile: native and conservative strict adjacent 10^-24 moment endpoints",
+  "method": "163-bit dyadic exponent brackets and 256-bit outward repeated integer square roots; independent integer qth-power controls",
+  "deliverable": "offline standard-library checker, exact certificate, proof of enclosure, mathematical and package negative controls",
+  "candidates_considered": [
+    "selected complex recursive moment bracket",
+    "prime-power cyclic inverse identity from PR621",
+    "finite binary-frame admissibility"
+  ],
+  "choice": "The two latter areas have existing exact engines and related current reviews. PR678 audits only the bit profile with binomial series; PR667/672 optimize existing log/exp engines. A series-free algebraic check of the complex native and conservative models adds a distinct arithmetic method.",
+  "coordination": "GraphQL pinnedIssues returned an empty list; claim recorded locally.",
+  "initial_overlap": {
+    "open_prs": 520,
+    "through_pr": 700,
+    "metadata_file_local": "../open-prs.json (outside contribution)",
+    "related_prs": [
+      678,
+      667,
+      672,
+      675
+    ],
+    "query_terms": [
+      "square.root",
+      "dyadic exponent",
+      "repeated.root",
+      "algebraic.*moment"
+    ]
+  },
+  "stopping_rule": "one finite arithmetic verification package; no supplier search or selected-frontier edit",
+  "result": {
+    "status": "completed independent finite verification; no new kappa",
+    "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/706",
+    "completed_at": "2026-10-13T01:34:37-03:00",
+    "evidence": "CERTIFICATE.json; four native/conservative strict endpoint decisions; 1743 integer-power controls; test_verify.py four tests OK",
+    "overlap_refresh": {
+      "open_prs_through_704": 523,
+      "latest_metadata_through": 705,
+      "finding": "PR705 register-path determinant obstruction is distinct; PR678 bit binomial audit and PR667/672 pricing optimizations are credited, not imported."
+    }
+  },
+  "seed_generation": "Four OS RandomNumberGenerator bytes interpreted as UInt32, remainder modulo 100; recorded before task selection."
+}

research/pr626-root-moment/PROOF.md

@@ -0,0 +1,134 @@
+# Exact rational-power enclosure and the checked obligation
+
+Prepared for arkfx with substantial OpenAI Codex assistance; Apache-2.0.
+
+## The precise finite statement
+
+Let `H[r]` be the complete paid child profile in the selected #626 assembly,
+`m=73`, `W=7168`, and let `b` be the supplier saving. The native moment is
+
+```text
+M(b) = sum_r H[r]/W * (r/m)^(1-b)
+     = sum_r r*H[r]/(m*W) * (m/r)^b.
+```
+
+The conservative model adds
+
+```text
+F(b) = (32*m^2*sum_r H[r])/10^16 * (1/W) * (1/m)^(1-b)
+     = 32*m*sum_r H[r]/(W*10^16) * m^b.
+```
+
+This is the rank-one exceptional-set profile charged by `check_moment` in the
+base commit's `research/complex-k492-owner-repair/code/assemble.py`. The native
+complex model omits that charge under the reviewed #559 exact-cover recurrence
+correction. The construction-level correctness of both models is inherited.
+
+For the source-recorded `b_N = 65528268492323474503 / 40000000000000000000000`
+and `b_C = 327641341885943404413 / 200000000000000000000000`, the package proves
+these particular real-number inequalities through rational enclosures:
+
+```text
+M(b_N) < 1 < M(b_N + 10^-24)
+M(b_C) + F(b_C) < 1 < M(b_C + 10^-24) + F(b_C + 10^-24).
+```
+
+These are the local moment obligations. They are not the assembled κ claim.
+All profile coefficients are positive and every `m/r > 1`, so each model is
+strictly increasing in `b`; the adjacent-endpoint decisions enclose its unique
+threshold within the recorded interval. Existence follows here from continuity
+and the opposing strict signs. No claim of global supplier optimality follows.
+
+## Enclosure argument
+
+Take an exact rational base `a >= 1` and exponent `0 <= b <= 1`. Set
+`D=2^K`, `k_L=floor(bD)` and `k_U=ceil(bD)`. Monotonicity gives
+
+```text
+a^(k_L/D) <= a^b <= a^(k_U/D).
+```
+
+Thus no analytic tail estimate is needed. The binary digits of an integer
+`0 <= k < D` write `k/D` as a sum of selected `2^-i`, for `1 <= i <= K`.
+Consequently `a^(k/D)` is a product of selected repeated roots
+`a^(2^-i)`. At `k=D`, use `a` directly. At `k=0`, the empty product is one.
+
+All intermediate intervals use a fixed scale `S=2^B`. An integer pair `(L,U)`
+denotes the real interval `[L/S,U/S]`. Initially use
+`L=floor(aS)`, `U=ceil(aS)`. Given such an enclosing pair, define
+
+```text
+L' = floor(sqrt(L*S))
+U' = ceil(sqrt(U*S)).
+```
+
+Then `[L'/S,U'/S]` encloses the square root of every element of the original
+interval. `isqrt(n)` gives the exact lower integer; add one for the upper
+integer precisely when that lower integer's square is smaller than `n`.
+This proves the root invariant for every step by induction.
+
+For nonnegative enclosing pairs `(L1,U1)` and `(L2,U2)`, multiplication gives
+
+```text
+floor(L1*L2/S)/S <= product <= ceil(U1*U2/S)/S.
+```
+
+Induction over the selected binary factors proves that `dyadic(k)` encloses
+`a^(k/D)`. Take only the lower endpoint of `dyadic(k_L)` and upper endpoint of
+`dyadic(k_U)` to enclose `a^b`. This argument holds for any supported positive
+depth and precision. An overly coarse grid may fail to decide a moment; it
+cannot justify acceptance when the strict rational comparison fails.
+
+The implementation uses `K=163`, `B=256`, sums all terms with `Fraction`, and
+does not round the final sum. Multiplying by nonnegative rational weights and
+adding intervals preserves containment. The four final certified intervals
+lie strictly on their required sides of one; their exact endpoints are stored
+in `CERTIFICATE.json` and reproduced on every run.
+
+## Independent comparisons and failure distinctions
+
+For each kernel fixture `a` and `b=p/q`, the checker separately evaluates
+
+```text
+lower^q <= a^p <= upper^q
+```
+
+with exact integer/rational exponentiation. Positive qth powers are strictly
+increasing, so these comparisons independently establish containment for the
+fixture without using the root enclosure's logic. Fixtures cover all 72
+ratios `73/r`, denominators 2 through 13 with numerators 1 and `q-1`, four
+endpoint cases, and 83 seed-83 additional integer bases with denominators
+2 through 31. Duplicate fractions across denominators are retained as distinct
+test fixtures; this is 1,743 comparisons, not 1,743 distinct rationals.
+
+The two coarse kernel controls are concrete failures of unsafe enclosures:
+using only `85/256` to approximate `1/3` from below omits the true cube root of
+`73/48`; rounding the upper bound for `sqrt(2)` down omits `sqrt(2)` itself.
+The separate package tests mutate the actual implementation and require
+rejection. These controls corroborate the general invariant; they are not a
+formal proof that every possible implementation error is detected.
+
+The equal-count/rank-mass control replaces two rank-two children with one
+rank-one and one rank-three child. Both totals are preserved, but the upper
+native saving endpoint becomes accepted. Strict concavity of `r^(1-b)` for
+`0<b<1` explains the reduced moment; the executable control supplies the exact
+sign for this profile. This is a concrete arithmetic distinction, not a claim
+that the altered profile has a realizable circuit.
+
+Omitting idle children, replacing live stock by physical stock, or dropping
+the conservative surcharge likewise demonstrates false acceptance in those
+specific modified models. No such error is alleged against the retained
+selected assembly. Its full profile and stated charge agree with this check.
+
+## Dependency boundary
+
+The checker authenticates five source files, binds the selected certificate
+path/hash and source head, recounts invoice call multiplicities and the sum of
+their paid profiles plus the separate idle profile, and checks rank mass and
+deficit. These are consistency checks of frozen receipts. It inherits the
+proof that the receipts enumerate every required recursive child and that
+native complex surcharge removal is permitted. It does not independently
+verify scalar maps, phase frames, physical hosting, restoration or all-size
+realization. The selected maintainer review enumerates the remaining compiler,
+common-label/mutable-basis, hosting, precision/tape and analytic assumptions.
+No finite replay here formalizes the integer multiplication theorem.

research/pr626-root-moment/README.md

@@ -0,0 +1,109 @@
+# Independent algebraic verification of the selected complex moment
+
+**Independent finite verification; no new κ.** The selected #626 complex
+supplier's native and conservative recursive moments have the recorded strict
+brackets at adjacent saving values separated by `10^-24`. This package checks
+both brackets using repeated integer square roots and binary exponent brackets,
+without importing any supplier, logarithm, exponential or binomial-series code.
+
+The exact certificate reconstructs the complete profile from 72 invoice calls
+(8 CK, 64 JP8) plus the separately recorded idle children. It recovers 262,707
+children, rank mass 520,704, parent dimension 73, live stock 7,168 and deficit
+2,560. The physical stock 7,670 is a different accounting quantity.
+
+From the repository root, Python 3.11+ and the standard library suffice:
+
+```sh
+python3 -I -B research/pr626-root-moment/verify.py
+```
+
+Expected output:
+
+```text
+PASS_PR626_ROOT_MOMENT
+4 strict endpoints; 72 calls; 262707 children; 1743 integer-power controls; 2 kernel mutants; 6 mathematical controls.
+```
+
+The default command is offline and reads without writing. `-O` gives identical
+output: no checks depend on assertions. `--write-certificate` explicitly
+recomputes and replaces only this package's certificate. The exact fractions in
+[CERTIFICATE.json](CERTIFICATE.json) are the evidence; these decimal diagnostics
+are rounded for readability:
+
+| Model | Decision | Enclosed moment minus one, approximately |
+|---|---|---:|
+| Native, recorded lower saving | accept | -2.34607234900 × 10^-24 |
+| Native, lower saving + 10^-24 | reject | +6.49310917479 × 10^-25 |
+| Conservative, recorded lower saving | accept | -2.80409546824 × 10^-24 |
+| Conservative, lower saving + 10^-24 | reject | +1.91287798245 × 10^-25 |
+
+[PROOF.md](PROOF.md) derives the enclosure and states the cost formula. The
+implementation brackets the saving by dyadic exponents with denominator
+`2^163` and uses outward rounding on a `2^256` fixed-point grid. Every square
+root is computed with `math.isqrt`; every final decision uses exact rational
+comparisons. The seed selects the exponent depth and 83 additional deterministic
+algebraic fixtures. This is a finite verification domain, not a supplier search.
+
+The 1,743 independent kernel comparisons raise interval endpoints to integer
+powers and compare them with exact rational powers, including dyadic and
+nondyadic exponents. Two coarse fixtures expose exponent truncation and unsafe
+upper-root rounding. Six mathematical controls cover the old surcharge at the
+native endpoint, omitted conservative surcharge, omitted idle children,
+physical-stock normalization, a changed profile with equal count/rank mass,
+and the exact zero-saving rank-mass identity. Five invalid power inputs are
+rejected. In particular, preserving count and rank mass alone does not preserve
+the adjacent-endpoint decision.
+
+Package and implementation corruption controls run separately:
+
+```sh
+python3 -I -B research/pr626-root-moment/test_verify.py
+```
+
+Expected: four tests `OK`. These replay a relocated minimal package, compare
+normal/optimized output, reject corruption of all five source files and the
+certificate, and reject five actual script mutations at their mathematical or
+accounting checks. The tests capture failure output to keep the result concise.
+
+## Sources, related work and scope
+
+Exact base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. Selected #626 source:
+`660de893d27bb7abd1d5b01b1640207528a5c851`; #622 construction source:
+`f69477f4f6d3c7eb1f740b166881bffed4ffa9f6`.
+[SOURCES.json](SOURCES.json) authenticates the five consumed inputs by SHA-256
+and binds the assembly to `certificates/selected-result.json`. The selected
+record's κ remains `51110230636731/31250000000000000`.
+
+The selected maintainer review already checks the moment with two arithmetic
+engines. This contribution adds a third, series-free arithmetic method and
+exact power controls. Concurrent [#678](https://github.com/CrocSwap/integer-mult-bounds/pull/678)
+checks #543's **bit** profile with generalized binomial enclosures;
+[#667](https://github.com/CrocSwap/integer-mult-bounds/pull/667) and
+[#672](https://github.com/CrocSwap/integer-mult-bounds/pull/672) accelerate
+existing logarithm/exponential kernels. This package does not import those
+contributions. [#675](https://github.com/CrocSwap/integer-mult-bounds/pull/675)
+checks owner boundaries; this package consumes the preserved owner/invoice
+receipts and checks their pricing consequence. The fixed-frame negative
+results #661/#698 do not preclude this verification task and are not reopened.
+The local sprint claim and overlap record are in [CLAIM.json](CLAIM.json).
+
+This does **not** independently reconstruct scalar circuits, frame geometry,
+ownership charts, restoration, or the validity of the profile/surcharge model.
+It checks arithmetic and consistency of the pinned finite receipts, assuming
+their construction-level justification. No production pricing engine,
+selected certificate, generator, upstream source or frontier is changed.
+The full repository suite, cold supplier replay, all 47 outer inequalities,
+Lean and remote CI are outside this package's validation. The all-size compiler,
+common-label/mutable-basis realization, whole-call hosting, precision/tape and
+analytic transfer obligations remain inherited. This finite certificate is not
+a formal proof of the multiplication theorem or a practical speedup claim.
+
+Credit to Chafik Boukhalfa/chafreaky (#626 ownership and independent checks),
+Jeremy Kothe (#622 construction and #623 dispatch), icekylinx's native assembly
+lineage, DreamingOfClouds' cold-helper work, Rohan Arun's #559 recurrence
+correction, eumemic's #543 bit supplier, and all predecessors retained in
+`research/complex-k492-owner-repair/NOTICE.md`. The selected review and original
+source notices remain authoritative for their cumulative attribution.
+Prepared for **arkfx** with substantial **OpenAI Codex** assistance; Apache-2.0.
+The checker and proof here are newly written; frozen inputs retain their
+original authorship. AI-assisted review is not independent human peer review.

research/pr626-root-moment/SOURCES.json

@@ -0,0 +1,28 @@
+{
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "selected_source_head": "660de893d27bb7abd1d5b01b1640207528a5c851",
+  "construction_source_head": "f69477f4f6d3c7eb1f740b166881bffed4ffa9f6",
+  "assignment_seed": 83,
+  "files": {
+    "selected": {
+      "path": "certificates/selected-result.json",
+      "sha256": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53"
+    },
+    "assembly": {
+      "path": "research/community-k492-audit/pr626/replay/ASSEMBLY.json",
+      "sha256": "6127732e2fcdd470dab349c1c51d03cd9f0787ad0309b1b4a7c811a908028f4e"
+    },
+    "owner": {
+      "path": "research/community-k492-audit/pr626/replay/mixed-global/audit/OWNERS-AND-PROFILE.json",
+      "sha256": "ec7bc4157e7ab1707bddf99994149c932b51365de7e742508fd182051ca57fc1"
+    },
+    "invoice": {
+      "path": "research/community-k492-audit/pr626/replay/mixed-global/audit/PREFIX-AND-INVOICE.json",
+      "sha256": "367a73f744ea9b7dd6cca5fa3fda47175f560aa3d37e708c9fa1294dbd4b56eb"
+    },
+    "idle": {
+      "path": "research/community-k492-audit/pr626/replay/mixed-global/audit/IDLE-REMAINDER-FRAMES.json",
+      "sha256": "11a97b7862117fa9fbb9e4469be5563a47cc5310dcb84360d267323d5b9b3282"
+    }
+  }
+}