diff --git a/research/shared-hub-seven-call/.gitattributes b/research/shared-hub-seven-call/.gitattributes new file mode 100644 index 0000000000..130a3ecaa2 --- /dev/null +++ b/research/shared-hub-seven-call/.gitattributes @@ -0,0 +1 @@ +retained/** -text whitespace=cr-at-eol diff --git a/research/shared-hub-seven-call/CREDITS.md b/research/shared-hub-seven-call/CREDITS.md new file mode 100644 index 0000000000..d868b6e66c --- /dev/null +++ b/research/shared-hub-seven-call/CREDITS.md @@ -0,0 +1,32 @@ +# Sources and credit + +Ali Romman (@aliromman) prepared this proof, checker and package with +substantial OpenAI Codex assistance. New material is Apache-2.0. +No independent human or formal proof-kernel acceptance is claimed. + +Nick Petalas (@petalas) supplied the six-call theorem, unchanged checker +and seven-call question in [PR #7742](https://github.com/CrocSwap/integer-mult-bounds/pull/7742), +at the [exact proof](https://github.com/petalas/integer-mult-bounds/blob/9394615e9fd3a30b66e23d422da4945258d7923f/research/shared-hub-single-pass/README.md) +and [checker](https://github.com/petalas/integer-mult-bounds/blob/9394615e9fd3a30b66e23d422da4945258d7923f/research/shared-hub-single-pass/verify.py). +All five package files are retained byte-exact. The integer bit-encoded +Laurent engine here adapts that source method; the bivariate set engine +is separate. + +Ali Romman supplied the shared-hub projector pool in +[PR #7707](https://github.com/CrocSwap/integer-mult-bounds/pull/7707), +[source proof](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/PROOF.md), +and the four-relation theorem and cross-commutator lemma in +[PR #7711](https://github.com/CrocSwap/integer-mult-bounds/pull/7711), +[retained proof](https://github.com/aliromman/integer-mult-bounds/blob/ac185e4529a01156f7b574555b50827f8cb645bb/research/shared-hub-triple-word-obstruction/PROOF.md). +The displayed projector matrices are checked directly. The cross-commutator lemma is a dependency. The four-relation theorem is +related prior work; its complete predecessor suite is not rerun. + +Jerry Jiaheng Chen (@CubeJerry) supplied the augmentation chronology method +in [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), +[source word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md). +The source notices identify this credit. This package adds the complete first-nonzero-form case split and the +exact cuts for the repeated call with a higher augmentation order. It does not claim a new geometry theorem or physical realization. + +`SOURCES.json` pins canonical main selection and task provenance. +`SOURCE-PINS.json` authenticates six retained source files. Source pins +are content references and do not assert unmerged ancestry. diff --git a/research/shared-hub-seven-call/PROOF.md b/research/shared-hub-seven-call/PROOF.md new file mode 100644 index 0000000000..865d8b0195 --- /dev/null +++ b/research/shared-hub-seven-call/PROOF.md @@ -0,0 +1,225 @@ +# Seven nonzero calls still require two blocks + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Use the six projectors from Ali Romman's +[PR #7707](https://github.com/CrocSwap/integer-mult-bounds/pull/7707): + +```text +A0=(6,5), A1=(5,6), A2=(7,7), +B0=(12,20), B1=(20,12), B2=(28,28). +``` + +The pair (u,v) means uv^T over F2, in coordinates 0 through 4. Each triple +is orthogonal. Their sums are DA=diag(1,1,1,0,0) and DB=diag(0,0,1,1,1). +A call with label a is I+([a]-1)P over F2[H], where H is the torsion-free +abelian group generated by the seven paid labels. Later calls act on the left. +Thus H=Z^7/L with L saturated. Every label is nonzero, one type occurs +twice, and the other five types occur once. There is no relation-rank limit. + +**Theorem.** A diagonal endpoint in the original coordinates requires all A +calls before all B calls, or the reverse. The exact exponent totals of the +three A types are one common S, and those of the three B types are one +common T. Conversely these conditions give + +```text +diag([S],[S],[S+T],[T],[T]). +``` + +In particular, no opposite-triple call can separate the repeated pair. +Any unused spectator coordinates remain fixed. Each target receives a +disjoint subset of paid labels, so the sum of rational target ranks is at +most the sum of paid ranks. This is an obstruction for the stated alphabet +without a relation-rank limit, not a new kappa or a physical supplier. + +## 1. First nonzero terms + +Choose an integral basis of the paid-generated group H. Expand each Laurent +variable at one in the formal power series ring over F2. The expansion is +injective, and its associated graded ring is a polynomial domain. Thus a +nonzero label has a coefficient [a]-1 of finite positive augmentation order. +This is the source method used in +[PR #7711](https://github.com/CrocSwap/integer-mult-bounds/pull/7711) and +[PR #7742](https://github.com/CrocSwap/integer-mult-bounds/pull/7742). +Reflection of coordinates 0 through 4 exchanges the A and B triples, so +assume the repeated type is on the A side. + +Let p be the least order of the four A coefficients, and q the least order +of the three B coefficients. At degree q, the two B-private off-diagonal +entries force all three B coefficients to have the same nonzero initial +form g. Pure A terms vanish there and all mixed terms have higher degree. +The B types are distinct and mutually orthogonal, so pure B products reduce +to the linear sum of their three projector coefficients. + +Let f1 and f2 be the degree-p forms of the two repeated A coefficients. +A form is zero if that call has higher order. At degree p, the A-private +entries equate the three type coefficients. Hence both non-repeated A +coefficients have form f=f1+f2. The product of the two repeated coefficients +has degree at least 2p and does not enter here. At least one of f1,f2 is +nonzero; otherwise every A coefficient would have zero degree-p form. + +## 2. The first mixed degree + +Let Q be the span of the six off-patterns. The nine classes +C_ij=off(Ai Bj+Bj Ai) modulo Q have rank eight; their sole nonzero +dependence is the sum of all nine. This is the cross-commutator lemma of +PR7711. The checker reconstructs the matrices and tests all 511 nonempty +subsets. + +Compare with the order in which all A calls precede all B calls. In degree +p+q its mixed part is fg DB DA, which is diagonal, including when f=0. +Pure off-diagonal terms lie in Q. Any term with at least three factors and +both triples has higher degree. Swapping an inverted A/B pair therefore +changes this degree by its two initial forms times C_ij. + +The rank-eight lemma makes all nine inversion coefficients equal, after +cancelling the common nonzero factor g. Fix a B_j. Let alpha and beta +indicate that it precedes the first and second repeated calls, and let +epsilon be the corresponding indicator for either non-repeated A type. +Equality gives + +```text +f1 alpha + f2 beta = (f1+f2) epsilon. +``` + +If f1=f2!=0, this forces alpha=beta. If f1 and f2 are distinct and both +nonzero, they are linearly independent over F2, so alpha=beta=epsilon. +In both cases B_j cannot separate the repeated pair. These alternatives +include every case where both repeated calls have order p. + +If exactly one of f1,f2 is zero, the other is f!=0. The six visible calls +have initial forms f on A and g on B. Equality of the nine coefficients +then makes every visible A/B inversion indicator the same. Those six +calls form two blocks. The extra call has strictly higher augmentation +order. No restriction on its exact nonzero label follows from this step. +The exact argument below resolves its possible position. + +## 3. The extra call cannot cross a B block + +Invert the word if necessary, so that the visible A block comes before +the B block. Inversion reverses the order, negates exact labels and +preserves diagonality and the hypotheses. If the extra A call separates +from its partner, it lies inside or after the B block. Write the word as + +```text +F_Bright F_Ai(x) F_Bleft F_Acore, +``` + +where x is nonzero. The two A-private rows of F_Bright are identity rows, +and the B-private columns of F_Acore are identity columns. The rectangle +from B-private input columns to A-private output rows is therefore + +```text +([x]-1) u_i,private (F_Bleft)_(hub,B-private). +``` + +The private image u_i,private is nonzero for all three A types. The group +algebra is a domain and [x]-1 is nonzero. Hence the hub/private row of +F_Bleft must vanish. If its three B coefficients are beta0,beta1,beta2, +this says beta0=beta1=beta2. A missing B type has coefficient zero; each +present type has nonzero coefficient. A nonempty proper B prefix is +therefore impossible. + +It remains to exclude the extra A call after the complete B block. The +same equations make that block DB(t), where t=[T] is a monomial different +from one. On the three A coordinates it is diag(1,1,t). Write + +```text +F_Acore = I + a A0 + b A1 + c A2, +F_Ai(x) = I + d Ai, d=[x]-1 != 0. +``` + +Each of 1+a, 1+b and 1+c is a nonzero monomial. + +For repeated A0, row zero forces b=c. With r=a+b, three required +off-diagonal zeros of W=(I+dA0)diag(1,1,t)F_Acore are + +```text +W_10 = r + d(1+b+tr), +W_12 = r + dt(1+a), +W_20 = (1+d)tr + d(1+b). +``` + +The first and third sum to (1+t)r. Since t!=1, diagonality gives r=0. +The second then gives dt(1+a)=0, which contradicts the three nonzero +factors. Swapping the two A-private coordinates proves the A1 case. + +For repeated A2, the sum W_02+W_12 equals a+b, so a=b. Put e=1+a and +r=a+c. Then F_Acore=eI+rJ, where J=A2 is the all-one three-by-three +matrix. The two entries + +```text +W_01 = r + d(e+tr), +W_02 = r + dt(e+r) +``` + +sum to de(1+t), again a product of nonzero elements. This excludes A2. +All possibilities for the extra call are now covered, so the repeated +pair cannot have an opposite-triple call between its occurrences. + +## 4. Exact totals and the complete endpoint + +All calls between the repeated pair are from its own orthogonal triple. +They commute, so combine the repeated calls into one call at their exact +sum. This sum cannot be zero in a diagonal word. If it were zero, the +remaining A side would have only two nonzero distinct types. At its first +nonzero augmentation degree, the A-private entries would equate all three +type coefficients, including the missing zero coefficient, which is +impossible. Pure B terms vanish on that private square, and mixed terms +have strictly higher degree. + +The combined word thus has six nonzero calls, one per type. Nick Petalas's +[PR #7742](https://github.com/CrocSwap/integer-mult-bounds/pull/7742) +forces its two triple blocks and exact common labels, for every +torsion-free abelian group. Expanding the combined call within its +same-triple interval preserves that block order. This proves necessity. +Orthogonality within each triple proves the converse and the displayed +endpoint directly. + +Assign coordinate 0 all A0 paid labels, coordinate 1 all A1 labels, +coordinate 2 all A2 and B2 labels, coordinate 3 all B0 labels and +coordinate 4 all B1 labels. These subsets are disjoint. Rational matrix +rank subadditivity proves the paid-rank inequality, including both +occurrences of the repeated type. Spectators receive the empty subset. + +## Exact checks and limits + +The checker examines all 5,040 labelled call orders for each of the four +possible relations between the leading forms. These four cases are complete +up to a change of basis in their F2-span. + +| Leading forms (f1,f2) | Passing orders | Passing orders with a separator | +| --- | ---: | ---: | +| (1,1) | 2,016 | 0 | +| (1,2), independent | 288 | 0 | +| (0,1) | 504 | 216 | +| (1,0) | 504 | 216 | + +For the last two cases every passing visible six-call core has two blocks. +Exact symbolic matrix products check the exceptional cut identities for +all three repeated A types. Coordinate reflection checks the B cases. + +Seven integer-vector fixtures realize all seven five-relation binary +quotients with nonzero labels generating Z^2. Six additional fixtures have +rank-one paid groups and six relations, with different augmentation orders +and signed totals. The gcd checks authenticate each paid group and the +saturated kernel. For each fixture and each of six repeated types, the +checker multiplies all 5,040 full Laurent words: 393,120 words in total. +Exactly 22,464 endpoints are diagonal, the 288 block orders in each of +78 cases, and every diagonal entry has the stated exponent. Integer bit encoding is injective on the +entire finite exponent support box. A separate bivariate set engine +checks 468 full products without that encoding. + +The controls include a separating even repeated label that degree two +misses, a nonzero even change to one exact type total, and an omitted hub +contribution. The unchanged PR7742 verifier also checks its 527,040 +six-call cases. All six retained source files are authenticated first. + +The arbitrary-label result is the written proof. The finite fixtures do +not enumerate all saturated lattices. Eight or more +calls, other projector pools, arbitrary register changes, native +realization, physical storage and restoration, and the complete caller +invoice remain outside scope. The full PR7711 and geometry predecessor +suites, selected cold replay, Lean and Docker were not run. All five +framework assumptions remain. No human or formal proof-kernel acceptance +or global literature priority is claimed. diff --git a/research/shared-hub-seven-call/README.md b/research/shared-hub-seven-call/README.md new file mode 100644 index 0000000000..a8bc5eeb58 --- /dev/null +++ b/research/shared-hub-seven-call/README.md @@ -0,0 +1,34 @@ +# Seven-call shared-hub obstruction + +Seven nonzero calls, with one shared-hub type repeated, still require two triple blocks to give a +diagonal endpoint. The repeated calls cannot straddle a call from the +other triple. Exact totals give the same five target labels, and their +total rational rank cannot exceed the paid rank. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), +[verify.py](verify.py), [SOURCE-PINS.json](SOURCE-PINS.json) and +[CREDITS.md](CREDITS.md). The proof handles both exceptional cases that +the degree-two check misses. The finite checker covers all four leading-form cases and all six choices +of repeated type. The theorem has no relation-rank limit. + +Run from the repository root with Python 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/shared-hub-seven-call +``` + +Both registered modes print `PASS_SHARED_HUB_SEVEN_CALL`. The retained +six-call verifier runs unchanged. The general theorem is a written proof; +finite replay is not formal proof-kernel acceptance. + +No new kappa, physical supplier or selected-frontier change follows. +All five framework assumptions remain. The selected cold replay, Lean +and Docker were not run. + +## Open next questions + +- Resolve two repeated types at eight calls without a relation limit. The + visible-core and exact-cut arguments must then handle two extra calls. + A complete caller cost remains necessary for any physical proposal. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/shared-hub-seven-call/RESULT.json b/research/shared-hub-seven-call/RESULT.json new file mode 100644 index 0000000000..db2f666acd --- /dev/null +++ b/research/shared-hub-seven-call/RESULT.json @@ -0,0 +1,120 @@ +{ + "source_files": 6, + "pool": { + "off_pattern_rank": 4, + "commutator_rank": 8, + "subset_checks": 511 + }, + "leading_cases": { + "canonical_cases": [ + {"leading_forms":[1,1],"passing_orders":2016,"separated_passing_orders":0}, + {"leading_forms":[1,2],"passing_orders":288,"separated_passing_orders":0}, + {"leading_forms":[0,1],"passing_orders":504,"separated_passing_orders":216}, + {"leading_forms":[1,0],"passing_orders":504,"separated_passing_orders":216} + ], + "coefficient_pairs": 63, + "indicator_cases": 504, + "order_cases": 20160 + }, + "exact_cut": { + "symbolic_identities": 6, + "proper_prefix_masks": [ + {"mask":1,"rank":1}, + {"mask":2,"rank":1}, + {"mask":3,"rank":2}, + {"mask":4,"rank":1}, + {"mask":5,"rank":2}, + {"mask":6,"rank":2} + ] + }, + "full_words": { + "cases": [ + {"repeated_type":0,"fixture":"S","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"0e96ab82e2d5e74428c334b7c74448e49013bba79f334b556360c226e8ab1af7"}, + {"repeated_type":0,"fixture":"T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"3b35b32be7c3f094b9dbd916fb9b45ac1d9131830e41048254bb71a4da23dcd8"}, + {"repeated_type":0,"fixture":"X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"5b2961a66bf5e31820fce4a8cb21fd1fdd7f0348db1fbd490cedd6a29e1a9596"}, + {"repeated_type":0,"fixture":"S+T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"84e3375629ec275e6b1e0538514be7227fef08e33b1bf441e567536881d32ea9"}, + {"repeated_type":0,"fixture":"S+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"9fe27b148836d9b362f6a64d873c6f93ba27312eb874bc448e1f2ce03f8b11fa"}, + {"repeated_type":0,"fixture":"T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"5ba2c878cb4abd0ec9777751a4002851b309320fda63db9eef2007cfcede54f1"}, + {"repeated_type":0,"fixture":"S+T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"e78934c8c4a325ef812c4029b3c703955e98d35ae239ab852b8e90ef02f42946"}, + {"repeated_type":0,"fixture":"rank-one-1","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"5ef242747f6784724545090ffed9e79862734025692aa8dae77641474e3e49b7"}, + {"repeated_type":0,"fixture":"rank-one-2","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"6af627f10c3a5e4606c04af18d699fe2496de2edaa6b07f807c08087e2df94c8"}, + {"repeated_type":0,"fixture":"rank-one-3","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"924c3d77ab4b51bc3459077e11ca07157f17ea4ebe74b8f61ecce129621a5491"}, + {"repeated_type":0,"fixture":"rank-one-4","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"d81d9778f20f9417d09d026cb55366a7b8c7bd860997c066c6b24bcc1be9f177"}, + {"repeated_type":0,"fixture":"rank-one-5","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"4dfbf0cb0d366f5145ef2c12de0c05f9ae9b2209e96621e2326e8c1c3cc415d5"}, + {"repeated_type":0,"fixture":"rank-one-6","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"858cb12aeb01aff1dccc90c96e4b7623b07676e49feb9c2efaa44462441200d6"}, + {"repeated_type":1,"fixture":"S","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"b7e13a3a7e1e793c50fee0b66a87e902bf939422ae41a24a708e6c8dc552ec07"}, + {"repeated_type":1,"fixture":"T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"597e89b6b559bd76895fc3b14fc19d024560526e47bbff4fdd19e5f0dbd8bdeb"}, + {"repeated_type":1,"fixture":"X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"fd569ae85319869972f27e3c5a66d703b53186434930148a1490764843474a90"}, + {"repeated_type":1,"fixture":"S+T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"b097f4d71ede03112ff7e1da13dd3baa0ca8063811085f852d875d6bb6bae2cb"}, + {"repeated_type":1,"fixture":"S+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"1099ef49f00ab7f5b60198d47c0201df8e4a11345b581b89015b7e9e0e784baf"}, + {"repeated_type":1,"fixture":"T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"2ef8bcde61e685342054ea391a99aa90b4299ba1d13e976c2e18b6327bb1ad2c"}, + {"repeated_type":1,"fixture":"S+T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"5cd91e355815317d72a71b72f7ff8a949ce627de0baaf6971d110e51f4c295a8"}, + {"repeated_type":1,"fixture":"rank-one-1","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"9702a30b119d929c0884bfa6a4b5c1e845aaf8020a03d52771e499305d9a3bfa"}, + {"repeated_type":1,"fixture":"rank-one-2","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"d995645bff8dbb895f4e38b546755c79974fda212481fb8e401ff737e130040a"}, + {"repeated_type":1,"fixture":"rank-one-3","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"7068e1bd8b4dd13835814d42cac6adb4ad798d1c58fb9dd90f1bb934fa346884"}, + {"repeated_type":1,"fixture":"rank-one-4","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"7a1c57e53db18d3a885296ff1beaae1c2eb853052f1175cd770a0980802dea81"}, + {"repeated_type":1,"fixture":"rank-one-5","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"6f445ea7322a52001e2797e5617a11e21c3f9eb2f6ffc7bd62b62f4e9a105ad5"}, + {"repeated_type":1,"fixture":"rank-one-6","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"56f1b7f994c1045a5b17746fb2353358d85c258e911c2a6f98b6d9a1d7cc72a6"}, + {"repeated_type":2,"fixture":"S","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"2cf87cf18e8efd68cd9e840a1bd5c008809a10568e4b21b77bd47444895ce500"}, + {"repeated_type":2,"fixture":"T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"cdf77e795efd5771cf2e4e1b38bc0244f919bfe9ab839447462f62a058539a22"}, + {"repeated_type":2,"fixture":"X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"d85ebe15d2dd10061e36566208a3e726ab241af89ccbe553141e9048f3cf4aa5"}, + {"repeated_type":2,"fixture":"S+T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"fa7797306041c5d73d62309797acbf32a9efb3b1d6721c74e53e00312fe44098"}, + {"repeated_type":2,"fixture":"S+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"313b2810ead848f7741b801e287c25a95dd13ff953efa3ae26b3c4982a989451"}, + {"repeated_type":2,"fixture":"T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"0f22bffa03e6f87891de00e6bab553610772af58dafe14e1a43c58f1a435a77e"}, + {"repeated_type":2,"fixture":"S+T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"1b1726b259470163bf43e525f6669f68c80995784945802b9b72bcfe645a794d"}, + {"repeated_type":2,"fixture":"rank-one-1","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"677b406f596b744a59acf5e16405c0e1c19b9a0397d4a2e2d8d467baa97a8bce"}, + {"repeated_type":2,"fixture":"rank-one-2","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"3e75551f4fa0565b53c4f6dcc5b5dfa671d171581a01c90577ff71dd0ac59672"}, + {"repeated_type":2,"fixture":"rank-one-3","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"791a6dc907d546cb0653e5ecd8156d6ec50d3dcdc2cf551f53617fe5d68dd9d0"}, + {"repeated_type":2,"fixture":"rank-one-4","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"84a4dea7b44de34c6b9ae53c0aa212114040875a96296640f3eb172f3c11e384"}, + {"repeated_type":2,"fixture":"rank-one-5","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"ef047228216a8926275491379d43aa292041213d27980cfa32ed1ffea13cad03"}, + {"repeated_type":2,"fixture":"rank-one-6","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"2d7858028db59c91de480f0fb47119a82b8cdfe7fbe7a22a68bb4816b1b2bca8"}, + {"repeated_type":3,"fixture":"S","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"fc2cddb3137e4a4977db2dfd2160433c3941b9f326646bd01773b461ef694d0a"}, + {"repeated_type":3,"fixture":"T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"ad4a21208f7a236ce7372cbf1f163e28782d3cbf65725f97217a8af74403f668"}, + {"repeated_type":3,"fixture":"X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"807b851f05689bb1528b07d7276e19802c9d2b616960b191f04505498d5ca2b6"}, + {"repeated_type":3,"fixture":"S+T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"7e5a3445a302915efa204045677c0630510dbe553c6a81ee73aeceb27e31f064"}, + {"repeated_type":3,"fixture":"S+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"685390a92d80bcb43184380ba494decf880bde1b122e22dc34b896b249d657fe"}, + {"repeated_type":3,"fixture":"T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"eadadb170e392c819ba34c0ec953b3d6a6d9bcb34b411baddf0086742418d7d4"}, + {"repeated_type":3,"fixture":"S+T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"029d0598011f14cd5110b15dd794431624102e0d3514858b60df2ef429be7b49"}, + {"repeated_type":3,"fixture":"rank-one-1","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"98c9ff9147fd7530e935cf1fe256691af74907774c2d14d5addbfba28e0931b2"}, + {"repeated_type":3,"fixture":"rank-one-2","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"f9c8fd8ce4e7ba767c8652fc2608bb463a75e4d84050b89c1924e95aa767e8f0"}, + {"repeated_type":3,"fixture":"rank-one-3","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"06bcc959c8eef9c154ba358222cc8699a59384d4f34bc3536869c342453ae99b"}, + {"repeated_type":3,"fixture":"rank-one-4","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"d3faa0bd3ca09c9a35792accec44d84d900845951eb714e175b0144f9359fb92"}, + {"repeated_type":3,"fixture":"rank-one-5","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"06417c6d271773625fffcb0bd9039d4630fa229e997e62b6cd27bd0b330fcb0e"}, + {"repeated_type":3,"fixture":"rank-one-6","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"12902303f36c540cba3085628836b8e8cc5a8e1a8a59ecceb1d4ea4fc39a1020"}, + {"repeated_type":4,"fixture":"S","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"ec4fe6cd6dcc48b4af7bd663e432d58bff1d83b4d71ae106c427e58250d5b679"}, + {"repeated_type":4,"fixture":"T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"af66f11f33eced0ad037de4a5d7bf59e6dd3152774cc21651d5f45679da1fe2b"}, + {"repeated_type":4,"fixture":"X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"b08054f02840ca58b67e29bdf484f483a546b6010678cf58f581dab05231ce6e"}, + {"repeated_type":4,"fixture":"S+T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"a9c9d4895defbbd59c8fbabee085712bdc11460eabab682b45a27fbb03919c01"}, + {"repeated_type":4,"fixture":"S+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"b8bfbb61cc0cb7b7c2e6a3b166569d403a571bb4b76bc99265bab08be112aa63"}, + {"repeated_type":4,"fixture":"T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"f2bbcb72f60e488caa0f9cb2c3c65ddf59c52038ac6871b99d34176def6f9b1d"}, + {"repeated_type":4,"fixture":"S+T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"55c3ce32e3a49b4d178117a24f40e88171cae2d3f12a30c79a485ca44903dafd"}, + {"repeated_type":4,"fixture":"rank-one-1","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"320eb741c0f95212768c0d75ccd5272beb2428dae251499cf7195d8b5a666e80"}, + {"repeated_type":4,"fixture":"rank-one-2","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"ea2298080c81b9407777e184addbe88be32a36ef795917a4607d3695f1516358"}, + {"repeated_type":4,"fixture":"rank-one-3","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"4bbc8f10d9cb2262c41b72ba45c844405a03f66f0c2947e3cdb7b85f66e475d1"}, + {"repeated_type":4,"fixture":"rank-one-4","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"160876f273718089a458394621736443042663d7383a443bd9ec7e9ef656502d"}, + {"repeated_type":4,"fixture":"rank-one-5","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"a261225eb7a79a2fd538df1646fa04cc63d7c05c932c42878bae7576b5d5ffc1"}, + {"repeated_type":4,"fixture":"rank-one-6","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"ee5560d7e80027787a9759662b639e0bdb8babd848927f5de5de7696d3813bc5"}, + {"repeated_type":5,"fixture":"S","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"820f43624f813665a9548a9c2d3c9d98c11e19c6553498f7be9918eb17b71cba"}, + {"repeated_type":5,"fixture":"T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"4b6f586aec8e515e60b79e0d670875814a728cc46859c7e4749957bd09ce4c2c"}, + {"repeated_type":5,"fixture":"X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"8914f8b5c22c15a9e11e7ffccb73a5890214c8d3fed09b2cec2de17f42615c6d"}, + {"repeated_type":5,"fixture":"S+T","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"d191e5c0ddae96e90124b6846a34dea6d14cfc276c95fdce9baf05c2bd22e81b"}, + {"repeated_type":5,"fixture":"S+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"312f1a37cbb33ce09e61277086cf7be69fc470cefc225da66080251573e11567"}, + {"repeated_type":5,"fixture":"T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"0dd4adaa1b72f07c440e45b55bf652245708a18abddca2622d21b821ff714215"}, + {"repeated_type":5,"fixture":"S+T+X","paid_rank":2,"relations":5,"orders":5040,"diagonal":288,"full_matrix_sha256":"6dc9645123a60e7b9f7cb07c0f9ece498785b5a66dc7a4c085dd9ec38a416bb2"}, + {"repeated_type":5,"fixture":"rank-one-1","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"f4cbfcb7b0fd819fa7c6aa7e01e31cc899c32fe5ecadc8db678cfcf5e3a66d5b"}, + {"repeated_type":5,"fixture":"rank-one-2","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"dfe9b9f5969c961ff8735da88c321f5cd50bee34d633737bb0b5fb749387a17b"}, + {"repeated_type":5,"fixture":"rank-one-3","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"d6c5ac0171b358f24c3f54625dd36ee16002d6daae4100d43ca192f21836c18f"}, + {"repeated_type":5,"fixture":"rank-one-4","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"f3d612859f5e72d4a530321c3c430d8f15190940b4333d0da642f246ad4f917c"}, + {"repeated_type":5,"fixture":"rank-one-5","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"6dbf52c297e1e24e3bfdba8fb66384c605b26d17054c0e8023551d6e9c671063"}, + {"repeated_type":5,"fixture":"rank-one-6","paid_rank":1,"relations":6,"orders":5040,"diagonal":288,"full_matrix_sha256":"77b310f443a4253e54ea86ef4ac2feb7451065dd33dd8ba55383b38d49403384"} + ], + "sparse_products": 468, + "words": 393120, + "diagonal": 22464 + }, + "controls": [ + "even repeated separator", + "even type-total mutation", + "missing hub target" + ] +} diff --git a/research/shared-hub-seven-call/SOURCE-PINS.json b/research/shared-hub-seven-call/SOURCE-PINS.json new file mode 100644 index 0000000000..0fbdff8b97 --- /dev/null +++ b/research/shared-hub-seven-call/SOURCE-PINS.json @@ -0,0 +1,53 @@ +{ + "schema_version": 1, + "sources": [ + { + "repository": "petalas/integer-mult-bounds", + "commit": "9394615e9fd3a30b66e23d422da4945258d7923f", + "path": "research/shared-hub-single-pass/README.md", + "retained": "retained/single-pass/README.md", + "git_blob": "c45cf1bf038fa5ebd376f1ab64103f2815b7683f", + "sha256": "e5f3cd1d935dceeb98b504e778f533e7b65abcce1088af889de9353d98ff68d0" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "9394615e9fd3a30b66e23d422da4945258d7923f", + "path": "research/shared-hub-single-pass/verify.py", + "retained": "retained/single-pass/verify.py", + "git_blob": "e4ccba0722f24f0f4fd167bd4a2ae67d8088dd5a", + "sha256": "014f42cab4aa51e23b2e5e4386f0bf7aeb180fe537f6e9a31fa973178c0973e6" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "9394615e9fd3a30b66e23d422da4945258d7923f", + "path": "research/shared-hub-single-pass/VERIFY.json", + "retained": "retained/single-pass/VERIFY.json", + "git_blob": "3a99090702ec5d1a8b5d4abceeb74311366d85b7", + "sha256": "dcacb15e58302a4b5fca18e62c47787eca25644a19cc522e444907f9d3f3b5c0" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "9394615e9fd3a30b66e23d422da4945258d7923f", + "path": "research/shared-hub-single-pass/TASK.json", + "retained": "retained/single-pass/TASK.json", + "git_blob": "9a72a72cdf264116f111211c8185c43611a5e3d8", + "sha256": "38167bf3f9d1b252e2bb4daf3265730db8afe4614cb21e186f9108dfa2398aab" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "9394615e9fd3a30b66e23d422da4945258d7923f", + "path": "research/shared-hub-single-pass/SOURCES.json", + "retained": "retained/single-pass/SOURCES.json", + "git_blob": "5335fa97d97f6df5a917eea1ee2fcd01c082d261", + "sha256": "0761fd793723c2df1e2ca51733251cfd597ff3e120f7e2ee8ebb8e10e8e98c08" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "ac185e4529a01156f7b574555b50827f8cb645bb", + "path": "research/shared-hub-triple-word-obstruction/PROOF.md", + "retained": "retained/four-relation-PROOF.md", + "git_blob": "b2d11b00681ea2f12271772f7400dcd2e0b6809d", + "sha256": "f7e93dd7cff4500ccfed6cb1058a8cd1a73f76808f7226f181b64d34b88910d1" + } + ] +} diff --git a/research/shared-hub-seven-call/SOURCES.json b/research/shared-hub-seven-call/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/shared-hub-seven-call/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/shared-hub-seven-call/TASK.json b/research/shared-hub-seven-call/TASK.json new file mode 100644 index 0000000000..bf31474025 --- /dev/null +++ b/research/shared-hub-seven-call/TASK.json @@ -0,0 +1,64 @@ +{ + "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": "Seven nonzero calls with one repeated type in the fixed shared-hub pool, every torsion-free paid-generated exponent group, and a full diagonal endpoint in the original coordinates; no relation-rank limit.", + "scope_change_reason": "The first nonzero augmentation forms reduce to four cases, which resolve the released seven-call question without a relation-rank restriction.", + "bottleneck_link": "A formal paid word must change the complete target/paid rank profile; this class has no rank saving.", + "budget_minutes": 60, + "stop_rule": "Stop at a proved scoped obstruction or exact counterexample, not a failed finite search.", + "outcome": "negative-result", + "evidence": "PROOF.md gives the general argument; RESULT.json and verify.py give all four leading-form cases, complete finite order checks, exact cuts and controls.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing", + "open_questions": [ + { + "question": "Eight calls with two repeated types, without a relation-rank limit.", + "why_it_matters": "Two extra calls can change the visible-core cut.", + "first_step": "Derive the exact private cross rectangles before any broad search.", + "blocked_by": "No complete classification or physical caller cost is supplied." + } + ] +} diff --git a/research/shared-hub-seven-call/VERIFY.json b/research/shared-hub-seven-call/VERIFY.json new file mode 100644 index 0000000000..f9ece34928 --- /dev/null +++ b/research/shared-hub-seven-call/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check all four leading-form cases, labelled orders, exact exceptional cuts, full Laurent endpoints, independent sparse products and controls." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check all four leading-form cases, labelled orders, exact exceptional cuts, full Laurent endpoints, independent sparse products and controls." + } + ] +} diff --git a/research/shared-hub-seven-call/retained/four-relation-PROOF.md b/research/shared-hub-seven-call/retained/four-relation-PROOF.md new file mode 100644 index 0000000000..b2d11b0068 --- /dev/null +++ b/research/shared-hub-seven-call/retained/four-relation-PROOF.md @@ -0,0 +1,246 @@ +# Words on two normal triples with one common coordinate + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +This is an author-checked scoped proof. It does not give a new kappa. + +## 1. Exact statement + +Work over F2. A pair of positive integers (x,y) denotes the rank-one +matrix `x y^T`, with binary digits in coordinate order 0 through 4. +Use exactly these six projectors: + +```text +A0=(6,5), A1=(5,6), A2=(7,7), +B0=(12,20), B1=(20,12), B2=(28,28). +DA=A0+A1+A2=diag(1,1,1,0,0), +DB=B0+B1+B2=diag(0,0,1,1,1). +``` + +Each triple is orthogonal. The common coordinate is 2. The two other +coordinates of each triple are its private coordinates. The six-member +complete pool and its pattern dimension four are prior results of +[PR #7707](https://github.com/CrocSwap/integer-mult-bounds/pull/7707), +at the [source proof](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/PROOF.md). +This proof uses the displayed matrices directly. It does not require +the source's full geometric maximum theorem. + +An m-call word applies `I+([a_j]-1)P_j` in chronological order over +the group algebra F2[H]. The additive group H is the torsion-free +abelian group generated by its paid exponents a_j. Equivalently, +`H=Z^m/L`, where L is saturated. Every one of the six types occurs. +Require `rank(L)<=4`. Add any number of unused coordinate spectators. +Require a diagonal monomial endpoint on the full ambient space in +the original coordinate basis. A coordinate permutation is allowed; +an arbitrary ambient change of basis is not included. + +Then all A calls occur before all B calls, or all B calls occur before +all A calls. The three A-type exponent totals are one common S, and +the three B-type totals are one common T. The five target exponents +are `(S,S,S+T,T,T)`. Spectators have exponent zero. + +Conversely, this two-block chronology and these exact totals give that +full endpoint. This converse is an identity and needs no relation limit. +The necessity uses every stated hypothesis. + +Each target is the sum of a disjoint subset of paid exponents: give +coordinates 0 and 1 the A0 and A1 calls, coordinates 3 and 4 the B0 +and B1 calls, and coordinate 2 all A2 and B2 calls. Give spectators +the empty subset. Thus rational address-matrix rank subadditivity gives + +```text +sum of target ranks <= sum of paid ranks. +``` + +All paid calls remain charged. There is no rank saving in this class. + +## 2. The first-order quotient + +Let off delete a matrix's diagonal, and let Q be the span of the six +off-patterns. It has dimension four. Within each triple the sum of +the patterns is zero. There are no other relations: in the two private +coordinates of A, the private off-diagonal entries of A0,A1,A2 are, +respectively, `E10`, `E01`, and `E10+E01`. The B triple has the same +property, with the private coordinate order reversed if necessary. +The two triple supports have no common off-diagonal entry. + +Write U for the degree-one space of the augmentation ideal of F2[H]. +Since H is the paid-generated torsion-free group, its degree-one +dimension is `m-rank(L)`. Its associated graded algebra is Sym(U). +This follows by choosing an integral basis of H and expanding its +Laurent variables at one. No larger ambient exponent group is used. + +The endpoint's off-diagonal degree-one part is zero. Therefore the +type-total linear forms obey exactly four independent relations: + +```text +sum(A0 calls) = sum(A1 calls) = sum(A2 calls) = u, +sum(B0 calls) = sum(B1 calls) = sum(B2 calls) = v. (1) +``` + +Each type occurs, so the four relations have rank four before quotient. +The limit `rank(L)<=4` forces equality and leaves no further linear +relation in U. In particular, u and v are independent. + +For each type, retain all but one call variable and express its last +variable from (1). This is a basis description of U: u, v, and the +private retained variables of all six types. If E_i is the span of +the degree-one call variables of type Ai, then +`E_i=span(u, its private variables)`. If F_j is the corresponding span +for Bj, then `F_j=span(v, its private variables)`. Within each type, +all its call variables are independent. The subspaces from the A and +B sides are disjoint. + +The augmentation method comes from CubeJerry's +[PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), +[word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md). +The prior arbitrary-basis use and paid-group caveat are in +[PR #7695](https://github.com/CrocSwap/integer-mult-bounds/pull/7695), +[proof](https://github.com/aliromman/integer-mult-bounds/blob/996c002d82420141c19797e4e3b699ed88aee330/research/orthogonal-basis-bridge-obstruction/PROOF.md). +The present first-order equations differ from the bridge-total equations. + +## 3. The cross-commutator lemma + +Put `C_ij=off(Ai Bj+Bj Ai)` in the quotient by Q. The nine C_ij have +exactly one linear relation: their total sum is zero. + +Here is a direct proof. For coefficients r_ij, restrict their sum to +the rectangle with A-private rows and B-private columns. The three +private image columns of A form a rank-two matrix X whose kernel is +the all-one vector. The three private covectors of B form a rank-two +matrix Y with the same kernel. Every cross factor pairing through the +common coordinate equals one. Thus this rectangle is `X R Y^T`. +Every matrix in Q is zero on it. + +The kernel of `R -> X R Y^T` consists of `r_ij=s_i+t_j`. To check this, +choose two independent columns on each side. The four corresponding +entries determine the quotient map, which is onto the four-dimensional +space of two-by-two matrices. The displayed additive row-and-column +forms lie in its kernel and have dimension five. They are the full +kernel by dimension. + +For this form, the full commutator sum is + +```text +sum_i s_i [Ai,DB] + sum_j t_j [DA,Bj]. (2) +``` + +Here `[P,R]=PR+RP`. The first term is supported inside the A triple +and has only common/private entries; it has no private/private entry. +The second term has the corresponding support inside B. These off- +diagonal supports are disjoint. A member of the A-pattern space with +zero private/private entries is zero, by the explicit entries in +Section 2. The same is true for B. Thus membership of (2) in Q forces +both terms to vanish separately. + +The common/private entries of the first term vanish exactly when the +private image sum and private covector sum vanish. Both two-by-three +matrices have all-one kernel, so s0=s1=s2. The same argument gives +t0=t1=t2. Thus all r_ij are equal. Conversely their common value one +gives `[DA,DB]=0`, since DA and DB are diagonal. This proves the lemma, +including the quotient by Q. Its rank is eight. + +## 4. Degree two forces two blocks + +For each pair i,j, define the quadratic polynomial q_ij to be the sum +of `a*b` over calls a of type Ai and calls b of type Bj for which b +occurs before a. These are degree-one call variables in U. + +Compare the word's degree-two coefficient with the order in which all +A calls precede all B calls. Calls inside a triple commute exactly. +Each interchange of an A call and a B call changes the degree-two +matrix by its variable product times the corresponding commutator. +The degree-two terms of individual factors lie in Q after off. In +the comparison order, the first-order blocks are u DA and v DB, so +their cross term is diagonal. The remaining within-block terms lie +in Q. Therefore a diagonal endpoint requires + +```text +sum_ij C_ij q_ij = 0 modulo Q. (3) +``` + +The rank-eight lemma, applied to each quadratic monomial separately, +makes all nine q_ij the same polynomial q. + +For each i,j, q_ij lies in `E_i F_j`, the span of products of one +element of E_i and one element of F_j. The basis in Section 2 shows +that the intersection of these nine spaces is precisely span(uv). +Indeed a private variable of any one type is absent from the product +space for another type on that side. The only remaining monomial is +uv. Hence `q=epsilon*u*v`, where epsilon is zero or one. + +Fix i,j. The call variables within Ai are a basis of E_i; those within +Bj are a basis of F_j. Their pairwise products are independent because +E_i and F_j lie in disjoint variable spaces. Their complete sum is uv, +by (1). Thus the coefficient of every call pair in q_ij is epsilon. +If epsilon is zero, every Ai call precedes every Bj call. If epsilon +is one, every Bj call precedes every Ai call. The same epsilon applies +to all nine pairs. This proves the two-block chronology at every length. + +## 5. Exact totals and full endpoints + +Degree one alone does not give exact equality of exponent totals. +Let the three exact A totals be S_i and the three exact B totals T_j. +After collecting calls within each block, its operator is + +```text +FA = I + sum_i ([S_i]-1)Ai, +FB = I + sum_j ([T_j]-1)Bj. (4) +``` + +Suppose A precedes B, so the full map is FB FA. The two A-private +rows of FB are identity rows. They leave the corresponding rows of +FA unchanged. The private off-diagonal entries in those rows are +`[S_0]+[S_2]` and `[S_1]+[S_2]`. Diagonality forces all three monomials +equal. Distinct group elements are linearly independent in F2[H], so +S0=S1=S2 exactly. + +The B-private columns of FA are identity columns. Thus the corresponding +columns of FB FA equal those of FB. Their private off-diagonal entries +force T0=T1=T2 by the same argument. If B precedes A, exchange the +roles of rows, columns and triples. The conclusion is unchanged. + +Equation (4) now gives `FA=I+([S]-1)DA` and `FB=I+([T]-1)DB`. +These operators are diagonal, commute, and have the stated full endpoint. +Their common coordinate has monomial `[S][T]=[S+T]`. Every spectator +is fixed at each call. This proves necessity, sufficiency and the +disjoint paid-subset rank bound in Section 1. + +## 6. Exact checks and limits + +The checker tests all 511 nonempty subsets of the nine commutators, +including reduction modulo Q. Only the full subset vanishes. This +corroborates the direct rank lemma; it is not the unbounded proof. + +Five multiplicity domains contain 68760 distinct type orders, with +1584 passing orders. Each has both a degree-two check and a full +original-coordinate Laurent product. The exponents use the universal +exact common-total lattice, with four relations. Every passing word +has the predicted full endpoint. Every other word has an off-diagonal +entry. A separate multinomial count gives each passing count. These +finite checks do not enumerate every saturated lattice with the same +modulo-two reduction; the written proof covers that distinction. + +Twenty-four larger fixtures include repeated calls, both block orders, +coordinate permutations, and up to twelve unused spectators. They +check the actual paid exponent rank and all ambient columns. Moving +one call across the block boundary changes an explicit input column. + +The controls also check two nonzero-even total changes at the same +four-relation rank. Degree two misses these changes; the full endpoint +rejects them. A larger ambient exponent group can hide an interleaving +after all labels are doubled; the correct paid-generated coordinates +reject it. At five relations, an interleaved diagonal word exists with +three zero calls. At six relations, an interleaved identity has every +call nonzero. These are boundary controls, not rank-saving constructions +or a classification above four relations. Omitted-type and wrong-hub- +target controls change the full map. + +The exact six-type alphabet, all types present, original diagonal +endpoint, paid-generated group and four-relation limit are essential +scope restrictions. This does not classify other even maximizers or +arbitrary ambient embeddings. It does not supply a native word, +physical storage, restoration, a complete recursive invoice, or a +selected-assumption discharge. The selected kappa and all five +assumptions remain unchanged. Full predecessor suites, selected cold +replay, native/physical replay, Lean, Docker, independent human and +formal-kernel review were not run. diff --git a/research/shared-hub-seven-call/retained/single-pass/README.md b/research/shared-hub-seven-call/retained/single-pass/README.md new file mode 100644 index 0000000000..c45cf1bf03 --- /dev/null +++ b/research/shared-hub-seven-call/retained/single-pass/README.md @@ -0,0 +1,134 @@ +# Six nonzero calls on the shared-hub projector pool + +**Scoped proof.** A six-call word on this five-register alphabet, with each +projector used once at a nonzero exponent, has a diagonal endpoint exactly when +the two triples are consecutive blocks with a common exponent within each +block. This holds in every torsion-free abelian exponent group. In particular, +allowing a fifth exponent relation cannot produce an interleaving in this +six-call model. + +## Model and result + +Write `(u,v)` for the rank-one matrix `uv^T` over F₂, with the masks interpreted +in coordinate order 0 through 4. The alphabet is + +```text +A0=(6,5) A1=(5,6) A2=(7,7) +B0=(12,20) B1=(20,12) B2=(28,28) +``` + +Each triple consists of mutually orthogonal idempotents. Their sums are +`DA = diag(1,1,1,0,0)` and `DB = diag(0,0,1,1,1)`. Coordinate 2 is the common +coordinate. The A-private coordinates are 0 and 1, and the B-private coordinates +are 3 and 4. The alphabet comes from Ali Romman's +[PR #7707 at `57e2492`](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/PROOF.md). + +Each of the six calls is `I + ([a]−1)P`, with its own nonzero `a` in the +additive group `H`. Here `[a]` is the monomial for `a` in the group algebra +F₂[H]. Use the original coordinates and let later calls act on the left. Any +additional unused coordinates are fixed. Diagonality on all five coordinates +forces either A then B or B then A. There are exponents `S,T` such that all +three A calls use `S` and all three B calls use `T`. The endpoint is +`diag([S],[S],[S+T],[T],[T])`. Both block orders attain this endpoint. If all six +labels are the same nonzero element, their generated group has rank one and +there are exactly five independent integral relations. + +The five target labels use disjoint sets of calls. The private coordinates +receive A0, A1, B0 and B1 respectively, while the common coordinate receives +A2 and B2. For rational matrix exponents, rank subadditivity bounds the total +target rank by the total paid rank. + +## Proof + +Let `Q` be the F₂-span of the off-diagonal parts of the six projectors. Use the +cross-commutator lemma from Ali Romman's [PR #7711, section 3 at +`ac185e4`](https://github.com/aliromman/integer-mult-bounds/blob/ac185e4529a01156f7b574555b50827f8cb645bb/research/shared-hub-triple-word-obstruction/PROOF.md). +In the off-diagonal matrix space modulo `Q`, the nine vectors +`off(Ai Bj + Bj Ai)` have only one nonzero dependence, the sum of all nine. +PR #7711 proves a two-block theorem for arbitrary repetitions with at most four +relations. Its interleaving at five relations uses zero exponents. + +**First nonzero term on each triple.** Replace `H` by the subgroup generated by +the six labels. It is free abelian of finite rank. Choose a basis and expand +each corresponding Laurent variable as `1 + x_k` in the formal power series +ring over F₂. This expansion is injective. To see this, multiply a Laurent +polynomial by a monomial to clear negative powers, then use injectivity of +translation on polynomials. Every nonzero label therefore gives a factor +coefficient `[a]−1` of finite positive order in total degree. + +Let `p` be the smallest such order among the A calls, and let `q` be the +smallest among the B calls. Any product term involving both triples starts +in degree at least `p+q`. In the A-private square at degree `p`, pure B terms +vanish, and pure A terms are linear combinations of the three A projectors +since distinct projectors within a triple multiply to zero. In the two +private off-diagonal entries, A0 and A1 each contribute to one entry and A2 +contributes to both. Diagonality gives equality of the three degree-`p` +coefficients of `[a]−1`, including any zero coefficients at that degree. By +choice of `p` at least one coefficient is nonzero. Thus every A call has +order `p` and the same nonzero initial form `f`. The B-private square at +degree `q` gives order `q` and a common nonzero initial form `g` for B. + +**The first mixed degree.** Compare the candidate word to the order with every A +call before every B call. Pure terms agree in the two words. In degree `p+q` +the comparison order has mixed part `fg DB DA`, which is diagonal. Its pure +off-diagonal parts lie in `Q`. Moving any B call before an A call adds that +pair's commutator times `fg` in this degree. No higher-order mixed products +can enter. If the candidate is diagonal, the sum of its inverted-pair +commutators times `fg` vanishes modulo `Q`. The polynomial ring over F₂ is an +integral domain, so `fg` has a nonzero coefficient. At that coefficient the +cross-commutator lemma applies. Either none of the nine pairs is inverted or +all nine are inverted. This proves the block separation even when every +linear coefficient of one triple vanishes. + +**Exact labels.** In order A then B, the A-private rows equal those of the A +block alone, and the B-private columns equal those of the B block alone. The +same private off-diagonal entries used above now give equality of the three +full monomials per block. Reverse the roles of rows and columns in order B +then A. Equality of group monomials gives equality of labels. Orthogonality +within each triple reduces the two blocks to `I+([S]−1)DA` and +`I+([T]−1)DB`. This gives the endpoint and proves sufficiency. + +## Evidence and reproduction + +The proof covers arbitrary labels under the stated hypotheses. The finite +[verifier](verify.py) independently multiplies full five-coordinate matrices +over F₂[z,z⁻¹]. It uses all 720 orders for each label tuple in +`{-2,1,2}^6`, plus three signed tuples that exercise a wider gap in augmentation +orders, equal initial forms at different labels, and a zero sum at the common +coordinate. It checked 527,040 words and found 792 diagonal endpoints. Every +passing matrix had the exact predicted diagonal. The finite check uses the +infinite cyclic group, so all the words checked have five exponent relations. + +From the repository root with CPython 3.12.15 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/shared-hub-single-pass +python3.12 -B scripts/check_research_commit.py --package research/shared-hub-single-pass --check-source-history +python3.12 -I -W error -B research/shared-hub-single-pass/verify.py +``` + +The verifier prints `PASS_SHARED_HUB_SINGLE_PASS cases=527040 diagonal=792`. +[SOURCES.json](SOURCES.json) pins the catalogue and selected record at the base +commit. Full Git history is needed for those provenance checks. The replay +requires only this package and the standard library. The scope is exactly six +nonzero calls in the formal alphabet. Repeated projectors, zero labels and +arbitrary changes of register basis lie outside it. Native realization, +physical storage and restoration, and the complete recursive invoice are open. +The predecessor replays, selected cold replay, Lean and Docker were unrun. + +## Open next questions + +Can a seven-call word interleave the triples at five relations with all labels +nonzero and the two occurrences of its repeated projector separated by a call +from the other triple? This is the first length at which per-type cancellation +could defeat the proof. Start with a single repeated A type and compare its +two leading coefficients in the private square with their separate contributions +to the mixed degree. The current argument only constrains their sum there. + +## Credit + +This contribution was produced by Nick Petalas. Credit Ali Romman for the +shared-hub pool in #7707 and the cross-commutator lemma, four-relation theorem +and larger-budget question in #7711. Credit Jerry Jiaheng Chen (CubeJerry) for +the earlier [augmentation chronology method in #6782](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md). +The written extension and verifier are Apache-2.0. diff --git a/research/shared-hub-seven-call/retained/single-pass/SOURCES.json b/research/shared-hub-seven-call/retained/single-pass/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/shared-hub-seven-call/retained/single-pass/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/shared-hub-seven-call/retained/single-pass/TASK.json b/research/shared-hub-seven-call/retained/single-pass/TASK.json new file mode 100644 index 0000000000..9a72a72cdf --- /dev/null +++ b/research/shared-hub-seven-call/retained/single-pass/TASK.json @@ -0,0 +1,64 @@ +{ + "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": "Classify diagonal endpoints in six nonzero single-pass calls on the fixed shared-hub projector pool, without a relation cap.", + "scope_change_reason": "PR #7711 leaves larger relation budgets open. This is a word obstruction on a named abelian alphabet rather than a construction in a new alphabet.", + "bottleneck_link": "Scoped BIT rank obstruction. Allows a fifth relation in the fixed six-call alphabet, where the total target rank remains bounded by total paid rank.", + "budget_minutes": 60, + "stop_rule": "Stop after proving or falsifying six-call separation and replaying the finite five-relation check.", + "outcome": "completed", + "evidence": "README.md proves block separation and exact labels. verify.py checks 527040 full Laurent matrices and 792 diagonal endpoints under CPython 3.12.15.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Can a seven-call word with five relations interleave the triples with all labels nonzero and its repeated projector separated by an opposite-triple call?", + "why_it_matters": "Seven calls are the first length allowing cancellation within one type while preserving all six types.", + "first_step": "Repeat one A type and compare the two initial coefficients in the private and mixed degrees.", + "blocked_by": "The private-square equations constrain the sum of those two initial forms, leaving their individual mixed-order contributions unresolved." + } + ] +} diff --git a/research/shared-hub-seven-call/retained/single-pass/VERIFY.json b/research/shared-hub-seven-call/retained/single-pass/VERIFY.json new file mode 100644 index 0000000000..3a99090702 --- /dev/null +++ b/research/shared-hub-seven-call/retained/single-pass/VERIFY.json @@ -0,0 +1,21 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 45, + "checks": "Full Laurent endpoints for every order and 732 exact tuples at five relations, with signed and higher-order controls." + } + ] +} diff --git a/research/shared-hub-seven-call/retained/single-pass/verify.py b/research/shared-hub-seven-call/retained/single-pass/verify.py new file mode 100644 index 0000000000..e4ccba0722 --- /dev/null +++ b/research/shared-hub-seven-call/retained/single-pass/verify.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python3 +"""Multiply the six shared-hub factors over F2[z,z^-1] on fixed finite domains.""" + +from itertools import permutations, product + + +PROJECTORS = ((6, 5), (5, 6), (7, 7), (12, 20), (20, 12), (28, 28)) +WIDTH = 5 +TRIPLE_SIZE = 3 + + +def coordinate_sets() -> tuple[tuple[tuple[int, ...], tuple[int, ...]], ...]: + return tuple( + ( + tuple(row for row in range(WIDTH) if image & (1 << row)), + tuple(column for column in range(WIDTH) if covector & (1 << column)), + ) + for image, covector in PROJECTORS + ) + + +def check_labels( + labels: tuple[int, ...], + orders: tuple[tuple[tuple[int, ...], bool], ...], + supports: tuple[tuple[tuple[int, ...], tuple[int, ...]], ...], +) -> int: + offset = sum(-label for label in labels if label < 0) + one = 1 << offset + diagonal_target = (labels[0], labels[0], labels[0] + labels[3], labels[3], labels[3]) + equal_within_triples = labels[0] == labels[1] == labels[2] and labels[3] == labels[4] == labels[5] + diagonal_cases = 0 + for order, two_blocks in orders: + rows = [[one if i == j else 0 for j in range(WIDTH)] for i in range(WIDTH)] + for index in order: + image, covector = supports[index] + exponent = labels[index] + for column in range(WIDTH): + donor = 0 + for row in covector: + donor ^= rows[row][column] + shifted = donor << exponent if exponent > 0 else donor >> -exponent + if exponent < 0 and (shifted << -exponent) != donor: + raise ValueError('Laurent shift lost a coefficient') + delta = shifted ^ donor + for row in image: + rows[row][column] ^= delta + diagonal = all(rows[i][j] == 0 for i in range(WIDTH) for j in range(WIDTH) if i != j) + if diagonal != (two_blocks and equal_within_triples): + raise ValueError(f'unexpected diagonal status at labels={labels}, order={order}') + if diagonal: + actual = tuple(rows[i][i] for i in range(WIDTH)) + expected = tuple(1 << (offset + label) for label in diagonal_target) + if actual != expected: + raise ValueError(f'incorrect diagonal at labels={labels}, order={order}') + diagonal_cases += 1 + return diagonal_cases + + +def main() -> None: + supports = coordinate_sets() + orders = tuple( + (order, all(label < TRIPLE_SIZE for label in order[:TRIPLE_SIZE]) + or all(label >= TRIPLE_SIZE for label in order[:TRIPLE_SIZE])) + for order in permutations(range(len(PROJECTORS))) + ) + labels_to_check = tuple(product((-2, 1, 2), repeat=len(PROJECTORS))) + ( + (-8, -8, -8, 16, 16, 16), + (8, 8, 8, -8, -8, -8), + (4, 4, -4, 1, 1, 1), + ) + diagonal_cases = sum(check_labels(labels, orders, supports) for labels in labels_to_check) + cases = len(labels_to_check) * len(orders) + print(f'PASS_SHARED_HUB_SINGLE_PASS cases={cases} diagonal={diagonal_cases}') + + +if __name__ == '__main__': + main() diff --git a/research/shared-hub-seven-call/verify.py b/research/shared-hub-seven-call/verify.py new file mode 100644 index 0000000000..fc6f89d88b --- /dev/null +++ b/research/shared-hub-seven-call/verify.py @@ -0,0 +1,380 @@ +"""Check seven shared-hub calls and the two exceptional proof cases. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from hashlib import sha1, sha256 +from itertools import permutations, product +import json +from math import factorial, gcd +from pathlib import Path +import subprocess +import sys + +ROOT = Path(__file__).resolve().parent +PAIRS = ((6, 5), (5, 6), (7, 7), (12, 20), (20, 12), (28, 28)) +SUPPORTS = tuple((tuple(i for i in range(5) if u >> i & 1), + tuple(i for i in range(5) if v >> i & 1)) for u, v in PAIRS) +ORDERS = tuple(permutations(range(7))) +# S, T and X; X and S-X are the two calls of the repeated type. +CASES = ( + ('S', (2, 0), (0, 1), (1, 0)), + ('T', (1, 0), (0, 2), (0, 1)), + ('X', (1, 0), (0, 1), (2, 0)), + ('S+T', (1, 0), (1, 2), (0, 1)), + ('S+X', (1, 0), (0, 1), (1, 2)), + ('T+X', (1, 0), (0, 1), (0, 1)), + ('S+T+X', (1, 0), (0, 1), (1, 1)), + ('rank-one-1', (1, 0), (1, 0), (2, 0)), + ('rank-one-2', (2, 0), (1, 0), (1, 0)), + ('rank-one-3', (1, 0), (2, 0), (2, 0)), + ('rank-one-4', (4, 0), (2, 0), (1, 0)), + ('rank-one-5', (2, 0), (4, 0), (1, 0)), + ('rank-one-6', (1, 0), (-1, 0), (2, 0)), +) + + +def require(value, message): + if not value: + raise ArithmeticError(message) + + +def add(a, b): + return tuple(x + y for x, y in zip(a, b)) + + +def parity(a): + return (a[0] & 1) | ((a[1] & 1) << 1) + + +def quadratic(a, b): + return ((a & b & 1) | ((((a & 1) * (b >> 1)) ^ + ((a >> 1) * (b & 1))) << 1) | ((a & b & 2) << 1)) + + +def types_for(repeated): + side = 0 if repeated < 3 else 3 + other = tuple(i for i in range(side, side + 3) if i != repeated) + opposite = tuple(i for i in range(6) if i // 3 != repeated // 3) + return (repeated, repeated, *other, *opposite) + + +def separated(order): + first, last = sorted((order.index(0), order.index(1))) + return any(call >= 4 for call in order[first + 1:last]) + + +def two_blocks(order): + return set(order[:4]) == set(range(4)) or set(order[:3]) == {4, 5, 6} + + +def cross_coefficients(order, labels, first_mixed=False): + positions = [order.index(i) for i in range(7)] + rows = [] + for calls in ((0, 1), (2,), (3,)): + for b in (4, 5, 6): + value = 0 + for a in calls: + if positions[b] < positions[a]: + value ^= labels[a] if first_mixed else quadratic(labels[a], labels[b]) + rows.append(value) + return rows + + +def check_leading_cases(): + records = [] + for f1, f2 in ((1, 1), (1, 2), (0, 1), (1, 0)): + labels = (f1, f2, f1 ^ f2, f1 ^ f2, 1, 1, 1) + passing = separated_pass = 0 + for order in ORDERS: + values = cross_coefficients(order, labels, True) + if len(set(values)) != 1: + continue + passing += 1 + separated_pass += separated(order) + if not f1 or not f2: + zero = 0 if f1 == 0 else 1 + core = tuple(i for i in order if i != zero) + require(set(core[:3]) == (set(range(4)) - {zero}) or + set(core[:3]) == {4, 5, 6}, 'visible core has two blocks') + else: + require(not separated(order), 'leading forms admit a separator') + records.append({'leading_forms': [f1, f2], 'passing_orders': passing, + 'separated_passing_orders': separated_pass}) + # Every ordered pair of vectors has one of the four stated relation types. + for f1, f2 in product(range(8), repeat=2): + if not (f1 or f2): + continue + for alpha, beta, epsilon in product(range(2), repeat=3): + if (f1 * alpha) ^ (f2 * beta) != (f1 ^ f2) * epsilon: + continue + if f1 and f2: + require(alpha == beta, 'all coefficient relations') + if f1 != f2: + require(alpha == epsilon, 'independent coefficient relations') + else: + require((alpha if f1 else beta) == epsilon, 'visible coefficient relation') + return {'canonical_cases': records, 'coefficient_pairs': 63, + 'indicator_cases': 504, 'order_cases': 4 * len(ORDERS)} + + +def integer_matrix(pair): + u, v = pair + return sum(((u >> i & 1) * (v >> j & 1)) << (5 * i + j) + for i in range(5) for j in range(5)) + + +def matrix_product(a, b): + return sum((sum(((a >> (5 * i + k)) & (b >> (5 * k + j)) & 1) + for k in range(5)) % 2) << (5 * i + j) + for i in range(5) for j in range(5)) + + +def off(a): + return a & ~sum(1 << (6 * i) for i in range(5)) + + +def span_basis(values): + basis = {} + for value in values: + while value: + pivot = value.bit_length() - 1 + if pivot not in basis: + basis[pivot] = value + break + value ^= basis[pivot] + return basis + + +def remainder(value, basis): + for pivot in sorted(basis, reverse=True): + if value >> pivot & 1: + value ^= basis[pivot] + return value + + +def check_pool(): + matrices = list(map(integer_matrix, PAIRS)) + for i, matrix in enumerate(matrices): + require(matrix_product(matrix, matrix) == matrix, 'idempotent') + for j in range(6): + if i != j and i // 3 == j // 3: + require(matrix_product(matrix, matrices[j]) == 0, 'orthogonal triple') + basis = span_basis(map(off, matrices)) + require(len(basis) == 4, 'pattern rank') + commutators = [remainder(off(matrix_product(a, b) ^ matrix_product(b, a)), basis) + for a in matrices[:3] for b in matrices[3:]] + zeros = [] + for mask in range(1, 512): + value = 0 + for i, matrix in enumerate(commutators): + if mask >> i & 1: + value ^= matrix + if value == 0: + zeros.append(mask) + require(zeros == [511], 'rank-eight commutator quotient') + reflection = lambda a: sum((a >> i & 1) << (4 - i) for i in range(5)) + require(tuple((reflection(u), reflection(v)) for u, v in PAIRS[:3]) == PAIRS[3:], + 'reflection exchanges the triples') + return {'off_pattern_rank': 4, 'commutator_rank': 8, 'subset_checks': 511} + + +def full_product(order, types, vectors): + radix = 2 * sum(abs(a) for a, _ in vectors) + 1 + labels = [a + radix * b for a, b in vectors] + offset = sum(-a for a in labels if a < 0) + one = 1 << offset + rows = [[one if i == j else 0 for j in range(5)] for i in range(5)] + for call in order: + image, covector = SUPPORTS[types[call]] + exponent = labels[call] + for column in range(5): + donor = 0 + for row in covector: + donor ^= rows[row][column] + shifted = donor << exponent if exponent >= 0 else donor >> -exponent + require(exponent >= 0 or (shifted << -exponent) == donor, 'Laurent shift') + delta = donor ^ shifted + for row in image: + rows[row][column] ^= delta + return rows, radix, offset + + +def sparse_product(order, types, vectors): + one = {(0, 0)} + rows = [[one.copy() if i == j else set() for j in range(5)] for i in range(5)] + for call in order: + u, v = PAIRS[types[call]] + factor = [[({(0, 0)} if i == j else set()) ^ + ({(0, 0), vectors[call]} if (u >> i & v >> j & 1) else set()) + for j in range(5)] for i in range(5)] + result = [[set() for _ in range(5)] for _ in range(5)] + for i, j, k in product(range(5), repeat=3): + for a in factor[i][k]: + for b in rows[k][j]: + value = add(a, b) + if value in result[i][j]: + result[i][j].remove(value) + else: + result[i][j].add(value) + rows = result + return rows + + +def check_full_words(): + records = [] + sparse_checks = 0 + for repeated in range(6): + types = types_for(repeated) + for name, s, t, x in CASES: + vectors = (x, add(s, tuple(-v for v in x)), s, s, t, t, t) + require(all(v != (0, 0) for v in vectors), 'nonzero labels') + minors = [abs(a[0] * b[1] - a[1] * b[0]) for a in vectors for b in vectors] + paid_rank = 2 if any(minors) else 1 + if paid_rank == 2: + require(gcd(*minors) == 1, 'paid-generated Z2 and saturated kernel') + else: + require(all(b == 0 for _, b in vectors) and gcd(*(abs(a) for a, _ in vectors)) == 1, + 'paid-generated Z and saturated kernel') + targets = (s, s, add(s, t), t, t) if repeated < 3 else (t, t, add(s, t), s, s) + passed = 0 + digest = sha256() + for index, order in enumerate(ORDERS): + rows, radix, offset = full_product(order, types, vectors) + diagonal = all(rows[i][j] == 0 for i in range(5) for j in range(5) if i != j) + require(diagonal == two_blocks(order), 'full seven-call endpoint') + if diagonal: + require([rows[i][i] for i in range(5)] == + [1 << (offset + a + radix * b) for a, b in targets], + 'exact hub and private targets') + passed += 1 + digest.update(json.dumps(rows, separators=(',', ':')).encode() + b'\n') + if index in (0, 39, 101, 777, 2048, 5039): + sparse = sparse_product(order, types, vectors) + encoded = [[sum(1 << (offset + a + radix * b) for a, b in entry) + for entry in row] for row in sparse] + require(rows == encoded, 'independent bivariate multiplication') + sparse_checks += 1 + require(passed == 2 * factorial(4) * factorial(3), 'block count') + records.append({'repeated_type': repeated, 'fixture': name, 'paid_rank': paid_rank, 'relations': 7 - paid_rank, 'orders': len(ORDERS), + 'diagonal': passed, 'full_matrix_sha256': digest.hexdigest()}) + return {'cases': records, 'sparse_products': sparse_checks, + 'words': len(records) * len(ORDERS), 'diagonal': sum(r['diagonal'] for r in records)} + + +def pmul(a, b): + result = set() + for x in a: + for y in b: + value = x + y + if value in result: + result.remove(value) + else: + result.add(value) + return result + + +def pmat(a, b): + result = [[set() for _ in range(3)] for _ in range(3)] + for i, j, k in product(range(3), repeat=3): + result[i][j] ^= pmul(a[i][k], b[k][j]) + return result + + +def factor_sum(coefficients): + return [ + [({0} if i == j else set()) ^ + xor_all(coefficient if (u >> i & v >> j & 1) else set() + for coefficient, (u, v) in zip(coefficients, PAIRS[:3])) + for j in range(3)] for i in range(3)] + + +def xor_all(values): + result = set() + for value in values: + result ^= value + return result + + +def check_exact_cut(): + one = {0} + a, b, c, d, t = ({1 << (4 * i)} for i in range(5)) + scale = [[one if i == j and i < 2 else t if i == j else set() + for j in range(3)] for i in range(3)] + + def word(repeated, coefficients): + extra = [set(), set(), set()] + extra[repeated] = d + return pmat(factor_sum(extra), pmat(scale, factor_sum(coefficients))) + + initial = word(0, (a, b, c)) + require(initial[0][1] == initial[0][2] == b ^ c, 'A0 initial private row') + w = word(0, (a, b, b)) + require(w[1][0] ^ w[2][0] == pmul(one ^ t, a ^ b), 'A0 cut elimination') + require(word(0, (a, a, a))[1][2] == pmul(pmul(d, t), one ^ a), 'A0 final factor') + swapped = word(1, (b, a, b)) + require(all(swapped[i][j] == w[1 - i if i < 2 else 2][1 - j if j < 2 else 2] + for i in range(3) for j in range(3)), 'A1 private permutation') + general = word(2, (a, b, c)) + require(general[0][2] ^ general[1][2] == a ^ b, 'A2 private difference') + w = word(2, (a, a, c)) + require(w[0][1] ^ w[0][2] == pmul(pmul(d, one ^ a), one ^ t), 'A2 final factor') + # Every nonempty proper B prefix misses at least one coefficient. + prefix_masks = [] + for mask in range(1, 7): + patterns = [(v >> 3) & 3 for i, (_, v) in enumerate(PAIRS[3:]) if mask >> i & 1] + rank = len(span_basis(patterns)) + require(rank == mask.bit_count(), 'proper prefix cut is injective') + prefix_masks.append({'mask': mask, 'rank': rank}) + return {'symbolic_identities': 6, 'proper_prefix_masks': prefix_masks} + + +def controls(): + _, s, t, x = CASES[2] + vectors = (x, add(s, tuple(-v for v in x)), s, s, t, t, t) + order = (1, 2, 3, 4, 0, 5, 6) + values = cross_coefficients(order, tuple(map(parity, vectors))) + require(len(set(values)) == 1 and separated(order), 'even repeated label evades degree two') + rows, _, _ = full_product(order, types_for(0), vectors) + require(any(rows[i][j] for i in range(5) for j in range(5) if i != j), 'exact cut detects separator') + labels = list(vectors) + labels[2] = add(labels[2], (2, 0)) + require(tuple(map(parity, labels)) == tuple(map(parity, vectors)), 'even mutation parity') + rows, _, _ = full_product(tuple(range(7)), types_for(0), labels) + require(any(rows[i][j] for i in range(5) for j in range(5) if i != j), 'even total mutation') + rows, radix, offset = full_product(tuple(range(7)), types_for(0), vectors) + require(rows[2][2] != 1 << (offset + s[0] + radix * s[1]), 'missing hub contribution') + return ['even repeated separator', 'even type-total mutation', 'missing hub target'] + + +def source_replay(): + pins = json.loads((ROOT / 'SOURCE-PINS.json').read_text())['sources'] + for pin in pins: + data = (ROOT / pin['retained']).read_bytes() + require(sha256(data).hexdigest() == pin['sha256'], 'retained SHA256') + require(sha1(b'blob ' + str(len(data)).encode() + b'\0' + data).hexdigest() + == pin['git_blob'], 'retained Git blob') + command = [sys.executable, '-W', 'error', *(['-O'] if sys.flags.optimize else []), + '-B', str(ROOT / 'retained/single-pass/verify.py')] + result = subprocess.run(command, check=True, capture_output=True, text=True, timeout=60) + require('PASS_SHARED_HUB_SINGLE_PASS cases=527040 diagonal=792' in result.stdout, + 'unchanged source replay') + return len(pins) + + +def collect(): + require(len(ORDERS) == factorial(7) and len(set(ORDERS)) == factorial(7), 'order coverage') + return {'source_files': source_replay(), 'pool': check_pool(), 'leading_cases': check_leading_cases(), + 'exact_cut': check_exact_cut(), 'full_words': check_full_words(), 'controls': controls()} + + +def main(): + actual = collect() + require(actual == json.loads((ROOT / 'RESULT.json').read_text()), 'saved certificate') + print('PASS_SHARED_HUB_SEVEN_CALL') + print('4 complete leading-form cases; 20160 order checks; 511 commutator subsets') + print('393120 full Laurent words; 22464 diagonal endpoints; 468 independent sparse products') + print('All three repeated projector types and both triples; exact exceptional cuts and controls') + + +if __name__ == '__main__': + main()