Verify the balanced-J boundary against the actual native word

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 <module>\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"
+  }
+}

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.

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.