Prove a complete-cost obstruction for eight two-accumulator rewrites

research/two-accumulator-saved-arms/NATIVE-REPLAY.md

@@ -0,0 +1,102 @@
+# Native local replay and source binding
+
+## Exact selected input
+
+The source word comes from PR1140 at
+`8e2e18b93d8c6b302e540ad5edc767cb98cf1514`, path
+`research/k8-frame-antichain/inputs/SEVEN-SLOT-WORD.json.gz`.
+Its decompressed SHA256 is
+`c2b294300760e1fd6eeab8c22c4d13e4633dca40e52cac8da0d68163a76e3ca8`.
+
+It is also the exact decompressed input in the selected PR1094 replay
+archive at the experiment base. The archive is
+`research/community-frontier1094-audit/selected-replay.tar.gz`; its member
+is `candidate/strict/global/base/providers/gauge44/FULL-WORD.json.gz`.
+The sibling `CANONICAL-WORD.json.gz` has decompressed SHA256
+`4ddb29fb9bc6f27e0c0fbfcf19a2a93a3496ad900d0f6d89059d0305c9576c0c`.
+The retained scalar/frame receipt binds both hashes and the local profile.
+The package retains that receipt and the canonical word. Mask zero changes
+only a research metadata field; all scalar gates, frames, endpoints, and
+paid data are equal to the raw input.
+
+The source tree's old `evidence/local` files are historical R492 evidence.
+They are not the selected rebuilt R480 word. The maintainer's
+`docs/research/community-batch1099-review.md` already records this distinction.
+This package binds to the selected replay archive.
+
+`audit_local.py` is copied without change from PR1238 at
+`50a1c992ce28c95d83d11bc691353aaa289d9d65`, path
+`research/end-cap-obstruction/inputs/repo/research/gauge44-slots/independent/audit_local.py`.
+`intervals.py` is copied without change from PR1240 at
+`1e136b8c4a552050820334ad113628775182f08c`, path
+`research/complex-local-word-ceiling/ceiling.py`.
+`SOURCES.json` gives their Git blobs and byte hashes. It also pins the native
+entry points and the baseline attaining-table source.
+
+## Repeat the native run
+
+Use a checkout of the exact experiment base with the selected native source
+directories present. The native source is read only. Put all new files in a
+new work directory. The commands below use a Python environment that can run
+the retained native tools. The recorded run used Python 3.14.7. The package's
+standard-library family check was also run with Python 3.12.
+
+Set the three paths, then run from this repository root:
+
+```sh
+NATIVE_ROOT=/absolute/path/to/base-checkout
+PYTHON=/absolute/path/to/python
+WORK=/absolute/path/to/new/two-accumulator-native
+UP="$NATIVE_ROOT/research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2"
+SRC="$NATIVE_ROOT/research/complex-k492-owner-repair/vendor/multicold"
+export MULTICOLD_SOURCE="$SRC" GAIN_PR564_SOURCE="$SRC"
+export OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1
+mkdir "$WORK"
+"$PYTHON" -I -B research/two-accumulator-saved-arms/build.py --mask 255 --output "$WORK/RAW.json.gz"
+"$PYTHON" "$UP/code/hpe_audit_and_transport.py" --raw "$WORK/RAW.json.gz" --routing "$SRC/vendor/pr558/vendor/pr552/complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz" --out "$WORK/local"
+"$PYTHON" "$UP/code/hpe_emit_local.py" "$WORK/local"
+"$PYTHON" "$UP/code/hpe_audit_local.py" "$WORK/local"
+"$PYTHON" "$SRC/code/run_portable.py" "$UP/code/hpe_adapters_local.py" "$WORK/local/CANONICAL-WORD.json.gz" "$WORK/local/RESIDUAL-ADAPTERS.json" "$WORK/local/WRAPPER-CHECKS.json"
+"$PYTHON" "$SRC/code/run_portable.py" "$SRC/vendor/pr558/code/phases_full.py" "$WORK/local" "$SRC/vendor/pr558/vendor/pr552/complex-global/vendor531/vendor/clifford"
+```
+
+The recorded all-eight run passes:
+
+- transport and exact 704-column maps in both orientations;
+- 24,883 emitted events in each orientation and complete paid mass 5602;
+- independent local replay and 25 rejected controls;
+- exact residual wrappers and 17 rejected controls;
+- all 2,900 directed frame/centre edges with exact global phases and 224
+  endpoint adapters.
+
+The new canonical content SHA256 is
+`0d5d90211bf938b59c1897589e379dfa16eadb0aa3e832f2b01b01a9ea40e50e`.
+The Clifford recipe byte SHA256 is
+`816fb074375279ed914f9cc7ca14da285fba8c76d133d8db69a60d9cbe74e293`.
+Compressed hashes in inherited receipts describe the recorded environment;
+content hashes are the comparison for regenerated compressed files.
+
+The native run is for the all-eight word. The all-256 check has the separate
+coverage in the README. No complete global owner, physical operator stream,
+or new kappa is constructed by these native commands.
+
+## Comparison with PR1319
+
+The fresh PR1319 head is
+`603defe58aac018c6a8457840481390a15846fe4`. Both its base and extra providers
+use a different local bill and helper inventory. Each still contains all
+the gate values removed from B by these eight recipes, but this does not
+establish compatibility. The selected cleanup gates at indices 6794 in
+recipe 6 and 6791 in recipe 7 are absent from both providers. Their width
+inventories are, respectively,
+
+```text
+{4:44,5:44,7:38,8:114,9:240}
+{4:40,5:48,7:38,8:114,9:240}
+```
+
+Thus the recipes do not apply byte-for-byte to these providers, and the
+baseline dual constants in this proof do not apply to their inventories.
+The saved-arm restoration also touches the later reader helpers 592 through
+599. A composition needs new dirty-input, frame, endpoint, and complete
+cost checks. This package makes no claim about that composition.

