diff --git a/research/odd-e8-direct-sum/NATIVE-LIFT.json b/research/odd-e8-direct-sum/NATIVE-LIFT.json new file mode 100644 index 0000000000..b8d655ef23 --- /dev/null +++ b/research/odd-e8-direct-sum/NATIVE-LIFT.json @@ -0,0 +1,656 @@ +{ + "controls": [ + "omitted_helper_climb", + "reversed_pencil_sign" + ], + "gates": [ + { + "copy_ranks": [ + 14, + 20 + ], + "finite_stages": [ + { + "ambient": 73, + "idle_cap": 51, + "margin_per_port_per_local_call": [ + "-4807193174792963/500000000000000000", + "-384575453983437/40000000000000000" + ], + "stages": 3 + }, + { + "ambient": 121, + "idle_cap": 85, + "margin_per_port_per_local_call": [ + "-1938312556627287/1000000000000000000", + "-969156278313643/500000000000000000" + ], + "stages": 5 + }, + { + "ambient": 169, + "idle_cap": 119, + "margin_per_port_per_local_call": [ + "-43885466351066629/1000000000000000000", + "-10971366587766657/250000000000000000" + ], + "stages": 7 + }, + { + "ambient": 217, + "idle_cap": 153, + "margin_per_port_per_local_call": [ + "-98373444315862769/1000000000000000000", + "-6148340269741423/62500000000000000" + ], + "stages": 9 + }, + { + "ambient": 265, + "idle_cap": 187, + "margin_per_port_per_local_call": [ + "-2449963881526999/15625000000000000", + "-31359537683545587/200000000000000000" + ], + "stages": 11 + }, + { + "ambient": 313, + "idle_cap": 221, + "margin_per_port_per_local_call": [ + "-108201587229285133/500000000000000000", + "-43280634891714053/200000000000000000" + ], + "stages": 13 + }, + { + "ambient": 361, + "idle_cap": 255, + "margin_per_port_per_local_call": [ + "-4314963987920501/15625000000000000", + "-276157695226912063/1000000000000000000" + ], + "stages": 15 + }, + { + "ambient": 409, + "idle_cap": 289, + "margin_per_port_per_local_call": [ + "-335647507938149083/1000000000000000000", + "-167823753969074541/500000000000000000" + ], + "stages": 17 + }, + { + "ambient": 457, + "idle_cap": 323, + "margin_per_port_per_local_call": [ + "-394709416236079571/1000000000000000000", + "-39470941623607957/100000000000000000" + ], + "stages": 19 + }, + { + "ambient": 505, + "idle_cap": 357, + "margin_per_port_per_local_call": [ + "-453289459138476177/1000000000000000000", + "-28330591196154761/62500000000000000" + ], + "stages": 21 + }, + { + "ambient": 553, + "idle_cap": 391, + "margin_per_port_per_local_call": [ + "-511383059043825199/1000000000000000000", + "-255691529521912599/500000000000000000" + ], + "stages": 23 + }, + { + "ambient": 601, + "idle_cap": 424, + "margin_per_port_per_local_call": [ + "-143174048381176309/250000000000000000", + "-114539238704941047/200000000000000000" + ], + "stages": 25 + }, + { + "ambient": 649, + "idle_cap": 458, + "margin_per_port_per_local_call": [ + "-314957676534912471/500000000000000000", + "-629915353069824941/1000000000000000000" + ], + "stages": 27 + }, + { + "ambient": 697, + "idle_cap": 492, + "margin_per_port_per_local_call": [ + "-137343577100292423/200000000000000000", + "-343358942750731057/500000000000000000" + ], + "stages": 29 + }, + { + "ambient": 745, + "idle_cap": 526, + "margin_per_port_per_local_call": [ + "-371567494028152953/500000000000000000", + "-148626997611261181/200000000000000000" + ], + "stages": 31 + }, + { + "ambient": 793, + "idle_cap": 560, + "margin_per_port_per_local_call": [ + "-799196233490944943/1000000000000000000", + "-399598116745472471/500000000000000000" + ], + "stages": 33 + }, + { + "ambient": 841, + "idle_cap": 594, + "margin_per_port_per_local_call": [ + "-42746450824797839/50000000000000000", + "-854929016495956779/1000000000000000000" + ], + "stages": 35 + }, + { + "ambient": 889, + "idle_cap": 628, + "margin_per_port_per_local_call": [ + "-910358400151354069/1000000000000000000", + "-227589600037838517/250000000000000000" + ], + "stages": 37 + }, + { + "ambient": 937, + "idle_cap": 662, + "margin_per_port_per_local_call": [ + "-241376790526313977/250000000000000000", + "-965507162105255907/1000000000000000000" + ], + "stages": 39 + }, + { + "ambient": 985, + "idle_cap": 696, + "margin_per_port_per_local_call": [ + "-510197967495431553/500000000000000000", + "-204079186998172621/200000000000000000" + ], + "stages": 41 + }, + { + "ambient": 1033, + "idle_cap": 730, + "margin_per_port_per_local_call": [ + "-1075043385286061899/1000000000000000000", + "-537521692643030949/500000000000000000" + ], + "stages": 43 + }, + { + "ambient": 1081, + "idle_cap": 764, + "margin_per_port_per_local_call": [ + "-1129466401374114707/1000000000000000000", + "-564733200687057353/500000000000000000" + ], + "stages": 45 + }, + { + "ambient": 1129, + "idle_cap": 798, + "margin_per_port_per_local_call": [ + "-1183680275941540049/1000000000000000000", + "-73980017246346253/62500000000000000" + ], + "stages": 47 + }, + { + "ambient": 1177, + "idle_cap": 832, + "margin_per_port_per_local_call": [ + "-1237698875678005577/1000000000000000000", + "-154712359459750697/125000000000000000" + ], + "stages": 49 + }, + { + "ambient": 1225, + "idle_cap": 866, + "margin_per_port_per_local_call": [ + "-129153479548990709/100000000000000000", + "-1291534795489907089/1000000000000000000" + ], + "stages": 51 + }, + { + "ambient": 1273, + "idle_cap": 900, + "margin_per_port_per_local_call": [ + "-1345199496703815639/1000000000000000000", + "-672599748351907819/500000000000000000" + ], + "stages": 53 + }, + { + "ambient": 1321, + "idle_cap": 934, + "margin_per_port_per_local_call": [ + "-55948137195859669/40000000000000000", + "-349675857474122931/250000000000000000" + ], + "stages": 55 + }, + { + "ambient": 1369, + "idle_cap": 968, + "margin_per_port_per_local_call": [ + "-1452056143534152359/1000000000000000000", + "-726028071767076179/500000000000000000" + ], + "stages": 57 + }, + { + "ambient": 1417, + "idle_cap": 1001, + "margin_per_port_per_local_call": [ + "-1509235491577388341/1000000000000000000", + "-75461774578869417/50000000000000000" + ], + "stages": 59 + }, + { + "ambient": 1465, + "idle_cap": 1035, + "margin_per_port_per_local_call": [ + "-1562317646265002431/1000000000000000000", + "-156231764626500243/100000000000000000" + ], + "stages": 61 + } + ], + "helper_cost_per_port": [ + "14512013225030033/100000000000000000", + "145120132250300331/1000000000000000000" + ], + "module_channels_lower_bound": 10752, + "module_fraction": "6/7", + "tail_from_stage": 63, + "tail_margin_upper": "-121361731471432189/1000000000000000000" + }, + { + "copy_ranks": [ + 15, + 22 + ], + "finite_stages": [ + { + "ambient": 73, + "idle_cap": 51, + "margin_per_port_per_local_call": [ + "-25471563833242949/1000000000000000000", + "-6367890958310737/250000000000000000" + ], + "stages": 3 + }, + { + "ambient": 121, + "idle_cap": 85, + "margin_per_port_per_local_call": [ + "-17795490040284311/1000000000000000000", + "-1779549004028431/100000000000000000" + ], + "stages": 5 + }, + { + "ambient": 169, + "idle_cap": 119, + "margin_per_port_per_local_call": [ + "-59742643834723653/1000000000000000000", + "-14935660958680913/250000000000000000" + ], + "stages": 7 + }, + { + "ambient": 217, + "idle_cap": 153, + "margin_per_port_per_local_call": [ + "-7139413862469987/62500000000000000", + "-114230621799519791/1000000000000000000" + ], + "stages": 9 + }, + { + "ambient": 265, + "idle_cap": 187, + "margin_per_port_per_local_call": [ + "-134886613985457/781250000000000", + "-172654865901384959/1000000000000000000" + ], + "stages": 11 + }, + { + "ambient": 313, + "idle_cap": 221, + "margin_per_port_per_local_call": [ + "-23226035194222729/100000000000000000", + "-232260351942227289/1000000000000000000" + ], + "stages": 13 + }, + { + "ambient": 361, + "idle_cap": 255, + "margin_per_port_per_local_call": [ + "-2281366193051321/7812500000000000", + "-292014872710569087/1000000000000000000" + ], + "stages": 15 + }, + { + "ambient": 409, + "idle_cap": 289, + "margin_per_port_per_local_call": [ + "-351504685421806107/1000000000000000000", + "-175752342710903053/500000000000000000" + ], + "stages": 17 + }, + { + "ambient": 457, + "idle_cap": 323, + "margin_per_port_per_local_call": [ + "-205283296859868297/500000000000000000", + "-410566593719736593/1000000000000000000" + ], + "stages": 19 + }, + { + "ambient": 505, + "idle_cap": 357, + "margin_per_port_per_local_call": [ + "-1172866591555333/2500000000000000", + "-469146636622133199/1000000000000000000" + ], + "stages": 21 + }, + { + "ambient": 553, + "idle_cap": 391, + "margin_per_port_per_local_call": [ + "-263620118263741111/500000000000000000", + "-527240236527482221/1000000000000000000" + ], + "stages": 23 + }, + { + "ambient": 601, + "idle_cap": 424, + "margin_per_port_per_local_call": [ + "-29427668550418113/50000000000000000", + "-588553371008362259/1000000000000000000" + ], + "stages": 25 + }, + { + "ambient": 649, + "idle_cap": 458, + "margin_per_port_per_local_call": [ + "-129154506110696393/200000000000000000", + "-161443132638370491/250000000000000000" + ], + "stages": 27 + }, + { + "ambient": 697, + "idle_cap": 492, + "margin_per_port_per_local_call": [ + "-351287531492559569/500000000000000000", + "-702575062985119137/1000000000000000000" + ], + "stages": 29 + }, + { + "ambient": 745, + "idle_cap": 526, + "margin_per_port_per_local_call": [ + "-75899216553996293/100000000000000000", + "-758992165539962929/1000000000000000000" + ], + "stages": 31 + }, + { + "ambient": 793, + "idle_cap": 560, + "margin_per_port_per_local_call": [ + "-815053410974601967/1000000000000000000", + "-407526705487300983/500000000000000000" + ], + "stages": 33 + }, + { + "ambient": 841, + "idle_cap": 594, + "margin_per_port_per_local_call": [ + "-217696548494903451/250000000000000000", + "-870786193979613803/1000000000000000000" + ], + "stages": 35 + }, + { + "ambient": 889, + "idle_cap": 628, + "margin_per_port_per_local_call": [ + "-231553894408752773/250000000000000000", + "-926215577635011091/1000000000000000000" + ], + "stages": 37 + }, + { + "ambient": 937, + "idle_cap": 662, + "margin_per_port_per_local_call": [ + "-981364339588912931/1000000000000000000", + "-98136433958891293/100000000000000000" + ], + "stages": 39 + }, + { + "ambient": 985, + "idle_cap": 696, + "margin_per_port_per_local_call": [ + "-103625311247452013/100000000000000000", + "-1036253112474520129/1000000000000000000" + ], + "stages": 41 + }, + { + "ambient": 1033, + "idle_cap": 730, + "margin_per_port_per_local_call": [ + "-1090900562769718923/1000000000000000000", + "-545450281384859461/500000000000000000" + ], + "stages": 43 + }, + { + "ambient": 1081, + "idle_cap": 764, + "margin_per_port_per_local_call": [ + "-1145323578857771731/1000000000000000000", + "-114532357885777173/100000000000000000" + ], + "stages": 45 + }, + { + "ambient": 1129, + "idle_cap": 798, + "margin_per_port_per_local_call": [ + "-1199537453425197073/1000000000000000000", + "-74971090839074817/62500000000000000" + ], + "stages": 47 + }, + { + "ambient": 1177, + "idle_cap": 832, + "margin_per_port_per_local_call": [ + "-6267780265808313/5000000000000000", + "-1253556053161662599/1000000000000000000" + ], + "stages": 49 + }, + { + "ambient": 1225, + "idle_cap": 866, + "margin_per_port_per_local_call": [ + "-1307391972973564113/1000000000000000000", + "-81711998310847757/62500000000000000" + ], + "stages": 51 + }, + { + "ambient": 1273, + "idle_cap": 900, + "margin_per_port_per_local_call": [ + "-1361056674187472663/1000000000000000000", + "-680528337093736331/500000000000000000" + ], + "stages": 53 + }, + { + "ambient": 1321, + "idle_cap": 934, + "margin_per_port_per_local_call": [ + "-353640151845037187/250000000000000000", + "-1414560607380148747/1000000000000000000" + ], + "stages": 55 + }, + { + "ambient": 1369, + "idle_cap": 968, + "margin_per_port_per_local_call": [ + "-733956660508904691/500000000000000000", + "-1467913321017809381/1000000000000000000" + ], + "stages": 57 + }, + { + "ambient": 1417, + "idle_cap": 1001, + "margin_per_port_per_local_call": [ + "-305018533812209073/200000000000000000", + "-381273167265261341/250000000000000000" + ], + "stages": 59 + }, + { + "ambient": 1465, + "idle_cap": 1035, + "margin_per_port_per_local_call": [ + "-789087411874329727/500000000000000000", + "-1578174823748659453/1000000000000000000" + ], + "stages": 61 + } + ], + "helper_cost_per_port": [ + "14512013225030033/100000000000000000", + "145120132250300331/1000000000000000000" + ], + "module_channels_lower_bound": 10752, + "module_fraction": "6/7", + "tail_from_stage": 63, + "tail_margin_upper": "-137218908955089213/1000000000000000000" + } + ], + "helper_paid": { + "1": 1513, + "2": 201, + "3": 432, + "4": 50, + "5": 12 + }, + "helper_targets": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "larger_factor_gates": { + "all_larger_odd_factors": { + "all_copies_and_helpers_granted_free": true, + "factors_from": 7, + "stage3_upper": "-137641244965417621/1000000000000000000", + "stages_from5_upper": "-88386306108550027/500000000000000000" + }, + "five_factors": { + "finite_stages": [ + { + "margin_upper": "-534207584730931/125000000000000000", + "stages": 3 + }, + { + "margin_upper": "-19371277332371833/250000000000000000", + "stages": 5 + } + ], + "module_fraction": "5/24", + "tail_from_stage": 7, + "tail_margin_upper": "-19064677439169977/1000000000000000000" + } + }, + "operator_pencil_fixtures": [ + { + "pencil_ranks": [ + 1, + 2, + 1, + 2 + ], + "weighted_rank_sum": 128 + }, + { + "pencil_ranks": [ + 2, + 2, + 1, + 2 + ], + "weighted_rank_sum": 176 + }, + { + "pencil_ranks": [ + 2, + 2, + 2, + 2 + ], + "weighted_rank_sum": 224 + } + ], + "scope": "Separated H_i modules with one frozen complete helper bank per coefficient channel; declared main paths and idle cap. Other coefficient maps are granted free. Joint producers, address-dependent coefficients, shared helper protocols, other module words and changed caller profiles are outside the result.", + "spectral_contract": { + "active_dimension": 56, + "active_eigenvalues": { + "-12": 8, + "2": 48 + }, + "kernel_dimension": 56 + }, + "status": "PASS_ODD_E8_SEPARATED_NATIVE_LIFT_GATE", + "test_exponent": "151/50000" +} diff --git a/research/odd-e8-direct-sum/NATIVE-LIFT.md b/research/odd-e8-direct-sum/NATIVE-LIFT.md new file mode 100644 index 0000000000..25a4b954c8 --- /dev/null +++ b/research/odd-e8-direct-sum/NATIVE-LIFT.md @@ -0,0 +1,299 @@ +# A cost obstruction for separated native lifts + +This result rejects one implementation of the odd E8 family. It does not +reject the geometry, all native producers, or all integer-multiplication +algorithms. The positive geometry result in PROOF.md remains unchanged. + +The cost model below fails at exponent 151/50000 = 0.00302 for every odd +factor count k>=3 and every odd stage count N>=3. It also fails at every +larger exponent below one. Thus this model cannot reach the selected +0.003027288235 checkpoint. This is a scoped obstruction, not a new kappa. + +## 1. The implementation class + +Let E be the 112-dimensional space of base port values over C. Let C be +the rank-eight fitting matrix in PROOF.md, and let B be its block-diagonal +restriction to the 14 sign cubes. Put + +``` +K = I-B +H = B-C. +``` + +For odd k=2s+1, form F_k as in PROOF.md. Form F_block,k with B in place of C. +The side map to be produced is H_k=F_block,k-F_k. + +A separated implementation writes + +``` +H_k = sum_(i=1)^k H_i tensor D_i, +``` + +where D_i is any linear operator on the other k-1 port factors. It need +not be diagonal, symmetric, a scalar polynomial, or a member of a fixed +dictionary. Every rank-one factor of D_i uses one channel of the fixed +base H module. All coefficient maps are granted for free. A decomposition +with several terms for one i cannot use fewer channels than rank(D_i) +after those terms are added. + +Each channel retains one complete native helper bank from the pinned base +word. Its helper paid and productive profiles are counted in section 5. +We grant extraction of H from the base coded transfer, all other main-role +work outside the stated paths, and all coefficient acquisition for free. +These grants favor this implementation. They do not describe an emitted +native program. + +The declared main and caller inventory is specified in section 6. There +are no additional productive main-role targets in this inventory. A joint +producer, a shared helper protocol that changes the paid word, a different +base module, conjugated modules that replace H, or a caller with changed +targets, main paths or idle cap is outside the claim. Address-dependent +operator coefficients are also outside this port-space model. + +## 2. The base spectral split + +The literal normalizers give + +``` +B^2=2B; C^2=14C; BC=CB=2C. +rank(B)=56; rank(C)=8. +``` + +Thus E=Z direct-sum U, with both spaces of dimension 56. On Z, B=C=H=0 +and K=I. On U, B=2I and K=-I. The operator H on U is invertible: it has +eigenvalue 2 with multiplicity 48 and eigenvalue -12 with multiplicity 8. +The checker verifies the two projection identities and the source covariance +over exact integers. The dimensions follow from their traces. + +## 3. A channel bound for every odd k + +Put t=(k+1)/2. Choose a set S of t factors and restrict H_k to U on S and +Z on the other factors. On this space, + +``` +H_k = 2I - 2*7^t P, +``` + +where P is the product of the rank-eight projections on the active factors. +This operator is invertible. The restricted space has dimension 56^k. +Only terms H_i tensor D_i with i in S remain. If D_i[S] denotes the +corresponding principal restriction to the other factors, rank subadditivity +therefore gives + +``` +sum_(i in S) rank(D_i[S]) >= 56^(k-1). +``` + +Fix i. Let J be a set of s of the other 2s factors. Consider the two spaces +with U on J and Z on its complement, and with these choices reversed. +The two off-diagonal blocks of D_i between these spaces are zero. To prove +this, restrict the full operator identity to U on factor i and to either +of these off-diagonal blocks. Every other factor changes between U and Z. +Each H_j for j!=i has a zero block between these two spaces. The right side +H_k also has zero such blocks. Since H_i is invertible on U, the block of +D_i is zero. + +Consequently rank(D_i) is at least the sum of its two principal block ranks. +Average this inequality over the binomial(2s,s) choices of J. Sum over i, +and then use the preceding inequality for all sets S. The result is + +``` +sum_i rank(D_i) >= (2k/t)*56^(k-1). +``` + +For k=5 this is (10/3)*56^4 channels. Relative to 112^4 channels, the +bound is 5/24. A fractional lower bound is sufficient for the cost test; +an actual channel count is an integer. + +## 4. A stronger three-factor bound + +For k=3, fix the third factor in Z. On U tensor U tensor Z the required +operator is + +``` +(H tensor I + I tensor H - H tensor H/2) tensor I_Z. +``` + +Let X and Y be the principal blocks of D_1 and D_2 that occur here. Every +solution of the two-factor identity has the form + +``` +X = I - H/4 + H tensor S +Y = I - H/4 - H tensor S, +``` + +with identity factors on Z understood, and with an arbitrary operator S +on Z. To see completeness, subtract the displayed particular solution. +The homogeneous equation is H tensor DeltaX + DeltaY tensor H=0. Passing +to the quotient of either matrix space by the line spanned by H forces +DeltaX=H tensor S and DeltaY=-H tensor S. This argument does not assume +that S is diagonalizable. + +Use the two eigenspaces of H on U. Then + +``` +rank(X)+rank(Y) + = 48*(rank(I/2+2S)+rank(I/2-2S)) + + 8*(rank(4I-12S)+rank(4I+12S)). +``` + +The four kernels are eigenspaces of S at the distinct values +-1/4, 1/4, 1/3 and -1/3. Their direct sum has dimension at most 56. +The largest coefficient in the weighted kernel sum is 48. It follows that + +``` +rank(X)+rank(Y) >= (2*48+2*8-48)*56 = 3584. +``` + +Apply this result with each factor in Z. For each D_i the two blocks used +in this sum are on U tensor Z and Z tensor U. Their off-diagonal blocks +are zero by section 3. Their ranks therefore add inside a principal +restriction of D_i. Summing the three face bounds gives + +``` +sum_i rank(D_i) >= 3*3584 = 10752. +``` + +This is 6/7 of 112^2. No claim that this lower bound is attained is needed. +The finite checker also tests the two-factor identity with diagonal, +nondiagonalizable and nonreal-spectrum choices of S. These checks support +the written argument; they do not replace its universal quantifiers. + +## 5. The retained helper cost + +The authenticated native source gives the following profiles on its 408 +original helper roles, in both orientations: + +``` +paid: {1:1513, 2:201, 3:432, 4:50, 5:12} +targets: {4:28, 7:7, 8:47, 9:326}. +``` + +Both have rank mass 3471. For each individual helper, the checker verifies +that its positive paid widths sum to its requested width. Owned center +copies and all main-role calls are excluded from these profiles. Removing +the center copies does not remove these helper paths. + +At sigma=1-a, write beta(a) for the paid moment minus the target moment of +one helper bank. The per-helper width partitions imply beta(a)>=0 for +0<=a<1 by concavity. Thus the three-factor side map costs at least +10752*beta(a) per local invocation. For five factors the lower bound is +(10/3)*56^4*beta(a). The coefficient maps and every further cost remain free +in this lower bound. + +The source is Cao Yifan's retained native word, used by Dugongue's center-free +code and Dillon's normalized caller. Their attribution and source notices +remain in the pinned files. This result counts their existing helper paths; +it does not re-prove their native operator identities. + +## 6. The declared relaxed invoice + +For a fixed odd k>=3 and odd N>=3, put v=112^k and m=8kN+1. Grant these +main paths per local invocation and per port: + +``` +source children: [3k-1, 5k, 1] +target children: [5k, 1 repeated 3k times]. +``` + +There are N local invocations and (N-1)*v productive main jobs of rank m. +Grant the pairing-rank COPY profile from PROOF.md. The k=3 check also tests +the larger source-dimension profile. The declared idle rank mass is +8k*N*(N-3)*v. Grant fractional packing of that mass at the largest width + +``` +c = floor(sqrt((m^2-1)/2)). +``` + +This is a stated caller model, not a proof that a native caller realizes it. +For N=3 it reduces to the inventory already used in PROOF.md. The bounds +for larger N apply to this declared idle cap; a changed cap is outside scope. + +Let g_k(a) be the per-port, per-local paid moment from the main paths, +the copied decoder, and the lower bound on separated helper banks. The +remaining moment per port per local invocation is at most + +``` +((N-1)/N)*m^(1-a) - 8k*(N-3)*c^(-a) - g_k(a). +``` + +At a=151/50000 every case below is strictly negative. The checker uses +rational logarithm and exponential bounds. It does not use floating-point +sign tests. To enclose log(r), first divide r by a power of two. For +z=(y-1)/(y+1), with 1<=y<2, use the first 24 terms of +`2*sum z^(2j+1)/(2j+1)`. The remainder is between zero and +`2*z^49/(49*(1-z^2))`. The same formula at z=1/3 encloses log(2). +Round the resulting bounds outward to a grid of 10^(-30). For +`x=a*log(r)`, use the exponential sum through degree 18. Its tail is at +most `(x^19/19!)/(1-x/20)`, since 0<=x<1. Invert these positive bounds +to enclose r^(1-a). Stored final intervals are rounded outward again. + +- For k=3, check all odd N from 3 through 61. For N>=63, even parent-width + idle packing gives the upper bound `49*1513^(-a)-g_3(a)`, which is negative. + Indeed the pre-main moment is at most `(49-1/N)*(24N+1)^(-a)`. +- For k=5, check N=3 and N=5 with the stated cap. For N>=7, parent-width + packing at N=7 already fails. The parent-width upper bound decreases with + N in this range. The rational derivative test is included in the checker. +- For all k>=7, grant every copy and helper for free. Main paths alone fail. + It is enough to check k=7,N=3 and the parent-width bound at k=7,N=5. + The monotonicity argument below covers the infinite ranges. + +For the last two tail arguments, the parent-width pre-main expression is + +``` +G(k,N) = (16k+1-1/N)*(8kN+1)^(-a). +``` + +For fixed k its derivative in N is negative when + +``` +1/N + 1/(8kN^2) < a*(16k+1-1/N). +``` + +The left side decreases with N and the right side increases. The checker +proves the inequality at k=5,N=5 and k=7,N=5. + +For the all-k tail subtract the main-path cost +`(3k-1)^(1-a)+2*(5k)^(1-a)+3k+1` from G(k,N). Its derivative in k is at most + +``` +[3*(1-a)-8*a*(N-3)/(8kN+1)]*(8kN+1)^(-a) - 3 < 0. +``` + +This follows because `3k-1` and `5k` are smaller than `8kN+1`. Thus the +two k=7 checks cover every larger odd k, with all copies and helpers free. + +## 7. Why failure persists at larger exponents + +Normalize each invoice by m^(1-a). The main target count is then constant. +Each normalized main, copy and idle paid term increases with a, since its +width is below m. The normalized helper-bank excess also cannot decrease. + +For one helper let its paid widths be d_j and its target width be r, with +sum d_j=r=0. Divide each +summand by its width and use sum d_j=r. The displayed derivative is +nonnegative. Hence a failed invoice at 0.00302 stays failed for every +a in [0.00302,1). This uses the checked per-helper partitions, not only +equality of the two aggregate rank masses. + +## 8. Consequence and limits + +Do not implement a larger separated lift with the same full helper-bank +contract and declared invoice. Even the free coefficient maps and favorable +packing do not make it fit. A useful next construction must change the joint +producer, native helper word, main paths or caller inventory, and must price +the resulting state and restoration work. + +The odd direct-sum fitting family and its vanishing pairing tariff remain +valid. No theorem here excludes a direct joint producer or a better interface. +No native program, independent human review, formal-kernel check or new +integer-multiplication bound is claimed. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/odd-e8-direct-sum/PROOF.md b/research/odd-e8-direct-sum/PROOF.md new file mode 100644 index 0000000000..041b6d365d --- /dev/null +++ b/research/odd-e8-direct-sum/PROOF.md @@ -0,0 +1,269 @@ +# Odd direct sums of the P112 line geometry + +This is a scalar and binary geometry construction. It is not a native +supplier or a new integer-multiplication bound. All vector spaces in the +geometry argument are over F2. The fitting matrices are over Q. + +## 1. Exact base data + +Use the 112 vectors q_i and the 112-by-8 matrix M in the pinned +`NORMALIZERS.json`. Put C=M M^T/4. The verifier checks + +``` +q_i dot q_i = 1; all q_i are distinct; +span(q_i) has dimension 9; +span(q_i+q_0) has dimension 8; +M^T M = 56 I_8; C_ii = 1; +C_ij = 0 if i != j and q_i dot q_j = 1. +``` + +Thus C has eigenvalues 14 and zero, with multiplicities 8 and 104. +The 12,544 entry checks establish the literal base mask. They do not assert +that rank eight is the minimum for every matrix with that mask. + +For each of the eight columns of M, its 56 nonzero positions select binary +vectors which span a nondegenerate 8-space V. Their affine differences span +the even subspace D of V. The verifier checks dim(D)=7 and rank(D)=6. Its +radical is one line, generated by z with z dot p=1 for every vector p in +the selected support. These eight checked contracts will suffice below. + +## 2. The port space + +Let k=2s+1 be positive and odd. For an ordered tuple of base ports, use + +``` +q_(i1,...,ik) = (q_i1,...,q_ik) in F2^(9k). +``` + +The 112^k labels are distinct and have norm one. Their span U consists of +the vectors whose k block parities agree. The affine-difference contract +in section 1 gives dim(U)=8k+1. + +Write chi_i for the all-ones vector in block i. The orthogonal complement +U-perp is the span of chi_i+chi_k for i=t) product_(i in J)(C_i/2) + * product_(i not in J)(I-C_i/2). +``` + +The coefficient of a fixed degree-j term is +2^(1-j) times sum_(l=t)^j (-1)^(j-l) binomial(j,l), which is the stated a_j. + +Put A_i=I-C_i. The polynomial I-F_k is the multilinear majority function +on signs A_i. Majority on an odd number of signs changes sign when all +signs change. Its multilinear expansion therefore has only odd-degree +monomials in the A_i. Each A_i has zero diagonal, and each nonzero entry +joins distinct orthogonal base labels. + +Consider a nonzero entry of one such monomial. The two port tuples differ +in an odd number of coordinates, with dot product zero in each changed +coordinate. They agree in the remaining even number of coordinates, with +dot product one in each. Their total dot product is zero. Also every such +monomial has zero diagonal. It follows that F_k has diagonal one and zero +at every forbidden off-diagonal position. This argument proves the full +mask without materializing a 112^k-square matrix. + +For k=3, the formula is particularly small: + +``` +F_3 = (C_1 C_2 + C_1 C_3 + C_2 C_3 - C_1 C_2 C_3)/2. +``` + +## 4. Rank of this matrix + +On a tensor eigenspace with exactly l active rank-eight factors, the +eigenvalue is + +``` +lambda_l = sum_(j=t)^l a_j * binomial(l,j) * 14^j. +``` + +It is zero for l=t. Here is a direct proof of the +second statement. Let + +``` +B_(l,t)(x) = sum_(j=t)^l binomial(l,j) x^j (1-x)^(l-j). +``` + +Then lambda_l=2 B_(l,t)(7), and differentiation gives + +``` +B_(l,t)(x) = t*binomial(l,t) + * integral_0^x u^(t-1) (1-u)^(l-t) du. +``` + +If l-t is even, the integral is positive. If l-t is odd, its positive +part on [0,1] is at most 1/t. Its negative part already has absolute value +at least 2^(t-1) on [2,3], and is larger on [1,7]. Thus it is negative. +Consequently + +``` +rank(F_k) = sum_(l=t)^k binomial(k,l) 8^l 104^(k-l). +``` + +For k=3, the nonzero eigenvalues are 98 and -1078. Their multiplicities +are 19,968 and 512. The rank is 20,480. This is the rank of the displayed +matrix, not a minimum-rank theorem for the graph. + +## 5. An explicit decoder and its pairing tariff + +Expand each C as M M^T/4 in the formula for F_k. A degree-j term gives +8^j * 112^(k-j) rank-one factors. A reader column uses j columns of M and +a coordinate unit vector on each remaining factor. Its source row is +the transpose of that column, multiplied by a_j/4^j. This specifies every +coefficient and has no odd denominator. + +The binary support of such a column has span T of dimension 7j+1. Indeed, +its differences are the direct sum of j spaces D_i of dimension seven, +and any one support vector p supplies one further direction. On the +differences, the form has rank 6j and radical spanned by z_1,...,z_j. +Each z_i pairs to one with p. The combinations sum c_i z_i with +sum c_i=0 form the radical of T, of dimension j-1. One remaining radical +direction pairs with p and supplies a nondegenerate two-dimensional +block. Thus + +``` +dim(T) = 7j+1 +rank(dot product on T) = 6j+2. +``` + +The second number is the separate-total source/reader pairing tariff. +It does not assert that a physical COPY operation at that price has been +implemented. The two numbers must not be interchanged. + +The total factor count and pairing tariff of this explicit factorization +are respectively + +``` +R_k = sum_(j=t)^k binomial(k,j) 8^j 112^(k-j) +ell_k = sum_(j=t)^k binomial(k,j) 8^j 112^(k-j) (6j+2). +``` + +For k=3 there are 21,504 factors of pairing rank 14 and 512 of pairing +rank 20. Hence ell_3=311,296, or 76/343 per port. The verifier directly +checks all 7,168 feature-pair/fixed-label supports and all 512 feature +triples; permutations of the three orthogonal blocks give the other +two degree-two families. + +For general odd k, ell_k/112^k is at most +(6k+2)*2^k/14^((k+1)/2), and thus tends to zero. This is a geometry and +decoder statement. Native production costs need not tend to zero. + +## 6. A local scalar core + +The rows of M split into 14 groups according to their four nonzero +coordinates. Each group contains all eight relative sign patterns. +Within one group, let C_b be its Gram matrix divided by four. The literal +root data give C_b^2=2 C_b. Thus K_b=I-C_b is an involution. + +After each root is oriented by its first nonzero coordinate, label the +three remaining relative signs by epsilon in F2^3. The scaled core 2 K_b +has entry zero on the diagonal and wt(epsilon+eta)-2 elsewhere. It has +nonzero entries only between opposite selector parities. The verifier +checks the actual binary labels: each parity class spans dimension three, +and the two spans pair to zero. It also checks every literal cube Gram +entry, including the original root orientation signs. + +On each three-cube product, set + +``` +K = (K_1 + K_2 + K_3 - K_1 K_2 K_3)/2. +``` + +The K_i commute and square to identity, so K^2=I. Each term reverses total +selector parity. Both parity classes have 256 ports and span dimension +nine. The two spans pair to zero. The verifier checks these spans for +all 2,744 product cubes. Thus both 256-by-256 blocks of K are invertible +dyadic scalar maps between orthogonal source and target classes. + +Let F_block be F_3 formed from the block-diagonal C_b operators. Then +K=I-F_block. The remaining side map is H=F_block-F_3, and + +``` +K + H + F_3 = I. +``` + +The off-diagonal support of H is orthogonal, since both fitting matrices +have that property and their diagonals agree. A chronological native +producer for H is not supplied. The K identity alone does not provide it. + +## 7. Exact allowance for the missing work + +For a proposed three-stage caller, grant the source children [8,15,1], +the target children [15,1,1,1,1,1,1,1,1,1], and physical copies at the +pairing tariff above. These are planning assumptions. In particular, +no H readout order compatible with the target flags is certified here. +The resulting granted inventory, with v=112^3, is + +``` +paid: H1:30v, H8:3v, H15:6v, H14:64512, H20:1536 +targets: H73:2v. +``` + +At a=31/10000, the signed moment of this inventory lies strictly between +3v/10 and v/3. The verifier encloses each r^(1-a) with rational numbers. +Decimal arithmetic only proposes an endpoint; the integer check + +``` +b^10000 <= r^31 * 10^240000 < (b+1)^10000 +``` + +proves every bracket. The printed rational intervals are therefore exact. + +The omitted work must fit the remaining signed-moment allowance, which is +less than 1/9 per port per local invocation. It includes complete helper +lifetimes and their productive targets, physical copies, old-value reads, +source restoration and any changed caller costs. No omitted item is zero +by assumption of the result. The favorable incomplete moment is not a +supplier exponent, an outer exponent or an admission certificate. No +balanced-interface a/(1+a) conversion is applied. + +## 8. A gate with full source-dimension copies + +The positive allowance does not require the smaller pairing tariff. Replace +one rank-14 copy by rank 15 for every feature pair, and one rank-20 copy by +rank 22 for every feature triple. The copy mass becomes + +``` +15*21504 + 22*512 = 333824 = (163/686)*v. +paid: H1:30v, H8:3v, H15:6v+64512, H22:1536 +targets: H73:2v. +``` + +At the same exponent 31/10000, the exact remaining moment lies between +v/4 and 3v/10. Its value per port is about 0.2707505542. Thus less than +1/10 per port per local invocation remains for all omitted work. + +This is a second planning gate. It does not assert that these copies have +been scheduled. A producer could use it without implementing the smaller +pairing-rank service. It would still need to supply the source totals at +their actual frames, compatible target reads, compensation for arbitrary +old values, and every helper return. All other assumptions of section 7 +remain in force. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/odd-e8-direct-sum/README.md b/research/odd-e8-direct-sum/README.md new file mode 100644 index 0000000000..aa81067fb7 --- /dev/null +++ b/research/odd-e8-direct-sum/README.md @@ -0,0 +1,119 @@ +# Odd E8 direct-sum decoder + +This construction gives 1,404,928 rank-one binary ports in dimension 25, +an explicit dyadic fitting matrix of rank 20,480, and a decoder factorization +with pairing tariff 311,296. The tariff per port is 76/343, compared with +4/7 for the retained single P112 factor. These are different geometries. +The comparison does not replace any paid job in the selected supplier. + +**No complete kappa improvement is established.** The missing step is a +native producer, its complete helper and restoration cost, and physical +COPY at the stated pairing tariff. The exact planning gate leaves less +than 1/9 per port per local call for the omitted work at exponent 0.0031. +This package supplies no complete invoice or multiplication theorem. +A second exact gate charges copies by source dimensions 15 and 22. It still +has positive allowance at 0.0031: between 1/4 and 3/10 per port, or less +than 1/10 per local invocation. This gives a possible alternative to the +smaller pairing-rank service; it does not supply a chronological program. + +The [native-lift cost proof](NATIVE-LIFT.md) rejects separated use of the +frozen base helper banks under the declared main paths and caller invoice. +The three-factor case needs at least 10,752 base-module channels, even with +arbitrary linear coefficient maps on the other port indices. Exact bounds +and written monotonicity proofs exclude every odd k>=3 and N>=3 at exponent +0.00302 in that model. This does not exclude a joint producer, a changed +helper word, address-dependent coefficients or a different caller inventory. +The [cost certificate](NATIVE-LIFT.json) is checked by [native_lift.py](native_lift.py). + +The [proof](PROOF.md) gives the all-odd-factor construction, the support +pairing formula, a local scalar involution, and the budget assumptions. +The [certificate](RESULT.json) and [verifier](verify.py) give exact finite +checks. [Source pins](SOURCES.json) bind the literal predecessor data to +canonical main `1a3ced60b2f7a46bc70280a04f2eeb8ca027c700`. + +For k=2s+1 factors, the construction has 112^k ports in dimension 8k+1. +The fitting matrix uses only products of at least s+1 copies of the +rank-eight base matrix. A term with j active factors has source support +dimension 7j+1 and binary source/reader pairing rank 6j+2. The tariff per +port tends to zero as k grows. This does not bound native production cost. + +For three factors, the 14 base sign cubes also give 2,744 product cubes. +On each, an explicit dyadic involution exchanges two orthogonal 256-port +classes. This is the scalar K part of K+H+F=I. A native H program and its +actual target readout order remain unknown. + +## Verification + +Use Python 3.12 and the standard library, from the repository root: + +```sh +python3.12 -I -W error -B research/odd-e8-direct-sum/verify.py +python3.12 -I -W error -B research/odd-e8-direct-sum/native_lift.py +python3.12 -B scripts/research_package.py --package research/odd-e8-direct-sum +``` + +The geometry command prints: + +```text +PASS_ODD_E8_DIRECT_SUM_COMPONENT ports=1404928 dimension=25 rank=20480 pairing_mass=311296 +``` + +The geometry verifier checks all 12,544 base entries, all eight feature support +contracts, 7,168 feature-pair/fixed-label supports, 512 feature triples, +all 2,744 product-cube parity spans, and exact majority coefficients and +eigenvalues for odd k from 1 through 15. It regenerates RESULT.json and +compares it in full. Altered root and binary-label data, a reversed cubic +sign and an omitted degree-two layer must fail. + +The native-lift verifier authenticates both orientations of all 408 helper +paths, checks three operator-pencil fixtures and two additional rejection +controls, and encloses the finite cost tests with rational arithmetic. The +written rank and monotonicity arguments cover the infinite parameter ranges. +It does not replay the native operator word. + +The proof handles the full fitting mask by a tensor support argument. +The enormous fitting matrix is not materialized or exhaustively enumerated. +The all-k statement is a written algebraic proof with finite corroboration, +not formal proof-kernel or independent human verification. No selected +native replay, compiler, Lean or outer admission command is part of this +package. The selected record is provenance only and is not changed. + +## Open next questions + +Can a direct H producer and its complete helper lifetimes fit the exact +remaining allowance in section 7 of the proof? First give its inputs, +physical charts, dirty reads, returns and paid/target profile. Stop that +schedule if its optimistic complete profile already exceeds the allowance. +The local K involution and decoder tariff cannot stand in for this program. + +Can a changed main-path or caller inventory remove this cost obstruction? +First state the new target jobs, paid paths and readout order. The all-factor +result grants copies and helpers for free when k>=7, so a decoder tariff +change alone cannot fix those cases under the declared paths. +[TASK.json](TASK.json) records the structured obligations. + +## Credit and scope + +The input is Dillon's retained `coded-native-caller/NORMALIZERS.json`. +Its [physical source note](../coded-native-caller/PHYSICAL.md) records the +literal E8 normalizers and their lineage. Dugongue's +[PR #4929](https://github.com/CrocSwap/integer-mult-bounds/pull/4929) supplies +the stable rank-eight code and factorization. Retain Cao Yifan, Cinna Davis, +zxv, Jacob Alan Sussman and the E8/native/Clifford/compiler predecessors +credited in that source. None of their native caller results is re-proved +or claimed as new here. + +Multilinear majority and tensor eigenspace calculations are standard +algebra. The contribution is their use on these literal direct-sum port +labels, the explicit decoder and support tariff, the product-cube core, +and the exact remaining-cost gate. No claim of a new general majority +identity or a minimum decoder tariff is made. + +The [scoped claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1587#discussioncomment-19164011) +records the overlap check. This changes the port geometry under the +complex-rank-shape card; it does not optimize the old native word or the +peer-owned fused-T/Global120 caller. Bounded repository, PR and Discussion +searches found no matching active scope; this is not an exhaustive novelty +certificate. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/odd-e8-direct-sum/RESULT.json b/research/odd-e8-direct-sum/RESULT.json new file mode 100644 index 0000000000..57d1807575 --- /dev/null +++ b/research/odd-e8-direct-sum/RESULT.json @@ -0,0 +1,563 @@ +{ + "base": { + "base_entries": 12544, + "feature_supports": [ + { + "radical": 504, + "support_size": 56 + }, + { + "radical": 486, + "support_size": 56 + }, + { + "radical": 469, + "support_size": 56 + }, + { + "radical": 459, + "support_size": 56 + }, + { + "radical": 435, + "support_size": 56 + }, + { + "radical": 429, + "support_size": 56 + }, + { + "radical": 414, + "support_size": 56 + }, + { + "radical": 384, + "support_size": 56 + } + ], + "pair_support_checks": { + "(15, 14)": 7168 + }, + "triple_ambient_rank": 25, + "triple_support_checks": { + "(22, 20)": 512 + } + }, + "budget": { + "ambient_rank": 73, + "complete_kappa_claim": false, + "copy_tariff_kind": "pairing_rank", + "granted_paid": { + "1": 42147840, + "14": 64512, + "15": 8429568, + "20": 1536, + "8": 4214784 + }, + "granted_targets": { + "73": 2809856 + }, + "proved_coarse_interval_per_port": [ + "3/10", + "1/3" + ], + "remaining_margin_per_port": [ + "476144121778628247594188812753727082820646743157391706631402173575776745290341117228471893341310347192976017407923394170/1495859593094010734680121293343161283632475049922456578543126315373137413264035077342729119096551363426900799419735886861", + "42323921935878066452850817730359558900634761592504247500278246358799961971598167069277357832167581049166023603311774570/132965297163912065304900066893666813325655995261828856468147120613877052241576303285594936011211622298361132546556274181" + ], + "remaining_margin_per_port_per_local_call": [ + "158714707259542749198062937584575694273548914385797235543800724525258915096780372409490631113770115730992005802641131390/1495859593094010734680121293343161283632475049922456578543126315373137413264035077342729119096551363426900799419735886861", + "14107973978626022150950272576786519633544920530834749166759415452933320657199389023092452610722527016388674534437258190/132965297163912065304900066893666813325655995261828856468147120613877052241576303285594936011211622298361132546556274181" + ], + "stages": 3, + "test_exponent": "31/10000", + "unknown_obligations": [ + "physical COPY at the pairing tariff", + "cross-cube producer and all helper lifetimes", + "old-value compensation and source restoration", + "caller, compiler, precision and outer admission" + ] + }, + "controls": [ + "changed_root_coefficient", + "changed_binary_label", + "reversed_cubic_sign", + "omitted_degree_two_layer" + ], + "core": { + "base_cubes": 14, + "core_polynomial": { + "1": "1/2", + "2": "1/2", + "4": "1/2", + "7": "-1/2" + }, + "opposite_pairing_rank": 0, + "opposite_parity_span_dimensions": [ + 9, + 9 + ], + "physical_program_emitted": false, + "ports_per_product_cube": 512, + "product_cubes": 2744, + "proposed_source_children": [ + 8, + 15, + 1 + ], + "proposed_target_children": [ + 15, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + "families": [ + { + "ambient_rank": 9, + "eigenvalues": { + "0": "0", + "1": "14" + }, + "equal_coordinate_values": { + "0": "1", + "1": "1" + }, + "factor_terms": 8, + "factors": 1, + "fitting_rank": 8, + "pairing_mass": 64, + "pairing_mass_per_port": "4/7", + "pairing_tariff": { + "8": 8 + }, + "ports": 112, + "scalar_coefficients": { + "1": "1" + }, + "source_widths": { + "8": 8 + } + }, + { + "ambient_rank": 25, + "eigenvalues": { + "0": "0", + "1": "0", + "2": "98", + "3": "-1078" + }, + "equal_coordinate_values": { + "0": "-1/2", + "1": "0", + "2": "1/2", + "3": "1" + }, + "factor_terms": 22016, + "factors": 3, + "fitting_rank": 20480, + "pairing_mass": 311296, + "pairing_mass_per_port": "76/343", + "pairing_tariff": { + "14": 21504, + "20": 512 + }, + "ports": 1404928, + "scalar_coefficients": { + "2": "1/2", + "3": "-1/2" + }, + "source_widths": { + "15": 21504, + "22": 512 + } + }, + { + "ambient_rank": 41, + "eigenvalues": { + "0": "0", + "1": "0", + "2": "0", + "3": "686", + "4": "-11662", + "5": "136514" + }, + "equal_coordinate_values": { + "0": "3/8", + "1": "0", + "2": "-1/8", + "3": "0", + "4": "3/8", + "5": "1" + }, + "factor_terms": 66551808, + "factors": 5, + "fitting_rank": 57540608, + "pairing_mass": 1345191936, + "pairing_mass_per_port": "10263/134456", + "pairing_tariff": { + "20": 64225280, + "26": 2293760, + "32": 32768 + }, + "ports": 17623416832, + "scalar_coefficients": { + "3": "1/4", + "4": "-3/8", + "5": "3/8" + }, + "source_widths": { + "22": 64225280, + "29": 2293760, + "36": 32768 + } + }, + { + "ambient_rank": 57, + "eigenvalues": { + "0": "0", + "1": "0", + "2": "0", + "3": "0", + "4": "4802", + "5": "-110446", + "6": "1618274", + "7": "-19126366" + }, + "equal_coordinate_values": { + "0": "-5/16", + "1": "0", + "2": "1/16", + "3": "0", + "4": "-1/16", + "5": "0", + "6": "5/16", + "7": "1" + }, + "factor_terms": 210249973760, + "factors": 7, + "fitting_rank": 168896233472, + "pairing_mass": 5520794583040, + "pairing_mass_per_port": "329065/13176688", + "pairing_tariff": { + "26": 201410478080, + "32": 8631877632, + "38": 205520896, + "44": 2097152 + }, + "ports": 221068140740608, + "scalar_coefficients": { + "4": "1/8", + "5": "-1/4", + "6": "5/16", + "7": "-5/16" + }, + "source_widths": { + "29": 201410478080, + "36": 8631877632, + "43": 205520896, + "50": 2097152 + } + }, + { + "ambient_rank": 73, + "eigenvalues": { + "0": "0", + "1": "0", + "2": "0", + "3": "0", + "4": "0", + "5": "33614", + "6": "-974806", + "7": "17176754", + "8": "-236945086", + "9": "2812516994" + }, + "equal_coordinate_values": { + "0": "35/128", + "1": "0", + "2": "-5/128", + "3": "0", + "4": "3/128", + "5": "0", + "6": "-5/128", + "7": "0", + "8": "35/128", + "9": "1" + }, + "factor_terms": 681570373468160, + "factors": 9, + "fitting_rank": 508609490321408, + "pairing_mass": 22007543958077440, + "pairing_mass_per_port": "5856035/737894528", + "pairing_tariff": { + "32": 649669638094848, + "38": 30936649433088, + "44": 947040288768, + "50": 16911433728, + "56": 134217728 + }, + "ports": 2773078757450186752, + "scalar_coefficients": { + "5": "1/16", + "6": "-5/32", + "7": "15/64", + "8": "-35/128", + "9": "35/128" + }, + "source_widths": { + "36": 649669638094848, + "43": 30936649433088, + "50": 947040288768, + "57": 16911433728, + "64": 134217728 + } + }, + { + "ambient_rank": 89, + "eigenvalues": { + "0": "0", + "1": "0", + "10": "35746707458", + "11": "-425331959038", + "2": "0", + "3": "0", + "4": "0", + "5": "0", + "6": "235298", + "7": "-8235430", + "8": "169649858", + "9": "-2676514750" + }, + "equal_coordinate_values": { + "0": "-63/256", + "1": "0", + "10": "63/256", + "11": "1", + "2": "7/256", + "3": "0", + "4": "-3/256", + "5": "0", + "6": "3/256", + "7": "0", + "8": "-7/256", + "9": "0" + }, + "factor_terms": 2247261433412714496, + "factors": 11, + "fitting_rank": 1557650978876948480, + "pairing_mass": 86097685448144977920, + "pairing_mass_per_port": "313221555/126548911552", + "pairing_tariff": { + "38": 2134381317687607296, + "44": 108897006004469760, + "50": 3889178785873920, + "56": 92599494901760, + "62": 1322849927168, + "68": 8589934592 + }, + "ports": 34785499933455142617088, + "scalar_coefficients": { + "10": "63/256", + "11": "-63/256", + "6": "1/32", + "7": "-3/32", + "8": "21/128", + "9": "-7/32" + }, + "source_widths": { + "43": 2134381317687607296, + "50": 108897006004469760, + "57": 3889178785873920, + "64": 92599494901760, + "71": 1322849927168, + "78": 8589934592 + } + }, + { + "ambient_rank": 105, + "eigenvalues": { + "0": "0", + "1": "0", + "10": "-28291996222", + "11": "419978929538", + "12": "-5497197290494", + "13": "65508917349890", + "2": "0", + "3": "0", + "4": "0", + "5": "0", + "6": "0", + "7": "1647086", + "8": "-67530526", + "9": "1592732162" + }, + "equal_coordinate_values": { + "0": "231/1024", + "1": "0", + "10": "-21/1024", + "11": "0", + "12": "231/1024", + "13": "1", + "2": "-21/1024", + "3": "0", + "4": "7/1024", + "5": "0", + "6": "-5/1024", + "7": "0", + "8": "7/1024", + "9": "0" + }, + "factor_terms": 7499291052717838958592, + "factors": 13, + "fitting_rank": 4827802254857178447872, + "pairing_mass": 332441159769931238080512, + "pairing_mass_per_port": "151176736731/198428693313536", + "pairing_tariff": { + "44": 7103221025264357081088, + "50": 380529697782019129344, + "56": 15100384832619806720, + "62": 431439566646280192, + "68": 8404666882719744, + "74": 100055558127616, + "80": 549755813888 + }, + "ports": 436349311165261308988751872, + "scalar_coefficients": { + "10": "-21/128", + "11": "105/512", + "12": "-231/1024", + "13": "231/1024", + "7": "1/64", + "8": "-7/128", + "9": "7/64" + }, + "source_widths": { + "50": 7103221025264357081088, + "57": 380529697782019129344, + "64": 15100384832619806720, + "71": 431439566646280192, + "78": 8404666882719744, + "85": 100055558127616, + "92": 549755813888 + } + }, + { + "ambient_rank": 121, + "eigenvalues": { + "0": "0", + "1": "0", + "10": "14400472898", + "11": "-284446810942", + "12": "4646533372418", + "13": "-66359581267966", + "14": "856719909057026", + "15": "-10220233974842878", + "2": "0", + "3": "0", + "4": "0", + "5": "0", + "6": "0", + "7": "0", + "8": "11529602", + "9": "-541891294" + }, + "equal_coordinate_values": { + "0": "-429/2048", + "1": "0", + "10": "9/2048", + "11": "0", + "12": "-33/2048", + "13": "0", + "14": "429/2048", + "15": "1", + "2": "33/2048", + "3": "0", + "4": "-9/2048", + "5": "0", + "6": "5/2048", + "7": "0", + "8": "-5/2048", + "9": "0" + }, + "factor_terms": 25251472656857649723211776, + "factors": 15, + "fitting_rank": 15097609917191404252037120, + "pairing_mass": 1271245435745854340487708672, + "pairing_mass_per_port": "4516371048687/19446011944726528", + "pairing_tariff": { + "50": 23866822644888239792455680, + "56": 1325934591382679988469760, + "62": 56825768202114856648704, + "68": 1844992474094638202880, + "74": 43928392240348528640, + "80": 724094377588162560, + "86": 7388718138654720, + "92": 35184372088832 + }, + "ports": 5473565759257037859954903482368, + "scalar_coefficients": { + "10": "9/128", + "11": "-15/128", + "12": "165/1024", + "13": "-99/512", + "14": "429/2048", + "15": "-429/2048", + "8": "1/128", + "9": "-1/32" + }, + "source_widths": { + "106": 35184372088832, + "57": 23866822644888239792455680, + "64": 1325934591382679988469760, + "71": 56825768202114856648704, + "78": 1844992474094638202880, + "85": 43928392240348528640, + "92": 724094377588162560, + "99": 7388718138654720 + } + } + ], + "full_source_copy_budget": { + "ambient_rank": 73, + "complete_kappa_claim": false, + "copy_tariff_kind": "source_dimension", + "granted_paid": { + "1": 42147840, + "15": 8494080, + "22": 1536, + "8": 4214784 + }, + "granted_targets": { + "73": 2809856 + }, + "proved_coarse_interval_per_port": [ + "1/4", + "3/10" + ], + "remaining_margin_per_port": [ + "267882440313842674497736930927160502131836586467737680930258306588871566617039283651002254201290/989406803315791554779851257108851448857779061719659050157500910508322060666932023878299924859957", + "1448013190885636078367512563550866938929930224693820047337698343293904829432698294213551119670/5348144882788062458269476891517223501693813596225407077227037478393711132768910056859548296011" + ], + "remaining_margin_per_port_per_local_call": [ + "267882440313842674497736930927160502131836586467737680930258306588871566617039283651002254201290/2968220409947374664339553771326554346573337185158977150472502731524966182000796071634899774579871", + "482671063628545359455837521183622312976643408231273349112566114431301609810899431404517039890/5348144882788062458269476891517223501693813596225407077227037478393711132768910056859548296011" + ], + "stages": 3, + "test_exponent": "31/10000", + "unknown_obligations": [ + "physical COPY at the source-dimension tariff", + "cross-cube producer and all helper lifetimes", + "old-value compensation and source restoration", + "caller, compiler, precision and outer admission" + ] + }, + "source_sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da", + "status": "PASS_ODD_E8_DIRECT_SUM_COMPONENT" +} diff --git a/research/odd-e8-direct-sum/SOURCES.json b/research/odd-e8-direct-sum/SOURCES.json new file mode 100644 index 0000000000..86da2378cf --- /dev/null +++ b/research/odd-e8-direct-sum/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "1a3ced60b2f7a46bc70280a04f2eeb8ca027c700", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/native-center-free-code/SOURCE-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + } + ] +} diff --git a/research/odd-e8-direct-sum/TASK.json b/research/odd-e8-direct-sum/TASK.json new file mode 100644 index 0000000000..5ea937c660 --- /dev/null +++ b/research/odd-e8-direct-sum/TASK.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 7, + "base_commit": "1a3ced60b2f7a46bc70280a04f2eeb8ca027c700", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md", + "research/selected-k8-unrestricted-ends/README.md", + "research/eisenstein-reduction-copy-floor/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound. 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", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "changed", + "actual_scope": "Construct an odd direct-sum family of rank-one E8 ports, an explicit dyadic fitting decoder, exact source/reader pairing tariffs, a local product-cube scalar involution and a scoped remaining-cost gate. Prove a channel-rank and cost obstruction for separated native lifts using the frozen complete helper banks and the declared caller inventory.", + "scope_change_reason": "The user requested novel routes toward a useful kappa improvement. This changes the port geometry; it does not repack the existing native invoice. The result is a complete geometry component, while native production remains open.", + "bottleneck_link": "The triple family lowers the pairing tariff per port from 4/7 for one P112 factor to 76/343. A direct native producer and its complete lifecycle must fit less than 1/9 per port per local call at the declared 0.0031 planning exponent.", + "budget_minutes": null, + "stop_rule": "Do not expand the separated frozen-bank lift under the declared invoice. Retain the geometry result. Reopen implementation only with a direct joint producer, changed helper word, changed main paths or changed caller inventory and a full cost allowance.", + "outcome": "partial", + "evidence": "Exact base mask and covariance; eight feature support contracts; 7168 feature-pair and 512 feature-triple spans; all 2744 product-cube parity spans; exact coefficients and spectra for odd k through 15; integer-certified 0.0031 budget brackets and four rejecting controls. No native word or complete kappa calculation. A second exact gate with full source-dimension copies retains moment between v/4 and 3v/10 at the same exponent. The native-lift rank proof allows arbitrary linear maps on the other port factors. Exact cost gates and written monotonicity exclude all odd k>=3 and N>=3 at 0.00302 in the stated model. Two additional rejection controls pass.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance with construction, proof and verification. No separate human or formal-kernel review is claimed.", + "open_questions": [ + { + "question": "Can a direct H producer and all helper lifetimes fit the remaining allowance?", + "why_it_matters": "The decoder and scalar K core do not supply the cross-cube native transfer, so no complete kappa improvement follows.", + "first_step": "Give one chronological H word with original inputs, physical charts, dirty reads, output returns and the full paid and productive profile; test it against PROOF.md section 7.", + "blocked_by": "No source-compatible native H word or fully charged lifecycle is supplied." + }, + { + "question": "Can changed main paths or a changed caller inventory remove the native-lift obstruction?", + "why_it_matters": "For k>=7 the declared main paths already fail with copies and helpers free; the three- and five-factor models also fail after the separated-module lower bound.", + "first_step": "Give the new target jobs, paid paths, compatible target reads and complete lifecycle. Compare its exact moment before expanding the construction.", + "blocked_by": "No such native schedule or completed caller is supplied." + } + ] +} diff --git a/research/odd-e8-direct-sum/VERIFY.json b/research/odd-e8-direct-sum/VERIFY.json new file mode 100644 index 0000000000..c45e305351 --- /dev/null +++ b/research/odd-e8-direct-sum/VERIFY.json @@ -0,0 +1,62 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/coded-native-caller/NORMALIZERS.json", + "research/native-center-free-code/SOURCE-WORD.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Authenticate the literal E8 input; regenerate all exact geometry, decoder, core and budget data; compare RESULT.json; reject four data or coefficient corruptions. No native supplier or outer calculation." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Authenticate the literal E8 input; regenerate all exact geometry, decoder, core and budget data; compare RESULT.json; reject four data or coefficient corruptions. No native supplier or outer calculation." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/native_lift.py" + ], + "timeout_seconds": 60, + "checks": "Authenticate the base code and native helper paths; check the spectral and operator-pencil identities, two rejection controls and exact cost gates; compare NATIVE-LIFT.json. Infinite ranges use the written rank and monotonicity proofs. No native producer replay." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/native_lift.py" + ], + "timeout_seconds": 60, + "checks": "Authenticate the base code and native helper paths; check the spectral and operator-pencil identities, two rejection controls and exact cost gates; compare NATIVE-LIFT.json. Infinite ranges use the written rank and monotonicity proofs. No native producer replay." + } + ] +} diff --git a/research/odd-e8-direct-sum/native_lift.py b/research/odd-e8-direct-sum/native_lift.py new file mode 100644 index 0000000000..a3eef985b5 --- /dev/null +++ b/research/odd-e8-direct-sum/native_lift.py @@ -0,0 +1,271 @@ +"""Check the separated native-lift cost gate for the odd E8 family. + +This is a lower bound for a declared module interface, not all producers. +Prepared for Ali Romman with OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as F +from functools import cache +from hashlib import sha256 +from math import comb, isqrt +from pathlib import Path +import argparse +import gzip +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +SOURCE = ROOT/'research/native-center-free-code/SOURCE-WORD.json.gz' +NORMAL = ROOT/'research/coded-native-caller/NORMALIZERS.json' +SOURCE_SHA = 'cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd' +NORMAL_SHA = 'ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da' +EXPONENT = F(151, 50000) + + +def need(value, message): + if not value: + raise ValueError(message) + + +def rank(matrix): + rows = [[F(x) for x in row] for row in matrix] + pivot = 0 + for col in range(len(rows[0])): + hit = next((i for i in range(pivot, len(rows)) if rows[i][col]), None) + if hit is None: + continue + rows[pivot], rows[hit] = rows[hit], rows[pivot] + scale = rows[pivot][col] + rows[pivot] = [x/scale for x in rows[pivot]] + for i in range(pivot+1, len(rows)): + scale = rows[i][col] + rows[i] = [x-scale*y for x,y in zip(rows[i], rows[pivot])] + pivot += 1 + return pivot + + +def spectral_contract(): + raw = NORMAL.read_bytes() + need(sha256(raw).hexdigest() == NORMAL_SHA, 'Normalizer bytes changed') + data = json.loads(raw) + roots = list(zip(*data['mode_columns'])) + supports = [tuple(j for j,x in enumerate(row) if x) for row in roots] + C4 = [[sum(x*y for x,y in zip(a,b)) for b in roots] for a in roots] + B4 = [[x if supports[i] == supports[j] else 0 for j,x in enumerate(row)] + for i,row in enumerate(C4)] + for i in range(112): + for j in range(112): + need(sum(B4[i][t]*B4[t][j] for t in range(112)) == 8*B4[i][j], + 'The cube projection identity failed') + need(sum(B4[i][t]*C4[t][j] for t in range(112)) == 8*C4[i][j], + 'The full code must lie in the cube subspace') + need(sum(C4[i][i] for i in range(112)) == 448, 'The trace changed') + need(all(sum(data['mode_columns'][a][i]*data['mode_columns'][b][i] + for i in range(112)) == 56*(a == b) + for a in range(8) for b in range(8)), 'The full code covariance failed') + return {'kernel_dimension':56, 'active_dimension':56, + 'active_eigenvalues':{'2':48,'-12':8}} + + +def helper_profile(c,word): + paid,targets = Counter(),Counter() + for owner in range(224,632): + steps = [e for e in word if e[0] == 'climb' and e[2] == owner] + need(all(e[-1] == len(c['frames'][e[4]])-len(c['frames'][e[3]]) > 0 + for e in steps), 'A helper climb has the wrong rank') + segments = [e[-1] for e in steps] + width = len(c['frames'][c['final'][owner]])-len(c['frames'][c['start'][owner]]) + need(sum(segments) == width and width > 0, 'A helper path does not partition its target') + paid.update(segments) + targets[width] += 1 + need(paid == {1:1513,2:201,3:432,4:50,5:12}, 'Helper paid profile changed') + need(targets == {4:28,7:7,8:47,9:326}, 'Helper target profile changed') + return paid,targets + + +def helper_bill(): + raw = gzip.decompress(SOURCE.read_bytes()) + need(sha256(raw).hexdigest() == SOURCE_SHA, 'Native payload changed') + source = json.loads(raw) + c = source['canonical'] + profiles = [helper_profile(c,source['programs'][direction]) + for direction in ('forward','backward')] + need(profiles[0] == profiles[1], 'The two orientations have different helper bills') + bad = source['programs']['forward'][:] + omitted = next(i for i,e in enumerate(bad) if e[0] == 'climb' and e[2] >= 224) + bad.pop(omitted) + try: + helper_profile(c,bad) + except ValueError: + pass + else: + raise ValueError('An omitted helper climb was accepted') + return profiles[0] + + +def check_face(X,Y): + for a in range(2): + for b in range(2): + for c in range(2): + for d in range(2): + for e in range(2): + for f in range(2): + ha,hb = (2,-12)[a],(2,-12)[b] + lhs = ha*int(a == d)*X[2*b+c][2*e+f]+hb*int(b == e)*Y[2*a+c][2*d+f] + rhs = (ha+hb-F(ha*hb,2))*int(a == d and b == e and c == f) + need(lhs == rhs, 'The two-factor decomposition failed') + + +def face_fixtures(): + # The proof permits an arbitrary operator S on the passive space. + matrices = [[[F(1,4),0],[0,F(-1,4)]], + [[F(1,4),1],[0,F(1,4)]], + [[0,1],[-1,0]]] + receipts = [] + for S in matrices: + pencils = [[[F(a)*int(i == j)+F(b)*S[i][j] for j in range(2)] for i in range(2)] + for a,b in ((F(1,2),2),(4,-12),(F(1,2),-2),(4,12))] + ranks = list(map(rank,pencils)) + cost = 48*(ranks[0]+ranks[2])+8*(ranks[1]+ranks[3]) + need(cost >= 64*2, 'The operator-pencil lower bound failed') + X = [[pencils[a//2][a%2][b%2] if a//2 == b//2 else 0 for b in range(4)] for a in range(4)] + Y = [[pencils[2+a//2][a%2][b%2] if a//2 == b//2 else 0 for b in range(4)] for a in range(4)] + check_face(X,Y) + try: + check_face(X,X) + except ValueError: + pass + else: + raise ValueError('The reversed pencil sign was accepted') + receipts.append({'pencil_ranks':ranks,'weighted_rank_sum':cost}) + return receipts + + +def log_series(z): + value = F(0) + term = z + for j in range(24): + value += 2*term/(2*j+1) + term *= z*z + remainder = 2*term/(49*(1-z*z)) + return value, value+remainder + + +@cache +def power_interval(n): + if n == 1: + return F(1), F(1) + shift = n.bit_length()-1 + low2,high2 = log_series(F(1,3)) + low,high = log_series(F(n-2**shift,n+2**shift)) + low,high = low+shift*low2,high+shift*high2 + unit = 10**30 + low = F((low*unit).__floor__(),unit)*EXPONENT + high = F((high*unit).__ceil__(),unit)*EXPONENT + terms = [] + for x in (low,high): + total,term = F(1),F(1) + for j in range(1,19): + term *= x/j + total += term + terms.append(total) + next_term = term*high/19 + upper_exp = terms[1]+next_term/(1-high/20) + need(0 <= low <= high < 1, 'The exponential enclosure domain failed') + return F(n)/upper_exp,F(n)/terms[0] + + +def small_interval(low,high): + unit = 10**18 + return [str(F((low*unit).__floor__(),unit)),str(F((high*unit).__ceil__(),unit))] + + +def gate(paid,targets,copy_ranks): + v = 112**3 + channels = 3*(2*56-48)*56 + need(channels == 10752, 'The channel floor changed') + helper_low = sum(n*power_interval(r)[0] for r,n in paid.items())-sum(n*power_interval(r)[1] for r,n in targets.items()) + helper_high = sum(n*power_interval(r)[1] for r,n in paid.items())-sum(n*power_interval(r)[0] for r,n in targets.items()) + copy_counts = {copy_ranks[0]:21504,copy_ranks[1]:512} + local_low = 10+power_interval(8)[0]+2*power_interval(15)[0] + local_high = 10+power_interval(8)[1]+2*power_interval(15)[1] + local_low += sum(n*power_interval(r)[0] for r,n in copy_counts.items())/v+channels*helper_low/v + local_high += sum(n*power_interval(r)[1] for r,n in copy_counts.items())/v+channels*helper_high/v + records = [] + for stages in range(3,63,2): + m = 24*stages+1 + cap = isqrt((m*m-1)//2) + target_low,target_high = [F(stages-1,stages)*x for x in power_interval(m)] + idle_low,idle_high = [F(24*(stages-3),cap)*x for x in power_interval(cap)] + lower,upper = target_low-idle_high-local_high,target_high-idle_low-local_low + need(upper < 0, 'The separated lift was not excluded') + records.append({'stages':stages,'ambient':m,'idle_cap':cap, + 'margin_per_port_per_local_call':small_interval(lower,upper)}) + tail_upper = F(49,1513)*power_interval(1513)[1]-local_low + need(tail_upper < 0, 'The all-stage tail gate failed') + return {'copy_ranks':copy_ranks,'module_channels_lower_bound':channels, + 'module_fraction':'6/7','helper_cost_per_port':small_interval(helper_low/112,helper_high/112), + 'finite_stages':records,'tail_from_stage':63, + 'tail_margin_upper':small_interval(tail_upper,tail_upper)[1]} + + +def larger_factor_gates(paid,targets): + helper_low = sum(n*power_interval(r)[0] for r,n in paid.items())-sum(n*power_interval(r)[1] for r,n in targets.items()) + k = 5 + v = 112**k + copy_low = sum(comb(k,j)*8**j*112**(k-j)*power_interval(6*j+2)[0] + for j in range(3,6))/v + local_low = 16+power_interval(14)[0]+2*power_interval(25)[0] + local_low += copy_low+F(5,24)*helper_low/112 + records = [] + for stages in (3,5): + m = 40*stages+1 + cap = isqrt((m*m-1)//2) + upper = F(stages-1,stages)*power_interval(m)[1]-F(40*(stages-3),cap)*power_interval(cap)[0]-local_low + need(upper < 0, 'The five-factor finite gate failed') + records.append({'stages':stages,'margin_upper':small_interval(upper,upper)[1]}) + # For N>=7, even a parent-width idle child does not fit. The derivative + # bound in the proof makes this upper bound decrease with N. + tail_upper = F(80+1-F(1,7),281)*power_interval(281)[1]-local_low + need(F(1,5)+F(1,40*25) < EXPONENT*(80+F(4,5)), 'The five-factor stage monotonicity bound failed') + need(tail_upper < 0, 'The five-factor infinite tail failed') + pent = {'module_fraction':'5/24','finite_stages':records, + 'tail_from_stage':7,'tail_margin_upper':small_interval(tail_upper,tail_upper)[1]} + # For all k>=7 grant every copy and helper for free. The proof shows + # that the remaining main-path bound decreases with k. + main_low = 22+power_interval(20)[0]+2*power_interval(35)[0] + upper3 = F(2,3)*power_interval(169)[1]-main_low + upper5 = F(112+F(4,5),281)*power_interval(281)[1]-main_low + need(F(1,5)+F(1,56*25) < EXPONENT*(112+F(4,5)), 'The large-factor stage monotonicity bound failed') + need(upper3 < 0 and upper5 < 0, 'The all-factor main-path gate failed') + large = {'factors_from':7,'all_copies_and_helpers_granted_free':True, + 'stage3_upper':small_interval(upper3,upper3)[1], + 'stages_from5_upper':small_interval(upper5,upper5)[1]} + return {'five_factors':pent,'all_larger_odd_factors':large} + + +def run(): + spectrum = spectral_contract() + paid,targets = helper_bill() + result = {'status':'PASS_ODD_E8_SEPARATED_NATIVE_LIFT_GATE', + 'test_exponent':str(EXPONENT),'spectral_contract':spectrum, + 'helper_paid':dict(paid),'helper_targets':dict(targets), + 'controls':['omitted_helper_climb','reversed_pencil_sign'], + 'operator_pencil_fixtures':face_fixtures(), + 'gates':[gate(paid,targets,(14,20)),gate(paid,targets,(15,22))], + 'larger_factor_gates':larger_factor_gates(paid,targets), + 'scope':'Separated H_i modules with one frozen complete helper bank per coefficient channel; declared main paths and idle cap. Other coefficient maps are granted free. Joint producers, address-dependent coefficients, shared helper protocols, other module words and changed caller profiles are outside the result.'} + return result + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write',action='store_true') + args = parser.parse_args() + result = json.loads(json.dumps(run())) + receipt = HERE/'NATIVE-LIFT.json' + if args.write: + receipt.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n',encoding='utf-8') + else: + need(result == json.loads(receipt.read_text()), 'The native-lift receipt differs') + print(result['status'],'channels=10752 exponent=151/50000 odd_factors=all_at_least_3 odd_stages=all_at_least_3') diff --git a/research/odd-e8-direct-sum/verify.py b/research/odd-e8-direct-sum/verify.py new file mode 100644 index 0000000000..6033dd1483 --- /dev/null +++ b/research/odd-e8-direct-sum/verify.py @@ -0,0 +1,332 @@ +"""Check an odd direct-sum E8 fitting family and its decoder tariff. + +The finite checks certify the base data and stated tensor identities. +The price screen omits a native producer. It does not certify kappa. +Prepared for Ali Romman with OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as F +from hashlib import sha256 +from itertools import product +from math import comb +from pathlib import Path +import json +from decimal import Decimal, localcontext +import argparse + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +SOURCE = ROOT / 'research/coded-native-caller/NORMALIZERS.json' +SOURCE_HASH = 'ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da' + + +def need(value, message): + if not value: + raise ValueError(message) + + +def basis(rows): + pivots = {} + for value in rows: + while value: + key = value.bit_length() - 1 + if key in pivots: + value ^= pivots[key] + else: + pivots[key] = value + break + return list(pivots.values()) + + +def dot(x, y): + return (x & y).bit_count() % 2 + + +def gram_rank(left, right): + return len(basis(sum(dot(x, y) << j for j, y in enumerate(right)) + for x in left)) + + +def cartesian_span(parts): + first = sum(part[0] << (9 * i) for i, part in enumerate(parts)) + return basis([first] + [(x ^ part[0]) << (9 * i) + for i, part in enumerate(parts) for x in part[1:]]) + + +def solve(matrix, values): + rows = [[F(x) for x in row] + [F(value)] + for row, value in zip(matrix, values)] + n = len(rows) + for j in range(n): + pivot = next(i for i in range(j, n) if rows[i][j]) + rows[j], rows[pivot] = rows[pivot], rows[j] + scale = rows[j][j] + rows[j] = [x / scale for x in rows[j]] + for i in range(n): + if i != j: + scale = rows[i][j] + rows[i] = [x - scale * y for x, y in zip(rows[i], rows[j])] + return [row[-1] for row in rows] + + +def coefficients(k): + first = (k + 1) // 2 + # For e equal coordinates, all k-e other coordinates must use C. + # Every odd e