Certify 64 depth-coarse profiles and an adaptive-recursion limit

.github/workflows/depth-coarse.yml

@@ -0,0 +1,52 @@
+name: Verify depth-coarse family
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  selected:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.11', '3.13', '3.14']
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Regenerate selected words and verify exact certificate
+        run: python3 research/depth-coarse/verify.py --regenerate
+      - name: Independently verify the root and finite-family ceiling
+        run: python3 research/depth-coarse/independent.py
+      - name: Check mathematical and adversarial controls
+        run: python3 -m unittest discover -s tests -p test_depth_coarse.py -v
+      - name: Require unchanged source and certificates
+        run: git diff --exit-code
+
+  family:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    strategy:
+      fail-fast: false
+      matrix:
+        choice: [ccc, ccr, crc, crr, rcc, rcr, rrc, rrr]
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97
+        with:
+          python-version: '3.13'
+      - name: Regenerate and replay both axes for this family member
+        run: python3 research/depth-coarse/verify.py --menu-choice ${{ matrix.choice }}
+      - name: Require unchanged source and certificates
+        run: git diff --exit-code

research/depth-coarse/.gitattributes

@@ -0,0 +1,4 @@
+# Preserve byte-exact contributor snapshots and source manifests.
+vendor/** -text
+# Bind the selected archives as bytes; regeneration checks canonical raw words.
+*.gz -text

research/depth-coarse/PROOF-BARRIER.md

@@ -0,0 +1,142 @@
+# Optimal scalar recursion power within the frozen depth-coarse family
+
+This companion concerns the finite family of 64 complete interchange profiles
+obtained by choosing one word in `{c,r}^3` for each of the two axes, h=23 and
+h=25. Those letters select row/column regrouping at the **first three internal
+weighted-exclusion construction levels**, uniformly across the axis's common
+points; deeper levels use columns. This happens before a fixed word is compiled.
+It is not arbitrary internal per-node row/column assignment, nor a change to
+unit completion or carry exchange. The letters do not represent choices made
+at recursion depths of a growing-width interchange invocation. The latter
+choices are the subject of the theorem below.
+
+The scalar regrouping comes from eumemic's PR69; the anchored split and paid
+compiler come from PR71 and its credited predecessors. This companion proves
+a mathematical limitation of adaptive selection among the supplied complete
+profiles. It does not claim a record multiplication bound, worldwide novelty,
+an unconditional all-size theorem, or optimality over other circuits.
+
+## Fixed profiles and exact selection
+
+For profile j let m=575, W_j be its total physical role divisor, and n_{j,t}
+its **complete** positive child multiplicity, including all endpoint copies,
+exterior banks, data corners, physical growth and actual axis-profile children.
+Every child width satisfies 1<=t<=529<m. An invocation of width e>=m produces
+children with width t floor(e/m), each at relative logical volume 1/W_j.
+Define
+
+    M_j(alpha) = sum_t (n_{j,t}/W_j)(t/m)^alpha.
+
+These n/W coefficients are relative-volume weights, not probabilities.
+In this family M_j(0)>1 and M_j(1)=1-1846900/(575 W_j)<1. Each M_j is strictly
+decreasing and has one root alpha_j in (0,1). Write
+
+    alpha_* = min_j alpha_j,       a_* = 1-alpha_*.
+
+The independent arithmetic receipt checks the selected `rcr`/`rrr` profile
+below one at its accepted rational saving a, its next saving grid point above
+one, and every one of the other 63 profiles above one at a by **lower**
+moment bounds. Thus the selected profile has the unique smallest alpha_j.
+This certifies the strongest scalar characteristic within this frozen family;
+it does not follow merely from comparing W or rank mass.
+
+## A floor-exact adaptive barrier
+
+Assume the inherited complete interchange interfaces for all profiles. Consider
+any finite charged recursive tree which chooses one of them at each node,
+according to width, depth, orientation, role, previous choices or a random
+choice. Each occurrence retains its own relative volume; nonrecursive charges
+are nonnegative. At any elementary leaf assume work at least c_0 V e for one
+fixed c_0>0. A fixed bounded-width elementary implementation meets this
+condition after choosing its fixed constant c_0.
+
+**Theorem.** Every such complete-tree accounting has work at least
+
+    [c_0/(1+D)^alpha_*] V(e+D)^alpha_*,    D=13225/2.
+
+Consequently adaptive profile switching cannot improve the scalar recursion
+power beyond the best standalone root in this family.
+
+**Proof.** More generally take D=max_{j,t} tm_j/(m_j-t) for any finite menu.
+Here t<=529 and m=575, so D=529*575/(575-529)=13225/2 suffices. For every
+legal recursive width,
+
+    t floor(e/m)+D >= (t/m)(e+D),
+
+because floor(e/m)>=e/m-1 and D(1-t/m)>=t. Since alpha_* is positive and
+M_j(alpha_*)>=M_j(alpha_j)=1,
+
+    sum_t (n_{j,t}/W_j)[t floor(e/m)+D]^alpha_*
+       >= (e+D)^alpha_* M_j(alpha_*) >= (e+D)^alpha_*.
+
+The function e/(e+D)^alpha_* increases on e>0, so for e>=1,
+
+    e >= (e+D)^alpha_* /(1+D)^alpha_*.
+
+This supplies the elementary-leaf lower charge. Every recursive child has
+strictly smaller positive integer width. Strong induction, multiplying each
+child charge by its actual V/W_j and summing its multiplicity, proves the
+bound. Node overhead only adds work. The proof is pointwise for each realized
+tree, so randomized selection does not evade it. QED.
+
+This is a bound on the explicit recursive work functional. An upper recurrence
+by itself never implies a lower bound on an arbitrary machine's actual runtime.
+An algorithm sharing computations between child occurrences, exploiting a
+stronger restricted child contract, choosing unbounded input-dependent new
+networks, or changing the leaf cost model is outside the theorem.
+
+## Sharpness of this scalar power
+
+For the selected profile alone, the unshifted potential V e^alpha_* does not
+increase at a recursive expansion: floors only decrease child widths and its
+characteristic equals one. Therefore total elementary-leaf volume is at most
+V e^alpha_*, since every positive leaf width is at least one. Let
+B_0=sum_t n_t/W>1. Summing volume identities over the whole selected tree gives
+
+    leaf volume = root volume + (B_0-1) total internal-node volume.
+
+Hence the total internal volume is O(V e^alpha_*). Elementary leaves have
+width below the fixed m and cost O(their volume). If the nonrecursive charge
+of a node is O(its volume times a common polylogarithmic factor), the selected
+tree has work O(V e^alpha_* times that factor). Separate setup and tape costs
+remain separately charged. Under these hypotheses the optimal scalar power
+for this complete-profile family is exactly alpha_*.
+
+Finite tensor compositions have characteristic equal to the product of their
+constituent characteristics, so every factor is at least one at alpha_*.
+Expanding any such macro into its complete tree gives the same obstruction.
+The result does not extend to new unbounded network families.
+
+## Typed recursion and the balanced assembly ceiling
+
+Merely adding orientation tags cannot improve the root if every type has this
+same complete child histogram. Its nonnegative matrix characteristic then has
+constant row sum M(alpha), so its spectral radius is exactly M(alpha), by the
+all-ones eigenvector and the ordinary sup norm. A genuine multitype improvement
+needs independently proved cheaper child-operation contracts, with a positive
+vector v satisfying A(alpha)v<v; the existing generic contract does not supply
+that improvement automatically.
+
+The inherited balanced assembly requires kappa<min(1-epsilon,epsilon q) and
+q<a_b. Balancing the two expressions at epsilon=1/(1+q) gives the existing
+strict scoped ceiling kappa<a_b/(1+a_b). Substituting the independently bounded
+selected root therefore bounds the complete remaining analytic/parameter
+headroom for this finite family. The receipt supplies the exact numerical
+enclosure; this ceiling is inherited and is not claimed as a new assembly.
+
+For the frozen selected profile the independently enclosed saving root is
+strictly between 0.0000516459365535807612 and 0.0000516459365535807613. Thus this
+family's unchanged balanced assembly has strict ceiling
+
+    kappa < 516459365535807613/10000516459365535807613.
+
+Its published finite witness is kappa=5164326938841/100000000000000000.
+The entire remaining analytic/parameter headroom within these hypotheses is
+less than 1.565e-16 in absolute saving. This says nothing about a stronger
+construction outside the frozen 64-profile family.
+
+The all-size residual compiler, row/remainder handling, finite-alphabet tape
+simulation, analytic transfer, routing, address primes, setup, precision and
+exact-recovery contracts remain explicit hypotheses. Finite word/profile replay
+and the rational comparisons establish their respective finite layers, not
+these complete all-size theorem dependencies.

research/depth-coarse/PROOF.md

@@ -0,0 +1,65 @@
+# Local algebra and inherited proof boundary
+
+Let Gi,Gj be disjoint groups of vertices, each of size 1 or 2. Every edge value
+e(a,b) has support disjoint from all other edge values in this coarse sum.
+The coarse edge is
+
+    Cij = sum_{a in Gi, b in Gj} e(a,b).
+
+It can be emitted as either
+
+    sum_{b in Gj} (sum_{a in Gi} e(a,b))       [columns]
+    sum_{a in Gi} (sum_{b in Gj} e(a,b))       [rows].
+
+Both are finite distributive regroupings of precisely the same partition.
+Every nontrivial addition has disjoint support; singleton/empty summands are
+handled by the inherited total routine. Each intermediate core and cover is
+computed from its actual support. The resulting common-point exclusion graph
+therefore retains its weighted total and all single/pair exclusion identities.
+
+The row/column choice is fixed at each internal weighted-exclusion construction
+level before compilation. There are eight choices at levels 0–2; deeper levels
+use columns. This is a
+finite grammar, not a data-dependent runtime choice. The PR71 grouping vector
+[1,1,2], singleton/pair partition and strict contraction are unchanged, so its
+weighted induction and termination proof apply to either regrouping. The
+global-pair anchor remains a permutation of points other than each common point.
+
+Reassociation can share nodes with the existing strip DAG and can alter
+carrier matching/retirement. Thus fewer scalar additions do not prove fewer
+physical roles or a better exponent. The selected word is recompiled in full,
+with every paid XOR, frame raise, source, copy, endpoint and dirty-state cleanup.
+No actual price is replaced by the discovery heuristic. The full paid profile
+is constructed as in PR71: data and endpoint copies, replicated actual axis
+profiles, exteriors and data growth. It satisfies
+
+    W = 2N + 2300 R23 + 1771 R25,
+    sum_t t n_t = 575 W - 1846900,
+    0 < t <= 529 < 575.
+
+The normalized characteristic is
+
+    M(a) = sum_t n_t t/(575 W) exp(a log(575/t)).
+
+Inherited independent rational logarithm/Taylor bounds prove a strict accepted
+upper moment and strict rejected lower moment at adjacent saving grid points.
+The complete frozen PR #71 and #75 profiles are also lower-bounded above 1 at
+the selected saving; comparing width alone is insufficient. The inherited
+balanced assembly is rerun for all 47 strict inequalities, seven margins and
+the adjacent kappa-grid rejection, retaining backoff 10^-12 and the unchanged
+complex saving 717/10^7.
+
+The literal verifier explicitly reconstructs the entire ordered scatter list
+from the exact output inventory and compares it with the word. Canceling extra
+scatter operations therefore cannot pass merely because their net scalar map
+is zero. This binding follows PR64's verification precedent. All port/role
+indices are range-checked before inherited replay, so negative Python indices
+cannot masquerade as legitimate source/dirty roles. Every input, target and
+dirty basis coordinate is replayed in both orientations, and actual frame
+transitions and exact fixed-basis/CRT profiles are regenerated.
+
+These are finite algebra, word and arithmetic claims. The ambient framed lift,
+all-size row/remainder compiler, scalar overhead, tape/routing simulation,
+prime/setup/recovery and analytic multiplication transfer remain inherited
+dependencies. This local proof does not remove those hypotheses or establish
+global optimality of the finite search.

research/depth-coarse/README.md

@@ -0,0 +1,79 @@
+# Exact depth-coarse family and adaptive recursion barrier
+
+[The finite-family adaptive barrier](PROOF-BARRIER.md) proves that switching
+among these 64 complete profiles cannot improve their best scalar recursion
+power under the stated leaf-work and complete-tree accounting assumptions.
+It includes exact root and balanced-assembly headroom bounds; it is a scoped
+family theorem, not a lower bound for arbitrary multiplication machines.
+[The local construction proof](PROOF.md) gives the disjoint-support grammar
+and finite validity argument. An independent checker imports no package
+arithmetic and rederives the complete profile, exact root, all 47 constraints,
+seven margins and 63 competitor exclusions.
+
+Concurrent [PR #79](https://github.com/CrocSwap/integer-mult-bounds/pull/79),
+at `9a58e62cf9e8954a4dde3c9b1372d733c276a6d1`, reports the stronger conditional
+κ = 5.1745625472866e-5 using a per-cell grammar, unit completion and carry
+exchanges outside this family's frozen compiler.
+[PR #80](https://github.com/CrocSwap/integer-mult-bounds/pull/80), at
+`a9ed157ff106fd35557b5896197f66a1272f7f13`, reports κ = 5.1778825456819e-5.
+These are submitted comparison values; this package establishes a bounded
+family result and makes no priority or strongest-known-bound claim.
+
+This adds a finite conditional witness by composing eumemic's PR69 coarse-column
+factorization with Chafik Boukhalfa's PR71 anchored split/next-use compiler.
+The depth grammar allows row factoring independently at the first three
+internal weighted-exclusion construction levels, with columns below them.
+All eight words at each axis have been physically checked; all 64 complete
+profile combinations are compared exactly. The selected h=23 word is `rcr`
+and h=25 word is `rrr`, in construction-level order.
+
+The selected witness gives exact kappa
+`5164326938841/10^17 = 5.164326938841e-5`. Its role counts are
+27,309 / 35,798 and physical width is 134,355,558. Complete PR #71 and #75 profiles are
+excluded at the new bit saving, using immutable comparison certificates.
+See `certificate.json` for the accepted complete moment, all 47 assembly
+inequalities, seven margins, next-grid rejection and arithmetic cutoffs.
+Every other 63 finite-menu profile is strictly excluded at the selected saving.
+
+From the repository root:
+
+```
+python3 research/depth-coarse/verify.py
+python3 research/depth-coarse/verify.py --regenerate
+python3 research/depth-coarse/verify.py --arithmetic-only
+python3 research/depth-coarse/verify.py --menu-choice ccc
+python3 research/depth-coarse/menu.py
+python3 research/depth-coarse/independent.py
+python3 -m unittest discover -s tests -p test_depth_coarse.py -v
+```
+
+Default verification independently binds every literal scatter port and exact
+terminal inventory, replays every source/target/arbitrary dirty basis in both
+orientations, reconstructs frame transitions, regenerates actual fixed-I+J/CRT
+profiles and checks exact arithmetic. `--regenerate` additionally recompiles
+the selected DAG/matching/reclamation word and compares decompressed bytes.
+`CXX` can select a working C++17 compiler, as in inherited checks. Temporary
+files and logs are outside scientific certificates.
+`--menu-choice` regenerates both axes of any one menu word and compares their
+canonical word hashes, full dirty/frame receipts and actual CRT profiles with
+the frozen menu. The 16 recipe/profile receipts and hashes are shipped without
+duplicating all 16 large words. The default arithmetic path verifies all 64
+exact moment brackets, assemblies and strict nonwinner exclusions.
+
+This package changes no root headline, notice, Makefile or historical witness.
+It remains conditional on the inherited all-size framed-word/residual compiler,
+finite-alphabet tape, analytic, routing, prime selection, precision and recovery
+contracts. Arithmetic cutoffs are not a complete operational threshold. No
+global optimum, unconditional theorem or practical speedup is asserted.
+
+Prepared for Joseph Demarest with substantial OpenAI Codex assistance. Original
+code is retained byte-for-byte with source hashes and contributor notices in
+`vendor/`; root Apache-2.0 terms apply. PR69 supplies uniform column factoring;
+PR71 supplies split/anchor/next-use composition; Rohan Arun PR65/67 supplies
+schedules/profile costs/directed arithmetic; Dominik Scholz PR68 supplies live
+controls; Rohan Garg PR59 supplies split operation; eumemic PR57 supplies joint
+reversible compilation; Avi Eisenberg PR62 supplies interval/core-aware graph.
+rfu08 PR64 supplies explicit literal-scatter verification precedent. Earlier
+community, OpenAI and Harvey–van der Hoeven attribution remains in retained
+notices. The contribution is the independently verified depth factoring
+family, its exact optimum, and its scoped adaptive-recursion barrier.