From 5cdd0ecf846e3fe9a4bf50f7fb3bb666878ed9eb Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Sun, 25 Oct 2026 02:36:22 -0500 Subject: [PATCH] Verify the balanced-J boundary against the actual native word --- .../PORTABILITY.json | 46 ++ research/balanced-j-native-word-join/PROOF.md | 190 +++++++ .../balanced-j-native-word-join/README.md | 105 ++++ .../balanced-j-native-word-join/RESULT.json | 97 ++++ .../balanced-j-native-word-join/SOURCES.json | 78 +++ .../balanced-j-native-word-join/TASK.json | 96 ++++ .../balanced-j-native-word-join/VALIDATION.md | 82 +++ .../balanced-j-native-word-join/VERIFY.json | 38 ++ .../balanced-j-native-word-join/verify.py | 500 ++++++++++++++++++ 9 files changed, 1232 insertions(+) create mode 100644 research/balanced-j-native-word-join/PORTABILITY.json create mode 100644 research/balanced-j-native-word-join/PROOF.md create mode 100644 research/balanced-j-native-word-join/README.md create mode 100644 research/balanced-j-native-word-join/RESULT.json create mode 100644 research/balanced-j-native-word-join/SOURCES.json create mode 100644 research/balanced-j-native-word-join/TASK.json create mode 100644 research/balanced-j-native-word-join/VALIDATION.md create mode 100644 research/balanced-j-native-word-join/VERIFY.json create mode 100644 research/balanced-j-native-word-join/verify.py diff --git a/research/balanced-j-native-word-join/PORTABILITY.json b/research/balanced-j-native-word-join/PORTABILITY.json new file mode 100644 index 0000000000..3fef7a6858 --- /dev/null +++ b/research/balanced-j-native-word-join/PORTABILITY.json @@ -0,0 +1,46 @@ +{ + "status": "PASS_READ_ONLY_GIT_FREE_NATIVE_JOIN_EXPORT", + "python": "Python 3.12.14", + "files": 14, + "empty_path": true, + "all_hashes_unchanged": true, + "checks": [ + { + "optimized": false, + "exit_code": 0, + "seconds": 236.686, + "stdout": "PASS_BALANCED_J_ACTUAL_NATIVE_WORD_JOIN {\"controls\": 6, \"native_events\": 21473, \"original_columns\": 632, \"owned_zero_returns\": 9}", + "stderr": "" + }, + { + "optimized": true, + "exit_code": 0, + "seconds": 215.817, + "stdout": "PASS_BALANCED_J_ACTUAL_NATIVE_WORD_JOIN {\"controls\": 6, \"native_events\": 21473, \"original_columns\": 632, \"owned_zero_returns\": 9}", + "stderr": "" + } + ], + "source_mutation": { + "mutation": "changed_Clifford_source_before_import", + "exit_code": 1, + "seconds": 0.051, + "stderr": "Traceback (most recent call last):\n File \"/tmp/balanced-j-export-4fnp_u54/research/balanced-j-native-word-join/verify.py\", line 500, in \n main()\n File \"/tmp/balanced-j-export-4fnp_u54/research/balanced-j-native-word-join/verify.py\", line 476, in main\n payloads=authenticate()\n ^^^^^^^^^^^^^^\n File \"/tmp/balanced-j-export-4fnp_u54/research/balanced-j-native-word-join/verify.py\", line 33, in authenticate\n need(sha256(raw).hexdigest() == record['sha256'],\n File \"/tmp/balanced-j-export-4fnp_u54/research/balanced-j-native-word-join/verify.py\", line 53, in need\n raise ValueError(message)\nValueError: Changed live input: research/coded-native-caller/clifford_exact.py\n", + "result": "REJECT_CHANGED_LIVE_INPUT_BEFORE_IMPORT" + }, + "file_sha256": { + "research/balanced-j-native-word-join/PROOF.md": "53745a57034a358bcfdfd40fa38bc202a5f2dfd422ff2c6e6c90d8de0ce252e5", + "research/balanced-j-native-word-join/README.md": "34a14ad76ec9cbfbf96fa9a60f95c38d0f21ffeaba86480a091c57916d89b2fc", + "research/balanced-j-native-word-join/RESULT.json": "3b02a1944a470c7c17c4f40ffcd298b326818909c5d8af77775ed819364a0e21", + "research/balanced-j-native-word-join/SOURCES.json": "0978debeedc4f22816211dd3aebebff1fb6f9010827b19668b4a6e8d4dd873ca", + "research/balanced-j-native-word-join/TASK.json": "2b1c1dde86c9fd42cf9b2e4b9469a20c1d1db4a585b715554b8cebf5976f64fe", + "research/balanced-j-native-word-join/VERIFY.json": "df031eca870047d33cacf8833616bfdf0b9296190adb204042b499b59ef9c5df", + "research/balanced-j-native-word-join/verify.py": "aa74e3634d7173694931b86669a5e28ab728080abbc91d0ba7ad8b9011c2c938", + "research/coded-native-caller/NORMALIZERS.json": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da", + "research/coded-native-caller/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "research/global120-optimistic-budget/science/inputs/10-BALANCED-J-NATIVE-v1.json": "7f26477b561114e1189d1ac7e00fd5cf5b1aea4881433619c931c12c01eb1ffd", + "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "research/native-rank8-helper-provider/PROVIDER.json": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65", + "research/native-rank8-helper-provider/WITNESS.json": "24599011da06325e1012619b2b84a4dd3aceb90ab42d3caaf6414879e7d16591", + "research/native-rank8-helper-provider/WORD.json.gz": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + } +} diff --git a/research/balanced-j-native-word-join/PROOF.md b/research/balanced-j-native-word-join/PROOF.md new file mode 100644 index 0000000000..d05521d944 --- /dev/null +++ b/research/balanced-j-native-word-join/PROOF.md @@ -0,0 +1,190 @@ +# Actual native word and balanced-J boundary join + +## Result and scope + +This audit checks the existing forward balanced-J component against the actual +coupled native word. It does not supply that construction. The native source is +from PR #5402. The fused-T packet is retained by PR #5423 and PR #5424. Its +operator is + +```text +T_s(u,v) = (D_s u - R_s v, D_s J_s v), +u=(x_112,k_8), v=(y_112,h_8), R_s=Q D_s, +J_s = [[I-W_s Z_s, -4W_s], [3Z_s, 13I_8]]. +``` + +The audit includes all 632 independent original fields. There are 240 main +fields and 392 other productive helper fields. It also includes all nine +arbitrary owned input fields and checks their zero returns. The main fields +are a joint coded endpoint. They are not credited as independent Gaussian +jobs on their original inputs. + +The native interpreter uses the retained normalized-row convention. It checks +the full actual word, not an assumed triangular matrix. The physical adapter +implementation remains a source premise. The exact Clifford check covers the +one-column physical operators. A separate sign-parity argument below proves +the field identity under the prescribed tensor lift of those operators. It +does not prove a new all-width machine compiler, precision bound or storage bill. + +## Source reconstruction and native transfer + +The verifier authenticates all seven live source files before it imports the +Clifford evaluator. It retains the exact authenticated bytes for execution. +It checks the decoded original and coupled payload pins and the eight source +site pins. It then reconstructs the coupled word from the original backward +word and the retained eight-site replacement recipe. All 21,473 records must +agree, including the unchanged physical annotations. + +Each of the 641 input fields starts with its own formal column. A row is a +finite rational linear combination of those columns with free native-map +words. ADD, SCALE, COPY and CLEAR act on the actual named rows. COPY requires +an owned zero destination. CLEAR cannot erase a persistent field. Each paid +child checks its actual entrance chart, exit chart and rank. Each zero retag +requires an identically zero row. + +A warp prepends its signed source-map name. Only adjacent inverse names cancel. +The checker reconstructs all 72 invertible maps from their full binary columns +and checks inverse-after-map on all 512 addresses. The checked bijection also +gives the reverse inverse identity. Every one of the +240 actual warp events must send its declared source-frame span to its declared +target-frame span. This check includes reused ground-frame events. + +At the native exit, every free map word cancels. No coefficient of an arbitrary +owned input remains. Every persistent chart equals the retained source exit +chart. The resulting rational transfer matrix is thus a direct consequence of +the actual word in the source convention. It is computed once and then composed +with the physical boundaries. No author-supplied provider formula is used in +place of that transfer matrix. + +This matrix composition is valid for arbitrary input functions. The native +word is linear, and its guard rows are zero on all independent original and +owned columns. Substituting an earlier operator-valued boundary in those input +columns therefore preserves the native transfer and its zero guards. It is +not necessary to repeat the same native instruction trace for each boundary. + +## Complete forward join + +The interpreter executes every primitive of the retained forward packet. +It does not replace the common K frames, the 448-entry W and Z shears, the +scalar-lowering episodes or the helper aliases by their advertised formulas. +Every monomial record must equal the prescribed lift of its actual nine-axis +source word to axes 0,9,...,16. All other axes are fixed. + +At the native call, the interpreter applies the source main wrappers, the mode +input maps, the scalar factor two and the complete input basis program. It +converts each actual physical input to its source entrance-frame coordinates. +It applies the independently computed native transfer, then restores the actual +exit-frame operators. It executes the complete output basis, cache scalars, +cache monomial maps, whole mode/cache swaps and main output wrappers. Each +swapped-out owned row is zero and is cleared. This is the concrete composition +of the source boundary with the actual native rows. + +The final comparison is derived separately from the displayed T_s identity. +It uses the actual source matrices + +```text +W_s = diag(K_port^-1) M diag(K_mode)/2, +Z_s = diag(K_mode^-1) M^T diag(K_port)/2. +``` + +Each main row is compared as a rational linear combination of exact physical +operators on independent original inputs. Every remaining helper row is +compared with its positive canonical H_r transform on its own original input. +All nine owned output rows must be zero. This is a check of all input and output +columns, not a test on selected input vectors. + +The promoted helper owners are + +```text +449,451,453,455,482,483,492,502. +``` + +The coupled mode owners are + +```text +224,225,227,229,240,241,256,257. +``` + +All these owners are distinct. The remaining helper profile is +`{4:28,7:7,8:39,9:318}`. The eight promoted H8 jobs are removed from the source's +400-helper autonomous profile. The audit gives them no second target credit. + +## Exact phases and digit-column parity + +A signed Clifford tableau determines its operator up to a scalar phase. The +checker also evaluates the exact zero column and retains one nonzero entry. +The tableau and that entry together determine the complete operator, including +its absolute phase. Rational Gaussian numerators and powers of two are exact. +No floating point is used. + +The operator table normalizes only a real sign. If an exact product satisfies +`B A = e C`, where `e` is 1 or -1 and C is a stored operator, the prescribed +f-column evaluation satisfies + +```text +B^(tensor f) A^(tensor f) = e^f C^(tensor f). +``` + +The checker therefore raises each extracted operator sign to the column parity. +It does not raise an exterior rational ADD or SCALE coefficient. In particular, +a scalar -1 from the native program stays -1 for every f. An i phase stays in +the stored operator key; it is not simplified into an exterior scalar. + +The complete join is evaluated twice in the formal span of the stored operator +keys: once for odd f and once for even f. Both final coefficient dictionaries +must equal their independently constructed target dictionaries. Each coefficient +can depend only on `e=(-1)^f`. Equality in both classes is therefore sufficient +for every positive integer f after the prescribed tensor evaluation. Additional +linear relations between evaluated keys do not weaken this sufficient test. +No equality of sums at one column is tensor-powered in this argument. The field +index remains an exterior direct-sum label. + +This argument establishes an exact field identity for that specified evaluation. +The premise that the source physical implementation realizes each columnwise +operator remains inherited. The result supplies no new implementation of the +adapters, address movement, arbitrary-width arithmetic, compiler or outer call. +The phase-only corruption control is a one-column physical rejection. It is +not a claim that an added i phase fails for every possible column count. + +## Complete component census + +The actual native paid profile is + +```text +{1:2193,2:412,3:510,4:127,5:40}. +``` + +The external boundary pays eight more H1 calls. The complete component profile +is therefore `{1:2201,2:412,3:510,4:127,5:40}`. No paid call is removed by this +audit. The native scalar census is 16,273 ADD, 1,164 SCALE, 16 COPY and 32 CLEAR. +The source boundary also has 1,644 ADD, 40 SCALE, 464 monomial field maps, +eight whole-field swaps and eight owned clears. These are in addition to the +native word, not an alternative count for it. + +The retained external packet has 960 ADD, 1,040 monomial field maps, 32 COPY, +24 whole-field swaps, 64 CLEAR, 64 zero retags and eight H1 calls. These counts +include all 800 inherited helper aliases. The audit retains every source event +and boundary operation. It does not count a physical annotation as a new free +primitive or turn these field counts into machine running times. + +No new recursive profile or alternative target invoice is proposed. The main +240-field coded endpoint has not become 240 independent Gaussian targets. A +signed-invoice comparison for such invented targets would not be valid. The +existing global caller, decoder, precision, simultaneous stock, compiler and +outer application remain separate obligations. No complete kappa gain follows. + +## Corruption controls + +Six controls exercise the joined checks. A wrong native paid rank, a deleted +owned-entry CLEAR and a reversed native warp fail actual native guards. Omitting +the second final half changes the complete output. An i phase appended to the +actual k0 post-alias keeps its signed tableau but fails the absolute-phase +endpoint. An added spectator translation fails the exact stage-word binding. +The boundary controls reuse the unchanged computed native transfer. They do not +claim an expensive independent native replay for each mutation. + +A separate source-byte mutation in the Git-free validation must fail the input +hash guard before any scientific module is imported. The normal and optimized +runs keep the inherited Clifford assertions active. New checks use explicit +errors. These checks support the written proof and are not a proof-assistant +certificate or independent human acceptance. diff --git a/research/balanced-j-native-word-join/README.md b/research/balanced-j-native-word-join/README.md new file mode 100644 index 0000000000..3f628da0e8 --- /dev/null +++ b/research/balanced-j-native-word-join/README.md @@ -0,0 +1,105 @@ +# Join the actual coupled native word to the balanced-J boundary + +This audit closes a specific verification gap in the existing forward +balanced-J component. It computes the transfer of all 21,473 actual coupled +native records, then composes every literal source and balanced-J boundary. +The comparison includes all 632 original fields, all nine arbitrary owned +inputs, all nine zero owned returns and all 392 remaining productive helpers. +The direct physical comparison uses the nine-axis one-column operators. It +verifies the existing construction in the retained source convention. It +supplies no new construction or kappa. + +The endpoint is `T_s(u,v)=(D_s u-R_s v,D_s J_s v)` on two 120-field banks, +where `J_s=[[I-W_s Z_s,-4W_s],[3Z_s,13I]]`. The new check replaces the compressed +native-ABI premise in the retained boundary replay with the independently +computed actual-word transfer. [PROOF.md](PROOF.md) states the exact scope. +[RESULT.json](RESULT.json) records the checked endpoint, counts and controls. +[SOURCES.json](SOURCES.json) pins every source and predecessor. + +Signed Clifford tableaus and exact zero-column entries retain absolute phase. +The check also keeps extracted real operator signs separate from exterior +scalar signs. It compares the full formal operator dictionaries for both odd +and even digit-column counts. This proves the field identity under the source's +prescribed tensor lift. The physical adapter implementation and its all-width +machine realization remain inherited; no new compiler or precision claim is made. + +The complete existing component pays +`{1:2201,2:412,3:510,4:127,5:40}`. Its 240 main fields remain a joint coded +endpoint. The eight promoted H8 fields lose their old autonomous target credit. +The other helper profile is `{4:28,7:7,8:39,9:318}`. All native, provider-boundary +and external ordinary counts are recorded. This audit removes no paid request +and admits no new independent main target. The selected conditional kappa at +the publication checkpoint remains 0.003027288235. + +## Reproduce + +Use Python 3.12 or later and the standard library: + +```sh +python3 -B scripts/research_package.py --package research/balanced-j-native-word-join +python3 -I -O -B research/balanced-j-native-word-join/verify.py +``` + +Expected token: `PASS_BALANCED_J_ACTUAL_NATIVE_WORD_JOIN`. +Each registered command has a 600-second limit. The default verifier is +read-only. Only `--emit` writes the mathematical receipt for authors. +All seven live inputs are authenticated before scientific imports. The inherited +Clifford evaluator keeps its assertions active in both wrapper modes. +[VALIDATION.md](VALIDATION.md) records the actual runs and remaining limits. + +The six controls cover native rank, owned-entry erasure, native warp direction, +a missing output half, a phase-only post-alias error and an unbound spectator +translation. Normalized native rows are checked on all independent original +and owned columns. Boundary equality is an exact operator comparison, not +random input testing. No inverse, selected cold replay, hosted CI, Lean proof, +new global caller or complete multiplication theorem is claimed. + +## Source and credit + +Dillon Amburgey's [PR #5402](https://github.com/CrocSwap/integer-mult-bounds/pull/5402) +supplies the coupled provider, its eight-site native replacement and its source +boundary. The original fused-T construction is retained in the +[pinned balanced-J packet](https://github.com/CrocSwap/integer-mult-bounds/blob/32890bc5de034ab8fc93ac88ead7279a6a416d04/research/global120-optimistic-budget/science/inputs/10-BALANCED-J-NATIVE-v1.json). +Its notice credits zxv's [PR #5419](https://github.com/CrocSwap/integer-mult-bounds/pull/5419) +for the cross-chart consumer and gauge, Dugongue's +[PR #4935](https://github.com/CrocSwap/integer-mult-bounds/pull/4935) for the +involutive completion, and the Dillon/Ali/native/helper/Clifford/compiler lineage. +Chris R / Clear1nsight's [PR #5423](https://github.com/CrocSwap/integer-mult-bounds/pull/5423) +adds the deferred-K overlay, while +[PR #5424](https://github.com/CrocSwap/integer-mult-bounds/pull/5424) retains the +packet and optimistic global budget. Those roles are separate from the original +fused-T construction. The deferred-K saving and the global budget are not used +to claim a gain in this audit. + +Our earlier 240-field reflection was consumed by this successor lineage. Its +matrix `H=[[I-WZ,-W],[12Z,13I]]` is related by +`J=S^-1 H S`, with `S=diag(I_112,4I_8)`. The promoted owners are identical. +This package does not republish that construction or the inverse from +[PR #5411](https://github.com/CrocSwap/integer-mult-bounds/pull/5411). + +[PR #5467](https://github.com/CrocSwap/integer-mult-bounds/pull/5467) is related +native-unit serialization work on the centre-free and uncoded sources. It is +not a consumed dependency and does not supply this coupled-word/balanced-J join. +[PR #5526](https://github.com/CrocSwap/integer-mult-bounds/pull/5526) gives general +Clifford tensor-faithfulness tests, and +[PR #5529](https://github.com/CrocSwap/integer-mult-bounds/pull/5529) sharpens native +monomial cutoffs. Neither is an executable dependency here. This audit uses a +sufficient coefficient comparison for one fixed component. It claims no general +faithfulness theorem or minimum testing cutoff. + +Retain the source notices for Cao Yifan, Cinna Davis, Dugongue, zxv, Jacob Alan +Sussman and the native/helper/Clifford, [PR #589](https://github.com/CrocSwap/integer-mult-bounds/pull/589), +geometry, COPY, compiler, precision and analytic lineage. + +Prepared for Ali Romman with substantial OpenAI Codex assistance and separate +campaign AI review. These are author-side checks. Apache-2.0; all predecessor +notices remain applicable. Publication base: +`32890bc5de034ab8fc93ac88ead7279a6a416d04`, priority revision 7. + +## Open next questions + +A complete caller still needs exact source versions, target ownership and a +favorable complete paid/target invoice. A complete machine implementation still +needs ordinary work, precision, address movement, storage and compiler funding. +[TASK.json](TASK.json) gives a first step and blocker for each question. This +package closes the bounded audit and does not start a new caller search. diff --git a/research/balanced-j-native-word-join/RESULT.json b/research/balanced-j-native-word-join/RESULT.json new file mode 100644 index 0000000000..63462d1f0e --- /dev/null +++ b/research/balanced-j-native-word-join/RESULT.json @@ -0,0 +1,97 @@ +{ + "J": "[[I-WZ,-4W],[3Z,13I]]", + "absolute_phase_method": "Signed Clifford tableau plus one nonzero entry of the exact zero column; real signs remain in rational coefficients", + "all_lifted_boundary_maps": 1040, + "arbitrary_owned_columns": 9, + "autonomous_helper_columns": 392, + "controls": [ + { + "mutation": "native_paid_rank", + "rejection": "Native paid rank" + }, + { + "mutation": "native_owned_entry_CLEAR", + "rejection": "Native destination chart" + }, + { + "mutation": "native_warp_orientation", + "rejection": "Native warp frame image" + }, + { + "mutation": "missing_second_output_half", + "rejection": "Complete endpoint differs" + }, + { + "mutation": "phase_i_after_actual_k0_post_alias", + "rejection": "Same tableau; wrong absolute phase" + }, + { + "mutation": "unbound_spectator_translation", + "rejection": "Exact25-axis source lift differs" + } + ], + "digit_column_parities_checked": [ + 1, + 0 + ], + "endpoint": "T_s(u,v)=(D_s u-R_s v,D_s J_s v); all392 other original fields are positive normalized H_r jobs", + "external": { + "ADD": 960, + "CLEAR": 64, + "COPY": 32, + "GAUSSIAN_Q": 8, + "MONOMIAL": 1040, + "PROVIDER_5402": 1, + "SWAP": 24, + "ZERO_RETAG": 64 + }, + "main_original_columns": 240, + "native_events": 21473, + "native_maps": 72, + "native_payload_sha256": "05490717144b3e6c69c0cc9e5c5df5c69d841ca13bf29aabd1b0db180628f038", + "native_scalar": { + "add": 16273, + "clear": 32, + "copy": 16, + "scale": 1164 + }, + "native_warp_events": 240, + "native_zero_guards": 8, + "new_construction": false, + "new_kappa": false, + "original_columns": 632, + "owned_zero_returns": 9, + "packet_sha256": "7f26477b561114e1189d1ac7e00fd5cf5b1aea4881433619c931c12c01eb1ffd", + "paid_complete_component": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "paid_native": { + "1": 2193, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "phase_lift_rule": "An extracted real Clifford sign is raised to the digit-column count; exterior rational coefficients are not raised.", + "physical_implementation": "Inherited source adapter and prescribed columnwise lift; no new all-width machine compiler.", + "provider_boundary_ordinary": { + "ADD": 1644, + "CLEAR": 8, + "MONOMIAL": 464, + "SCALE": 40, + "SWAP": 8 + }, + "remaining_helper_profile": { + "4": 28, + "7": 7, + "8": 39, + "9": 318 + }, + "scope": "Forward actual-word and literal balanced-J boundary join under retained normalized-row and physical-adapter premises. No inverse, new all-width compiler or global caller.", + "source_payload_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd", + "status": "PASS_BALANCED_J_ACTUAL_NATIVE_WORD_JOIN" +} diff --git a/research/balanced-j-native-word-join/SOURCES.json b/research/balanced-j-native-word-join/SOURCES.json new file mode 100644 index 0000000000..50a22c45c2 --- /dev/null +++ b/research/balanced-j-native-word-join/SOURCES.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coded-native-caller/PHYSICAL.md", + "usage": "provenance", + "git_blob": "da8837ba67423ef08ef1afb8e8297a8032aafe9f", + "sha256": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078" + }, + { + "path": "research/coded-native-caller/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/deferred-k-query-sharing-component/PROOF.md", + "usage": "provenance", + "git_blob": "9ec973a52ad67eb6fe31709961c005630c3d2190", + "sha256": "4cff7aad4cd31479bcbce7eeb23015fa6ae60bc78640756ad3dc5f39544b108d" + }, + { + "path": "research/global120-optimistic-budget/science/inputs/10-BALANCED-J-NATIVE-v1.json", + "usage": "input", + "git_blob": "74208836ea479565dd6c159e132932f75bdda117", + "sha256": "7f26477b561114e1189d1ac7e00fd5cf5b1aea4881433619c931c12c01eb1ffd" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/native-rank8-helper-provider/PROOF.md", + "usage": "provenance", + "git_blob": "5cbfc4fd02dce926c3d235f1549bdb2035dea088", + "sha256": "2d59282f3b5e9fb848d0099ce91729fa433162e6975f877a441e2ab4f57a29c5" + }, + { + "path": "research/native-rank8-helper-provider/PROVIDER.json", + "usage": "input", + "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455", + "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65" + }, + { + "path": "research/native-rank8-helper-provider/WITNESS.json", + "usage": "input", + "git_blob": "19665f9eac2238d709758e0296eb6016e71b2b1a", + "sha256": "24599011da06325e1012619b2b84a4dd3aceb90ab42d3caaf6414879e7d16591" + }, + { + "path": "research/native-rank8-helper-provider/WORD.json.gz", + "usage": "input", + "git_blob": "f3111b47e89496da8ca0ee45b2e4b258c0634d8e", + "sha256": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + } + ] +} diff --git a/research/balanced-j-native-word-join/TASK.json b/research/balanced-j-native-word-join/TASK.json new file mode 100644 index 0000000000..2d12ccc533 --- /dev/null +++ b/research/balanced-j-native-word-join/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "original_card": { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "An independent forward join of the actual coupled native word to the already published balanced-J240 boundary, including every original field, owned return, source map and exact phase.", + "scope_change_reason": "The donor authorized useful saved research publications. The240 construction was consumed by later work, so this package closes its actual-word/boundary verification gap without claiming a new construction.", + "bottleneck_link": "The retained balanced-J checker treats the native provider as a compressed ABI premise. This check computes its actual all-column native transfer and composes the literal boundary.", + "budget_minutes": null, + "stop_rule": "Finish the bounded independent joined audit and exact mutation controls. Do not add a global caller, inverse construction, new search or kappa claim.", + "outcome": "partial", + "evidence": "PROOF.md states the joined field identity and phase/column boundary. RESULT.json records complete original/owned endpoint, paid/ordinary census and corruptions.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance. Prepared by the exact-coefficient worker with separate campaign review. The existing native provider and balanced-J construction remain credited predecessors.", + "open_questions": [ + { + "question": "Can this exact component supply a complete profitable caller?", + "why_it_matters": "A component endpoint and its paid profile do not give independent main Gaussian targets or a complete recursive gain.", + "first_step": "Use a released caller scope and bind every source version, target owner and paid request to a complete invoice.", + "blocked_by": "No global caller or new target admission is supplied." + }, + { + "question": "Can the inherited physical adapter and columnwise implementation be compiled with a complete ordinary, precision and storage bill?", + "why_it_matters": "This package checks the exact field identity under that implementation premise.", + "first_step": "Compile the actual selected caller and preserve every source/boundary operation in the machine bill.", + "blocked_by": "No new all-width machine compiler or outer transfer is supplied." + } + ] +} diff --git a/research/balanced-j-native-word-join/VALIDATION.md b/research/balanced-j-native-word-join/VALIDATION.md new file mode 100644 index 0000000000..cc6ba41d1b --- /dev/null +++ b/research/balanced-j-native-word-join/VALIDATION.md @@ -0,0 +1,82 @@ +# Validation record + +Publication base: `32890bc5de034ab8fc93ac88ead7279a6a416d04`. +All seven live source files are present at that base. No predecessor file was +edited. The five other source records are historical provenance. + +## Executed scientific checks + +CPython 3.12.14 on macOS ran these commands successfully: + +```sh +python3 -I -B research/balanced-j-native-word-join/verify.py --emit +python3 -B scripts/research_package.py --package research/balanced-j-native-word-join --check-only +python3 -B scripts/research_package.py --package research/balanced-j-native-word-join +``` + +The registered normal and optimized runs each printed +`PASS_BALANCED_J_ACTUAL_NATIVE_WORD_JOIN` and matched the complete typed receipt. +Both runs together took 420.859 seconds. Each command had a 600-second limit. +Each mode checked the complete component in both digit-column sign parities, +all 632 original inputs, nine arbitrary owned inputs, all zero owned returns, +the 392 remaining helper jobs, all native and boundary counts, and six controls. +The metadata token is a source-binding check, not mathematical acceptance. + +The exact scientific files used by those runs have these SHA-256 values: + +```text +verify.py aa74e3634d7173694931b86669a5e28ab728080abbc91d0ba7ad8b9011c2c938 +RESULT.json 3b02a1944a470c7c17c4f40ffcd298b326818909c5d8af77775ed819364a0e21 +SOURCES.json 0978debeedc4f22816211dd3aebebff1fb6f9010827b19668b4a6e8d4dd873ca +VERIFY.json df031eca870047d33cacf8833616bfdf0b9296190adb204042b499b59ef9c5df +``` + +These bytes remained unchanged during final documentation and attribution work. +The final README credit clarification and these validation records required no +new scientific replay. + +## Read-only source export + +A fresh temporary export contained seven package files and seven live inputs. +It had no Git directory, an empty PATH, and read-only files and directories. +The absolute interpreter ran the direct verifier in normal and optimized modes. +They passed in 236.686 and 215.817 seconds. All 14 file hashes stayed unchanged. +[PORTABILITY.json](PORTABILITY.json) records the executions and snapshot hashes. +The README attribution paragraph was clarified after that snapshot. The verifier, +receipt, source declarations and all live inputs are the same bytes as tested. +The portability and validation records were added after the export test. + +A separate fresh-process control appended a raising statement to the exported +Clifford source. It failed with `Changed live input` before importing that +module. The statement did not execute. The source was then restored and all +snapshot hashes matched again. This is a source-custody control, separate from +the six semantic controls in the mathematical receipt. + +## Independent author-side review + +Two other campaign AI workers reviewed the exact source convention and phase +argument. The controller worker also reran the cheap raw native interpreter on +all 641 formal input columns, checked the reverse map composition on all 512 +addresses for each of the 72 maps, and reconstructed the source, provider and +external counts directly. That worker did not rerun the expensive Clifford join. +The review found no remaining scientific blocker in the stated tensor-evaluation +scope. The source-cache clears and inverse-map wording were corrected before +the final review. + +A separate direct scan checked that all 464 provider-boundary words use only +P, D, X and phase tokens. No hidden Gaussian word was counted as a monomial map. +These are author-side AI checks, not independent human or proof-kernel acceptance. + +## Limits + +The exact one-column operator check and formal parity argument are distinct +from the physical source implementation. Native phase, adapter and residual +annotations retain their source meaning; they are not flattened into a new +machine program here. The prescribed columnwise tensor implementation is an +explicit premise. There is no new inverse, decoder, Gaussian target admission, +complete caller, machine compiler, precision/stock bill or outer exponent. + +No selected-construction cold replay, Lean proof, Docker build, hosted CI or +complete multiplication theorem check ran. The standalone source-export checks +above are the cold checks for this package. The shared Git repository is shallow; +full-history source ancestry is not established by these scientific runs. diff --git a/research/balanced-j-native-word-join/VERIFY.json b/research/balanced-j-native-word-join/VERIFY.json new file mode 100644 index 0000000000..d82900179b --- /dev/null +++ b/research/balanced-j-native-word-join/VERIFY.json @@ -0,0 +1,38 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/coded-native-caller/NORMALIZERS.json", + "research/coded-native-caller/clifford_exact.py", + "research/global120-optimistic-budget/science/inputs/10-BALANCED-J-NATIVE-v1.json", + "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "research/native-rank8-helper-provider/PROVIDER.json", + "research/native-rank8-helper-provider/WITNESS.json", + "research/native-rank8-helper-provider/WORD.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Authenticate every input before importing science; reconstruct all21473 actual native records, source frame spans and all632 original plus9 owned columns; compose every balanced-J boundary with exact phases and both column parities; check all392 helper returns, complete component census and six mutations." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Repeat the complete joined check under optimized Python. The inherited Clifford engine keeps its assertions active." + } + ] +} diff --git a/research/balanced-j-native-word-join/verify.py b/research/balanced-j-native-word-join/verify.py new file mode 100644 index 0000000000..87ad706e30 --- /dev/null +++ b/research/balanced-j-native-word-join/verify.py @@ -0,0 +1,500 @@ +"""Join the actual coupled native word to the retained balanced-J boundary. + +This uses the retained normalized native-row convention and Clifford lift. +It does not flatten the physical child adapters into a new machine compiler. +""" +from collections import Counter +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +from hashlib import sha256 +import argparse +import copy +import gzip +import importlib.util +import json +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +NATIVE = 'research/native-rank8-helper-provider/' +PACKET = 'research/global120-optimistic-budget/science/inputs/10-BALANCED-J-NATIVE-v1.json' +SOURCE = 'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz' +CLIFFORD = 'research/coded-native-caller/clifford_exact.py' +NORMAL = 'research/coded-native-caller/NORMALIZERS.json' +ce = None + + +def authenticate(): + payloads = {} + for record in json.loads((HERE/'SOURCES.json').read_text())['files']: + if record['usage'] == 'input': + raw = (ROOT/record['path']).read_bytes() + need(sha256(raw).hexdigest() == record['sha256'], + 'Changed live input: '+record['path']) + payloads[record['path']] = raw + return payloads + + +def freeze(value): + return tuple(freeze(x) for x in value) if isinstance(value,(list,tuple)) else value + + +def load_clifford(payloads): + global ce + spec = importlib.util.spec_from_file_location('joined_clifford',ROOT/CLIFFORD) + ce = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = ce + exec(compile(payloads[CLIFFORD],str(ROOT/CLIFFORD),'exec',optimize=0),ce.__dict__) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def add(dst, src, factor=1): + for key, value in src.items(): + value = dst.get(key, F()) + factor*value + if value: + dst[key] = value + else: + dst.pop(key, None) + + +def literal(word): + return cached_literal(freeze(word)) + + +@lru_cache(None) +def cached_literal(word): + op = ce.ident(9) + for e in word: + kind = e[0] + if kind == 'P': part = ce.perm(9, tuple(e[1])) + elif kind == 'D': part = ce.diag(9, tuple(e[1]), tuple(e[2])) + elif kind == 'X': part = ce.xgate(9, e[1]) + elif kind == 'C': part = ce.cgate(9, e[1], e[2]) + elif kind == 'phase': part = ce.Op(9, ce.identity(9), [('phase', e[1])]) + else: raise ValueError('Unknown Clifford word') + op = op.then(part) + return op + + +class Operators: + """Exact Clifford keys include an absolute phase, up to a real sign.""" + def __init__(self): + self.ops, self.keys, self.products, self.by_circuit = [], {}, {}, {} + self.parity = 1 + need(self.insert(ce.ident(9)) == (0, 1), 'Identity key') + + def insert(self, op): + literal_key = (op.tab, freeze(op.circuit)) + if literal_key in self.by_circuit: + return self.by_circuit[literal_key] + state, den = op.zero_state() + at = next(j for j, z in enumerate(state) if z != (0,0)) + a, b = state[at] + sign = -1 if a < 0 or (a == 0 and b < 0) else 1 + key = (op.tab, at, F(sign*a,1<> j & 1: + result ^= columns[j] + return result + + +def warp_maps(c): + maps = {} + for item in c['warps']: + columns = item['G_columns'] + need(len(columns) == 9 and len(span(columns)) == 512,'Invertible native map') + inverse = [next(x for x in range(512) if apply_columns(columns,x) == 1<= 632, 'No persistent erasure') + rows[dst], charts[dst] = {}, chart + else: + need(charts[dst] == chart, 'Native destination chart') + if kind in ('add','copy'): + src = address(gate[2]) + need(charts[src] == chart and src != dst, 'Native source chart and alias') + if kind == 'copy': + need(dst >= 632 and not rows[dst], 'Native COPY uses owned zero') + rows[dst] = dict(rows[src]) + else: + add(rows[dst],rows[src],F(gate[3],gate[4])) + else: + need(kind == 'scale' and gate[2] != 0, 'Native nonzero SCALE') + rows[dst] = {key:F(gate[2],gate[3])*a for key,a in rows[dst].items()} + elif e[0] == 'warp': + _, ref, symbol, before, after = e + dst = address(ref) + need(charts[dst] == before, 'Native warp chart') + need(symbol in maps and span(apply_columns(maps[symbol],x) for x in c['frames'][before]) + == span(c['frames'][after]),'Native warp frame image') + out = {} + for (owner, tail), a in rows[dst].items(): + tail = tail[1:] if tail and tail[0] == -symbol else (symbol,)+tail + add(out,{(owner,tail):a}) + rows[dst], charts[dst] = out, after + elif e[0] == 'climb': + _, _, dst, before, after, rank = e + need(charts[dst] == before, 'Native child input chart') + need(rank == len(c['frames'][after])-len(c['frames'][before]) > 0, 'Native paid rank') + charts[dst] = after; paid[rank] += 1 + elif e[0] == 'zero_retag': + _, dst, before, after = e + need(charts[dst] == before and not rows[dst], 'Native zero-retag guard') + charts[dst] = after; zero_checks += 1 + else: + need(e[0] in ('phase','adapter','residual_adapter'), 'Inherited physical annotation') + need(charts[:632] == c['final'], 'Every persistent native exit chart') + need(all(not tail and owner < 632 for row in rows for owner,tail in row), 'Every free native word cancels; arbitrary owned input is absent') + return [{owner:a for (owner,_),a in row.items()} for row in rows], charts, paid, scalar, zero_checks + + +def lift(word, active): + def mask(value):return sum(1<>j&1) + out=[] + for e in word: + if e[0]=='P': + cols=[1<=632,'Boundary erases only owned') + rows[slot]={};tags[event['field']]=None;cleared=event['field'] + elif op=='ZERO_RETAG': + field=event['field'];need(field==cleared and not rows[names[field]],'Retag immediately cleared owned field') + chart=event['chart'] + tags[field]=tags[chart.removeprefix('exact current frame of ')] if chart!='ground' else 'ground' + cleared=None + elif op=='COPY': + dst,src=names[event['dst']],names[event['src']] + need(dst>=632 and not rows[dst] and tags[event['dst']]==tags[event['src']],'Boundary COPY actual owned zero/chart') + rows[dst]=dict(rows[src]) + elif op=='ADD': + dst,src=names[event['dst']],names[event['src']] + need(dst!=src and F(event['coefficient']) in (1,-1,F(1,2),F(-1,2)),'Literal ADD coefficient') + add(rows[dst],rows[src],F(event['coefficient'])) + elif op=='SWAP': + a,b=event['fields'];need(event['includes_chart'] is True,'Whole-field/chart swap') + x,y=names[a],names[b];rows[x],rows[y]=rows[y],rows[x];tags[a],tags[b]=tags[b],tags[a] + elif op=='GAUSSIAN_Q': + need(event['axis']==0 and event['rank']==1 and event['sign']==1 and event['paid'] is True,'Actual paid common Q') + physical(names[event['field']],ce.cgate(9,1)) + elif op=='PROVIDER_5402':provider_call() + else:raise ValueError('Unknown boundary primitive '+op) + need(dict(external)==packet['forward_counts'],'All literal boundary counts') + need(all(not row for row in rows[632:]),'All9 final owned fields zero') + original=[{(j,0):F(1)} for j in range(641)] + R,D=ce.fourier(9),ce.fourier(9,range(1,9)) + Kp=[literal(port['K_word']) for port in normal['ports']] + Km=[literal(record['input_K']['literal_word']) for record in provider['mode_boundaries']] + M=normal['mode_columns'] + def Z(bank): + out=[{} for _ in range(8)] + for k in range(8): + for j in range(112): + if M[k][j]:add(out[k],pool.apply(bank[j],Kp[j].then(Km[k].adjoint())),F(M[k][j],2)) + return out + def W(bank): + out=[{} for _ in range(112)] + for k in range(8): + for j in range(112): + if M[k][j]:add(out[j],pool.apply(bank[k],Km[k].then(Kp[j].adjoint())),F(M[k][j],2)) + return out + y=[dict(original[112+j]) for j in range(112)];h=[dict(original[j]) for j in mode] + zy=Z(y);wzy=W(zy);wh=W(h) + expected=[{} for _ in range(641)] + for j in range(112): + expected[j]=pool.apply(original[j],D);add(expected[j],pool.apply(original[112+j],R),-1) + jy=dict(y[j]);add(jy,wzy[j],-1);add(jy,wh[j],-4) + expected[112+j]=pool.apply(jy,D) + for k,owner in enumerate(promoted): + expected[owner]=pool.apply(original[owner],D);add(expected[owner],pool.apply(h[k],R),-1) + jh={};add(jh,zy[k],3);add(jh,h[k],13) + expected[mode[k]]=pool.apply(jh,D) + for j in range(224,632): + if j not in mode+promoted: + rank=len(c['frames'][c['final'][j]])-len(c['frames'][c['start'][j]]) + expected[j]=pool.apply(original[j],ce.fourier(9,range(rank))) + need(rows == expected, 'Complete632-original/9-owned endpoint in digit-column parity '+str(parity)) + controls = [] + def reject(label, action, messages): + try: + action() + except ValueError as error: + need(str(error) in messages,'Wrong rejection for '+label+': '+str(error)) + controls.append({'mutation':label,'rejection':str(error)}) + else: + raise ValueError('Mutation admitted: '+label) + bad = copy.deepcopy(native) + next(e for e in bad if e[0] == 'climb')[-1] += 1 + reject('native_paid_rank',lambda:raw_transfer(bad,c,maps),{'Native paid rank'}) + first_clear = next(i for i,e in enumerate(native) if e[0]=='scalar' and e[1][0]=='clear') + bad = native[:first_clear]+native[first_clear+1:] + reject('native_owned_entry_CLEAR',lambda:raw_transfer(bad,c,maps), + {'Native destination chart','Native source chart and alias','Native COPY uses owned zero'}) + bad = copy.deepcopy(native) + event = next(e for e in bad if e[0]=='warp' and c['frames'][e[3]] and e[3]!=e[4]) + event[2] *= -1 + reject('native_warp_orientation',lambda:raw_transfer(bad,c,maps),{'Native warp frame image'}) + need(before_last_half is not None and before_last_half != expected,'Missing second output half must fail') + controls.append({'mutation':'missing_second_output_half','rejection':'Complete endpoint differs'}) + post = next(seg for seg in packet['forward_segments'] if seg['label']=='forward_alias_post') + post_k = next(e for e in post['operations'] if e['field']=='k0') + need(post_k['source_owner']==promoted[0],'Phase control is on actual promoted owner') + phase = ce.Op(9,ce.identity(9),[('phase',1)]) + need(phase.tab == ce.identity(9),'Phase-only control has unchanged signed tableau') + need(pool.apply(rows[promoted[0]],phase) != expected[promoted[0]],'Wrong absolute phase must fail') + controls.append({'mutation':'phase_i_after_actual_k0_post_alias','rejection':'Same tableau; wrong absolute phase'}) + bad_lift = copy.deepcopy(post_k) + bad_lift['word'].append(['X',2]) + need(bad_lift['word'] != lift(bad_lift['source_word9'],packet['stage_geometry']['source9_to_stage_axes']), + 'Spectator mutation must fail exact lift') + controls.append({'mutation':'unbound_spectator_translation','rejection':'Exact25-axis source lift differs'}) + need(guards==8 and len(native)==21473 and dict(scalar)==provider['source_changed_scalar_counts'], + 'Full native event, zero-guard and scalar census') + need(len({j for j in mode+promoted})==16 and len(expected)==641,'Independent original ownership') + helper_profile=Counter(len(c['frames'][c['final'][j]])-len(c['frames'][c['start'][j]]) + for j in range(224,632) if j not in mode+promoted) + need(helper_profile==Counter({4:28,7:7,8:39,9:318}),'Every remaining productive helper') + need(boundary==Counter({'ADD':1644,'SCALE':40,'MONOMIAL':464,'SWAP':8,'CLEAR':8}),'Loop-derived provider boundary census') + complete_paid=paid+Counter({1:external['GAUSSIAN_Q']}) + return {'status':'PASS_BALANCED_J_ACTUAL_NATIVE_WORD_JOIN', + 'source_payload_sha256':sha256(source_payload).hexdigest(), + 'native_payload_sha256':sha256(native_payload).hexdigest(), + 'packet_sha256':sha256(payloads[PACKET]).hexdigest(), + 'native_events':len(native),'native_warp_events':sum(e[0]=='warp' for e in native), + 'native_maps':72,'native_zero_guards':guards,'original_columns':632, + 'main_original_columns':240,'autonomous_helper_columns':392,'arbitrary_owned_columns':9, + 'owned_zero_returns':9,'paid_native':dict(sorted(paid.items())), + 'paid_complete_component':dict(sorted(complete_paid.items())), + 'native_scalar':dict(sorted(scalar.items())), + 'provider_boundary_ordinary':dict(sorted(boundary.items())), + 'external':dict(sorted(external.items())), + 'remaining_helper_profile':dict(sorted(helper_profile.items())), + 'endpoint':'T_s(u,v)=(D_s u-R_s v,D_s J_s v); all392 other original fields are positive normalized H_r jobs', + 'J':'[[I-WZ,-4W],[3Z,13I]]','all_lifted_boundary_maps':1040, + 'absolute_phase_method':'Signed Clifford tableau plus one nonzero entry of the exact zero column; real signs remain in rational coefficients', + 'controls':controls,'digit_column_parity':parity,'new_construction':False,'new_kappa':False, + 'scope':'Forward actual-word and literal balanced-J boundary join under retained normalized-row and physical-adapter premises. No inverse, new all-width compiler or global caller.'} + + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--emit',action='store_true',help='Write the mathematical receipt for package authors.') + args=parser.parse_args() + payloads=authenticate() + load_clifford(payloads) + pool=Operators() + odd=run(payloads,pool,1) + even=run(payloads,pool,2) + need({k:v for k,v in odd.items() if k!='digit_column_parity'} == + {k:v for k,v in even.items() if k!='digit_column_parity'},'Identical scientific census in both parity classes') + result={k:v for k,v in odd.items() if k!='digit_column_parity'} + result['digit_column_parities_checked']=[1,0] + result['phase_lift_rule']='An extracted real Clifford sign is raised to the digit-column count; exterior rational coefficients are not raised.' + result['physical_implementation']='Inherited source adapter and prescribed columnwise lift; no new all-width machine compiler.' + text=json.dumps(result,sort_keys=True,indent=2)+'\n' + target=HERE/'RESULT.json' + if args.emit: + target.write_text(text) + else: + saved=json.loads(target.read_text()) + need(text==json.dumps(saved,sort_keys=True,indent=2)+'\n','Saved typed result differs') + print(result['status'],json.dumps({'native_events':result['native_events'], + 'original_columns':result['original_columns'],'owned_zero_returns':result['owned_zero_returns'], + 'controls':len(result['controls'])},sort_keys=True)) + + +if __name__=='__main__': + main()