Conditional κ = 6.92144604250060e-4: served diagonal operations on PR200's bit word (+1.09% over #217)

.github/workflows/served-diagonal-bit.yml

@@ -0,0 +1,38 @@
+name: Verify served diagonal bit supplier
+on:
+  pull_request:
+    paths:
+      - 'research/served-diagonal-bit/**'
+      - 'research/source-assisted-v4/**'
+      - 'research/source-assisted/**'
+      - 'scripts/paired_cube_assembly.py'
+      - '.github/workflows/served-diagonal-bit.yml'
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  full:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          persist-credentials: false
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          repository: CrocSwap/integer-mult-bounds
+          ref: a1175449f34d39ff933d9d8ab23ced1f32b290ec
+          path: .dependencies/pr200
+          persist-credentials: false
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          repository: CrocSwap/integer-mult-bounds
+          ref: 187e1010ac8b259af8e9b5166f68b64bc27b4b47
+          path: .dependencies/pr193
+          persist-credentials: false
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97
+        with:
+          python-version: '3.13'
+      - run: python -m pip install -r .dependencies/pr193/research/source-assisted/requirements-round13.txt
+      - run: python -B research/served-diagonal-bit/verify.py --complex-root .dependencies/pr193 --bit-root .dependencies/pr200 --full
+      - run: git diff --exit-code

research/served-diagonal-bit/NOTICE

@@ -0,0 +1,28 @@
+Served diagonal bit supplier. Apache-2.0.
+Prepared by Avi Eisenberg (ikeboy) with Anthropic Claude assistance.
+
+New here: the served diagonal operation (patch.py), its forked word and terminal
+checks (bit/served_word.py, bit/served_terminal.py, bit/served_prove.py) and the
+argument in PROOF.md.
+
+Reused, with credit:
+- Chafik Boukhalfa, PR200 at a1175449f34d39ff933d9d8ab23ced1f32b290ec: the
+  fixed-coordinate/face-diagonal bit word that patch.py starts from, its frames,
+  partner mixes, 34 terminal sinks, prime witnesses, paid-moment certification
+  and package verifier. bit/served_word.py forks PR200's bit/word.py and
+  bit/base_word.py; bit/served_terminal.py forks PR200's bit/terminal.py;
+  bit/served_prove.py follows PR200's bit/prove.py and imports its certify().
+- Rohan Arun, PR205: the completed-bank packing on PR200's word. packing.py,
+  arithmetic.py, audit.py and verify.py adapt PR205's files to the served word.
+- Evan McKinney, PR197: completed-bank packing, exact gauge charts, nine-colour
+  bank incidence, routing bound, arithmetic, audit and endpoint controls.
+  banks.py and controls.py are byte-identical to PR205's copies of PR197's code.
+- Avi Eisenberg, PR193 at 187e1010ac8b259af8e9b5166f68b64bc27b4b47: the v4
+  source-assisted complex supplier and balanced assembly bridge; icekylinx for
+  the source-assisted method (PR184) and the paired-cube framework (PR144).
+- eumemic, PR168: the v4 exact integer backend that the forked checks load from
+  PR200's pinned references.
+- jamesyc, PR166: the terminal lemma behind the sinks.
+- PR185/187: the finite ordinary-leaf composition.
+- hcg890, PR217: the previous best completed claim, used as the comparison.
+Original notices remain in the pinned checkouts.

research/served-diagonal-bit/PROOF.md

