diff --git a/research/extremal-core-word-obstruction/CREDITS.md b/research/extremal-core-word-obstruction/CREDITS.md new file mode 100644 index 0000000000..60013b5978 --- /dev/null +++ b/research/extremal-core-word-obstruction/CREDITS.md @@ -0,0 +1,41 @@ +# 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. + +- CubeJerry's [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), + head `685457252b51b9c7932ece363365bdf0b12c9c31`, supplies the + five-dimensional restricted bridge-cancellation theorem and its + associated-graded, star-quotient and chronology arguments. Read the + [exact word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md). + Its notice states that the work was prepared for @CubeJerry with + substantial OpenAI assistance. It credits the retained relation and + augmentation framework; that lineage is not relabelled as new here. +- The full Laurent recurrence is adapted from the same source's + [independent_five_word.py](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/independent_five_word.py). + The present verifier generalizes its dimension, exponent tuples and + ambient projector factors. This adapted code is not a separately + authored review. The prior k=3 case and wrong-sign bridge control + retain their original credit. +- Ali Romman's [PR #7693](https://github.com/CrocSwap/integer-mult-bounds/pull/7693), + head `dab13e010216570a00e22490b379b31b610f2890`, supplies the all-width + classification and unique ambient link. Read its + [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/dab13e010216570a00e22490b379b31b610f2890/research/edge-extremal-pool-classification/PROOF.md). + That theorem uses the matching bound from + [PR #7692](https://github.com/CrocSwap/integer-mult-bounds/pull/7692), + head `c2870a38841f515db7203a0761cd77f014f7fb7a`, + [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/c2870a38841f515db7203a0761cd77f014f7fb7a/research/edge-matching-image-bound/PROOF.md). + Both are explicit mathematical dependencies; their complete packages + are not rerun here. + +The new result is the all-k, all-length word obstruction and its +full-ambient bridge deletion for this exact extremal alphabet. +The common degree-one kernel, five-core argument and known positive +pool family remain prior work. The new one-extra-relation control +shows the limit of the chronology statement without asserting a saving. + +No external file is read at runtime. SOURCES.json binds the selected +state and task catalogue on main for provenance. Those records are +not mathematical premises. All required proof dependencies are linked +at their exact public commits. diff --git a/research/extremal-core-word-obstruction/PROOF.md b/research/extremal-core-word-obstruction/PROOF.md new file mode 100644 index 0000000000..68786c13e0 --- /dev/null +++ b/research/extremal-core-word-obstruction/PROOF.md @@ -0,0 +1,273 @@ +# Extremal irreducible cores cannot save paid rank at the relation budget + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +This is an all-length scalar-word proof with finite exact checks. +Independent human and formal-kernel review are unclaimed. + +## 1. Exact model and result + +Let H be the subgroup generated by finitely many paid exponents A_j +in a torsion-free abelian group. Thus H is a finite-rank free abelian +group. Work over `R=F2[H]`, and write [A] for its monomial with exponent A. +The saturated relation lattice is + +``` +L = kernel(Z^m -> H), e_j -> A_j. +``` + +On W scalar coordinates, consider a word of calls +`I+([A_j]-1)P_j`. Each P_j is a binary rank-one idempotent with nonzero +off-diagonal pattern. Coordinate projectors are excluded. The span +of the occurring patterns has dimension `k>=2`. Their joint image V +has dimension `2k-1`, and the occurring projectors act irreducibly on V. +Suppose `rank(L)<=k` and the full ambient endpoint is diagonal monomial. + +**Theorem.** The occurring alphabet is the complete edge-pair-and-link +family in Section 2. All link calls lie in one consecutive block. +Their exponent sum is zero. Deleting that block preserves the full +ambient linear map, including every spectator-input column. Each +original target exponent is a sum of a disjoint subset of paid +exponents. If the exponents are rational address matrices, the sum +of target ranks is at most the sum of paid ranks. + +Word length, ambient width and address ranks are unrestricted within +these hypotheses. This is not a theorem for coordinate calls, reducible +or smaller joint images, or a larger relation budget. No native +supplier, complete multiplier invoice or new kappa is supplied. + +CubeJerry's [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), +[exact word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md), +already proves the five-dimensional restricted bridge result. The +argument below extends its degree-two and chronology proof to every k. +The full ambient deletion uses the later ambient-link uniqueness in +Ali Romman's [PR #7693](https://github.com/CrocSwap/integer-mult-bounds/pull/7693), +[exact classification](https://github.com/aliromman/integer-mult-bounds/blob/dab13e010216570a00e22490b379b31b610f2890/research/edge-extremal-pool-classification/PROOF.md). +It is stronger than deleting calls only in a restricted core, and +is asserted only for the full alphabet specified here. + +## 2. Forced alphabet and the endpoint after shear + +Use the cited all-width classification, which depends on the matching +theorem in [PR #7692](https://github.com/CrocSwap/integer-mult-bounds/pull/7692), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/c2870a38841f515db7203a0761cd77f014f7fb7a/research/edge-matching-image-bound/PROOF.md). +Put `t=k-1`. After a coordinate permutation the occurring projectors are + +``` +P_i = e_a_i(e_a_i+e_b_i)^T, +Q_i = (e_a_i+e_b_i)e_b_i^T, i=1,...,t, +B = (h_x+a)(h_y+b)^T, +h_x = sum_i e_b_i, h_y = sum_i e_a_i, +``` + +with disjoint edge endpoints, fresh a,b and `a dot b=1`. Every one of +these `2t+1` types occurs, because this is the set of actual word types. +The classification forces the entire set to be complete. In particular, +all B calls use the same ambient matrix, not merely the same restriction. + +Let E be the coordinate span of the endpoints. Then +`V=E direct-sum F2*a`. The shear +`S=product_i(I+E_a_i,b_i)` acts only on E. In the basis of E and a, +it sends the restricted alphabet to the first 2t coordinate projectors +and `J_n`, the all-one matrix of odd size `n=2t+1`. + +The full diagonal endpoint preserves V after extension of scalars to R. +Its action on a has fresh support only, so lies in R*a. All coordinates +in the support of a therefore have the same endpoint monomial. Before +the shear, the endpoint on E and a is diagonal monomial. After the +shear it can have off-diagonal entries at the t directed edge positions. +These positions are allowed throughout the proof. They must not be +silently assumed zero. + +## 3. The entire linear relation kernel + +Introduce one independent Laurent variable T_j for each call, with +augmentation variable `u_j=T_j-1`. The quotient onto the paid-generated +group H induces the linear map + +``` +F2^m -> H/2H, u_j -> A_j mod 2H. +``` + +Its kernel is L/2L. Indeed, the exact sequence with quotient H splits +over the integers because H is free. Tensoring with F2 keeps it exact. +Thus the kernel dimension is rank(L). An arbitrary larger ambient +exponent group cannot replace H in this step: its mod-two map can +lose the rank of paid generators that are even in that larger group. + +The associated graded algebra of R at its augmentation ideal is +`Sym(H/2H)`. Choose a basis of H: R is a Laurent polynomial algebra, +and each basis monomial minus one gives an independent degree-one +generator. This proves the stated associated-graded description. + +The t edge patterns and the bridge pattern are independent. At first +order the original diagonal endpoint therefore puts the following +k forms in the linear kernel: + +``` +L_B = sum of u_j over bridge calls, +M_i = sum of u_j over calls of P_i or Q_i, i=1,...,t. +``` + +Their supports are nonempty and disjoint. They are independent. Hence +`rank(L)=k`, and these forms give the entire linear kernel. The ideal +of the induced map between symmetric algebras is exactly +`(L_B,M_1,...,M_t)`. This is an associated-graded assertion; the actual +Laurent relation ideal need not be linear. + +## 4. The general star quotient + +In the sheared n-dimensional core, quotient the off-diagonal matrix +space by + +``` +Q = span(off(J_n), E_a_1,b_1, ..., E_a_t,b_t). +``` + +The universal constant and linear word terms vanish in this quotient +before exponent substitution. Consequently nonlinear substitution +terms cannot alter its degree-two image. Only the linear map from +Section 3 acts on that degree-two term. + +For each old coordinate r, define +`K_r=off(J_n E_rr+E_rr J_n)`. The 2t matrices K_r are independent +modulo Q. Suppose their linear combination equals lambda times +`off(J_n)` plus allowed edges. Entries in the fresh row and old +column r force each coefficient to be lambda. At the reverse position +`(b_i,a_i)`, which is not an allowed edge, the left side is +`lambda+lambda=0`, so lambda is zero. All coefficients are zero. +This argument works even for t=1. It does not treat the fresh-coordinate +star as an additional independent matrix. + +Bridge/bridge quadratic products are multiples of J_n, since n is odd. +Products of coordinate projectors are diagonal. Only mixed products +remain. For an old coordinate type r put + +``` +q_r = sum over calls j of type r + u_j times (sum of bridge variables before call j). +``` + +Modulo L_B, bridge prefix and suffix sums are equal. The degree-two +term in the quotient is therefore the sum of `K_r q_r`. Independence +of the K_r implies that every q_r lies in +`(L_B,M_1,...,M_t)`. + +## 5. Chronology forces a single bridge block + +Eliminate the last bridge variable by L_B=0. Let qbar_r be the resulting +polynomial. It uses only the first h-1 bridge variables and call +variables of coordinate type r, where h is the number of bridge calls. +It belongs to `(M_1,...,M_t)`. + +This polynomial subring meets that ideal only in zero. In the pair +that contains r, choose a call variable of the partner type, which +exists because every type occurs. In each other pair choose any call +variable. Solve M_i=0 for these t chosen variables. This substitution +kills every M_i and fixes every variable in qbar_r. Hence qbar_r=0. + +Every coordinate call has its own universal variable. Its coefficient +in qbar_r is its bridge prefix after elimination. A proper nonempty +prefix is a nonzero linear form in the first h-1 bridge variables. +It is zero only before the first bridge or after the last bridge. +Thus no coordinate call occurs strictly between the first and last +bridge calls. All bridge calls are consecutive. At h=1 this conclusion +has an empty interior and is immediate. + +Combine the block on the restricted core. With Z the sum of its paid +exponents, the sheared word is + +``` +D_left [I+([Z]-1)J_n] D_right, +``` + +where both surrounding matrices are invertible monomial diagonals. +A fresh-row/old-column entry is an invertible monomial times `[Z]-1`. +This is outside the allowed endpoint edge positions, so it is zero. +Distinct exponents index distinct group-algebra monomials; hence Z=0. + +## 6. Full ambient deletion and the rank invoice + +The original ambient B is a single idempotent. For any A,C in H, + +``` +[I+([A]-1)B][I+([C]-1)B] = I+([A+C]-1)B. +``` + +The consecutive bridge block therefore equals the ambient identity +when Z=0. Its deletion preserves every input column, including dirty +spectator columns outside V. This conclusion uses ambient uniqueness; +it would not follow merely from identical restrictions on V. + +All remaining projectors act only on E. In the sheared basis, old +coordinate r has diagonal label equal to the sum of exponents of +calls of that type. All fresh and other spectator coordinates have +label zero. Undoing S creates the edge entry `d_a_i+d_b_i`. Original +diagonality forces these monomials to agree, so the endpoint is the +same diagonal before and after S. + +Assign to original coordinate r the paid calls of its corresponding +old projector type. Assign the empty subset to every other coordinate. +These subsets are disjoint and give all target exponents exactly. +For rational address matrices, rank subadditivity on each subset gives + +``` +sum_r rank(target_r) + <= sum over nonbridge calls j rank(A_j) + <= sum over all paid calls j rank(A_j). +``` + +Bridge calls remain paid; their deletion is an endpoint identity, not +a claim that they cost nothing in the original invoice. No saving +in total rational target rank is possible in this class. + +## 7. Exact checks and hypothesis controls + +The verifier checks the star-quotient ranks for t=1 through 20. It +also checks that the fresh star is dependent. It computes degree-two +terms from ordered matrix products and substituted linear exponent +vectors for 88748 type orders in eleven stated domains. These domains +have one call of each old type, one through four bridges for t=1,2, +and one through three bridges for t=3. Exactly the orders with one +consecutive bridge block pass. Bridge positions are not separately +labelled permutations; their exponents are assigned in chronological +order. Each model has exactly t+1 saturated relations, and its listed +paid exponents generate the stated free exponent group. + +Separate full Laurent products check all 20532 type orders with two +bridges for t=1,2,3. Exactly 5166 have the expected diagonal endpoint; +every other word has a forbidden off-edge entry. The t=2 case is a +prior five-core control, not a new result. The recurrence is adapted +with credit from the source's +[Laurent checker](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/independent_five_word.py). +This adapted implementation is not a separately authored review. + +Ten full ambient fixtures use nonsymmetric fresh factors `(3,5)`, +two unused coordinates, t=1,2,3,4,6 and two or three bridge calls. +All full matrix coefficients agree before and after deleting the +whole bridge block. Omitting just one bridge changes an explicit +dirty-spectator column outside V. These checks do not project away +the spectator state. + +A wrong-sign bridge control has the same linear kernel and passes +the degree-two quotient, but the full Laurent endpoint is not diagonal. +Thus the exact endpoint step cannot be replaced by a quadratic test. +With just one extra relation, an exactly diagonal word can contain a +cancelling coordinate excursion inside two separated bridge calls. +This defeats literal chronology beyond the stated budget; it is not +a rank-saving counterexample. A separate even-generator control shows +why the paid-generated group is needed for the parity kernel. + +Finite checks corroborate the written proof and do not prove all +lengths. Full predecessor package replays, selected cold replay, +Lean and Docker were not run. No coordinate-call split, arbitrary +other alphabet, native realization, rounding contract, complete +multiplier or improvement in kappa is claimed. The selected frontier +and all five inherited assumptions remain unchanged. + +## Open next questions + +Can a reducible or subextremal image give a legal saving at the same +relation budget, or can an explicitly larger relation budget support +a saving? First give one exact scalar alphabet and its complete paid +and target invoice. The one-extra-relation control only removes the +chronology obstruction; it supplies no saving or native interface. diff --git a/research/extremal-core-word-obstruction/README.md b/research/extremal-core-word-obstruction/README.md new file mode 100644 index 0000000000..fad36cc953 --- /dev/null +++ b/research/extremal-core-word-obstruction/README.md @@ -0,0 +1,65 @@ +# A word obstruction for every extremal irreducible binary core + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. + +Consider binary scalar calls `I+([A_j]-1)P_j` over the paid-generated +torsion-free exponent group. Suppose the occurring projectors are +noncoordinate rank-one idempotents, their pattern dimension is `k>=2`, +their joint image is irreducible of dimension `2k-1`, their saturated +exponent relation rank is at most k, and the full ambient endpoint is +diagonal monomial. + +Then all bridge calls lie in one consecutive block and their exponent +sum is zero. Deleting that block preserves the full ambient operator, +including spectator-input columns. The 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 proof extends the prior five-core +restricted word theorem in +[PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782). +The full ambient conclusion uses the unique ambient link from +[PR #7693](https://github.com/CrocSwap/integer-mult-bounds/pull/7693). + +## Reproduce + +Use CPython 3.12 and its standard library, from the repository root. + +```sh +python3.12 -I -W error -B research/extremal-core-word-obstruction/verify.py +python3.12 -I -W error -B -O research/extremal-core-word-obstruction/verify.py +python3.12 -B scripts/research_package.py --package research/extremal-core-word-obstruction +``` + +Expected markers are `PASS_EXTREMAL_CORE_WORD_OBSTRUCTION` and +`PASS_REGISTERED_RESEARCH_PACKAGE`. The verifier compares its result +with the committed receipt and writes no file. + +It checks 88748 degree-two type orders, 20532 full Laurent type orders, +the star quotient through 20 edge pairs, and ten ambient deletion +fixtures with nonsymmetric fresh factors and dirty spectators. Wrong +bridge signs, one extra relation and an incorrect ambient parity +kernel have explicit controls. The finite checks corroborate the +written all-length proof; they do not replace it. + +## Limits + +Coordinate calls, reducible or smaller images, and larger relation +budgets are outside this theorem. The one-extra-relation control +breaks the chronology claim but gives no rank saving. The normal-form +shear is a proof device, not a free physical operation. + +No native supplier, rounding contract, complete multiplier invoice +or new kappa is supplied. The selected frontier and its 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 subextremal or reducible core, or an explicitly larger +relation budget, support a legal saving? Give the exact alphabet and +full paid/target invoice before searching. A scalar word would still +need native realization, dirty-state restoration and a complete cost +and precision account. diff --git a/research/extremal-core-word-obstruction/RESULT.json b/research/extremal-core-word-obstruction/RESULT.json new file mode 100644 index 0000000000..bef94d8bf2 --- /dev/null +++ b/research/extremal-core-word-obstruction/RESULT.json @@ -0,0 +1,460 @@ +{ + "status": "PASS_EXTREMAL_CORE_WORD_OBSTRUCTION", + "scope": "Noncoordinate binary scalar words with irreducible image 2k-1, pattern dimension k>=2, at most k saturated exponent relations and a full diagonal monomial endpoint.", + "star_quotient_checks": [ + { + "edge_pairs": 1, + "width": 3, + "quotient_rank": 2, + "old_star_rank_mod_quotient": 2 + }, + { + "edge_pairs": 2, + "width": 5, + "quotient_rank": 3, + "old_star_rank_mod_quotient": 4 + }, + { + "edge_pairs": 3, + "width": 7, + "quotient_rank": 4, + "old_star_rank_mod_quotient": 6 + }, + { + "edge_pairs": 4, + "width": 9, + "quotient_rank": 5, + "old_star_rank_mod_quotient": 8 + }, + { + "edge_pairs": 5, + "width": 11, + "quotient_rank": 6, + "old_star_rank_mod_quotient": 10 + }, + { + "edge_pairs": 6, + "width": 13, + "quotient_rank": 7, + "old_star_rank_mod_quotient": 12 + }, + { + "edge_pairs": 7, + "width": 15, + "quotient_rank": 8, + "old_star_rank_mod_quotient": 14 + }, + { + "edge_pairs": 8, + "width": 17, + "quotient_rank": 9, + "old_star_rank_mod_quotient": 16 + }, + { + "edge_pairs": 9, + "width": 19, + "quotient_rank": 10, + "old_star_rank_mod_quotient": 18 + }, + { + "edge_pairs": 10, + "width": 21, + "quotient_rank": 11, + "old_star_rank_mod_quotient": 20 + }, + { + "edge_pairs": 11, + "width": 23, + "quotient_rank": 12, + "old_star_rank_mod_quotient": 22 + }, + { + "edge_pairs": 12, + "width": 25, + "quotient_rank": 13, + "old_star_rank_mod_quotient": 24 + }, + { + "edge_pairs": 13, + "width": 27, + "quotient_rank": 14, + "old_star_rank_mod_quotient": 26 + }, + { + "edge_pairs": 14, + "width": 29, + "quotient_rank": 15, + "old_star_rank_mod_quotient": 28 + }, + { + "edge_pairs": 15, + "width": 31, + "quotient_rank": 16, + "old_star_rank_mod_quotient": 30 + }, + { + "edge_pairs": 16, + "width": 33, + "quotient_rank": 17, + "old_star_rank_mod_quotient": 32 + }, + { + "edge_pairs": 17, + "width": 35, + "quotient_rank": 18, + "old_star_rank_mod_quotient": 34 + }, + { + "edge_pairs": 18, + "width": 37, + "quotient_rank": 19, + "old_star_rank_mod_quotient": 36 + }, + { + "edge_pairs": 19, + "width": 39, + "quotient_rank": 20, + "old_star_rank_mod_quotient": 38 + }, + { + "edge_pairs": 20, + "width": 41, + "quotient_rank": 21, + "old_star_rank_mod_quotient": 40 + } + ], + "degree_two_censuses": [ + { + "edge_pairs": 1, + "bridges": 1, + "relation_rank": 2, + "counts": { + "orders": 6, + "passing": 6 + } + }, + { + "edge_pairs": 1, + "bridges": 2, + "relation_rank": 2, + "counts": { + "orders": 12, + "passing": 6 + } + }, + { + "edge_pairs": 1, + "bridges": 3, + "relation_rank": 2, + "counts": { + "orders": 20, + "passing": 6 + } + }, + { + "edge_pairs": 1, + "bridges": 4, + "relation_rank": 2, + "counts": { + "orders": 30, + "passing": 6 + } + }, + { + "edge_pairs": 2, + "bridges": 1, + "relation_rank": 3, + "counts": { + "orders": 120, + "passing": 120 + } + }, + { + "edge_pairs": 2, + "bridges": 2, + "relation_rank": 3, + "counts": { + "orders": 360, + "passing": 120 + } + }, + { + "edge_pairs": 2, + "bridges": 3, + "relation_rank": 3, + "counts": { + "orders": 840, + "passing": 120 + } + }, + { + "edge_pairs": 2, + "bridges": 4, + "relation_rank": 3, + "counts": { + "orders": 1680, + "passing": 120 + } + }, + { + "edge_pairs": 3, + "bridges": 1, + "relation_rank": 4, + "counts": { + "orders": 5040, + "passing": 5040 + } + }, + { + "edge_pairs": 3, + "bridges": 2, + "relation_rank": 4, + "counts": { + "orders": 20160, + "passing": 5040 + } + }, + { + "edge_pairs": 3, + "bridges": 3, + "relation_rank": 4, + "counts": { + "orders": 60480, + "passing": 5040 + } + } + ], + "full_laurent_censuses": [ + { + "edge_pairs": 1, + "width": 3, + "counts": { + "orders": 12, + "diagonal_endpoints": 6 + } + }, + { + "edge_pairs": 2, + "width": 5, + "counts": { + "orders": 360, + "diagonal_endpoints": 120 + } + }, + { + "edge_pairs": 3, + "width": 7, + "counts": { + "orders": 20160, + "diagonal_endpoints": 5040 + } + } + ], + "ambient_deletion_checks": [ + { + "edge_pairs": 1, + "width": 7, + "bridges": 2, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 4, + "endpoint_terms": 2, + "omitted_bridge_error_terms": 6 + }, + { + "edge_pairs": 1, + "width": 7, + "bridges": 3, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 4, + "endpoint_terms": 2, + "omitted_bridge_error_terms": 6 + }, + { + "edge_pairs": 2, + "width": 9, + "bridges": 2, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 6, + "endpoint_terms": 3, + "omitted_bridge_error_terms": 8 + }, + { + "edge_pairs": 2, + "width": 9, + "bridges": 3, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 6, + "endpoint_terms": 3, + "omitted_bridge_error_terms": 8 + }, + { + "edge_pairs": 3, + "width": 11, + "bridges": 2, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 8, + "endpoint_terms": 4, + "omitted_bridge_error_terms": 16 + }, + { + "edge_pairs": 3, + "width": 11, + "bridges": 3, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 8, + "endpoint_terms": 4, + "omitted_bridge_error_terms": 16 + }, + { + "edge_pairs": 4, + "width": 13, + "bridges": 2, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 10, + "endpoint_terms": 5, + "omitted_bridge_error_terms": 18 + }, + { + "edge_pairs": 4, + "width": 13, + "bridges": 3, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 10, + "endpoint_terms": 5, + "omitted_bridge_error_terms": 18 + }, + { + "edge_pairs": 6, + "width": 17, + "bridges": 2, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 14, + "endpoint_terms": 7, + "omitted_bridge_error_terms": 32 + }, + { + "edge_pairs": 6, + "width": 17, + "bridges": 3, + "fresh_image": 3, + "fresh_covector": 5, + "dirty_column_checked": 14, + "endpoint_terms": 7, + "omitted_bridge_error_terms": 32 + } + ], + "boundary_controls": { + "wrong_sign_same_linear_kernel": { + "k": 4, + "relation_rank": 4, + "full_endpoint_rejected": true + }, + "extra_relation_chronology_counterexample": { + "order": [ + 6, + 0, + 0, + 6, + 0, + 1, + 2, + 3, + 4, + 5 + ], + "exponents": [ + [ + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + -1, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0 + ] + ], + "k": 4, + "relation_rank": 5 + }, + "paid_generated_parity_control": { + "rational_rank": 2, + "paid_parity_rank": 2, + "ambient_parity_rank": 0 + } + }, + "limitations": [ + "Uses the pinned all-width extremal classification and the stated associated-graded argument.", + "Coordinate calls, reducible/subextremal images and larger relation budgets are outside the theorem.", + "No native supplier, complete multiplier invoice or new kappa." + ] +} diff --git a/research/extremal-core-word-obstruction/SOURCES.json b/research/extremal-core-word-obstruction/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/extremal-core-word-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/extremal-core-word-obstruction/TASK.json b/research/extremal-core-word-obstruction/TASK.json new file mode 100644 index 0000000000..b8584a0f52 --- /dev/null +++ b/research/extremal-core-word-obstruction/TASK.json @@ -0,0 +1,80 @@ +{ + "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 scalar-word obstruction and full-ambient bridge deletion for irreducible image 2k-1, pattern dimension k>=2, at most k saturated exponent relations and a diagonal monomial endpoint.", + "scope_change_reason": "Use the complete all-k geometry to test legal scalar word chronology and its exact rank invoice. This is a negative word result, not a new native construction.", + "bottleneck_link": "Exclude paid rank saving in every maximal irreducible core at the matching relation budget, before larger word searches.", + "budget_minutes": 60, + "stop_rule": "Stop at the all-length obstruction and exact endpoint controls. Do not infer a theorem for coordinate calls, reducible or smaller images, or larger relation budgets.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; 88748 quadratic type orders, 20532 full Laurent type orders, star quotients through 20 edge pairs and ten full ambient deletion checks.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "Can a specified subextremal or reducible core, or a larger relation budget, support a legal saving?", + "why_it_matters": "The maximal irreducible core cannot save rank at the stated relation budget, but the other classes remain open.", + "first_step": "Specify the exact alphabet and full paid/target invoice before a word search; distinguish the one-extra-relation chronology control from a saving.", + "blocked_by": "No saving word or native interface is supplied." + } + ], + "family_decision": { + "decision": "Move from the completed scalar geometry to a precise negative word theorem; stop at that theorem.", + "sources": "6782@685457252b51b9c7932ece363365bdf0b12c9c31:FIVE-CORE-WORD.md; 7693@dab13e010216570a00e22490b379b31b610f2890; 7692@c2870a38841f515db7203a0761cd77f014f7fb7a", + "evidence_status": "Author-checked written proof using pinned all-width geometry and a restated associated-graded argument, with exact finite corroboration.", + "boundary": "Noncoordinate binary scalar calls over the paid-generated torsion-free group; irreducible image 2k-1, pattern dimension k>=2, relation rank at most k, full diagonal monomial endpoint.", + "obligations": { + "alphabet": "specified", + "relation_budget": "specified and forced tight", + "full_ambient_deletion": "proved", + "disjoint_paid_subsets": "proved", + "native_realization": "not supplied", + "complete_multiplier_invoice": "not supplied" + }, + "alternative": "A larger word search in the classified core would not replace an all-length chronology argument.", + "construction_gate": "No new construction is proposed. A future saving requires a different stated hypothesis, native interface and complete invoice." + } +} diff --git a/research/extremal-core-word-obstruction/VERIFY.json b/research/extremal-core-word-obstruction/VERIFY.json new file mode 100644 index 0000000000..5ca1e06fe3 --- /dev/null +++ b/research/extremal-core-word-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": "Exact star quotient, degree-two chronology, complete Laurent type-order domains, full ambient deletion and wrong-sign/extra-relation/paid-group controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact star quotient, degree-two chronology, complete Laurent type-order domains, full ambient deletion and wrong-sign/extra-relation/paid-group controls." + } + ] +} diff --git a/research/extremal-core-word-obstruction/verify.py b/research/extremal-core-word-obstruction/verify.py new file mode 100644 index 0000000000..ac7202c026 --- /dev/null +++ b/research/extremal-core-word-obstruction/verify.py @@ -0,0 +1,287 @@ +"""Exact scalar-word checks for all extremal irreducible binary cores. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +The Laurent matrix recurrence is adapted from CubeJerry's PR6782 +independent_five_word.py. This adaptation is not an independent review. +See CREDITS.md for the exact source and proof dependencies. +""" + +from collections import Counter +from fractions import Fraction +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 model(t): + n = 2 * t + 1 + ones = (1 << n) - 1 + pairs = [(1 << i, 1 << i) for i in range(2 * t)] + [(ones, ones)] + edge_bits = [1 << ((2 * i) * n + 2 * i + 1) for i in range(t)] + diagonal = identity(n) + quotient = basis([outer(ones, ones, n) & ~diagonal] + edge_bits) + products = {} + for i, p in enumerate(pairs): + for j, q in enumerate(pairs): + product = left_project(p, outer(*q, n), n) & ~diagonal + products[i, j] = reduce_vector(product, quotient) + return n, pairs, quotient, products, diagonal | sum(edge_bits) + + +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 exponents(order, t, h): + r, bridge = t + h - 1, 0 + result = [] + for kind in order: + vector = [0] * r + if kind < 2 * t: + vector[kind // 2] = 1 + else: + if bridge < h - 1: + vector[t + bridge] = 1 + else: + vector[t:] = [-1] * (h - 1) + bridge += 1 + result.append(tuple(vector)) + require(bridge == h, 'bridge count') + return result + + +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 expected_endpoint(t, r, width): + result = {(0,) * r: sum(1 << (i * width + i) for i in range(2 * t, width))} + for i in range(t): + key = tuple(int(j == i) for j in range(r)) + result[key] = (1 << ((2 * i) * width + 2 * i)) | (1 << ((2 * i + 1) * width + 2 * i + 1)) + return result + + +def star_checks(): + result = [] + for t in range(1, 21): + n, pairs, quotient, _, _ = model(t) + diagonal = identity(n) + bridge = outer(*pairs[-1], n) + stars = [(left_project(pairs[i], bridge, n) ^ left_project(pairs[-1], outer(*pairs[i], n), n)) & ~diagonal + for i in range(2 * t)] + require(len(basis((*quotient, *stars))) == t + 1 + 2 * t, 'independent old stars modulo quotient') + fresh = (1 << (2 * t), 1 << (2 * t)) + fresh_star = (left_project(fresh, bridge, n) ^ left_project(pairs[-1], outer(*fresh, n), n)) & ~diagonal + require(len(basis((*quotient, *stars, fresh_star))) == t + 1 + 2 * t, + 'the fresh star is dependent, not an extra independent constraint') + result.append({'edge_pairs': t, 'width': n, 'quotient_rank': len(quotient), 'old_star_rank_mod_quotient': 2 * t}) + return result + + +def degree_two_census(t, h): + _, _, _, products, _ = model(t) + counts = Counter() + for order in orders(t, h): + exps = exponents(order, t, h) + allowed = not quadratic(order, exps, products) + block = consecutive(order, 2 * t) + require(allowed == block, 'exact quadratic chronology criterion') + counts['orders'] += 1 + counts['passing'] += allowed + sample = next(orders(t, h)) + exps = exponents(sample, t, h) + rank = rational_rank(exps) + require(rank == t + h - 1 and len(exps) - rank == t + 1, 'saturated model relation rank') + units = {tuple(int(i == j) for j in range(rank)) for i in range(rank)} + require(units <= set(exps), 'the listed exponents generate the whole stated free group') + return {'edge_pairs': t, 'bridges': h, 'relation_rank': t + 1, 'counts': dict(counts)} + + +def full_word_census(t): + n, pairs, _, _, allowed_entries = model(t) + counts = Counter() + expected = expected_endpoint(t, t + 1, n) + for order in orders(t, 2): + actual = laurent(order, exponents(order, t, 2), pairs, n) + block = consecutive(order, 2 * t) + require((actual == expected) == block, 'full Laurent chronology agrees with the exact endpoint') + if not block: + require(any(matrix & ~allowed_entries for matrix in actual.values()), 'forbidden endpoint entry') + counts['orders'] += 1 + counts['diagonal_endpoints'] += block + return {'edge_pairs': t, 'width': n, 'counts': dict(counts)} + + +def ambient_checks(): + rows = [] + for t in (1, 2, 3, 4, 6): + for h in (2, 3): + width = 2 * t + 5 + old = [(x, y) for i in range(t) for x, y in + [(1 << (2 * i), 3 << (2 * i)), (3 << (2 * i), 1 << (2 * i + 1))]] + hx = sum(1 << (2 * i + 1) for i in range(t)) + hy = sum(1 << (2 * i) for i in range(t)) + link = (hx | (3 << (2 * t)), hy | (5 << (2 * t))) + pairs = old + [link] + order = tuple(range(t)) + (2 * t,) * h + tuple(range(t, 2 * t)) + exps = exponents(order, t, h) + actual = laurent(order, exps, pairs, width) + kept = [(kind, exponent) for kind, exponent in zip(order, exps) if kind != 2 * t] + deleted = laurent([p[0] for p in kept], [p[1] for p in kept], pairs, width) + require(actual == deleted == expected_endpoint(t, t + h - 1, width), 'full ambient deletion, including spectator columns') + omit = order.index(2 * t) + wrong = laurent(order[:omit] + order[omit + 1:], exps[:omit] + exps[omit + 1:], pairs, width) + dirty_column = 2 * t + 2 + changed = {key: wrong.get(key, 0) ^ actual.get(key, 0) for key in wrong.keys() | actual.keys()} + require(any(any(matrix >> (i * width + dirty_column) & 1 for i in range(width)) + for matrix in changed.values()), 'omitted bridge changes a dirty spectator column') + rows.append({'edge_pairs': t, 'width': width, 'bridges': h, + 'fresh_image': 3, 'fresh_covector': 5, 'dirty_column_checked': dirty_column, + 'endpoint_terms': len(actual), 'omitted_bridge_error_terms': sum(bool(v) for v in changed.values())}) + return rows + + +def controls(): + t = 3 + n, pairs, _, products, allowed = model(t) + order = (6, 6, 0, 1, 2, 3, 4, 5) + good = exponents(order, t, 2) + wrong = list(good) + wrong[1] = wrong[0] + require(not quadratic(order, wrong, products), 'wrong bridge sign has the same degree-two quotient') + endpoint = laurent(order, wrong, pairs, n) + require(any(matrix & ~allowed for matrix in endpoint.values()), 'full endpoint rejects a noncancelling bridge') + require(rational_rank(wrong) == 4 and len(wrong) - rational_rank(wrong) == 4, 'wrong-sign relation rank is still k') + # One extra relation permits a cancelling coordinate excursion inside the bridge calls. + order = (6, 0, 0, 6, 0, 1, 2, 3, 4, 5) + unit = lambda i: tuple(int(j == i) for j in range(5)) + neg = lambda row: tuple(-x for x in row) + exps = [unit(3), unit(4), neg(unit(4)), neg(unit(3))] + [unit(i // 2) for i in range(6)] + require(laurent(order, exps, pairs, n) == expected_endpoint(3, 5, n), 'extra-relation word is exactly diagonal') + require(not consecutive(order, 6) and len(exps) - rational_rank(exps) == 5, 'one extra relation defeats literal chronology') + # An ambient exponent basis can give a false parity kernel. + paid_coordinates = [(1, 0), (0, 1)] + ambient_coordinates = [(2, 0), (0, 2)] + parity_rank = lambda rows: len(basis(sum((v % 2) << i for i, v in enumerate(row)) for row in rows)) + require(rational_rank(paid_coordinates) == rational_rank(ambient_coordinates) == 2, + 'the exponent groups have the same rational rank') + require(parity_rank(paid_coordinates) == 2 and parity_rank(ambient_coordinates) == 0, + 'the associated-graded kernel must use the paid-generated group') + return {'wrong_sign_same_linear_kernel': {'k': 4, 'relation_rank': 4, 'full_endpoint_rejected': True}, + 'extra_relation_chronology_counterexample': {'order': order, 'exponents': exps, 'k': 4, 'relation_rank': 5}, + 'paid_generated_parity_control': {'rational_rank': 2, 'paid_parity_rank': 2, 'ambient_parity_rank': 0}} + + +def compute(): + return {'status': 'PASS_EXTREMAL_CORE_WORD_OBSTRUCTION', + 'scope': 'Noncoordinate binary scalar words with irreducible image 2k-1, pattern dimension k>=2, at most k saturated exponent relations and a full diagonal monomial endpoint.', + 'star_quotient_checks': star_checks(), + 'degree_two_censuses': [degree_two_census(t, h) for t, hs in ((1, range(1, 5)), (2, range(1, 5)), (3, range(1, 4))) for h in hs], + 'full_laurent_censuses': [full_word_census(t) for t in (1, 2, 3)], + 'ambient_deletion_checks': ambient_checks(), 'boundary_controls': controls(), + 'limitations': ['Uses the pinned all-width extremal classification and the stated associated-graded argument.', + 'Coordinate calls, reducible/subextremal images and larger relation budgets are outside the theorem.', + 'No native supplier, 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({'quadratic_orders': sum(r['counts']['orders'] for r in actual['degree_two_censuses']), + 'full_laurent_orders': sum(r['counts']['orders'] for r in actual['full_laurent_censuses']), + 'ambient_deletions': len(actual['ambient_deletion_checks'])}, sort_keys=True))