Balanced-column carry exchanges: conditional κ = 5.1915547765237e-5

research/round6-pr71/.gitignore

@@ -0,0 +1 @@
+baseline/

research/round9-balanced-columns/README.md

@@ -0,0 +1,58 @@
+# Balanced columns with envelope ordering and carried-signal exchanges
+
+The selected conditional witness has κ = **51915547765237/10^18**
+(**5.1915547765237e-5**) and bit saving **3244890195589/62500000000000000**.
+It combines balanced coarse columns with anchored split frames, envelope
+ordering and carried-signal exchanges. Physical width is **133,585,058**,
+with auxiliary role counts **27,128 / 35,598**.
+
+Compared with PR #74 at `5830ccfca8466aff613767222558e29b57fa8225`, the
+conditional κ improves by approximately **0.163125609609%**. Compared with
+PR #76 it improves by **0.3418559067%**. These are comparisons of pinned
+conditional claims; no global optimality or unconditional theorem is claimed.
+
+[Proof and attribution](selected-both/PROOF.md) ·
+[Exact certificate](selected-both/arithmetic.json) ·
+[Source and word manifest](selected-both/MANIFEST.json) ·
+[Completed finite validation](package-validation-receipt.json) ·
+[Exact comparison](selected-both/comparison.json)
+
+Passed checks include dense scalar/data-output identities, full compiler
+input/dirty bases, independent serialized-word replay in both orientations,
+exact frame/event reconstruction, regenerated fixed-basis profiles with zero
+CRT disagreements, independent rational moments, all 47 strict assembly
+constraints and seven margins, and adjacent-grid rejection. Fresh portable
+deterministic compilation and broad repository checks remain pending.
+
+The package validation receipt independently reproduces all saved-word, profile
+and arithmetic checks against the current manifest. Its mathematical results
+match the original receipt exactly. The original validation receipt binds
+the original freeze manifest archived
+in `provenance/frozen-manifest.json`. Runtime sources, words, profiles and
+arithmetic are byte-identical to that freeze; only proof/comparison metadata
+has been updated for this publication. The current manifest records those
+two documentation changes. No CI configuration or dependencies are changed.
+
+From the repository root, restore the exact inherited source archive:
+
+```sh
+git fetch https://github.com/CrocSwap/integer-mult-bounds.git 1bef94fd40a746452548c84a4a8f8834670a3113
+mkdir -p research/round6-pr71/baseline
+git archive 1bef94fd40a746452548c84a4a8f8834670a3113 | tar -x -C research/round6-pr71/baseline
+python3 research/round9-balanced-columns/dense_audit.py
+python3 research/round9-balanced-columns/validate_selected.py --bundle research/round9-balanced-columns/selected-both --output /tmp/balanced-columns-validation.json
+```
+
+The proof gives sequential compiler regeneration commands. Use assert-enabled
+Python and C++17; `CXX` can select a compiler and SDK. All inherited all-size
+compiler, fixed-tape, analytic, routing, prime-selection, precision and recovery
+hypotheses remain conditional. Finite checks do not establish practical speedup.
+
+Credit eumemic's PR #69 balanced coarse columns; huxint's PR #77 anchored
+adapter; Thomas DiFiore's PR #74 envelope ordering; Chafik Boukhalfa's PR #71
+anchored splits and next-use scoring; Alejandro Zarzuelo Urdiales's PR #70
+exchanges; Rohan Arun's PR #65/#67 schedules, costs and arithmetic; Dominik
+Scholz's PR #68/#76 controls and composition; Avi Eisenberg's PR #62,
+eumemic's PR #57 and the complete inherited contributor chain. This composition
+was prepared by Dominik Scholz with substantial OpenAI GPT-6 Astra assistance.
+All original notices and Apache-2.0 terms remain preserved.

research/round9-balanced-columns/SOURCE.json

