Scoped negative result: certify 33 fixed Clifford register words (no kappa claim)

research/clifford-relation-obstructions/.gitattributes

@@ -0,0 +1,2 @@
+* text eol=lf
+*.gz binary

research/clifford-relation-obstructions/MANIFEST.json

@@ -0,0 +1,18 @@
+{
+  "files_sha256": {
+    ".gitattributes": "abeba78466be388a1c5f3cb4ad595b915a0aa9402d1d87e37dfe42762e5b91c5",
+    "dense.py": "760df8621caaa81ab841df39667f910b45b40d9167c02747db346e80649632af",
+    "independent.py": "6440b846d1dafd540f8d5192602a7e38abf8db5963848306838b8686dd70a954",
+    "model.py": "5d8c14e1aa62185fcb75725f0c337f00423642cebf121545d38a024567fc6dbf",
+    "NOTICE.md": "51a6115711b865339854be0d074821a4d360ddc0392c6617e52c118beb64e1b2",
+    "ORIGINS.json": "afa172d5f1fc8083f8595b7d43c023b834b76e0689a6fe9d66c225c6e92f845a",
+    "PROOF.md": "62f1f0adaead9ba8beb80118015d6feb81fc120e54a7cc0a0577587f8d5c8eeb",
+    "rank_support.py": "8999d8cc1a630db23578779cd9b30d15c426917037fbbaaca18b2d390da8bcfb",
+    "README.md": "9a2f98e47fdab88147630be1c13d108313ec7520612b60c81e60ef587577dc45",
+    "support.py": "c2dc7ccf0c0e4c7a0513a897ccadda6ffa745d6a0de1addda8b51e9ff956e25d",
+    "torus.py": "000db69c7d6dc3844655a39fea020cad4354d86793117ccc9ecc3f2863c06ab2",
+    "VALIDATION.json": "6c235f3c9f055ea87a0a31a6f262711f9f3b93c8c37160c243e6f865a205cd27",
+    "verify.py": "922c0b18c51155628cf32762479fb3d45721f9a317c93f6288a18e65d80d67d2"
+  },
+  "certificate_payload_sha256": "dafd07d683df169f3c1613bc9ecbab054ce66581d93e7ef0c649286ec2eddc6c"
+}

research/clifford-relation-obstructions/NOTICE.md

@@ -0,0 +1,34 @@
+# Attribution and source scope
+
+Prepared by [littleBro](https://github.com/littleBro) with substantial OpenAI
+Codex assistance in the research, implementation, proof exposition, packaging
+and validation. New contribution under the repository's Apache-2.0 license.
+No independent human review or contributor endorsement is represented as
+completed.
+
+The open complex m=3, W=3, s=8 register problem and prior exclusions are
+credited to eumemic's [PR #288](https://github.com/CrocSwap/integer-mult-bounds/pull/288),
+pinned at `475a088b5862f75f0b10596cfd6842d19531a5ec`, and the predecessors it
+credits, including Swapnil Jain's closed-ideas list and P1/P2 and the upstream
+Clifford-frame framework. This package does not claim to originate that problem
+or the general algebraic methods.
+
+The implementation is a focused extraction and adaptation of same-author
+local exploratory packages. `ORIGINS.json` records hashes of those source
+snapshots and of the earlier proof payload. Those provenance hashes are not
+external dependencies or a claim that the snapshots were publicly reviewed.
+All code and exact witnesses required here are supplied in this directory.
+
+The source target is CrocSwap/integer-mult-bounds main at
+`66849e1475c930fd7732b1a0067ffee7e1e95f60`. Its selected construction was not
+changed or replayed as part of this standalone contribution. At that base,
+the selected kappa was 0.001635527380375392, conditional as stated in the
+selected record and maintainer review.
+
+Overlap review read the earlier open-PR metadata through #661 and refreshed
+recent metadata through #666. PR #620 concerns E8/decoder research; #634
+concerns coding-gap and minrank questions; #651 concerns fixed K-triangle
+delivery; #661 concerns fixed-order R420 frame optimality; #662 accelerates
+existing helper checks. None of those descriptions supplies these 33 fixed
+register-word certificates. This comparison is not an audit of every PR diff
+or a proof of literature novelty. The scoped result remains open to review.

research/clifford-relation-obstructions/ORIGINS.json

@@ -0,0 +1,15 @@
+{
+  "note": "Same-author unpublished research snapshots. These hashes record extraction provenance only; all runtime source and evidence needed for this contribution are included here.",
+  "local_snapshot_source_sha256": {
+    "small-register-search/search.py": "4937080f884c6074533e78f296294dbde29c30c93d53b9bc876ff2df15d82811",
+    "full-block-evolution/verify_blocks.py": "555c83180a34f796b30a97fee66a38b4fcefba3d297d012ea8ba1c73ecede4ef",
+    "symbolic-generator-evolution/symbolic.py": "953c97bb2eda709ee11e5d4079310f3dd3a196cbba30e52f9fad51d3faea2fcc",
+    "relation-evolution/support.py": "959f9b730d8c85b1c23efdc9ebfa80e206b01220a4ab77a3d855e6d824ca209b",
+    "relation-evolution/rank_support.py": "78ced44eb2c5d041955d7816ab5a24d939794971f6e06f9702e3fcdd1ab3b99a",
+    "relation-evolution/binomial.py": "78ac7052807f65e0c0210ea6769cc1e0db309e78aec3ae18335316758fd6bec8",
+    "relation-evolution/independent.py": "fe303facfcb59bab2c5738be8fae0f7a99a9719f702fb3aa5300b3f24c1781a0",
+    "small-register-search/audit.py": "ed8bf19248108f05a940907b1d0dffe471b9277b5ab517bf0e3661863ed774af"
+  },
+  "original_solutions_payload_sha256": "67c74c0c03942f9d6936f9cf8f09e2961750f7d8174ed8097e46493f408df3d2",
+  "certificate_payload_sha256": "dafd07d683df169f3c1613bc9ecbab054ce66581d93e7ef0c649286ec2eddc6c"
+}

research/clifford-relation-obstructions/PROOF.md

@@ -0,0 +1,132 @@
+# Model and certificate argument
+
+This written argument concerns the 33 supplied formal words, with arbitrary
+complex scalar coefficients. The executable certificate is not a Lean proof.
+
+## Operators and endpoint
+
+Use basis vectors |x> indexed by x in F2^3. Let X_v translate x by v, and
+Z_v multiply |x> by (-1)^(v dot x). The paid gate, for nonzero v, is
+
+    C_v = ((1+i)/2) I + ((1-i)/2) X_v.
+
+In particular C_v^2 = X_v. Each occurrence is charged one paid call. The free
+unaries are S_j|x> = i^(x_j)|x>, X_j, Z_j, directed CNOT gates
+x -> x + x_a e_b, and CZ gates (-1)^(x_a x_b). The 18 free gate indices are
+listed explicitly in `model.py`. Their words are fixed inputs, not additional
+optimization variables in the exclusion.
+
+Let G be their projective Clifford group, represented by conjugation on the
+six Pauli generators. A Pauli is encoded as i^p X^x Z^z. Scalars that give the
+same conjugation action are identified. Let D be the diagonal Pauli subspace
+and H its monomial stabilizer. The frame key of g records g^-1(D); equal frame
+keys specify the same left coset H g. The Fourier rank rho(g) is the binary
+rank of the X parts of the images of the three Z generators. It is constant
+on each left H coset.
+
+A word is a 3-by-3 matrix over C[G], built from fixed unary diagonal matrices
+and three arbitrary scalar matrices in GL(3,C). Its required endpoint is:
+for each input column s, all nonzero group coefficients across the output
+rows lie in one coset H g_s with rho(g_s)=3. This is the precise condition
+being excluded. No finite 8-by-8 matrix representation is assumed linearly
+independent. The negative conclusion is in the formal group algebra.
+
+For an intended tensor realization the inherited phase-quotient convention
+requires multiplicity divisible by four. The finite dense controls verify
+projective operators, not all tensor sizes, compilation or paid bit costs.
+
+## Necessary Boolean conditions
+
+Expand the word by paths. A path chooses one scalar entry per block and
+contributes their product to one output/input/group coefficient. Equal group
+labels are collected before endpoint constraints. The saved words have
+coefficient one on each resulting path monomial; the arithmetic checker
+explicitly checks this condition when reducing to binomial equations.
+
+Each scalar entry has a Boolean variable meaning nonzero. Invertibility
+requires a nonzero determinant permutation term, although such a term alone
+does not imply invertibility. Choose exactly one admissible full-rank frame
+per input column. Every coefficient outside that frame must vanish. Exactly
+one active monomial in such a coefficient is impossible, so the formula
+forbids it. Allowing two or more active terms is only a relaxation.
+
+There is also a necessary whole-matrix matching test. Augmentation g -> 1
+maps the invertible word to the product of its scalar blocks. If positions
+with any full-rank term admit no perfect matching, its augmented endpoint
+would be singular. The formula then includes an empty clause.
+
+Boolean UNSAT is checked by a tree of binary splits, unit reasons and conflict
+clauses. The replay uses literal lists, separately from the solver's bitset
+propagation. A surviving Boolean model is not an arithmetic solution.
+
+## Invertibility constraints
+
+Write a three-block word, in matrix-composition order, as
+
+    diag(w) C diag(v) B diag(u) A diag(t).
+
+For each middle product g = v_i u_j, let M_g retain the entries B_ij with
+that product. Before the outside unaries its coefficient matrix is
+
+    R_g = C M_g A.
+
+At position (r,s) the outside operations relabel g as w_r g t_s, a bijection
+on labels. The chosen endpoint frames thus determine allowed positions of R_g.
+
+Only classes occupying distinct rows and distinct columns of B receive the
+following strengthening. Such an M_g is a partial permutation with scalars.
+
+1. A required zero column of R_g implies M_g A(:,s)=0 since C is invertible.
+   Distinct occupied rows imply B_ij A_js=0 at every occupied position.
+2. A required zero row implies C(r,:) M_g=0 since A is invertible.
+   Distinct occupied columns imply C_ri B_ij=0.
+3. rank(R_g)=rank(M_g) equals the number of nonzero retained B entries.
+   A matrix supported on a graph has rank no larger than that graph's maximum
+   matching. The allowed positions of R_g must admit a matching at least as
+   large as every active subset of retained B entries.
+
+These implications yield necessary clauses. Nonpartial classes are left to
+the weaker filter. Omitting these constraints cannot create a false exclusion.
+The independent encoding builds middle classes from unary group products;
+the producer's encoding builds them from path monomials. Their full formulas
+are compared for every supplied word.
+
+## Torus refutations and learned clauses
+
+Fix one exact entry support and three selected frames. Every retained entry
+is in C*. When every unwanted coefficient has at most two active monomials,
+its nontrivial equation is x^a+x^b=0, equivalently x^(a-b)=-1.
+
+The certificate performs unimodular integer row and column operations on the
+exponent matrix. Row operations preserve the torus equations; columns give
+an invertible monomial substitution x_j=product(z_i^V_ji). A positive diagonal
+and zero rows suffice; Smith divisibility is not needed. An odd right-hand
+parity on a zero row is inconsistent.
+
+Otherwise a diagonal entry 1 fixes a sign. An entry 2 with even parity has
+both signs as components. Other torsion or excessive component counts are
+left unresolved by the arithmetic producer; the negative checker accepts no
+certificate that silently omits them. All 78 saved negative certificates have
+diagonal entries 1.
+
+On every component, substitute into det(A) det(B) det(C). If this Laurent
+polynomial is identically zero, no point on the component makes all blocks
+invertible. The checker directly expands the product using Leibniz's formula,
+rather than the producer's successive polynomial products. It checks every
+integer operation, the substitution and complete component coverage.
+
+Such a refutation permits a clause blocking exactly this entry support and
+these frame choices. It does not permit blocking neighboring supports or
+unspecified frames. The checker verifies the literal learned clause and then
+replays the next support proof. A final Boolean contradiction covers all
+remaining assignments; the removed ones already have exact refutations.
+Therefore the entire fixed word is excluded over C, including scalar blocks
+with zero entries. No arithmetic search timeout is used as evidence.
+
+## Boundaries
+
+This proves no impossibility for arbitrary three-block words, arbitrary
+Clifford circuits, different frame groups or a finite representation that
+admits additional linear cancellations. It does not decide the full register
+problem in PR #288 or bound integer multiplication. The inputs are 33 explicit
+skeletons, not representatives of all possibilities.

research/clifford-relation-obstructions/README.md

@@ -0,0 +1,105 @@
+# Exact exclusions for 33 fixed Clifford register words
+
+**Scoped negative result; no new primitive or kappa claim.** For each of the
+33 words in `certificates.json.gz`, no choice of three invertible complex
+3-by-3 scalar mixing blocks achieves the specified full-rank coset endpoint
+with eight paid calls. This is a statement in a formal projective Clifford
+group algebra. It does not exclude arbitrary three-block words or solve the
+general m=3, W=3, s=8 register problem left open in [PR #288](https://github.com/CrocSwap/integer-mult-bounds/pull/288).
+
+The contribution is a self-contained support/rank/torus checker, explicit
+fixed-word inputs, exact refutation traces and a written explanation of the
+necessary conditions. Every runtime dependency is in this directory or the
+Python standard library. No author-local directory, solver installation,
+network access or historical research checkout is needed.
+
+## Reproduce
+
+From the repository root, with Python 3.10 or later:
+
+```sh
+python -B -S research/clifford-relation-obstructions/verify.py
+```
+
+Expected final JSON contains:
+
+```json
+{
+  "status": "PASS_FIXED_CLIFFORD_WORD_EXCLUSIONS",
+  "counts": {
+    "excluded_templates": 33,
+    "exact_torus_refutations": 78,
+    "noncommuting_relations": 32
+  }
+}
+```
+
+The actual output has additional control counts. The command replays saved
+witnesses; it does not rerun the bounded discovery search. It writes no files.
+`-O` and `-OO` are explicitly rejected because the checker uses assertions.
+`MANIFEST.json` pins source bytes and the decompressed certificate payload;
+gzip container bytes are not used to decide mathematical equality.
+
+## Domain and method
+
+There are three streams of formal group-algebra elements, and each target
+column must be supported in one left monomial coset of Fourier rank three.
+Every unary operation and scalar-block location is fixed by the input word.
+Each scalar block ranges over all GL(3,C), including matrices with zero
+entries. [PROOF.md](PROOF.md) defines the operators, endpoint and model limits.
+
+For 32 words, the generator prescribed
+
+    U = (I,Q,T), V = (I,P,Q), T = Q^-1 P Q,
+
+so that PQ = QT and Q is also repeated. P and Q do not commute. P and T each
+have one paid gate; Q has one or two, with 16 words of each kind. Free
+monomial decorations and outside gates vary, keeping the total at eight.
+The other word is a commuting-diamond case from the preceding local search.
+All 33 literal words are included; no equivalence-class uniqueness is claimed.
+
+The support relaxation encodes nonzero entries, a necessary determinant
+matching, selected endpoint frames and the fact that a single nonzero term
+cannot cancel. Invertibility gives stronger row, column and rank constraints
+for partial-permutation middle-product classes. When a Boolean support survives,
+binomial torus equations and exact Laurent determinant identities can refute
+it. Only that exact support/frame assignment is then forbidden. The final
+Boolean proof closes the fixed word. Twenty-nine words close without an
+arithmetic cut; four require the 78 saved torus refutations.
+
+The recorded discovery seed was 521031. The conjugation generator accepted
+16 words of each Q cost after 22 and 39 proposals respectively; a 112-gate
+representation cap also applied. The final fixed-word search had a 55-second
+overall budget, four seconds per word and at most 192 support assignments per
+word; it completed all 33 exclusions. These are post-selection research inputs,
+not an exhaustive domain or a statistical sample. The seed records provenance;
+the literal inputs, rather than a seeded search rerun, define this certificate.
+
+## Validation and independence
+
+The checker compares direct trajectory enumeration with sequential polynomial
+propagation. It reconstructs rank clauses from unary products and compares
+them with the monomial-based encoding. It replays literal Boolean proof trees,
+unimodular integer operations and a direct Leibniz expansion of determinant
+products. No SAT or arithmetic solver is trusted for a negative conclusion.
+
+Controls include 33 exact dense skeleton checks, 150 Pauli conjugation
+identities, seven paid-gate square identities, four known nine-call solutions,
+recovery of their scalar matrices, and an eight-call rejection. A second
+eight-call control deliberately survives the Boolean relaxation while its
+concrete scalar word fails: Boolean feasibility is not a construction.
+Corrupt integer traces, Boolean proofs and learned clauses, missing final
+refutations and an unsupported complex-torsion exclusion are rejected.
+
+The two path/rank encodings share the tableau/coset core. The dense Gaussian
+matrix implementation independently checks that core on the finite corpus;
+it does not establish an all-size representation theorem. The methods were
+implemented and checked with substantial AI assistance, not independent human
+peer review. There is no Lean proof or novelty claim for the general support,
+rank, torus or determinant techniques. See `VALIDATION.json` for the measured
+local checks and [NOTICE.md](NOTICE.md) for attribution.
+
+The selected frontier, all supplier sources and `upstream/` are unchanged.
+This standalone contribution does not replay or strengthen their compiler,
+physical, recursive, precision/tape or analytic assumptions. No bit primitive,
+complete exponent invoice or practical multiplication speedup is supplied.

research/clifford-relation-obstructions/VALIDATION.json

@@ -0,0 +1,41 @@
+{
+  "status": "PASS",
+  "environment": {
+    "system": "Windows",
+    "python": "3.14.4"
+  },
+  "result": {
+    "status": "PASS_FIXED_CLIFFORD_WORD_EXCLUSIONS",
+    "counts": {
+      "boolean_proof_nodes": 14483,
+      "support_models_or_refutations": 111,
+      "dense_skeleton_checks": 33,
+      "excluded_templates": 33,
+      "noncommuting_relations": 32,
+      "exact_torus_refutations": 78,
+      "dense_generator_identities": 150,
+      "paid_square_identities": 7,
+      "positive_nine_call_controls": 4,
+      "dense_positive_checks": 8,
+      "relaxation_false_positive": 1,
+      "negative_eight_call": 1,
+      "integer_trace_controls": 3,
+      "corrupt_integer_traces_rejected": 3,
+      "corrupt_boolean_proofs_rejected": 1,
+      "corrupt_learned_clauses_rejected": 1,
+      "missing_final_refutations_rejected": 1,
+      "unsupported_torsion_exclusions_rejected": 1
+    },
+    "certificate_payload_sha256": "dafd07d683df169f3c1613bc9ecbab054ce66581d93e7ef0c649286ec2eddc6c"
+  },
+  "checks": {
+    "fresh_directory_without_repository_or_sibling_packages": "PASS",
+    "different_working_directory": "PASS",
+    "changed_gzip_header_and_compression_same_payload": "PASS identical mathematical output",
+    "corrupt_payload": "rejected",
+    "-O": "rejected explicitly",
+    "-OO": "rejected explicitly"
+  },
+  "elapsed_seconds": 78.074,
+  "scope": "Focused standalone replay only; unchanged repository-wide suite and selected frontier replay not run; no remote CI or human-review claim."
+}