Research: Odd-word precision grid

research/odd-native-common-grid/EXPECTED-BOUNDS.json

@@ -0,0 +1,43 @@
+{
+  "caller": {
+    "coarse_height": 1240,
+    "coarse_mass_bits": 4362,
+    "denominator_height": 163,
+    "events": 3221,
+    "mass_bits": 126,
+    "maximum_mass": "16246698892210214036146399419475929893435/256",
+    "operations": {
+      "ADD": 2198,
+      "IDLE_ONE": 100,
+      "J": 18,
+      "LAMBDA": 206,
+      "QUERY": 10,
+      "SCALE": 180,
+      "SWAP": 509
+    },
+    "pre_joint_height": 154,
+    "pre_joint_mass_bits": 124
+  },
+  "word": {
+    "coefficient_numerator_bits": 24,
+    "coefficient_visits": 14060742,
+    "dyadic_height": 24,
+    "events": 71069,
+    "mass_witness": [
+      63297,
+      "stored add"
+    ],
+    "maximum_scaled_mass": "1636447290138225/16384",
+    "odd_scale": 1125,
+    "operations": {
+      "ADD": 60978,
+      "CLEAR": 54,
+      "COPY": 1,
+      "INIT": 54,
+      "MOVE": 6330,
+      "SCALE": 3652
+    },
+    "public_fields": 1452,
+    "scaled_mass_bits": 37
+  }
+}

research/odd-native-common-grid/INDEPENDENT-BOUNDS.json

@@ -0,0 +1,36 @@
+{
+  "caller": {
+    "denominator_height": 163,
+    "maximum_mass": "16246698892210214036146399419475929893435/256",
+    "pre_joint_height": 154,
+    "pre_joint_mass": "758143798823020519902612486795530419693/64"
+  },
+  "negative_scales": {
+    "225": "integer grid rejection at event 1101: denominator 250",
+    "375": "integer grid rejection at event 36915: denominator 48"
+  },
+  "source_sha256": {
+    "caller.json": "5489eee96950881b0dd8fdecd6c02a3f663c60ba5bed0d5e5cbeed50fb9ae5fb",
+    "word.json.gz": "1cb1dd9acac7cc13dd5ef58162c9b89ac07215bf0364170db6940191d3605af5"
+  },
+  "threshold": {
+    "357Kstar_bits": 14075,
+    "H": 1339210000000000000,
+    "Kstar_bits": 14066,
+    "gap_denominator": 10000000000000,
+    "integer_threshold_index": 133921,
+    "logarithm_power": 2224,
+    "source_check_sha256": "f1d6831810200ae6b677a32fc0e7fcf2c8bd9f033ae9fca7f8b1918ea5ed9f28"
+  },
+  "word": {
+    "coefficient_visits": 14060742,
+    "dyadic_height": 24,
+    "mass_witness": [
+      63297,
+      "stored add"
+    ],
+    "maximum_scaled_mass": "1636447290138225/16384",
+    "numerator_bits": 24,
+    "odd_scale_lcm": 1125
+  }
+}

research/odd-native-common-grid/INDEPENDENT-REVIEW.md