@@ -0,0 +1,14 @@
+{
+  "pr77_commit": "83298467291d3bd4b53f76faaef60dbf585be171",
+  "pr76_base_manifest_sha256": "52c1a59a4372376f64df937a2f19268e2ebd553574386fcdda08b01db9a5c345",
+  "base_pair_graph_sha256": "3d47e89d2649c90800a276bdd0480131def50e0bdf92c122a19494b55bf17420",
+  "base_pair_graph_matches_pr77_bytes": true,
+  "inherited_files": {
+    "inherited/SOURCE.json": "813564d76569fd54a5aa1645da15f1a33b12de8a0bcc53056e69087394b0cfcd",
+    "inherited/graph.py": "349c74a3684cc26c14f4b7001efb086825a4398461709ba13ade2cd10e336d23",
+    "inherited/NOTICE": "3bfe7a693e10fbe710e7fadedb7caeb21e272ce5899f48d043f636e2b06562b0",
+    "inherited/README.md": "e9d7ae955d27fb1832744583f1d251263e9fc499bae2d664b31f28fc83dc2592",
+    "inherited/vendor/pr69-compiler.py": "bd8169bf9f5df185a8aa4aec22234b4fd483000a1cecc78b71bf32e479af1499"
+  },
+  "scope": "Only PR69/77 balanced coarse-column graph mechanism composed with PR76 node ordering + carry exchanges; no PR77 cost-basis compiler changes."
+}

research/round9-balanced-columns/cache-stale-failure.log

@@ -0,0 +1,25 @@
+Traceback (most recent call last):
+  File "/Users/dominik/integer-mult-bounds-incremental/research/round9-balanced-columns/run.py", line 102, in <module>
+    if __name__=='__main__':main()
+                            ~~~~^^
+  File "/Users/dominik/integer-mult-bounds-incremental/research/round9-balanced-columns/run.py", line 93, in main
+    try:result,word=compiler.compile_(a.h,matching=True,reclaim=True,dirty=True)
+                    ~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/Users/dominik/integer-mult-bounds-incremental/research/round6-pr71/baseline/scripts/experiments/split_pair_engine.py", line 120, in compile_
+    t0=time.time();c,blocks,uses,value_uses,owner,signal,order,contains=build(h);v=len(c.inputs)
+                                                                        ~~~~~^^^
+  File "/Users/dominik/integer-mult-bounds-incremental/research/round6-pr71/baseline/references/frame-compiler/pr65/research/reordered-rank-pair/verify.py", line 34, in build
+    parts=list(original(h))
+               ~~~~~~~~^^^
+  File "/Users/dominik/integer-mult-bounds-incremental/research/round6-pr71/baseline/scripts/experiments/split_pair_engine.py", line 39, in build
+    c=graph(h);groups={};owner={};signal={};blocks=[]
+  File "/Users/dominik/integer-mult-bounds-incremental/research/round9-balanced-columns/run.py", line 33, in <lambda>
+    compiler.graph=lambda h: schedule_variant.reorder(coarse_graph.graph(h,coarse='columns'));compiler.build=producer.ordered_build(compiler.build,a.h)
+                             ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/Users/dominik/integer-mult-bounds-incremental/research/round9-balanced-columns/schedule_variant.py", line 34, in reorder
+    c.verify()
+    ~~~~~~~~^^
+  File "/Users/dominik/integer-mult-bounds-incremental/research/round6-pr71/baseline/references/frame-compiler/pr48/scripts/partial_swap/shared.py", line 111, in verify
+    assert not A&B
+           ^^^^^^^
+AssertionError

research/round9-balanced-columns/coarse_graph.py

