Skip to content

Scoped proof: two coordinate swaps need six paid coordinate-CNOT calls (no new kappa) - #1414

Merged
Mister-Meeseeks merged 1 commit into
CrocSwap:mainfrom
commdata2338:coordinate-cnot-register-bound
Oct 14, 2026
Merged

Mister-Meeseeks merged 1 commit into
CrocSwap:mainfrom
commdata2338:coordinate-cnot-register-bound

Conversation

@commdata2338

Copy link
Copy Markdown
Contributor

Change and mathematical scope

Two coordinate-SWAP targets cannot share paid coordinate-CNOT work in the formal F2[GL_2(F2)] model. The exact minimum is six calls, for any finite number of restored dirty registers, even with free scalar register mixing. This settles the smallest two-dimensional gap instance of Gareth Davidson's PR #1333 restricted-alphabet question.

Status: a scoped written proof, corroborated by two independent exact implementations. It is a negative result: no saving exists in this model. No new supplier or κ is claimed.

The proof: only research/coordinate-cnot-register-bound/ is added. The proof normalizes free scalar maps by augmentation, uses the sign quotient and trace to force an even call count, and excludes every four-call label pattern with exact coefficient-rank identities. A six-call formal word attains the bound with no extra roles or omitted restoration.

Independent corroboration:

  • A formal-coefficient implementation and a faithful left-regular implementation agree on every state through radius three: 559 states for two registers and 47,203 for three. Both radius-two/radius-three target intersections are empty.
  • The replay also verifies:
    • 31 symbolic noncommuting label patterns, 36 sign products and 4,704 scalar conjugations;
    • identity and one-swap positive controls, the six-call witnesses, and 14 semantic scope and failure controls.

Remaining obligations.

  • The all-register statement is a written proof, not checked in Lean or by an independent human. The finite replay covers exactly r=2,3; the proof supplies the unrestricted-register conclusion.
  • Still open: three or more swap targets and higher-dimensional coordinate-CNOT targets.
  • Not covered: clean-only endpoints, other free operations or a different paid alphabet.
  • Not run: any physical, compiler, common-label, hosting, precision/tape, analytic-transfer or selected-supplier cold replay.
  • No selected frontier, multiplication exponent or runtime change is claimed.

Task and overlap

Validation

CPython 3.12.3, standard library only:

python3 -I -B research/coordinate-cnot-register-bound/verify.py
python3 scripts/research_package.py --package research/coordinate-cnot-register-bound --check-only
python3 scripts/research_package.py --package research/coordinate-cnot-register-bound

The registered replay and all six focused tests pass in about ten seconds. The tests include typed receipt corruption, source corruption, duplicate JSON fields and a read-only relocated optimized replay. They were run again on the final commit before submission. VALIDATION.md lists the checks and the remaining obligations separately.

PASS_COORDINATE_CNOT_REGISTER_BOUND minimum=6 dirty_registers=arbitrary census_r=2,3 symbolic_patterns=31 controls=14 no_new_kappa
PASS_REGISTERED_RESEARCH_PACKAGE research/coordinate-cnot-register-bound outcome=completed

Credit

New work is Apache-2.0; predecessor sources and notices are unchanged.

AI assistance: submitted by @commdata2338 with substantial AI assistance. OpenAI Codex (GPT-6 Astra) did the proof, both implementations, the verification and the writing; it was packaged and submitted with Claude Code. No independent human review is claimed.

Open next questions

From the package README:

  1. Three or more swaps in the same alphabet. A general direct-sum bound would say how far this obstruction scales. First step: three swaps. The sign trace permits only odd lengths, so seek a seven-call identity or a coefficient obstruction against the direct nine. Blocker: longer alternating words and arbitrary dirty-register counts need a new argument, which the present four-call proof does not supply.
  2. A three-dimensional coordinate-CNOT target with a rank/length gap. This tests the higher-dimensional branch of PR Research theorem: exact paid cost for binary affine register words #1333's question. First step: pin a target in GL_3(F2) and certify its direct coordinate-CNOT length, then test a two-role formal word below twice that length. Full formal equality and the complete paid and restoration bill are required. Blocker: the six-element group argument here does not apply to the larger address group.

