Improve conditional κ to 0.00329394 by retiring an independent Gaussian

research/gaussian-root-retirement/NOTICE

@@ -0,0 +1,25 @@
+New Gaussian retirement construction, proof, caller checks and package:
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+No subagents or independent scientific review are claimed.
+
+Retained sources are byte-exact in native-source.tar and engines.tar.
+RETAINED.json records every original path, head, Git blob and SHA256.
+Original source headers, proof files and notices remain in the archives.
+
+https://github.com/CrocSwap/integer-mult-bounds/pull/5599
+The independent causal handoff and productive helper method; retain the
+PR5602/5611/5615 basis and dyadic-completion lineage.
+https://github.com/CrocSwap/integer-mult-bounds/pull/6398
+Ali Romman's mixed projector root, based on PR6348 and the retained native,
+query, productive recursion, interval, compiler and outer proof sources.
+https://github.com/CrocSwap/integer-mult-bounds/pull/6529
+Ali Romman's scaled transport fusion. Predecessors include Rohan Arun's
+PR6399/6417, Erwan L.'s PR6453, DreamingOfClouds' PR6375, and PR6353/6372.
+https://github.com/CrocSwap/integer-mult-bounds/pull/6524
+Ali Romman's explicit complete replay interfaces. Native sources retain
+David Arias, Cinna Davis, Gareth Davidson and earlier contributor credit.
+Integer interval work retains ywz65 and Nick Petalas credit.
+
+Other retained contributors include Jacob Alan Sussman, Mason Hale,
+Pierre-Loic Doulcet, Chris R / Clear1nsight, zxv and Cao Yifan.
+The exact archive notices provide the complete retained source attribution.

research/gaussian-root-retirement/PHYSICAL-EDITS.json

@@ -0,0 +1,6 @@
+[
+  [
+    "            positive = list(axes[:9]) if selected[0] else [q]",
+    "            need(qp in (-1, 0, 1) and not (qp == 0 and selected[0]), 'Declared central phase and fresh-stage target')\n            positive = list(axes[:9]) if selected[0] else ([q] if qp else [])"
+  ]
+]

research/gaussian-root-retirement/PRICING-EDITS.json

@@ -0,0 +1,46 @@
+[
+  [
+    "KAPPA = Q('0.003288299')",
+    "KAPPA = Q('0.00329394')"
+  ],
+  [
+    "TESTED = Q('0.003288304')",
+    "TESTED = Q('0.003293945')"
+  ],
+  [
+    "PREVIOUS = Q('0.003287014')",
+    "PREVIOUS = Q('0.003288299')"
+  ],
+  [
+    "        main[1+8*sum(term[1:])] += 104",
+    "        main[int(term[0] % 2)+8*sum(term[1:])] += 104"
+  ],
+  [
+    "    need((targets, paid) == formula_invoice(local), 'Independent tree and emitted-event counts')",
+    "    expected_targets, expected_paid = formula_invoice(local)\n    expected_targets.update({1:104,16:104,17:-104})\n    need((targets, paid) == (expected_targets, expected_paid), 'Independent tree, retirement delta and emitted-event counts')"
+  ],
+  [
+    "counts['LAMBDA'] == 20",
+    "counts['LAMBDA'] == 34"
+  ],
+  [
+    "(13652, 67096)",
+    "(13756, 67096)"
+  ],
+  [
+    "32*34*104*len(word['events']) + 34*104*(26+1000)",
+    "32*35*104*len(word['events']) + 35*104*(26+1000)"
+  ],
+  [
+    "'kappa_decimal': '0.003288299'",
+    "'kappa_decimal': '0.00329394'"
+  ],
+  [
+    "'refinement_kind': 'Two scaled transport fusions with an output basis correction; unchanged mixed root.'",
+    "'refinement_kind': 'Independent Gaussian retirement changes the complete productive profile.'"
+  ],
+  [
+    "    low, high, grid = 0, 10**24, 10**26\n    while high-low > 1:\n        middle = (low+high)//2\n        if margin(Q(middle, grid))[0] > 0:\n            low = middle\n        else:\n            high = middle\n    lower, upper = Q(low, grid), Q(high, grid)\n",
+    "    from root_interval import construct\n    bracket, _ = construct(E, T, P)\n    lower, upper = Q(bracket['lower'], bracket['grid']), Q(bracket['upper'], bracket['grid'])\n"
+  ]
+]