@@ -0,0 +1,99 @@
+# Served diagonal operations on the PR200 bit word
+
+This package changes one thing in PR200's bit word. Then it applies PR205's completed banks (PR197's construction) and PR193's balanced assembly without change. This file states the change and why the word stays correct. Every argument not restated here is PR200's, PR205's or PR197's, with the same inherited interfaces.
+
+## 1. The partner mixes in PR200
+
+PR200's word has `v = 1760` source lines, `h = 24` and `m = 72`. Each source `s` has a data register. The register holds `x_s` after the injection. The 1,760 sources form 880 partner pairs. Each pair has a carrier `c` and a passive `d`, with orthogonal labels. For each pair the word:
+
+- adds `x_d` into the carrier data register at the 2-dim mix frame, so it holds `x_c + x_d`;
+- delivers `x_c + x_d` to the pair's receivers at the cap frame;
+- subtracts `x_d` again at the end.
+
+So the passive data register always holds `x_d`. Only carrier registers change. The carrier chain is `line → mix → cap → full`. The passive chain is `line → mix → full`, with children `[1, 22]`.
+
+## 2. The served operation
+
+PR200 also forms the same sum `x_c + x_d` in auxiliary registers. Operation `i = (a, b, n)` adds register `b` into register `a`, and node `n` is the partner diagonal with `args[n] = {c, d}`. `patch.py` finds the operations where all of these hold:
+
+1. before `i`, register `a` holds exactly `x_c`, and register `b` holds exactly `x_d`;
+2. `b` is not a root, gauge, source or alias register;
+3. `b` has exactly two operations: one copy operation `j` that writes the source node `d` into it, and then `i`;
+4. the mix frame of the pair is inside the frame `F_i` of operation `i` (exact containment in PR200's own frame algebra).
+
+There are 373 such operations. All of them are in phase one, and every `F_i` has dimension 3. For each one, `patch.py`:
+
+- deletes register `b` and its copy operation `j`;
+- makes operation `i` read `x_d` from the passive data register: `ops[i] = [a, -1-d, n]`, with `served = [i, d, F_i]`;
+- moves the partner mix of that pair to the start of the word, right after the injections (`early = true` in the schedule);
+- extends the passive chain to `line → mix → F_i → full`, with children `[1, 1, 21]`.
+
+Nothing else changes. Operations, roles and read positions are renumbered compactly. `verify.py --full` runs `patch.py` again on PR200's frozen word and compares its output with the frozen files.
+
+## 3. Why the word is still correct
+
+**Values.** Before operation `i`, register `a` holds `x_c`. The passive data register holds `x_d` at all times. So `a` receives `x_c + x_d`, the same value as before. The checker simulates every register content and checks the operands of every served operation against the node's arguments.
+
+**Early mix.** After the injections, the word reads a carrier data register only at the deliveries and at the final subtraction. Both come after the mix in both schedules. Thus the early mix changes no value that the word reads.
+
+**Dirty registers.** The deleted register `b` takes its adjoint response with it. A served operation reads a data register, not a dirty auxiliary register, so it adds no dirty response.
+
+**Formal check.** `bit/served_prove.py` runs all `2v + 16,775 = 20,295` formal columns in F2 and over the integers. All target columns equal the defining decoder. All source and dirty columns return to their start values. No column is sampled.
+
+**Frames.** Each `F_i` is nondegenerate and contains the passive line. The passive chain `line ⊂ mix ⊂ F_i ⊂ full` is nested, and every other chain keeps PR200's check. The exact integer backend is eumemic's PR168 v4 backend, loaded from PR200's pinned references. The served word uses 24,401 frames. Each one is a PR200 frame with its PR200 prime witness, so every Gram inverse and projector stays valid at every prime `q > 2^80`, as in PR200. No new frame comes in.
+
+**Controls.** The checker rejects each of these changes:
+
+- PR200's three word controls (omitted compensation, missing partner, stale read);
+- a served operation that reads the carrier instead of the passive register;
+- a zero operation frame;
+- a served passive chain without its served stop;
+- a served pair whose mix is not early.
+
+## 4. Terminal sinks
+
+PR200's 34 PR166 terminal sinks apply unchanged. `bit/served_terminal.py` is PR200's `bit/terminal.py` with three edits:
+
+- a served operation is not a register-to-register gate, so it has no control use;
+- the gate replay adds the passive data register for a served operation;
+- the replay applies early mixes after the injections and late mixes at delivery.
+
+The retained scalar bill does not grow (delta −158). The three terminal controls are rejected.
+
+## 5. Ledger
+
+| Per copy | PR200 | Served |
+|---|---:|---:|
+| Logical auxiliary roles | 18,908 | 18,535 |
+| Physical chains (after 1,760 aliases and 34 sinks) | 17,114 | 16,741 |
+| Stock `W` | 20,634 | 20,261 |
+| Deficit `72W − mass` | 1,936 | 1,936 |
+| Coarse bit saving | 6.77774e-4 | 6.86716e-4 |
+
+The deficit stays at 1,936, so the telescoping identity holds with the same loss.
+
+## 6. Banks
+
+PR205's packing applies with new counts. There are three copies, 2,200 rank-20 gauges (220 distinct frames, the same charts as PR205) and 14,541 other physical chains:
+
+```
+6·3300 = 9·2200,      2·3300 + 3·41423 = 9·(16741 − 2200).
+```
+
+Thus `W = 3·2·1760 + 44,723 = 55,283` and the deficit is `5,808 = 3·1,936`. The largest child is 22. The chain/bank multigraph gets a proper 9-edge-colouring, and an independent check rejects a duplicated colour.
+
+## 7. Arithmetic
+
+`arithmetic.py` and `audit.py` are PR205's, with the served word's numbers. The paid moment includes the 10^-16 rare-class fallback. Two independent moment engines exclude the next 10^-18 grid point. Three finite ordinary-leaf levels start from the served word's completed ordinary supplier. PR193's complex supplier does not bind. The unchanged 47-constraint balanced assembly certifies κ, and the next 10^-18 κ point is rejected. `certificate.json` holds every value.
+
+## 8. Limits
+
+The finite checks establish the served word, the sinks, the charts, the banks, the moments, the leaf recurrence and the assembly arithmetic. These remain inherited assumptions, as in PR200, PR205 and PR197:
+
+- the completed-core contract;
+- the general Clifford interface;
+- uniform weighted compilation;
+- restored rows;
+- fixed-tape transfer.
+
+PR193's disclosed limits on the complex side also remain.

research/served-diagonal-bit/README.md

@@ -0,0 +1,80 @@
+# Served diagonal operations on PR200's bit word
+
+Under the retained multiplication interfaces, this finite witness certifies
+
+$$
+T(n)=O\left(n(\log n)^{1-\kappa}\right),\qquad
+\kappa=\frac{692144604250060}{10^{18}}=0.000692144604250060 .
+$$
+
+That is **+1.088%** over PR217 (`684696826673891/10^18`, the best completed claim) and **+1.330%** over PR205 (`683061299399923/10^18`).
+
+| Construction | Bit coarse saving | Conditional kappa |
+|---|---:|---:|
+| PR205: PR200 word, packed | 6.83528e-4 | 0.000683061299399923 |
+| PR217: butterflies and optimized frames, packed | 6.85166e-4 | 0.000684696826673891 |
+| Served word, unpacked | 6.86716e-4 | 0.000685800818606951 |
+| **Served word, packed** | **6.92624e-4** | **0.000692144604250060** |
+
+## What is new
+
+PR200's bit word mixes each partner pair on its data registers: the carrier register gets `x_c + x_d`, and the passive register keeps `x_d`. The same word also builds `x_c + x_d` again in auxiliary registers. At 373 of these operations, the control register is a pure copy of `x_d`, made by one copy operation and used once.
+
+This package reads `x_d` straight from the passive data register at those 373 operations. It then deletes the 373 copies and their copy operations. To keep the passive register's frame chain nested, the pair's partner mix moves to right after the injections. The passive chain gets one extra 3-dim stop: `line → mix → F_i → full`.
+
+| Per copy | PR200 | Served |
+|---|---:|---:|
+| Logical auxiliary roles | 18,908 | 18,535 |
+| Physical chains | 17,114 | 16,741 |
+| Stock `W` | 20,634 | 20,261 |
+| Deficit | 1,936 | 1,936 |
+| Coarse bit saving | 6.77774e-4 | 6.86716e-4 (+1.32%) |
+
+Every frame stays one of PR200's witnessed frames. The 34 terminal sinks, the 1,760 aliases, the gauges and every other operation are PR200's.
+
+**Checks.** `bit/served_prove.py` checks the served word completely, in the same way as PR200's `bit/prove.py`:
+
+- all 20,295 formal columns in F2 (identity) and over the integers (defining decoder), with no sampling;
+- exact frame geometry with PR200's PR168 v4 integer backend, including each served frame and the new passive chains;
+- PR200's 34 terminal sinks through a forked terminal compiler, with the scalar bill retained;
+- PR200's paid-moment certification, imported unchanged;
+- seven adverse word controls and three terminal controls, all rejected.
+
+**Banks and arithmetic.** PR205's completed banks (PR197's construction) then apply with new counts: 3,300 small banks and 41,423 large banks over three copies, so `W = 55,283` and the deficit is `5,808`. Three finite ordinary-leaf levels and PR193's unchanged 47-constraint assembly give κ. The bit branch binds; the complex supplier (`700918443859411/10^18`) has slack.
+
+`PROOF.md` gives the argument.
+
+## Verify
+
+```sh
+git fetch https://github.com/CrocSwap/integer-mult-bounds a1175449f34d39ff933d9d8ab23ced1f32b290ec
+git worktree add --detach ../served-bit-pr200 a1175449f34d39ff933d9d8ab23ced1f32b290ec
+git fetch https://github.com/CrocSwap/integer-mult-bounds 187e1010ac8b259af8e9b5166f68b64bc27b4b47
+git worktree add --detach ../served-complex-pr193 187e1010ac8b259af8e9b5166f68b64bc27b4b47
+python3 -m pip install -r ../served-complex-pr193/research/source-assisted/requirements-round13.txt
+python3 -B research/served-diagonal-bit/verify.py --complex-root ../served-complex-pr193 --bit-root ../served-bit-pr200 --full
+```
+
+`--full` takes about five minutes on Linux. It runs:
+
+1. PR193's and PR200's unchanged package verifiers;
+2. `patch.py`, which derives the served word again from PR200's frozen word and must match the frozen files;
+3. `bit/served_prove.py`, the complete check of the served word and its sinks;
+4. PR205's charts, banks and colouring on the served word;
+5. the arithmetic, the independent audit and the bank endpoint controls.
+
+Without `--full`, the saved receipts are used, and only the pins and the arithmetic run. The terminal compiler needs Linux (`resource`).
+
+## Scope and credit
+
+This is a conditional finite construction and composition. It is not an unconditional multiplication theorem or a speedup claim. The all-size compiler, analytic, precision, restored-row and fixed-tape hypotheses are inherited exactly as in PR200, PR205 and PR197.
+
+The served operation is new. Credit for everything it builds on goes to:
+
+- Chafik Boukhalfa (PR200) for the bit word, its sinks, witnesses and verifier, which the served checks fork;
+- Rohan Arun (PR205) and Evan McKinney (PR197) for the completed banks and their code;
+- PR193 for the complex supplier, and icekylinx for the source-assisted method and the paired-cube framework;
+- eumemic (PR168), jamesyc (PR166) and PR185/187 for the backend, the terminal lemma and the leaf composition;
+- hcg890 (PR217) for the previous best claim.
+
+Prepared by Avi Eisenberg with Anthropic Claude assistance. Apache-2.0.

research/served-diagonal-bit/SOURCE.json

@@ -0,0 +1,35 @@
+{
+  "bit_commit": "a1175449f34d39ff933d9d8ab23ced1f32b290ec",
+  "bit_files": {
+    "research/paired-cube-diagonal-bit-168/arithmetic/interval_moment.py": "9d3d1d28bfb3375958995205179b171fb65c70a3792cf9f7a21ef5ee54f5460b",
+    "research/paired-cube-diagonal-bit-168/bit/base_word.py": "9fe3a81b7561d2b09c086f63fac4626e88a32369ef8bc5579c94878de1218a89",
+    "research/paired-cube-diagonal-bit-168/bit/prime-witnesses.json.gz": "612f0b91c7689b0cebcacb28278579aa2c88801df640798d7a119f11eca836c3",
+    "research/paired-cube-diagonal-bit-168/bit/prove.py": "c4a7f6ea79d2b9bbdace7c1e99bd4c068967d90fcab5bddc4ce37b5055cbf0cc",
+    "research/paired-cube-diagonal-bit-168/bit/word.py": "85822e9cca5b1b2335c3704a3df2f3c6ef01e42d8328daacb33701d30cee80ab",
+    "research/paired-cube-diagonal-bit-168/references/pr168-v4/research/paired-cube-bit/check_paired_cube_bit.py": "4d7c86cd999a1519e0dfb6dcf33a8f26e442a353c3665a0f06881216a260fbf3",
+    "research/paired-cube-diagonal-bit-168/selected/bit/frames_p12.json": "aec2f09df5b42165a353a9233d9c8549bf091167915f6b044689c4bfb189d406",
+    "research/paired-cube-diagonal-bit-168/selected/bit/frames_p12.json.gz": "ad8e2705652b68476713d7647a8592505e222f2b3ccd1728dedce153aac6d462",
+    "research/paired-cube-diagonal-bit-168/selected/bit/graph_p12.json": "31a09a55920e64c8bfbac8b845dc01754c112aa6e207812e2fd1f4939d8f64cb",
+    "research/paired-cube-diagonal-bit-168/selected/bit/kchron_p12.json": "0fab548e84cf5ca7c04e8bd19b5810850463f36e0f92180efe73aeff17105e39",
+    "research/paired-cube-diagonal-bit-168/selected/bit/profile_p12.json": "c44ef8640cbcbcc9bac3a30e13373bd79efddde55d7cea514354ca2cdb60d66d",
+    "research/paired-cube-diagonal-bit-168/selected/bit/sinks.json": "c00ff70c564829d4b97740f92796fc6ce14fbcd5ca519663828650552b80249d",
+    "research/paired-cube-diagonal-bit-168/selected/bit/word_p12.json": "0728ed1c7320430a87709b1034485cbabefec85d532b48897f74136cf3954218"
+  },
+  "bit_manifest_sha256": "015abe3342d08d08a9c4a764f103cafc1be1fe7f23d7a72471bd87412c57c2df",
+  "comparison": {
+    "pr205": "Rohan Arun, PR200 word with PR197 banks, kappa = 683061299399923/10^18",
+    "pr217": "paid XOR butterflies with cascade-optimized frames, kappa = 684696826673891/10^18"
+  },
+  "complex_commit": "187e1010ac8b259af8e9b5166f68b64bc27b4b47",
+  "complex_files": {
+    "research/source-assisted-v4/SOURCE.json": "99024e5c8296ad03b6e499c3c4e1e9e879bf6a5954d8558cc39abd557edf79d6",
+    "research/source-assisted-v4/certificate.json": "d84406d2fcc6990deba2b135509e6d86600e57123d88f9b21f7b7240e1aeb513",
+    "research/source-assisted/global/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46",
+    "scripts/paired_cube_assembly.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c"
+  },
+  "served_files": {
+    "selected/served/kchron_p12.json": "8542463c58b25c97e10a7e80c5504e4517cc6acf439ce8c549741b8456f0ad76",
+    "selected/served/profile_p12.json": "428ab934b5f71093eba46b9fc341c5edda6354bdb48144e8496804587e8e5b3e",
+    "selected/served/word_p12.json.gz": "8d21c91a96d72cbe12b94e18ffc2d7c88c5958aee2199c94631723b420051b5d"
+  }
+}