@@ -0,0 +1,134 @@
+# Independent review of the odd native common-grid draft
+
+Reviewer: same-session research subagent, with substantial OpenAI assistance.
+This is author-side independent-method review, not a human or formal-kernel
+acceptance. No root-owned files were modified.
+
+## Frozen scope
+
+The reviewer froze the pre-clarification draft during the run. Its SHA-256 pins were:
+
+- `PROOF.md`: `0a3b37c82869c37afbcea50ed1e440a8c8e6e9f01f3a84476c004586c1bec82e`
+- `audit_bounds.py`: `1e859d997e667514864871fd64e2b01039107708a848ddfec340e3947d0bbbcb`
+
+The exact source word/caller and threshold source are recorded in
+`SOURCE-BYTES.json` and the executed `INDEPENDENT-BOUNDS.json`. Canonical base remains
+`7c49fe32c55de02c2c873655c804b16e4c3fef0a`. The source-specific mathematical
+claim is the per-call scale-1125 precision implication for candidate #6934,
+not a proof of the candidate's native maps, physical supplier or complete bill.
+
+## Verdict
+
+No mathematical counterexample or blocking gap was found within the stated
+ideal endpoint, same-root-factor, ownership, scheduling and source interfaces.
+The conclusion remains conditional on those interfaces. The independent
+integer engines reproduce the finite bounds used in the all-size argument.
+
+Two wording clarifications would improve the proof and make the inherited
+scope harder to misread:
+
+1. Section 2's fresh helper mass 1 and height 0 are **relative to the current
+   raw-call entrance**. A helper introduced inside a nested compiler call
+   carries its actual entrance expansion in original root inputs; its root
+   mass/debt is not reset to 1/0. Section 3 and the credited #6901 proof imply
+   this interpretation, but the present short sentence should say so.
+2. Interface 1 should explicitly say **Gaussian-dyadic Clifford**, including
+   absolute phase. A generic Clifford with an arbitrary global phase would
+   not imply the stated binary grid. The source construction is in the
+   Gaussian-dyadic subgroup; no extension to arbitrary global phases follows.
+
+It is also useful to state the short compiler size check: 153<2^8 and
+8*1920<H imply the fixed N exceeds the carrier m=153^1920. The source
+threshold already checks the stronger written inequality, so this is
+exposition rather than a failing gate.
+
+## Independent finite evidence
+
+The reviewer did not import the author's `audit_bounds.py` implementation.
+`independent_bounds.py` uses two different representations:
+
+- Native rows are sparse **integers on one fixed 24-bit fractional grid**,
+  initially scaled by 1125. Every scalar multiplication uses exact integer
+  quotient/remainder, including separate pre-ADD products. This independently
+  checks the finite precision certificate and computes the least common
+  multiple of the actual odd coefficient denominators from gcds.
+- Caller mass is propagated as a **78 by 78 positive transfer matrix** on an
+  increasing common integer grid. Row sums give the noncommutative triangle
+  bound. No numerical character or commuting-operator identity is used.
+
+The word engine visits all 14,060,742 coefficient instances and finds:
+minimal odd scale 1125, dyadic height 24, mass
+1636447290138225/16384, and literal numerator bit length 24. Two insufficient
+scales reject at precise events: 225 at event 1101 and 375 at event 36915.
+
+The separate caller matrix engine obtains height 163 and maximum mass
+16246698892210214036146399419475929893435/256. Before a joint event, the
+maximum mass is 758143798823020519902612486795530419693/64, below 2^124;
+the maximum height is 154. Thus the local-plus-caller envelopes A=178 and
+B=161 agree exactly with the proof's safe integer bounds.
+
+The threshold routine reads candidate/tested rationals and logarithm power
+2224 by AST from the retained source, without executing its scientific
+program. It regenerates the integer threshold and checks both neighboring
+indices. It verifies the 14,066-bit K_star and 14,075-bit 357*K_star; N itself
+is never constructed.
+
+Reproduction, from this run's workspace:
+
+```sh
+python -I -B research/odd-native-common-grid/independent_bounds.py
+```
+
+The final marker is `PASS_INDEPENDENT_ODD_GRID_BOUNDS`. The lead rebound only this audit script's source paths to the byte-identical
+package-local snapshots and expected bounds. The registered verifier reruns
+its independent engines. The audit is part of this package, not an additional
+contribution or external human acceptance.
+
+## All-size reasoning checked
+
+The ideal recursion is defined before numerical execution. Compiler exits and
+complements strictly reduce rank; ordinary substitution reduces selected width.
+Thus using ideal endpoint identities to reset only **extra entrance-relative
+debt** is not a circular assumption of exact finite-precision child returns.
+Completed siblings leave no extra debt, whereas already present entrance debt
+persists. Per-call scale 1125 applies independently to each unfinished local
+context. A one-time outer factor 1125 is a different program and would fail
+under nesting; the proof correctly excludes that shortcut.
+
+The compiler recurrence bounds source dependence depth, not bank count. Its
+inherited contraction is applicable after separation because paid ranks are
+strictly below every productive rank and the latter are at least two. The
+ordinary root bound t=K_star*floor(log_N D), together with
+357*K_star<N and N*ell<=N^ell<=D, gives 356t<D, also at ell=0.
+
+Every completed root-factor Clifford row has dyadic entry denominator at
+most 2^ceil(D/2) and unit Euclidean norm. Combining this once with exterior
+denominator 178t and mass 2*2^(161t), rather than charging the Clifford
+denominator at each recursive level, gives the stated F and magnitude
+requirements. Integer parity of D gives 178t<=floor(D/2), so F=p+D and
+W=p+h+2D+3 suffice. The W recomputation correctly accounts for the raised
+fractional grid.
+
+Temporary W+26 bits safely cover signed multiplication by a numerator of
+at most 24 bits and the subsequent addition; the complete four-term Gaussian
+pair numerator is smaller. Quotients are exact because their ideal results
+are proved to be grid values. No rounding of individual Gaussian summands is
+licensed. A partial in-place field need not have a Clifford-vector form;
+the no-consumer-before-return premise and old/new component bounds are the
+correct way to cover those writes. A complete external row is required:
+projecting on a selected ancestor coordinate would invalidate the invariant.
+
+## Limits
+
+This review does not establish arbitrary-width native map/phase identities,
+the full root preprocessing or H0 boundary, owned erasure, a physical scalar
+table, storage capacity, source access or complete asymptotic admission. It
+does not rerun #6934's supplier invoice or selected certificate. Those remain
+explicit obligations, and no new kappa or unconditional theorem follows.
+
+## Lead response before package freeze
+
+Both wording clarifications above were applied. The carrier-size inequality
+was added. No scientific bound or finite receipt changed. The independent
+engines were rebound to package-local byte-authenticated sources and replayed
+as part of the registered normal/optimized gates; see VERIFICATION.md.