research/two-accumulator-saved-arms/NOTICE.md

@@ -0,0 +1,39 @@
+# Attribution and license
+
+The new saved-arm recipes, complete cost proof, builder, and check package
+are by Ali Romman <226877337+aliromman@users.noreply.github.com>, with
+substantial OpenAI Codex assistance. They are under Apache-2.0.
+
+The source word is Jeremy Kothe's seven-slot k8 construction in PR1074,
+which retains the PR1018 step and credits Rohan Arun's PR987 search. This
+package takes the exact retained word from the PR1140 input archive. It
+does not claim authorship of the earlier scalar, frame, source-access,
+wrapper, or phase construction. The source notices are retained under
+`inputs/notices/`.
+
+The research question comes from the explicit two-accumulator escape in
+PR1238. That work proves the monotone frame-ancestry obstruction and checks
+the one-accumulator schedules. PR1140 gives the distinct 224-helper clean
+formation lower bound. This package does not reprove or strengthen that
+bound. PR1012 supplies the rank-mass accounting distinction.
+
+`audit_local.py` is an unchanged copy of the independent gauge44 local
+auditor retained by PR1238. Its header credits icekylinx and OpenAI GPT-6
+Astra assistance. `intervals.py` is an unchanged copy of `ceiling.py` from
+PR1240. Its header credits Douglas Colkitt and Claude (Anthropic) assistance.
+Their source commits and file hashes are in `SOURCES.json`.
+
+The whole-helper prices and root comparison come from PR1129, by Ali
+Romman with OpenAI Codex assistance. That proof credits Chafik Boukhalfa's
+PR795 prices and the PR890/PR942 owner-bound chain. The present additional
+550 units of dual demand per rewrite, the two majorization inequalities,
+and the all-mixture conclusion apply to the changed local words here.
+The sprint coordinator independently supplied and checked this dual
+calculation during the current work.
+
+PR1198 makes the arbitrary-private-centre input obligation explicit.
+PR1387 gives a separate warning that scalar invoices and owner checks alone
+can miss a changed physical operator. This package proposes no changed
+global owner and makes no operator-level claim for a new host assignment.
+
+No predecessor license, notice, or AI disclosure is replaced by this file.

research/two-accumulator-saved-arms/PROOF.md

