diff --git a/research/p2-full-history-deficit/INPUTS.json b/research/p2-full-history-deficit/INPUTS.json new file mode 100644 index 0000000000..5bdfa71143 --- /dev/null +++ b/research/p2-full-history-deficit/INPUTS.json @@ -0,0 +1,72 @@ +[ + { + "local_path": "inputs/algebra.py", + "path": "research/passive-saved-query-ceiling/evidence/algebra.py", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "0fffec34c573ea98dbf083196c0b92fd173495d2", + "sha256": "f824a46d061be2326c544f2f3637eec0c2d2a38800848c2da2f2aa409cad43dc" + }, + { + "local_path": "inputs/clifford_exact.py", + "path": "research/passive-saved-query-ceiling/evidence/inputs/clifford_exact.py", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "local_path": "inputs/NORMALIZERS.json", + "path": "research/passive-saved-query-ceiling/evidence/inputs/NORMALIZERS.json", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "local_path": "inputs/INVOLUTIVE-WORD.json.gz", + "path": "research/passive-saved-query-ceiling/evidence/inputs/INVOLUTIVE-WORD.json.gz", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "eac634fb1d09428aa6715a47d652ae701dd0efc5", + "sha256": "ff2999f022e93e05a250160808aa3c32a08041039d7edfb01068c0308f50c138" + }, + { + "local_path": "inputs/SOURCE-PROOF.md", + "path": "research/passive-saved-query-ceiling/evidence/frozen/pr4948-saved-query-macro-gate/PROOF.md", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "3933f848e5bd6e253cd78ff0a15a15558aaa9d55", + "sha256": "02ccd0a9d93b381286e441afa4c28a902db153a4d0dae4d761cf813ede9f2f6d" + }, + { + "local_path": "inputs/UNIFORM-ALPHABET-ADDENDUM.md", + "path": "research/passive-saved-query-ceiling/evidence/frozen/pr4948-saved-query-macro-gate/UNIFORM-ALPHABET-ADDENDUM.md", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "d742381500d94759a3278050d86b7d1dcc726a7e", + "sha256": "f51448dc7551e8b61613c642d9487282f06e2ddc6274b1693276920688d5496f" + }, + { + "local_path": "inputs/OWNED-RESET-CLARIFICATION.md", + "path": "research/passive-saved-query-ceiling/evidence/frozen/pr4948-saved-query-macro-gate/OWNED-RESET-CLARIFICATION.md", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "75339d65d966610b4c035436ca93c2fd7417142c", + "sha256": "bd30b35ff2364fb6b430e31bd6cc3de969454a3e81d73adf4fc2f633ac0d9484" + }, + { + "local_path": "inputs/bank_span.py", + "path": "research/passive-saved-query-ceiling/evidence/frozen/pr4948-saved-query-macro-gate/bank_span.py", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "513be55ff4c630dda408244223a0bfed6b76ad49", + "sha256": "55c5d1761812d847188fa893988decc491a40151ad45f3fb806e7f8c3337229d" + }, + { + "local_path": "inputs/POINTWISE-PROOF.md", + "path": "research/clifford-pointwise-faithfulness/PROOF.md", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "465009d9d1b6947e80e6f1e868022f47ddab1f3c", + "sha256": "45483e4b5f604a5e70602c5caaa4394d4a0d0d1a6d0b6e8a93b836d50b23f764" + }, + { + "local_path": "inputs/HISTORY-REPAIR.md", + "path": "research/clifford-pointwise-faithfulness/REPAIR.md", + "commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "git_blob": "417748bf8620ef23330dfd30d823b4e89370d263", + "sha256": "4b1ec6a8c41dd8e5d49f33c926738b18a41b7cf28d8e81b68faa2ddc59fa3e23" + } +] diff --git a/research/p2-full-history-deficit/OBSERVATIONS.json b/research/p2-full-history-deficit/OBSERVATIONS.json new file mode 100644 index 0000000000..f1165fa604 --- /dev/null +++ b/research/p2-full-history-deficit/OBSERVATIONS.json @@ -0,0 +1,1046 @@ +[ + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [], + [ + { + "coefficient": "-1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut0_after_right_boundary:0" + }, + { + "columns": [ + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [], + [] + ], + "label": "cut0_after_right_boundary:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut0_after_right_boundary:2" + }, + { + "columns": [ + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ] + ], + "label": "cut0_after_right_boundary:3" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [ + -1 + ] + } + ], + [], + [ + { + "coefficient": "-1", + "fresh": [ + 0, + 0 + ], + "word": [ + -1 + ] + } + ], + [] + ], + "label": "paid_response0_Qinv_x" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [], + [ + { + "coefficient": "-1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut1_after_thin0:0" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [ + 2, + -1 + ] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [ + { + "coefficient": "-1", + "fresh": [ + 0, + 0 + ], + "word": [ + 2, + -1 + ] + } + ], + [] + ], + "label": "cut1_after_thin0:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut1_after_thin0:2" + }, + { + "columns": [ + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ] + ], + "label": "cut1_after_thin0:3" + }, + { + "columns": [ + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + 2, + 1 + ] + } + ], + [], + [] + ], + "label": "cut2_after_FULL1:0" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [] + ], + "label": "cut2_after_FULL1:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut2_after_FULL1:2" + }, + { + "columns": [ + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ], + [], + [ + { + "coefficient": "1", + "fresh": [ + 0, + 0 + ], + "word": [] + } + ] + ], + "label": "cut2_after_FULL1:3" + }, + { + "columns": [ + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + 2, + 1 + ] + } + ], + [], + [] + ], + "label": "cut3_after_IDLE:0" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [] + ], + "label": "cut3_after_IDLE:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut3_after_IDLE:2" + }, + { + "columns": [ + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ] + ], + "label": "cut3_after_IDLE:3" + }, + { + "columns": [ + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [] + ], + "label": "paid_response2_Qinv_C1_x" + }, + { + "columns": [ + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + 2, + 1 + ] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut4_after_bridge_plus_and_thin2:0" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [], + [], + [] + ], + "label": "cut4_after_bridge_plus_and_thin2:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut4_after_bridge_plus_and_thin2:2" + }, + { + "columns": [ + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ] + ], + "label": "cut4_after_bridge_plus_and_thin2:3" + }, + { + "columns": [ + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + 2, + 1 + ] + } + ], + [], + [] + ], + "label": "cut5_after_bridge_minus:0" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [], + [], + [] + ], + "label": "cut5_after_bridge_minus:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ], + [] + ], + "label": "cut5_after_bridge_minus:2" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [] + } + ] + ], + "label": "cut5_after_bridge_minus:3" + }, + { + "columns": [ + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + 2, + 1 + ] + } + ], + [], + [] + ], + "label": "cut6_after_FULL3:0" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [], + [], + [] + ], + "label": "cut6_after_FULL3:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [] + }, + { + "coefficient": "-1", + "fresh": [ + 1, + 1 + ], + "word": [ + 3, + 2 + ] + } + ], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 1 + ], + "word": [ + 3, + 1 + ] + } + ] + ], + "label": "cut6_after_FULL3:2" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [ + -1, + 2 + ] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [] + } + ] + ], + "label": "cut6_after_FULL3:3" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 1 + ], + "word": [ + -1, + 2 + ] + }, + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [ + -1, + 3 + ] + } + ], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 1 + ], + "word": [] + } + ] + ], + "label": "paid_response4_Qinv_C3_x" + }, + { + "columns": [ + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 0 + ], + "word": [ + 2, + 1 + ] + } + ], + [], + [] + ], + "label": "cut7_after_thin4:0" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [], + [], + [] + ], + "label": "cut7_after_thin4:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [] + }, + { + "coefficient": "-1", + "fresh": [ + 1, + 1 + ], + "word": [ + 3, + 2 + ] + } + ], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 1 + ], + "word": [ + 3, + 1 + ] + } + ] + ], + "label": "cut7_after_thin4:2" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [ + -1, + 3 + ] + } + ], + [] + ], + "label": "cut7_after_thin4:3" + }, + { + "columns": [ + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + -1, + 2 + ] + } + ], + [], + [], + [] + ], + "label": "cut8_after_final_standard_boundary:0" + }, + { + "columns": [ + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 0 + ], + "word": [ + 2, + 1 + ] + } + ], + [], + [] + ], + "label": "cut8_after_final_standard_boundary:1" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [ + -1, + 3 + ] + } + ], + [] + ], + "label": "cut8_after_final_standard_boundary:2" + }, + { + "columns": [ + [], + [], + [ + { + "coefficient": "-1", + "fresh": [ + 1, + 1 + ], + "word": [] + }, + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [ + 3, + 2 + ] + } + ], + [ + { + "coefficient": "1", + "fresh": [ + 1, + 1 + ], + "word": [ + 3, + 1 + ] + } + ] + ], + "label": "cut8_after_final_standard_boundary:3" + } +] diff --git a/research/p2-full-history-deficit/PROOF.md b/research/p2-full-history-deficit/PROOF.md new file mode 100644 index 0000000000..19d144ec49 --- /dev/null +++ b/research/p2-full-history-deficit/PROOF.md @@ -0,0 +1,227 @@ +# The complete fixed caller needs at least 225 new returns + +The model is the frozen p2 caller of Dugongue's PR4948 and Chris R's PR4978. +Keep all 39 observed bank fields, all original paid inputs and all required +outputs. Ordinary operations are scalar row operations and left actions from +the full columnwise monomial Clifford algebra. All storage, COPY and owned +reset may be free. New paid returns may be arbitrary linear fields, may use +older new returns, and have the same capacity as one original field. Changing +an original paid input, observing a native internal prefix, changing capacity, +using noncolumnwise maps or changing target credit is outside this contract. + +At every width f>=72, the complete target needs at least 225 new returns. +In the enlarged arbitrary-linear-oracle model, 240 returns suffice. The exact +minimum between these bounds is open. This is not a native 240-call word. + +## 1. Source and algebra + +Use n=17 axes: shared axis 0, first fresh axes 1..8 and second fresh axes 9..16. +Write D1,D3 for the two rank-eight Gaussian blocks and Q for the shared rank-one +Gaussian. Put D=D1 D3 and + + C_s = diag(K_s)^-1 F^T diag(K_s), s=1,3. + +The literal source gives C_s^2=I, [C_s,D_s Q]=0 and [C_s,D_t]=0 for s!=t. +The signed K words are monomial. Their binary linear parts G_i are orthogonal. +The verifier checks all 112 signed commutations with the full local Gaussian, +including absolute phase. It also checks the actual transpose and (F^T)^2=I. +The source scalar coefficients stay outside tensor powers. + +There are 448 independent original main fields and 816 independent autonomous +helper outputs. Snapshots add no independent input or target credit. On a +restriction to main inputs, the autonomous helper outputs vanish. This does +not grant native internal helper states as observations. + +Let H be the finite projective monomial Clifford group on 17 axes. At fixed f, +let A be the span of its tensor lifts, with the phase factors retained in its +multiplication. The credited pointwise theorem in PR5526 gives dim(A)=h=|H| +for f>=72. It also makes different full-Clifford projective classes linearly +independent at these widths. Thus distinct left H cosets give disjoint free +A-modules. Multiplication by a Clifford unitary is injective on A. + +This uses the full fixed Clifford universe, not a width-dependent alphabet. +The pinned uniform-alphabet addendum and owned-reset clarification apply. +No inverse-uncompute cost is used in the lower bound. + +## 2. All four banks, before the coupled argument + +`OBSERVATIONS.json` records all 156 bank coefficients in the 39 observations. +The D-right and credited D-left normal forms agree on every coefficient. +The union of the D-right term families is: + +| Original bank | Term families | +|---|---| +| 0 | I; Q^-1; C1 Q^-1; Q^-1 C1 D1 | +| 1 | I; D1; C1 Q D1 | +| 2 | I; Q^-1; C1 Q^-1; D1; Q^-1 C1 D1; D; C3 C1 D; Q^-1 C1 D; Q^-1 C3 D | +| 3 | I; D1; D; C3 Q D | + +The four diagonal targets have grades 9,9,17,17. The actual transpose has +104 zero-diagonal columns and eight diagonal entries equal to 12. All 5,832 +nonzero native pair coefficients are checked. Each zero-diagonal column has +52 late words of grade 7 on its own fresh block. Adding the other untouched +rank-eight block gives grade 15. Left monomial factors preserve grade. + +For the 104 zero-diagonal columns, bank 0 therefore has grades {0,1,7}; bank 2 +has grades {0,1,7,8,15,16}. This gives 208 grade-separated target columns. +The other 240 columns have explicit target-grade terms. Thus 208 is the largest +set obtained by this columnwise grade-absence test. Grade presence does not +mean recovery. The coupled argument below also excludes the eight remaining +columns in each negative bank. + +## 3. Coupled rows exclude all 112 columns of each negative bank + +Consider E_s=Q^-1 C_s D_s, or E_s=Q^-1 C_s D when both blocks are present. +Its (i,j) entry is a nonzero scalar times + + W_ij = Q^-1 K_i^-1 K_j D_s + +on a supported pair. For fixed j, these words lie in distinct left H cosets +as i varies. Here is a direct invariant proof. + +A monomial left factor preserves the row space of the X block of a symplectic +matrix. In these source words the X block has an invertible linear part T, +so its row space has unique form [I,R]. For W_ij, + + R = E_s + u_ij u_ij^T, u_ij=G_j^-1 G_i e0, (1) + +where E_s is the diagonal mask of the fresh Gaussian axes. For both blocks, +replace E_s by the mask of all 16 fresh axes. All 112 vectors G_i e0 are +distinct. Thus the u_ij are distinct at fixed j. Over F2 the diagonal of +u u^T is u, so (1) gives distinct cosets. The same proof works in either +embedded fresh block. All signs and scalar phases leave this invariant fixed. + +Every row i of F^T has a nonzero entry in at least one zero-diagonal column j. +Suppose an A-linear combination of the E_s rows has no grade-7 (or grade-15) +component on those 104 columns. In a fixed such column, distinct cosets prevent +cancellation between different i. A nonzero scalar and a Clifford word are +injective on its left coefficient a_i. Thus each supported a_i is zero. +The row witnesses cover all i, so every a_i is zero. + +For original bank 0, the other observations have grades 0 or 1. Its target +module has grade 9. The preceding argument proves that its full 112h-dimensional +target module intersects the available history only at zero, including the +eight selected columns. This is stronger than the 104-column grade test. + +## 4. The last positive bank forces at least one more return + +Set the original bank-1 input to zero; this restriction only helps a decoder. +Separate bank 0 from banks 2 and 3, granting independent use of their projected +histories. This enlarges the available module and is valid for a lower bound. +Write x,z for the 112-field inputs in banks 2 and 3, and T_-=D Q^-1, T_+=D Q. +All observations before D3 have grade at most 9 in these columns. +Every later high-layer observation lies in the A-span of these three row banks: + + Arow = Q^-1 C3 D x, + Brow = Q^-1 C1 D x + D z, + Crow = (I-C3 C1)D x - C3 T_+ z. (2) + +The third paid response is Arow-Brow. The verifier checks (2), the zero +coefficients of the other two original inputs, and the membership of every +high-layer observation. Old terms added at final bridges have grade at most 9. + +Let a,b,c be row vectors over A, and ask when a*Arow+b*Brow+c*Crow belongs to +the module of the two prescribed targets T_-x and T_+z. Its z coefficient of +grade 16 is b*D. No other term can cancel that grade there, so b=0. In its x +coefficient, a*Arow has grade-15 off-diagonal components. The other remaining +x term has grade 16. Section 3 therefore gives a=0. What remains is allowed +only if + + c L = 0, where L=I-C3 C1. (3) + +Let r be the complex rank of right multiplication by L on row vectors A^112. +The kernel in (3) has dimension 112h-r. Since C3 is invertible, its T_+z image +has the same dimension. The two-target module has dimension 224h. Its deficit +modulo this enlarged history is therefore 112h+r. Bank 0 adds another 112h. +The complete selected target deficit is at least + + 224h+r. (4) + +The source proves r>0. In entry L_(0,0), the k=0 term of C3 C1 is literally +identity with coefficient 12^2=144. Every other supported k has a nonidentity +binary linear part in the 17-axis product + + K_(3,0)^-1 K_(3,k) K_(1,k)^-1 K_(1,0). + +The finite checker verifies this for every supported k. No such term is +projectively identity. Thus the identity coefficient of L_(0,0) is -143. +Pointwise Clifford faithfulness makes L nonzero for every f>=72, so r>0. + +One new same-capacity return adds a cyclic A-module of dimension at most h. +This remains true for arbitrary linear returns outside the Clifford span and +for feedback among new calls. Existing paid input expressions remain fixed. +To cover (4), q*h>=224h+r. Since q is an integer and r>0, + + q >= 225. (5) + +This proof does not compute r/h. It must not be read as an exact minimum of 225. + +## 5. A 240-return upper bound in the enlarged oracle model + +The literal F^T is an involution with trace 96 and dimension 112. Therefore +P=(I-F^T)/2 is an idempotent of rank eight. Factor it over Q as P=UV with eight +columns in U. Then + + P_s=diag(K_s)^-1 P diag(K_s)=U_s V_s, + I-C3 C1=2P1+2P3-4P3 P1. (6) + +The entries of U_s,V_s lie in A. Ask an arbitrary linear oracle for the 112 +negative targets in bank 0 and the 112 negative targets in bank 2. Ask also +for the eight rows V1 D x and the eight rows V3 D x. Ordinary A operations +assemble L D x from (6). Subtract it from Crow and apply -C3 to obtain T_+z. +The first positive bank is already available: its FULL1 X row is +-C1 D1 Q times that original input, so multiplication by -C1 recovers it. +All original helper outputs stay as in the frozen caller. Total: 240 returns. + +This is an explicit linear-oracle construction with 16 factored repair rows. +It is not a native supplier or a claim that these rows cost one H1 each. +The exact optimum in this enlarged model remains in [225,240]. + +## 6. Price and approximation consequences + +The source declares the optimistic invoice + + Ppaid={1:4754,2:824,3:1020,4:254,5:80,8:224}, + T={4:56,7:14,8:94,9:876,17:224}. + +Adding only 225 rank-one jobs is the cheapest allowed tariff relaxation. +The nine concave-order hinges are all positive, with final rank-mass deficit +129. Thus every increasing power tariff r^t, 0= lambda_f (1-q/208)_+, + lambda_f=1/9 for f>=72; lambda_f=125/126 for f>=84. + +At q<=36 this is at least 5375/6552 from width 84. At q<=95 it is at least +14125/26208. The predecessor's reference-tariff margin below 37 and its +all-power profitable-return cap of 95 are credited premises, not newly priced +roots here. The algebraic 224-column result does not itself prove the same +quantitative angle bound on 224 columns. No such extension is claimed. + +## Open next questions + +The remaining exact optimization is the rank of right multiplication by +I-C3 C1 on A^112, including the width-dependent phase cocycle, and whether +that dimension bound is attained by cyclic generators. This controls the +remaining gap between 225 and the 240-return construction. The finite native +grade census alone cannot determine that module rank. + +A productive escape must change an original paid input, the observation set, +the ordinary alphabet, target credit or the supplier tariff. Bind a literal +changed caller and its complete bill before claiming that it evades this result. + +## Attribution + +Dugongue supplies PR4948 and its native source. Chris R / Clear1nsight supplies +PR4978, the two mandatory clarifications and the independent D-left interpreter. +Ali Romman supplies PR5526 and the earlier PR5449 history-dimension formulation. +josecarlosgonzalezroque-design supplies the PR5570 bridge audit and source-binding +handoff. Retain Cao Yifan, Cinna Davis, DLamdata, zxv and the native, controller, +Clifford and interval lineage. The rank-nullity and idempotent factorization +arguments are classical. New full-bank and coupled-module analysis: Ali Romman +with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/p2-full-history-deficit/README.md b/research/p2-full-history-deficit/README.md new file mode 100644 index 0000000000..a6e6cf2cf0 --- /dev/null +++ b/research/p2-full-history-deficit/README.md @@ -0,0 +1,112 @@ +# Bind and strengthen the complete p2 repair deficit + +The frozen coded p2 caller needs at least **225 new same-capacity linear +returns** at every width f>=72. The previous PR5526 bound used 104 columns. +This package binds all four original banks to the literal observation list, +then uses coupled rows to reach 224 negative targets and one further positive +output obstruction. It also gives a 240-return construction in the enlarged +arbitrary-linear-oracle model. The exact minimum is in [225,240]. + +No new kappa or physical supplier is claimed. The constructive upper bound is +not a 240-H1 native word. Even the lower bill of 225 added H1 jobs makes the +complete frozen optimistic invoice adverse for every power tariff r^t, +0=84 its squared operator-error floor is + 5375/6552. The algebraic 224-column argument does not by itself give that + same quantitative angle bound on all 224 columns. + +`RESULT.json` gives the full column classification and certificate hashes. +`OBSERVATIONS.json` exposes the complete ordered trace. Source pins are in +`SOURCES.json` and `INPUTS.json`. All inputs are byte-exact copies. Replays +need no network, pending Git object or predecessor executable checkout. +The imported D-left algebra and phase interpreter retain their original +notices. The D-right interpreter and binary grade calculations are new. + +```sh +python3.12 -B scripts/research_package.py --package research/p2-full-history-deficit +``` + +Normal and optimized Python run the same exact checks. Controls include the +complete uncoded endpoint, selected diagonal terms, a missing bridge, falsely +homogeneous frames and a code row with no off-diagonal witness. The written +proof supplies the uniform module argument; finite checks are not a proof +kernel. The core pointwise Clifford theorem and its general paid-return +lemma are credited premises, with their exact proof files retained. + +## Maximization and remaining limits + +The initial full-column grade scan gave 208. Further work removed the +columnwise relaxation and reached all 224 negative targets. The complete +late-history analysis then exposed a further nonzero positive-output +obligation, giving 225. A rank-eight factorization supplies the 240-return +oracle construction and identifies the remaining exact optimization. +This is one contribution about the complete fixed caller, not separate +contributions for each intermediate bound. + +The exact rank of I-C3 C1 on the regular monomial algebra, including its +width-dependent phase cocycle, is not computed. Attainment of the lower +module bound by cyclic return generators is also open. Neither the full +native word nor compiler/precision/outer admission is re-proved here. +New paid input expressions, internal native observations, noncolumnwise maps, +different capacity, nonlinear operations and changed targets are outside the +proof. Hosted CI and independent human review are separate from local checks. + +## Open next questions + +1. Compute the regular-module rank of I-C3 C1 and the minimum cyclic-generator + count. This can close the [225,240] oracle gap. Start from the explicit + 17-axis monomial products; do not substitute a width-one matrix rank. +2. Supply one literal active-feed or changed-observation caller that defeats + the frozen-history premise, with a complete paid and target invoice. + The source-bound native and outer obligations remain necessary. + +## Attribution + +Dugongue: PR4948 and native inputs. Chris R / Clear1nsight: PR4978, the two +mandatory source clarifications and the D-left audit. Ali Romman: PR5526, +PR5449 and the pointwise/history tools. josecarlosgonzalezroque-design: +PR5570 and its source-binding handoff. Retain Cao Yifan, Cinna Davis, DLamdata, +zxv and the native/controller/Clifford/interval predecessors. +New full-bank analysis and verifier: Ali Romman, with substantial OpenAI +Codex assistance. Apache-2.0. No independent human acceptance is claimed. diff --git a/research/p2-full-history-deficit/RESULT.json b/research/p2-full-history-deficit/RESULT.json new file mode 100644 index 0000000000..8daa05c7f5 --- /dev/null +++ b/research/p2-full-history-deficit/RESULT.json @@ -0,0 +1,3100 @@ +{ + "any_profitable_q95_squared_error_width84": "14125/26208", + "bank_coefficients": 156, + "error_bound_columns": 208, + "grade_support": [ + [ + [ + 0, + 1, + 7, + 9 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7, + 9 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7, + 9 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7, + 9 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7, + 9 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7, + 9 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7, + 9 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7 + ], + [ + 0, + 1, + 7, + 9 + ] + ], + [ + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ], + [ + 0, + 8, + 9 + ] + ], + [ + [ + 0, + 1, + 7, + 8, + 9, + 15, + 16, + 17 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 9, + 15, + 16, + 17 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 9, + 15, + 16, + 17 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 9, + 15, + 16, + 17 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 9, + 15, + 16, + 17 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 9, + 15, + 16, + 17 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 9, + 15, + 16, + 17 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 15, + 16 + ], + [ + 0, + 1, + 7, + 8, + 9, + 15, + 16, + 17 + ] + ], + [ + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ], + [ + 0, + 8, + 16, + 17 + ] + ] + ], + "minimum_width": 72, + "missing_columns": [ + [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 21, + 22, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 87, + 88, + 89, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 109, + 110 + ], + [], + [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 21, + 22, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 87, + 88, + 89, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 109, + 110 + ], + [] + ], + "missing_per_bank": [ + 104, + 0, + 104, + 0 + ], + "module_extension": { + "all_negative_columns": 224, + "arbitrary_oracle_upper_bound": 240, + "complete_return_lower_bound": 225, + "negative_eigenspace_rank": 8, + "nonzero_leak_identity_coefficient": "-143", + "rejected_module_controls": [ + "homogeneous false frames", + "unwitnessed code row" + ], + "row_witnesses": [ + 1, + 2, + 1, + 1, + 1, + 1, + 8, + 1, + 2, + 3, + 4, + 5, + 2, + 3, + 4, + 5, + 1, + 1, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 6, + 1, + 2, + 3, + 4, + 5, + 1, + 3, + 4, + 5, + 1, + 1, + 1, + 2, + 2, + 2, + 3, + 3, + 4, + 2, + 1, + 1, + 1, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 3, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 4, + 3, + 3, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 6, + 1, + 1, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 1, + 1, + 1, + 1, + 8, + 1, + 2, + 3, + 4, + 5, + 1, + 2, + 3, + 4, + 5, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 3, + 3 + ] + }, + "native_pair_sha256": "3a23975f5f47165071e63b33b4fab0402e3837d94a3028ae2cf80051a5531d8b", + "necessary_returns": 225, + "new_kappa": null, + "observations": 39, + "original_columns": 448, + "reference_q36_squared_error_width84": "5375/6552", + "repair_hinges": { + "1": 6117, + "17": 129, + "2": 7255, + "3": 7569, + "4": 6863, + "5": 5959, + "7": 3991, + "8": 3021, + "9": 1921 + }, + "status": "PASS_P2_FULL_HISTORY_DEFICIT", + "supported_native_pairs": 5832, + "term_families": [ + 4, + 3, + 9, + 4 + ] +} diff --git a/research/p2-full-history-deficit/SOURCES.json b/research/p2-full-history-deficit/SOURCES.json new file mode 100644 index 0000000000..095c982619 --- /dev/null +++ b/research/p2-full-history-deficit/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "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" + } + ] +} diff --git a/research/p2-full-history-deficit/TASK.json b/research/p2-full-history-deficit/TASK.json new file mode 100644 index 0000000000..02b2dbc5c8 --- /dev/null +++ b/research/p2-full-history-deficit/TASK.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "original_card": { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. 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_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Bind all four banks of the fixed p2 history and prove the complete 225-return obstruction with a 240-return oracle construction.", + "scope_change_reason": "Take PR5570 full-source handoff, then maximize the argument across all targets and coupled rows.", + "bottleneck_link": "Identify the full frozen-history repair deficit and the exact remaining monomial-module rank, so changed callers do not assume free selected columns or a free last positive output.", + "budget_minutes": 90, + "stop_rule": "Classify all four banks and all 448 columns, strengthen by coupled cosets, and give a full oracle upper construction. Do not equate a finite native rank with the regular-module rank.", + "outcome": "completed", + "evidence": "PROOF.md, OBSERVATIONS.json and RESULT.json; exact registered normal/optimized checks.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance.", + "open_questions": [ + { + "question": "What is the exact regular-module rank of I-C3 C1 and minimum cyclic return count?", + "why_it_matters": "It controls the remaining 225 to 240 gap in the enlarged repair model.", + "first_step": "Analyze the literal monomial products with the width-dependent phase cocycle.", + "blocked_by": "No regular-module rank certificate is supplied." + } + ] +} diff --git a/research/p2-full-history-deficit/VERIFY.json b/research/p2-full-history-deficit/VERIFY.json new file mode 100644 index 0000000000..d49d802e67 --- /dev/null +++ b/research/p2-full-history-deficit/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": 180, + "checks": "Full observation trace, all native pairs, coupled cosets, leakage and complete invoice." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "The same exact result in optimized Python." + } + ] +} diff --git a/research/p2-full-history-deficit/inputs/HISTORY-REPAIR.md b/research/p2-full-history-deficit/inputs/HISTORY-REPAIR.md new file mode 100644 index 0000000000..417748bf86 --- /dev/null +++ b/research/p2-full-history-deficit/inputs/HISTORY-REPAIR.md @@ -0,0 +1,255 @@ +# At least 104 paid returns are needed to repair the frozen caller + +At every width f>=72, the frozen PR4948 passive caller needs at least +**104 additional paid field returns** to meet its original target. New +calls may use earlier new returns. Even if each new return costs only one +rank-one job, the complete optimistic invoice fails for every tariff +r^p with 0=1. A new multi-output supplier must +account for its actual paid primitives. The proof does not charge its +free outputs as extra queries. A supplier with a different ordinary +alphabet, capacity or price rule is outside this statement. + +## 2. Relative history dimension at one width + +**Reusable form.** Let H be any subgroup of the projective n-axis Clifford +group. Suppose the initial history is in a coefficient span that is +invariant under left H. In each of b independent input columns, let the +required unitary Clifford target T_j have its whole coset H T_j outside +that initial coefficient support. At any width with full-Clifford Gram +lower bound lambda>0, an exact decoder needs at least b additional +same-capacity returns. With q returns its selected block error satisfies +`D^(-f)||E||_HS^2 >= lambda(b-q)_+` and +`||E||_op^2 >= lambda(1-q/b)_+`, where D=2^n. +The targets must occupy distinct diagonal input/output positions. The +ordinary operations, arbitrary new linear returns and phase rules are +those of section 1. The proof below uses b=104 and a common T; replacing +these by b and T_j gives the stated general form. For another caller, +the complete initial history and coset exclusion must be proved anew. + +Let H be the projective monomial Clifford group on 17 axes, with h elements. +Choose unitary representatives. Its tensor lifts, including their phase +factors, span a unital algebra A at the fixed width. The pointwise theorem +in [PROOF.md](PROOF.md) shows that dim A=h for f>=72. Multiplication of +projective representatives can introduce a phase. It does not change this +dimension or the algebra closure. + +Restrict all input rows to the 104 zero-diagonal ports of original main +bank 0. Set every other independent input to zero. This is a legitimate +restriction of the required endpoint. The autonomous helper rows then +vanish. Let M be the A-module generated by all frozen observation rows +after this restriction. + +The source audit gives pure Clifford grades in {0,1,7} in each of these +input columns. Left monomial action preserves each grade. Thus M lies +in the span of these grades, separately in every input column. The +desired first target bank has diagonal coefficient T=D1 Q^-1, of grade 9. +Write t_j for the row with T^(tensor f) in input column j and zero elsewhere. + +For each j, the h words H T are projectively distinct. They all have +grade 9. The pointwise theorem shows that the h rows in A t_j are +independent. Different j have different independent input columns. +Consequently the target module L=sum_j A t_j has dimension 104h, and +L intersects M only at zero. This uses the complete finite Clifford +alphabet, not a free-word interpretation of its physical matrices. + +Let b_1,...,b_q be the new paid rows, in their actual order. After every +prefix, every available row lies in + + M + A b_1 + ... + A b_q. (1) + +Ordinary operations preserve this module. One new return adds a cyclic +module A b_i of dimension at most h. This statement needs no restriction +on the paid map and no assumption that A has no zero divisors. Overwrite, +clear and feedback do not invalidate (1). If every t_j is returned, +the final module contains L. Dimension in the quotient by M gives + + 104h <= dim((M + sum_i A b_i)/M) <= qh, + q >= 104. (2) + +This is the relative-history argument of PR5449, with its missing +physical source and all-width premises supplied here. Counting nominal +output rows alone would not prove (2): singular target rows can generate +smaller cyclic modules. The invertible unitary T and pointwise +faithfulness supply the full dimension h for each present target. + +The count is attained for this isolated target block in the enlarged +arbitrary-linear-oracle model: return each t_j in one call. This is not +a claim that 104 native calls suffice for the complete four-bank caller, +helper restoration or a permitted physical implementation. + +## 3. Error when fewer returns are used + +Give operator rows the normalized Hilbert--Schmidt inner product, with +normalization D^(-f), D=2^17. Let lambda_f be any lower Gram bound for +the complete projective Clifford alphabet. In this package one can use +lambda_f=1/9 for f>=72, and lambda_f=125/126 for f>=84. + +Form the 104h-column frame F whose columns are H t_j. Let Q be the +orthogonal projection onto the complement of M. For a coefficient +vector c and any m in M, the Clifford coefficient supports of F c and +m are disjoint in every input column. The pointwise Gram bound gives + + ||F c - m||^2 >= lambda_f ||c||^2. + +Take the infimum over m. Hence (QF)* QF >= lambda_f I. The subspace +N=Q(sum_i A b_i) has dimension at most qh. Let P_N be its orthogonal +projection. A basic rank approximation inequality gives + + ||(I-P_N) QF||_HS^2 >= lambda_f (104-q)_+ h. (3) + +For completeness, if a frame B has B*B>=lambda I_m and P has rank at +most r, choose m-r orthonormal vectors in ker(PB). Their squared image +norms are at least lambda each. Extend them to an orthonormal basis and +sum. This proves ||(I-P)B||_HS^2>=lambda(m-r). It is the elementary +rank bound behind classical low-rank approximation, not a new general +matrix approximation theorem. + +Suppose the decoder produces rows y_j, with error e_j=t_j-y_j. Each +H y_j lies in M+sum_i A b_i. Unitary left action preserves each error +norm. Thus the total squared error over the 104h orbit rows is exactly +h sum_j ||e_j||^2. It is at least (3). After division by h, the selected +104-output by 104-input block error E satisfies + + D^(-f) ||E||_HS^2 >= lambda_f (104-q)_+, + ||E||_op^2 >= lambda_f (1-q/104)_+. (4) + +The second inequality uses rank(E)<=104 D^f. It is a worst-case error +on the direct sum of the 104 input spaces. It does not assert that 104 +individual worst-case errors occur on one common field input. A complete +endpoint has at least this operator norm error, since restriction and +selection are contractions. New paid rows may lie outside the Clifford +span: only their module dimension enters (3). + +For example, at q=103 and f>=84 the squared operator norm error is at +least 125/13104. At q=0 and f>=72 it is at least 1/9, as in the original +passive application. Error below the corresponding q=103 threshold +therefore also requires at least 104 returns. + +## 4. The complete optimistic invoice is adverse + +The authenticated frozen mixed checker supplies these job histograms: + + P = {1:4754, 2:824, 3:1020, 4:254, 5:80, 8:224} + T = {4:56, 7:14, 8:94, 9:876, 17:224}. + +T includes all original helper credits exactly once. The source calls +this an optimistic, unrealized invoice. The histograms are frozen source +declarations; this package does not recount a new physical word. A lower-bound test can grant +every omitted finite cost as zero. By (2), a repair must add at least +104 positive-rank returns. Replace them all by rank-one jobs to obtain +the cheaper paid profile P'=P+104 delta_1. Do not remove an original paid +job, change its input, or add a target credit in this comparison. + +For d=P'-T, calculate K(k)=sum_r d_r min(r,k). The exact support knots are: + +| k | 1 | 2 | 3 | 4 | 5 | 7 | 8 | 9 | 17 | +|---|---|---|---|---|---|---|---|---|---| +| K(k) | 5996 | 7134 | 7448 | 6742 | 5838 | 3870 | 2900 | 1800 | 8 | + +Between support knots K is linear. All its positive integer values are +positive. For any increasing concave tariff phi with phi(0)=0, set +s_k=phi(k)-phi(k-1). Summation by parts gives + + sum_r d_r phi(r) + = s_17 K(17) + sum_(k=1..16) (s_k-s_(k+1)) K(k) >= 0. (5) + +For phi(r)=r^p with 00 and K(17)=8. The inequality is strict. +The original rank-mass surplus is 96; the unavoidable repair costs at +least 104. Equation (5) shows the loss at every positive concave power, +not merely at p=1 or at a numerical sample of exponents. No rounding or +root estimate is used. Constant-zero or flat concave tariffs need not +give a strict inequality. + +This applies the repository's existing +[exact invoice comparator](../../scripts/compare_recursive_invoices.py), +with its credit to classical concave order, mightyOil and predecessors. +The new [repair invoice](REPAIR-INVOICE.json) binds this arithmetic to +the source histograms and the proved added-return count. The comparator +alone does not establish those physical premises. + +There is also an error floor for any profitable approximate repair. +With 96 added rank-one jobs the same hinges remain nonnegative, with +K(17)=0 and the earlier knots positive. Such a repair cannot have a +positive margin for any 0=1 and every integer f>=4n+4, + + (1/9) sum_g |b_g|^2 + <= D^(-f) ||sum_g b_g U_g^(tensor f)||_HS^2 + <= (17/9) sum_g |b_g|^2. (1) + +The coefficients are arbitrary complex numbers at this one width. Thus all +the projective tensor operators are linearly independent at every such f. +Any subset has the same bounds. The choice of representative phase does not +change the bounds. The proof also applies to the usual Clifford group with +arbitrary unit scalar phases, after projective classes are combined. + +For a fixed residual in the exact dyadic group algebra, the following are +equivalent: + +1. Every exact-operator coefficient is zero. +2. The residual vanishes at every positive width. +3. It vanishes at the four widths 4n+4,...,4n+7. + +If M is the squared coefficient norm after equal exact operators are +combined, at least one of these four normalized squared norms is >= M/9. +Four tests are necessary for this exact group with arbitrary complex scalar +coefficients. This is a sufficient width bound, not a sharp width threshold. +For n=0 the group is the four scalar phases; widths 1,2,3,4 suffice. + +There is a broader result. A nonzero stabilizer map from a binary input +space to a binary output space is a matrix whose vectorization, up to a +nonzero scalar, is a pure stabilizer state. Let N be the total number of +input and output axes. Normalize these vectors to unit length and choose +one per projective class. At every f>=2N+6 their tensor Gram matrix has + + (2/5) I <= Gram_f <= (8/5) I. (2) + +This includes rectangular maps and Pauli projections. For arbitrary +unnormalized representatives A_g, (2) means + + ||sum_g b_g A_g^(tensor f)||_HS^2 + >= (2/5) sum_g |b_g|^2 ||A_g||_HS^(2f). (3) + +The statements at a single width allow different finite words, different +scalar coefficients and different subsets at each width. They do not infer +all-width equality of a changing family from four tests. Products must +still have the stated columnwise Clifford or stabilizer-map form. + +There is a robust consequence. If a unitary Clifford target T is absent +from a set of projective classes S, then for f>=4n+4, + + D^(-f) ||T^(tensor f)-sum_(g in S) b_g U_g^(tensor f)||_HS^2 + >= (1/9)(1+sum_g |b_g|^2) >= 1/9. (4) + +Its operator norm error is therefore at least 1/3. This is a worst-case +unit-input error bound, not a guarantee about the error on each input. +Later widths use the stronger constants in Section 4. In particular the +lower bound on normalized squared error tends to one as f increases. + +## 2. Count the stabilizer overlaps + +A projective N-qubit stabilizer state has a computational-basis support +which is an affine binary subspace. In coordinates t on its k-dimensional +support, its amplitudes have the form + + 2^(-k/2) i^(a.t + 2 sum_(j. A state has a nonzero overlap of modulus 2^(-k/2) +with it exactly when its support is a k-subspace containing zero. Normalize +its amplitude at zero to be positive. The remaining phase polynomial is +unique. There are + + A_(N,k) = [N choose k]_2 2^(k(k+3)/2) (5) + +such states, including A_(N,0)=1. Here + + [N choose k]_2 = product_(j=0..k-1) + (2^(N-j)-1)/(2^(k-j)-1). + +There are k coefficients with four choices and k(k-1)/2 coefficients with +two choices. This proves the exponent in (5). The other states have zero +overlap. Clifford conjugation is transitive on pure stabilizer states, so +the same distribution holds about every projective stabilizer state. + +Transitivity can also be seen directly: a basis change puts the support +on coordinate axes, a translation removes its offset, diagonal Clifford +phases remove its phase polynomial, and Hadamards send its uniform support +to zero. This argument does not use a counting formula for the Clifford +group. + +It follows that the absolute off-diagonal row sum of the f-fold tensor +Gram matrix of all these states is exactly + + S_(N,f) = sum_(k=1..N) A_(N,k) 2^(-kf/2). (6) + +An arbitrary subset has no larger row sum. This count concerns projective +states. Repeating scalar-phase copies would make a pointwise Gram singular. + +## 3. The Clifford first-overlap improvement + +Vectorize U/sqrt(D) to obtain its unit Choi state on 2n qubits. It is a +stabilizer state: the Bell state is a stabilizer state and Clifford action +on one half preserves that property. Projectively different matrices give +different projective Choi states. Formula (5), with N=2n, therefore bounds +their overlap counts. + +For k=1 the Clifford count is exactly + + B_(n,1) = 2(2^(2n)-1) = A_(2n,1)/2. (7) + +Here is a separate proof which retains the signs. Let S be the symplectic +Pauli action of U, and L=ker(S-I). In the Hermitian Pauli basis, conjugation +has trace |tr U|^2. Its contribution at a fixed label v is its sign epsilon(v). +On L these signs form a character: conjugation cancels the same Pauli +multiplication phase on both sides. Thus |tr U|^2 is either zero or +2^dim(L). + +For a fixed S, its projective Clifford lifts differ by the 2^(2n) Paulis. +They multiply the sign on L by every character of L, each with multiplicity +2^(2n-dim(L)). Therefore exactly 2^k lifts have nonzero trace when +rank(S-I)=k. Their normalized trace modulus is 2^(-k/2). + +A rank-one symplectic displacement is a transvection. Indeed, write +(S-I)x=ell(x)a for nonzero a. Symplecticity gives +ell(x) omega(a,y)+ell(y) omega(x,a)=0. Nondegeneracy then forces +ell(x)=omega(x,a) over F_2. Every nonzero a gives one such map. There are +2^(2n)-1 choices, and each has two nonzero-trace lifts. This proves (7). + +For clarity, a second count gives the same general upper bound without +Choi states. Put W=im(S-I), dim W=k. Then ker(S-I)=W-perp. The residual +form B((S-I)x,w)=omega(x,w) is well-defined, nonsingular and satisfies +B(u,v)+B(v,u)=omega(u,v). For fixed W there are at most +2^(k(k+1)/2) bilinear forms with this fixed symmetrization. Each nonsingular +one determines S uniquely: solve B((S-I)x,w)=omega(x,w) for every w in W. +There are [2n choose k]_2 possible W and 2^k nonzero-trace Pauli lifts. +Their product is exactly A_(2n,k). No equality is asserted for k>=2. + +The Choi and residual-form arguments are different derivations of the same +upper bound. The checks enumerate signed Pauli actions and literal Choi +vectors separately. + +## 4. Uniform rational row bounds + +Set d_k=product_(j=1..k)(2^j-1). The subspace count satisfies + + [N choose k]_2 <= 2^(k(N-k)) / + product_(j=1..k)(1-2^(-j)). + +At f=2N+4, its term in (6) is at most 1/d_k. The Clifford first term is +at most 1/2 by (7). Its whole off-diagonal row sum is consequently at most + + 1/2 + 1/3 + 1/21 + 1/315 + + (1/9765)/(1-1/63) < 8/9. (8) + +The tail starts at k=5. Each subsequent term has ratio at most 1/63. +The bound is independent of n. Terms with k>2n were added only to bound +the finite sum from above. At all larger widths the row sum can only fall. + +For all stabilizer states use f=2N+6. Each term is at most 2^(-k)/d_k, +so the full row sum is at most + + 1/2 + 1/12 + 1/168 + 1/5040 + + (1/312480)/(1-1/126) < 3/5. (9) + +Again this is a rational bound on the complete infinite tail. The executable +also provides the sharper finite sums for any specified axis count and any +even width. For an odd width it uses the preceding even width. A failed +sufficient bound is no decision, not evidence of linear dependence. + +If a Hermitian matrix has diagonal one and absolute off-diagonal row sums +at most s, then its eigenvalues lie in [1-s,1+s]. One direct proof bounds +each pair by 2|b_i b_j| <= |b_i|^2+|b_j|^2 in its quadratic form. +Apply this to the Gram matrices and (8)-(9). This proves (1)-(3). +Apply (1) to the residual with target coefficient one to obtain (4). +The inequality ||R||_HS <= sqrt(D^f)||R||_op gives its operator norm claim. + +There are useful stronger bounds at a slightly later width. At +f=4n+4+2s the Clifford row bound is at most + + 2^(-s-1) + sum_(k>=2) 2^(-sk)/d_k. (10) + +For s=2 this is <3/20. For s=6 it is <1/126. +Thus four consecutive widths starting at 4n+8 have a 17/20 lower bound; +four starting at 4n+16 have a 125/126 lower bound. The same geometric-tail +argument proves these constants. These are sufficient constants, not +optimal spectral values. + +## 5. Exact phases and the four-width theorem + +For the Gaussian-dyadic group write every exact matrix uniquely as i^j U_g, +where g is its projective class and j=0,1,2,3. For a fixed residual define + + beta_(g,r) = sum_(j=0..3) c_(g,j) i^(jr). + +At any f>=4n+4 with f=r modulo four, (1) says that the residual is zero +exactly when all beta_(g,r) vanish. This is the exact pointwise kernel: +only the unavoidable scalar-phase relations remain. Four consecutive +widths supply all four residues. Fourier inversion then makes every +c_(g,j) zero. + +Parseval gives (1/4) sum_(g,r)|beta_(g,r)|^2=M. Averaging (1) over the +four tested widths proves the M/9 claim. Formula (10) gives the two stronger +four-width constants stated above. Apply the argument to each entry of a +complete input-to-output register matrix; every dirty role must be retained. + +For each r the residual sum_(j=0..3) i^(-rj)[i^j I] vanishes at every width +outside r modulo four and is 4I in that residue. Thus three widths cannot +be a universal fixed-residual test. The same argument gives eight necessary +residues if a chosen finite normalized Clifford lift includes eighth-root +scalar phases. The four-test conclusion is for the repository's exact +Gaussian-dyadic group, not that larger central extension. + +## 6. Quantifiers, applications and exclusions + +At a single specified f>=4n+4, the coefficient vector may be chosen after +f. Its entries may be arbitrary complex numbers. Its finite support and +the finite word that produces it may also depend on f. There is no term +count in the theorem. Thus an equality at that width can be read as an +identity in the projective phase quotient of the group algebra. A scalar +phase is evaluated as its f-th power, not discarded. + +This gives an explicit threshold for future applications of the retained +finite-alphabet tensor-separation arguments. It replaces an unspecified +large width or a projective-group-size bound when the entire operator +alphabet in the argument is contained in this fixed n-axis Clifford group. +For n=9 the pointwise threshold is 40 and the four test widths are 40..43. +For n=17 they are 72 and 72..75. At n=64 they are 260 and 260..263. +The prior full-Clifford fixed-residual tests are 69..76, 133..140 and +509..516 respectively. These comparisons are theorem bounds, not measured +execution speedups. + +The [retained passive application](APPLICATION.md) meets the full alphabet +premise. It gives a uniform width-72 obstruction and an operator error bound +of 1/3 under that exact passive contract. Its sources and both mandatory +clarifications are retained as byte-pinned inputs. + +For stabilizer maps, terms which differ by any nonzero scalar must first be +combined with that scalar raised to f. Their coefficients may then depend +on f. Formula (3) does not identify scaled copies at all widths, and it does +not give four tests for arbitrary nonunitary scalings. + +This does not by itself strengthen an additional-call bound at a caller +cut with already paid observations. That needs its correct initial module, +source versions, ownership and cost ledger. Nor does it show that any +particular paid-history theorem's whole alphabet consists of Clifford +maps. A nominal matrix or a sum of Cliffords is not automatically a +Clifford or a stabilizer map. Each application must check that premise. + +Arbitrary non-Clifford matrices, nonlinear/rounded operations, operators +which act across tensor columns, unpriced physical routing, and omitted +dirty returns remain outside the result. No all-size multiplication +assumption is declared discharged by this algebraic theorem alone. + +## 7. Verification and attribution + +The registered verifier checks the finite counting identities by separate +state and signed-Pauli enumerations, the rational tail bounds, literal Gram +matrices, complete native register examples and deliberate invalid inputs. +The written proof supplies the all-dimension and all-width quantifiers. +Finite computation is corroboration; it is not a formal-kernel proof or +independent human acceptance. + +The retained tensor-Gram package supplies the exact native grammar, compact +quadratic sums and complete register frontend. Its original trace filter, +code invariant, one-axis sharpness and provider results remain its work. +The monomial tensor-cutoff package remains a stronger cutoff for its smaller +class. Chris R and the retained paid-history authors supply the earlier +finite-alphabet applications. Krzysztof Wojt and Nick Petalas supply the +repository's related residual-form and partial-Pauli statements. + +Classical stabilizer descriptions follow Dehaene and De Moor, +[*Clifford group, stabilizer states, and linear and quadratic operations +over GF(2)*](https://arxiv.org/abs/quant-ph/0304125). The finite symplectic residual-form +method is classical Wall-form theory. No general counting, Gram, Fourier, +stabilizer-simulation or literature-priority claim is made. Exact repository +pins and the role of each source are in SOURCES.json and README.md. + +## Open next questions + +Find the least pointwise threshold and best spectral constant for this +group, with the phase residue kept explicit. Test one actual complete +caller against the new pointwise kernel, retaining its available history +and complete bill. Extend the exact native frontend to a source-bound +nonunitary stabilizer caller only when its projections and scalar factors +are supplied. None of these follow-ups is claimed complete here. diff --git a/research/p2-full-history-deficit/inputs/SOURCE-PROOF.md b/research/p2-full-history-deficit/inputs/SOURCE-PROOF.md new file mode 100644 index 0000000000..3933f848e5 --- /dev/null +++ b/research/p2-full-history-deficit/inputs/SOURCE-PROOF.md @@ -0,0 +1,95 @@ +# Nine passive macro cuts do not recover the four Gaussian jobs + +This is a necessary-condition result for the prospective scope in Discussion #4902, expiry 06:00 UTC. It concerns the single frozen mixed p2 word from the preceding local packet. It does not change that word, inject a saved value into a later paid gate, access native internal prefixes, or emit a physical caller. + +## Source and exact observation contract + +The source is #4948, `86e474038e05f99a76d41f71d81946ad2327e4a4`, using its actual signed monomial normalizers K_i and involutory scalar matrix F. The native reverse primitive is + +`B_s=diag(D_s,D_s) U(−Q C_s)`, `C_s=diag(K_s)^−1 F^T diag(K_s)`. + +The source relations are `C_s²=I`, `[C_s,D_s Q]=0`, and `[C_s,D_t]=0` for distinct fresh stages. No own-stage `[C_s,D_s]` or `[C_s,Q]` commutation is assumed. Source-byte hashes are included in `GRADE-GATE.json`, inherited through the authenticated frozen mixed checker. + +There are four independent original main input banks, each of 112 owners. The word keeps the source scalar right/left boundaries, initial paid IDLE, all bridges and signed swaps. Its three thins are exactly: + +`C1 Q^-1` at stage 0, `Q^-1 C1` at stage 2, and `Q^-1 C3` at stage 4. + +Choose these nine macro cuts, saving the four current main banks at each: + +1. After the scalar right boundary. +2. After thin 0. +3. After FULL 1. +4. After the paid IDLE on pair 1. +5. After bridge-plus and thin 2. +6. After bridge-minus. +7. After FULL 3. +8. After thin 4. +9. After the final bridge, signed swaps and scalar left boundary. + +Also save the three already paid responses in their actual order: `Q^-1 x` before C1 in thin 0; `Q^-1 C1 x` in thin 2; and `Q^-1 C3 x` in thin 4. Thus there are 39 dependent observed bank fields. The initial cut is after an invertible scalar boundary; it includes the original input information without adding a tenth cut. + +Copies are passive. The original paid gates continue with precisely the frozen input expressions. New left decoder controls may combine arbitrary owner fields by scalar operations and apply the actual finite C1/C3 words of length at most three. They may be interleaved on decoder fields: every such resulting coefficient is still a finite scalar sum of monomial Clifford maps. No Q is free. Restoring the old autonomous helper jobs cannot change any coefficient of an independent original main input. + +## The original-input dependency trace + +Track original main bank 0, before the scalar right boundary. For its four current-bank coefficients and its three paid-response coefficients, the entire exact trace contains only signed occurrences of + +`I`, `Q^-1`, `C1 Q^-1`, and `Q^-1 C1 D1`. + +The checker verifies all 39 observations against precisely this set. In particular, there is no hidden D3 term or later query path for this original input. FULL 1 cancels its X coefficient. The bridge-minus cancels its pair-1 Y coefficient before FULL 3; it therefore never obtains the second transverse factor. This trace uses the original input, not a later field whose owner or frame was silently changed. + +The preliminary bank-scalar span contains 273 candidate generators: 39 observations times the seven reduced words `I,C1,C3,C1C3,C3C1,C1C3C1,C3C1C3`. Its dimension is 92. Only the positive first-pair target is attained; its explicit recipe is minus C1 applied to the saved FULL-1 X row. This preliminary calculation alone does not cover arbitrary per-port scalar controls. The following grade argument does. + +## Actual port coefficients and their grades + +For original source port j in bank 0, the late observation `Q^-1 C1 D1` has output-port-i coefficient + +`(F^T)_(i,j) Q^-1 K_i^-1 K_j D1`. + +The actual F diagonal is zero at 104 ports and equals 12 at the other eight. For every one of the 104 zero-diagonal ports: + +* Its same-port late term vanishes. +* Exactly 52 other output coefficients are nonzero. +* Every one of those 52 literal Clifford words has Fourier grade 7. + +The exact signed-tableau census checks all **5,408** such nonzero words. It does not sample pairs. Each source K_i is monomial, and its commutation with the full nine-axis Gaussian is independently checked including absolute phase. The nine-axis grade calculation embeds into the actual 17-axis ambient space by leaving the other fresh eight axes untouched. + +The earlier I path has grade 0. The earlier Q^-1 and C1 Q^-1 paths consist of grade-1 words because each K_i^-1 K_j is monomial. Hence every observed coefficient for each of these 104 original source inputs has pure-word support of grades in `{0,1,7}`. + +By contrast, the required original first-bank target is `D1 Q^-1`, of grade **9**. The checker confirms this rank and also checks the eight nonzero diagonal ports as controls: their literal same-port late term has grade 9. Replacing the code by the identity likewise exposes the uncoded grade-9 term, and the preliminary uncoded span recovers all four ordinary targets. + +## Why finite code controls cannot fill the missing grade + +For a Clifford tableau, its Fourier grade is the rank of the X component in its images of the Z generators. Multiplying on the left by a monomial Clifford map applies an invertible address map to that X component and therefore preserves its rank. Scalar coefficients, phases, COPY and owner mixing do not create new pure operator words. Each entry of C1 or C3 is a scalar multiple of a monomial K_i^-1 K_j. Every finite code word expands into a finite scalar sum of monomial words. + +Consequently, after any allowed passive left decoder, each of these original-source coefficients remains supported on pure words of grades `{0,1,7}`. Allowing arbitrary port-by-port scalar operations, extra decoder work arrays, or all finite COPY/CLEAR costs for free does not change this support fact. The eight selected ports cannot repair the absent coefficients of the 104 different arbitrary original inputs: those inputs are independent. + +This is a pure-word support argument, not a claim that small-width Clifford matrices are linearly independent. The latter claim would be false. + +## Sufficiently large width and the phase quotient + +At column width f, each literal one-column operator word A is lifted as `A^tensor(f)`. The source scalar owner coefficients occur once, outside that tensor power. Each observed entry and finite code decoder expands as a finite sum of these pure-word tensor lifts. No tensor of a sum is replaced by a sum of tensor powers. + +Group the finite one-column words into projective classes. Words differing by a scalar phase have the same grade; their phase to power f is absorbed into their scalar coefficient. Choose one unitary representative A_r from each remaining class. Distinct representatives satisfy + +`|tr(A_r^* A_s)/dim(A_r)| < 1` for r≠s. + +The normalized Hilbert–Schmidt Gram matrix of their f-fold tensor powers has off-diagonal entries equal to the f-th powers of these overlaps. The finite Gram matrix therefore tends to the identity as f tends to infinity, and is positive definite for all sufficiently large f. The projectively distinct pure-word tensor powers are consequently linearly independent at those widths. This remains true if the reconstruction's scalar coefficients depend on f. + +The grade-9 target is projectively distinct from every grade-0, grade-1 or grade-7 word. It cannot lie in their span for sufficiently large f. Therefore no decoder in this passive finite-code grammar can supply an identity valid at every positive width. The proof does not assert failure at every small width, does not infer independence from width-1 arrays, and does not need to enumerate the whole Clifford group. + +## Ownership, invoice and stopping decision + +All-snapshot storage would add `39*112=4,368` dependent fields, initialized to owned zero, with 4,368 COPY operations and 4,368 final zero-reset obligations. The existing 448 original main inputs remain arbitrary. The 816 independent helper jobs remain unchanged and credited once. There is no fresh input or productive reward for a snapshot. + +There is no accepted reset recipe: saved values would need to be erased using a still-available source or a permitted expression in retained outputs. Overwriting an owned snapshot, discarding its information, running the native inverse for free, and treating a dependent copy as a new arbitrary input are all excluded. A span identity alone would not settle those obligations. + +The preceding optimistic recursive profile remains + +`P={1:4754,2:824,3:1020,4:254,5:80,8:224}`, + +`T={4:56,7:14,8:94,9:876,17:224}`, + +with unrealized raw margin about 36.14614 at C=.0030217758. Here no new Gaussian is requested, but the required main endpoint already fails even when all added finite operations, code evaluations, storage, initialization, resets and precision are granted for free. Thus no finite bill can turn this specific passive-snapshot proposal into that supplier. No physical emission, compiler strictification, outer reserve, BIT promotion or κ claim follows. + +Active use of a saved response as an input to a later paid Gaussian gate changes the original dependency trace and is outside this fixed-word result. So are new Gaussian calls, native internal prefix taps, a different thin placement, a different target profile, and f-dependent non-columnwise payload routing. Those require a new exact physical/cost contract. diff --git a/research/p2-full-history-deficit/inputs/UNIFORM-ALPHABET-ADDENDUM.md b/research/p2-full-history-deficit/inputs/UNIFORM-ALPHABET-ADDENDUM.md new file mode 100644 index 0000000000..d742381500 --- /dev/null +++ b/research/p2-full-history-deficit/inputs/UNIFORM-ALPHABET-ADDENDUM.md @@ -0,0 +1,11 @@ +# Uniform finite alphabet for the large-width argument + +This clarification leaves the six-file freeze and its manifest unchanged. Independent reviewer B requested that the finite-alphabet premise be explicit. + +All one-column literal address maps in this gate lie in the Clifford group on the **fixed 17-axis ambient space**. Its projective quotient is finite. Scalar root phases are absorbed into the coefficients after tensor lift; they do not change Fourier grade. The finite universe of projective one-column Clifford maps is therefore independent of column width f. + +The Gram argument in `PROOF.md` can be applied once to representatives of this whole finite projective universe, rather than merely to the words appearing in a single chosen decoder. For sufficiently large f its tensor-power Gram matrix is positive definite. This gives a uniform threshold even when scalar reconstruction coefficients, selections of allowed controls, or numbers of passive scalar operations depend on f. The source one-column C1/C3 entries and all their allowed left expansions remain in the monomial subset and preserve the grade support proved in the frozen packet. + +This does not include f-dependent payload permutations outside the fixed columnwise Clifford alphabet. Such maps are not granted by this gate's scalar-owner/actual finite-code contract. It also does not turn the source's finite coefficients into coefficients raised to tensor powers. + +No new scan, emitter, cost claim, or κ result is added. diff --git a/research/p2-full-history-deficit/inputs/algebra.py b/research/p2-full-history-deficit/inputs/algebra.py new file mode 100644 index 0000000000..0fffec34c5 --- /dev/null +++ b/research/p2-full-history-deficit/inputs/algebra.py @@ -0,0 +1,77 @@ +"""Independent exact audit of ONE mixed-thin p2 policy; no search/emitter. + +Own D-left semidirect-product interpreter (producer uses D-right normal form). +Only pinned Clifford primitives and interval library are reused. Apache-2.0. +""" +from pathlib import Path +from fractions import Fraction as F +from collections import Counter +from hashlib import sha256 +import gzip, json, types, sys + +HERE=Path(__file__).resolve().parent +def need(x,msg): + if not x: raise ValueError(msg) + +# D1^a D3^b followed by a word in Q,C1,C3. C_s^2=I and +# D_s C_s D_s^-1=Q^-1 C_s Q; no own-D or Q/C commutation. +def reduce(w): + out=[] + for x in w: + if out and (out[-1]==-x or (x in (2,3) and out[-1]==x)): + out.pop() + else: out.append(x) + return tuple(out) +def act(w,b): + out=() + for x in w: + if x in (2,3): + n=b[x-2] + pre=(1,)*n if n>=0 else (-1,)*(-n) + post=(-1,)*n if n>=0 else (1,)*(-n) + out=reduce(out+pre+(x,)+post) + else: out=reduce(out+(x,)) + return out +def add(*ps): + z=Counter() + for p in ps: + for k,v in p.items(): z[k]+=v + return {k:v for k,v in z.items() if v} +def neg(p): return {k:-v for k,v in p.items()} +def mul(*ps): + out={((0,0),()):F(1)} + for p in ps: + z=Counter() + for (a,w),x in out.items(): + for (b,v),y in p.items(): + z[(tuple(i+j for i,j in zip(a,b)),reduce(act(w,b)+v))]+=x*y + out={k:v for k,v in z.items() if v} + return out +one={((0,0),()):F(1)} +q={((0,0),(1,)):F(1)}; qi={((0,0),(-1,)):F(1)} +c={((0,0),(2,)):F(1)}; e={((0,0),(3,)):F(1)} +d={((1,0),()):F(1)}; f={((0,1),()):F(1)} +def mm(A,B): + return [[add(*(mul(A[i][k],B[k][j]) for k in range(len(B)))) + for j in range(len(B[0]))] for i in range(len(A))] +def lower(z): return [[one,{}],[z,one]] +def upper(z): return [[one,z],[{},one]] +def diag(x): return [[x,{}],[{},x]] +def replay(C,E): + M=[[one.copy() if i==j else {} for j in range(4)] for i in range(4)] + def plus(i,j,z): M[i]=[add(x,mul(z,y)) for x,y in zip(M[i],M[j])] + def left(i,z): M[i]=[mul(z,x) for x in M[i]] + def thick(pair,C,D): + plus(2*pair,2*pair+1,neg(mul(q,C))) + left(2*pair,D); left(2*pair+1,D) + def bridge(i,j,sgn): + plus(2*i,2*j,one if sgn==1 else neg(one)) + plus(2*j+1,2*i+1,neg(one) if sgn==1 else one) + plus(0,2,neg(one)); plus(3,1,one) + plus(1,0,mul(C,qi)); thick(0,C,d) + left(2,d);left(3,d) # both source paid IDLE jobs retained + bridge(0,1,1);plus(1,0,mul(qi,C));bridge(0,1,-1) + thick(1,E,f);plus(3,2,mul(qi,E));bridge(1,0,1) + for i in (0,1): M[2*i],M[2*i+1]=M[2*i+1],[neg(x) for x in M[2*i]] + plus(0,2,one);plus(3,1,neg(one)) + return M diff --git a/research/p2-full-history-deficit/inputs/bank_span.py b/research/p2-full-history-deficit/inputs/bank_span.py new file mode 100644 index 0000000000..513be55ff4 --- /dev/null +++ b/research/p2-full-history-deficit/inputs/bank_span.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python3 +"""One macro-observation bank-level span, not a physical caller emitter. + +Block-scalar coefficients are deliberately distinguished from arbitrary +port-by-port owner controls. A negative result here does not close the +larger permitted physical grammar. +""" +import contextlib +import hashlib +import io +import json +from fractions import Fraction as F +from pathlib import Path +import runpy + +HERE=Path(__file__).resolve().parent +dependency=HERE.parent/'pr4948-mixed-thin-gate/check.py' +need_hash='fe7db972d7ae238b21f8a453c21243360d131d728a76b91a469dacf447629582' +if hashlib.sha256(dependency.read_bytes()).hexdigest()!=need_hash: + raise ValueError('Frozen mixed derivation changed') +with contextlib.redirect_stdout(io.StringIO()): env=runpy.run_path(str(dependency)) +a,q,qi,c,e,d,f=[env[k] for k in ('a','q','qi','c','e','d','f')] +need=env['need'] + +def observations(c1,c3): + rows=[[a.one if i==j else {} for j in range(4)] for i in range(4)] + obs=[]; cuts=[] + def snap(label): + cuts.append(label) + for i,row in enumerate(rows): obs.append((label+':'+str(i),list(row))) + def plus(i,j,z): rows[i]=[a.add(x,a.mul(z,y)) for x,y in zip(rows[i],rows[j])] + def left(i,z): rows[i]=[a.mul(z,x) for x in rows[i]] + def thin(pair,before,after,label): + response=[a.mul(before,x) for x in rows[2*pair]] + obs.append((label,response)) + rows[2*pair+1]=[a.add(x,a.mul(after,y)) for x,y in zip(rows[2*pair+1],response)] + def full(pair,C,D): + plus(2*pair,2*pair+1,a.neg(a.mul(q,C))) + left(2*pair,D);left(2*pair+1,D) + def bridge(dst,src,sgn): + plus(2*dst,2*src,a.one if sgn==1 else a.neg(a.one)) + plus(2*src+1,2*dst+1,a.neg(a.one) if sgn==1 else a.one) + rows[0][2]=a.neg(a.one);rows[3][1]=a.one + snap('cut0_after_right_boundary') + thin(0,qi,c1,'paid_response0_Qinv_x') + snap('cut1_after_thin0') + full(0,c1,d);snap('cut2_after_FULL1') + left(2,d);left(3,d);snap('cut3_after_IDLE') + bridge(0,1,1) + thin(0,a.mul(qi,c1),a.one,'paid_response2_Qinv_C1_x') + snap('cut4_after_bridge_plus_and_thin2') + bridge(0,1,-1);snap('cut5_after_bridge_minus') + full(1,c3,f);snap('cut6_after_FULL3') + thin(1,a.mul(qi,c3),a.one,'paid_response4_Qinv_C3_x') + snap('cut7_after_thin4') + bridge(1,0,1) + for pair in range(2): + x,y=2*pair,2*pair+1 + rows[x],rows[y]=rows[y],[a.neg(z) for z in rows[x]] + plus(0,2,a.one);plus(3,1,a.neg(a.one)) + snap('cut8_after_final_standard_boundary') + return obs,cuts,rows + +def vector(row): + return {(i,w,ds):v for i,p in enumerate(row) for (w,ds),v in p.items() if v} +def axpy(x,z,y): + out=dict(x) + for k,v in y.items(): + out[k]=out.get(k,F(0))+z*v + if not out[k]:del out[k] + return out +def scale(x,z):return {k:z*v for k,v in x.items() if z*v} + +controls=[(),(2,),(3,),(2,3),(3,2),(2,3,2),(3,2,3)] +def span(obs,targets): + basis={};generators=[] + for label,row in obs: + for control in controls: + z=a.term(control,(0,0)) + v=vector([a.mul(z,p) for p in row]) + index=len(generators);generators.append({'observation':label,'left_word':list(control)}) + coef={index:F(1)} + while v: + pivot=min(v) + if pivot not in basis: + inv=1/v[pivot];basis[pivot]=(scale(v,inv),scale(coef,inv));break + b,bc=basis[pivot];factor=v[pivot] + v=axpy(v,-factor,b);coef=axpy(coef,-factor,bc) + answers=[] + for target in targets: + v=vector(target);coef={} + while v: + pivot=min(v) + if pivot not in basis:break + b,bc=basis[pivot];factor=v[pivot] + v=axpy(v,-factor,b);coef=axpy(coef,factor,bc) + answers.append({'attained':not v, + 'recipe':[{**generators[i],'coefficient':str(z)} for i,z in sorted(coef.items())] if not v else None, + 'first_residual_monomial':{'source':min(v)[0],'word':list(min(v)[1]),'D_powers':list(min(v)[2]),'coefficient':str(v[min(v)])} if v else None}) + return {'basis_dimension':len(basis),'generator_count':len(generators),'answers':answers} + +targets=[a.mul(d,qi),a.mul(d,q),a.mul(f,d,qi),a.mul(f,d,q)] +targetrows=[[targets[i] if i==j else {} for j in range(4)] for i in range(4)] +obs,cuts,rows=observations(c,e) +need(rows==env['rows'],'Exact frozen mixed endpoint') +actual=span(obs,targetrows) +plain,_,_=observations(a.one,a.one) +control=span(plain,targetrows) +need(all(x['attained'] for x in control['answers']),'Uncoded recoverability control') +out={'status':'BANK_LEVEL_SPAN_ONLY_PENDING_PORT_LEVEL_GATE', + 'cuts':cuts,'paid_response_count':3,'saved_bank_fields':len(obs), + 'controls':controls,'actual':actual,'uncoded_control':control, + 'copy_upper_ledger':{'independent_original_main_fields':448,'saved_dependent_fields':len(obs)*112, + 'COPY':len(obs)*112,'owned_zero_initializations':len(obs)*112, + 'required_final_zero_resets':len(obs)*112,'extra_Gaussian_calls':0, + 'qualification':'An all-snapshot upper inventory, not a cleanup certificate. Snapshots must be erased from still-available sources or an admitted final free representation.'}, + 'helpers':'Both invocations retain408 autonomous helper jobs each, untouched by this bank-level observation model.', + 'scope':'Scalar coefficients on whole112-port banks plus reduced C1/C3 words length<=3. Arbitrary per-port scalar controls are not yet represented.', + 'physical_emission':False,'new_kappa':None, + 'dependency_sha256':need_hash} +print(json.dumps(out,indent=2,sort_keys=True)) diff --git a/research/p2-full-history-deficit/inputs/clifford_exact.py b/research/p2-full-history-deficit/inputs/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/p2-full-history-deficit/inputs/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<> j & 1) + aug[j], aug[k] = aug[k], aug[j] + for i in range(n): + if i != j and aug[i] >> j & 1: + aug[i] ^= aug[j] + return [v >> n for v in aug] + + +def physical_grades(code, normal): + """Compute ranks from native binary maps without the source rank routine.""" + ce = load('p2_phase_source', 'clifford_exact.py') + ks, matrices = [], [] + for record in normal['ports']: + op = ce.ident(9) + for e in record['K_word']: + if e[0] == 'P': + op = op.then(ce.perm(9, e[1])) + elif e[0] == 'D': + need(not any(e[1]) and all(x % 2 == 0 for x in e[2]), 'Pauli phase only') + op = op.then(ce.diag(9, e[1], e[2])) + else: + raise ValueError('Unexpected normalizer gate') + need(len(record['K_word']) == 2 and record['K_word'][0][0] == 'P', 'Normalizer form') + g = record['K_word'][0][1] + need(all(((x & y).bit_count() % 2) == (i == j) + for i, x in enumerate(g) for j, y in enumerate(g)), 'Orthogonal source G') + gaussian = ce.fourier(9) + a, b = op.then(gaussian), gaussian.then(op) + need(a.tab == b.tab and a.zero_state() == b.zero_state(), 'Signed Gaussian commutation') + matrices.append(g) + ks.append(op) + invs = [inverse(g) for g in matrices] + per_column, pairs = [], [] + d = ce.fourier(9, range(1, 9)) + qi = ce.cgate(9, 1).adjoint() + for j in range(112): + grades = set() + for i in range(112): + if not code[i][j]: + continue + # Q^-1 K_i^-1 K_j D: track the X part of every Z image. + gcol = [linear(invs[i], linear(matrices[j], 1 << k)) for k in range(9)] + xcols = [(gcol[k] if k else 0) ^ (gcol[k] & 1) for k in range(9)] + value = rank(xcols) + source_op = d.then(ks[j]).then(ks[i].adjoint()).then(qi) + need(value == rank([x for x, _, _ in source_op.tab[9:]]), 'Independent physical grade') + grades.add(value) + pairs.append([i, j, str(code[i][j]), value]) + per_column.append(grades) + return per_column, pairs + + +def grades_for(term, j, late): + word, ds = term + weight = 8 * sum(ds) + if word in ((), (3, 2)): + return {weight} + if word in ((-1,), (2, -1)) and ds == (0, 0): + return {1} + if word in ((2, 1), (3, 1)): + return {weight + 1} + if word == (-1, 2) and ds in ((1, 0), (1, 1)): + return {g + 8 * ds[1] for g in late[j]} + if word == (-1, 3) and ds == (1, 1): + return {g + 8 for g in late[j]} + raise ValueError('Unclassified physical term ' + str(term)) + + +def encode(obs): + return [{'label': label, 'columns': [[{'word': list(w), 'fresh': list(ds), + 'coefficient': str(v)} for (w, ds), v in sorted(p.items())] for p in row]} + for label, row in obs] + + +def coset_witnesses(code, gs): + columns = [linear(g, 1) for g in gs] + need(len(set(columns)) == 112, 'Distinct left monomial cosets') + zero = [j for j in range(112) if not code[j][j]] + witnesses = [next((j for j in zero if code[i][j]), None) for i in range(112)] + need(all(j is not None for j in witnesses), 'Every row meets a zero-diagonal column') + # A fixed j has distinct u=G_j^-1 G_i e0. The rank-one matrices u*u^T + # distinguish the left cosets. The diagonal of u*u^T recovers u. + for j in zero: + gi = inverse(gs[j]) + us = [linear(gi, columns[i]) for i in range(112) if code[i][j]] + need(len(us) == len(set(us)) and 1 not in us, 'Distinct off-diagonal coset signatures') + return witnesses + + +def rejected(fn, label): + try: + fn() + except ValueError: + return label + raise ValueError('Control accepted: ' + label) + + +def module_extension(code, normal, obs, a): + """Check the extra source facts used by the complete target-module proof.""" + gs = [r['K_word'][0][1] for r in normal['ports']] + witnesses = coset_witnesses(code, gs) + controls = [rejected(lambda: coset_witnesses(code, [gs[0]] * 112), 'homogeneous false frames')] + bad = [row[:] for row in code] + for j in range(112): + if not code[j][j]: + bad[0][j] = Q(0) + controls.append(rejected(lambda: coset_witnesses(bad, gs), 'unwitnessed code row')) + + lookup = dict(obs) + dd = a.mul(a.d, a.f) + A = a.mul(a.qi, a.e, dd) + B = a.mul(a.qi, a.c, dd) + L = a.mul(a.add(a.one, a.neg(a.mul(a.e, a.c))), dd) + Z = a.neg(a.mul(a.e, a.q, dd)) + need(lookup['cut6_after_FULL3:2'] == [{}, {}, L, Z], 'Literal high-layer C row') + need(lookup['cut6_after_FULL3:3'] == [{}, {}, B, dd], 'Literal high-layer B row') + need(lookup['cut7_after_thin4:3'] == [{}, {}, A, {}], 'Literal high-layer A row') + need(lookup['paid_response4_Qinv_C3_x'] == [{}, {}, a.add(A, a.neg(B)), a.neg(dd)], + 'Paid response is A minus B') + need(lookup['cut2_after_FULL1:0'] == [{}, a.neg(a.mul(a.c, a.d, a.q)), {}, {}], + 'First positive target has a free code decoder') + generators = [[A, {}], [B, dd], [L, Z], [a.add(A, a.neg(B)), a.neg(dd)]] + allowed = [[{}, {}]] + generators + [[a.neg(p) for p in v] for v in generators] + for _, row in obs: + high = [{key: value for key, value in p.items() if key[1] == (1, 1)} for p in row] + need(not high[0] and not high[1] and high[2:] in allowed, + 'Every high-layer observation is in A,B,C') + + def act(g, v, axes): + local = sum(((v >> k) & 1) << i for i, k in enumerate(axes)) + value = linear(g, local) + for i, k in enumerate(axes): + v = (v & ~(1 << k)) | (((value >> i) & 1) << k) + return v + + first, second = list(range(9)), [0] + list(range(9, 17)) + invs = [inverse(g) for g in gs] + identity_terms = [] + for k in range(112): + if not code[0][k] * code[k][0]: + continue + cols = [] + for j in range(17): + v = act(gs[0], 1 << j, first) + v = act(invs[k], v, first) + v = act(gs[k], v, second) + cols.append(act(invs[0], v, second)) + if cols == [1 << j for j in range(17)]: + identity_terms.append(k) + need(identity_terms == [0] and code[0][0] == 12, 'Unique identity term in leakage entry') + # The k=0 word is literally identity, with phase one. Every other + # supported word has a nonidentity linear part, so cannot be projectively I. + identity_coefficient = 1 - code[0][0] ** 2 + need(identity_coefficient == -143, 'Nonzero leakage coefficient') + trace = sum(code[i][i] for i in range(112)) + need(trace == 96, 'Rank-eight minus eigenspace') + return {'all_negative_columns': 224, 'row_witnesses': witnesses, + 'rejected_module_controls': controls, + 'nonzero_leak_identity_coefficient': str(identity_coefficient), + 'negative_eigenspace_rank': int((112 - trace) / 2), + 'complete_return_lower_bound': 225, 'arbitrary_oracle_upper_bound': 240} + + +def main(): + for pin in json.loads((HERE / 'INPUTS.json').read_bytes()): + need(sha256((HERE / pin['local_path']).read_bytes()).hexdigest() == pin['sha256'], 'Source pin') + right = Right() + obs = observations(right) + left = load('p2_left_source', 'algebra.py') + other = [(label, [to_right(p, right) for p in row]) for label, row in observations(left)] + need(obs == other and len(obs) == 39, 'All 156 bank coefficients in both normal forms') + need(observations(right, True) != obs, 'Omitted bridge control') + target_terms = [right.mul(right.d, right.qi), right.mul(right.d, right.q), + right.mul(right.f, right.d, right.qi), right.mul(right.f, right.d, right.q)] + # With no code, the declared four targets must be the exact endpoint. + plain = Right() + plain.c = plain.e = plain.one + last = [row for _, row in observations(plain)[-4:]] + need(last == [[target_terms[i] if i == j else {} for j in range(4)] for i in range(4)], + 'Uncoded full endpoint control') + raw = json.loads(gzip.decompress((HERE / 'inputs/INVOLUTIVE-WORD.json.gz').read_bytes()))['F'] + code = [[Q(raw[j][i]) for j in range(112)] for i in range(112)] + need(code[0][1] == Q(-1, 2), 'Literal F transpose entry') + scale = max(q.denominator for row in code for q in row) + need(all((q * scale).denominator == 1 for row in code for q in row), 'Exact integer scale') + ints = [[int(q * scale) for q in row] for row in code] + need(all(sum(ints[i][k] * ints[k][j] for k in range(112)) == (scale * scale if i == j else 0) + for i in range(112) for j in range(112)), 'Literal code involution') + normal = json.loads((HERE / 'inputs/NORMALIZERS.json').read_bytes()) + late, pairs = physical_grades(code, normal) + zero = [j for j in range(112) if not code[j][j]] + need(len(zero) == 104 and all(late[j] == {7} for j in zero), 'Complete zero-diagonal source') + terms = [sorted({key for _, row in obs for key in row[b]}) for b in range(4)] + targets = [9, 9, 17, 17] + missing, support = [], [] + for b in range(4): + column_support = [sorted(set().union(*(grades_for(t, j, late) for t in terms[b]))) + for j in range(112)] + absent = [j for j, ranks in enumerate(column_support) if targets[b] not in ranks] + missing.append(absent) + support.append(column_support) + need(missing == [zero, [], zero, []], 'Maximal grade-separated target set') + extension = module_extension(code, normal, obs, right) + b = extension['complete_return_lower_bound'] + paid = {1: 4754 + b, 2: 824, 3: 1020, 4: 254, 5: 80, 8: 224} + target = {4: 56, 7: 14, 8: 94, 9: 876, 17: 224} + hinges = {str(k): sum(n * min(r, k) for r, n in paid.items()) - + sum(n * min(r, k) for r, n in target.items()) + for k in sorted(set(paid) | set(target))} + need(min(hinges.values()) > 0 and hinges['17'] == 129, 'All-concave adverse bill') + # Selected diagonal terms and both positive banks defeat a larger grade claim. + need(all(9 in late[j] for j in set(range(112)) - set(zero)), 'Selected positive controls') + out = {'status': 'PASS_P2_FULL_HISTORY_DEFICIT', 'observations': 39, + 'bank_coefficients': 156, 'original_columns': 448, + 'term_families': [len(t) for t in terms], 'supported_native_pairs': len(pairs), + 'native_pair_sha256': sha256(json.dumps(pairs, separators=(',', ':')).encode()).hexdigest(), + 'missing_per_bank': list(map(len, missing)), 'missing_columns': missing, + 'necessary_returns': b, 'minimum_width': 72, 'module_extension': extension, + 'error_bound_columns': 208, + 'reference_q36_squared_error_width84': str(Q(125, 126) * (1 - Q(36, 208))), + 'any_profitable_q95_squared_error_width84': str(Q(125, 126) * (1 - Q(95, 208))), + 'repair_hinges': hinges, 'grade_support': support, 'new_kappa': None} + trace = encode(obs) + for filename, value in [('RESULT.json', out), ('OBSERVATIONS.json', trace)]: + if '--write' in sys.argv: + (HERE / filename).write_text(json.dumps(value, indent=2, sort_keys=True) + '\n') + else: + need(value == json.loads((HERE / filename).read_bytes()), 'Exact ' + filename) + print(json.dumps({k: v for k, v in out.items() if k not in ('grade_support', 'missing_columns')}, sort_keys=True)) + + +if __name__ == '__main__': + main()