research/gaussian-root-retirement/PROOF.md

@@ -0,0 +1,130 @@
+# A Gaussian output before the suffix
+
+## 1. Exact source and claim
+
+The native source is PR6529 at
+`44b0d0e8961201ac1656490b4384a7752e1cd9c5`. Its caller is the PR6398
+34-field word. Number events from zero. Let P be its prefix through event 328,
+`QUERY 20 21 -1`. Let q denote the central Gaussian Q in the replay.
+All 18 stage variables D_j commute with q and with one another.
+
+Set
+
+```text
+λ = (1+i)/2 + (1-i)q²/2,
+S = λ q⁻¹.
+```
+
+Then λ⁻¹ is its complex conjugate, λ² = q², and S² = 1. Thus λ and its
+inverse are ordinary linear combinations of the identity and the ordinary
+translation q². The retained physical checker verifies the translation and
+its absolute phase. These ordinary scalars stay outside tensor powers.
+
+Fields 4, 20 and 21 have the same two-stage factor D = D_10 D_11. An even
+central translation and λ normalize all three complete outputs to S D.
+The other fields keep their source targets. All input fields are arbitrary.
+
+## 2. Two exact dual pairs
+
+Use row vectors a,c and column vectors b,d:
+
+```text
+a = e1ᵀ - 2e2ᵀ - λe20ᵀ + e21ᵀ,
+b = -e2 - e21,
+c = e20ᵀ - e4ᵀ,
+d = -λ⁻¹e21 - e4.
+```
+
+The identities are
+
+```text
+ab = cd = 1,       aP = Sc,       Pd = Sb.
+```
+
+`check_caller.py` checks both pairings and both prefix identities over the full
+central polynomial ring. It does not specialize q² to one or test only numeric
+values of the D_j.
+
+Let G and J be the literal ordinary basis words in `WITNESS.json`. The checker
+also verifies
+
+```text
+e4ᵀG = c,     Gd = e4,
+e4ᵀJ = a,     Jb = e4.
+```
+
+Every gate is invertible. ADD coefficients are dyadic; SCALE uses a dyadic
+unit; λ has the stated ordinary inverse. G acts only on fields 4,20,21.
+
+## 3. Separate the completed Gaussian from the remaining work
+
+Apply G⁻¹ at the input. At the cut, apply J. The pivot row and column of
+`JPG⁻¹` are both exactly `S e4`. Therefore the pivot has no coupling to the
+other inputs or outputs at this cut. In block form, the prefix is `S ⊕ K`.
+
+Let F be the complete source diagonal after the three output normalizations.
+Since G mixes only equal S D targets, G commutes with F. Apply G at the output.
+The complete map remains `GFG⁻¹ = F`. The suffix after J must therefore have
+pivot block D and zero coupling to the other fields: its pivot block times S
+is S D. This uses S²=1 and the exact arbitrary-input source identity.
+
+Return the completed pivot output. Give the suffix a new independent input in
+field 34. In the literal word, rename pivot 4 to 34 in J⁻¹ and every later gate,
+including the output basis. Other fields still pass through K and its matching
+suffix. This is a direct sum of two independent targets, S and D, in place of
+one S D target. It is not a copy of one input to two output targets.
+
+Finally apply λ⁻¹ to the three original group fields. The returned pivot has
+target q⁻¹. The new field has target D_10 D_11. The complete 35-field word has
+609 events. Both full forward replay and an independent reverse-row replay
+check every one of its 1,225 coefficient positions. Deletion, sign and target
+mutations reject the claimed identity.
+
+## 4. Physical maps and all costs
+
+For each of the 104 ports, the central q axis is orthogonal to the two fresh
+8-axis stage blocks. The old Gaussian target has rank 17. The returned q⁻¹
+target has rank 1 after an ordinary q² translation. The fresh target has rank 16
+and no central factor. The physical checker compares complete phase polynomials,
+including the absence of that central factor. It checks every port.
+
+At each positive tensor width f, substitute q tensor f and D_j tensor f in
+the same ring identity. Define the ordinary normalizer from the square of
+that central operator. Do not tensor its scalar coefficients. The two new
+Gaussian ranks are f and 16f. This retains the source tensor convention and
+its framework assumptions.
+
+The ordered full-stage calls, thin-query signs, and whole-idle stage sets stay
+fixed. Only some role names change. Every native call still receives arbitrary
+inputs and fresh independent helper fields. All 67,096 paid jobs and all native
+helper credits stay in the source invoice. The productive change is exactly
+
+```text
+104(H1 + H16 - H17).
+```
+
+For H_r=r^t and 0<t<1, strict subadditivity gives H1+H16>H17. Rank mass stays
+fixed. The gain comes from independent outputs, not from a larger rank count.
+The total productive-field count becomes 13,756.
+
+The caller has one extra public field per port. The native owned inventory is
+unchanged: 29 labels, 45 lifetimes, peak 13. The complete ordinary-work upper
+bound is 254,699,248, below the retained 10^9 allowance. It includes every scalar
+basis gate, central normalization, route and output adapter. The coefficient,
+storage, growth and precision estimates remain explicit in `pricing.py`.
+
+## 5. Conditional κ and the fixed invoice limit
+
+Two rational engines certify the positive complete moment at the tested saving
+0.003293945. They independently certify both signs of the raw bracket stated
+in the README. A negative derivative bound gives a unique crossing through the
+retained BIT range. The old caller fails at the new claim in both engines.
+
+The productive recursion, completion tails, uniform compiler threshold and all
+outer inequalities are checked with the enlarged target count. The result is
+conditional κ=0.00329394 under the same five framework assumptions. No selected
+frontier change or independent scientific acceptance follows from this replay.
+
+The fixed invoice cannot reach the current 1% target 0.00332118199. A larger
+result must change the caller, source word or another charged interface. More
+digits of this crossing do not provide that change.