@@ -0,0 +1,68 @@
+"""Controlled combinations of the PR62, PR69 and PR71 scalar graphs.
+
+PR62 graph: Avi Eisenberg with Claude assistance. PR59 split operation:
+Rohan Garg. PR69 balanced coarse columns: eumemic with Codex assistance.
+PR71 anchored split vector: Chafik Boukhalfa with Codex assistance.
+This configurable composition/search adapter: huxint with Codex assistance.
+Apache-2.0 and all inherited notices apply. No global search claim.
+"""
+import sys
+if sys.flags.optimize:
+    raise ValueError('Assertions must remain enabled')
+from hashlib import sha256
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent/'round6-pr71/baseline/references/frame-compiler/pr65'
+BASE = ROOT/'research/pair-assembly/pair_graph.py'
+BEFORE = '''            coarse = {(i, j): self.total([e(a, b) for a in groups[i] for b in groups[j]])
+                      for i, j in combinations(range(ng), 2)}'''
+AFTER_COLUMNS = '''            def coarse_sum(i, j):
+                columns = [self.total([e(a,b) for a in groups[i]]) for b in groups[j]]
+                return self.total(columns)
+            coarse = {(i,j):coarse_sum(i,j) for i,j in combinations(range(ng),2)}'''
+AFTER_ROWS = '''            def coarse_sum(i, j):
+                rows = [self.total([e(a,b) for b in groups[j]]) for a in groups[i]]
+                return self.total(rows)
+            coarse = {(i,j):coarse_sum(i,j) for i,j in combinations(range(ng),2)}'''
+
+
+def graph(h, groups=(1, 1, 2), anchor='first', coarse='none'):
+    if h not in (23, 25) or any(type(x) is not int or not 0 <= x <= 3 for x in groups):
+        raise ValueError('Unsupported finite graph configuration')
+    source = BASE.read_text()
+    if coarse != 'none':
+        assert source.count(BEFORE) == 1
+        source = source.replace(BEFORE, {'columns': AFTER_COLUMNS, 'rows': AFTER_ROWS}[coarse])
+    namespace = {'__file__': str(BASE), '__name__': 'next_use_graph_composition'}
+    exec(compile(source, str(BASE)+':next_use_composition', 'exec'), namespace)
+    original_class = namespace['circuit_class']
+
+    def circuit_class(dimension):
+        class SplitPair(original_class(dimension)):
+            def grouping(self, points):
+                partition = super().grouping(points)
+                choice = groups[self._level] if self._level < len(groups) else 0
+                if len(points) > 3 and choice:
+                    index = {1: 0, 2: (len(partition)-1)//2, 3: len(partition)-1}[choice]
+                    if len(partition[index]) == 2:
+                        partition[index:index+1] = [[x] for x in partition[index]]
+                assert all(len(g) in (1, 2) for g in partition)
+                assert len(partition) < len(points)
+                assert sorted(x for g in partition for x in g) == sorted(points)
+                return partition
+        return SplitPair
+
+    namespace['circuit_class'] = circuit_class
+    original_points = namespace['alternating_points']
+    if anchor != 'none':
+        def points(dimension, common):
+            old = original_points(dimension, common)
+            pairs = [(a, a+1) for a in range(0, dimension-1, 2) if common not in (a, a+1)]
+            chosen = {'first': pairs[0], 'second': pairs[min(1, len(pairs)-1)], 'last': pairs[-1]}[anchor]
+            result = list(chosen)+[x for x in old if x not in chosen]
+            assert sorted(result) == [x for x in range(dimension) if x != common]
+            return result
+        namespace['alternating_points'] = points
+    result = namespace['graph'](h)
+    result.verify()
+    return result

research/round9-balanced-columns/dense-audit.json

@@ -0,0 +1,28 @@
+{
+  "scope": "Finite dense scalar/data-output identity audit",
+  "axes": {
+    "23": {
+      "h": 23,
+      "inputs": 1771,
+      "additions": 67460,
+      "outputs": 5336,
+      "all_dense_additions_disjoint": true,
+      "all_dense_partial_outputs_exact": true,
+      "original_common_point_envelopes_exact": true
+    },
+    "25": {
+      "h": 25,
+      "inputs": 2300,
+      "additions": 94993,
+      "outputs": 6925,
+      "all_dense_additions_disjoint": true,
+      "all_dense_partial_outputs_exact": true,
+      "original_common_point_envelopes_exact": true
+    }
+  },
+  "sources": {
+    "dense_audit.py": "b282e743d9d8c48cbc97eb2c2597a6c52894d33ea1967dd1ff4c269b0e0a72e3",
+    "coarse_graph.py": "b5bbabb8e5bf69769af4b6cd67163954d990dc489e3c9488ed84bd09f0a767c8",
+    "schedule_variant.py": "3ce3b4c0886868e3fcd2b75c54b61180d103447cfdb9d3ece1de47dd6d46eecc"
+  }
+}

research/round9-balanced-columns/dense_audit.py

@@ -0,0 +1,53 @@
+"""Independent dense supports for both balanced-column scalar graphs.
+
+Dominik Scholz with substantial OpenAI GPT-6 Astra assistance. Apache-2.0.
+Does not use the graph's memoized/provenance-based support routine.
+"""
+from hashlib import sha256
+from pathlib import Path
+import json
+import run
+
+
+def audit(h):
+    c = run.schedule_variant.reorder(run.coarse_graph.graph(h, coarse='columns'))
+    support = [0] * len(c.args)
+    point_rows = [0] * h
+    for i, triple in enumerate(c.inputs):
+        support[i + 1] = 1 << i
+        for point in triple:
+            point_rows[point] |= 1 << i
+    additions = 0
+    for node in sorted(c.active):
+        if not c.args[node]:
+            assert node <= len(c.inputs)
+            continue
+        a, b = c.args[node]
+        assert a < node and b < node
+        assert support[a] and support[b]
+        assert not support[a] & support[b]
+        support[node] = support[a] | support[b]
+        assert c.core[node] == c.core[a] & c.core[b]
+        assert c.union[node] == c.union[a] | c.union[b]
+        additions += 1
+    for (common, target), node in c.outputs.items():
+        expected = point_rows[common]
+        for point in target:
+            if point != common:
+                expected &= ~point_rows[point]
+        assert support[node] == expected
+    return dict(h=h, inputs=len(c.inputs), additions=additions,
+                outputs=len(c.outputs), all_dense_additions_disjoint=True,
+                all_dense_partial_outputs_exact=True,
+                original_common_point_envelopes_exact=True)
+
+
+if __name__ == '__main__':
+    root = Path(__file__).resolve().parent
+    result = {'scope': 'Finite dense scalar/data-output identity audit',
+              'axes': {str(h): audit(h) for h in (23, 25)},
+              'sources': {name: sha256((root/name).read_bytes()).hexdigest()
+                          for name in ('dense_audit.py', 'coarse_graph.py',
+                                       'schedule_variant.py')}}
+    (root/'dense-audit.json').write_text(json.dumps(result, indent=2) + '\n')
+    print(json.dumps(result, indent=2))

research/round9-balanced-columns/inherited/NOTICE

@@ -0,0 +1,28 @@
+Balanced coarse sums on anchored split frames
+Prepared for huxint with substantial OpenAI Codex assistance, October 9, 2026.
+Distributed under the repository's Apache License 2.0.
+
+The selected finite network composes previously attributed constructions.
+Preserve all repository notices and these source-specific attributions:
+
+eumemic: PR57 joint reversible frame compiler and independent physical replay;
+PR69 balanced coarse column sums, with OpenAI Codex assistance.
+Avi Eisenberg / ikeboy: PR62 interval strips and core-aware pair assembly,
+with Anthropic Claude assistance.
+Rohan Garg / rohangar1: PR59 split-pair operation, with OpenAI Codex assistance.
+Rohan Arun: PR65 schedule/refined arithmetic and PR67 profile-cost compiler,
+with OpenAI Codex assistance.
+Dominik Scholz: PR63 ranked composition and PR68 compatible pending controls,
+with OpenAI GPT-6 Astra / Codex assistance.
+Chafik Boukhalfa: PR60 ranked reclamation and PR71 anchored split graph and
+next-use scoring, with OpenAI Codex assistance.
+
+The original code comments and preserved vendor snapshots retain their own
+attributions. The inherited framework also credits icekylinx, RaD / hipotures,
+James Chang, Zhihao Chen / jacklightChen, Aurel Prosz / Paureel, Swapnil Jain,
+Douglas Colkitt, OpenAI, David Harvey, Joris van der Hoeven, and other
+contributors identified in the root NOTICE and inherited source files.
+
+The new package's finite checks are conditional evidence. They are not a
+complete theorem formalization, an independent human referee report, or a
+practical multiplication benchmark.

research/round9-balanced-columns/inherited/README.md

@@ -0,0 +1,90 @@
+# Balanced coarse sums on anchored split frames
+
+The selected finite construction gives the conditional integer-multiplication
+bound
+
+\[
+T(n)=O\bigl(n(\log n)^{1-\kappa}\bigr),\qquad
+\kappa=\frac{12886963972497}{250000000000000000}
+=5.1547855889988\times10^{-5}.
+\]
+
+This is **0.2590891819% above PR71** at commit
+`1bef94fd40a746452548c84a4a8f8834670a3113`. It is a comparison of conditional
+asymptotic exponent bounds, with no global-optimality or measured-runtime claim.
+
+The construction combines eumemic's PR69 balanced coarse columns with Chafik
+Boukhalfa's PR71 anchored `[1,1,2]` split graph. It uses the inherited joint
+reversible frame compiler and compatible pending controls, and orders both
+eligible live controls and retired dependency candidates by their actual
+profile cost. The latter changes the temporary dependency basis, not just the
+choice among the first basis's dependent rows. Pending controls are priced
+against their known next use. Every selected clearing expression is emitted
+as literal XORs, and all frame moves and final cleanup remain charged.
+
+| Quantity | Pinned PR71 | This construction |
+|---|---:|---:|
+| Roles at h=23 | 27,455 | 27,338 |
+| Roles at h=25 | 36,015 | 35,939 |
+| Physical width W | 135,075,665 | 134,671,969 |
+| Complete rank mass | 77,666,660,475 | 77,434,535,275 |
+| Rank deficit | 1,846,900 | 1,846,900 |
+
+The strict bit-saving witness is `51550513208569/10^18`. The full paid child
+list of PR71 has a rigorous moment lower bound above one at this value. The
+new list has a rigorous upper bound below one. Its next `10^-18` bit grid
+point is rejected, as is the next kappa grid point in the unchanged balanced
+assembly. All 47 strict inequalities and seven margins are checked exactly.
+
+## Reproduction
+
+From the repository root, with Python 3.11+ and a C++17 compiler:
+
+```sh
+make -C research/balanced-split-reclamation verify
+make -j1 verify
+```
+
+The first command regenerates both selected words byte-for-byte, independently
+replays every input/target/dirty basis vector in both orientations, derives
+all physical transitions from literal XOR incidences, recomputes every
+fixed-basis profile with the inherited bounded-minor/CRT checks, rebuilds
+the complete global profile and exact arithmetic, and runs twelve failure-mode
+tests. A second logarithm/exponential evaluation uses a different range
+reduction and Taylor degree. This is a second arithmetic implementation,
+not independent expert review of the theorem.
+
+`selected/` contains the words, actual profiles, receipts and exact certificate.
+`SOURCE.json` freezes consumed sources and deliverables; verification never
+rewrites this manifest. `pin.py` is an explicit maintenance operation.
+`generate.py --output <directory>` produces fresh artifacts without modifying
+the selected witness. The proof is in [paper.tex](paper.tex) and [paper.pdf](paper.pdf).
+
+The selected graph uses columns rather than a three-addition coarse chain,
+split vector `[1,1,2]`, and the lowest intact pair first in each common-point
+ordering. The h23 region order is `cover-core`; h25 uses `reverse-node`.
+The oracle's integer entropy score is only a deterministic search heuristic.
+The final complete physical profile, not the score, determines acceptance.
+
+## Proof boundary and attribution
+
+The original-envelope interpretation, all-size residual/frame compiler,
+fixed finite-alphabet tape layout, semantic and analytic multiplication
+reduction, routing, prime setup and exact recovery remain inherited
+assumptions. The complex branch is unchanged. Exact finite checks do not
+constitute a complete formal proof of the multiplication theorem.
+
+This composition, cost-ordered dependency basis experiment, independent
+reproduction and package were prepared for **huxint with OpenAI Codex
+assistance**. Credit eumemic for PR57's reversible region compiler and PR69's
+coarse-column identity; Avi Eisenberg for PR62's interval/core-aware graph;
+Rohan Garg for PR59's split operation; Rohan Arun for PR65's schedules and
+PR67's cost oracle and numerical refinement; Dominik Scholz for PR63's
+composition and PR68's compatible pending controls; and Chafik Boukhalfa for
+PR60's ranked reclamation and PR71's anchored split/next-use composition.
+All prior contributors retain their original notices. See [NOTICE](NOTICE).
+
+The preserved contributor files in `vendor/` are unmodified snapshots, used
+for provenance and the complete PR71 comparison. The inherited repository
+files are retained unchanged. No endorsement or completed expert review by
+those contributors is implied.