Implement phase-preserving cyclic recovery with bounded-word rounding

research/native-cyclic-recovery/.gitattributes

@@ -0,0 +1 @@
+* -text whitespace=cr-at-eol

research/native-cyclic-recovery/APPLICATION-PINS.json

@@ -0,0 +1,8 @@
+{
+  "pr": 4733,
+  "head": "dd6948e95eb002d903ce36dd21e0c075e00790ed",
+  "local_reference_sha256": {
+    "PR4733-README.md": "01f60b01fc4b8cb70fbac7fff2d4758e4a364cb627463ecd677060a9ce774c34",
+    "PR4733-PROOF.md": "88118364f7a8e97da76ab7198bf1edde582f1bdd5d62a1d0a881809bcb5f3191"
+  }
+}

research/native-cyclic-recovery/APPLICATIONS-NOTE.md

@@ -0,0 +1,67 @@
+# Concrete native odd-scan services
+
+This note instantiates the fixed-divisor theorem in existing public component
+invoices. It changes the scalar implementation on the declared both-shifts
+Word RAM. It does not replace a Turing-tape head-step tariff by the same numeric
+RAM count, and does not claim a better kappa or a completed productive caller.
+
+## Existing centre-code scan obligations
+
+Ali Romman's PR #4733 at commit
+`dd6948e95eb002d903ce36dd21e0c075e00790ed` gives exact component scan counts.
+The current
+[component README](https://github.com/aliromman/integer-mult-bounds/blob/dd6948e95eb002d903ce36dd21e0c075e00790ed/research/centre-code-services/README.md)
+and
+[pivot-code proof](https://github.com/aliromman/integer-mult-bounds/blob/dd6948e95eb002d903ce36dd21e0c075e00790ed/research/centre-code-services/annexes/pivot-code-invoice/PROOF.md)
+were read directly. Their unchanged matrix identities, code image tests and
+precision obligations are retained source premises, not newly replayed here.
+No predecessor scientific certificate is copied or rebranded.
+
+For n scalar records in each real stream, assume each prescribed signed
+numerator fits a word after the stated constant guard headroom. Applying the
+new exact unsigned quotient/remainder scan and restoring signs supplies the
+following sufficient implementations:
+
+| Source service, inverse direction | Exact fixed-odd divisions | New scalar Word RAM work |
+|---|---|---|
+| Rank-16 whole-bank code E | 16 at 5 and 16 at 7 | O(32 n log(2+w)) |
+| Rank-30 capture | 22 at 3 and 22 at 5 | O(44 n log(2+w)) |
+| Rank-30 capture/action/decode | 22 at 3 and 22 at 5, plus the separately charged fixed multiplications | O(44 n log(2+w)) for division, O(44 n) for its fixed-integer multiplications |
+| Fixed-reader section swap | 60 at 15, with 60 separately charged multiplication-by-15 scans | O(60 n log(2+w)) for division and O(60 n) for those multiplications |
+| Pivot-code inverse annex | 16 at 3 | O(16 n log(2+w)) |
+
+The fixed constants hidden by O differ with the listed denominator. These are
+asymptotic instruction upper bounds, not exact small-word scan tariffs. The
+source's 3,420, 2,910, 6,090, 208,028 and 2,078 dyadic scalar accounts, native
+translation calls, routing, root conversions and descriptors remain additional.
+The two rank-30 rows describe different source service scopes; their bills
+must not be added or interchanged without selecting the actual caller.
+
+On a valid code image, each source inverse requires exact odd divisibility.
+The new scan computes q,r with x=dq+r exactly. It therefore checks r=0 and
+returns the exact quotient on precisely that domain; it does not replace an
+exact inverse by rounded division. A nonzero remainder rejects that exact
+service. Arbitrary code coordinates do not acquire missing image membership
+from this implementation. Common-grid, matching code types, preservation by
+middle operations, full parent height and outer unscaling remain source
+premises. The source's generic inverse coefficient 1/12 is not a dyadic unit.
+
+The pivot annex explicitly charges at most 64 n (w_g+1) arithmetic head steps
+for its sixteen fixed-three scans. The theorem here supplies a different,
+fully specified Word RAM realization of those exact scalar quotients in
+O(16 n log(2+w_g)) instructions, when a bounded word or constant number of
+limbs holds the guarded numerator. It is a model-specific alternative,
+not a claimed reduction of the original tape head-step count. A practical
+constant or crossover improvement has not been measured.
+
+## Credit and source limits
+
+Credit Ali Romman and the retained centre-code campaign contributors for
+PR #4733's rational-code and pivot constructions, @icekylinx for its common-grid
+source, @dcharb78 for the coupled-core folds, Jeremy Diviney for the provider
+packing exchange, and the complete original package notices. This note adds
+only the explicit restricted-Word-RAM instantiation of the generic scalar
+scan. It does not claim invention of the codes, their invoices, exact-image
+conditions or the common-grid method. Substantial OpenAI Codex assistance was
+used. The independent review of the generic scalar algorithm does not amount
+to a fresh review of all PR #4733 constructions.

research/native-cyclic-recovery/CASCADE-CROSS-REVIEW.json

@@ -0,0 +1,83 @@
+{
+  "status": "PASS_SCOPED_CASCADE_REVIEW",
+  "files": {
+    "cascade_free.py": "64e906a2827f3e17987bddec85ee48a93ee574f494f1566460748bd2edf66162",
+    "CASCADE-INVERSE.md": "bc66783f0d2e746eecc40246127269612c4443d2813091b38732093637d86cab",
+    "CASCADE-ORIGINS.json": "b5265c8cd6ac0738a111363f85d4c13a2b910d214ce9c3a5322b16a5d144262b",
+    "CASCADE-EXPECTED.json": "c772111f1e1a44dda45d85d395eda1a8c9ddf1f23166fe7aee3616e318bb948a"
+  },
+  "normal_or_optimized": "optimized isolated replay matches complete frozen expected receipt",
+  "independent_random_cases": 144,
+  "independent_cases": "Roles 1 through 6, addresses 2, 4 and 8; eight deterministic signed rational phase-bearing fixtures per shape; independent literal U action and W-step return.",
+  "controls": [
+    "factored discarded phase rejects",
+    "false q=2 on order-12 quarter-phase fixture rejects"
+  ],
+  "all_width_argument": "The cycle return is Pauli, hence its fourth power is identity; pure XOR return squares to identity. Tensorize unit monomials, keeping the coefficient 1/2 outside.",
+  "pass_count": "W + q - 2 passes over TOTAL N = W n entries; q = 2 for XOR, q = 4 for general quarter phase.",
+  "coefficient_norm": "The sum of absolute coefficients is exactly 2; the intermediate first Horner sum is at most 2 and second-stage geometric amplification at most 2.",
+  "buffers": "Observations retained; q = 2 uses two owned full buffers, q = 4 uses three. Python additionally stores an O(N) compiled return route.",
+  "runtime_scope": "O((W + q) N d(w)) plus O(W N) literal Python return compilation, for fixed W. O(W N log w) uses TOTAL N entries and denominator constants depending on fixed W.",
+  "source_binding": [
+    {
+      "pr": 4818,
+      "head": "fd29d065bbe12f5be5af02fdf5a8b4d86dda3381",
+      "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/fd29d065bbe12f5be5af02fdf5a8b4d86dda3381/research/complex-block4-three-in-ten/verify_schedule.py",
+      "hash_matches": true,
+      "changed_notice_paths": [
+        "research/complex-block4-three-in-ten/LICENSE",
+        "research/complex-block4-three-in-ten/NOTICE.md"
+      ],
+      "source_header": "#!/usr/bin/env python3\n\"\"\"Exact Synthesis & Verification of the 3-Array 10-Call Cascade Schedule on V = C^16.\n\nProves the viability of breaking the kappa > 0.10 milestone via:\n  - W = 3 arrays in s = "
+    },
+    {
+      "pr": 4819,
+      "head": "a7b42c2f8ffe5a18d305ca4dda5729d2f1d72ea8",
+      "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/a7b42c2f8ffe5a18d305ca4dda5729d2f1d72ea8/research/complex-block4-thirteen-in-fortyone/verify_schedule.py",
+      "hash_matches": true,
+      "changed_notice_paths": [
+        "research/complex-block4-thirteen-in-fortyone/LICENSE",
+        "research/complex-block4-thirteen-in-fortyone/NOTICE.md"
+      ],
+      "source_header": "#!/usr/bin/env python3\n\"\"\"Exact Synthesis & Verification of the 13-Array 41-Call Boundary Schedule on V = C^16.\n\nProves the viability of the theoretical maximum boundary schedule for Block m = 4:\n  - "
+    },
+    {
+      "pr": 4826,
+      "head": "d7b53d3992e658f0dd49d0207ba33bbc39272bac",
+      "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/d7b53d3992e658f0dd49d0207ba33bbc39272bac/research/complex-block5-three-in-nine/verify_schedule.py",
+      "hash_matches": true,
+      "changed_notice_paths": [
+        "research/complex-block5-three-in-nine/LICENSE",
+        "research/complex-block5-three-in-nine/NOTICE.md"
+      ],
+      "source_header": "#!/usr/bin/env python3\n\"\"\"Exact Synthesis & Algebraic Verification of the 3-Array 9-Call Schedule on Block m=5 (V = C^32).\n\nBreaking into the Block m=5 frontier to achieve saving exponent:\n  kappa = 1"
+    }
+  ],
+  "redistributed_notice_obligation": "Original per-package LICENSE and NOTICE.md independently retrieved; retain them with source redistribution. Source headers contain unsupported large kappa claims, which the consumer theorem does not endorse.",
+  "remaining": "Observation producer and favorable paid profile are not provided. No new kappa, native compiler, Lean kernel audit or human peer review is claimed.",
+  "literal_tensor_controls": [
+    {
+      "tensor_width": 1,
+      "dimension": 24,
+      "q4_recovers": true
+    },
+    {
+      "tensor_width": 2,
+      "dimension": 192,
+      "q4_recovers": true,
+      "untensorized_central_phase_rejects": true
+    },
+    {
+      "tensor_width": 3,
+      "dimension": 1536,
+      "q4_recovers": true
+    }
+  ],
+  "retained_licenses_sha256": {
+    "CASCADE-PR4818-LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "CASCADE-PR4819-LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "CASCADE-PR4826-LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+  },
+  "canonical_root_license_sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+  "integrated_theorem_sha256": "986b7f6a24e387c3cd44317b4d50e790d73c72d13f7befbc0464877eca406394"
+}

research/native-cyclic-recovery/CASCADE-EXPECTED.json

@@ -0,0 +1,75 @@
+{
+  "status": "PASS_FINITE_MONOMIAL_CASCADE_INVERSE",
+  "new_kappa": false,
+  "paid_observation_word_emitted": false,
+  "cases": [
+    {
+      "roles": 3,
+      "addresses": 16,
+      "dimension": 48,
+      "period": 6,
+      "exact_basis_columns": 48,
+      "monomial_passes_upper_bound": 6,
+      "ADD_passes_upper_bound": 6,
+      "coefficient_l1": "2",
+      "factored_monomial_passes": 3,
+      "factored_ADD_passes": 3
+    },
+    {
+      "roles": 3,
+      "addresses": 32,
+      "dimension": 96,
+      "period": 6,
+      "exact_basis_columns": 96,
+      "monomial_passes_upper_bound": 6,
+      "ADD_passes_upper_bound": 6,
+      "coefficient_l1": "2",
+      "factored_monomial_passes": 3,
+      "factored_ADD_passes": 3
+    },
+    {
+      "roles": 13,
+      "addresses": 16,
+      "dimension": 208,
+      "period": 26,
+      "exact_basis_columns": 208,
+      "monomial_passes_upper_bound": 26,
+      "ADD_passes_upper_bound": 26,
+      "coefficient_l1": "2",
+      "factored_monomial_passes": 13,
+      "factored_ADD_passes": 13
+    },
+    {
+      "roles": 3,
+      "addresses": 8,
+      "dimension": 24,
+      "period": 12,
+      "exact_basis_columns": 24,
+      "monomial_passes_upper_bound": 12,
+      "ADD_passes_upper_bound": 12,
+      "coefficient_l1": "2",
+      "factored_monomial_passes": 5,
+      "factored_ADD_passes": 5
+    }
+  ],
+  "source_binding": [
+    {
+      "pr": 4818,
+      "head": "fd29d065bbe12f5be5af02fdf5a8b4d86dda3381",
+      "exact_coupler_entries": 768
+    },
+    {
+      "pr": 4819,
+      "head": "a7b42c2f8ffe5a18d305ca4dda5729d2f1d72ea8",
+      "exact_coupler_entries": 3328
+    },
+    {
+      "pr": 4826,
+      "head": "d7b53d3992e658f0dd49d0207ba33bbc39272bac",
+      "exact_coupler_entries": 3072
+    }
+  ],
+  "controls": [
+    "discarded phase changes decoder and is rejected"
+  ]
+}

research/native-cyclic-recovery/CASCADE-INVERSE.md

@@ -0,0 +1,48 @@
+# Finite monomial cascade inverse
+
+This is a sufficient, constructive consumer theorem. It does not assert that any of the claimed 9-, 10-, 14-, or 41-call producer schedules actually emits its required observations. No new κ is established.
+
+Let W be a fixed positive integer and let H_0,...,H_(W-1) be phase-retaining Pauli monomials on a qubit address space. Define U on W arrays by (Uz)_k = H_k z_((k+1) mod W). Let M=I+U/2. Then U is unitary, U^(4W)=I, and
+
+    M^-1 = [sum_(j=0)^(4W-1) (-1/2)^j U^j] / (1-2^(-4W)).
+
+Every factor U is one literal role permutation plus one monomial address pass per role. Horner evaluation uses at most 4W such passes and 4W ADD passes, one fixed rational final scale, the unchanged observation array, and two owned work arrays. Thus this decoder introduces no additional recursive Gaussian child. Its native costs, storage and precision remain charged. It is not an unpriced dense inverse or oracle.
+
+## Proof and all-width quantifier
+
+Each diagonal block of U^W is a cyclic product of the H_k. The phase-retaining Pauli group is closed under products and every Pauli has fourth power I, including its quarter phase. Therefore every diagonal block has fourth power I and U^(4W)=I. The finite geometric-series identity gives M times the displayed polynomial equal to I on both sides. This argument applies at every tensor width f: tensorized Paulis remain Paulis; the coefficient 1/2 stays outside tensor products.
+
+If H_k are pure XOR translations, they commute, square to I and their cycle product squares to I. Then U^(2W)=I and the same formula shortens to 2W terms. In the exact source examples, W=3 with shifts [1,2,4] and W=13 with shifts [1,...,13], the XOR sum is nonzero. The role cycle forces every period to be a multiple of W and the nonzero return translation forces an even multiple. Hence 2W is the exact order, for those literal operators at positive width.
+
+For target observations v_k=K x_k + K G_k x_(k+1), write y_k=K x_k. The couplers in the y coordinates are H_k=K G_k K^-1. Clifford K conjugates a Pauli G_k to a phase-retaining Pauli. When G_k includes the scalar 1/2, factor that scalar out before defining H_k. Therefore the theorem recovers all y from genuinely emitted v. It does not create v from the original inputs; an actual chronological producer and its paid profile are prerequisites.
+
+The norm bounds are ||M|| <= 3/2 and ||M^-1|| <= 2. The absolute sum of decoder coefficients is exactly 2, since the geometric sum numerator is 2(1-2^-L) for even period L. A perturbation of the input observations is therefore amplified by at most 2. The exact complete-cascade condition number is 3 in the inspected source examples, as already proved in PR #4842; the small Schur-return bound 9/7 or 8193/8191 is not substituted for this full condition number.
+
+## Factored operational implementation
+
+The supplied program also compiles V=U^W as a single monomial, including the exact accumulated phase; it does not perform W live data passes to apply V. Write beta=(-1/2)^W and let q=2 for pure XOR or q=4 for general quarter-phase Pauli routing. Then
+
+    M^-1 = S_W(U) * [sum_(j=0)^(q-1) beta^j V^j] / (1-beta^q),
+    S_W(U) = sum_(j=0)^(W-1) (-U/2)^j.
+
+The two Horner evaluations need W-1 and q-1 monomial passes respectively, totaling W+q-2. This is 3 passes for each three-role XOR source and 13 passes for the thirteen-role XOR source; the quarter-phase three-role test uses 5 passes. The same number of ADD passes suffices, followed by the fixed rational scaling. Compared with the direct geometric polynomial, this reduces 6 passes to 3 and 26 passes to 13. The direct count was a constructive upper bound, not an optimality theorem.
+
+The factored evaluation retains the observation arrays. At most three owned work arrays suffice for general q=4 with separate source and destination buffers; the q=2 case needs two. The Python executable also materializes one monomial routing table, charged as O(W N) index/phase storage. A native Pauli implementation can instead store the W composed Pauli descriptors and enumerate addresses, but this replacement is a mathematical implementation prescription rather than a benchmarked machine program. Compilation and final cleanup are separately charged linear work.
+
+The coefficient absolute sum of the factored polynomial is again exactly 2: the sums are 2(1-2^-W) and 1/(1-2^-W). This supplies a bound for roundoff and perturbation; it does not make rational scaling free.
+
+## Native interpretation
+
+W and L are fixed. An address odometer implements the tensorized Pauli with one XOR/phase update per addressed scalar; all role routing, reads, writes, ADDs and fixed rational scaling are part of the finite bill. With coefficient precision p and word width w, general fixed-denominator rational arithmetic can be charged explicitly by d(w); a restoring-division fallback gives d(w)=O(w). This yields O(W L N d(w)) word operations and O(W N) scalar storage, with a constant depending on the fixed program. No hardware division instruction is assumed.
+
+Magnitude and roundoff are bounded by a constant independent of width because the Horner multiplier has norm 1/2 and there are only L steps. Choosing p = O(log(2+B)+log N+log(1/δ)) suffices for bounded input magnitude B and requested global error δ, after retaining the input's exact scale. Word-address headroom must include all original, output, scratch and guard fields. The sufficient storage condition is 2^w >= c W N for an explicit implementation constant c; no input is silently overwritten or counted twice as productive data.
+
+## Exact checks and provenance
+
+cascade_free.py implements the polynomial directly using exact rational complex pairs. It checks every basis column of the actual permutation operators on dimensions 48, 96 and 208, and a signed quarter-phase Pauli case of dimension 24. CASCADE-ORIGINS.json freezes the exact source bytes of PRs #4818, #4819 and #4826. The checker explicitly compares all 7,168 source coupler entries and verifies K G_k = G_k K. For #4826 it evaluates only the exact constructor prefix through E3, never the dense recovery test. These source checks stay active under optimized Python. The last case has noncommuting phase-bearing couplers; a decoder which discards these phases is rejected. Normal and optimized Python both use explicit checks rather than assertions.
+
+This leaf builds on hexapode's PRs #4818, #4819 and #4826 for the particular proposed cascade observations; Clear1nsight's PR #4842 for the exact full-cascade conditioning and producer-admission distinction; Dugongue's PR #4743 for the actual dirty native ports and monomial implementation; and the source lineage through Yiyang/Lyy-iiis #4710, lee-phys #4688 and Jacob Alan Sussman #4628. The finite-order geometric-series identity and Clifford/Pauli conjugation are standard facts, not claimed as new general mathematics. The contribution is a literal phase-preserving finite-pass decoder and explicit cost contract at this proposed consumer boundary. Prepared with substantial OpenAI Codex assistance, Apache-2.0.
+
+## Open next question
+
+Emit one of these observations from arbitrary independent inputs with an actual favorable paid Gaussian profile, retained source ownership, correct chronology and all-width phases. Then the present decoder can replace the unpriced dense recovery stage. A source which merely inserts K and E into a matrix does not satisfy the prerequisite. Compiler reserve, ordinary/outer admission, native precision and the full multiplication transfer must still be bound to the completed producer before any κ claim.