diff --git a/research/native-provider-lift/.gitattributes b/research/native-provider-lift/.gitattributes new file mode 100644 index 0000000000..625449502b --- /dev/null +++ b/research/native-provider-lift/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/native-provider-lift/ACTUAL-WORD.json.gz b/research/native-provider-lift/ACTUAL-WORD.json.gz new file mode 100644 index 0000000000..46d929df83 Binary files /dev/null and b/research/native-provider-lift/ACTUAL-WORD.json.gz differ diff --git a/research/native-provider-lift/ADDITIONAL-SOURCE-PINS.json b/research/native-provider-lift/ADDITIONAL-SOURCE-PINS.json new file mode 100644 index 0000000000..90985b0fa8 --- /dev/null +++ b/research/native-provider-lift/ADDITIONAL-SOURCE-PINS.json @@ -0,0 +1,82 @@ +[ + { + "local_file": "sources/PR4483-DIRECT-MIXED-FLOW.md", + "sha256": "78351e2419eb1ff1d645addd411158b91b381b23a962a91b6deeebeacd5192a8", + "source": "PR4483 head fb0c208864e6b24e3473318a058aa5b2dbd5764b:research/direct-mixed-flow/README.md" + }, + { + "local_file": "sources/PR4630-4535-BRIDGE-PINS.json", + "sha256": "82b86fbc8a09bb7c72044bdfda1f7b45d694ef47f0bcbb4c4f5b38fc4134f248", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699; retained source maps supply earlier proof commits" + }, + { + "local_file": "sources/PR4630-CODE-SOURCE-PINS.json", + "sha256": "40d160b96402054c7cac05d21e383eda449445eceba2520a2a6a90c17b117c55", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699; retained source maps supply earlier proof commits" + }, + { + "local_file": "sources/PR4630-MODERN-SOURCE-MAP.json", + "sha256": "cc48b51a9b2ae46cef437e0a56c4e68b613f8c3bd8b03c3386bc6cf4745c6c57", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699; retained source maps supply earlier proof commits" + }, + { + "local_file": "sources/PR4630-NATIVE-ASSEMBLY.md", + "sha256": "a1f200292ea13d72bd64cb91a4daa28261bc220a80fe9c94983f3b9a1dffaa42", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699; retained source maps supply earlier proof commits" + }, + { + "local_file": "sources/PR4630-NATIVE-PROVIDER-4535.md", + "sha256": "242af59962fe466dc0bfe5826bd33da1b9b7d2430a2f8dfceb71e4282ecc410c", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699; retained source maps supply earlier proof commits" + }, + { + "local_file": "sources/PR4630-OFFLINE-SETUP.md", + "sha256": "cb9becabc6102270e93f83dfe808f367771a0f1f4eff729ff01b998fb91f85dc", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699; retained source maps supply earlier proof commits" + }, + { + "local_file": "sources/PR4630-RECORD-PRODUCT.md", + "sha256": "a141fe4ebb35aea44b1f006217841d40f57ca2112df6de6944a8507905e1ec57", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699; retained source maps supply earlier proof commits" + }, + { + "local_file": "root_seed.py", + "sha256": "9b323f84ade7decfa6152dd4385e90ec43b56087927ac23ad4ef73ae4d5d3042", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699:research/native-kappa-30201655/root_seed.py" + }, + { + "local_file": "native_convolution.py", + "sha256": "a62a4cb5a1da458e31c90ea881a1146b59e9fd7ccbf317c1c9836c19bc7fa2c6", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699:research/native-kappa-30201655/native_convolution.py" + }, + { + "local_file": "record_product.py", + "sha256": "6967feb00fbcb13640504f26c5e20bcea249e1dc89c41713aa8e8f161def873e", + "source": "PR4630 head f4b974db1f651250a252721cf127d0491a802699:research/native-kappa-30201655/record_product.py" + }, + { + "local_file": "critical_engine.py", + "sha256": "e656ef12f73a8dd3bdb256eca95a712de1269facb18a652fc4068ba718619b4d", + "source": "PR4535 a6d7237f697185e857090e174c23c1cb22c6563c:research/adaptive-gate-existence/root_application.py" + }, + { + "local_file": "majorant-benchmarks.json", + "sha256": "513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850", + "source": "Canonical main f626db5c3a3d781d8f7695038776c621651f75e1:research/rank-convergence/BENCHMARKS.json" + }, + { + "local_file": "CONTROLLER.json", + "sha256": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "source": "Canonical main fbc9ea0249746acca4f504d4fda2b84e0e36cf0d:research/joint-helper-lattice/CONTROLLER.json" + }, + { + "local_file": "ARITHMETIC.json", + "sha256": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "source": "PR4610 1eb8da6cfb35512c0cc2533413e5ca42f48e13c6:research/kappa-round3-warp-20261022/ARITHMETIC.json" + }, + { + "local_file": "ACTUAL-WORD.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "source": "PR4610 1eb8da6cfb35512c0cc2533413e5ca42f48e13c6:research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz" + } +] diff --git a/research/native-provider-lift/ARBITRARY-FRAME-BRIDGES.md b/research/native-provider-lift/ARBITRARY-FRAME-BRIDGES.md new file mode 100644 index 0000000000..488176141c --- /dev/null +++ b/research/native-provider-lift/ARBITRARY-FRAME-BRIDGES.md @@ -0,0 +1,40 @@ +# Exact arbitrary-frame bridges + +Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0. + +Let U,V be arbitrary subspaces of F₂ⁿ, with the retained source's canonical frame operators C_U and C_V. They need not be nested. Then the operator C_U.adjoint().then(C_V) has exact Fourier rank + + r(U,V)=dim U+dim V−2 dim(U∩V). + +It can therefore be implemented by one rank-r recursive Gaussian transform between two explicit monomial adapters, with all absolute phases retained. When r=0, only a monomial adapter is required. The finite exact Clifford lowering constructs and checks these adapters; this is a sufficient realization, not an assumption that arbitrary frame changes are free. + +## Proof + +Write Pauli exponents as (x,z)∈F₂ⁿ×F₂ⁿ and let L₀={(0,z)} denote the Z Lagrangian. We claim + + C_U(L₀)=L_U={(x,z):x∈U and x+z∈U⊥}. + +For the coordinate r-plane E, this follows directly from each retained C gate sending a Z basis generator to the corresponding XZ generator on selected axes and fixing unselected Z generators. For a general basis of U, the canonical frame uses an invertible matrix G with GE=U and the monomial K=D_Q P_G, where Q=I+G⁻ᵀG⁻¹. Its symplectic action is + + (x,z) ↦ (Gx,G⁻ᵀz+QGx). + +Consequently the new x coordinate is Gx and the sum of new x and z coordinates is G⁻ᵀ(x+z). This sends L_E precisely to L_U. The canonical-frame conjugation and the fact that K preserves L₀ prove the claim. The special zero and full-frame definitions satisfy the same formula. + +Now L_U∩L_V is parametrized independently by x∈U∩V and y=x+z∈(U+V)⊥. Its dimension is + + dim(U∩V)+n−dim(U+V) + =n−dim U−dim V+2 dim(U∩V). + +The Fourier rank of a symplectic operator is the rank of its B block, equivalently n minus the intersection dimension of its image of L₀ with L₀. Each canonical frame is a conjugate of commuting selected-axis C gates, whose symplectic actions are involutions; hence C_U and C_U⁻¹ have the same symplectic action. Applying an invertible canonical-frame action transports the intersection calculation above to the relative operator, in either composition convention. Therefore its rank is exactly r(U,V). + +The source's exact Clifford normal form factors any such relative operator into a right monomial, the r-axis Gaussian transform, and a left monomial. Its tableau and exact zero-state vector determine and check the absolute phase. Tensoring with identity spectator coordinates preserves the factorization and its active rank r. Taking f independent digit-column tensor copies gives active rank rf, as required by the retained all-fiber interface. + +## Finite check + +A separate checker evaluated 1,024 deterministic random pairs among the actual round-three frame registry. The Fourier rank read directly from each composed exact Clifford tableau matched the formula above in every case. The sample result is `RANK-FORMULA-SAMPLES.json`; it corroborates the proof and does not replace it. + +This primitive permits nonnested contact proposals in the native model, provided every actual bridge and both its adapters are charged and its endpoint is checked. It does not by itself establish any improved paid invoice or κ. Productive helper credit must use the same actual relative-operator rank; a helper's input remains an arbitrary independent field. + +## Attribution + +The canonical-frame and exact Clifford implementations are retained repository sources, including Cinna Davis's native/helper interface, the transported warp-frame work, zxv's native framework, and all original compiler notices. This note gives an explicit arbitrary-frame rank proof and its sufficient native realization. No Lean verification or novelty priority for the general Clifford normal form is claimed. diff --git a/research/native-provider-lift/ARITHMETIC-INDEPENDENT-REVIEW.md b/research/native-provider-lift/ARITHMETIC-INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..caa0a604d8 --- /dev/null +++ b/research/native-provider-lift/ARITHMETIC-INDEPENDENT-REVIEW.md @@ -0,0 +1,23 @@ +# Independent review of the new native target + +The source reviewed is Cao Yifan's PR #4610 at head 1eb8da6cfb35512c0cc2533413e5ca42f48e13c6, including round-three paid profile + + {1:2201,2:412,3:510,4:127,5:40,8:8} + +and unchanged productive census {4:28,7:7,8:47,9:326}. This is a genuinely changed paid invoice relative to the old #4470/#4535 supplier. Its acceptance still requires the exact endpoint/phase/whole-job conditions reviewed separately; a histogram alone cannot establish them. + +I read critical_provider_check.py and its frozen majorant engine. The exact interval root certification and the majorant checker both pass on the complete 64,404-paid, 10,928-productive profile with rank surplus 752. The retained witness a=1,b=1,height_base=1024,ell0=650,s=1/20,lambda=1/10,p=2/5,c=133 and upper_exponent=.997067 is applied to the changed profile, not to a stale old root. The bracket is theta in (.9969782241,.9969782242). + +For q_C=.0030217755 and N=2^(10^12), the gap 1-theta_hi-q_C is exactly 3/10^10. The source majorant constant obeys log A<20 from (1-theta)log n0 and n0=145*1024^650. The logarithmic overhead is below16 because 133+log N<2^40 and log2<1. Thus total logarithmic overhead is below36. Since log2>2/3, absorption has logarithmic margin greater than + + (3/10^10)*10^12*(2/3)-36 = 164. + +No enormous integer N is materialized. The derivative check gap > (2/5)/(133+(2/3)*10^12) ensures continuation for larger ranks. The finite compiler theorem still requires its credited chronological all-column construction and whole-job normalizers; this review does not manufacture them from the root. + +I independently recomputed the crossing using a separate 70-digit Decimal exponential/logarithm sum and 180 bisections (provider_review.py), obtaining a saving near .0030217758 in the same bracket. This is corroboration, not the exact interval certificate. The source engine's wrong-root and unfunded-mirror controls reject as intended. + +Finally, native_lift.choose('.0030217755','.0030217754') gives positive values for every interface guard and every nine-row excess. NEW-TARGET-PARAMETERS.json records the exact rational choices. In particular q=60435509/20000000000 and delta=1/80241742036, so the full-coordinate group-key exponent is 1-2delta<1, cap xi 0. + +This establishes the numerical assembly of conditional native κ=.0030217754 from the admitted stronger source provider and the retained analytic caller. It does not assert unconditional mathematical acceptance, a practical algorithm implementation, a new TM frontier or a further paid-profile improvement over the current #4610 round-three head. Prepared for Dugongue with substantial OpenAI Codex assistance; Apache-2.0. diff --git a/research/native-provider-lift/ARITHMETIC.json b/research/native-provider-lift/ARITHMETIC.json new file mode 100644 index 0000000000..c89e009ca4 --- /dev/null +++ b/research/native-provider-lift/ARITHMETIC.json @@ -0,0 +1,241 @@ +{ + "compiler": { + "H": 31385200000000, + "N": "2^31385200000000", + "eta": { + "lower": "0.000000204541256425394083726654", + "upper": "0.000000204541256425394083726655" + }, + "gap": "1/700000000", + "integer_test_exponent": 44836, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "1057619/350000000", + "word_materialized": false + }, + "gain_over_PR4535": "319/200000000", + "kappa": "9443/3125000", + "local_helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "local_paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "margin_at_old_root_upper": [ + "78072058023577019965454984044224523228758899702419408235/196159429230833773869868419475239575503198607639501078528", + "1249152928377232319447279744707592371660142395238823308861/3138550867693340381917894711603833208051177722232017256448" + ], + "native_receipt_sha256": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "nonrecursive": { + "local_routes": 4802000, + "local_scalar": 158168, + "raw_scalar_upper": 181098496 + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299999253/175000000000", + "fixed_halo_explicit_metadata_branch": "13475000001/175000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899997009/700000000000", + "new_semantic_group_guard": "3/700000000" + }, + "margins": { + "boundary_algebraic_matrix": "296133039576953/98000000000000000", + "fused_gaussian": "296133038730859/98000000000000000", + "global_coordinate_router": "528809/175000000", + "group_bit_router": "370166473413573/122500000000000000", + "group_scans": "349999999/350000000", + "main_transform": "296132899576953/98000000000000000", + "microbox_face_corrections": "13475000001/175000000", + "polynomial_products": "699999999/700000000", + "sparse_union_movement": "40108633039576953/98000000000000000" + }, + "parameters": { + "a": "528809/175000000", + "b": "2115237/700000000", + "beta": "699999997/700000000", + "bit_saving": "17/5000", + "cap_xi": "89108632899576953/98000000000000000", + "complex_uniform_saving": "1057619/350000000", + "d": "1/700000000", + "epsilon": "699999999/700000000", + "kappa": "9443/3125000", + "lambda_": "199395647/200000000", + "lambda_prime": "139576953/140000000", + "layout": "1/700000000", + "q": "423047/140000000", + "r0": "1/7000000000", + "stop": "1/700000000", + "tested_saving": "302177/100000000" + }, + "strict_checks": { + "actual_bit_above_effective": "66191/175000000", + "actual_logarithmic_gamma_guard": "1/700000000", + "actual_logarithmic_group_guard": "8891367310423047/49000000000000000", + "alpha_logarithm_absorption": "1/7000000000", + "boundary_algebraic_matrix_above_kappa": "559576953/98000000000000000", + "cap_above_band": "40108632899576953/98000000000000000", + "cap_below_cell": "8891366960423047/98000000000000000", + "cap_below_phase_cell_power": "106891367100423047/98000000000000000", + "complex_above_effective": "1/700000000", + "complex_below_one_over_32": "19759763/700000000", + "complex_endpoint": "1/350000000", + "epsilon_below_one": "1/700000000", + "epsilon_positive": "699999999/700000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "558730859/98000000000000000", + "gaussian_above_main": "69576953/49000000000000000", + "global_coordinate_router_above_kappa": "1/175000000", + "global_gamma_power_slack": "9/7000000000", + "group_below_dimension": "1/350000000", + "group_bit_router_above_kappa": "873413573/122500000000000000", + "group_gauge_power_slack": "8891367303423047/49000000000000000", + "group_key_fits_record": "1/350000000", + "group_positive": "699999997/700000000", + "group_scans_above_kappa": "348942383/350000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "645394790400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000", + "lambda_above_sigma": "3/1400000000", + "lambda_above_tau": "1/1400000000", + "lambda_prime_above_lambda": "1/1400000000", + "lambda_prime_above_leaf": "1397884763/490000000000000000", + "leaf_saving_above_effective": "697884763/490000000000000000", + "main_transform_above_kappa": "419576953/98000000000000000", + "membership_arithmetic_fits_record": "1/700000000", + "microbox_face_corrections_above_kappa": "13474471193/175000000", + "microbox_halo_volume": "55300000003/700000000", + "new_complex_uniform_saving_above_b": "1/700000000", + "new_semantic_guard_with_C1_one": "1/700000000", + "polynomial_products_above_kappa": "697884767/700000000", + "positive_layout_slack": "1/700000000", + "q_below_effective": "1/700000000", + "q_below_internal": "1/700000000", + "q_below_leaf": "1397884763/490000000000000000", + "q_positive": "423047/140000000", + "short_record_fallback": "697884763/700000000", + "source_axis_superpolynomial": "1/700000000", + "sparse_union_movement_above_kappa": "39812500559576953/98000000000000000", + "stop_below_one": "699999999/700000000", + "stop_positive": "1/700000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000", + "union_tag_work_per_visit_fits_record": "3/700000000" + } + }, + "paid": { + "1": 41298, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "paid_calls": 64404, + "productive_fields": 10928, + "rank_mass_surplus": 752, + "raw_root_interval": [ + "15108879/5000000000", + "30217759/10000000000" + ], + "scope": "Exact changed-profile arithmetic only. Requires separately admitted changed native programs, paid transports and absolute phases. Retained compiler/native/precision/tape/analytic/recovery assumptions.", + "source_sha256": { + "research/fresh-helper-boundary/native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "research/joint-helper-lattice/CONTROLLER.json": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "research/joint-helper-lattice/native_joint.py": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46", + "research/joint-helper-lattice/verify.py": "8eb13f77a94315f811612cb557a17edeecb6b9d9a75dfa238b112dd6520c336f", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85", + "research/kappa-interface-round2-20261022/price_profile.py": "adde619968d3ac37147d239e25145b28150650e9ce0f76035f680f22589adcbb", + "research/kappa-rebuild/architecture/mixed_target_probe.py": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a", + "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "research/query-thinned-controllers/RESULT.json": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "research/query-thinned-controllers/controller.py": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2" + }, + "status": "PASS_CHANGED_PROFILE_ARITHMETIC_NATIVE_ADMISSION_SEPARATE", + "strictification": { + "alpha": { + "lower": "0.999999993884252622740095906769", + "upper": "0.999999993884252622740095906770" + }, + "cutoff": 20, + "delta": { + "lower": "0.958285305508943939401236992035", + "upper": "0.958285305508943939401236992036" + }, + "floor": 21, + "gamma": { + "lower": "0.956217506703714253758457710273", + "upper": "0.956217506703714253758457710274" + }, + "normalized_paid_upper": "2097152001953127/2097154147483648", + "power": 1024, + "tail_offset": "1/5", + "tested": "302177/100000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 846, + "9": 5868 + } +} diff --git a/research/native-provider-lift/CONTENT-HASHES.json b/research/native-provider-lift/CONTENT-HASHES.json new file mode 100644 index 0000000000..b036a7eabd --- /dev/null +++ b/research/native-provider-lift/CONTENT-HASHES.json @@ -0,0 +1,70 @@ +{ + ".gitattributes": "8b9c3028d6467ff3be7c793141927841d70f47f52d0590677438f488ca154992", + "ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "ADDITIONAL-SOURCE-PINS.json": "603d832931113e0af1f07104d51361623872d00adb459982bf337d051039d374", + "ARBITRARY-FRAME-BRIDGES.md": "46fd98deb1f4c408cb4c21861c876b14da94865ed297d187223db8d518449587", + "ARITHMETIC-INDEPENDENT-REVIEW.md": "53746303c76ae2fdcc27c8bcaea62a7a7c1d574b4b726914c1058abe8a3202d7", + "ARITHMETIC.json": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "CONTROLLER.json": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "FRAME-BRIDGE-INDEPENDENT-REVIEW.md": "2b441e0d06107e2908fdb98375a3da1240da47924ac87ac612c2dfd50e520bb7", + "JOINT-TRANSPORT.md": "21fcf4e5d983e74c56edb41fe421a89560a6a9ba5210e9185538f8f371776cf6", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NATIVE-LIFT.md": "66188d374905361062d30710b2cd0510defcf50d3786c1e54323847c3d9f9d08", + "NATIVE-PROVIDER-4610.md": "51d4484f912be7ca093aa20e19eb7608d7a7eb55843727d11eda1c36e4099524", + "OPERATOR-INDEPENDENT-REVIEW.md": "3e1df216268db9f1db66d994862b511af544f8a555fc4d8e0613210a6906e2a9", + "OVERLAP.json": "5996748ab57ac54c1ee5a00ce39af01f31b2b39d647b41db10e3aaf6cf5495a2", + "PARAMETERS.json": "95bb0399057fd1c83687c8f51e47799cced99e0a112575bca486fb922a606a9e", + "PHASE-SOURCE-PINS.json": "3e7089b1564008bffcfba0f7732da44b2338ad8f59b66243662cc17637a888a6", + "PR4633-OVERLAP.json": "13cba4da5f4e96149fab95489a1b95d966d66fd7d19dc4702b713449de7151c4", + "README.md": "fb36c8c959dfc39fe01e2dd5a5910f1883bee6d52bfa15cd7aea5315ef0baa93", + "SOURCES.json": "f686ee49a74ab596c4d92120ffb4cbfdb0e1bcb07a6961810a03b72af259a311", + "TASK.json": "ffd2281ceb536601579d07b8d2ea4b4e3b4be60952914c2361050a6b807acf91", + "VERIFY.json": "94462667ffbcc7003a747d9bf6da95d1a0a050ae19c9682f350c61c7235bad78", + "critical_engine.py": "e656ef12f73a8dd3bdb256eca95a712de1269facb18a652fc4068ba718619b4d", + "critical_provider_check.py": "593fbf957e9049bcdfcee198cf4f47f1b4eb4cc40f05f216f983a9c4d8486faa", + "frame_bridge_review.py": "f1f8fb86ccc22dd39aa5195c1b496d3088269820b71b562a882fdb1d45032779", + "majorant-benchmarks.json": "513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850", + "native_convolution.py": "a62a4cb5a1da458e31c90ea881a1146b59e9fd7ccbf317c1c9836c19bc7fa2c6", + "native_lift.py": "c9cbf4d8baeb993b393388a948520b1b4031ae896c10be5616a5a9bdda9dc2d9", + "operator_check.py": "11d5855d89c07299c500b0f063d289cc318f152e392f2bb833bcf518ab2fa3a4", + "record_product.py": "6967feb00fbcb13640504f26c5e20bcea249e1dc89c41713aa8e8f161def873e", + "root_seed.py": "9b323f84ade7decfa6152dd4385e90ec43b56087927ac23ad4ef73ae4d5d3042", + "sources/PR4483-DIRECT-MIXED-FLOW.md": "78351e2419eb1ff1d645addd411158b91b381b23a962a91b6deeebeacd5192a8", + "sources/PR4630-4535-BRIDGE-PINS.json": "82b86fbc8a09bb7c72044bdfda1f7b45d694ef47f0bcbb4c4f5b38fc4134f248", + "sources/PR4630-CODE-SOURCE-PINS.json": "40d160b96402054c7cac05d21e383eda449445eceba2520a2a6a90c17b117c55", + "sources/PR4630-MODERN-SOURCE-MAP.json": "cc48b51a9b2ae46cef437e0a56c4e68b613f8c3bd8b03c3386bc6cf4745c6c57", + "sources/PR4630-NATIVE-ASSEMBLY.md": "a1f200292ea13d72bd64cb91a4daa28261bc220a80fe9c94983f3b9a1dffaa42", + "sources/PR4630-NATIVE-PROVIDER-4535.md": "242af59962fe466dc0bfe5826bd33da1b9b7d2430a2f8dfceb71e4282ecc410c", + "sources/PR4630-OFFLINE-SETUP.md": "cb9becabc6102270e93f83dfe808f367771a0f1f4eff729ff01b998fb91f85dc", + "sources/PR4630-RECORD-PRODUCT.md": "a141fe4ebb35aea44b1f006217841d40f57ca2112df6de6944a8507905e1ec57", + "v/research/fresh-helper-boundary/CHANGES.json": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "v/research/fresh-helper-boundary/native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "v/research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "v/research/joint-helper-lattice/NATIVE.json.gz": "74582cce642c80f0235be7fcbce3716174666326ac6a1d46d02a62a75d7be4c6", + "v/research/joint-helper-lattice/PATCH.json": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727", + "v/research/joint-helper-lattice/native_joint.py": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46", + "v/research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7", + "v/research/kappa-function-composition/complex/prune_native.py": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257", + "v/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "v/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "v/research/kappa-rebuild/complex/native_extensions.py": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3", + "v/research/kappa-rebuild/complex/power_two_balance.py": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424", + "v/research/kappa-rebuild/complex/rebuild_native.py": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5", + "v/research/kappa-round3-warp-20261022/ACTUAL-WORD-FREEZE.json": "b464b18dde15a4f3f0f71252f4eacf5a1883115fdff87734819e0b8e59b26285", + "v/research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "v/research/kappa-round3-warp-20261022/SOURCES.json": "533d6a3a8c8335826090b00cdc4928a996aec9dad58c81a27a77e4332c6ac06e", + "v/research/kappa-round3-warp-20261022/phase_check.py": "0aec13f218fd131b63430064c7cd212b4320a87564e75c34a359e08f1e249009", + "v/research/missing-join-frame/PATCH.json": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e", + "v/research/native-warp-extraction-boundary/algebra.py": "52b73c482f9aa171ac266bf0f5752bb520b100d79949f615d0aa26cb926452ba", + "v/research/native-warp-extraction-boundary/operators.py": "4427aa6bb35b095868381de947d177bdbfc2c92e8e0ef9c5a75731ac4d0ca5bd", + "v/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "v/research/transported-warp-frames/PROOF.md": "cd227d0cc0e34c7b4b6a850a042f0f99099f1fe9b25e0519982e8f5973603f2d", + "v/research/warp-interface-20261022/ACTUAL-WORD-FREEZE.json": "474c3fdd8194639bcfcf7b46259198c8a189bab0be9e059438d74d27a08ec8ca", + "v/research/warp-interface-20261022/ACTUAL-WORD.json.gz": "d578875344095047c383ef513e69b9deb9d99d2b75abe14f7359d06365a924ac", + "v/research/warp-interface-20261022/PATCH.json": "9da8af096dfc08d9a2e953bf8b78e81195fe74e8da2583d5d7fd0eed97f7a748", + "v/research/warp-interface-20261022/PHASE-VALIDATION.json.gz": "352572dd77a20dd4569b0172aed5971f5bdb324efa75798ce6d84089812a1d38", + "v/research/warp-interface-20261022/SOURCES.json": "7d40ebea3255181e900a15557825ba92cc7dd25c7963285b82736b2c2fb2bb0c", + "v/research/warp-interface-20261022/verify_candidate.py": "7aae8922f456673f3be7045c064e4700cf929c51da1316368758fb5cdd3a3e50", + "v/research/warp-interface-20261022/warp_merge.py": "661fe7dc9d079da2753ba8af9b512d24e8c16b39caf709b459709a495d7d17f6", + "verify.py": "17f9e942c315713b6c8280eda48357075250197b42b56de448baff8c7fa1182f" +} diff --git a/research/native-provider-lift/CONTROLLER.json b/research/native-provider-lift/CONTROLLER.json new file mode 100644 index 0000000000..49a2f06758 --- /dev/null +++ b/research/native-provider-lift/CONTROLLER.json @@ -0,0 +1,5224 @@ +{ + "ambient_rank": 145, + "boundaries": { + "left": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "left_program": [ + [ + "SWAP", + 30, + 31 + ], + [ + "SWAP", + 29, + 30 + ], + [ + "SWAP", + 28, + 30 + ], + [ + "SWAP", + 27, + 29 + ], + [ + "SWAP", + 26, + 28 + ], + [ + "SWAP", + 25, + 30 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "SWAP", + 23, + 26 + ], + [ + "SWAP", + 22, + 30 + ], + [ + "SWAP", + 20, + 26 + ], + [ + "SWAP", + 19, + 22 + ], + [ + "SWAP", + 18, + 29 + ], + [ + "SWAP", + 17, + 23 + ], + [ + "SWAP", + 16, + 27 + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "SWAP", + 15, + 31 + ], + [ + "ADD", + 12, + 14, + "1" + ], + [ + "ADD", + 10, + 14, + "-1" + ], + [ + "ADD", + 8, + 14, + "1" + ], + [ + "ADD", + 6, + 14, + "-1" + ], + [ + "ADD", + 4, + 14, + "1" + ], + [ + "ADD", + 2, + 14, + "-1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 31, + 13, + "1" + ], + [ + "SWAP", + 13, + 30 + ], + [ + "ADD", + 10, + 12, + "1" + ], + [ + "ADD", + 8, + 12, + "-1" + ], + [ + "ADD", + 6, + 12, + "1" + ], + [ + "ADD", + 4, + 12, + "-1" + ], + [ + "ADD", + 2, + 12, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "SWAP", + 12, + 14 + ], + [ + "ADD", + 31, + 11, + "-1" + ], + [ + "ADD", + 30, + 11, + "-1" + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "SWAP", + 11, + 29 + ], + [ + "ADD", + 8, + 10, + "1" + ], + [ + "ADD", + 6, + 10, + "-1" + ], + [ + "ADD", + 4, + 10, + "1" + ], + [ + "ADD", + 2, + 10, + "-1" + ], + [ + "ADD", + 0, + 10, + "1" + ], + [ + "SWAP", + 10, + 13 + ], + [ + "ADD", + 31, + 9, + "1" + ], + [ + "ADD", + 30, + 9, + "1" + ], + [ + "ADD", + 29, + 9, + "1" + ], + [ + "SWAP", + 9, + 28 + ], + [ + "ADD", + 6, + 8, + "1" + ], + [ + "ADD", + 4, + 8, + "-1" + ], + [ + "ADD", + 2, + 8, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "SWAP", + 8, + 12 + ], + [ + "ADD", + 31, + 7, + "-1" + ], + [ + "ADD", + 30, + 7, + "-1" + ], + [ + "ADD", + 29, + 7, + "-1" + ], + [ + "ADD", + 28, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SWAP", + 7, + 27 + ], + [ + "ADD", + 4, + 6, + "1" + ], + [ + "ADD", + 2, + 6, + "-1" + ], + [ + "ADD", + 0, + 6, + "1" + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 31, + 5, + "1" + ], + [ + "ADD", + 30, + 5, + "1" + ], + [ + "ADD", + 29, + 5, + "1" + ], + [ + "ADD", + 28, + 5, + "1" + ], + [ + "ADD", + 27, + 5, + "1" + ], + [ + "SWAP", + 5, + 26 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "SWAP", + 4, + 10 + ], + [ + "ADD", + 31, + 3, + "-1" + ], + [ + "ADD", + 30, + 3, + "-1" + ], + [ + "ADD", + 29, + 3, + "-1" + ], + [ + "ADD", + 28, + 3, + "-1" + ], + [ + "ADD", + 27, + 3, + "-1" + ], + [ + "ADD", + 26, + 3, + "-1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 25 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 9 + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 30, + 1, + "1" + ], + [ + "ADD", + 29, + 1, + "1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 26, + 1, + "1" + ], + [ + "ADD", + 25, + 1, + "1" + ], + [ + "SWAP", + 1, + 24 + ], + [ + "SWAP", + 0, + 8 + ] + ], + "right": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "right_program": [ + [ + "ADD", + 30, + 31, + "-1" + ], + [ + "ADD", + 29, + 31, + "-1" + ], + [ + "ADD", + 28, + 31, + "-1" + ], + [ + "ADD", + 27, + 31, + "-1" + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 30, + "-1" + ], + [ + "ADD", + 29, + 30, + "-1" + ], + [ + "ADD", + 28, + 30, + "-1" + ], + [ + "ADD", + 27, + 30, + "-1" + ], + [ + "ADD", + 31, + 29, + "-1" + ], + [ + "ADD", + 28, + 29, + "-1" + ], + [ + "ADD", + 27, + 29, + "-1" + ], + [ + "SCALE", + 29, + "-1" + ], + [ + "ADD", + 31, + 28, + "-1" + ], + [ + "ADD", + 27, + 28, + "-1" + ], + [ + "SWAP", + 28, + 29 + ], + [ + "ADD", + 31, + 27, + "-1" + ], + [ + "SCALE", + 27, + "-1" + ], + [ + "SWAP", + 27, + 29 + ], + [ + "ADD", + 31, + 26, + "1" + ], + [ + "SWAP", + 26, + 29 + ], + [ + "ADD", + 29, + 25, + "-1" + ], + [ + "ADD", + 24, + 25, + "-1" + ], + [ + "SWAP", + 25, + 28 + ], + [ + "ADD", + 28, + 24, + "1" + ], + [ + "SWAP", + 23, + 29 + ], + [ + "SWAP", + 22, + 25 + ], + [ + "SWAP", + 20, + 23 + ], + [ + "SWAP", + 19, + 25 + ], + [ + "SWAP", + 18, + 27 + ], + [ + "SWAP", + 17, + 29 + ], + [ + "SWAP", + 16, + 31 + ], + [ + "ADD", + 14, + 15, + "-1" + ], + [ + "SWAP", + 15, + 30 + ], + [ + "ADD", + 13, + 14, + "-1" + ], + [ + "SWAP", + 14, + 30 + ], + [ + "ADD", + 12, + 13, + "-1" + ], + [ + "SWAP", + 13, + 22 + ], + [ + "ADD", + 11, + 12, + "-1" + ], + [ + "SWAP", + 12, + 30 + ], + [ + "ADD", + 10, + 11, + "-1" + ], + [ + "SWAP", + 11, + 18 + ], + [ + "ADD", + 9, + 10, + "-1" + ], + [ + "SWAP", + 10, + 22 + ], + [ + "ADD", + 8, + 9, + "-1" + ], + [ + "SWAP", + 9, + 26 + ], + [ + "SWAP", + 8, + 30 + ], + [ + "SWAP", + 7, + 16 + ], + [ + "SWAP", + 6, + 18 + ], + [ + "SWAP", + 5, + 20 + ], + [ + "SWAP", + 4, + 22 + ], + [ + "SWAP", + 3, + 24 + ], + [ + "SWAP", + 2, + 26 + ], + [ + "SWAP", + 1, + 28 + ], + [ + "SWAP", + 0, + 30 + ] + ] + }, + "diagonal": [ + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ] + ], + "invoice": { + "main": { + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 46446, + "2": 12834, + "3": 4032, + "4": 1836, + "5": 360, + "8": 144, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + }, + "paid_calls": 69012, + "productive_fields": 10928, + "rank_surplus": 752, + "raw_scalar_record_bound": 1000000000, + "targets": { + "5": 504, + "6": 324, + "7": 1008, + "8": 1674, + "9": 3834, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + }, + "thick_calls": 18, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ], + "thin_queries": 1680, + "whole_idle": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + } + }, + "keep_mask": 35047648968703, + "kind": "complex", + "pairs": 16, + "physical_events": [ + [ + "LOCAL", + 0, + 0, + false + ], + [ + "LOCAL", + 1, + 0, + true + ], + [ + "IDLE", + 1, + [ + 0, + 1 + ] + ], + [ + "ADD", + 0, + 2, + 1 + ], + [ + "ADD", + 3, + 1, + -1 + ], + [ + "QUERY_SHEAR", + 2, + 0, + false + ], + [ + "ADD", + 0, + 2, + -1 + ], + [ + "ADD", + 3, + 1, + 1 + ], + [ + "LOCAL", + 3, + 1, + true + ], + [ + "IDLE", + 2, + [ + 0, + 1, + 3 + ] + ], + [ + "ADD", + 2, + 4, + 1 + ], + [ + "ADD", + 5, + 3, + -1 + ], + [ + "QUERY_SHEAR", + 4, + 1, + false + ], + [ + "ADD", + 2, + 4, + -1 + ], + [ + "ADD", + 5, + 3, + 1 + ], + [ + "LOCAL", + 5, + 2, + true + ], + [ + "IDLE", + 3, + [ + 0, + 1, + 3, + 5 + ] + ], + [ + "ADD", + 4, + 6, + 1 + ], + [ + "ADD", + 7, + 5, + -1 + ], + [ + "QUERY_SHEAR", + 6, + 2, + false + ], + [ + "ADD", + 4, + 6, + -1 + ], + [ + "ADD", + 7, + 5, + 1 + ], + [ + "LOCAL", + 7, + 3, + true + ], + [ + "IDLE", + 4, + [ + 0, + 1, + 3, + 5, + 7 + ] + ], + [ + "ADD", + 6, + 8, + 1 + ], + [ + "ADD", + 9, + 7, + -1 + ], + [ + "QUERY_SHEAR", + 8, + 3, + false + ], + [ + "ADD", + 6, + 8, + -1 + ], + [ + "ADD", + 9, + 7, + 1 + ], + [ + "LOCAL", + 9, + 4, + true + ], + [ + "IDLE", + 5, + [ + 0, + 1, + 3, + 5, + 7, + 9 + ] + ], + [ + "ADD", + 8, + 10, + 1 + ], + [ + "ADD", + 11, + 9, + -1 + ], + [ + "QUERY_SHEAR", + 10, + 4, + false + ], + [ + "ADD", + 8, + 10, + -1 + ], + [ + "ADD", + 11, + 9, + 1 + ], + [ + "LOCAL", + 11, + 5, + true + ], + [ + "IDLE", + 6, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11 + ] + ], + [ + "ADD", + 10, + 12, + 1 + ], + [ + "ADD", + 13, + 11, + -1 + ], + [ + "QUERY_SHEAR", + 12, + 5, + false + ], + [ + "ADD", + 10, + 12, + -1 + ], + [ + "ADD", + 13, + 11, + 1 + ], + [ + "LOCAL", + 13, + 6, + true + ], + [ + "IDLE", + 7, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13 + ] + ], + [ + "ADD", + 12, + 14, + 1 + ], + [ + "ADD", + 15, + 13, + -1 + ], + [ + "QUERY_SHEAR", + 14, + 6, + false + ], + [ + "ADD", + 12, + 14, + -1 + ], + [ + "ADD", + 15, + 13, + 1 + ], + [ + "LOCAL", + 15, + 7, + true + ], + [ + "ADD", + 14, + 16, + 1 + ], + [ + "ADD", + 17, + 15, + -1 + ], + [ + "QUERY_SHEAR", + 16, + 7, + false + ], + [ + "ADD", + 14, + 16, + -1 + ], + [ + "ADD", + 17, + 15, + 1 + ], + [ + "LOCAL", + 17, + 8, + true + ], + [ + "ADD", + 16, + 18, + 1 + ], + [ + "ADD", + 19, + 17, + -1 + ], + [ + "QUERY_SHEAR", + 18, + 8, + false + ], + [ + "ADD", + 16, + 18, + -1 + ], + [ + "ADD", + 19, + 17, + 1 + ], + [ + "LOCAL", + 19, + 9, + true + ], + [ + "ADD", + 18, + 20, + 1 + ], + [ + "ADD", + 21, + 19, + -1 + ], + [ + "QUERY_SHEAR", + 20, + 9, + false + ], + [ + "ADD", + 18, + 20, + -1 + ], + [ + "ADD", + 21, + 19, + 1 + ], + [ + "LOCAL", + 21, + 10, + true + ], + [ + "ADD", + 20, + 22, + 1 + ], + [ + "ADD", + 23, + 21, + -1 + ], + [ + "QUERY_SHEAR", + 22, + 10, + false + ], + [ + "ADD", + 20, + 22, + -1 + ], + [ + "ADD", + 23, + 21, + 1 + ], + [ + "LOCAL", + 23, + 11, + true + ], + [ + "ADD", + 22, + 24, + 1 + ], + [ + "ADD", + 25, + 23, + -1 + ], + [ + "QUERY_SHEAR", + 24, + 11, + false + ], + [ + "ADD", + 22, + 24, + -1 + ], + [ + "ADD", + 25, + 23, + 1 + ], + [ + "LOCAL", + 25, + 12, + true + ], + [ + "ADD", + 24, + 26, + 1 + ], + [ + "ADD", + 27, + 25, + -1 + ], + [ + "QUERY_SHEAR", + 26, + 12, + false + ], + [ + "ADD", + 24, + 26, + -1 + ], + [ + "ADD", + 27, + 25, + 1 + ], + [ + "LOCAL", + 27, + 13, + true + ], + [ + "ADD", + 26, + 28, + 1 + ], + [ + "ADD", + 29, + 27, + -1 + ], + [ + "QUERY_SHEAR", + 28, + 13, + false + ], + [ + "ADD", + 26, + 28, + -1 + ], + [ + "ADD", + 29, + 27, + 1 + ], + [ + "LOCAL", + 29, + 14, + true + ], + [ + "ADD", + 28, + 30, + 1 + ], + [ + "ADD", + 31, + 29, + -1 + ], + [ + "QUERY_SHEAR", + 30, + 14, + false + ], + [ + "ADD", + 28, + 30, + -1 + ], + [ + "ADD", + 31, + 29, + 1 + ], + [ + "LOCAL", + 31, + 15, + true + ], + [ + "LOCAL", + 32, + 15, + false + ], + [ + "IDLE", + 7, + [ + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 8, + [ + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 9, + [ + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 10, + [ + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 11, + [ + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 12, + [ + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 13, + [ + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 14, + [ + 31, + 32 + ] + ], + [ + "ADD", + 30, + 28, + 1 + ], + [ + "ADD", + 29, + 31, + -1 + ], + [ + "ADD", + 28, + 26, + 1 + ], + [ + "ADD", + 27, + 29, + -1 + ], + [ + "ADD", + 26, + 24, + 1 + ], + [ + "ADD", + 25, + 27, + -1 + ], + [ + "ADD", + 24, + 22, + 1 + ], + [ + "ADD", + 23, + 25, + -1 + ], + [ + "ADD", + 22, + 20, + 1 + ], + [ + "ADD", + 21, + 23, + -1 + ], + [ + "ADD", + 20, + 18, + 1 + ], + [ + "ADD", + 19, + 21, + -1 + ], + [ + "ADD", + 18, + 16, + 1 + ], + [ + "ADD", + 17, + 19, + -1 + ], + [ + "ADD", + 16, + 14, + 1 + ], + [ + "ADD", + 15, + 17, + -1 + ], + [ + "ADD", + 14, + 12, + 1 + ], + [ + "ADD", + 13, + 15, + -1 + ], + [ + "ADD", + 12, + 10, + 1 + ], + [ + "ADD", + 11, + 13, + -1 + ], + [ + "ADD", + 10, + 8, + 1 + ], + [ + "ADD", + 9, + 11, + -1 + ], + [ + "ADD", + 8, + 6, + 1 + ], + [ + "ADD", + 7, + 9, + -1 + ], + [ + "ADD", + 6, + 4, + 1 + ], + [ + "ADD", + 5, + 7, + -1 + ], + [ + "ADD", + 4, + 2, + 1 + ], + [ + "ADD", + 3, + 5, + -1 + ], + [ + "ADD", + 2, + 0, + 1 + ], + [ + "ADD", + 1, + 3, + -1 + ], + [ + "SIGNED_SWAP", + 0, + 1 + ], + [ + "SIGNED_SWAP", + 2, + 3 + ], + [ + "SIGNED_SWAP", + 4, + 5 + ], + [ + "SIGNED_SWAP", + 6, + 7 + ], + [ + "SIGNED_SWAP", + 8, + 9 + ], + [ + "SIGNED_SWAP", + 10, + 11 + ], + [ + "SIGNED_SWAP", + 12, + 13 + ], + [ + "SIGNED_SWAP", + 14, + 15 + ], + [ + "SIGNED_SWAP", + 16, + 17 + ], + [ + "SIGNED_SWAP", + 18, + 19 + ], + [ + "SIGNED_SWAP", + 20, + 21 + ], + [ + "SIGNED_SWAP", + 22, + 23 + ], + [ + "SIGNED_SWAP", + 24, + 25 + ], + [ + "SIGNED_SWAP", + 26, + 27 + ], + [ + "SIGNED_SWAP", + 28, + 29 + ], + [ + "SIGNED_SWAP", + 30, + 31 + ] + ], + "prefix_pairs": 7 +} diff --git a/research/native-provider-lift/FRAME-BRIDGE-INDEPENDENT-REVIEW.md b/research/native-provider-lift/FRAME-BRIDGE-INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..e439ec33c8 --- /dev/null +++ b/research/native-provider-lift/FRAME-BRIDGE-INDEPENDENT-REVIEW.md @@ -0,0 +1,17 @@ +# Independent review of arbitrary-frame bridges and native provider consequence + +Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0. + +The arbitrary-frame theorem in ARBITRARY-FRAME-BRIDGES.md is mathematically sound with the retained source conventions. I independently inspected clifford_exact.py's canonical_frame, cgate, perm, diag, Op.then and lower_child implementations. + +The source matrix convention is rows for G and gi=G^-1. The canonical-frame constructor forms inner products of columns of gi, so its Q is exactly I+G^-T G^-1. Since perm.then(diag) acts as D_Q P_G, its symplectic action is (x,z)→(Gx,G^-T z+QGx). In characteristic two the sum of the new coordinates is G^-T(x+z). Hence K maps L_E onto the stated L_U, and canonical_frame=K C_E K^-1 sends L0 onto L_U. Selected C gates send (x,z) to (x+z,z) on their own coordinate, with involutive symplectic action. The full and zero source special cases obey the same Lagrangian formula. + +For arbitrary U,V, the intersection L_U∩L_V has independent coordinates x∈U∩V and y=x+z∈(U+V)^perp. Its dimension is n-dimU-dimV+2dim(U∩V). Applying the inverse canonical action gives the relative operator's B-block nullity. Thus the exact Fourier rank is dimU+dimV-2dim(U∩V), including nonnested frames. Source lower_child realizes its Clifford normal form with two explicit monomial adapters and checks the absolute phase through its literal circuit and zero-state vector. Rank zero needs no recursive child. All adapters must still be paid by the retained native implementation. + +One wording correction was requested and should be retained: tensoring with identity spectators leaves rank r unchanged; the tensor product of f independent digit-column copies has rank fr. These are different operations. This distinction does not invalidate the rank theorem or its all-fiber construction once the correct operation is stated. + +As separate corroboration I wrote frame_bridge_review.py, which enumerates every subspace of F2^n for n=1,2,3, rather than selecting registry samples. It computes L_U directly from the source's literal tableau, checks the proposed membership formula, checks the symplectic involution, and checks every relative Fourier rank and exact phase-preserving lower_child factorization. All 23 subspaces, 285 ordered pairs and 152 Lagrangian vectors pass. FRAME-BRIDGE-REVIEW.json pins the exact Clifford source SHA256. Finite enumeration supports the written universal proof and is not its replacement. + +I also read the new package's NATIVE-PROVIDER-4610.md and NATIVE-LIFT.md. Their claim remains properly source-bound: an actual all-fiber chronological supplier identity and explicit whole-job normalization are retained premises, rather than inferred from histograms or f=1 replay. The native closure charges all sources, stock, leftovers and owned work, and proves precision directly without a TM tariff. The changed #4610 profile has a funded critical majorant and q_C=.0030217755 finite supplier; the generic theorem's rational parameter choice gives strict native κ=.0030217754. No stronger complex quotient is silently admitted. See PROVIDER-INDEPENDENT-REVIEW.md for the independently corroborated root and exact native margins. + +This review establishes no additional numerical gain from arbitrary-frame bridges alone, no global optimality of a search grammar, no Lean kernel verification and no unconditional acceptance of inherited analytic or compiler proofs. The positive result is an exact sufficient bridge realization and its native assembly consequence under the stated retained mathematical inputs. diff --git a/research/native-provider-lift/JOINT-TRANSPORT.md b/research/native-provider-lift/JOINT-TRANSPORT.md new file mode 100644 index 0000000000..2f0ea48a9e --- /dev/null +++ b/research/native-provider-lift/JOINT-TRANSPORT.md @@ -0,0 +1,39 @@ +# Joint partial transport and exact scalar-circuit gauges + +Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0. + +## A sufficient exact transporter theorem + +Let V be a finite-dimensional vector space over a field, A and B subspaces of V, L another subspace and f:L→V a specified linear map. There exists an invertible G:V→V such that G(A)=B and G restricted to L equals f if and only if: + +1. dim A = dim B; +2. f is injective; +3. f(L ∩ A) = f(L) ∩ B. + +This is a complete sufficient construction, not just a necessary incidence test. + +Proof. Necessity follows by applying G to intersections. For sufficiency, choose a basis C of L∩A, extend it by D to a basis of L, and extend C by E to a basis of A. Their union C,D,E is independent. The vectors f(C),f(D) are independent, and the last condition says their span intersects B exactly in span f(C). Extend f(C) to a basis f(C),E' of B. Therefore f(C),f(D),E' is independent. Extend C,D,E and f(C),f(D),E' separately to bases of V and send one basis to the other. The resulting invertible G is the required map. This is a finite Gaussian-elimination algorithm; over F₂⁹ it is small exact arithmetic. + +If the supplied restrictions are individual pairs a_i→b_i, first check every linear dependence among the a_i is also a dependence among the b_i, and conversely. These checks define an injective f on L=span(a_i). Checking separate line memberships without those relation checks is insufficient. For example a₁=e₁,a₂=e₂,a₃=e₁+e₂ cannot map to b₁=e₁,b₂=e₂,b₃=e₁ under any linear map, although every a_i and b_i is nonzero. + +With one nonzero pair a→b, the condition reduces to dim A=dim B and a∈A if and only if b∈B. This recovers the constrained-map predicate already used by Cao Yifan's round-three search. Its multi-pair form allows shared native maps with several freed prelude occurrences to be tested jointly, instead of silently constructing inconsistent maps for different contacts. + +## Exact all-column gauge identity + +For composable linear maps M₁,…,M_s on the whole persistent/owned state and invertible state-coordinate gauges D₀,…,D_s, define + + M'_j = D_j M_j D_(j-1)^(-1). + +Then, on every state, including arbitrary independent helper inputs, + + M'_s … M'_1 = D_s (M_s … M₁) D₀^(-1). + +Proof: cancel each adjacent D_j^(-1)D_j. This is an operator identity, so basis-column replay can corroborate it but is not its proof. When initial and final gauges are fixed, the complete semantic endpoint is unchanged. If helper entrance gauges change, the helper endpoint changes by the displayed relative conjugation and must be included as its actual productive interface; it is not initialized scratch and it is not interchangeable with an unrelated Gaussian chart. + +For an elementary scalar contact x←x+a y, independent data-coordinate gauges on x and y retain exactly that scalar opcode only when the two data-coordinate maps agree (or when their relative map is explicitly implemented and paid). Thus a search cannot free each scalar incidence independently. Choose one frame per scalar contact, include every paid transition between consecutive contacts, require the same physical native G at all its occurrences, and use the transporter theorem to test the complete joint constraints. The conjugation identity then supplies an all-column proof for the changed gauge schedule. Exact Clifford lifting must retain absolute phases, rather than checking only projective matrix agreement. + +## Application to the twelve prelude contracts + +The current round-three witness keeps the twelve additional prelude maps fixed. To extend that feasible set, expose their prelude line contacts as shared variables as well as their late source/target subspaces. For each reused G, combine every prescribed pair into one partial f and apply the theorem. A candidate has a positive admission path only after reconstructing the entire chronological word, counting all paid rank changes and owned jobs, retaining main endpoints, authenticating every helper's relative interface, lowering absolute Clifford phases and replaying all independent columns. + +This is a constructive search-enabling theorem. It claims no improvement from any candidate not yet emitted and admitted, no global optimality for the finite search, and no resolution of PR #4629's changed-main endpoint objection. Credit Cao Yifan's joint helper/native-map search, Dugongue's transported warp-frame lemma, Cinna Davis's joint-helper circuit and the cumulative Clifford/compiler lineage. The basis extension and gauge cancellation are classical linear algebra, stated here in the concrete sufficient form needed by this contact search. diff --git a/research/native-provider-lift/LICENSE b/research/native-provider-lift/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/native-provider-lift/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/native-provider-lift/NATIVE-LIFT.md b/research/native-provider-lift/NATIVE-LIFT.md new file mode 100644 index 0000000000..a900a66392 --- /dev/null +++ b/research/native-provider-lift/NATIVE-LIFT.md @@ -0,0 +1,104 @@ +# A supplier-to-native-multiplication theorem below 3/32 + +Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0. + +## Scope and precise sufficient conclusion + +Retain the actual algebraic and analytic source results, scalar instructions and paid native algorithms of PR #4630, pinned at head f4b974db1f651250a252721cf127d0491a802699. These are the explicit all-column chronological finite-word identities, finite compiler, fine-padding Gaussian/Poisson reduction, capped gauge-free Toeplitz tensor circuits, batched boundary factors and integer recovery theorem enumerated in its NATIVE-ASSEMBLY.md. They are mathematical dependencies, not permission to replace a missing identity by an oracle. + +Assume a fixed, algorithmically specified uniform provider word with productive width W, complete paid leaf count P and rank N satisfies + + P/W < N^(1-q_C), 0 < q_C < 1. + +A purported larger q_C may first be weakened to 1/2. Its exact endpoint must be the required canonical selected-axis Gaussian operator on every independent productive field, with literal phase charts, restored owned storage, actual all-column/fiber lift, and the coefficient/prefix bounds required by the native finite-word lowering. The moment inequality alone is insufficient. Fixed N and all its instructions may be enormous; they must be effective finite constructions independent of the growing input. + +Then, for every real target + + 0 < kappa < min(q_C, 3/32), + +these retained constructions multiply packed n-bit integers on a standard Word RAM in + + O(n/(log n)^kappa) + +operations, with word width C log n for a sufficiently large fixed C. No Turing-machine algorithm, BIT transform supplier, or tape-to-RAM simulation is a premise. For real endpoints, choose rational interior q and kappa first; the explicit rational formulas below suffice for every rational target and therefore for every strictly smaller real target. This is a source-bound sufficient theorem, not an unconditional record claim or a new paid supplier profile. + +## Explicit universal parameter choice + +Put c=3/32 and Q=min(q_C,c). For rational 0 0. + +Here stop is the harmless strict loss used by the provider recurrence/base policy; it is not a license to omit paid exits or owned work. The finite provider lowering is unchanged. Only the dimension, grouping and cap parameters in the actual native caller vary. + +## All interface guards, with universal proofs + +We have 0=97/100>0, beta0. The global gamma guard is + + 1-epsilon-r = 9delta/10 > 0. + +The full-coordinate group key has size + + K=O(p^(beta+1-epsilon)+p^beta log p), + +where beta+1-epsilon=1-2delta<1. Hence K=o(p), and explicitly enumerating the actual coefficient/address/classification functions on every K-bit key costs n^o(1). It is important that the key includes coarse coordinates, not only a local membership header. The separate retained membership guard is + + 1-beta-2(1-epsilon)=delta>0. + +Since epsilon>=99/100, + + xi > 99/100 - 3/32 > 1/2. + +The cap lies below the axis exponent because + + epsilon-xi = c-epsilon*q-layout + >= c-q-delta/100 > 0; + +indeed delta<=(c-q)/16. The actual chirp/conditioning guard simplifies exactly to + + 1-(beta+2xi-2+r) + = 2(c-q) + delta(122/25+2q) > 0. + +Thus the group guard bits remain o(p). This explicitly preserves the two potentially restrictive analytic inequalities while allowing q up to c. Fixed polynomial setup remains polynomial(s_i,p)=n^o(1), and all online coefficients remain O(p) bits under the retained conditioning bounds. + +## Every paid native row + +The actual algorithms and complete accounting are those in PR #4630. Here p=Theta(log n), d=Theta(p^epsilon), g=Theta(p^beta), cap B=Theta(p^xi), boundary width W_band=O(sqrt(p) polylog p), and T p=Theta(n). Every row is O(T p^(1-saving) polylog p): + +| Actual native operation | Saving | Strict comparison with kappa | +|---|---:|---| +| Main simultaneous transform | epsilon*q | q-delta*q > kappa | +| Standalone complete-address routing | 1 | 1>kappa | +| Fused Gaussian circuits | 1-epsilon+q*beta | q+delta(1-3q)>q>kappa | +| Additional standalone addressing passes | 1 | 1>kappa | +| Extra group scans and lookups | 1-epsilon+beta=1-2delta | >=98/100>kappa | +| Boundary algebra, both couplings and periodic closure | c+xi-epsilon=epsilon*q+layout | >epsilon*q>kappa | +| Indexed sparse-axis visits | 1/2+xi-epsilon=13/32+epsilon*q+layout | >13/32>kappa | +| Global-precision polynomial record products | epsilon | >=99/100>kappa | +| Core-face recovery | 79-epsilon-beta | >77>kappa | + +For the first row, delta <= (q-kappa)/(4(q+1)) implies delta*q < (q-kappa)/4. Its saving exceeds kappa by more than 3(q-kappa)/4. This proves all nine strict comparisons without numerical optimization. + +The boundary exponent uses Strassen's explicit seven-product recursion and the exact integer certificate 7^16<2^45, giving c=3/32 conservatively. It includes factorization setup, batched solves, both coupling directions and periodic closure. The fused Gaussian row uses the actual shallow tensor circuits; unfused O(Td) Gaussian evaluation does not satisfy this theorem. The record-product row uses global O(p)-bit words on r coefficients; switching to a fresh O(log(rp))-bit local machine would invalidate its tariff. Per-call gathers and restoration are charged in their calls, and extra group scans have their own row. No recurring pass is silently assigned a one-time cost. + +Every polylog(p) factor is absorbed by the fixed positive margins just proved. Native preparation is n^o(1), below the claimed work bound. The retained recovery theorem then gives exact packed integer multiplication. This completes the sufficient assembly argument. + +## Meaning of the 3/32 endpoint + +This theorem establishes the open range below min(q_C,3/32). It does not establish equality at either endpoint. The number 3/32 comes from this caller's cap inequality xi 3·10^−10 and log 2 > 2/3, + +(1−θ−q_C) log N − log A − (2/5) log(133 + log N) > 200 − 36 = 164. + +Therefore L(N) < N^(1−q_C), with a strict multiplicative margin. N is specified by its encoded exponent; neither this integer nor its enormous expanded word is materialized. This is a finite effectively specified construction. Its potentially astronomical initialization cost is a fixed constant, not input-dependent advice. + +## Native execution of the frozen finite word + +Enumerate the finite construction at N, assigning distinct storage to every concurrently live persistent/owned role. All its fixed literal coefficients, affine maps, quadratic phase descriptors, source/complement routes and chronological child calls are explicit records. Evaluate fixed rational scalar gates by bounded-word additions, products and divisions with a fixed number of limbs; COPY and CLEAR are charged array passes. Dirty borrowed storage is preserved. A child completes before its suspended caller resumes. + +An e-bit affine/quadratic monomial map can be implemented in O(2^e) word operations including setup. Prepare parity and least-set-bit tables on ⌊e/16⌋-bit chunks. For increasing addresses, the usual binary recurrence updates the affine image and the quadratic phase using O(1) chunk lookups, since a fixed number of chunks covers an e-bit index. The tables have O(e² + 2^(e/16)) preparation cost and use explicit bounded-word arithmetic, not PEXT, POPCOUNT or CTZ instructions. Selected-coordinate deposits and fiber gather/scatter admit the same chunk-table treatment. Every independent fiber is processed once; adapters, owned initialization and flattening are included. + +After N is fixed, all role counts and literal map sizes are fixed constants. Consequently nonchild work in a volume V batch is at most C·V for an explicit finite, albeit impractically large, constant C. One may enumerate the constant instruction inventory as charged uniform setup; it is not advice varying with n. + +## Complete batches and recurrence + +Let W be the actual productive batch width after integer denominator clearing and P_leaf its complete number of rank-one paid leaves. The critical majorant gives P_leaf/W = L(N) < N^(1−q_C). Retain all W independent source roles; never replace them by a reusable dirty field. + +For a call of rank e choose a = ⌈log₂ W⌉, λ_e = ⌈log₂(e+2)⌉ and D_e = 1 + ⌈log_N(e+1)⌉. Use a fixed direct base branch until e > aD_e + 2λ_e + 2N. Above it put + +f = ⌊(e − aD_e − 2λ_e − N)/N⌋, ℓ = e − Nf. + +Then f ≥ 1, f ≤ e/N and ℓ = O(log(e+2)). The ℓ high directions produce 2^ℓ distinct fibers. Group only whole W-fiber sets and execute the frozen word on each. Fewer than W leftover fibers occupy fraction W/2^ℓ ≤ (e+2)^−2; perform direct completed butterflies on those exact fields. Their normalized cost is O(1). The high directions cost O(ℓ), and the aD_e reserve pays actual stock at every nested level. Every reserve, leftover and source field retains its identity. + +For t(e) = T(e)/2^e this gives the direct native recurrence + +t(e) ≤ (P_leaf/W) t(f) + C(1 + log(e+2)). + +Set z = 1−q_C. Since (P_leaf/W)N^(−z) < 1 and log(e+2) = o((e+1)^z), a sufficiently large fixed base constant closes strong induction t(e) ≤ C'(e+1)^z. Recursion depth is O(log(e+2)). + +## Quantitative bounded precision + +For each exact scalar instruction take its explicit Euclidean operator-norm bound; multiply the finite bounds over one local template to obtain a computable fixed K ≥ 2. Monomial adapters have norm 1. Each completed recursive child is an exact unitary Gaussian map on its live fields; it is not charged again as a product of all its internal scalar norms. An expanded prefix or suffix has at most one unfinished child per depth. Hence its norm is bounded by K^(D+1), where D = O(log(e+2)). + +If at most C'2^e(e+1)^z scalar operations inject rounding error ≤ √2·2^−P each, the final error is at most + +√2 C'2^e(e+1)^z K^(D+1)2^−P. + +Thus P = B + e + (D+1)⌈log₂ K⌉ + O(log(e+2)) bits suffice for absolute error 2^−B. The prefix bound and input magnitude bound give integral width b + e/2 + (D+1)⌈log₂ K⌉ + O(log(e+2)). A conservative sequential stock layout has fixed-polynomial-in-e volume overhead; its logarithm is absorbed. All widths are O(log n) when e, b, B = O(log n). Enormous fixed coefficient heights remain fixed constants in these bounds; they are not silently omitted. + +This proves the stated direct native kernel theorem under the explicit retained algebraic premises. A complete multiplication exponent additionally uses the separately proved native outer assembly. It does not establish a new TM κ, a materialized implementation at the gigantic cutoff, or independent human/kernel acceptance of the inherited theory. + +Credit: Cao Yifan's PR #4610 joint helper/map profile; Cinna Davis and the PR #4470 native supplier lineage; Dugongue's transported frames; Jacob Alan Sussman's integer matching; zxv's direct flow, nested widths and majorants; Ryanson Jonathan's mirror-window analysis; Dillon's critical-root criterion; the retained Clifford, Gaussian and analytic contributors. Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/native-provider-lift/OPERATOR-INDEPENDENT-REVIEW.md b/research/native-provider-lift/OPERATOR-INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..30ff812878 --- /dev/null +++ b/research/native-provider-lift/OPERATOR-INDEPENDENT-REVIEW.md @@ -0,0 +1,63 @@ +# Independent native-provider and lift review + +Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0. + +## Result + +The exact round-three word at PR #4610 head `1eb8da6cfb35512c0cc2533413e5ca42f48e13c6` is suitable for the source-bound native lowering, conditional on the explicitly retained native-generator, all-fiber compiler, normalization and analytic contracts. Its decompressed payload SHA-256 is `cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd`. This review establishes the finite identities below and checks the informal lift algebra; it does not independently prove every retained contract or certify a full multiplication program. + +## Fresh finite checks + +A separately written checker read the actual compressed word and used the main-pinned PR #4470 constructor only as predecessor evidence. It checked: + +- The complete original frame-registry prefix and every main entrance and exit are preserved. +- Every scalar opcode, coefficient and chronological order is preserved in each orientation; every logical native operator label and its order is preserved. +- Every one of the 72 explicit binary native maps is a permutation of all 512 binary columns: 36,864 image columns were independently evaluated. +- All 180 actual signed warp classes send their declared input subspace onto their declared output subspace, with the direction reversed for an inverse warp. +- All 408 helpers are arbitrary independent inputs with strictly nested whole-job boundaries. Their exact census is `{4:28,7:7,8:47,9:326}`. +- Both retained literal interpreters check all 632 arbitrary-input columns in both orientations, with owned storage restored as required by their checks. +- The complete paid census, including eight rank-eight center jobs, is `{1:2201,2:412,3:510,4:127,5:40,8:8}` in both orientations. + +The receipt is `INDEPENDENT-RECEIPT.json`; the separate checker is `review_provider.py`. These local discovery/review files use workspace paths and are not themselves a portable release entry point. The publication package should retain the receipt and use its own source-authenticated dependency closure for replay. + +## Absolute phase source review + +The exact public round-three `phase_check.py` and its predecessor `research/warp-interface-20261022/verify_candidate.py` were retrieved from the pinned head and read in full. The round-three checker calls the predecessor's phase routine on the actual new word, then explicitly checks every changed helper boundary. The routine constructs the actual physical operator + + C_input.adjoint().then(K_G).then(C_output) + +for each actual warp class and requires its exact Fourier rank to be zero. It checks both orientations, absolute phases and reconstructed monomial recipes. Changed native maps are also compared on all 512 columns against two integer formulas. Each new paid frame edge is lowered and its required positive rank checked. Meaningful wrong-map and same-tableau/wrong-global-phase controls are present. The unmodified pinned public phase checker was then run in a separate 29-file, hash-authenticated tree. It passed in 30.09 seconds: 20 changed native maps on all 512 columns, 180 actual warp classes, 105 new paid pairs, 26 changed helpers, both orientations, and the meaningful wrong-map and wrong-global-phase controls. No authenticated input changed. The separate source manifest and run receipt are `PHASE-INPUT-MANIFEST.json` and `PHASE-RUN-RECEIPT.json`; the regenerated mathematical receipt is `PHASE-VALIDATION.json.gz`. + +Generator substitution remains a retained model premise: the new maps may replace the old maps consistently with the unchanged symbolic native identity. The verifier does not claim that a changed K_G is the identical physical matrix to its predecessor K_G. That equality is neither needed by the stated generalized contract nor established here. + +## Why the quotient headlines were not used + +PR #4596 (`477232ced13ec75fa40e0451ad1377db54c9d385`) and PR #4629 (`2cf7d081118f6f702aa317816d231b41ce073579`) supply much larger numerical invoice roots. PR #4604 (`6d4d72885351e01d0a2ce2b20419c0d84cb4949c`) and PR #4627 (`b5d71c724a30fde0e8d2538c09549ce6a4fca756`) correctly identify the endpoint question. Those constructions change main charts, while literal replay compares against the word's own final-frame record and represents native warps by free symbols. They therefore do not establish the unchanged canonical main operator required by the present lift. No numerical quotient root was used as a replacement for that missing identity. + +A bounded alternative tested intersection with each of 511 hyperplanes, followed by least anchored closure while preserving main endpoints and warp frames. It found no positive moment gain over the pinned PR #4470 invoice. This is a search report for that restricted family, not an impossibility theorem or the contribution's main result. + +## Native lift algebra + +The explicit generic lift was checked symbolically. Write c=3/32, Q=min(q_C,c), q=(κ+Q)/2 and choose + + δ=min(1/100,(q−κ)/(4(q+1)),(c−q)/16), + ε=1−δ, β=1−3δ, r=δ/10, layout=δ/100, + ξ=ε(1+q)−c+layout. + +For every 0<κ0. +- The cap margin is ε−ξ=c−εq−layout>0. +- The chirp margin is exactly `1−(β+2ξ−2+r)=2(c−q)+δ(122/25+2q)>0`. +- The transform saving is εq>κ, the fused Gaussian saving is q+δ(1−3q)>q, and the boundary saving is εq+layout. The remaining six paid rows also strictly exceed κ. + +The global-word FFT record setup does not introduce a per-record O(p) defect: in the actual caller log r is of order p/d, with d=p^ε and ε<1 fixed. Thus r grows faster than p, so O(p+r) reusable setup is absorbed by O(r log r). Individual coefficients and intermediates occupy a fixed number of global O(log n)-bit words, rather than a newly chosen local word model. + +This establishes the assembly algebra once an effective source-bound provider exponent q_C has been admitted. The independently checked finite profile above is a genuine changed paid profile, not an extra decimal of an unchanged raw root. Its finite compiler/critical-majorant arithmetic is a separate obligation checked by the lead's portable verifier. + +## Attribution and remaining review + +Credit Cao Yifan for PR #4610 and its round-three joint helper/native-map witness; Cinna Davis and the PR #4470 native/helper lineage; Dugongue for the transported warp-frame lemma and PR #4630 native caller; zxv for the native compiler/critical majorant; Jacob Alan Sussman for mixed-target matching; and Pierre-Loic Doulcet for the independently developed PR #4626 helper-621 route. All source-specific attribution and licenses remain applicable. + +The exact supplier all-fiber lift, analytic Gaussian decomposition, conditioning, finite matching, prime avoidance and integer recovery remain the pinned source proofs, not conclusions of the finite checker. No Lean kernel verification or independent human acceptance is claimed. diff --git a/research/native-provider-lift/OVERLAP.json b/research/native-provider-lift/OVERLAP.json new file mode 100644 index 0000000000..39b16b48ad --- /dev/null +++ b/research/native-provider-lift/OVERLAP.json @@ -0,0 +1,504 @@ +{ + "base": "fbc9ea0249746acca4f504d4fda2b84e0e36cf0d", + "recent": [ + { + "number": 4630, + "head": "f4b974db1f651250a252721cf127d0491a802699", + "title": "Conditional native Word RAM \u03ba = 0.0030201655: fused execution without TM simulation", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4629, + "head": "2cf7d081118f6f702aa317816d231b41ce073579", + "title": "No new kappa: complex supplier to 0.015637149 via the best ambient quotient (kernel 153 of 32 replay-valid directions)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4628, + "head": "ee4fd87f064017c23e5a86fc1dcfe0a5237caed3", + "title": "Research: lower bounds for small complex units: m = 2 never saves, m = 3 needs 14W/5 calls (Lean, engine game), m = 4 needs 41W/13, and the smallest open cases (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4604, + "head": "6d4d72885351e01d0a2ce2b20419c0d84cb4949c", + "title": "Endpoint-frame audit of #4596: every main output chart changes under the span{511} quotient; replay checks only the word's own finals (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4596, + "head": "477232ced13ec75fa40e0451ad1377db54c9d385", + "title": "Conditional \u03ba = 0.0034 (BIT-limited, +12.58%): complex supplier to 0.011417749 via the ambient quotient by span{511}", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4610, + "head": "1eb8da6cfb35512c0cc2533413e5ca42f48e13c6", + "title": "Conditional \u03ba = 0.00302176 (+0.00000024): joint helper interfaces and Lean certificates", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4626, + "head": "e4413c43eeaacdd20be123fdd7d7add53427f028", + "title": "Improve conditional kappa to 0.003021569 with helper621 and a funded compiler gap", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4627, + "head": "b5d71c724a30fde0e8d2538c09549ce6a4fca756", + "title": "Classify the admissible quotient kernels of the #4596 word: 32 of 511 pass, v = 153 beats 511 (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4625, + "head": "89db6060d0d5090e3feec98dfbaef4fb316621fe", + "title": "Independently check #4623's idle-mass bookkeeping (177,408 - 141,568 = 35,840 = M_p) and its C=.006/.007 tangent bounds (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4624, + "head": "7e1b48989382f91b55ab51c10756880e5c6e7801", + "title": "Three short rows realize every unit for every m>=6, nothing for m<=5 (#4600 OQ2 answered in the row model; no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4622, + "head": "47cc973ac1e0b4970c33b37d2b65afdc4f300a04", + "title": "Two short rows realize c iff gcd(c,m) >= 3 (#4600 OQ1): necessity proof and explicit construction for every m (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4623, + "head": "fd5d3be12b9d6ee92c8fa089d95bd529c3236563", + "title": "Construct border controllers without idles and bound recovery costs (no \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4621, + "head": "fe0419b0b2b24e996479625d45d0d22146071b25", + "title": "Partially check #4603's query-shear floor: exact Laurent identity, 15 disjoint ADD/IDLE windows in the pinned controller, merge saving 0.70 < 1 (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4620, + "head": "8744f324e1b0ed8e5a22166a21f011a9328c35ed", + "title": "Independently recompute #4602's lever table subset on both invoices with a 40-digit Decimal engine: all values match (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4619, + "head": "0f62abfdbb7e24659b218aa20cfbaefc7d771f4b", + "title": "Classify #4598's 24 five-request decompositions: 2 stars + 10 char-2 mixed + 12 Hamiltonian-cycle pentagons (#4598 OQ1; no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4618, + "head": "ed4686b91f6453720f151f2a6a88d7f7731ba7e8", + "title": "Small-prime check of #4612's outer-reserve threshold: displayed H fails at p=2 for moderate C; corrected H' = max(H, 4096 C log2(4096 C)) (no \u03ba change)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4617, + "head": "96c01a2124e234d798e9e97643c20fb5b430840d", + "title": "Binary commuting projectors attain the Schur-commutator bound 2d for every d at n=5d (follow-up to #4597 OQ2 and #4609; no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4616, + "head": "5c051ee2c79a399246af3ecff8f067ec51264a42", + "title": "Independently check #4610's warp substitution: 34 of 72 G maps changed, all invertible and frame-transporting; 17,453 scalar opcodes unchanged, 422 labels; 3,298 paid calls (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4615, + "head": "29e1120baeec37959095c08ccfbc64ab6193d440", + "title": "Independently recompute #4610's raw crossing in 50-digit Decimal from the pinned controller: 0.00302155511 inside its bracket, PR4535 root reproduced (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4614, + "head": "b14d286c6e0276db052249929e1cbd2427975cfe", + "title": "Scoped check of #4610: all 632 endpoint frames equal PR4470's, profile arithmetic exact, moment improvement proved on (0,1) (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4613, + "head": "a59c2bf803d05799cceb19e201b38f4e6b852fd5", + "title": "Literally check #4601's radical-invariance cost formula on a noncommutative local algebra (F4[e;Frob]/e^2) and three further local rings: holds on every target (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4612, + "head": "7e362114fa41570bffe74dbb32896f13354a54cd", + "title": "Audit #4359 BIT row stock and its #4470 atom change (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4609, + "head": "eb5ccf9288808d973551e6264300d30d2f6e48a0", + "title": "Refine #4597's Schur commutator bound for projectors: odd-codimension parity theorem and minimal binary/ternary sharpness witnesses (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4580, + "head": "08f93ced6f304e8804cf31cfd6db0d6869752fed", + "title": "Price the p3 H-branch boundary at kappa 0.00302015 (322/397 calls) and close four repair routes (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4608, + "head": "aae3cddad698f9c8fb293304eb7260a96ce6190a", + "title": "Exhaustively check #4597's block Schur commutator bound on all commuting pairs in M3(F2), M3(F3), M4(F2); binary/ternary idempotent pairs stay at rank <= 1 (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4607, + "head": "00f4eebeb11dec452082131fe102d077d786cdd9", + "title": "Prove the five-request binary full-guard product inequality for every m>=5 (k=5 of #4275 OQ2; no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4606, + "head": "3bd2fdd9632841bf8d25b0baa09b81a7b8d1e8f8", + "title": "Independently check #4599's four-event product inequality by direct header count for every 4<=m<=85; its spectrum table matches at all 82 dimensions (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4605, + "head": "fe99331d0735c7a3d61babedb003188a1bfaa815", + "title": "Independently recount #4598's binary threshold headers by exact pair convolution: 2/12/48/2,880 for k=2..5, brute-force-checked on GL_3/GL_4 (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4600, + "head": "44640c4a9538d5565d33e6dc218889f130143ce7", + "title": "Prove the two-short-row connector obstruction for every modulus", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4601, + "head": "4b2322fc5bd30a129507c2eee69aa275527b69ac", + "title": "Prove radical invariance of right-vector costs over local products", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4598, + "head": "c80f445e8c3c22d341d467254b89245fbddb9eb2", + "title": "Count 2,880 five-request binary threshold headers; refute 2 k! (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4599, + "head": "19ca650c67ad2722790dc60c0bfd12989479b06a", + "title": "Prove the four-request binary full-guard product inequality (no new kappa)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4597, + "head": "dfeb8ca729a04aea4aa290438f2ed50a37a9c7cb", + "title": "Prove the sharp 2d block Schur commutator bound (no new kappa)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4603, + "head": "caab2b42880ebd846e4a1b24ee795ac2139cfaa6", + "title": "The p16 query-only shears cannot be fused, re-framed (floor 15 = 15) or absorbed by a gather-type two-query word (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4602, + "head": "0dadb8773dc299ddaf1eaaa2e272b8491f728ac3", + "title": "Re-price the #1240 lever table on the #4470 and BIT invoices: one-sided levers stop at +12.6%, idle stages are 56-59% of the bill (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4567, + "head": "4437c89e577da1c4982510135b2b7be108e59538", + "title": "Close local improvements on #4470: shear rewrites (128 windows, 88 nonadjacent, len 6, |c|<=3) and 1- and 2-contact retiming - all 0 (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4594, + "head": "81b302ecda3e24893debf3cf8013867c3a0cbf30", + "title": "Soundness check of #4585's coarsened partitions against exact geometry: all 235 realisable profiles covered (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4595, + "head": "618096061351465f38ddbdf437cb35c898451298", + "title": "Independently recount #4545's PR4470 transport census: 3,302/2,856 per orientation, 406 new pairs vs PR4447 (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4591, + "head": "84c0fb3a39bcb1e4b8c48892bfdd8a6e7ae58a50", + "title": "Independently check #4483's identity (2) and Chernoff bounds (7)-(9) on actual flows (p7, p16): all hold with wide margins (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4593, + "head": "d6370b47b1217db2483b6d4fc0d45ecf690d8946", + "title": "Independently check #4521's expanded rank-mass identity with my own #4436 flow: 12/12 exact totals match (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4592, + "head": "8ef033ed69204b9d48a877e213c93f9147c063ec", + "title": "Navigation receipt for pinterbanget's 37 session PRs (#4513-#4591): subjects, types, merge-relevant edges (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4590, + "head": "e7538ae03738d903d1fb6bfde970573c31bda71b", + "title": "Independently check #4583's union header: separate codec, exact width chain, cutoff and \u03b2 binding (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4589, + "head": "fd9f28beff7d03464d5a07cbdb00c38f431a1613", + "title": "Independently check #4580's p3 H-branch budget (322/397) with own certified powers; note two rounded bracket endpoints (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4588, + "head": "2f6578907b7f8718a13921552cc3069d3908e936", + "title": "Independently check #4586's width-growth lemmas with separate flow/width code (raw p7 to rank 4000): all hold (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4586, + "head": "aadb7bc59390683450b1969e4632f546929dc569", + "title": "Prove quasipolynomial bound for chronological batch widths (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4587, + "head": "4f05085bfd3ef9f7ab54a4c30c0d6bd84bd4333c", + "title": "Independently cross-check all-length receiver floors and two pinned certificates", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4582, + "head": "23c515a3c071a6bfdd1fe80bc67cea55f6d43643", + "title": "Independently certify all-length receiver-window floors with two exact algorithms", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4585, + "head": "025f37fe346203cfe18d47367ce239e420961d36", + "title": "Prove receiver-window floors with mandatory contacts and bridges (no new kappa)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4584, + "head": "cc304c09c48103c20e7c0e2634b22d0aa19aa38a", + "title": "Audit R437 bad-class proof against literal pivot routines", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4583, + "head": "8d259a89fcff2a347de640a2f91cbe629c2e7a5c", + "title": "Bind PR4100 union headers to the actual core size (no new kappa)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4581, + "head": "b154350fbf1e7d49118851ab899a733727483289", + "title": "Independently certify all-length receiver-window floors by exact rank dominance", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4579, + "head": "20188e79a19f236eaea5bb67e5fe50411ea76727", + "title": "Make committed-export regression fixtures portable to Windows", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4569, + "head": "c4607e578e09a7cc7fe60ee0b7685b941822135d", + "title": "Independent proof check of #4532 \u00a71.1, \u00a72.2-2.3, \u00a73 (critical-root majorant under #4535's \u03ba): every step verified, no gap (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4570, + "head": "b5e119c1760203f10a2c2245bd8a50fa47b7013a", + "title": "Independently check #4568's arithmetic (\u03ba = 0.00302016597): outer ledger, gap, absorption; frozen rank 6.9x smaller with #4565 (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4568, + "head": "b269a729bc27ff3415e2b873ad00730ea6bc1a58", + "title": "Conditional \u03ba = 0.00302016597 (+9.7e-10 over #4535)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4566, + "head": "d1f2fa275dbd3388190e6ff30499b7ea90562575", + "title": "Independently check #4554's linear-program lowering (PHASE-TABLES \u00a72, \u00a74): exact induction, random programs, FFT instantiation (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4565, + "head": "d6a9a75bf48b047927bc4103def6f821909bb835", + "title": "Retuned p16 critical-root majorant (M=2^24, ell0=64, p=3/10): #4535's frozen rank 2^11,825,387,808, 85x below 2^10^12 (same \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4564, + "head": "fbcc9d63446cd4fc8eade8fc29b149fb60fa79ce", + "title": "Certify #4535 at outer slack d=1e-12: all 54 predicates pass, frozen rank N = 2^29,328,002,299 (34x below 2^10^12, same \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4563, + "head": "7db8ee8d97d456f120cb534d8cf356a1b8b02ca8", + "title": "Certify #4535 at a 13x smaller finite rank: N = 2^77,014,944,503 instead of 2^10^12 (same \u03ba = 0.003020165)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4562, + "head": "754e8c6849a152b4a7531ee7f2e8d8cee2d69b5a", + "title": "Independently check #4554's native stability lowering: exact gate norms, roundoff formulas, #956 moment and depth, shear bounds (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4561, + "head": "30ce22be2dd737791d40318bd90928042db40ee3", + "title": "Independently check #4554's native outer assembly and Gaussian recount: exact tolerance, perturbed assemblies, lattice tail, exponents (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4560, + "head": "4ee0d1ed4ffd202adb745c65835c89b5f6317bcf", + "title": "Independently check #4554's Gaussian chirp blocks: Hankel identity, conditioning, geometry, own fixed-point block at the (C) precision (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4559, + "head": "4ed34481357b2331be54da8b2661e38638658438", + "title": "Independently check #4554's paid phase and exp tables: own tables vs 16(E+d)/Q and 2^-p, worst-direction seeds (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4558, + "head": "870b86cbd3840dfd0fcd1c8bdab96b699be54159", + "title": "Independently check #4554's root seeds and recovery: own seed vs exact Taylor terms and algebraic values, CRT, carries (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4557, + "head": "ebc09ef98f107da49b78b450642fd00ca1a93a74", + "title": "Independently check #4554's native FFT multiplier: exact error-chain recurrences, parameters to ell=200, separate fixed-grid multiplier (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4556, + "head": "5193f368a77a1533abcf8e8bafc97486f85fcb02", + "title": "Independently check #4554's native banded inverse: exact elimination bounds, Gaussian tail, exact periodic Woodbury solves (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + }, + { + "number": 4555, + "head": "a73b063b6970ecb6730211508969b05b306f4f80", + "title": "Independently check #4538's native-layout cost theorems 1-4: own RAM program within 8NL+40N+8, phases, negation, metadata compiler (no new \u03ba)", + "scope": "body screened by team; relevant source code/proofs reviewed separately" + } + ], + "delta_pr4631": { + "head": "48aef2349dc761f6b3b6bf3e59c3ee8080dbbe7a", + "scope": "full sparse baseline patch read; no mathematical change" + }, + "limits": "No exhaustive historical survey or complete discussion/comment pagination; public API rate limited after initial snapshot.", + "delta_pr4633": { + "head": "b2998bacd50d57c301fe67c5392054440c42398c", + "scope": "latest source documents and four-commit patch reviewed; no finite replay", + "files": [ + { + "file": "bit-ambient-quotient-PROOF.md", + "sha256": "09ffd242aa039c9ea1c46d88816a4738af1ce8f878107c0547937b27c2823df4", + "hits": [ + { + "line": 107, + "text": "0.015637149091 (`research/complex-ambient-quotient`) and the BIT supplier here at" + }, + { + "line": 112, + "text": "`admitted 0.0034` are declared literals in" + }, + { + "line": 131, + "text": "- **The outer value needs the admission literals raised.** The composition to" + }, + { + "line": 132, + "text": " 0.012401 requires `atom`, `ordinary` and `admitted` in" + }, + { + "line": 135, + "text": "- **The frame charts are not preserved**: 636 frames become 117. The interpreter" + }, + { + "line": 139, + "text": " for the complex quotient in #4604, and it is not settled here." + }, + { + "line": 145, + "text": " supplier and are not raised here." + } + ] + }, + { + "file": "bit-ambient-quotient-README.md", + "sha256": "b35d299ada28f029ae7eab65535f3873d3ff6c103ce052d0c127f0ea61756418", + "hits": [ + { + "line": 5, + "text": "With the complex supplier at 0.015637149091, the outer value is" + }, + { + "line": 35, + "text": "| main widths | `{7: 222}` | `{6: 107, 7: 105, 8: 10}` |" + }, + { + "line": 94, + "text": " supplier word and are not raised here. The 0.012401 outer value requires them" + }, + { + "line": 96, + "text": " `controller.py:152` for the mixed main widths." + }, + { + "line": 97, + "text": "- **The frame charts collapse**: 636 distinct frames become 117. The local record" + }, + { + "line": 99, + "text": " the BIT's frame charts (`inventories` reads the paid and helper profiles only)," + }, + { + "line": 100, + "text": " but a contract that requires particular frame charts would reject the word \u2014" + }, + { + "line": 110, + "text": "2. **Which consumer, if any, requires the frame charts?** The same question as" + } + ] + }, + { + "file": "complex-ambient-quotient-PROOF.md", + "sha256": "add509beee194aea7e1168eda1120f03cef742d5f7b1efb0c02f8a71cf40e311", + "hits": [ + { + "line": 124, + "text": "quotient complex kappa = 0.015637149091 (+417.8%)" + }, + { + "line": 152, + "text": "- **The main output charts are not preserved, and no consumer reads them.**" + } + ] + } + ] + } +} diff --git a/research/native-provider-lift/PARAMETERS.json b/research/native-provider-lift/PARAMETERS.json new file mode 100644 index 0000000000..0ec8027ed7 --- /dev/null +++ b/research/native-provider-lift/PARAMETERS.json @@ -0,0 +1,49 @@ +{ + "provider": "6043551/2000000000", + "target": "15108877/5000000000", + "q": "60435509/20000000000", + "stop": "1/120871020", + "delta": "1/80241742036", + "epsilon": "80241742035/80241742036", + "beta": "80241742033/80241742036", + "spare": "1/802417420360", + "layout": "1/8024174203600", + "xi": "291846204981126384163/320966968144000000000", + "savings": { + "main": "969890104586384163/320966968144000000000", + "standalone_routing": "1", + "fused_gaussian": "4849450542811049797/1604834840720000000000", + "standalone_addressing": "1", + "group_scans": "40120871017/40120871018", + "boundary": "969890104626384163/320966968144000000000", + "sparse_visits": "131362720913126384163/320966968144000000000", + "record_products": "80241742035/80241742036", + "core_face_recovery": "1544653534194/20060435509" + }, + "guards": { + "stopped_provider": "1/40000000000", + "stop_positive": "1/120871020", + "stop_below_one": "120871019/120871020", + "epsilon_below_one": "1/80241742036", + "beta_positive": "80241742033/80241742036", + "beta_below_epsilon": "1/40120871018", + "cap_above_band": "131362720909126384163/320966968144000000000", + "cap_below_dimension": "29120763158873615837/320966968144000000000", + "global_gamma": "9/802417420360", + "group_chirp": "29120763168673615837/160483484072000000000", + "group_key": "1/40120871018", + "membership": "1/80241742036", + "spare_positive": "1/802417420360", + "strassen_integer_certificate": "1951441519231", + "main_excess": "80181306527/1604834840720000000000", + "standalone_routing_excess": "4984891123/5000000000", + "fused_gaussian_excess": "100060435509/1604834840720000000000", + "standalone_addressing_excess": "4984891123/5000000000", + "group_scans_excess": "99999086889828086607/100302177545000000000", + "boundary_excess": "80381306527/1604834840720000000000", + "sparse_visits_excess": "651964154122881306527/1604834840720000000000", + "record_products_excess": "99999086891078086607/100302177545000000000", + "core_face_recovery_excess": "7722964580317328086607/100302177545000000000" + }, + "minimum_excess": "80181306527/1604834840720000000000" +} diff --git a/research/native-provider-lift/PHASE-SOURCE-PINS.json b/research/native-provider-lift/PHASE-SOURCE-PINS.json new file mode 100644 index 0000000000..56a00d8673 --- /dev/null +++ b/research/native-provider-lift/PHASE-SOURCE-PINS.json @@ -0,0 +1,179 @@ +{ + "head": "1eb8da6cfb35512c0cc2533413e5ca42f48e13c6", + "files": [ + { + "path": "research/fresh-helper-boundary/CHANGES.json", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "bytes": 13176, + "origin": "hash-equal existing source" + }, + { + "path": "research/fresh-helper-boundary/native.py", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "bytes": 8228, + "origin": "hash-equal existing source" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "bytes": 17152, + "origin": "hash-equal existing source" + }, + { + "path": "research/joint-helper-lattice/NATIVE.json.gz", + "sha256": "74582cce642c80f0235be7fcbce3716174666326ac6a1d46d02a62a75d7be4c6", + "bytes": 35042, + "origin": "hash-equal existing source" + }, + { + "path": "research/joint-helper-lattice/PATCH.json", + "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727", + "bytes": 112792, + "origin": "hash-equal existing source" + }, + { + "path": "research/joint-helper-lattice/native_joint.py", + "sha256": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46", + "bytes": 6886, + "origin": "hash-equal existing source" + }, + { + "path": "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7", + "bytes": 17028, + "origin": "hash-equal existing source" + }, + { + "path": "research/kappa-function-composition/complex/prune_native.py", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257", + "bytes": 13794, + "origin": "hash-equal existing source" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "bytes": 82793, + "origin": "hash-equal existing source" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "bytes": 198063, + "origin": "hash-equal existing source" + }, + { + "path": "research/kappa-rebuild/complex/native_extensions.py", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3", + "bytes": 12470, + "origin": "hash-equal existing source" + }, + { + "path": "research/kappa-rebuild/complex/power_two_balance.py", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424", + "bytes": 7152, + "origin": "hash-equal existing source" + }, + { + "path": "research/kappa-rebuild/complex/rebuild_native.py", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5", + "bytes": 25306, + "origin": "hash-equal existing source" + }, + { + "path": "research/missing-join-frame/PATCH.json", + "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e", + "bytes": 249, + "origin": "hash-equal existing source" + }, + { + "path": "research/native-warp-extraction-boundary/algebra.py", + "sha256": "52b73c482f9aa171ac266bf0f5752bb520b100d79949f615d0aa26cb926452ba", + "bytes": 7509, + "origin": "pinned raw source" + }, + { + "path": "research/native-warp-extraction-boundary/operators.py", + "sha256": "4427aa6bb35b095868381de947d177bdbfc2c92e8e0ef9c5a75731ac4d0ca5bd", + "bytes": 4244, + "origin": "pinned raw source" + }, + { + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "bytes": 6824, + "origin": "hash-equal existing source" + }, + { + "path": "research/transported-warp-frames/PROOF.md", + "sha256": "cd227d0cc0e34c7b4b6a850a042f0f99099f1fe9b25e0519982e8f5973603f2d", + "bytes": 6441, + "origin": "pinned raw source" + }, + { + "path": "research/warp-interface-20261022/ACTUAL-WORD-FREEZE.json", + "sha256": "474c3fdd8194639bcfcf7b46259198c8a189bab0be9e059438d74d27a08ec8ca", + "bytes": 752, + "origin": "pinned raw source" + }, + { + "path": "research/warp-interface-20261022/ACTUAL-WORD.json.gz", + "sha256": "d578875344095047c383ef513e69b9deb9d99d2b75abe14f7359d06365a924ac", + "bytes": 207650, + "origin": "pinned raw source" + }, + { + "path": "research/warp-interface-20261022/PATCH.json", + "sha256": "9da8af096dfc08d9a2e953bf8b78e81195fe74e8da2583d5d7fd0eed97f7a748", + "bytes": 224838, + "origin": "pinned raw source" + }, + { + "path": "research/warp-interface-20261022/PHASE-VALIDATION.json.gz", + "sha256": "352572dd77a20dd4569b0172aed5971f5bdb324efa75798ce6d84089812a1d38", + "bytes": 24650, + "origin": "pinned raw source" + }, + { + "path": "research/warp-interface-20261022/SOURCES.json", + "sha256": "7d40ebea3255181e900a15557825ba92cc7dd25c7963285b82736b2c2fb2bb0c", + "bytes": 4836, + "origin": "pinned raw source" + }, + { + "path": "research/warp-interface-20261022/verify_candidate.py", + "sha256": "7aae8922f456673f3be7045c064e4700cf929c51da1316368758fb5cdd3a3e50", + "bytes": 11365, + "origin": "pinned raw source" + }, + { + "path": "research/warp-interface-20261022/warp_merge.py", + "sha256": "661fe7dc9d079da2753ba8af9b512d24e8c16b39caf709b459709a495d7d17f6", + "bytes": 5320, + "origin": "pinned raw source" + }, + { + "path": "research/kappa-round3-warp-20261022/phase_check.py", + "sha256": "0aec13f218fd131b63430064c7cd212b4320a87564e75c34a359e08f1e249009", + "bytes": 2655, + "origin": "pinned raw source" + }, + { + "path": "research/kappa-round3-warp-20261022/SOURCES.json", + "sha256": "533d6a3a8c8335826090b00cdc4928a996aec9dad58c81a27a77e4332c6ac06e", + "bytes": 4659, + "origin": "pinned raw source" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "bytes": 207673, + "origin": "pinned raw source" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD-FREEZE.json", + "sha256": "b464b18dde15a4f3f0f71252f4eacf5a1883115fdff87734819e0b8e59b26285", + "bytes": 330, + "origin": "pinned raw source" + } + ] +} diff --git a/research/native-provider-lift/PR4633-OVERLAP.json b/research/native-provider-lift/PR4633-OVERLAP.json new file mode 100644 index 0000000000..3e4e1dec2f --- /dev/null +++ b/research/native-provider-lift/PR4633-OVERLAP.json @@ -0,0 +1,92 @@ +{ + "head": "b2998bacd50d57c301fe67c5392054440c42398c", + "scope": "latest source documents and four-commit patch reviewed; no finite replay", + "files": [ + { + "file": "bit-ambient-quotient-PROOF.md", + "sha256": "09ffd242aa039c9ea1c46d88816a4738af1ce8f878107c0547937b27c2823df4", + "hits": [ + { + "line": 107, + "text": "0.015637149091 (`research/complex-ambient-quotient`) and the BIT supplier here at" + }, + { + "line": 112, + "text": "`admitted 0.0034` are declared literals in" + }, + { + "line": 131, + "text": "- **The outer value needs the admission literals raised.** The composition to" + }, + { + "line": 132, + "text": " 0.012401 requires `atom`, `ordinary` and `admitted` in" + }, + { + "line": 135, + "text": "- **The frame charts are not preserved**: 636 frames become 117. The interpreter" + }, + { + "line": 139, + "text": " for the complex quotient in #4604, and it is not settled here." + }, + { + "line": 145, + "text": " supplier and are not raised here." + } + ] + }, + { + "file": "bit-ambient-quotient-README.md", + "sha256": "b35d299ada28f029ae7eab65535f3873d3ff6c103ce052d0c127f0ea61756418", + "hits": [ + { + "line": 5, + "text": "With the complex supplier at 0.015637149091, the outer value is" + }, + { + "line": 35, + "text": "| main widths | `{7: 222}` | `{6: 107, 7: 105, 8: 10}` |" + }, + { + "line": 94, + "text": " supplier word and are not raised here. The 0.012401 outer value requires them" + }, + { + "line": 96, + "text": " `controller.py:152` for the mixed main widths." + }, + { + "line": 97, + "text": "- **The frame charts collapse**: 636 distinct frames become 117. The local record" + }, + { + "line": 99, + "text": " the BIT's frame charts (`inventories` reads the paid and helper profiles only)," + }, + { + "line": 100, + "text": " but a contract that requires particular frame charts would reject the word \u2014" + }, + { + "line": 110, + "text": "2. **Which consumer, if any, requires the frame charts?** The same question as" + } + ] + }, + { + "file": "complex-ambient-quotient-PROOF.md", + "sha256": "add509beee194aea7e1168eda1120f03cef742d5f7b1efb0c02f8a71cf40e311", + "hits": [ + { + "line": 124, + "text": "quotient complex kappa = 0.015637149091 (+417.8%)" + }, + { + "line": 152, + "text": "- **The main output charts are not preserved, and no consumer reads them.**" + } + ] + } + ] +} diff --git a/research/native-provider-lift/README.md b/research/native-provider-lift/README.md new file mode 100644 index 0000000000..8fba53ff3c --- /dev/null +++ b/research/native-provider-lift/README.md @@ -0,0 +1,35 @@ +# Conditional native κ = 0.0030217754 + +Subject to the explicitly retained all-fiber algebraic and analytic predecessor proofs, this package gives packed n-bit integer multiplication in O(n / (log n)^κ) on a standard Word RAM with w = Θ(log n), bounded-word MUL/DIV and κ = 0.0030217754. It uses no TM simulator, tape-cost theorem or TM multiplication subroutine. The fixed word-width constant and eventual cutoff may be astronomical. + +The increase over our prior native result #4630 (κ = 0.0030201655) is exactly 0.0000016099. Cao Yifan's current #4610 head supplies the stronger complete paid profile; this package does not rediscover it or claim a new raw critical root. Its native consequence is distinct from a further digit refinement of a TM ledger. The selected upstream frontier remains unchanged. Larger open complex-supplier headlines are not used: their canonical endpoint and actual warp contracts remain disputed. + +## Sufficient assembly + +[NATIVE-LIFT.md](NATIVE-LIFT.md) proves an explicit native transfer theorem: every κ < min(q_C, 3/32) follows from an actual canonical native provider of saving q_C with the stated exact endpoint, phase, restoration, compiler and precision contracts. It supplies rational choices for every dimension, group, cap and precision parameter and proves every interface guard and all nine paid cost inequalities. The cofinal ε and β idea already appears in the fine-padding predecessors; the contribution here is the explicit source-bound native interface and its full paid parameter range. + +[NATIVE-PROVIDER-4610.md](NATIVE-PROVIDER-4610.md) connects the actual changed #4610 word and retained chronological compiler to q_C = 0.0030217755. The exact critical root lies in (0.0030217758, 0.0030217759). A fixed supplier at N = 2^(10^12) has logarithmic absorption margin greater than 164. Neither that integer nor the expanded supplier is materialized. PARAMETERS.json gives the strict native assembly at κ = 0.0030217754. + +The mechanisms enabling the native consequence are direct bounded-word execution of the actual finite provider; fused gauge-free Gaussian circuits with paid full-coordinate lookup tables and local microbox routing; and global-word-precision native record products plus batched boundary arithmetic. These inherit #4630's explicit algorithms. A BIT provider is absent from the sufficient premises. [JOINT-TRANSPORT.md](JOINT-TRANSPORT.md) separately proves a constructive simultaneous partial-map transport theorem for future compatible native-map searches; it supplies no extra numerical saving in this package. + +## Reproduce and evidence + +Run `python3 -I -O -B verify.py` in this folder, or `python3 -B scripts/research_package.py --package research/native-provider-lift` from the repository root. Python 3.12 and standard library suffice. No SciPy, GPU, network, Git or Lean is needed by the standalone replay. Original mathematical source files under v/ are byte-preserved and run only in a temporary copy; the replay leaves this package unchanged. Isolated child interpreters explicitly retain assertions even when the parent is optimized. + +The replay authenticates all package bytes, reconstructs both local invoices from the emitted word and the complete 18-local/15-query/15-idle controller invoice, then checks the funded critical majorant and finite absorption. It replays both orientations on all 632 formal columns with two retained interpreters, all native map/frame incidences, exact absolute phases and controls, every native arithmetic margin and native FFT record products. Finite replays establish those finite identities and arithmetic checks, not the all-fiber asymptotic theorem or scientific acceptance of its inherited premises. + +## Retained proof boundary + +The exact all-column/fiber identity for arbitrary lift width, owned restoration, explicit whole-job monomial normalizers, chronological source matching and recursive stock construction are retained source proofs. The Gaussian/Poisson, fine prime padding, accretive Toeplitz circuits and exact recovery proofs are likewise inherited, as specified in sources/PR4630-NATIVE-ASSEMBLY.md and its pinned source map. These are identified mathematical dependencies, not an unspecified fast algorithm oracle. The new native assembly and provider closure remain informal; no fresh Lean kernel audit is claimed. A growing-input complete multiplier has not been emitted or practically benchmarked. + +## Frontier checkpoint, overlap and credit + +Canonical main was fetched at fbc9ea0249746acca4f504d4fda2b84e0e36cf0d. Its selected maintainer-reviewed conditional κ is 0.00302015 (#4470). The team read recent PR bodies across #4555–#4630, and reviewed the newly appearing #4631 sparse-checkout fix and #4633 quotient extension; this is bounded recent coverage, not an exhaustive audit of all historical submissions or comments. API rate limiting prevented further API pagination; public exact-ref/raw source reads were used afterward. Relevant changed source proofs and code were inspected and replayed independently. #4615's older root check concerns an earlier #4610 revision; this package pins the newer round-three head 1eb8da6cfb35512c0cc2533413e5ca42f48e13c6. #4626 is a distinct helper621 construction. #4596/#4604/#4627/#4629 quotient charts and #4623's border controller are not admitted inputs. The later #4633 head b2998bacd50d57c301fe67c5392054440c42398c adds a BIT quotient but explicitly retains unresolved changed main charts and unraised outer admission; it supplies no verified canonical provider for this native lift. PR4633-OVERLAP.json pins the exact source review. OVERLAP.json records the exact screened heads and scope. + +Credit Cao Yifan (#4610) for joint helper/native map changes; Cinna Davis and the #4470 joint-helper/controller lineage; Dugongue's #4630/#4554 native arithmetic and assembly; Jacob Alan Sussman; zxv; Ryanson Jonathan; Dillon (#4532/#4535); Vlado Vojdanovski (#1673); the gauge-free #1758 authors; Chafik Boukhalfa (#1786) and Tim Trudgian; Jeremy Kothe; eumemic and icekylinx; Harvey and van der Hoeven; and all retained source owners/notices. The independent structural, root and frame audits #4614–#4616 are useful precedents, not substitutes for this exact-head replay. Prepared for Dugongue with substantial OpenAI Codex assistance from a lead and three research/review agents. New code is Apache-2.0; inherited notices remain intact. + +The shared DAG was searched for Word RAM, limbs and symplectic interfaces; canonical MpLimbs20261007 and MpSparse20261007 were read as representation precedents. Their source headers do not establish a fresh kernel audit, and source-only catalog hits were not promoted to proof evidence. The live DAG and Lean source tree are unchanged. + +## Open next questions + +Independently review the retained all-fiber compiler and analytic proofs at the actual native caller. Implement a practical complete native caller with tractable constants. The simultaneous transporter lemma permits joint prelude-map searches. ARBITRARY-FRAME-BRIDGES.md proves an exact sufficient implementation for any two canonical frames, with recursive rank dim U + dim V − 2 dim(U ∩ V), both monomial adapters and absolute phase. The independent checker covers all 23 subspaces and 285 ordered pairs in dimensions 1–3. These positive primitive theorems enlarge the valid native search grammar; they supply no extra numerical gain in this bound. See TASK.json for concrete next steps and review obligations. diff --git a/research/native-provider-lift/SOURCES.json b/research/native-provider-lift/SOURCES.json new file mode 100644 index 0000000000..9b3d9dc421 --- /dev/null +++ b/research/native-provider-lift/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "fbc9ea0249746acca4f504d4fda2b84e0e36cf0d", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + } + ] +} diff --git a/research/native-provider-lift/TASK.json b/research/native-provider-lift/TASK.json new file mode 100644 index 0000000000..f0777b3286 --- /dev/null +++ b/research/native-provider-lift/TASK.json @@ -0,0 +1,80 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 7, + "base_commit": "fbc9ea0249746acca4f504d4fda2b84e0e36cf0d", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Does one quantified step of the proposed #4100 all-size construction hold at its actual caller?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Prove one missing implication with explicit quantified hypotheses.", + "Find an exact counterexample at the claimed interface boundary." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read PROOF.md and AUDIT.md in #4100. Select one distinct obligation: CRT total repair, native/free-algebra lifting, precision/conditioning, or complete fixed-tape cost. This is an author-submitted proof, not an accepted unconditional theorem.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Check live handoffs; name one proposition, its caller, quantified domain and dependency closure. Independently prove the implication or exhibit a precise gap/counterexample. Prioritize CRT.md total repair or COMPLEX.md free-algebra lift only if unclaimed. Stop at the chosen obligation; do not substitute finite samples or root arithmetic for an all-size proof, or launch the complete package by default.", + "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.", + "allowed_variations": [ + "One CRT repair, native lift, precision/conditioning or tape-cost proposition, with its exact caller." + ], + "scope_change_triggers": [ + "Replacing a quantified obligation with another finite smoke test.", + "Treating archive intake, an author PASS receipt or a finite composed fixture as discharge of the universal hypotheses." + ], + "overlap_terms": [ + "uniform transfer", + "all-size", + "precision", + "4100", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Native Word RAM lift of the exact-head stronger profile, proving every kappa below min(q_C,3/32) and instantiating kappa 0.0030217754.", + "scope_change_reason": "User explicitly assigned a stronger native kappa using recent PRs; this overrides the default catalogue audit.", + "bottleneck_link": "Removes the BIT/TM transfer premise while retaining all actual source identity, whole-job and analytic obligations.", + "budget_minutes": 60, + "stop_rule": "Bound speculative changed-grammar search; retain exact-head positive native lift, independently check source identities/margins and finish a portable handoff.", + "outcome": "completed", + "evidence": "NATIVE-LIFT.md; NATIVE-PROVIDER-4610.md; critical majorant and actual invoice replay; independent exact phase and native assembly reviews.", + "author": "Dugongue", + "ai_assistance": "Substantial OpenAI Codex assistance: lead plus three research/review agents; no new Lean formalization.", + "open_questions": [ + { + "question": "Can independent reviewers accept the retained all-fiber compiler and analytic proofs at this native caller?", + "why_it_matters": "Finite arithmetic and column checks cannot establish those universal premises.", + "first_step": "Review exact source contracts in the provider theorem and PR4630 native assembly against their pinned originals.", + "blocked_by": "Independent mathematical review." + }, + { + "question": "Can coupled prelude maps or arbitrary paid frame bridges improve the complete invoice?", + "why_it_matters": "The current contribution transfers an existing stronger profile rather than discovering a new one.", + "first_step": "Use JOINT-TRANSPORT and exact Clifford lowering, charge every bridge and replay absolute phases before repricing.", + "blocked_by": "A favorable fully checked witness." + } + ] +} diff --git a/research/native-provider-lift/VERIFY.json b/research/native-provider-lift/VERIFY.json new file mode 100644 index 0000000000..96980a459d --- /dev/null +++ b/research/native-provider-lift/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Authenticate source closure; actual-word/controller invoice; exact critical/provider and all native margins; both literal orientations; all changed absolute phases and rejecting controls; native record products." + } + ] +} diff --git a/research/native-provider-lift/critical_engine.py b/research/native-provider-lift/critical_engine.py new file mode 100644 index 0000000000..89d6139b63 --- /dev/null +++ b/research/native-provider-lift/critical_engine.py @@ -0,0 +1,365 @@ +#!/usr/bin/env python3 +"""Critical-root hypotheses for the retained p7 and p16 rank inventories. + +Separate exact arithmetic and mirror enumeration; no predecessor evaluator is +imported. The inventories and native contracts remain credited source inputs. +Dillon with substantial OpenAI Codex assistance; Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as F +from functools import lru_cache +from hashlib import sha256 +import json +from pathlib import Path + + +GRID = 1 << 128 +PINS = { + 'research/higher-moment-strictification/RESULT.json': + 'ad79e3c0459e7b495a0ca34010553b12147779a007389e1695cc1336f123c156', + 'research/compact-joint-compiler/arithmetic/RESULT.json': + 'a6caaa2a6d6460a8c1ef7e48c4853bb27976be33a52b96a4216dfa90d96c9091', + 'research/joint-helper-lattice/RESULT.json': + 'c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21', + 'research/rank-convergence/BENCHMARKS.json': + '513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850', +} + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def floorq(x): + return x.numerator // x.denominator + + +def ceilq(x): + return -((-x.numerator) // x.denominator) + + +def outward(lo, hi): + return floorq(lo * GRID), ceilq(hi * GRID) + + +@lru_cache(None) +def logarithm(n): + """Integer endpoints in units 2^-128, using an exact atanh tail.""" + require(type(n) is int and n >= 1, 'positive integer logarithm') + + def series(y): + z = (y - 1) / (y + 1) + require(0 <= z <= F(1, 3), 'logarithm range reduction') + # log(y)=2 sum z^(2j+1)/(2j+1). Every omitted denominator + # is at least 121, so the geometric tail bounds all omitted terms. + term, total = z, F(0) + for j in range(60): + total += 2 * term / (2*j + 1) + term *= z*z + return total, total + 2*term / (121*(1-z*z)) + + exponent = n.bit_length() - 1 + a, b = series(F(n, 1 << exponent)) + c, d = series(F(2)) + return outward(a + exponent*c, b + exponent*d) + + +def exponential(x): + """Outward integer endpoints for exp(exact rational x).""" + x = F(x) + if x == 0: + return GRID, GRID + if x < 0: + lo, hi = exponential(-x) + return GRID*GRID // hi, -((-GRID*GRID) // lo) + squarings = 0 + while x > F(1, 2): + x /= 2 + squarings += 1 + term_lo = term_hi = total_lo = total_hi = GRID + for j in range(1, 65): + term_lo = floorq(term_lo*x/j) + term_hi = ceilq(term_hi*x/j) + total_lo += term_lo + total_hi += term_hi + # The next term is x^65/65!. Subsequent ratios are <=1/132; + # twice an upper enclosure of that term bounds the entire tail. + total_hi += 2*ceilq(term_hi*x/65) + for _ in range(squarings): + total_lo = total_lo*total_lo // GRID + total_hi = -((-total_hi*total_hi) // GRID) + return total_lo, total_hi + + +@lru_cache(None) +def power(n, t): + t = F(t) + lo, hi = logarithm(n) + endpoints = [F(lo, GRID)*t, F(hi, GRID)*t] + lower = exponential(min(endpoints))[0] + upper = exponential(max(endpoints))[1] + return F(lower, GRID), F(upper, GRID) + + +def moment(histogram, t): + lo = hi = F(0) + for rank, count in histogram.items(): + a, b = power(rank, t) + lo += count*a + hi += count*b + return lo, hi + + +def mean(histogram, t): + lo = hi = F(0) + for rank, count in histogram.items(): + a, b = power(rank, t) + c, d = logarithm(rank) + lo += count*a*F(c, GRID) + hi += count*b*F(d, GRID) + total_lo, total_hi = moment(histogram, t) + require(total_lo > 0, 'positive tilted total') + return lo/total_hi, hi/total_lo + + +def display(interval): + # These short rational bounds are rounded outward, never floating point. + unit = 10**6 + return [str(F(floorq(interval[0]*unit), unit)), + str(F(ceilq(interval[1]*unit), unit))] + + +def histogram(raw): + require(isinstance(raw, dict) and raw, 'nonempty histogram') + result = {} + for key, count in raw.items(): + rank = int(key) + require(str(rank) == str(key) and rank >= 1, + 'canonical positive integer rank') + require(type(count) is int and count > 0, 'positive multiplicity') + result[rank] = count + return result + + +def mirror_sides(targets, paid, x): + sources, exits = Counter(), Counter() + for k, w in targets.items(): + for r, count in paid.items(): + if k > r and F(1, k) < x <= F(1, r): + sources[k*r] += w*count + if r > k and F(1, r) < x <= F(1, k): + exits[k*r] += w*count + return sources, exits + + +def certify(profile, lo, hi, beta, derivative_floor): + targets, paid = (histogram(profile[key]) for key in ('targets', 'paid')) + m = max(targets) + require(min(targets) >= 2 and max(paid) < m and paid.get(1, 0) > 0, + 'native rank interface and nonempty forests') + require(0 < lo < hi < 1, 'critical exponent interval') + require(sum(k*q for k, q in targets.items()) > + sum(k*q for k, q in paid.items()), 'positive rank-one surplus') + first_t, first_p = moment(targets, lo), moment(paid, lo) + last_t, last_p = moment(targets, hi), moment(paid, hi) + first = first_t[0]-first_p[1], first_t[1]-first_p[0] + last = last_t[0]-last_p[1], last_t[1]-last_p[0] + require(first[1] < 0 < last[0], 'root sign crossing') + # Each tilted mean is nondecreasing: its derivative is the variance + # of log(rank). Thus this bounds their difference on the whole interval. + gap = mean(targets, lo)[0] - mean(paid, hi)[1] + require(gap > derivative_floor > 0, 'positive crossing derivative') + # t*m^(t-1) increases for t>0, since its derivative has the sign + # of 1+t*log(m). This lower bound therefore applies at the unknown root. + eta = lo*power(m, lo-1)[0] + require(0 <= beta < eta, 'strict mirror capacity') + points = sorted({F(0), *(F(1, k) for k in targets), + *(F(1, r) for r in paid)}) + cells, worst, worst_cell = [], F(0), None + for left, right in zip(points, points[1:]): + source, exit_ = mirror_sides(targets, paid, (left+right)/2) + require((source, exit_) == mirror_sides(targets, paid, right), + 'right-closed mirror endpoint') + ehi = moment(exit_, hi)[1] + slo = moment(source, lo)[0] + require(ehi <= beta*slo, 'uniform mirror inequality') + if exit_: + ratio = ehi/slo + cells.append({'left': str(left), 'right': str(right), + 'upper_ratio': display((ratio, ratio))[1]}) + if ratio > worst: + worst, worst_cell = ratio, [str(left), str(right)] + require(mirror_sides(targets, paid, F(0)) == (Counter(), Counter()), + 'zero mirror endpoint') + require(mirror_sides(targets, paid, 2*points[-1]) == (Counter(), Counter()), + 'empty mirror tail') + return {'critical_root_interval': [str(lo), str(hi)], + 'endpoint_target_minus_paid': [display(first), display(last)], + 'uniform_mean_gap_lower': display((gap, gap))[0], + 'derivative_floor': str(derivative_floor), + 'beta': str(beta), 'source_capacity_lower': display((eta, eta))[0], + 'mirror_upper': display((worst, worst))[1], + 'maximizing_cell': worst_cell, 'funded_mirror_cells': cells, + 'conclusion': 'Unique crossing on this bracket; critical-root hypotheses hold.', + 'scope': 'Rank-inventory admission criterion; native and outer obligations inherited.'} + + +def arithmetic_controls(): + count = 0 + for base in (1, 2, 3, 5, 16, 121, 145, 10440): + for exponent in (F(-1, 2), F(0), F(1, 4), F(1, 2), F(1), F(2)): + lo, hi = power(base, exponent) + require(lo > 0 and lo**exponent.denominator <= F(base)**exponent.numerator + <= hi**exponent.denominator, 'exact power enclosure control') + count += 1 + return count + + +def critical_guards(profile, root_lo, root_hi, witness): + """Fund a shifted-logarithmic majorant at the isolated critical root. + + Uniform inequalities cover [root_lo, upper_exponent], a superset of + every unknown-root interval needed in the written endpoint theorem. + Parameters are inherited from #4483 except the explicit cover and beta. + """ + targets, paid = (histogram(profile[key]) for key in ('targets', 'paid')) + m = max(targets) + top = F(witness['upper_exponent']) + a, b, M, ell = (witness[key] for key in ('a', 'b', 'height_base', 'ell0')) + require(all(type(v) is int and v >= 1 for v in (a, b, ell)) and + type(M) is int and M >= 2, 'critical integer geometry') + s, lam, p, c = (F(witness[key]) for key in ('s', 'lambda', 'p', 'c')) + require(0 < root_lo < root_hi < top < 1 and min(s, lam, p, c) > 0, + 'critical parameter domain') + U, V, Q, d, beta = (F(witness['guards'][key]) + for key in ('U', 'V', 'Q', 'd', 'beta')) + require(0 < U < 1 and 0 < V < 1 and Q >= 1 and d > 0, + 'critical uniform guard domain') + require(c >= p/(1-root_hi), 'critical concavity') + mean_gap = mean(targets, root_lo)[0] - mean(paid, top)[1] + require(mean_gap >= d, 'critical mean gap') + + def forward(h, t): + x, y = moment(h, t+s), moment(h, t) + return x[0]/y[1], x[1]/y[0] + + # The derivative of log(M_h(t+s)/M_h(t)) is mu_h(t+s)-mu_h(t) + # and is nonnegative, because a tilted mean has variance derivative. + ordering = forward(targets, root_lo)[0] - forward(paid, top)[1] + require(ordering >= 0, 'critical forward ordering') + actual_u = power(M, -s)[1]*forward(targets, top)[1]**a*forward(paid, top)[1]**b + actual_v = power(M, lam)[1]*(moment(targets, top-lam)[1]/moment(paid, root_lo)[0])**(a+b) + actual_q = moment(targets, top)[1]/moment(paid, root_lo)[0] + require(actual_u <= U, 'critical mixed tail') + require(actual_v <= V, 'critical root tail') + require(actual_q <= Q, 'critical moment ratio') + eta = root_lo*power(m, root_lo-1)[0] + require(0 <= beta < eta < 1, 'critical mirror capacity') + points = sorted({F(0), *(F(1, k) for k in targets), + *(F(1, r) for r in paid)}) + mirror_upper = F(0) + for left, right in zip(points, points[1:]): + sources, exits = mirror_sides(targets, paid, (left+right)/2) + numerator, denominator = moment(exits, top)[1], moment(sources, root_lo)[0] + require(numerator <= beta*denominator, 'critical mirror window') + if exits: + mirror_upper = max(mirror_upper, numerator/denominator) + + def log(n): + return tuple(F(x, GRID) for x in logarithm(n)) + + logn0_lo = log(m)[0] + ell*log(M)[0] + tau_upper = root_hi + p/(c+logn0_lo) + require(tau_upper <= top, 'critical tangent cover') + denominator = c + log(m)[1] + (ell+1)*log(M)[1] + log(2)[1] + K = d*p*(a*ell+1)/denominator + lower = (1-U**ell)*(F(exponential(K)[0], GRID)-1)-Q*power(M, lam)[1]*V**ell + required = (1-eta)/(eta-beta) + require(lower >= required, 'critical recurrence funding') + return {'parameters': witness, + 'uniform_interval': [str(root_lo), str(top)], + 'uniform_mean_gap_lower': display((mean_gap, mean_gap))[0], + 'forward_ordering_margin_lower': display((ordering, ordering))[0], + 'mixed_tail_upper': display((actual_u, actual_u))[1], + 'root_tail_upper': display((actual_v, actual_v))[1], + 'moment_ratio_upper': display((actual_q, actual_q))[1], + 'mirror_upper': display((mirror_upper, mirror_upper))[1], + 'source_capacity_lower': display((eta, eta))[0], + 'tangent_exponent_upper': display((tau_upper, tau_upper))[1], + 'funding_lower': display((lower, lower))[0], + 'required_funding_upper': display((required, required))[1], + 'ordinary_base_cutoff': str(m)+'*'+str(M)+'^'+str(ell), + 'normalization': 'A=n0^(1-theta)/(c+log(n0))^p, where theta is the isolated root', + 'conclusion': 'L(n)<=A*n^theta*(c+log(n))^p for every integer n>=1, under the stated contracts.', + 'scope': 'Critical-exponent leaf-count majorant; no new outer endpoint or physical admission.'} + + +def run(root): + root = Path(root) + sources = {} + for path, digest in PINS.items(): + raw = (root/path).read_bytes() + require(sha256(raw).hexdigest() == digest, 'source bytes: '+path) + sources[path] = json.loads(raw) + p7 = sources['research/higher-moment-strictification/RESULT.json']['invoice_oracle'] + p16 = sources['research/compact-joint-compiler/arithmetic/RESULT.json'] + native = sources['research/joint-helper-lattice/RESULT.json'] + require(all(p16[k] == native[k] for k in ('targets', 'paid')), + 'p16 consumer/native inventory equality') + cases = [('p7', p7, F('0.997313'), F('0.997314'), F('0.321'), F(1)), + ('p16', p16, F('0.996979'), F('0.996980'), F('0.564'), F(1))] + results, rejected = {}, {} + original = {row['name']: row['witness'] for row in + sources['research/rank-convergence/BENCHMARKS.json']['cases']} + for name, profile, lo, hi, beta, gap in cases: + results[name] = certify(profile, lo, hi, beta, gap) + mutations = { + 'no crossing': (F('0.998'), F('0.999'), beta, gap), + 'unfunded mirror': (lo, hi, F(0), gap), + 'false derivative': (lo, hi, beta, F(100)), + } + for label, args in mutations.items(): + try: + certify(profile, *args) + except ValueError as error: + expected = {'no crossing': 'root sign crossing', + 'unfunded mirror': 'uniform mirror inequality', + 'false derivative': 'positive crossing derivative'}[label] + require(str(error) == expected, 'unexpected control rejection') + rejected[name+': '+label] = str(error) + else: + raise ValueError('accepted root-application mutation: '+label) + # Retain the predecessor's actual geometry, tails, logarithmic power, + # concavity constant, cutoff, and U/V/Q/d guards. The root replaces its + # strict base exponent; cover endpoints and the p7 beta are explicit. + previous = original[name] + witness = {key: previous[key] for key in + ('a', 'b', 'height_base', 'ell0', 's', 'lambda', 'p', 'c')} + witness['guards'] = {key: previous['guards'][key] + for key in ('U', 'V', 'Q', 'd', 'beta')} + witness['upper_exponent'] = '.997483' if name == 'p7' else '.997067' + if name == 'p7': + witness['guards']['beta'] = '.322' + results[name]['critical_majorant'] = critical_guards(profile, lo, hi, witness) + defects = { + 'concavity': ('c', '1', 'critical concavity'), + 'tangent cover': ('ell0', 1, 'critical tangent cover'), + 'underfunded logarithm': ('p', str(F(witness['p'])/100), 'critical recurrence funding'), + } + for label, (key, value, expected) in defects.items(): + bad = dict(witness, **{key: value}) + try: + critical_guards(profile, lo, hi, bad) + except ValueError as error: + require(str(error) == expected, 'unexpected critical-guard rejection') + rejected[name+': '+label] = str(error) + else: + raise ValueError('accepted critical-guard mutation: '+label) + return {'source_sha256': PINS, 'applications': results, + 'arithmetic_controls': arithmetic_controls(), 'rejected_controls': rejected, + 'arithmetic': 'Separate exact 128-bit outward log/exp intervals; no producer execution.'} + + +if __name__ == '__main__': + print(json.dumps(run(Path(__file__).resolve().parents[2]), sort_keys=True, indent=2)) diff --git a/research/native-provider-lift/critical_provider_check.py b/research/native-provider-lift/critical_provider_check.py new file mode 100644 index 0000000000..76f58548ff --- /dev/null +++ b/research/native-provider-lift/critical_provider_check.py @@ -0,0 +1,71 @@ +"""Critical native-provider consequence of Cao Yifan's PR4610 round-three profile. +Apache-2.0; prepared for Dugongue with substantial OpenAI Codex assistance. +Engine: Dillon; compiler: zxv, Jacob Alan Sussman and credited predecessors. +""" +from pathlib import Path +from fractions import Fraction as F +from hashlib import sha256 +import json +import gzip +from collections import Counter +HERE=Path(__file__).resolve().parent + +def need(ok,why): + if not ok: raise ValueError(why) + +def check(): + ep=HERE/'critical_engine.py'; E={'__name__':'frozen_critical','__file__':str(ep)} + exec(compile(ep.read_bytes(),str(ep),'exec'),E) + profile=json.loads((HERE/'ARITHMETIC.json').read_bytes()) + need(profile['local_paid']=={'1':2201,'2':412,'3':510,'4':127,'5':40,'8':8},'round-three local profile') + need(profile['local_helpers']=={'4':28,'7':7,'8':47,'9':326},'all independent helper ranks') + paid={int(k):v for k,v in profile['paid'].items()};targets={int(k):v for k,v in profile['targets'].items()} + need(sum(paid.values())==64404 and sum(targets.values())==10928,'complete inventory counts') + need(sum(k*v for k,v in targets.items())-sum(k*v for k,v in paid.items())==752,'rank mass surplus') + # Rebuild the complete invoice from actual emitted word plus pinned controller. + word_bytes=gzip.decompress((HERE/'ACTUAL-WORD.json.gz').read_bytes()) + need(sha256(word_bytes).hexdigest()=='cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd','actual source word canonical payload') + word=json.loads(word_bytes);c=word['canonical'] + local=Counter(e[5] for e in word['programs']['forward'] if e[0]=='climb') + local.update(e[4] for e in word['programs']['forward'] if e[0]=='center') + reverse=Counter(e[5] for e in word['programs']['backward'] if e[0]=='climb') + reverse.update(e[4] for e in word['programs']['backward'] if e[0]=='center') + helpers=Counter(len(c['frames'][c['final'][r]])-len(c['frames'][c['start'][r]]) for r in range(224,632)) + need(local==reverse==Counter({int(k):v for k,v in profile['local_paid'].items()}),'actual complete local dual paid profiles') + need(helpers==Counter({int(k):v for k,v in profile['local_helpers'].items()}),'actual independent helper interfaces') + controller_bytes=(HERE/'CONTROLLER.json').read_bytes() + need(sha256(controller_bytes).hexdigest()=='1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f','pinned source controller') + controller=json.loads(controller_bytes);rt,rp=Counter(),Counter();kinds=Counter(e[0] for e in controller['physical_events']) + need(kinds==Counter(ADD=90,LOCAL=18,SIGNED_SWAP=16,IDLE=15,QUERY_SHEAR=15),'complete retained controller event census') + for event in controller['physical_events']: + if event[0]=='LOCAL':rt.update(helpers);rp.update(local) + elif event[0]=='QUERY_SHEAR':rp[1]+=112 + elif event[0]=='IDLE':rp[8*len(event[2])]+=224 + for term in controller['diagonal']:rt[1+8*sum(term[1:])]+=112 + need(dict(rt)==targets and dict(rp)==paid,'complete emitted word/controller invoice') + old=next(row['witness'] for row in json.loads((HERE/'majorant-benchmarks.json').read_bytes())['cases'] if row['name']=='p16') + witness={key:old[key] for key in ('a','b','height_base','ell0','s','lambda','p','c')} + witness['guards']={key:old['guards'][key] for key in ('U','V','Q','d','beta')};witness['upper_exponent']='.997067' + lo,hi=F('.9969782241'),F('.9969782242') + root=E['certify'](profile,lo,hi,F('.564'),F(1)) + majorant=E['critical_guards'](profile,lo,hi,witness) + qC=F('.0030217755'); H=10**12;gap=1-hi-qC + log=lambda n:tuple(F(x,E['GRID']) for x in E['logarithm'](n)) + need(log(2)[0]>F(2,3) and log(145)[1]<8,'exact logarithms') + # log A < (1-theta)*(log145+650 log1024) < .003022*(8+6500)<20. + # (2/5)*log(133+log N)<(2/5)*40 log2 <16. + need(F('.003022')*(8+6500)<20 and 133+H<2**40,'overhead below36') + margin=gap*H*F(2,3)-36 + need(gap==F(3,10**10) and margin==164,'finite critical-root absorption') + need(gap-F(2,5)/(133+F(2,3)*H)>0,'monotone continuation above cutoff') + controls={} + for name,kwargs in [('unfunded_mirror',dict(beta=F(0))),('wrong_root',dict(lo=F('.9969798340229'),hi=F('.9969798340230')))]: + k=dict(lo=lo,hi=hi,beta=F('.564'),derivative_floor=F(1));k.update(kwargs) + try:E['certify'](profile,**k) + except ValueError:controls[name]=True + else:raise ValueError('negative control accepted: '+name) + return dict(status='PASS_SOURCE_BOUND_CRITICAL_PROVIDER',source_pr=4610,source_head='1eb8da6cfb35512c0cc2533413e5ca42f48e13c6', + critical_root=root,critical_majorant=majorant,uniform_saving=str(qC),fixed_rank_encoding='2^1000000000000', + fixed_rank_materialized=False,finite_absorption_log_margin=str(margin),negative_controls=controls, + scope='Exact profile arithmetic and funded critical majorant; actual all-fiber algebraic supplier and whole-job normalizers are explicitly inherited proofs, not finite tests.') +if __name__=='__main__': print(json.dumps(check(),indent=2)) diff --git a/research/native-provider-lift/frame_bridge_review.py b/research/native-provider-lift/frame_bridge_review.py new file mode 100644 index 0000000000..bbc4cf7403 --- /dev/null +++ b/research/native-provider-lift/frame_bridge_review.py @@ -0,0 +1,60 @@ +"""Independent exhaustive small-space rank/lattice corroboration; Apache-2.0. +Source Clifford implementation is an explicit caller-supplied frozen input. +Dugongue with substantial OpenAI Codex assistance. +""" +from pathlib import Path +import argparse,importlib.util,sys,json,hashlib + +def subspaces(n): + out=[] + for mask in range(1<<(1<>i&1} + if all(a^b in s for a in s for b in s):out.append(s) + return out + +def basis(s): + piv={};out=[] + for v in sorted(s): + w=v + while w: + b=w.bit_length()-1 + if b not in piv:piv[b]=w;out.append(v);break + w^=piv[b] + return tuple(out) + +def span(vs): + s={0} + for v in vs:s|={x^v for x in tuple(s)} + return s + +def check(source): + p=Path(source);spec=importlib.util.spec_from_file_location('frame_review_clifford',p) + ce=importlib.util.module_from_spec(spec);sys.modules[spec.name]=ce;spec.loader.exec_module(ce) + spaces=pairs=images=0 + for n in range(1,4): + ss=subspaces(n);spaces+=len(ss);fs=[] + for s in ss: + op=ce.canonical_frame(n,basis(s));fs.append(op) + # Compute image L0 from literal Z-tableau columns, without formula. + actual=span([x|(z<=2 and size&(size-1)==0 and p>=1,'transform shape') + self.N=size;self.p=p;self.S=1<>1 + while j&mask:j^=mask;mask>>=1;self.operations+=4 + j^=mask + if i>1;stride=self.N//step + for start in range(0,self.N,step): + for k in range(half): + tw=self.roots[k*stride] + if not inverse:tw=(tw[0],-tw[1]) + u=data[start+k];v=self.cmul(data[start+k+half],tw) + data[start+k]=(self.val(u[0]+v[0]),self.val(u[1]+v[1])) + data[start+k+half]=(self.val(u[0]-v[0]),self.val(u[1]-v[1])) + self.operations+=18 + step<<=1 + if inverse:data=[(self.val(a//self.N),self.val(b//self.N)) for a,b in data] + return data + + def prepare(self,kernel): + need(1<=len(kernel)<=self.N,'kernel size') + return self.fft(list(kernel)+[(0,0)]*(self.N-len(kernel))) + + def apply(self,data,prepared,output_length): + need(1<=len(data)<=self.N and 1<=output_length<=self.N,'convolution size') + d=self.fft(list(data)+[(0,0)]*(self.N-len(data))) + result=self.fft([self.cmul(x,y) for x,y in zip(d,prepared)],True) + return result[:output_length] diff --git a/research/native-provider-lift/native_lift.py b/research/native-provider-lift/native_lift.py new file mode 100644 index 0000000000..93f56bff2a --- /dev/null +++ b/research/native-provider-lift/native_lift.py @@ -0,0 +1,85 @@ +"""Rational native caller parameter selection; Apache-2.0. +Dugongue with substantial OpenAI Codex assistance. +Checks exponent arithmetic, not the retained operator identities. +""" +from fractions import Fraction as F +import json + +C=F(3,32) + +def choose(provider, target): + provider, target=F(provider), F(target) + if not 0 < target < min(provider,C): + raise ValueError('need 0 < target < min(provider,3/32)') + q=(target+min(provider,C))/2 + stop=(provider-q)/(2*provider) + delta=min(F(1,100),(q-target)/(4*(q+1)),(C-q)/16) + epsilon=1-delta + beta=1-3*delta + spare=delta/10 + layout=delta/100 + xi=epsilon*(1+q)-C+layout + savings={ + 'main':epsilon*q, + 'standalone_routing':F(1), + 'fused_gaussian':1-epsilon+q*beta, + 'standalone_addressing':F(1), + 'group_scans':1-epsilon+beta, + 'boundary':C+xi-epsilon, + 'sparse_visits':F(1,2)+xi-epsilon, + 'record_products':epsilon, + 'core_face_recovery':1-(epsilon+beta+48-128+2), + } + guards={ + 'stopped_provider':provider*(1-stop)-q, + 'stop_positive':stop, + 'stop_below_one':1-stop, + 'epsilon_below_one':1-epsilon, + 'beta_positive':beta, + 'beta_below_epsilon':epsilon-beta, + 'cap_above_band':xi-F(1,2), + 'cap_below_dimension':epsilon-xi, + 'global_gamma':1-epsilon-spare, + 'group_chirp':1-(beta+2*xi-2+spare), + 'group_key':1-(beta+1-epsilon), + 'membership':1-(beta+2*(1-epsilon)), + 'spare_positive':spare, + 'strassen_integer_certificate':F(2**45-7**16), + } + guards.update({k+'_excess':v-target for k,v in savings.items()}) + failed=[k for k,v in guards.items() if v<=0] + if failed: + raise ValueError('strict guard failure: '+','.join(failed)) + return {'provider':str(provider),'target':str(target),'q':str(q), + 'stop':str(stop),'delta':str(delta),'epsilon':str(epsilon), + 'beta':str(beta),'spare':str(spare),'layout':str(layout),'xi':str(xi), + 'savings':{k:str(v) for k,v in savings.items()}, + 'guards':{k:str(v) for k,v in guards.items()}, + 'minimum_excess':str(min(v-target for v in savings.values()))} + +def check(): + # Illustrations are arithmetic only: supplying q_C is a separate obligation. + cases=[('0.0030201656','0.0030201655'), + ('0.00302157','0.003021569'), + ('0.0156','0.0155'), + (F(3,32),F(3,32)-F(1,10**9)), + (F(1,4),F(9,100)), + (F(1,10**50),F(1,2*10**50))] + results=[choose(a,b) for a,b in cases] + for a in range(1,31): + provider=F(a,320) + for j in range(1,20): + choose(provider,min(provider,C)*F(j,20)) + bad=[(0,F(1,100)),(F(1,100),0), + (F(1,100),F(1,100)),(F(1,4),C), + (F(1,4),C+F(1,10**9))] + for a,b in bad: + try:choose(a,b) + except ValueError:pass + else:raise AssertionError('bad parameter accepted') + return {'status':'PASS','illustrative_cases':results, + 'additional_rational_cases':570,'rejecting_controls':len(bad), + 'scope':'Exact universal parameter formulas instantiated on rational cases; operator identity and provider realization remain separate proof inputs.'} + +if __name__=='__main__': + print(json.dumps(check(),indent=2)) diff --git a/research/native-provider-lift/operator_check.py b/research/native-provider-lift/operator_check.py new file mode 100644 index 0000000000..f7cdd6b872 --- /dev/null +++ b/research/native-provider-lift/operator_check.py @@ -0,0 +1,50 @@ +"""Portable exact-head logical/frame check in an authenticated temporary tree.""" +from pathlib import Path +from collections import Counter +from copy import deepcopy +import json,gzip,sys + +def need(ok,why): + if not ok:raise ValueError(why) + +def main(): + R=Path(sys.argv[1]);sys.path.insert(0,str(R/'research/joint-helper-lattice')) + import native_joint as J + F=J.F + new=json.loads(gzip.decompress((R/'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz').read_bytes())) + c=new['canonical'];old,base,*_=J.construct() + need(c['frames'][:len(old['frames'])]==old['frames'],'base chart prefix') + need(c['start'][:224]==old['start'][:224] and c['final'][:224]==old['final'][:224],'canonical main interfaces') + need(len(c['start'])==len(c['final'])==632,'all independent fields') + H=Counter() + for r in range(224,632): + a,b=c['start'][r],c['final'][r];A,B=map(F.span,(c['frames'][a],c['frames'][b])) + need(A>i&1:y^=col + return y + G={w['op']:w['G_columns'] for w in c['warps']} + need(set(G)==set(range(1,73)),'all native maps') + for cols in G.values():need(len({image(cols,x) for x in range(512)})==512,'invertible map') + V=F.load(R/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py','portable_rows') + X=F.load(R/'research/kappa-rebuild/complex/native_extensions.py','portable_literal') + classes=set() + for d,p in new['programs'].items(): + need([e[1] for e in p if e[0]=='scalar']==[e[1] for e in base[d] if e[0]=='scalar'],'literal scalar word') + need([(e[1],e[2]) for e in p if e[0]=='warp']==[(e[1],e[2]) for e in base[d] if e[0]=='warp'],'logical warp word') + for e in p: + if e[0]!='warp':continue + op,a,b=e[2:5];A,B=map(F.span,(c['frames'][a],c['frames'][b]));cols=G[abs(op)] + need(({image(cols,x) for x in A}==B) if op>0 else ({image(cols,x) for x in B}==A),'actual warp chart') + classes.add((op,a,b)) + rows,rec=X.literal_replay(V,c,p,d=='backward') + need(all(rows['L',r]==V.expected(('L',r),[],d=='backward',False) for r in range(632)),'all arbitrary columns') + paid={int(k):v for k,v in rec['paid_profile'].items()} + need(paid=={1:2201,2:412,3:510,4:127,5:40,8:8},'complete local paid invoice') + rebound=deepcopy(c);rebound['R']=408;rebound['local_profile']=paid + V.replay(p,rebound,[],d=='backward',False) + print(json.dumps(dict(status='PASS',columns_per_orientation=632,orientations=2,interpreters=2,native_maps=72,map_image_columns=36864,warp_classes=len(classes),helpers=408))) +if __name__=='__main__':main() diff --git a/research/native-provider-lift/record_product.py b/research/native-provider-lift/record_product.py new file mode 100644 index 0000000000..fe528ae356 --- /dev/null +++ b/research/native-provider-lift/record_product.py @@ -0,0 +1,75 @@ +"""Global-precision native negacyclic record products, Apache-2.0. +Dugongue with substantial OpenAI Codex assistance. +""" +from pathlib import Path +from random import Random +import json + + +def need(ok,why): + if not ok:raise ValueError(why) + + +def module(name): + p=Path(__file__).with_name(name);ns={'__name__':'record_component','__file__':str(p)} + exec(compile(p.read_bytes(),str(p),'exec'),ns);return ns + + +class RecordProduct: + def __init__(self,r,p): + need(r>=1 and r&(r-1)==0 and p>=1,'record shape') + self.r=r;self.p=p;N=max(2,2*r) + self.F=16*p+16*r.bit_length()+64;self.S=1<=0 else -((-x)//d) + + +def root_seed(order,p,word_width=None): + need(order>=1 and p>=1,'root seed shape') + P=8*(p+16);S=1<=2*P+20 and order<(1<>shift,5) + return z if x>=0 else -z + real,imag=nearest(sr),nearest(si) + error_numerator=40*(P+2)+1+4096*K+32 + # Seed internal error <= error_numerator/2^P; nearest rounding adds 2^(-p-1). + need((error_numerator<<(p+1))<(1<= k_min`. At a fixed integer top rank n>=m, +put + +``` +c(a) = product_k k^a_k, +u(a) = multinomial(|a|;a) product_k W_k^a_k, +R(rho) = {a : m*rho*c(a) <= n}, +G = floor(log_(k_min)(floor(n/m))). +``` + +For every paid-round path s of length d<=G with multiplier rho_s, instantiate +u(a) units at column rho_s*c(a), for every point a in R(rho_s) of degree +G−d. This is the source class construction. For a parent class with +multiplier rho, its rank-r round supplies u(b) jobs at point b when b is +present. The child demand at that point is + +``` +D(b) = sum over eligible (b−e_k) of W_k*u(b−e_k). +``` + +The complete Pascal sum is u(b). Therefore: + +- If the parent point b exists, `0 <= D(b) <= u(b)`. Route D(b) of the + **whole** issued jobs to the child. Complete the remaining u(b)−D(b) + jobs as paid exits, at their actual rank `e=r*rho*c(b)`. +- If the parent point is absent, supply the child demand with new distinct + top input arrays. These are source jobs, not copies of issued data. +- At depth G, every point has degree zero; all paid jobs are exits. + +No fractional jobs, cloned productive inputs or uncharged discarded requests +are introduced. Within each point, choose a fixed enumeration of parent +jobs and target slots and match their first D(b) elements. The rest have +explicit endpoints and remain on their actual owners. + +### Sources and exits + +At the root, every demanded point has degree G+1, so it is outside R(1). +Its rank s is in `(n/m,n]`. A non-root source has no parent point, hence +`m*rho_parent*c(b)>n`; its rank is `r*rho_parent*c(b)>r*n/m>=n/m`. +Its eligible child target ensures s<=n. Thus every source is a positive +job in `(n/m,n]`. + +Every exit belongs to an actual parent unit, so + +``` +e <= r_max*n/m < n. +``` + +This holds for the new premature exits as well as leaf exits. A premature +exit has at least one omitted Pascal term, with +`m*r*rho*c(b)/k > n`; consequently `e > k_min*n/m`. These are large exits +near the upper boundary. They cannot be assigned the old bound +`r_max*(n/m)^theta` with theta<1. That lost estimate is the exponent issue. + +### Chronology and arbitrary inputs + +Run all scalar steps of a class in their specified order. At paid position +j, issue that position for every unit, partition its whole issued jobs into +matched and unmatched slots, finish all unmatched exits and the entire child +class, restore adapters, and only then resume position j+1. The child takes +incoming jobs from this one parent round plus its new top sources. It never +waits for a later round of a suspended parent. The finite class depth is G; +all complement and exit calls have rank below n, so their uniform programs +are already available by strong induction. + +Distinct slots in one class have distinct physical fields. Routing fewer +parent slots than the original full-Pascal construction preserves this +property. Arbitrary-input native correctness permits correlated values, +including current owned-center contents; it does not permit field aliasing +or extra productive credit. Each unit has its own owned identities and +retains them until its word clears them. These requirements are unchanged. + +### Exact potential and count identities + +Let S_s and E_e be integer source and exit inventories, U the unit count, +and Qcol the sum of the units' positive integer column multiplicities. +Cancellation of matched jobs gives, exactly at rank one, + +``` +sum_s S_s*s − sum_e E_e*e = Delta * Qcol, +Delta = sum_k W_k*k − sum_j r_j. +``` + +At any real exponent t, the corresponding identity is + +``` +sum_s S_s*s^t − sum_e E_e*e^t + = (T_t−P_t) * sum_units column^t. +``` + +Thus a favorable raw t-moment survives as a superpotential. It does **not** +by itself pay the source complements. Writing W=sum W_k and P=number of +paid rounds, complete untruncated layer counts give + +``` +U <= sum_(d=0..G) P^d W^(G−d) <= (W+P+1)^(G+1), +S := sum_s S_s <= W*U, +sum_e E_e <= P*U. +``` + +The source package's separated case is unchanged: no premature exits occur. +The verifier compares it with the byte-identical predecessor literal replay. + +## 3. Nested divisible widths and complete count bounds + +Use the ordinary base B_n=1, P_n=n below m, with B_0=1 and P_0=0. For n>=m +choose the replication factor and productive width + +``` +a_n = B_(n−1), B_n = a_n*S_n. +``` + +Every earlier width B_e divides B_(n−1), by induction. Therefore every +source-complement batch and exit batch is an integer number of smaller +uniform programs. This is a concrete choice within the source compiler's +existing denominator-clearing freedom; no optimum is claimed. Its previous +option to use an LCM is retained as predecessor context. + +As in the source compiler, each of the a_n*S_n original arrays first gets +its disjoint complementary job, then its one source job through the flow. +All exits are completed by smaller uniform programs. The result is a full +rank-n transform on every original array. Owned storage is excluded from B_n. + +The normalized leaf count satisfies the **same exact recurrence** for any +valid replication choice: + +``` +L(n) = (1/S_n) * [sum_s S_s L(n−s) + sum_e E_e L(e)]. +``` + +Changing the replication factors changes width and total counts equally. +It does not spend supplier saving or alter any outer parameter. + +For a fixed final N and h=G(N), all n<=N satisfy + +``` +S_n <= C_N := W*(W+P+1)^(h+1), +B_N = product_(n=m..N) S_n <= C_N^N. +``` + +Since h=O(log N), **log B_N=O(N log N)** for a fixed mixed rule. Repeatedly +multiplying all previous widths is unnecessary. This bounds one explicit +realization; the original compiler did not require that inefficient choice. + +If Delta>0, telescope rank-one mass over the fully expanded uniform program: + +``` +B_N*N − P_N = Delta * Qcol_N, +U_N <= Qcol_N <= B_N*N/Delta. +``` + +All raw columns are positive integers, which gives the middle inequality. +Thus paid leaves and raw instances have the same `exp(O(N log N))` bound. +With one owned center per raw unit, the center count is at most U_N. A rule +with O_local distinct owned banks per invocation instead gets O_local*U_N. +Extra router scratch must be counted separately. + +### Routing and word description + +Count one routing slot for every source, every exit, every unit target slot +and every unit paid position. At one flow its count is at most +`2*(W+P)*U`. The same bound telescopes over all recursive calls, because +each call contributes its own local unit instances. Exact compilation checks +this identity alongside widths and leaves. + +In the macro grammar that records a whole-job adapter, inverse adapter or +whole-field move as one record, a slot can be handled with at most sixteen +records: up to two whole-job conjugations and their inverses, park/load/ +return/reorder moves, and explicit scratch initialization and erasure. +Allocate separate owned scratch for those moves when needed; no zero-cost +routing or free copying is assumed. Let A bound the fixed unit's complete +nonrecursive record count, owned operations and scalar coefficient heights. +The final weighted record allowance satisfies the conservative bound + +``` +R_bar <= A*U_N + 32*(W+P)*U_N + P_N + <= (A+32*(W+P)+1)*B_N*N, for Delta>=1. +``` + +R_bar bounds both the macro count and the sum of scalar-height and native +record allowances. Every owned bank has an explicit initialization record, +so total allocated owned banks can also be bounded by R_bar; the sharper +raw-center bound remains separate. This is a **description/record bound**, +not a new tariff for executing a +general matrix or permutation. A Gaussian monomial adapter's dense binary +address matrix and quadratic phase have O(N^2) descriptor bits. Explicit role indices add O(log B_N) +bits. Thus an encoding of this finite word still has +`exp(O(N log N))` bits for a fixed unit and its finite coefficient alphabet. +If physical expansion of one adapter needs F(N) native records, multiply +the routing term by its actual F(N). That physical implementation, coefficient +heights and tape costs remain separately priced native obligations. They +are not set to zero by the macro bound. + +## 4. Applying the size result to PR4433 + +The new nested widths may be used in the separated compiler of PR4433. +Its normalized L(n), ambient N, uniform saving and outer ledger remain +unchanged. Therefore this application does not need the still-open direct +exponent lemma. + +With `v=150`, `H=349300000000`, `N=2^H`, the completed mixed rule has + +``` +W = 7688^150 < 2^1950, +P <= 131115^150 + 7688^150*15^150 < 2^2701, +W+P+1 < 2^2702. +``` + +The bound on P counts every original and completion call by its positive +rank mass; splitting preserves that mass. Since k_min>=2, h<=H. Set + +``` +D = 1950 + 2702*(H+1) = 943808600004652. +``` + +There is consequently a realization of the same proposed conditional +κ=0.00268647 supplier satisfying + +``` +B_N < 2^(D * 2^H), +P_N < B_N * 2^H. +``` + +More finely, after expanding every product, padding, split and compiler call +back to the raw p7 word, that word has surplus 608. Product/completion/split +boundaries cancel, so + +``` +B_N*N − P_N = 608 * sum_raw_p7_instances column, +U_raw <= (B_N*N − P_N)/608. +``` + +This is also an explicit bound on raw p7 center banks under the safe +one-center-per-instance allocation. These are large upper bounds, not +emitted words, smallest widths or practical precision estimates. They replace +one implicit part of the source finite-constant prescription. The native +adapter bodies, analytic transfer and physical costs retain their original +conditions; a closed bound for the source's finite-constant prescription is +given next, without a new physical runtime or exact-recovery threshold. + +### A closed envelope for the source finite constants + +The exported THREE-base native word has exactly 22,633 records in each +orientation. Source-bound counting retains all 15 copies, the literal p7 +controller, scalar allowance 2,490,856, every productive/paid/contact/helper/ +idle slot, and all routing and owned operations. A raw macro allowance is + +``` +A_raw = 15*8*(decompressed native JSON bytes) + + 8*(literal controller JSON bytes) + + 32*(2490856 + all declared slots + 15*22633) < 2^40. +``` + +The payload-bit terms overcount the coefficient literals and full local +descriptors, including both orientations. The 32-per-slot term overcounts +whole-job normalizers and inverses, field movements, initialization and +erasure. It is a bound on the declared source word in this grammar, not +independent verification of its functional correctness or physical tariffs. + +For the chronological v-fold product, its number of raw p7 invocations is + +``` +U_v = sum_(i=0..v−1) 7688^(v−1−i)*55998^i < 2^2392. +``` + +At every product level retain the whole-job matching wrappers. A conservative +product allowance is + +``` +A_product <= (2^40 + 32*v*(7688+55998+1))*U_v + 32*v*55998^v. +``` + +Add 32 records for every final paid call, completion role and original paid +position. Counting paid calls by their rank mass gives + +``` +A_completed <= A_product + + 32*(131115^v + 7688^v*15^v + 7688^v + 55998^v). +``` + +A dense local binary map/quadratic phase and role index fit in +`64*(121^v)^2` bits per such record. The verifier checks the integer bound +`A_completed * 64*(121^v)^2 < 2^5000`. Thus **A=2^5000** is a valid weighted +record/description allowance for this fixed completed unit. It includes all +source coefficients and owned operations, with a large deliberate overcount. +No instruction list of the completed product is emitted. + +Since `A+32*(W+P)+1 < 2^5001`, use the envelope + +``` +R_bar < 2^(D*2^H + H + 5001). +``` + +Apply the existing source finite-constant prescription to the **newly expanded +word**. With Z=B_N+owned banks, G its scalar coefficient envelope, and P_N +its rank-one leaves, we have `Z<=2*R_bar`, `G<=8*R_bar`, `P_N<=R_bar` and +`N<=R_bar`. Therefore + +``` +E = 64*(Z+N+P_N+G+1)^3 + < 2^(3*D*2^H + 3*H + 15021), +B_constant = P_N+E, +C0 = 32*N*B_constant^2 + < 2^(6*D*2^H + 7*H + 30049) + < 2^(8*D*2^H). +``` + +The last comparison uses `2^H>=H+1` and an exact polynomial integer check +on D and H. These are explicit, very loose upper bounds for the inherited +semantic precision/stock constants, conditional on that source prescription +and its admitted native record implementations. The exact numerical outer +input threshold, prime exclusions and physical tape costs remain separate. + +## 5. Exact finite checks and the open exponent gate + +The verifier uses no floating-point acceptance tests. It checks: + +- Nine literal/merged flows at ranks 20, 40 and 80: a separated control, + strict overlap `{2:1,5:1} <- {1:2,4:1}`, and Sussman's open equality + example `{2:4,3:1} <- {1:6,2:2}`. Every whole input and exit agrees. +- The separated control agrees with the unchanged Sussman literal replay. +- Complete nested-width compilations through rank 100 on both overlap + examples, checking every recursive batch, routing count and rank identity. +- Raw p7 through rank 1,000: **880 exact nonbase compilations**. B_1000 has + 17,504 bits; the saved receipt binds all large computed integers by their + unsigned big-endian hashes, avoiding enormous decimal dumps. +- Removing premature exits violates mass conservation. Removing batch + replication fails integer divisibility. Allowing a paid rank equal to + the ambient rank is rejected because strict rank descent is unavailable. + +For raw p7 at rank 1,000, exact arithmetic gives + +``` +L(1000) > 990 > 1000^(1−0.00268647). +``` + +The second comparison is elementary and exact: `ln(2)>2/3` from its first +atanh term and `1000>2^9` give `ln(1000)>6`. Then +`1000^κ > 1+6κ > 100/99`. No log approximation is used in this rejection. +This checks one finite failure and keeps it distinct from the infinite-rank +question. + +The missing lemma is a uniform bound on the **whole** recurrence. For some +fixed p and sufficiently large n, one would need, for example, + +``` +sum_e E_e e^t (1+log2(e))^p + + sum_s S_s (n−s)^t (1+log2(n−s))^p + <= S_n n^t (1+log2(n))^p, +``` + +with zero-rank terms defined separately and a correctly funded base range. +The premature exits have rank proportional to n. Their logarithmic factors +cannot use the old fixed theta<1 power contraction. A raw moment advantage +alone does not prove this inequality. + +Exploratory `approximate_leaves` in flow.py evaluates the recurrence in +floating point and is deliberately excluded from verification. A bounded +run through 20,000 ranks found saving about 0.000827 for the default height; +varying the height did not approach 0.00268647 there. This is local search +evidence, not a lower bound or a reason to enlarge the same scan. A better +boundary estimate or a changed flow is the next research obligation. + +## 6. Reproduction and provenance + +Python 3.12, standard library only: + +```sh +python3.12 -B research/direct-mixed-flow/verify.py +python3.12 -B scripts/research_package.py --package research/direct-mixed-flow --check-only +python3.12 -B scripts/research_package.py --package research/direct-mixed-flow +``` + +Use `verify.py --out /absolute/new/result.json` for a fresh receipt. +[RESULT.json](RESULT.json) contains exact flows, integer compilation hashes, +symbolic size bounds and negative controls. `flow.py` is the new algorithm; +the verifier independently compares its merged and literal traversal outputs. +Those are two internal implementations, not an independent mathematical review. + +Canonical base is `12fa8c5c844be21bfefb38a19503fbd867a11244`, priority revision +7. SOURCES.json pins orientation metadata. VENDOR.json separately binds eleven +unchanged exports by commit, full path, Git blob and SHA256. Their bytes and +notices are preserved; direct replay needs no foreign Git objects. The source +theorem and earlier finite compiler remain attributed hypotheses, not new work. + +Local validation used Python 3.12.8 on macOS arm64. The registered replay, +metadata/pin check and committed-byte preflight passed. A separate Git-free +copy passed with `python3.12 -I -O -B verify.py`; changed-native-source and +changed-receipt controls both rejected. Replay uses exact integer arithmetic +and source hashes, with no network or foreign Git objects. The repository is +shallow, so a full source-history preflight was not attempted. No Lean, Docker, +full native/all-column admission, physical adapter expansion or historical +suite was run. Independent mathematical acceptance remains open. + +The overlap refresh at 18:48 UTC covered 538 open PR bodies and 3,280 +discussion/comment records, with complete reported pagination. Specific +searches for direct overlapping-rank compilers, Pascal matching and nested +widths found no matching public item in that scope; this is not a novelty +certificate. Existing PR4433 supplies the fixed-rank application, and the +source theorem explicitly leaves the unseparated exponent open. No Discussion +claim or PR has been posted for this partial checkpoint. + +## Open next questions + +1. **Close or refute the direct exponent gate for this capped flow.** Start + with a proved bound on premature-exit potential relative to the actual + complement capacity. This decides whether the flow can replace the + tensor/padding layer. A larger rank scan is not a uniform proof. +2. **Independently admit the physical expansions and precision prescription.** + Audit the conservative A allowance against the actual native caller and + bind every adapter's physical implementation, row movements and recovery + exclusions. The encoded constants above use the inherited semantics; + description size is not a physical execution tariff. +3. **Tighten the constructive width.** The nested product is an explicit + upper bound, not an optimized LCM. A useful next step would control prime + valuations of the actual source counts; another arbitrary batching choice + would not by itself establish a smaller physical supplier. + +Prepared by zxv with substantial OpenAI Codex assistance in research, code +and writing. No subagents or independent human mathematical review were +used. New material is Apache-2.0. The integer lockstep/Pascal construction +and original open unseparated question are Jacob Alan Sussman's work, retained +at upstream `wht-power-saving-lean` commit +`563b4e6e913625637f36ba7869bf5fcd0dd4975a`; its LICENSE and NOTICE are included. +PR4359 supplies the native finite-precompilation bridge and p7 predecessor +lineage. PR4416's p7 product/padding is @1337isnot1337's work. PR4433 supplies +the unchanged sufficient rank. Their original contributor credit remains +in the authenticated exports. diff --git a/research/native-provider-lift/sources/PR4630-4535-BRIDGE-PINS.json b/research/native-provider-lift/sources/PR4630-4535-BRIDGE-PINS.json new file mode 100644 index 0000000000..93467db60e --- /dev/null +++ b/research/native-provider-lift/sources/PR4630-4535-BRIDGE-PINS.json @@ -0,0 +1,40 @@ +{ + "files": [ + { + "pr": 4483, + "head": "fb0c208864e6b24e3473318a058aa5b2dbd5764b", + "path": "research/compact-joint-compiler/PROOF.md", + "sha256": "3f337fba12288d3b5e51af9541e2a645f79c8668fabf48b212672285fe6150b4" + }, + { + "pr": 4532, + "head": "644607ba59ebe401ac7ecd627ae7f331f924d1b0", + "path": "research/adaptive-gate-existence/PROOF.md", + "sha256": "340d637feef40f44a808c718207c0fede12cc483e2c979b86c56bb736b9c1ef5" + }, + { + "pr": 4483, + "head": "fb0c208864e6b24e3473318a058aa5b2dbd5764b", + "path": "research/direct-mixed-flow/README.md", + "sha256": "78351e2419eb1ff1d645addd411158b91b381b23a962a91b6deeebeacd5192a8" + }, + { + "pr": 4483, + "head": "fb0c208864e6b24e3473318a058aa5b2dbd5764b", + "path": "research/compact-joint-compiler/arithmetic/PROOF.txt", + "sha256": "273598588316e29a45e3940c6f5070d973b1998fe5b9c582b23bfe87502724cc" + }, + { + "pr": 4535, + "head": "a6d7237f697185e857090e174c23c1cb22c6563c", + "path": "research/critical-root-multiplication/PROOF.md", + "sha256": "870cc213c847175f3717db057539686de638594e8c509b2a2daf8d8e72497102" + }, + { + "pr": 4535, + "head": "a6d7237f697185e857090e174c23c1cb22c6563c", + "path": "research/critical-root-multiplication/RESULT.json", + "sha256": "e830f4cab30e70ab02d2ecca283969bd97f3a6925948b61d0eb15df3be831b14" + } + ] +} diff --git a/research/native-provider-lift/sources/PR4630-CODE-SOURCE-PINS.json b/research/native-provider-lift/sources/PR4630-CODE-SOURCE-PINS.json new file mode 100644 index 0000000000..2db32160b9 --- /dev/null +++ b/research/native-provider-lift/sources/PR4630-CODE-SOURCE-PINS.json @@ -0,0 +1,62 @@ +[ + { + "local_file": "sources/4554-FFT-ERROR.md", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/native-word-fft/FFT-ERROR.md", + "sha256": "ca426930df5c449ca8ce432360ba3ac80f12377bcd9a058ad16387d8ad87bef5" + }, + { + "local_file": "sources/4554-ROOTS-RECOVERY.md", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/native-word-fft/ROOTS-RECOVERY.md", + "sha256": "5e115c3ded1734dbcb119c889755a13ce9e9357598ec20a3eb1d3cdd727638f4" + }, + { + "local_file": "sources/4554-NATIVE-STABILITY.md", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/native-word-fft/NATIVE-STABILITY.md", + "sha256": "260e78bf8f88667a637b804d013d1e7c6dfdf1e23ae35ffdc64a4366c7321221" + }, + { + "local_file": "root_seed.py", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/native-word-fft/root_seed.py", + "sha256": "9b323f84ade7decfa6152dd4385e90ec43b56087927ac23ad4ef73ae4d5d3042" + }, + { + "local_file": "native_convolution.py", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/native-word-fft/native_convolution.py", + "sha256": "a62a4cb5a1da458e31c90ea881a1146b59e9fd7ccbf317c1c9836c19bc7fa2c6" + }, + { + "local_file": "phase_tables.py", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/native-word-fft/phase_tables.py", + "sha256": "4d70323775a8efc3af82eff7ee567482bfa5d14d8c86289fe21c29c0d37422e1" + }, + { + "local_file": "exp_table.py", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/native-word-fft/exp_table.py", + "sha256": "e617b40d499f423a7861b4483bdacdb7db28232fadf7468efe871adae557fa35" + }, + { + "local_file": "critical_engine.py", + "commit": "a6d7237f697185e857090e174c23c1cb22c6563c", + "repository_path": "research/adaptive-gate-existence/root_application.py", + "sha256": "e656ef12f73a8dd3bdb256eca95a712de1269facb18a652fc4068ba718619b4d" + }, + { + "local_file": "raw-profile.json", + "commit": "f626db5c3a3d781d8f7695038776c621651f75e1", + "repository_path": "research/joint-helper-lattice/RESULT.json", + "sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21" + }, + { + "local_file": "majorant-benchmarks.json", + "commit": "f626db5c3a3d781d8f7695038776c621651f75e1", + "repository_path": "research/rank-convergence/BENCHMARKS.json", + "sha256": "513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850" + } +] diff --git a/research/native-provider-lift/sources/PR4630-MODERN-SOURCE-MAP.json b/research/native-provider-lift/sources/PR4630-MODERN-SOURCE-MAP.json new file mode 100644 index 0000000000..1ade8c7499 --- /dev/null +++ b/research/native-provider-lift/sources/PR4630-MODERN-SOURCE-MAP.json @@ -0,0 +1,124 @@ +{ + "sources": [ + { + "local_file": "modern-sources/BILATERAL-LDU.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/BILATERAL-LDU.md", + "sha256": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77", + "bytes": 6305 + }, + { + "local_file": "modern-sources/CAPPED-INTERIORS.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/CAPPED-INTERIORS.md", + "sha256": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba", + "bytes": 7284 + }, + { + "local_file": "modern-sources/FINE-PADDING-COMPOSITION.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/capped-fusion-t74-k554/outer/FINE-PADDING-COMPOSITION.md", + "sha256": "331189874c79c2fbfb839838ec8ea61c09a7f0769098af88716ad6e7c54c0b5a", + "bytes": 7442 + }, + { + "local_file": "modern-sources/FINE-PRIME-PADDING.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/capped-fusion-t74-k554/vendor/pr1786/FINE-PRIME-PADDING.md", + "sha256": "47d1b1b4df28aadda3cd6bdeb1fbc47290595e9208cd09c1a1f338520d33fdce", + "bytes": 18927 + }, + { + "local_file": "modern-sources/FIXED-A-PERIODIC-NORM-AUDIT.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-PERIODIC-NORM-AUDIT.md", + "sha256": "21027a569588922c491b2c5b4f31e01ddb784f1f20cdf48b7d482d0e85b66bdb", + "bytes": 3422 + }, + { + "local_file": "modern-sources/FORWARD-SMALL-A-AUDIT.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/FORWARD-SMALL-A-AUDIT.md", + "sha256": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0", + "bytes": 6689 + }, + { + "local_file": "modern-sources/GAUGEFREE-INTERIORS.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "4f46c6a9732f63cba411698c743f6b6b681273c9", + "repository_path": "research/capped-fusion-t74-k554/outer/GAUGEFREE-INTERIORS.md", + "sha256": "a7fc34302a70f8453f877a6433ffe2776457bf37b5d8bb262afcb6b198a935fc", + "bytes": 19045 + }, + { + "local_file": "modern-sources/LOG-A-PHASE-SCHUR-AUDIT.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md", + "sha256": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272", + "bytes": 10642 + }, + { + "local_file": "modern-sources/OUTER-AUDIT.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/OUTER-AUDIT.md", + "sha256": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc", + "bytes": 13831 + }, + { + "local_file": "modern-sources/PARTIAL-FUSION.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/PARTIAL-FUSION.md", + "sha256": "811a3a0c88a90708add5b12fb0a05c25623f0af155010d5dcacd56021c55cba5", + "bytes": 4169 + }, + { + "local_file": "modern-sources/README.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/README.md", + "sha256": "4d65ea3c8b6a0d5faef819a58c8b8277681d11bed54686e9a7f78de29736e68e", + "bytes": 18502 + }, + { + "local_file": "modern-sources/REFINED-PHASE-FUSION.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/REFINED-PHASE-FUSION.md", + "sha256": "b4367eac012624f803b3d2e3a72339e050a0071bbec37e6d33b2cf322bd70bc5", + "bytes": 7276 + }, + { + "local_file": "modern-sources/SHALLOW-TOEPLITZ.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/SHALLOW-TOEPLITZ.md", + "sha256": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310", + "bytes": 15480 + }, + { + "local_file": "modern-sources/SUPPLIER-SUPPORT-AUDIT.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/SUPPLIER-SUPPORT-AUDIT.md", + "sha256": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6", + "bytes": 16557 + }, + { + "local_file": "modern-sources/TENSOR-COMPILER.md", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "repository_path": "research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/TENSOR-COMPILER.md", + "sha256": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15", + "bytes": 13430 + } + ] +} diff --git a/research/native-provider-lift/sources/PR4630-NATIVE-ASSEMBLY.md b/research/native-provider-lift/sources/PR4630-NATIVE-ASSEMBLY.md new file mode 100644 index 0000000000..93116735b7 --- /dev/null +++ b/research/native-provider-lift/sources/PR4630-NATIVE-ASSEMBLY.md @@ -0,0 +1,145 @@ +# Source-bound native Word RAM multiplication with saving 0.0030201655 + +## Precise claim and retained mathematical inputs + +On the standard finite-word random-access model with indexed memory, add/subtract, shifts, Boolean operations, comparison and multiplication/division of O(log n)-bit words, the constructions below give packed n-bit integer multiplication in + + O(n/(log n)^kappa), kappa=0.0030201655. + +The word-width coefficient is a sufficiently large fixed constant. This is a Word RAM claim, not a stronger multitape-TM exponent. It is conditional on the correctness of the specifically retained algebraic and analytic predecessor proofs listed next. It imports no TM algorithm or TM complexity theorem. No new unknown compiler, stability oracle, fast multiplier or unpriced coefficient instruction is a premise. + +Retain these mathematical source results: + +1. The literal all-input dyadic native identity and chronological finite compiler of PR #4470/#4483/#4532/#4535, including distinct productive fields, all paid jobs, owned scratch restoration, exact endpoint phase normalizers and the finite compiler majorant. The pinned #4535 certificate funds a fixed uniform provider saving q_C=0.0030201656 at N=2^(10^12). In particular P_leaf/W