@@ -0,0 +1,244 @@
+# Complete cost of the eight saved-arm recipes
+
+## 1. Declared method and free choices
+
+Fix the source word and the eight gate recipes in this package. A call can
+use any subset of the recipes. Different calls can use different subsets.
+There are nine calls and 896 live data families per replica. Let `T` be any
+positive integer number of replicas. Whole helpers can use any owner map
+with the retained capacity stock. Helpers cannot be split. The stock per
+replica is
+
+| Capacity | Number of bins |
+| --- | ---: |
+| 8 | 672 |
+| 16 | 448 |
+| 32 | 448 |
+| 48 | 448 |
+
+The proof below even removes owner chronology, coordinate matching, and
+per-call restrictions. Thus it gives a lower cost bound for all owners that
+satisfy those additional restrictions. The method does not add physical
+families, change the nine-stage schedule, or change the unpaid-coordinate
+and centre law. The bit supplier and the outer recipe stay fixed.
+
+The claim is an optimum for use of these eight completed recipes, including
+the zero-recipe choice. It does not optimize arbitrary rational gates,
+partitions, frame choices, or schedules. No finite synthesis search is used
+as evidence for an all-order impossibility statement.
+
+## 2. Local construction and exact finite bill
+
+The old hub helpers are 448 through 455. Each has one entrance direction
+and a rank-eight final frame, so its width is 7. In recipe `g`, helper
+`448+g` keeps one pair sum until the full packet can be formed. The recipe
+routes the old hub uses through their original source and uses the saved
+pair to complete the packet in the other accumulator. It keeps the later
+packet copy. It does not reduce the total count of 480 helpers.
+
+The complete recipe includes 19 ordered core gates with explicit frames,
+removal of two old entrance corrections, two changed cleanup operands, and
+four final full-frame corrections. The new saved-pair helper starts at
+frame zero and ends at the full rank-nine frame. It therefore has width 9.
+Its arbitrary initial value is not assumed to be zero. The four final
+corrections remove its dirt from the affected packet and later helper
+columns. The normal frame-zero compensation also uses this helper. This
+explains why retaining its former low endpoint is not a free option.
+
+The recipes have explicit pins to every replaced source gate. Their changed
+gate sites and cleanup sites are disjoint. The check replays every one of
+the 256 subsets with exact rational arithmetic. It checks the complete
+704-column forward and inverse-transpose maps, source reads, monotone
+frame paths, centre levels, helper entrances, and both low-end cones. The
+native check separately verifies the emitted all-eight word, wrappers, and
+Clifford phases. These are finite construction checks, not a formal proof
+of the full multiplication theorem.
+
+Write `H_r` for one rank-`r` child. The exact local changes are
+
+```text
+even g in {0,2,4,6}:  -2 H1 + 2 H2,
+odd  g in {1,3,5,7}:           H2.
+```
+
+Every recipe adds two local rank units and changes one width 7 to width 9.
+The baseline local profile is
+`{1:2412,2:418,3:432,4:142,5:82,8:8}`. Its rank mass is 5586. Its width
+inventory, in width order `(4,5,7,8,9)`, is `(56,32,30,122,240)`.
+
+Let `E` and `O` now count individual even and odd recipe uses over all
+`9T` calls, and put `Z=E+O`. These counts need not be uniform across calls.
+The complete residual rank mass is
+
+```text
+M = 14814 T - 2 Z.
+```
+
+The complete mass remains `73*896*T - 320*T`. This includes the eight
+rank-eight centre paths per call. The saving cannot come from a new deficit.
+
+## 3. A necessary inequality for every owner
+
+Use the signed prices from the PR1129 whole-helper proof, which credits
+PR795 and the PR890/PR942 proof chain:
+
+```text
+width price at (4,5,7,8,9): (-1,-20,-8,-2,4),
+capacity bonus at (8,16,32,48): (2,4,8,-13).
+```
+
+For residual rank `r`, let `u(r)` be the largest bonus plus price of any
+legal bin pattern with that residual. There are 1,163 legal patterns.
+Enumeration and an independent unbounded-fill recurrence give the same
+table. In particular,
+
+```text
+u(0)=0, u(1)=19, u(48)=-13.
+```
+
+The baseline total signed price is `-1084 T`. A width-7 to width-9 change
+adds 12, so the changed total is `S=-1084 T+12 Z`. If `n_r` counts residual
+bins, every whole-helper assignment satisfies
+
+```text
+sum r*n_r = 14814 T - 2 Z,
+sum u(r)*n_r >= -1084 T + 12 Z.
+```
+
+Set `v(r)=48*u(r)+13*r`. Then `v(0)=v(48)=0`, `v(1)=925`, and
+
+```text
+sum_(0<r<48) v(r)*n_r >= 140550 T + 550 Z.       (1)
+```
+
+The additional demand is `48*12-13*2=550` for each recipe use. The sign is
+positive. A model that consumes arbitrary rank-one idle mass misses this
+new packing restriction.
+
+## 4. Supporting inequality at the baseline optimum
+
+For a complex saving `b`, let
+
+```text
+f_b(r) = (r/73)^(1-b),
+c_b(r) = 48*f_b(r) - r*f_b(48),
+lambda_b = c_b(1)/925.
+```
+
+The baseline whole-helper optimum has its root in
+
+```text
+I = [0.001676905273619680861300,
+     0.001676905273619680861301].
+```
+
+The exact interval checker proves, for every `b` in `I`,
+
+```text
+lambda_b > 0,
+c_b(r) > lambda_b*v(r)
+  for each attainable 0<r<48 other than r=1.      (2)
+```
+
+At ranks 0, 1, and 48 the required non-strict inequality is exact. The
+checker encloses each exponential with rational atanh and Taylor bounds.
+It uses interval endpoints according to each coefficient's sign. There
+is no floating-point sign test. Since `r<73`, each `f_b(r)` increases with
+`b`, which justifies the endpoint choices.
+
+Use (1) and (2), and eliminate the residual mass term. They give
+
+```text
+sum f_b(r)*n_r >=
+ T*((5622/37)*f_b(1) + (11302/37)*f_b(48))
+ + Z*((22/37)*f_b(1) - (2/37)*f_b(48)).          (3)
+```
+
+For example, the coefficient of `f_b(1)` is
+`(140550*T+550*Z)/925 = (5622*T+22*Z)/37`. The coefficient of `f_b(48)`
+is the remaining mass divided by 48. This proves the claimed residual
+increment without assuming that the fractional counts can be attained.
+
+## 5. Every nonempty use has a larger complete moment
+
+Combine (3) with the exact local changes. The complete increment for one
+even recipe is
+
+```text
+Delta_even = (2/37)*(37*f_b(2)-26*f_b(1)-f_b(48)).
+```
+
+The complete increment for one odd recipe is
+
+```text
+Delta_odd = (1/37)*(22*f_b(1)+37*f_b(2)-2*f_b(48)).
+```
+
+Both are strictly positive for every `0<b<1`. Here is a proof that does
+not use numerical samples. For `s=1-b`, the function `x^s` is strictly
+concave on nonnegative real numbers. In decreasing order, the vectors
+
+```text
+(48, 1 repeated 26 times, 0 repeated 10 times)
+(2 repeated 37 times)
+```
+
+have the same length and sum. Each initial partial sum of the first vector
+is at least the corresponding sum of the second. The vectors differ.
+Strict concavity therefore gives
+`48^s+26 < 37*2^s`. This proves `Delta_even>0` after multiplication by
+the positive factor `73^(-s)`.
+
+The same argument applies to
+
+```text
+(48, 48, 0 repeated 57 times)
+(2 repeated 37 times, 1 repeated 22 times).
+```
+
+Their common sum is 96. It gives `2*48^s < 37*2^s+22`, which proves
+`Delta_odd>0`. The checker verifies every integer partial-sum inequality.
+Strict concavity supplies the theorem for the whole open interval.
+
+At the baseline optimum root `b0` in `I`, the unchanged complete moment is
+`896*T`. Every changed owner with `Z>0` has moment at least
+
+```text
+896*T + E*Delta_even + O*Delta_odd > 896*T.
+```
+
+All complete moments increase with `b`. Thus every nonempty finite mixture
+has a complex root strictly smaller than `b0`. The argument permits all
+positive replica counts and all per-call subsets. The 256 finite checks
+establish the recipe bills; they are not the reason that the number of
+replicas can be unbounded.
+
+## 6. Attainment and kappa
+
+The zero-recipe choice retains the PR1129 local word and owner inventory.
+PR1129 supplies an exact attaining whole-helper pattern table and a
+literal time-compatible T37 owner map. Its root is `b0`. This package
+rechecks the pattern counts and the root bracket. The existing native
+global and independent owner receipts remain predecessor evidence with
+explicit pins. The global owner construction is not rerun here.
+
+The retained bit endpoint is `0.001733427039589844234749`, above `b0`.
+The retained outer recipe is monotone in the complex endpoint in this
+range. Its seven updates have the form `a_next=s*(1-s+a_old)` with fixed
+strict reserves. PR1129 checks all 47 inequalities and both endpoints
+of `I` give the same outer grid value,
+
+```text
+kappa = 0.001674097969905390.
+```
+
+It follows that no member of this method family improves that value.
+The zero-recipe choice attains the family optimum under the inherited
+admission contract. A very sparse nonempty mixture can tie the same rounded
+grid value; the strict statement concerns the complex root, not every
+rounded display value. There is no claim of a new kappa.
+
+This argument uses the actual changed helper widths and all residual mass.
+It remains valid if a changed word has further owner or physical-admission
+restrictions. Those restrictions cannot lower the cost below this relaxed
+bound. It gives no obstruction for a new local bill outside these recipes.