research/odd-native-common-grid/NOTICE.md

@@ -0,0 +1,20 @@
+# Credit and retained source notice
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0.
+
+The five files under `source/` are unchanged snapshots from DreamingOfClouds'
+`research/p104-shared-odd-native` at
+`4e13b7acdbea1c9f12aa88126435360eecea7401`. Their original LICENSE and NOTICE
+are retained alongside them. The original word, caller, scale1125 certificate,
+strictification parameters and candidate bound are their contributors' work.
+
+The proof explicitly credits #104's odd clearing and #6901's fixed-root
+precision theorem, with the #4586/#5443/#6878 compiler and occurrence lineage.
+Credit icekylinx, Ross Richardson, zxv, Jacob Alan Sussman and all authors
+identified by those predecessor packages. No predecessor method, endpoint
+identity or independent human acceptance is claimed as a new result here.
+
+The rational audit and fixed-grid/transfer-matrix audit were authored by
+different same-session AI research agents. That separation supplies an
+independent method and review; it does not imply external authorship or
+formal proof verification.

research/odd-native-common-grid/PR-DESCRIPTION.md

@@ -0,0 +1,65 @@
+## Change and mathematical scope
+
+Replace the older quoted caller bounds in #6934's precision discussion with
+independently computed bounds for its actual word and changed caller. Prove
+that the per-call scale1125 program has a sufficient common component format
+`F=p+D`, `W=p+h+2D+3`, with `W+26` temporary bits, through the retained ideal
+compiler and ordinary recursion after a paid root boundary.
+
+The exact word prefix has height24 and scaled mass below2^37. The actual
+caller has height163/mass below2^126, and joint entrances have
+height154/mass below2^124. Thus unfinished contexts add at most178 denominator
+bits and161 mass bits. An exact integer threshold absorbs this debt. The
+simulation derives exact numerical child returns from a finite ideal
+instruction tree, retaining the stated nonprecision endpoint, full-root-factor,
+ownership and scheduling interfaces.
+
+**No new κ.** No native endpoint, full physical supplier, root H0 boundary or
+unconditional multiplication theorem is admitted.
+
+## Novelty and dependencies
+
+Base: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+Candidate: #6934 at `4e13b7acdbea1c9f12aa88126435360eecea7401`.
+The fixed-root/compiler method is #6901 at
+`4c7a4f00f09665276e145ac2cc1d12f8b8f9a7ac`, with #4586/#5443/#6878.
+Odd clearing originates in #104; the word, scale1125 and per-call wrapper are
+#6932/#6934's. This package supplies the missing current-source envelope and
+scoped recursive precision implication, not those predecessor constructions.
+
+## Reproduction and verification
+
+```sh
+python3 -B scripts/research_package.py --package research/odd-native-common-grid
+```
+
+Expected: two `PASS_ODD_NATIVE_COMMON_GRID` markers and
+`PASS_REGISTERED_RESEARCH_PACKAGE`.
+
+The complete rational row audit and separately authored fixed-grid integer
+audit agree on14,060,742 coefficient instances. A positive78-by-78 transfer
+matrix independently reproduces the caller bounds. The exact threshold,
+negative controls, registered normal/optimized checks, committed-byte checks
+and Git-free replay are recorded in VERIFICATION.md. Independent review found
+no blocking gap under the explicitly retained interfaces; two scope wording
+clarifications were applied before freeze.
+
+Controls reject insufficient scales, source corruption, invalid frames/owners,
+changed caller semantics and an unfunded odd prime. Concrete counterexamples
+rule out a one-time outer scale under nesting and an active-coordinate
+projection inside the fixed-root Clifford invariant.
+
+## Costs, limitations and credit
+
+The per-call wrapper adds52,272 complete-field scaling operations per raw
+caller. All positive conversion and inherited source/native/owned/recursive
+costs remain. The full raw allowance, BIT supplier, strictification and outer
+ledger are separate admissions. All five selected assumptions remain.
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Credit
+DreamingOfClouds, icekylinx, Ross Richardson, zxv, Jacob Alan Sussman,
+the lockstep/occurrence contributors and retained native/compiler/precision
+lineage. The separate AI audit is not human or formal-kernel acceptance.
+Apache-2.0; original source LICENSE/NOTICE retained.
+
+[Proof, exact pins, full review and open questions](https://github.com/CubeJerry/integer-mult-bounds/tree/research/odd-native-common-grid-20261109/research/odd-native-common-grid).