research/gaussian-root-retirement/README.md

@@ -0,0 +1,101 @@
+# Independent Gaussian retirement: conditional κ = 0.00329394
+
+The complete caller returns one central Gaussian output before its two-stage
+suffix. A fresh independent input then uses that suffix. On each of 104 ports,
+this replaces one rank-17 target with independent rank-1 and rank-16 targets.
+Every paid Gaussian call stays in the invoice.
+
+The conditional claim is **κ = 0.00329394**. The increment over
+[PR6529](https://github.com/CrocSwap/integer-mult-bounds/pull/6529),
+κ = 0.003288299, is **0.000005641, or 0.17154766%**. This percentage excludes
+all gains in the source chain. The requested 1% gain is not achieved.
+
+| Complete invoice | PR6529 | This caller |
+|---|---:|---:|
+| Independent caller fields per port | 34 | 35 |
+| Caller events | 570 | 609 |
+| Productive fields, with native helpers | 13,652 | 13,756 |
+| Paid Gaussian jobs | 67,096 | 67,096 |
+| Full native calls / thin queries | 18 / 17 | 18 / 17 |
+| Rank-mass surplus | 760 | 760 |
+
+The target change is `104(H1 + H16 - H17)`, where `Hr = r^(1-κ)`.
+It is positive for every exponent strictly between zero and one. The source
+native word, its helper targets and its owned lifetimes stay fixed. All added
+basis gates, routes, output normalizers and the additional public field enter
+the complete ordinary-work allowance.
+
+Start with [PROOF.md](PROOF.md), [retirement.py](retirement.py) and
+[WITNESS.json](WITNESS.json). [RESULT.json](RESULT.json) records the exact
+caller, phase, price, compiler and outer checks. [RESEARCH.md](RESEARCH.md)
+states the scope of the discovery and the limit of this fixed invoice.
+
+## Evidence
+
+The forward polynomial replay checks all 1,225 coefficients over
+`Q(i)[Q,D_1,...,D_18]/(Q^4-1)`. A separate reverse-row engine checks the same
+complete map. Both dual-pair identities and both literal basis maps are checked.
+The fresh input is arbitrary; it is not prepared zero storage.
+
+The source replay regenerates PR6529 and retains its checks and controls. It
+checks all 799 native columns, 2,939 native maps, 208 main adapters, and all
+7,488 physical contacts. The candidate then checks all target phases, all
+whole idles, both rational price engines, the uniform compiler, and all
+54 strict plus four functional outer predicates. See [VALIDATION.md](VALIDATION.md)
+for the executed commands and publication status.
+
+The unique raw crossing for this fixed invoice lies in
+`(0.00329394637095319036829691, 0.00329394637095319036829692)`.
+The claim uses the tested saving `0.003293945`, below that interval.
+This is a ceiling for this invoice, not for other words or callers.
+
+## Reproduce
+
+From the repository root, with CPython 3.12:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/gaussian-root-retirement
+```
+
+The package needs only the standard library. Both normal and optimized runs are
+registered. The two source archives contain every runtime input, with original
+paths, heads, Git blobs, SHA256 hashes and notices. The adapter checks preserve
+all source checks. Explicit engine dependencies use the interfaces from PR6524;
+no imported function or class is patched.
+
+## Scope and limits
+
+This is an author-checked conditional construction. It is not independent
+scientific acceptance, a formal proof of the full multiplication theorem, or a
+measured runtime gain. The five inherited framework assumptions remain:
+`native_all_columns`, `owned_erasure`, `compiler`, `precision_tape`, and
+`analytic_recovery`. The large uniform word and rounded multiplier are not
+materialized. The selected frontier is unchanged.
+
+The source stack includes pending PRs. Passing the registered replay does not
+admit that stack. The new result improves the caller boundary; it does not prove
+optimality over other cuts, native words, target groups or query networks.
+
+## Open next questions
+
+- Can another caller return a larger Gaussian factor at a legal intermediate
+  cut? First test exact dual pairings on a changed word and write its complete
+  target and paid invoice. The present fixed word has little remaining price
+  headroom. A favorable numerical screen is not a caller.
+- Can a repeated Gaussian-assisted interface have a favorable complete cost?
+  First supply exact transition matrices, a closed endpoint and native helper
+  delivery. The current small-state searches do not supply such a cycle.
+- Can an independent reviewer check the prefix identities and the 104 physical
+  output normalizations? The small basis and separate reverse engine provide
+  bounded entry points. Full framework admission is a separate task.
+
+## Credit
+
+New construction, proof and package: Ali Romman with substantial OpenAI Codex
+assistance; no subagents. Apache-2.0. The independent handoff method comes from
+PR5599 and the PR5602/5611/5615 line. The root comes from PR6398 and PR6348.
+PR6529 supplies the complete native word; PR6524 supplies the replay engines.
+Credit Cinna Davis, Jacob Alan Sussman, Rohan Arun, Erwan L., DreamingOfClouds,
+David Arias, Gareth Davidson, Mason Hale, Pierre-Loic Doulcet, Chris R /
+Clear1nsight, zxv, Cao Yifan, and all authors in the retained notices.
+[NOTICE](NOTICE) gives the source links and attribution boundary.

research/gaussian-root-retirement/RESEARCH.md

@@ -0,0 +1,36 @@
+# Discovery and remaining scope
+
+The new step changes a hypothesis of the PR6398 packing ceiling. That ceiling
+keeps each complete Gaussian target intact. This caller returns one factor at
+an intermediate cut and gives the suffix a fresh input. Its target inventory
+is therefore outside that fixed-target model.
+
+The discovery screen first set q²=1. It searched the equal-target groups and
+paid-event cuts in the literal 34-field caller. It found the group 4,20,21 after
+event 328. A separate q²=-1 calculation gave compatible dual pairs. Neither
+specialized calculation was used as a substitute for the full-ring proof. The
+published checker validates the unspecialized pair and complete caller.
+
+The first emitted word normalized every original output. Only the three group
+outputs need that normalization. The final construction uses 609 events instead
+of 684. This reduces ordinary work and proof surface; it does not add another
+κ gain. The native source was then updated from PR6398 to PR6529. The reported
+increment compares the new caller with PR6529 and excludes that inherited gain.
+
+The source invoice is preserved, except for the 104 legal target splits. The
+strict raw bracket is less than 6.371e-9 above the conditional claim. This is
+almost all the gain available from this exact invoice. It is not a global
+ceiling for independent Gaussian retirement.
+
+Further local discovery tests covered supplier-boundary shears, larger scalar
+roots, changed query words, owned-lifetime output bases, and short moving-state
+Gaussian-assisted templates. They did not produce another complete caller.
+These were bounded searches, not universal impossibility proofs. Their work
+files are not runtime inputs to this package and are not published as exact
+exhaustive coverage claims. No relaxed favorable price is counted as a result.
+
+A useful next construction needs a larger independent target split or a new
+closed query interface. It must bind the actual native helper maps and charge
+all helper debits, idles, routes, COPY/CLEAR work, restoration, compiler and
+outer costs. The 1% target over PR6529 is 0.00332118199. This package does not
+meet that target.