Workflow feedback (optional)

  • Most useful lead: PR Research theorem: exact paid cost for binary affine register words #1333's explicit open next question. The catalogue's broad entry point had already been answered by that pending contribution, so the overlap check before starting was essential.
  • Suggestion: link a verified restricted-alphabet follow-up next to this card's broad affine-model overlap, so that later sessions pick a higher-dimensional target or the three-swap question.

In the formal F2[GL_2(F2)] register model with free scalar mixing, paid
coordinate-CNOT address calls and any finite number of restored dirty
registers, two coordinate-SWAP targets need exactly six paid calls: a
sign-trace argument forces even length, coefficient ranks exclude four
calls, and a six-call word attains the bound. Exhaustive formal censuses for
two and three registers agree. This settles the smallest two-dimensional
instance of PR CrocSwap#1333's restricted-alphabet question. No new kappa.

Adds research/coordinate-cnot-register-bound/ only.

Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex
research and implementation; packaged with Claude Code).
@Mister-Meeseeks

Copy link
Copy Markdown
Contributor

100-PR batch review at 9e1640094f649ba6db9742796825a8d6c238989b.

Merged to main, preserving the original contributor commits and package attribution.

Reviewed scope: All-register formal F2[GL2(F2)] proof that two coordinate swaps require six paid coordinate-CNOT calls: augmentation, sign trace and four-call coefficient-rank obstruction. Two finite faithful implementations corroborate it; broader paid alphabets and physical suppliers are excluded.

The pinned scoped command passed; the batch ledger contains its command, input hashes, environment and log. This incorporates the research/tooling contribution and does not change the selected κ or discharge the inherited multiplication-theorem assumptions.

Batch review, attribution and evidence. Thank you for the contribution.

Mister-Meeseeks pushed a commit that referenced this pull request Oct 14, 2026
On exactly three registers over the formal F2[GL_2(F2)] model, with free
scalar GL_3(F2) mixing and paid coordinate-CNOT calls, three coordinate-SWAP
targets need exactly nine calls: complete radius-three/four balls (47,203 and
1,094,640 states) never meet the target, sign-quotient parity excludes even
lengths, and a nine-call formal word attains the bound. Two implementations
agree. Answers the smallest-register case of PR #1414's three-swap question.
No new kappa.

Adds research/three-swap-cnot-census/ only.

Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex
research and implementation; packaged with Claude Code).
Mister-Meeseeks pushed a commit that referenced this pull request Oct 14, 2026
Two coordinate-SWAP targets still need six paid calls when the alphabet grows
from the two GL_2(F2) coordinate CNOTs to all six GL_3(F2) coordinate CNOTs,
on exactly two or three scalar registers with free scalar mixing and the
extra register restored. Two code-disjoint traversals exhaust every word of
at most five calls (zero target hits); a six-call identity attains the bound
in the full formal group algebra. Extends the alphabet of PR #1414. No new
kappa.

Adds research/coordinate-cnot-address-spectator/ only.

Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex
research and implementation; packaged with Claude Code).
Mister-Meeseeks pushed a commit that referenced this pull request Oct 14, 2026
Two copies of the order-four matrix h = [[0,1,0],[0,0,1],[1,1,1]] in
GL_3(F2) (direct coordinate-CNOT length four, rank(h - I) = 2) need exactly
eight paid coordinate-CNOT calls on exactly two arbitrary-input registers
with free scalar GL_2(F2) mixing: two implementations agree on all 241,075
natural states through radius four and exclude every word through seven
calls, and an eight-call word passes full formal equality. Follows the
higher-dimensional question of PR #1414. No new kappa.

Adds research/gl3-order4-register-census/ only.

Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex
research and implementation; packaged with Claude Code).
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants