From 56f5926c7aec567412fb3facc53b6b8048b1046e Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:05:36 -0500 Subject: [PATCH 1/2] Prove the arbitrary orthogonal-basis bridge word obstruction --- .../CREDITS.md | 42 ++ .../PROOF.md | 291 ++++++++ .../README.md | 70 ++ .../RESULT.json | 636 ++++++++++++++++++ .../SOURCES.json | 18 + .../TASK.json | 81 +++ .../VERIFY.json | 34 + .../verify.py | 358 ++++++++++ 8 files changed, 1530 insertions(+) create mode 100644 research/orthogonal-basis-bridge-obstruction/CREDITS.md create mode 100644 research/orthogonal-basis-bridge-obstruction/PROOF.md create mode 100644 research/orthogonal-basis-bridge-obstruction/README.md create mode 100644 research/orthogonal-basis-bridge-obstruction/RESULT.json create mode 100644 research/orthogonal-basis-bridge-obstruction/SOURCES.json create mode 100644 research/orthogonal-basis-bridge-obstruction/TASK.json create mode 100644 research/orthogonal-basis-bridge-obstruction/VERIFY.json create mode 100644 research/orthogonal-basis-bridge-obstruction/verify.py diff --git a/research/orthogonal-basis-bridge-obstruction/CREDITS.md b/research/orthogonal-basis-bridge-obstruction/CREDITS.md new file mode 100644 index 0000000000..2f8b20b485 --- /dev/null +++ b/research/orthogonal-basis-bridge-obstruction/CREDITS.md @@ -0,0 +1,42 @@ +# Sources and credit + +Ali Romman prepared this proof and verifier with substantial OpenAI +Codex assistance. New work is Apache-2.0. Independent human and +formal-kernel review are unclaimed. + +- Ali Romman's [PR #7694](https://github.com/CrocSwap/integer-mult-bounds/pull/7694), + head `96b8b22f5925c4cf4514ed27575f465ebc95e51a`, supplies the prior + all-k extremal edge-core word obstruction and the full ambient + bridge-deletion argument. Read its + [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/96b8b22f5925c4cf4514ed27575f465ebc95e51a/research/extremal-core-word-obstruction/PROOF.md). + Binary matrix, polynomial, type-order and Laurent routines are + adapted from its [verifier](https://github.com/aliromman/integer-mult-bounds/blob/96b8b22f5925c4cf4514ed27575f465ebc95e51a/research/extremal-core-word-obstruction/verify.py). +- CubeJerry's [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), + head `685457252b51b9c7932ece363365bdf0b12c9c31`, supplies the original + five-core associated-graded and bridge-chronology proof: + [exact word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md). + Its [Laurent checker](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/independent_five_word.py) + is the original source of the adapted recurrence. The source notice + states that the work was prepared for @CubeJerry with substantial + OpenAI assistance. This adaptation is not an independent review. +- The no-edge seven-image corollary uses Ali Romman's + [PR #7691](https://github.com/CrocSwap/integer-mult-bounds/pull/7691), + head `69e70b1426c32b19da8334930815800a2c95ffca`, + [exact classification](https://github.com/aliromman/integer-mult-bounds/blob/69e70b1426c32b19da8334930815800a2c95ffca/research/no-edge-dim5-extremal-classification/PROOF.md), + and [PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690), + head `b725be51349cce4e0a262c76233838992042dd62`, + [exact image bound](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/PROOF.md). + The classification retains unpaidmoon's normal-triple and positive + link credit and Nick Petalas's nonsymmetric-link credit. Those + constructions and their pool geometry are prior work. + +The new result concerns arbitrary even old bases, including coordinate +old calls. It uses the exact diagonal-intersection partition, a +basis-independent idempotence obstruction in the star quotient, and +physical target-multiplicity matching. The Boolean-algebra partition +itself is an elementary algebraic fact, not a new priority claim. + +No external file is read at runtime. SOURCES.json binds the main +selected record and task catalogue as provenance. The corollary's +mathematical dependencies are linked at exact public commits; their +whole package replays are not part of this verifier. diff --git a/research/orthogonal-basis-bridge-obstruction/PROOF.md b/research/orthogonal-basis-bridge-obstruction/PROOF.md new file mode 100644 index 0000000000..ca7183496d --- /dev/null +++ b/research/orthogonal-basis-bridge-obstruction/PROOF.md @@ -0,0 +1,291 @@ +# An orthogonal binary basis and one bridge cannot save paid rank + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +This is an all-width, all-length scalar-word proof with exact finite +checks. Independent human and formal-kernel review are unclaimed. + +## 1. Alphabet and theorem + +Let E be an old coordinate space of positive even dimension N. Choose +any `X in GL_N(F2)`. Its columns x_i and dual covectors y_i define + +``` +P_i = x_i y_i^T = X E_ii X^-1, i=1,...,N. +``` + +Extend these projectors by zero on all other coordinates. They are +mutually orthogonal and sum to the identity on E. Coordinate P_i are +allowed. Put `h_x=sum x_i` and `h_y=sum y_i`. On fresh coordinates +choose a,b with `a dot b=1`, and add the one fixed bridge + +``` +B = (h_x+a)(h_y+b)^T. +``` + +It is idempotent because `h_y dot h_x=N=0` in F2. Its incidences with +every old projector are one. On `V=E direct-sum F2*a`, the basis +`x_1,...,x_N,a` gives the old coordinate projectors and the all-one +matrix J of odd size N+1. This action is irreducible. A nonzero invariant +vector gives an old coordinate vector or lies on the fresh line. In +either case J gives the all-one vector; the old coordinate projectors +then recover every basis vector. + +Consider a word of m calls using exactly these types, with every type present. +Its calls are `I+([A_j]-1)P_type` over `R=F2[H]`, where H is the +torsion-free subgroup generated by all paid exponents A_j. Let k be +the actual off-diagonal pattern dimension of the alphabet, and let +`L=kernel(Z^m -> H)` be its saturated exponent relation lattice. +Assume `rank(L)<=k` and a full ambient diagonal monomial endpoint. + +**Theorem.** All bridge calls form one consecutive block. Their +exponent sum is zero, and their block can be deleted in the full +ambient map. Every physical target exponent is the sum of a disjoint +subset of paid exponents. For rational address matrices, total target +rank is therefore at most paid rank. + +The theorem permits coordinate old projectors and can have k=1. +It does not permit additional projector types. The change of basis +is a proof device, not a free physical operation. No native supplier, +rounding contract, complete multiplier invoice or new kappa follows. + +The chronology method comes from CubeJerry's +[PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), +[five-core word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md), +and its all-k edge-family extension in Ali Romman's +[PR #7694](https://github.com/CrocSwap/integer-mult-bounds/pull/7694), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/96b8b22f5925c4cf4514ed27575f465ebc95e51a/research/extremal-core-word-obstruction/PROOF.md). +The new steps handle an arbitrary X, its full linear kernel, and the +physical target multiplicities. The elementary Boolean-algebra fact +used below is not claimed as a new general algebraic result. + +## 2. The exact diagonal-intersection partition + +Define the binary coefficient space + +``` +K_X = {c in F2^N : X diag(c) X^-1 is diagonal}. +``` + +This is a unital subalgebra of F2^N under coordinatewise multiplication. +Indeed, the map to `X diag(c) X^-1` preserves products, and diagonal +matrices are closed under products. Define i and j to be equivalent +when `c_i=c_j` for every c in K_X. + +The indicator of each equivalence block belongs to K_X. To construct +it, choose an index in that block. For each other block choose an +element that separates their values. Replace it by one plus itself +if necessary to make its value one on the chosen block and zero on +the other block. The product of these elements is the desired +indicator. Thus K_X consists exactly of the vectors constant on +the d equivalence blocks, and has dimension d. + +The old pattern map is `c -> off(X diag(c) X^-1)`, so it has rank N-d. +The bridge has nonzero old-to-fresh and fresh-to-old rectangles, while +all old projectors are supported on E. Its pattern is independent of +the old patterns. Therefore + +``` +k = N-d+1. +``` + +Singleton blocks are allowed. They are exactly the old coordinate +projectors: a singleton indicator in K_X says that P_i itself is a +diagonal rank-one idempotent. + +For a block C, the sum `Q_C=sum_{i in C} P_i` is a diagonal projection. +Its rank is |C|, since these old projectors are orthogonal and have +independent images. Its active coordinate set S_C therefore has +size |C|. The sets S_C partition the original N coordinates. This +will give the physical multiplicity matching at the endpoint. + +## 3. The full degree-one kernel + +Give each call its own universal variable `u_j=T_j-1`. Put +`U_i=sum u_j` over old calls of type i and `L_B=sum u_j` over bridge +calls. First-order diagonality, and the independent bridge pattern, +give L_B=0 and equal U_i within each block of K_X. Use the forms + +``` +L_B, U_i+U_ref(C) for every nonreference i in each block C. +``` + +There are `1+N-d=k` independent forms. Every type occurs, so their +coefficient rows remain independent in the universal call variables. + +The paid-generated group H is free abelian. Its defining exact +sequence with kernel L splits over the integers. Therefore the +linear substitution kernel `F2^m -> H/2H` is L/2L and has dimension +rank(L). The above k forms and `rank(L)<=k` imply equality, and give +the whole linear kernel. + +The associated graded algebra of F2[H] at augmentation is +`Sym(H/2H)`: choose a free basis of H and use each basis monomial +minus one as a degree-one variable. The induced map of symmetric +algebras therefore has the ideal generated by the displayed linear +forms as its kernel. This does not assert that the Laurent relation +ideal itself is linear. An arbitrary larger ambient exponent group +cannot replace the paid-generated H in this parity argument. + +## 4. Star independence for every old basis + +Normalize the old basis by X^-1 on E and use a as the fresh basis +vector of V. The full endpoint preserves V. Since it is diagonal +in the original coordinates, every coordinate in the support of a +has the same endpoint monomial. Its restricted endpoint has an old +block in the algebra generated by + +``` +A = X^-1 diag(F2^N) X +``` + +after extension to R, and one fresh diagonal entry. Each binary +element of A is idempotent. Let A_off be its off-diagonal image, +embedded only in the old N-by-N block. Quotient the off-diagonal +(N+1)-dimensional matrix space by + +``` +Q = span(off(J_(N+1)), A_off). +``` + +For each old coordinate i, let +`K_i=off(J E_ii+E_ii J)`. These N stars are independent modulo Q. +Suppose `sum c_i K_i=lambda off(J)+off(A0)` for A0 in A. The fresh +row forces `c_i=lambda` for every old i. If lambda is one, the old +off-diagonal entries on the left are all zero. Thus +`off(A0)=off(J_N)`, and `A0=J_N+D` for a binary diagonal D. + +This matrix cannot be idempotent when N is even. Since `J_N^2=0`, +the diagonal of `(J_N+D)^2` is diag(D), while the diagonal of +`J_N+D` is one plus diag(D). This contradicts idempotence of A0. +Hence lambda is zero and every c_i is zero. + +This proof uses the actual conjugated diagonal algebra. Replacing +it by all old-block matrices loses the obstruction for a single +indecomposable block; the verifier includes that false-positive control. + +## 5. The bridge calls are consecutive and cancel + +The quotient Q kills the universal constant and linear word terms +before exponent substitution. Thus nonlinear substitution terms +cannot change its degree-two image. In normalized coordinates, +old/old products are diagonal and bridge/bridge products are J. +Only mixed products remain. Modulo L_B, the bridge prefix and suffix +at an old call are equal. The projected degree-two term is +`sum_i K_i q_i`, where + +``` +q_i = sum over calls j of old type i + u_j times the sum of bridge variables before call j. +``` + +The star independence gives q_i in the full linear-kernel ideal. +Eliminate the last bridge variable using L_B. The resulting qbar_i +uses only old variables of type i and the first h-1 bridge variables. + +Reanchor the block containing i at i. In every other type of that +block, solve its equality with U_i for one of its call variables. +For each other block, choose any reference type and solve for one +call variable of each nonreference type. Each such variable exists, +since every type occurs. These substitutions kill all the remaining +kernel generators and fix every variable in qbar_i. Singleton blocks +need no substitution. Consequently qbar_i is identically zero. + +Each old call has a distinct universal variable. Its coefficient is +its bridge prefix after elimination. Every proper nonempty prefix +is a nonzero linear form in the first h-1 bridge variables. Thus no +old call lies between the first and last bridge calls. The bridge +calls are consecutive, including the immediate h=1 case. + +Let Z be their exponent sum. The normalized word has the form +`D_left [I+([Z]-1)J] D_right` with monomial diagonal surrounding +matrices. A fresh-row/old-column entry is an invertible monomial +times `[Z]-1`. Such a cross entry is absent from the endpoint algebra, +so Z=0. The actual ambient bridge is one fixed idempotent B; its +consecutive calls multiply to `I+([Z]-1)B=I`. This deletes the block +on every ambient input, including dirty spectators outside V. + +## 6. Physical target subsets + +Let T_i be the sum of paid exponents of old type i. After the bridge +deletion, the old endpoint is `X diag([T_i]) X^-1`, and every other +coordinate has identity action. Full diagonality implies that, for +each monomial label, the binary mask of types with that label lies +in K_X. Thus the labels [T_i] are equal within each partition block C. + +The endpoint on every original coordinate of S_C is this common +monomial. There are |C| such coordinates and |C| distinct old types +in C. Choose a bijection between them, and assign to each coordinate +the paid calls of its matched type. Its target is exactly their sum. +Different types give disjoint subsets. Give every spectator the empty +subset. This establishes a full physical target assignment without +assuming that X preserves diagonal targets or that its transport is free. + +For rational address matrices, rank subadditivity gives +`sum target ranks <= sum nonbridge paid ranks <= sum all paid ranks`. +The bridge calls remain charged in the original invoice. This is +an exact scalar no-saving theorem, not a native implementation. + +## 7. No-edge pattern-five corollary + +Ali Romman's [PR #7691](https://github.com/CrocSwap/integer-mult-bounds/pull/7691), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/69e70b1426c32b19da8334930815800a2c95ffca/research/no-edge-dim5-extremal-classification/PROOF.md), +classifies every complete unit-free pattern-five pool with irreducible +image seven. It is two disjoint normal triples plus a fresh-factor +link. Here N=6, d=2 with block sizes three and three, and k=5. +The present theorem excludes rank saving for every word on this pool +that uses all types and has at most five exponent relations. + +This also applies when the actual word alphabet is only initially +given as unit-free pattern-five and irreducible image seven. The +total-image bound in [PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/PROOF.md), +makes its complete pool have the same image. That complete pool is +irreducible because it contains the actual alphabet. The cited +classification gives exactly seven independent image lines; the +actual image dimension seven forces every type to occur. + +The normal triples and positive link family are prior work, with +unpaidmoon and Nick Petalas credited in the cited classification. +This corollary adds the word obstruction at five relations. It does +not cover smaller or reducible no-edge images or a larger relation budget. + +## 8. Verification and limits + +The verifier checks all six GL2 and all 20160 GL4 bases. For each it +computes the complete Boolean kernel, its partition, the physical +diagonal supports and the actual star quotient. Coordinate projectors, +mixed partitions and one indecomposable block are included. + +Twelve word domains cover 130320 degree-two type orders. Three of +these domains also check 20880 full Laurent words in the original +coordinates: the coordinate four-basis, one orthogonal four-block, +and the two normal triples. Exactly 5280 have the predicted diagonal +endpoint. Every other full word has a nonzero off-diagonal entry. +Bridge exponents are assigned by chronology; these counts are type +orders, not separate permutations of labelled bridge occurrences. + +Eight larger fixtures through old dimension ten include a repeated +old type, three cancelling bridge calls, nonsymmetric fresh factors +and unused spectator coordinates. Their actual relation rank equals +k. Complete ambient products agree with bridge deletion and with +the physical target-multiplicity assignment. Omitting one bridge +changes an explicit dirty column outside V. Eighty-four binary +diagonal perturbations of even all-one matrices check the idempotence +obstruction. The single-block coarse-quotient control and odd-dimension +guard both reject for their stated reasons. + +The all-width and all-length claims rest on the proof. The finite +tests do not enumerate every old basis, ambient embedding or word. +Extra projector types, omitted types and larger relation budgets +are outside the theorem. Full predecessor package replays, selected +cold replay, Lean and Docker were not run. Independent human and +formal-kernel review are unclaimed. No native supplier, rounding +contract, complete multiplier invoice, selected-frontier change or +new kappa is supplied. All five selected assumptions remain. + +## Open next questions + +Can a specified second nonorthogonal bridge, or a larger relation +budget, support a legal saving? State the full alphabet and paid/target +invoice first. Failure of the present one-bridge hypotheses is not +evidence of a saving or of a native interface. diff --git a/research/orthogonal-basis-bridge-obstruction/README.md b/research/orthogonal-basis-bridge-obstruction/README.md new file mode 100644 index 0000000000..27790b45ce --- /dev/null +++ b/research/orthogonal-basis-bridge-obstruction/README.md @@ -0,0 +1,70 @@ +# No saving from an orthogonal binary basis and one bridge + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. + +Take all projectors of any even-dimensional binary orthogonal basis +on an old coordinate space. Add one fresh pairing-one bridge whose +incidences with all old projectors are one. Coordinate old projectors +are allowed. Every type must occur; extra types are excluded. + +Let k be the actual off-diagonal pattern dimension. Over the +paid-generated torsion-free exponent group, a word with at most k +saturated exponent relations and a full diagonal monomial endpoint +has one consecutive cancelling bridge block. That block can be deleted +on all ambient inputs. Physical target exponents are sums of disjoint +paid subsets, so total rational target rank cannot exceed paid rank. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), [CREDITS.md](CREDITS.md) +and [TASK.json](TASK.json). The new proof identifies the full diagonal +kernel by a Boolean partition and proves star independence for any +old basis. It keeps the physical target multiplicities explicit. +The normal-form basis change is not a free operation. + +As a corollary, the no-edge pattern-five, irreducible-image-seven +family classified in +[PR #7691](https://github.com/CrocSwap/integer-mult-bounds/pull/7691) +cannot save rank at five exponent relations. This family is outside +the extremal edge-core hypothesis of +[PR #7694](https://github.com/CrocSwap/integer-mult-bounds/pull/7694). + +## Reproduce + +Use CPython 3.12 and its standard library, from the repository root. + +```sh +python3.12 -I -W error -B research/orthogonal-basis-bridge-obstruction/verify.py +python3.12 -I -W error -B -O research/orthogonal-basis-bridge-obstruction/verify.py +python3.12 -B scripts/research_package.py --package research/orthogonal-basis-bridge-obstruction +``` + +Expected markers are `PASS_ORTHOGONAL_BASIS_BRIDGE_OBSTRUCTION` and +`PASS_REGISTERED_RESEARCH_PACKAGE`. The verifier compares all results +with the committed receipt and writes no file. + +It checks all 20166 binary bases at old dimensions two and four, +130320 degree-two type orders, 20880 full Laurent words, and eight +ambient fixtures with repeated types and dirty spectators. A single +four-block control shows why the actual conjugated diagonal algebra +must be used in the quotient. Coordinate old calls and a pattern-one +case are included. + +## Limits + +The theorem concerns the stated one-bridge alphabet and its relation +budget. Extra types, omitted types and larger budgets are not covered. +It is not a classification of every subextremal projector pool. +The no-edge corollary uses the pinned classification and image bound. +Finite tests corroborate the written all-width and all-length proof. + +No native supplier, rounding contract, complete multiplier invoice +or new kappa is supplied. The selected frontier and all five assumptions +remain unchanged. Independent human and formal-kernel review are +unclaimed. Full predecessor package replays, selected cold replay, +Lean and Docker were not run. + +## Open next questions + +Can a specified second nonorthogonal bridge or a larger relation +budget support a legal saving? State the whole alphabet and paid/target +invoice first. A failure of the one-bridge hypotheses does not supply +a saving or a native interface. diff --git a/research/orthogonal-basis-bridge-obstruction/RESULT.json b/research/orthogonal-basis-bridge-obstruction/RESULT.json new file mode 100644 index 0000000000..bfb565b670 --- /dev/null +++ b/research/orthogonal-basis-bridge-obstruction/RESULT.json @@ -0,0 +1,636 @@ +{ + "status": "PASS_ORTHOGONAL_BASIS_BRIDGE_OBSTRUCTION", + "scope": "Every old type in an arbitrary even orthogonal binary basis, including coordinate types, plus one fresh pairing-one bridge; actual pattern relation budget and diagonal monomial endpoint.", + "basis_censuses": [ + { + "N": 2, + "bases": 6, + "partition_counts": { + "(1, 1)": 2, + "(2,)": 4 + }, + "examples": { + "(1, 1)": { + "xs": [ + 1, + 2 + ], + "ys": [ + 1, + 2 + ], + "groups": [ + [ + 0 + ], + [ + 1 + ] + ], + "active": [ + 1, + 2 + ], + "k": 1, + "coordinate_count": 2 + }, + "(2,)": { + "xs": [ + 1, + 3 + ], + "ys": [ + 3, + 2 + ], + "groups": [ + [ + 0, + 1 + ] + ], + "active": [ + 3 + ], + "k": 2, + "coordinate_count": 0 + } + }, + "certificate_sha256": "da61c448d6c5ceaab194967761857127b2083c65a9104ba51b131c692d0faf22" + }, + { + "N": 4, + "bases": 20160, + "partition_counts": { + "(1, 1, 1, 1)": 24, + "(1, 1, 2)": 288, + "(1, 3)": 2016, + "(2, 2)": 288, + "(4,)": 17544 + }, + "examples": { + "(1, 1, 1, 1)": { + "xs": [ + 1, + 2, + 4, + 8 + ], + "ys": [ + 1, + 2, + 4, + 8 + ], + "groups": [ + [ + 0 + ], + [ + 1 + ], + [ + 2 + ], + [ + 3 + ] + ], + "active": [ + 1, + 2, + 4, + 8 + ], + "k": 1, + "coordinate_count": 4 + }, + "(1, 1, 2)": { + "xs": [ + 1, + 2, + 4, + 9 + ], + "ys": [ + 9, + 2, + 4, + 8 + ], + "groups": [ + [ + 0, + 3 + ], + [ + 1 + ], + [ + 2 + ] + ], + "active": [ + 9, + 2, + 4 + ], + "k": 2, + "coordinate_count": 2 + }, + "(1, 3)": { + "xs": [ + 1, + 2, + 4, + 11 + ], + "ys": [ + 9, + 10, + 4, + 8 + ], + "groups": [ + [ + 0, + 1, + 3 + ], + [ + 2 + ] + ], + "active": [ + 11, + 4 + ], + "k": 3, + "coordinate_count": 1 + }, + "(4,)": { + "xs": [ + 1, + 2, + 4, + 15 + ], + "ys": [ + 9, + 10, + 12, + 8 + ], + "groups": [ + [ + 0, + 1, + 2, + 3 + ] + ], + "active": [ + 15 + ], + "k": 4, + "coordinate_count": 0 + }, + "(2, 2)": { + "xs": [ + 1, + 2, + 5, + 10 + ], + "ys": [ + 5, + 10, + 4, + 8 + ], + "groups": [ + [ + 0, + 2 + ], + [ + 1, + 3 + ] + ], + "active": [ + 5, + 10 + ], + "k": 3, + "coordinate_count": 0 + } + }, + "certificate_sha256": "8938e23ddb390fe4bed744280df83803e66051789cc7046e7448f9c477dcd3fa" + } + ], + "word_domains": [ + { + "name": "coordinate4", + "N": 4, + "k": 1, + "partition": [ + [ + 0 + ], + [ + 1 + ], + [ + 2 + ], + [ + 3 + ] + ], + "bridges": 1, + "full_laurent": false, + "counts": { + "orders": 120, + "passing": 120 + } + }, + { + "name": "coordinate4", + "N": 4, + "k": 1, + "partition": [ + [ + 0 + ], + [ + 1 + ], + [ + 2 + ], + [ + 3 + ] + ], + "bridges": 2, + "full_laurent": true, + "counts": { + "orders": 360, + "passing": 120 + } + }, + { + "name": "coordinate4", + "N": 4, + "k": 1, + "partition": [ + [ + 0 + ], + [ + 1 + ], + [ + 2 + ], + [ + 3 + ] + ], + "bridges": 3, + "full_laurent": false, + "counts": { + "orders": 840, + "passing": 120 + } + }, + { + "name": "quad4", + "N": 4, + "k": 4, + "partition": [ + [ + 0, + 1, + 2, + 3 + ] + ], + "bridges": 1, + "full_laurent": false, + "counts": { + "orders": 120, + "passing": 120 + } + }, + { + "name": "quad4", + "N": 4, + "k": 4, + "partition": [ + [ + 0, + 1, + 2, + 3 + ] + ], + "bridges": 2, + "full_laurent": true, + "counts": { + "orders": 360, + "passing": 120 + } + }, + { + "name": "quad4", + "N": 4, + "k": 4, + "partition": [ + [ + 0, + 1, + 2, + 3 + ] + ], + "bridges": 3, + "full_laurent": false, + "counts": { + "orders": 840, + "passing": 120 + } + }, + { + "name": "quad4", + "N": 4, + "k": 4, + "partition": [ + [ + 0, + 1, + 2, + 3 + ] + ], + "bridges": 4, + "full_laurent": false, + "counts": { + "orders": 1680, + "passing": 120 + } + }, + { + "name": "normal3_plus_normal3", + "N": 6, + "k": 5, + "partition": [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + "bridges": 1, + "full_laurent": false, + "counts": { + "orders": 5040, + "passing": 5040 + } + }, + { + "name": "normal3_plus_normal3", + "N": 6, + "k": 5, + "partition": [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + "bridges": 2, + "full_laurent": true, + "counts": { + "orders": 20160, + "passing": 5040 + } + }, + { + "name": "normal3_plus_normal3", + "N": 6, + "k": 5, + "partition": [ + [ + 0, + 1, + 2 + ], + [ + 3, + 4, + 5 + ] + ], + "bridges": 3, + "full_laurent": false, + "counts": { + "orders": 60480, + "passing": 5040 + } + }, + { + "name": "edge2_plus_quad4", + "N": 6, + "k": 5, + "partition": [ + [ + 0, + 1 + ], + [ + 2, + 3, + 4, + 5 + ] + ], + "bridges": 2, + "full_laurent": false, + "counts": { + "orders": 20160, + "passing": 5040 + } + }, + { + "name": "orthogonal6", + "N": 6, + "k": 6, + "partition": [ + [ + 0, + 1, + 2, + 3, + 4, + 5 + ] + ], + "bridges": 2, + "full_laurent": false, + "counts": { + "orders": 20160, + "passing": 5040 + } + } + ], + "ambient_checks": [ + { + "name": "coordinate4", + "N": 4, + "width": 9, + "k": 1, + "old_calls": 5, + "coordinate_old_types": 4, + "physical_block_supports": [ + 1, + 2, + 4, + 8 + ], + "endpoint_terms": 5, + "dirty_column_checked": 6 + }, + { + "name": "quad4", + "N": 4, + "width": 9, + "k": 4, + "old_calls": 5, + "coordinate_old_types": 0, + "physical_block_supports": [ + 15 + ], + "endpoint_terms": 2, + "dirty_column_checked": 6 + }, + { + "name": "normal3_plus_normal3", + "N": 6, + "width": 11, + "k": 5, + "old_calls": 7, + "coordinate_old_types": 0, + "physical_block_supports": [ + 7, + 56 + ], + "endpoint_terms": 3, + "dirty_column_checked": 8 + }, + { + "name": "edge2_plus_quad4", + "N": 6, + "width": 11, + "k": 5, + "old_calls": 7, + "coordinate_old_types": 0, + "physical_block_supports": [ + 3, + 60 + ], + "endpoint_terms": 3, + "dirty_column_checked": 8 + }, + { + "name": "orthogonal6", + "N": 6, + "width": 11, + "k": 6, + "old_calls": 7, + "coordinate_old_types": 0, + "physical_block_supports": [ + 63 + ], + "endpoint_terms": 2, + "dirty_column_checked": 8 + }, + { + "name": "coordinate6", + "N": 6, + "width": 11, + "k": 1, + "old_calls": 7, + "coordinate_old_types": 6, + "physical_block_supports": [ + 1, + 2, + 4, + 8, + 16, + 32 + ], + "endpoint_terms": 7, + "dirty_column_checked": 8 + }, + { + "name": "orthogonal8", + "N": 8, + "width": 13, + "k": 8, + "old_calls": 9, + "coordinate_old_types": 0, + "physical_block_supports": [ + 255 + ], + "endpoint_terms": 2, + "dirty_column_checked": 10 + }, + { + "name": "orthogonal10", + "N": 10, + "width": 15, + "k": 10, + "old_calls": 11, + "coordinate_old_types": 0, + "physical_block_supports": [ + 1023 + ], + "endpoint_terms": 2, + "dirty_column_checked": 12 + } + ], + "boundary_controls": { + "single_quad_coarse_quotient_false_positive": { + "order": [ + 4, + 0, + 1, + 2, + 3, + 4 + ], + "k": 4, + "full_endpoint_rejected": true + }, + "even_diagonal_perturbations_rejected": 84, + "odd_old_dimension_rejected": true, + "coordinate_basis_four_pattern_dimension": 1 + }, + "limitations": [ + "The alphabet is specified; extra projector types and larger relation budgets are not covered.", + "All-width and all-length conclusions rest on the written proof.", + "No native implementation, complete multiplier invoice or new kappa." + ] +} diff --git a/research/orthogonal-basis-bridge-obstruction/SOURCES.json b/research/orthogonal-basis-bridge-obstruction/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/orthogonal-basis-bridge-obstruction/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/orthogonal-basis-bridge-obstruction/TASK.json b/research/orthogonal-basis-bridge-obstruction/TASK.json new file mode 100644 index 0000000000..7e9bc9cac2 --- /dev/null +++ b/research/orthogonal-basis-bridge-obstruction/TASK.json @@ -0,0 +1,81 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "All-length no-saving for every type in an arbitrary even orthogonal binary basis, including coordinate old calls, plus one fresh pairing-one bridge at the actual pattern relation budget.", + "scope_change_reason": "Replace the extremal edge-pair geometry by an arbitrary old basis. Use its Boolean diagonal kernel and the actual conjugated endpoint algebra; include the subextremal no-edge seven-core.", + "bottleneck_link": "Exclude a larger specified scalar word class, including the remaining no-edge seven-image family, before native construction or broader searches.", + "budget_minutes": 60, + "stop_rule": "Stop at the arbitrary-basis one-bridge theorem and exact target invoice. Extra types, omitted types and larger relation budgets remain separate.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; all 20166 GL2/GL4 bases, 130320 degree-two orders, 20880 full Laurent words, eight full ambient fixtures and quotient/idempotence controls.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "Can a specified second nonorthogonal bridge or larger relation budget support a legal saving?", + "why_it_matters": "The one-bridge alphabet cannot save rank at the stated budget, but other alphabets are not excluded.", + "first_step": "State the full alphabet and paid/target invoice; do not treat failure of a one-bridge hypothesis as a saving.", + "blocked_by": "No saving word or native interface is supplied." + } + ], + "family_decision": { + "decision": "Change the exact word alphabet from disjoint edge pairs to an arbitrary even old orthogonal basis, then stop at the resulting negative theorem.", + "sources": "7694@96b8b22f5925c4cf4514ed27575f465ebc95e51a; 6782@685457252b51b9c7932ece363365bdf0b12c9c31:FIVE-CORE-WORD.md; 7691@69e70b1426c32b19da8334930815800a2c95ffca; 7690@b725be51349cce4e0a262c76233838992042dd62", + "evidence_status": "Author-checked all-width/all-length proof, exact finite corroboration, and explicit source-dependent no-edge corollary.", + "boundary": "All old types in one even orthogonal binary basis plus one fixed fresh bridge; paid-generated torsion-free group; relation rank at most actual pattern dimension; full diagonal monomial endpoint.", + "obligations": { + "alphabet": "specified; coordinate old types allowed", + "linear_kernel": "proved via Boolean partition", + "general_star_quotient": "proved via idempotence", + "physical_target_matching": "proved", + "full_ambient_deletion": "proved", + "native_realization": "not supplied", + "complete_multiplier_invoice": "not supplied" + }, + "alternative": "A blind word search in the remaining no-edge seven-core would not establish arbitrary length or arbitrary old-basis coverage.", + "construction_gate": "No new native construction is proposed. A future saving needs a different stated alphabet or budget and a complete invoice." + } +} diff --git a/research/orthogonal-basis-bridge-obstruction/VERIFY.json b/research/orthogonal-basis-bridge-obstruction/VERIFY.json new file mode 100644 index 0000000000..95b71e3cfb --- /dev/null +++ b/research/orthogonal-basis-bridge-obstruction/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "All GL2/GL4 Boolean kernels and star quotients, exact type-order domains, full original-coordinate Laurent endpoints, target multiplicities and dirty-spectator controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "All GL2/GL4 Boolean kernels and star quotients, exact type-order domains, full original-coordinate Laurent endpoints, target multiplicities and dirty-spectator controls." + } + ] +} diff --git a/research/orthogonal-basis-bridge-obstruction/verify.py b/research/orthogonal-basis-bridge-obstruction/verify.py new file mode 100644 index 0000000000..6803031643 --- /dev/null +++ b/research/orthogonal-basis-bridge-obstruction/verify.py @@ -0,0 +1,358 @@ +"""Exact checks for an arbitrary orthogonal binary basis and one bridge. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +Matrix and Laurent routines are adapted from PR7694 and its credited +CubeJerry PR6782 source. This is not an independent review. +""" + +from collections import Counter +from fractions import Fraction +import hashlib +import itertools +import json +from pathlib import Path + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def basis(values): + pivots = {} + for value in values: + while value: + bit = value.bit_length() - 1 + if bit in pivots: + value ^= pivots[bit] + else: + pivots[bit] = value + break + return tuple(pivots[i] for i in sorted(pivots, reverse=True)) + + +def reduce_vector(value, pivots): + for row in pivots: + value = min(value, value ^ row) + return value + + +def outer(x, y, width): + return sum(y << (i * width) for i in range(width) if x >> i & 1) + + +def identity(width): + return sum(1 << (i * width + i) for i in range(width)) + + +def left_project(pair, matrix, width): + x, y = pair + row, mask = 0, (1 << width) - 1 + while y: + bit = y & -y + row ^= (matrix >> ((bit.bit_length() - 1) * width)) & mask + y ^= bit + return outer(x, row, width) + + +def orders(t, h): + size = 2 * t + h + for bridge_positions in itertools.combinations(range(size), h): + positions = set(bridge_positions) + for old in itertools.permutations(range(2 * t)): + it = iter(old) + yield tuple(2 * t if i in positions else next(it) for i in range(size)) + + +def rational_rank(rows): + pivots = {} + for original in rows: + row = [Fraction(x) for x in original] + for col in sorted(pivots): + coefficient = row[col] + if coefficient: + row = [x - coefficient * y for x, y in zip(row, pivots[col])] + nonzero = next((i for i, x in enumerate(row) if x), None) + if nonzero is not None: + lead = row[nonzero] + pivots[nonzero] = [x / lead for x in row] + return len(pivots) + + +def consecutive(order, bridge): + positions = [i for i, kind in enumerate(order) if kind == bridge] + return bool(positions) and positions == list(range(positions[0], positions[-1] + 1)) + + +def quadratic(order, exps, products): + coefficients = {} + supports = [[i for i, x in enumerate(row) if x % 2] for row in exps] + for j in range(len(order)): + for i in range(j): + matrix = products[order[j], order[i]] + if matrix: + for a in supports[i]: + for b in supports[j]: + monomial = (min(a, b), max(a, b)) + coefficients[monomial] = coefficients.get(monomial, 0) ^ matrix + return {key: value for key, value in coefficients.items() if value} + + +def laurent(order, exps, pairs, width): + """Multiply the full matrices with exact integer exponent tuples.""" + zero = (0,) * len(exps[0]) + out = {zero: identity(width)} + for kind, exponent in zip(order, exps): + new = {} + for key, matrix in out.items(): + projected = left_project(pairs[kind], matrix, width) + new[key] = new.get(key, 0) ^ matrix ^ projected + shifted = tuple(x + y for x, y in zip(key, exponent)) + new[shifted] = new.get(shifted, 0) ^ projected + out = {key: value for key, value in new.items() if value} + return out +def dual(xs): + n = len(xs) + require(len(basis(xs)) == n, 'invertible old image basis') + return tuple(next(y for y in range(1, 1 << n) + if [(y & x).bit_count() % 2 for x in xs] == [int(i == j) for j in range(n)]) + for i in range(n)) + + +def inspect_basis(xs): + N, ys = len(xs), dual(xs) + require(N >= 2 and N % 2 == 0, 'positive even old dimension') + n, diagonal = N + 1, identity(N + 1) + old_matrices = [outer(x, y, n) for x, y in zip(xs, ys)] + kernel, diagonal_sums = [], {} + for c in range(1 << N): + value = 0 + for i, p in enumerate(old_matrices): + if c >> i & 1: + value ^= p + if not value & ~diagonal: + kernel.append(c) + diagonal_sums[c] = value + require((1 << N) - 1 in kernel and all((a & b) in kernel for a in kernel for b in kernel), + 'unital Boolean diagonal intersection') + signatures = {} + for i in range(N): + signatures.setdefault(tuple(c >> i & 1 for c in kernel), []).append(i) + groups = list(signatures.values()) + indicators = [sum(1 << i for i in group) for group in groups] + require(all(c in kernel for c in indicators) and len(kernel) == 1 << len(groups), 'partition gives the full kernel') + active = [sum(((diagonal_sums[c] >> (j * n + j)) & 1) << j for j in range(N)) for c in indicators] + require(all(mask.bit_count() == len(group) for mask, group in zip(active, groups)), 'target multiplicities') + require(all(not (a & b) for a, b in itertools.combinations(active, 2)) + and sum(active) == (1 << N) - 1, 'active coordinate partition') + k = N - len(groups) + 1 + require(len(basis(p & ~diagonal for p in old_matrices)) == k - 1, 'old pattern dimension') + allowed = [outer(sum(((ys[i] >> j) & 1) << i for i in range(N)), + sum(((xs[i] >> j) & 1) << i for i in range(N)), n) & ~diagonal for j in range(N)] + J = (1 << (n * n)) - 1 + Q = basis([J & ~diagonal] + allowed) + ones = (1 << n) - 1 + normalized = [(1 << i, 1 << i) for i in range(N)] + [(ones, ones)] + stars = [(left_project(normalized[i], J, n) ^ left_project(normalized[-1], outer(*normalized[i], n), n)) & ~diagonal + for i in range(N)] + require(len(Q) == k and len(basis((*Q, *stars))) == k + N, 'general star quotient') + coordinate_count = sum(not (p & ~diagonal) for p in old_matrices) + require(coordinate_count == sum(len(g) == 1 for g in groups), 'singleton blocks are coordinate projectors') + products = {(i, j): reduce_vector(left_project(p, outer(*q, n), n) & ~diagonal, Q) + for i, p in enumerate(normalized) for j, q in enumerate(normalized)} + return {'N': N, 'xs': tuple(xs), 'ys': ys, 'groups': groups, 'active': active, + 'k': k, 'Q': Q, 'products': products, 'coordinate_count': coordinate_count} + + +def basis_census(N): + counts, examples = Counter(), {} + digest = hashlib.sha256() + for xs in itertools.permutations(range(1, 1 << N), N): + if len(basis(xs)) != N: + continue + row = inspect_basis(xs) + key = str(tuple(sorted(map(len, row['groups'])))) + counts[key] += 1 + data = {name: row[name] for name in ('xs', 'ys', 'groups', 'active', 'k', 'coordinate_count')} + examples.setdefault(key, data) + digest.update((json.dumps(data, sort_keys=True) + '\n').encode()) + require(sum(counts.values()) == {2: 6, 4: 20160}[N], 'all invertible bases') + return {'N': N, 'bases': sum(counts.values()), 'partition_counts': dict(sorted(counts.items())), + 'examples': examples, 'certificate_sha256': digest.hexdigest()} + + +def allocate_exponents(order, groups): + N = sum(map(len, groups)) + locations = {kind: [i for i, value in enumerate(order) if value == kind] for kind in range(N + 1)} + require(all(locations.values()), 'every old type and the bridge occur') + dependent = {locations[N][-1]} + for group in groups: + dependent.update(locations[kind][-1] for kind in group[1:]) + free = [i for i in range(len(order)) if i not in dependent] + r = len(free) + exps = [[0] * r for _ in order] + for column, pos in enumerate(free): + exps[pos][column] = 1 + for group in groups: + reference = [sum(exps[pos][j] for pos in locations[group[0]]) for j in range(r)] + for kind in group[1:]: + pos = locations[kind][-1] + exps[pos] = [reference[j] - sum(exps[other][j] for other in locations[kind] if other != pos) for j in range(r)] + pos = locations[N][-1] + exps[pos] = [-sum(exps[other][j] for other in locations[N][:-1]) for j in range(r)] + require(len(dependent) == N - len(groups) + 1, 'exact saturated relation count') + return [tuple(row) for row in exps] + + +def ambient_frame(frame, a=1, b=1, fresh_width=1, unused=0): + N = frame['N'] + require(a and b and a < 1 << fresh_width and b < 1 << fresh_width and (a & b).bit_count() % 2, + 'fresh pairing one') + hx, hy = 0, 0 + for x, y in zip(frame['xs'], frame['ys']): + hx ^= x + hy ^= y + pairs = list(zip(frame['xs'], frame['ys'])) + [(hx | (a << N), hy | (b << N))] + require(all((x & y).bit_count() % 2 for x, y in pairs), 'all projectors are idempotent') + width = N + fresh_width + unused + require(len(basis(outer(x, y, width) & ~identity(width) for x, y in pairs)) == frame['k'], + 'actual ambient pattern dimension') + require(len(basis(x for x, _ in pairs)) == N + 1, 'actual ambient image dimension') + return pairs, width + + +def target_endpoint(frame, order, exps, width): + N, r = frame['N'], len(exps[0]) + totals = [tuple(sum(row[j] for kind, row in zip(order, exps) if kind == i) for j in range(r)) for i in range(N)] + expected = {(0,) * r: sum(1 << (i * width + i) for i in range(N, width))} + for group, active in zip(frame['groups'], frame['active']): + require(all(totals[i] == totals[group[0]] for i in group), 'equal labels within each kernel block') + mask = sum(1 << (i * width + i) for i in range(N) if active >> i & 1) + label = totals[group[0]] + expected[label] = expected.get(label, 0) ^ mask + return {key: value for key, value in expected.items() if value} + + +def frames(): + return { + 'coordinate4': inspect_basis((1, 2, 4, 8)), + 'quad4': inspect_basis(tuple(15 ^ (1 << i) for i in range(4))), + 'normal3_plus_normal3': inspect_basis((6, 5, 7, 48, 40, 56)), + 'edge2_plus_quad4': inspect_basis((1, 3) + tuple((15 ^ (1 << i)) << 2 for i in range(4))), + 'orthogonal6': inspect_basis(tuple(63 ^ (1 << i) for i in range(6))), + 'coordinate6': inspect_basis(tuple(1 << i for i in range(6))), + 'orthogonal8': inspect_basis(tuple(255 ^ (1 << i) for i in range(8))), + 'orthogonal10': inspect_basis(tuple(1023 ^ (1 << i) for i in range(10))), + } + + +def word_domain(name, frame, h, full): + N, counts = frame['N'], Counter() + pairs, width = ambient_frame(frame) + for order in orders(N // 2, h): + exps = allocate_exponents(order, frame['groups']) + block = consecutive(order, N) + require((not quadratic(order, exps, frame['products'])) == block, 'general-basis quadratic chronology') + if full: + actual = laurent(order, exps, pairs, width) + expected = target_endpoint(frame, order, exps, width) + require((actual == expected) == block, 'full original-coordinate endpoint') + if not block: + require(any(matrix & ~identity(width) for matrix in actual.values()), 'nonconsecutive word is not diagonal') + counts['orders'] += 1 + counts['passing'] += block + order = next(orders(N // 2, h)) + exps = allocate_exponents(order, frame['groups']) + require(len(exps) - rational_rank(exps) == frame['k'], 'actual exponent relation rank') + return {'name': name, 'N': N, 'k': frame['k'], 'partition': frame['groups'], 'bridges': h, + 'full_laurent': full, 'counts': dict(counts)} + + +def ambient_checks(all_frames): + result = [] + for name, frame in all_frames.items(): + N = frame['N'] + pairs, width = ambient_frame(frame, 3, 5, 3, 2) + old = (0, 0) + tuple(range(1, N)) + order = old[:N // 2] + (N, N, N) + old[N // 2:] + exps = allocate_exponents(order, frame['groups']) + require(len(exps) - rational_rank(exps) == frame['k'], 'repeated-type word keeps the exact relation budget') + actual = laurent(order, exps, pairs, width) + kept = [(kind, row) for kind, row in zip(order, exps) if kind != N] + deleted = laurent([x[0] for x in kept], [x[1] for x in kept], pairs, width) + require(actual == deleted == target_endpoint(frame, order, exps, width), 'full ambient target multiplicities and deletion') + omit = order.index(N) + wrong = laurent(order[:omit] + order[omit + 1:], exps[:omit] + exps[omit + 1:], pairs, width) + delta = [wrong.get(key, 0) ^ actual.get(key, 0) for key in wrong.keys() | actual.keys()] + require(any(any(matrix >> (i * width + N + 2) & 1 for i in range(width)) for matrix in delta), + 'one omitted bridge changes a dirty spectator column') + result.append({'name': name, 'N': N, 'width': width, 'k': frame['k'], 'old_calls': len(old), + 'coordinate_old_types': frame['coordinate_count'], 'physical_block_supports': frame['active'], + 'endpoint_terms': len(actual), 'dirty_column_checked': N + 2}) + return result + + +def boundary_controls(all_frames): + frame = all_frames['quad4'] + N, n = 4, 5 + order = (4, 0, 1, 2, 3, 4) + exps = allocate_exponents(order, frame['groups']) + diagonal, J = identity(n), (1 << (n * n)) - 1 + coarse = basis([J & ~diagonal] + [1 << (i * n + j) for i in range(N) for j in range(N) if i != j]) + ones = (1 << n) - 1 + normalized = [(1 << i, 1 << i) for i in range(N)] + [(ones, ones)] + products = {(i, j): reduce_vector(left_project(p, outer(*q, n), n) & ~diagonal, coarse) + for i, p in enumerate(normalized) for j, q in enumerate(normalized)} + require(not quadratic(order, exps, products), 'coarse endpoint quotient loses the obstruction') + require(quadratic(order, exps, frame['products']), 'actual conjugated diagonal quotient rejects') + pairs, width = ambient_frame(frame) + require(any(matrix & ~identity(width) for matrix in laurent(order, exps, pairs, width).values()), + 'coarse false positive fails the full endpoint') + # A binary diagonal perturbation of J_N is never idempotent when N is even. + checked = 0 + for N in (2, 4, 6): + for mask in range(1 << N): + JN = (1 << (N * N)) - 1 + M = JN ^ sum(1 << (i * N + i) for i in range(N) if mask >> i & 1) + squared_diagonal = [sum(((M >> (i * N + j)) & 1) * ((M >> (j * N + i)) & 1) + for j in range(N)) % 2 for i in range(N)] + require(squared_diagonal != [(M >> (i * N + i)) & 1 for i in range(N)], 'idempotence obstruction') + checked += 1 + require((15 & 15).bit_count() % 2 == 0, 'odd old dimension gives a nonidempotent all-one bridge') + rejected = False + try: + inspect_basis((1, 2, 4)) + except ValueError as e: + rejected = str(e) == 'positive even old dimension' + require(rejected, 'odd-dimension guard') + return {'single_quad_coarse_quotient_false_positive': {'order': order, 'k': 4, 'full_endpoint_rejected': True}, + 'even_diagonal_perturbations_rejected': checked, 'odd_old_dimension_rejected': True, + 'coordinate_basis_four_pattern_dimension': all_frames['coordinate4']['k']} + + +def compute(): + all_frames = frames() + domains = [] + for name, hs in [('coordinate4', range(1, 4)), ('quad4', range(1, 5)), + ('normal3_plus_normal3', range(1, 4)), ('edge2_plus_quad4', (2,)), ('orthogonal6', (2,))]: + for h in hs: + full = h == 2 and name in {'coordinate4', 'quad4', 'normal3_plus_normal3'} + domains.append(word_domain(name, all_frames[name], h, full)) + return {'status': 'PASS_ORTHOGONAL_BASIS_BRIDGE_OBSTRUCTION', + 'scope': 'Every old type in an arbitrary even orthogonal binary basis, including coordinate types, plus one fresh pairing-one bridge; actual pattern relation budget and diagonal monomial endpoint.', + 'basis_censuses': [basis_census(N) for N in (2, 4)], + 'word_domains': domains, 'ambient_checks': ambient_checks(all_frames), + 'boundary_controls': boundary_controls(all_frames), + 'limitations': ['The alphabet is specified; extra projector types and larger relation budgets are not covered.', + 'All-width and all-length conclusions rest on the written proof.', + 'No native implementation, complete multiplier invoice or new kappa.']} + + +if __name__ == '__main__': + actual = json.loads(json.dumps(compute())) + expected = json.loads(Path(__file__).with_name('RESULT.json').read_text()) + require(actual == expected, 'committed exact receipt') + print(actual['status']) + print(json.dumps({'binary_bases': sum(r['bases'] for r in actual['basis_censuses']), + 'quadratic_orders': sum(r['counts']['orders'] for r in actual['word_domains']), + 'full_laurent_orders': sum(r['counts']['orders'] for r in actual['word_domains'] if r['full_laurent']), + 'ambient_fixtures': len(actual['ambient_checks'])}, sort_keys=True)) From 996c002d82420141c19797e4e3b699ed88aee330 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:09:21 -0500 Subject: [PATCH 2/2] State the abelian exponent-group hypothesis explicitly --- research/orthogonal-basis-bridge-obstruction/PROOF.md | 2 +- research/orthogonal-basis-bridge-obstruction/README.md | 2 +- research/orthogonal-basis-bridge-obstruction/TASK.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/research/orthogonal-basis-bridge-obstruction/PROOF.md b/research/orthogonal-basis-bridge-obstruction/PROOF.md index ca7183496d..57fc4c2a8a 100644 --- a/research/orthogonal-basis-bridge-obstruction/PROOF.md +++ b/research/orthogonal-basis-bridge-obstruction/PROOF.md @@ -32,7 +32,7 @@ then recover every basis vector. Consider a word of m calls using exactly these types, with every type present. Its calls are `I+([A_j]-1)P_type` over `R=F2[H]`, where H is the -torsion-free subgroup generated by all paid exponents A_j. Let k be +torsion-free abelian subgroup generated by all paid exponents A_j. Let k be the actual off-diagonal pattern dimension of the alphabet, and let `L=kernel(Z^m -> H)` be its saturated exponent relation lattice. Assume `rank(L)<=k` and a full ambient diagonal monomial endpoint. diff --git a/research/orthogonal-basis-bridge-obstruction/README.md b/research/orthogonal-basis-bridge-obstruction/README.md index 27790b45ce..bfe535c55b 100644 --- a/research/orthogonal-basis-bridge-obstruction/README.md +++ b/research/orthogonal-basis-bridge-obstruction/README.md @@ -8,7 +8,7 @@ incidences with all old projectors are one. Coordinate old projectors are allowed. Every type must occur; extra types are excluded. Let k be the actual off-diagonal pattern dimension. Over the -paid-generated torsion-free exponent group, a word with at most k +paid-generated torsion-free abelian exponent group, a word with at most k saturated exponent relations and a full diagonal monomial endpoint has one consecutive cancelling bridge block. That block can be deleted on all ambient inputs. Physical target exponents are sums of disjoint diff --git a/research/orthogonal-basis-bridge-obstruction/TASK.json b/research/orthogonal-basis-bridge-obstruction/TASK.json index 7e9bc9cac2..70d153ad21 100644 --- a/research/orthogonal-basis-bridge-obstruction/TASK.json +++ b/research/orthogonal-basis-bridge-obstruction/TASK.json @@ -65,7 +65,7 @@ "decision": "Change the exact word alphabet from disjoint edge pairs to an arbitrary even old orthogonal basis, then stop at the resulting negative theorem.", "sources": "7694@96b8b22f5925c4cf4514ed27575f465ebc95e51a; 6782@685457252b51b9c7932ece363365bdf0b12c9c31:FIVE-CORE-WORD.md; 7691@69e70b1426c32b19da8334930815800a2c95ffca; 7690@b725be51349cce4e0a262c76233838992042dd62", "evidence_status": "Author-checked all-width/all-length proof, exact finite corroboration, and explicit source-dependent no-edge corollary.", - "boundary": "All old types in one even orthogonal binary basis plus one fixed fresh bridge; paid-generated torsion-free group; relation rank at most actual pattern dimension; full diagonal monomial endpoint.", + "boundary": "All old types in one even orthogonal binary basis plus one fixed fresh bridge; paid-generated torsion-free abelian group; relation rank at most actual pattern dimension; full diagonal monomial endpoint.", "obligations": { "alphabet": "specified; coordinate old types allowed", "linear_kernel": "proved via Boolean partition",