From f22626f334a06f6e842766e4a6647419e6821d2d Mon Sep 17 00:00:00 2001 From: Adam Gall Date: Wed, 14 Oct 2026 15:11:37 -0400 Subject: [PATCH] Prove the native P104 channel's local precision interface --- research/p104-native-precision/README.md | 280 ++ research/p104-native-precision/RESULT.json | 2434 +++++++++++++++++ research/p104-native-precision/SELECTION.json | 91 + research/p104-native-precision/SOURCES.json | 80 + research/p104-native-precision/TASK.json | 104 + research/p104-native-precision/VERIFY.json | 38 + research/p104-native-precision/test_verify.py | 86 + research/p104-native-precision/verify.py | 438 +++ 8 files changed, 3551 insertions(+) create mode 100644 research/p104-native-precision/README.md create mode 100644 research/p104-native-precision/RESULT.json create mode 100644 research/p104-native-precision/SELECTION.json create mode 100644 research/p104-native-precision/SOURCES.json create mode 100644 research/p104-native-precision/TASK.json create mode 100644 research/p104-native-precision/VERIFY.json create mode 100755 research/p104-native-precision/test_verify.py create mode 100755 research/p104-native-precision/verify.py diff --git a/research/p104-native-precision/README.md b/research/p104-native-precision/README.md new file mode 100644 index 0000000000..e78d40f380 --- /dev/null +++ b/research/p104-native-precision/README.md @@ -0,0 +1,280 @@ +# A source-bound precision interface for the native P104 channel + +**Finite local precision theorem; no side correction, admitted supplier or new κ.** +For the literal native channel of [PR1991](https://github.com/CrocSwap/integer-mult-bounds/pull/1991), +this package bounds every instruction boundary, including arbitrary dirty +helpers and the eight owned private-copy lifetimes. It supplies the following +missing local implication, rather than another compilation of the channel. + +Let `B` bound the Hilbert norm of each of the 280 independent input roles. +All norms below are **the maximum of individual register Hilbert norms**, not +the pointwise maximum over addresses and not a concatenated 280-register norm. + +| Exact finite-word quantity | Bound | First attaining location | +|---|---:|---| +| Ideal input-to-prefix row norm | **106** | after event 2464, `D0` | +| Accumulation of independent unit absolute defects at every update | **450** | after event 4057, `Q7` | +| Accumulation with scalar-add weight `1+abs(a)`, other update weights 1 | **668** | after event 4057, `Q7` | + +Event numbers are zero-based in the immutable predecessor witness. The first +two bounds are sharp under the stated independent-input/defect contracts. +The third is a sharp *weighted independent-defect* coefficient; its use in +state-relative feedback below is sufficient, not an attained rounding error. +The ideal endpoint bound is only 26, and exact dirty restoration does **not** +mean error-free dirty restoration. + +## Native and error contracts + +The exact source has 4,058 events: 1,410 positive-child transports, 2,624 scalar +additions, eight copies, eight exact owned-zero allocations and eight owned +discards. Put one independent additive defect immediately after each transport, +addition and copy: **4,042 defect sites**. Allocation is exact zero; discard has +no retained output. Intrinsic monomial adapters and address/phase factors are +exact. A defect inside an actual recursive child must first be bounded at that +child's completed output; this package does not analyze its internal algorithm. + +This is a **normalized native** contract, not an assumption that an arbitrary +recursive matrix is contractive. The retained physical primitive is + +``` +C_q = ((1+i)I + (1-i)X_q)/2, q != 0, +F_r = C_e0 ... C_e(r-1). +``` + +`X_q` is a self-adjoint involutive permutation. On its `+1/-1` eigenspaces, +`C_q` has eigenvalues `1` and `i`; its inverse has eigenvalues `1` and `-i`. Hence both +have Hilbert operator norm exactly one. The canonical charts and each native +recipe consist of these normalized factors, invertible binary address +permutations, translations and diagonal Gaussian unit phases. They, and all +of their exact factor prefixes, are unitary. The checker validates their actual +gate domains and binds all **740 transport recipes / 1,410 occurrences** and +**208 monomial adapters** to the source word. It compares signed Pauli actions, +exact scalar phase and **948 normalized Gaussian columns**, using the pinned +independent interpreter, not the Clifford compiler. + +These checks establish the concrete operator normalization being used. They +do not prove a numerical implementation of a child meets the error contract. +The normalization control rejects omitting the `1/2`. A separate exact example +`C_1(e_0+i e_1)=(1+i)e_0` shows why these operators are **not** contractions in +the addresswise maximum norm. A phase-only change preserves norms but fails +exact operator equality; a norm estimate cannot authenticate phases. + +## Proof of the precision implication + +### 1. Frame conjugation reduces defects to the literal scalar word + +At a source instruction cut, write the physical value of register `r` as +`Gamma_(W_r) z_r`, where `Gamma_(W_r)` is its actual canonical unitary chart. +The native transport checks give exactly +`Gamma_new Gamma_old^-1`; a transport changes the chart, not the logical row. +An addition uses a common chart and performs `z_dst += a z_src`. A private +copy creates a new logical row from its source; its eight different lifetimes +are never identified. The pinned exact endpoint map is independently checked +against the E8 roots: + +``` +X_s -> X_s, +Y_t -> Y_t + sum_s X_s/2, +all 72 dirty helpers -> their own arbitrary initial values. +``` + +For a physical additive error `e_j` after event `j`, define +`eta_j = Gamma_(W_after_j)^-1 e_j`. Unitarity gives +`||eta_j||_2 = ||e_j||_2`. Linearity then gives, at **every** subsequent cut, + +``` +z_r = sum_s A_(r,s) z_s_initial + sum_j c_(r,j) eta_j. +``` + +The coefficients are the exact rational rows of the literal scalar program. +They retain signs until each row norm is evaluated. A discard removes its +private current row, but not any error already propagated from that private +row to a delivery or target register. An unrelated later allocation gets fresh +error symbols. No dirty input is assumed zero. + +### 2. Exact norms, sharpness and finite coverage + +For independent input vectors bounded by `B`, the first sum has norm at most +`B sum_s |A_(r,s)|`. For independent error vectors bounded by `delta_j`, the +second has norm at most `sum_j |c_(r,j)| delta_j`. Both inequalities are sharp +for a fixed row: choose any unit vector `v` and choose each logical input/error +as the sign of its row coefficient times `v` and the permitted magnitude. +Use `Gamma_(W_after_j)` to turn that logical defect into a physical defect of +the same norm. Thus the sharpness assertion is about independent arbitrary +additive vector defects, **not** the correlated errors of a rounding algorithm. + +The exact forward replay maintains all input and error symbols after every +update. Initial, zero and discard boundaries cannot increase these maxima; +therefore the 4,042 changed-register rows cover all 4,059 instruction boundaries +including the initial boundary, and every live role at each boundary. Complete +coefficient and norm streams are hashed in `RESULT.json`, not sampled. A reverse +adjoint recurrence, implemented separately, agrees on all **62,867 nonzero +signed endpoint-response coefficients** and on the entire arbitrary-input map. +Constructive forward executions attain the three displayed maxima. + +The complete endpoint row table is in [RESULT.json](RESULT.json): + +| Final role class | Native defects only | Scalar defects only | Copy defects only | All unit absolute defects | Weighted defects | +|---|---:|---:|---:|---:|---:| +| 104 sources | 7 | 0 | 0 | 7 | 7 | +| 104 targets | 711/4 | 110 | 3/2 | 1153/4 | 1847/4 | +| 72 dirty helpers | 336 | 114 | 1 | 450 | 668 | + +Column maxima can have different attaining roles; do not add column maxima to +claim an exact joint maximum. The two rightmost columns are calculated directly +from each complete row. For equal absolute defect bound `delta`, every live +role at every boundary has error at most **450 delta**, sharply. In particular, +`delta <= B 2^(-b-9)` is sufficient for error at most `B 2^-b` everywhere. + +There is a concrete endpoint/interior distinction even with scalar arithmetic +exact: native-only defects have sharp **all-cut coefficient 356**, at event +3962 in `Q6`, versus final all-role coefficient **336**. Thus an endpoint-only +native sensitivity understates the interior error required by feedback. + +### 3. State-relative errors require feedback, not only endpoint sensitivity + +Suppose a common `u >= 0` satisfies the following local hypotheses on the +**actual perturbed operands**, with exact dyadic scalar coefficients: + +- transport output defect: at most `u ||actual input||_2`; +- copy output defect: at most `u ||actual source||_2`; +- `dst += a src` defect: at most + `u (||actual dst before||_2 + |a| ||actual src before||_2)`. + +Let `M` be the maximum actual register norm across all instruction boundaries. +The event error bounds are at most `u M w_j`, with `w_j=1+|a|` for additions +and `w_j=1` otherwise. The exact weighted all-cut coefficient 668 gives + +``` +M <= 106 B + 668 u M. +``` + +For `668 u < 1`, this proves the finite-word guard + +``` +M <= 106 B / (1 - 668 u), +max_boundary_error <= 106 * 668 * u * B / (1 - 668 u). +``` + +There is no unproved bootstrap: the finite execution defines `M`, the +instruction error premises hold at those actual operands, and the inequality +can be rearranged under the explicit strict guard. For a particular final +role replace the numerator's `668` by that role's weighted coefficient, while +keeping **668 in the denominator**. In particular the target numerator is +`106*(1847/4)u B`, but dirty helpers still require `106*668u B`. + +For every integer `b >= 0`, **`u <= 2^(-b-17)` suffices** for all-role error +`<= B 2^-b`. Indeed, `668(106*2^b+1) <= 2^(b+17)` since +`106*668=70,808` and `70,808+668 < 131,072`. Sixteen uniform guard bits do not +satisfy this particular all-role sufficient bound even in the limit: +`70,808 > 65,536`. This does **not** establish minimal numerical precision. +Target-only accuracy can use a smaller numerator, but must not be substituted +for arbitrary-dirty restoration or all-cut stability. + +The contract is dimension independent once unitary charts and the identical +scalar word are available. Only the concrete nine-coordinate/512-address native +realization is source-checked here. No physical all-size lift follows merely +from the abstract Hilbert-space argument. + +## Accounting, scope and predecessors + +The local paid profile is unchanged: +`1074 H1 + 58 H2 + 86 H3 + 104 H4 + 48 H5 + 24 H6 + 8 H7 + 8 H8`, +rank mass **2368 = 2312 boundary coverage + COPY56**. No new primitive is +inserted, and no recursive precision charge is removed. Correction, global +idle/owner costs, actual rounded child contracts and all-size/tape admission +are not supplied, so there is no completed supplier moment or κ claim. + +[PR1972](https://github.com/CrocSwap/integer-mult-bounds/pull/1972), head +`fd82d172f46933fd253c2c6de4bd5eaff5429cfd`, supplies the entire scalar/frame +channel. PR1991, reviewed at `6e222517e182e98499239bc9a4009f540e1c5520`, +supplies the concrete native recipes and explicitly leaves recursive precision +open. This contribution supplies the **finite local error-transfer premise**, +not the complete recursive-precision obligation. The same channel and all +predecessor attribution are retained unchanged. + +This is distinct from [PR2067](https://github.com/CrocSwap/integer-mult-bounds/pull/2067): +that result proves an all-size endpoint recurrence for complete PR628 balanced +word leaves. Here the object is the actual 4,058-event P104 word; native +normalization, every instruction cut, private lifetimes and source/helper/target +error distinctions are essential. The selected1094 wire-prefix and dirty-prefix +monomial audits supply useful norm-method precedents on different words; no +constant or proof from those words is transplanted. Active terminal correction +work in [Discussion2080](https://github.com/CrocSwap/integer-mult-bounds/discussions/2080) +is separate and not consumed or certified here. + +## Reproduce + +Standard-library CPython 3.12, from the repository root: + +```sh +uv run --python 3.12 --no-project python -I -O -B research/p104-native-precision/verify.py +uv run --python 3.12 --no-project python -I -O -B research/p104-native-precision/test_verify.py +uv run --python 3.12 --no-project python scripts/research_package.py --package research/p104-native-precision +``` + +Default replay is read-only. `verify.py --write /new/path.json` writes a new +receipt exclusively; canonical parsed payloads, not compression headers, are +compared. All external bytes are authenticated **before** interpreter import. +The registered replay includes native/phase/normalization checks, arbitrary-input +and reverse sensitivity identities, constructive sharpness, semantic controls, +a dense rational defect execution, individual native-rank/private-lifetime +impulses and an optimized read-only export with a corrupted-source rejection. +No formal kernel, selected cold replay or hosted CI result is claimed. + +Observed locally on CPython 3.12/macOS arm64: the scientific receipt generation +passed, followed by the complete registered replay (13.25 seconds): + +```text +PASS_P104_NATIVE_PRECISION input=106 absolute=450 relative=668 guard_bits=17 native_recipes=740 endpoint_coefficients=62867 controls=13 no_new_kappa +PASS_P104_NATIVE_PRECISION_TESTS dense_defects=4042 independent_impulses=18 source_drift=reject read_only_optimized_export=pass +PASS_REGISTERED_RESEARCH_PACKAGE research/p104-native-precision outcome=completed +``` + +## Provenance and freshness + +Scientific base: `564148b82ae9df72163f22106f15e73efca8aff2`; priority revision 4. +Independent chooser nonce: `1be10fd8d275206692a433be1dacd810`, complex-mechanisms. +[SELECTION.json](SELECTION.json) preserves the complete sole draw. +[TASK.json](TASK.json) explicitly records the changed card obligation and limits; +[SOURCES.json](SOURCES.json) pins each consumed source. The latest inspected +canonical checkpoint `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2` changes guidance +only; catalogue and scientific inputs are unchanged. The scientific base stays +immutable. + +The shared refreshed search at 2026-10-14 19:02:09Z covered 353 open PRs including +drafts, 738 discussion/comment/reply records and 1,536 local records, with +complete remote pagination. Targeted live PR1991/PR2067 and Discussion2080, +and local norm predecessors, were read. These metadata searches do not cover +all code or the literature and do not prove novelty. No separate discussion +post or comment was made for this investigation; its claim/result are in the +package and the self-contained PR. + +## Open next questions + +1. **Bound an actual rounded recursive child.** The present theorem consumes + a completed-child Hilbert-norm defect bound. Bind the selected primitive's + precision convention to that norm and exercise its rounded implementation + at P104's ranks. The unresolved blocker is that implementation/interface, + not another scalar norm estimate. +2. **Compose a corrected P104 word.** Once an exact chronological `I-G/2` word + is available, bind its source and replay the combined prefix/error maps. + This is necessary because the current channel is only `G/2`; a separate + correction's endpoint error bound cannot silently replace combined + interior and dirty-restoration bounds. +3. **Global physical hosting and precision.** Transport actual owner-family + magnitude bounds through completed calls, keeping helper residual errors. + A globally admitted corrected owner schedule and its all-size precision/tape + contracts are still missing. + +## Credit + +Prepared by Adam Gall with substantial OpenAI Codex assistance in research, +proof, code, verification and writing. No independent human or formal review +is claimed. Rohan Arun/PR1972 supplies the scalar word; Chafik Boukhalfa/PR1991 +supplies its native realization; Adam Gall/PR1940 supplies the schedule; Josie +Elliston/PR1071 and Ali Romman/PR1125 supply the fixture/delivery lineage. +The exact compiler descends from icekylinx's Clifford work; the retained +independent Gaussian interpreter is Ali Romman's PR1862/PR1931 lineage. +Existing notices remain in the unchanged predecessor package. New material +is Apache-2.0 under the repository license. diff --git a/research/p104-native-precision/RESULT.json b/research/p104-native-precision/RESULT.json new file mode 100644 index 0000000000..ebba0b1cf6 --- /dev/null +++ b/research/p104-native-precision/RESULT.json @@ -0,0 +1,2434 @@ +{ + "all_cut_coefficients_sha256": "32d0923af6df7c2411bc408f9eadb4ec7c6e692191b73a707e67fe8ac0f5afa4", + "all_cut_count": 4042, + "all_cut_norms_sha256": "a072205c71c197034d7d5a19f3d42f9f89e94189a511801f2deb2bee8b016940", + "all_cut_peaks": { + "absolute": { + "attaining_row_sha256": "478c9cd44ce6ec0484f82129b79ef4e540a7f95e0a7e705fc7c23def3f67970f", + "event": 4057, + "register": "Q7", + "value": "450" + }, + "input": { + "attaining_row_sha256": "404cecc6eb3efb6fed156c4b477543b6d7cb8f0bf2c18a5d1679f333501af812", + "event": 2464, + "register": "D0", + "value": "106" + }, + "relative": { + "attaining_row_sha256": "478c9cd44ce6ec0484f82129b79ef4e540a7f95e0a7e705fc7c23def3f67970f", + "event": 4057, + "register": "Q7", + "value": "668" + } + }, + "all_cut_type_peaks": { + "add": { + "event": 3693, + "register": "Q0", + "value": "114" + }, + "copy": { + "event": 3432, + "register": "Y55", + "value": "3/2" + }, + "transport": { + "event": 3962, + "register": "Q6", + "value": "356" + } + }, + "controls": [ + "attained_input", + "attained_absolute", + "attained_relative", + "endpoint_only_input_cap_rejected", + "error_free_dirty_restoration_rejected", + "discard_erases_prior_output_errors_rejected", + "missing_initial_compensation", + "missing_final_cleanup", + "private_lifetime_alias", + "unnormalized_native_child_rejected", + "pointwise_contraction_rejected", + "norm_only_phase_blindness_exhibited", + "relative_feedback_and_guard_boundary" + ], + "defect_sites": { + "add": 2624, + "copy": 8, + "transport": 1410 + }, + "endpoint_group_maxima": { + "dirty_helper": { + "absolute": { + "attainers": [ + "Q7" + ], + "value": "450" + }, + "add": { + "attainers": [ + "Q0", + "Q7" + ], + "value": "114" + }, + "copy": { + "attainers": [ + "D0", + "D1", + "D10", + "D11", + "D12", + "D13", + "D14", + "D15", + "D16", + "D17", + "D18", + "D19", + "D2", + "D20", + "D21", + "D22", + "D23", + "D24", + "D25", + "D26", + "D27", + "D28", + "D29", + "D3", + "D30", + "D31", + "D4", + "D5", + "D6", + "D7", + "D8", + "D9" + ], + "value": "1" + }, + "relative": { + "attainers": [ + "Q7" + ], + "value": "668" + }, + "transport": { + "attainers": [ + "Q7" + ], + "value": "336" + } + }, + "source": { + "absolute": { + "attainers": [ + "X1", + "X12", + "X14", + "X3", + "X41", + "X46", + "X54", + "X6", + "X7", + "X74", + "X81", + "X83" + ], + "value": "7" + }, + "add": { + "attainers": [ + "X0", + "X1", + "X10", + "X100", + "X101", + "X102", + "X103", + "X11", + "X12", + "X13", + "X14", + "X15", + "X16", + "X17", + "X18", + "X19", + "X2", + "X20", + "X21", + "X22", + "X23", + "X24", + "X25", + "X26", + "X27", + "X28", + "X29", + "X3", + "X30", + "X31", + "X32", + "X33", + "X34", + "X35", + "X36", + "X37", + "X38", + "X39", + "X4", + "X40", + "X41", + "X42", + "X43", + "X44", + "X45", + "X46", + "X47", + "X48", + "X49", + "X5", + "X50", + "X51", + "X52", + "X53", + "X54", + "X55", + "X56", + "X57", + "X58", + "X59", + "X6", + "X60", + "X61", + "X62", + "X63", + "X64", + "X65", + "X66", + "X67", + "X68", + "X69", + "X7", + "X70", + "X71", + "X72", + "X73", + "X74", + "X75", + "X76", + "X77", + "X78", + "X79", + "X8", + "X80", + "X81", + "X82", + "X83", + "X84", + "X85", + "X86", + "X87", + "X88", + "X89", + "X9", + "X90", + "X91", + "X92", + "X93", + "X94", + "X95", + "X96", + "X97", + "X98", + "X99" + ], + "value": "0" + }, + "copy": { + "attainers": [ + "X0", + "X1", + "X10", + "X100", + "X101", + "X102", + "X103", + "X11", + "X12", + "X13", + "X14", + "X15", + "X16", + "X17", + "X18", + "X19", + "X2", + "X20", + "X21", + "X22", + "X23", + "X24", + "X25", + "X26", + "X27", + "X28", + "X29", + "X3", + "X30", + "X31", + "X32", + "X33", + "X34", + "X35", + "X36", + "X37", + "X38", + "X39", + "X4", + "X40", + "X41", + "X42", + "X43", + "X44", + "X45", + "X46", + "X47", + "X48", + "X49", + "X5", + "X50", + "X51", + "X52", + "X53", + "X54", + "X55", + "X56", + "X57", + "X58", + "X59", + "X6", + "X60", + "X61", + "X62", + "X63", + "X64", + "X65", + "X66", + "X67", + "X68", + "X69", + "X7", + "X70", + "X71", + "X72", + "X73", + "X74", + "X75", + "X76", + "X77", + "X78", + "X79", + "X8", + "X80", + "X81", + "X82", + "X83", + "X84", + "X85", + "X86", + "X87", + "X88", + "X89", + "X9", + "X90", + "X91", + "X92", + "X93", + "X94", + "X95", + "X96", + "X97", + "X98", + "X99" + ], + "value": "0" + }, + "relative": { + "attainers": [ + "X1", + "X12", + "X14", + "X3", + "X41", + "X46", + "X54", + "X6", + "X7", + "X74", + "X81", + "X83" + ], + "value": "7" + }, + "transport": { + "attainers": [ + "X1", + "X12", + "X14", + "X3", + "X41", + "X46", + "X54", + "X6", + "X7", + "X74", + "X81", + "X83" + ], + "value": "7" + } + }, + "target": { + "absolute": { + "attainers": [ + "Y93" + ], + "value": "1153/4" + }, + "add": { + "attainers": [ + "Y26", + "Y27", + "Y66", + "Y67", + "Y90", + "Y97" + ], + "value": "110" + }, + "copy": { + "attainers": [ + "Y103", + "Y26", + "Y27", + "Y31", + "Y33", + "Y55", + "Y62", + "Y66", + "Y67", + "Y90", + "Y93", + "Y97" + ], + "value": "3/2" + }, + "relative": { + "attainers": [ + "Y93" + ], + "value": "1847/4" + }, + "transport": { + "attainers": [ + "Y93" + ], + "value": "711/4" + } + } + }, + "endpoint_response_nonzeros": 62867, + "endpoint_responses_sha256": "964481cce5e4d0ab723da5d9ef54be3f33a4bcba36cfe986b0dd43cd1b5766b6", + "endpoint_rows": { + "D0": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D1": { + "absolute": "12", + "add": "2", + "copy": "1", + "relative": "14", + "transport": "9" + }, + "D10": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D11": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D12": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D13": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D14": { + "absolute": "12", + "add": "2", + "copy": "1", + "relative": "14", + "transport": "9" + }, + "D15": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D16": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D17": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D18": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D19": { + "absolute": "9", + "add": "2", + "copy": "1", + "relative": "11", + "transport": "6" + }, + "D2": { + "absolute": "9", + "add": "2", + "copy": "1", + "relative": "11", + "transport": "6" + }, + "D20": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D21": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D22": { + "absolute": "9", + "add": "2", + "copy": "1", + "relative": "11", + "transport": "6" + }, + "D23": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D24": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D25": { + "absolute": "9", + "add": "2", + "copy": "1", + "relative": "11", + "transport": "6" + }, + "D26": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D27": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D28": { + "absolute": "12", + "add": "2", + "copy": "1", + "relative": "14", + "transport": "9" + }, + "D29": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D3": { + "absolute": "9", + "add": "2", + "copy": "1", + "relative": "11", + "transport": "6" + }, + "D30": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D31": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D4": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D5": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D6": { + "absolute": "11", + "add": "2", + "copy": "1", + "relative": "13", + "transport": "8" + }, + "D7": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D8": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "D9": { + "absolute": "10", + "add": "2", + "copy": "1", + "relative": "12", + "transport": "7" + }, + "G0": { + "absolute": "118", + "add": "30", + "copy": "0", + "relative": "178", + "transport": "88" + }, + "G1": { + "absolute": "115", + "add": "28", + "copy": "0", + "relative": "171", + "transport": "87" + }, + "G10": { + "absolute": "190", + "add": "48", + "copy": "0", + "relative": "286", + "transport": "142" + }, + "G11": { + "absolute": "76", + "add": "14", + "copy": "0", + "relative": "104", + "transport": "62" + }, + "G12": { + "absolute": "140", + "add": "46", + "copy": "0", + "relative": "232", + "transport": "94" + }, + "G13": { + "absolute": "107", + "add": "22", + "copy": "0", + "relative": "151", + "transport": "85" + }, + "G14": { + "absolute": "107", + "add": "24", + "copy": "0", + "relative": "155", + "transport": "83" + }, + "G15": { + "absolute": "66", + "add": "12", + "copy": "0", + "relative": "90", + "transport": "54" + }, + "G16": { + "absolute": "137", + "add": "48", + "copy": "0", + "relative": "233", + "transport": "89" + }, + "G17": { + "absolute": "137", + "add": "36", + "copy": "0", + "relative": "209", + "transport": "101" + }, + "G18": { + "absolute": "79", + "add": "16", + "copy": "0", + "relative": "111", + "transport": "63" + }, + "G19": { + "absolute": "28", + "add": "4", + "copy": "0", + "relative": "36", + "transport": "24" + }, + "G2": { + "absolute": "36", + "add": "6", + "copy": "0", + "relative": "48", + "transport": "30" + }, + "G20": { + "absolute": "242", + "add": "80", + "copy": "0", + "relative": "402", + "transport": "162" + }, + "G21": { + "absolute": "89", + "add": "18", + "copy": "0", + "relative": "125", + "transport": "71" + }, + "G22": { + "absolute": "36", + "add": "6", + "copy": "0", + "relative": "48", + "transport": "30" + }, + "G23": { + "absolute": "143", + "add": "54", + "copy": "0", + "relative": "251", + "transport": "89" + }, + "G24": { + "absolute": "69", + "add": "14", + "copy": "0", + "relative": "97", + "transport": "55" + }, + "G25": { + "absolute": "28", + "add": "4", + "copy": "0", + "relative": "36", + "transport": "24" + }, + "G26": { + "absolute": "128", + "add": "32", + "copy": "0", + "relative": "192", + "transport": "96" + }, + "G27": { + "absolute": "160", + "add": "48", + "copy": "0", + "relative": "256", + "transport": "112" + }, + "G28": { + "absolute": "97", + "add": "22", + "copy": "0", + "relative": "141", + "transport": "75" + }, + "G29": { + "absolute": "69", + "add": "14", + "copy": "0", + "relative": "97", + "transport": "55" + }, + "G3": { + "absolute": "38", + "add": "6", + "copy": "0", + "relative": "50", + "transport": "32" + }, + "G30": { + "absolute": "76", + "add": "14", + "copy": "0", + "relative": "104", + "transport": "62" + }, + "G31": { + "absolute": "41", + "add": "6", + "copy": "0", + "relative": "53", + "transport": "35" + }, + "G4": { + "absolute": "134", + "add": "34", + "copy": "0", + "relative": "202", + "transport": "100" + }, + "G5": { + "absolute": "192", + "add": "58", + "copy": "0", + "relative": "308", + "transport": "134" + }, + "G6": { + "absolute": "110", + "add": "28", + "copy": "0", + "relative": "166", + "transport": "82" + }, + "G7": { + "absolute": "87", + "add": "18", + "copy": "0", + "relative": "123", + "transport": "69" + }, + "G8": { + "absolute": "101", + "add": "32", + "copy": "0", + "relative": "165", + "transport": "69" + }, + "G9": { + "absolute": "53", + "add": "10", + "copy": "0", + "relative": "73", + "transport": "43" + }, + "Q0": { + "absolute": "448", + "add": "114", + "copy": "0", + "relative": "666", + "transport": "334" + }, + "Q1": { + "absolute": "394", + "add": "110", + "copy": "0", + "relative": "608", + "transport": "284" + }, + "Q2": { + "absolute": "426", + "add": "112", + "copy": "0", + "relative": "642", + "transport": "314" + }, + "Q3": { + "absolute": "426", + "add": "112", + "copy": "0", + "relative": "642", + "transport": "314" + }, + "Q4": { + "absolute": "387", + "add": "112", + "copy": "0", + "relative": "603", + "transport": "275" + }, + "Q5": { + "absolute": "372", + "add": "110", + "copy": "0", + "relative": "586", + "transport": "262" + }, + "Q6": { + "absolute": "374", + "add": "112", + "copy": "0", + "relative": "590", + "transport": "262" + }, + "Q7": { + "absolute": "450", + "add": "114", + "copy": "0", + "relative": "668", + "transport": "336" + }, + "X0": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X1": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X10": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X100": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X101": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X102": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X103": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X11": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X12": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X13": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X14": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X15": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X16": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X17": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X18": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X19": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X2": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X20": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X21": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X22": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X23": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X24": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X25": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X26": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X27": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X28": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X29": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X3": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X30": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X31": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X32": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X33": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X34": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X35": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X36": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X37": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X38": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X39": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X4": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X40": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X41": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X42": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X43": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X44": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X45": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X46": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X47": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X48": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X49": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X5": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X50": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X51": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X52": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X53": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X54": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X55": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X56": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X57": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X58": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X59": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X6": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X60": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X61": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X62": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X63": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X64": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X65": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X66": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X67": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X68": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X69": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X7": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X70": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X71": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X72": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X73": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X74": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X75": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X76": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X77": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X78": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X79": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X8": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X80": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X81": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X82": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X83": { + "absolute": "7", + "add": "0", + "copy": "0", + "relative": "7", + "transport": "7" + }, + "X84": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X85": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X86": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X87": { + "absolute": "6", + "add": "0", + "copy": "0", + "relative": "6", + "transport": "6" + }, + "X88": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X89": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X9": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X90": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X91": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X92": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X93": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X94": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X95": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "X96": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X97": { + "absolute": "3", + "add": "0", + "copy": "0", + "relative": "3", + "transport": "3" + }, + "X98": { + "absolute": "4", + "add": "0", + "copy": "0", + "relative": "4", + "transport": "4" + }, + "X99": { + "absolute": "5", + "add": "0", + "copy": "0", + "relative": "5", + "transport": "5" + }, + "Y0": { + "absolute": "423/2", + "add": "147/2", + "copy": "1", + "relative": "328", + "transport": "137" + }, + "Y1": { + "absolute": "521/4", + "add": "37", + "copy": "1/2", + "relative": "755/4", + "transport": "371/4" + }, + "Y10": { + "absolute": "204", + "add": "73", + "copy": "1", + "relative": "320", + "transport": "130" + }, + "Y100": { + "absolute": "683/4", + "add": "219/4", + "copy": "3/4", + "relative": "1031/4", + "transport": "461/4" + }, + "Y101": { + "absolute": "847/4", + "add": "73", + "copy": "1", + "relative": "1311/4", + "transport": "551/4" + }, + "Y102": { + "absolute": "967/4", + "add": "363/4", + "copy": "5/4", + "relative": "1545/4", + "transport": "599/4" + }, + "Y103": { + "absolute": "1079/4", + "add": "109", + "copy": "3/2", + "relative": "1773/4", + "transport": "637/4" + }, + "Y11": { + "absolute": "166", + "add": "219/4", + "copy": "3/4", + "relative": "253", + "transport": "221/2" + }, + "Y12": { + "absolute": "523/4", + "add": "36", + "copy": "1/2", + "relative": "753/4", + "transport": "377/4" + }, + "Y13": { + "absolute": "333/2", + "add": "217/4", + "copy": "3/4", + "relative": "253", + "transport": "223/2" + }, + "Y14": { + "absolute": "531/4", + "add": "36", + "copy": "1/2", + "relative": "761/4", + "transport": "385/4" + }, + "Y15": { + "absolute": "333/2", + "add": "217/4", + "copy": "3/4", + "relative": "253", + "transport": "223/2" + }, + "Y16": { + "absolute": "397/2", + "add": "73", + "copy": "1", + "relative": "629/2", + "transport": "249/2" + }, + "Y17": { + "absolute": "971/4", + "add": "365/4", + "copy": "5/4", + "relative": "1551/4", + "transport": "601/4" + }, + "Y18": { + "absolute": "481/2", + "add": "365/4", + "copy": "5/4", + "relative": "771/2", + "transport": "148" + }, + "Y19": { + "absolute": "811/4", + "add": "73", + "copy": "1", + "relative": "1275/4", + "transport": "515/4" + }, + "Y2": { + "absolute": "170", + "add": "221/4", + "copy": "3/4", + "relative": "515/2", + "transport": "114" + }, + "Y20": { + "absolute": "677/4", + "add": "217/4", + "copy": "3/4", + "relative": "1023/4", + "transport": "457/4" + }, + "Y21": { + "absolute": "821/4", + "add": "145/2", + "copy": "1", + "relative": "1283/4", + "transport": "527/4" + }, + "Y22": { + "absolute": "209", + "add": "145/2", + "copy": "1", + "relative": "649/2", + "transport": "271/2" + }, + "Y23": { + "absolute": "166", + "add": "219/4", + "copy": "3/4", + "relative": "253", + "transport": "221/2" + }, + "Y24": { + "absolute": "409/2", + "add": "73", + "copy": "1", + "relative": "641/2", + "transport": "261/2" + }, + "Y25": { + "absolute": "945/4", + "add": "367/4", + "copy": "5/4", + "relative": "1527/4", + "transport": "573/4" + }, + "Y26": { + "absolute": "555/2", + "add": "110", + "copy": "3/2", + "relative": "452", + "transport": "166" + }, + "Y27": { + "absolute": "1079/4", + "add": "110", + "copy": "3/2", + "relative": "1777/4", + "transport": "633/4" + }, + "Y28": { + "absolute": "955/4", + "add": "367/4", + "copy": "5/4", + "relative": "1537/4", + "transport": "583/4" + }, + "Y29": { + "absolute": "204", + "add": "73", + "copy": "1", + "relative": "320", + "transport": "130" + }, + "Y3": { + "absolute": "261/2", + "add": "37", + "copy": "1/2", + "relative": "189", + "transport": "93" + }, + "Y30": { + "absolute": "971/4", + "add": "365/4", + "copy": "5/4", + "relative": "1551/4", + "transport": "601/4" + }, + "Y31": { + "absolute": "1087/4", + "add": "109", + "copy": "3/2", + "relative": "1781/4", + "transport": "645/4" + }, + "Y32": { + "absolute": "971/4", + "add": "363/4", + "copy": "5/4", + "relative": "1549/4", + "transport": "603/4" + }, + "Y33": { + "absolute": "273", + "add": "109", + "copy": "3/2", + "relative": "893/2", + "transport": "325/2" + }, + "Y34": { + "absolute": "497/2", + "add": "361/4", + "copy": "5/4", + "relative": "785/2", + "transport": "157" + }, + "Y35": { + "absolute": "847/4", + "add": "72", + "copy": "1", + "relative": "1307/4", + "transport": "555/4" + }, + "Y36": { + "absolute": "861/4", + "add": "72", + "copy": "1", + "relative": "1321/4", + "transport": "569/4" + }, + "Y37": { + "absolute": "711/4", + "add": "215/4", + "copy": "3/4", + "relative": "1055/4", + "transport": "493/4" + }, + "Y38": { + "absolute": "839/4", + "add": "145/2", + "copy": "1", + "relative": "1301/4", + "transport": "545/4" + }, + "Y39": { + "absolute": "963/4", + "add": "363/4", + "copy": "5/4", + "relative": "1541/4", + "transport": "595/4" + }, + "Y4": { + "absolute": "671/4", + "add": "221/4", + "copy": "3/4", + "relative": "1021/4", + "transport": "447/4" + }, + "Y40": { + "absolute": "703/4", + "add": "217/4", + "copy": "3/4", + "relative": "1049/4", + "transport": "483/4" + }, + "Y41": { + "absolute": "553/4", + "add": "36", + "copy": "1/2", + "relative": "783/4", + "transport": "407/4" + }, + "Y42": { + "absolute": "343/2", + "add": "219/4", + "copy": "3/4", + "relative": "517/2", + "transport": "116" + }, + "Y43": { + "absolute": "415/2", + "add": "73", + "copy": "1", + "relative": "647/2", + "transport": "267/2" + }, + "Y44": { + "absolute": "427/2", + "add": "73", + "copy": "1", + "relative": "659/2", + "transport": "279/2" + }, + "Y45": { + "absolute": "335/2", + "add": "219/4", + "copy": "3/4", + "relative": "509/2", + "transport": "112" + }, + "Y46": { + "absolute": "549/4", + "add": "36", + "copy": "1/2", + "relative": "779/4", + "transport": "403/4" + }, + "Y47": { + "absolute": "823/4", + "add": "145/2", + "copy": "1", + "relative": "1285/4", + "transport": "529/4" + }, + "Y48": { + "absolute": "165", + "add": "217/4", + "copy": "3/4", + "relative": "503/2", + "transport": "110" + }, + "Y49": { + "absolute": "399/2", + "add": "73", + "copy": "1", + "relative": "631/2", + "transport": "251/2" + }, + "Y5": { + "absolute": "172", + "add": "221/4", + "copy": "3/4", + "relative": "519/2", + "transport": "116" + }, + "Y50": { + "absolute": "951/4", + "add": "365/4", + "copy": "5/4", + "relative": "1531/4", + "transport": "581/4" + }, + "Y51": { + "absolute": "967/4", + "add": "365/4", + "copy": "5/4", + "relative": "1547/4", + "transport": "597/4" + }, + "Y52": { + "absolute": "391/2", + "add": "73", + "copy": "1", + "relative": "623/2", + "transport": "243/2" + }, + "Y53": { + "absolute": "168", + "add": "217/4", + "copy": "3/4", + "relative": "509/2", + "transport": "113" + }, + "Y54": { + "absolute": "505/4", + "add": "36", + "copy": "1/2", + "relative": "735/4", + "transport": "359/4" + }, + "Y55": { + "absolute": "270", + "add": "109", + "copy": "3/2", + "relative": "887/2", + "transport": "319/2" + }, + "Y56": { + "absolute": "943/4", + "add": "363/4", + "copy": "5/4", + "relative": "1521/4", + "transport": "575/4" + }, + "Y57": { + "absolute": "208", + "add": "72", + "copy": "1", + "relative": "323", + "transport": "135" + }, + "Y58": { + "absolute": "170", + "add": "215/4", + "copy": "3/4", + "relative": "256", + "transport": "231/2" + }, + "Y59": { + "absolute": "969/4", + "add": "361/4", + "copy": "5/4", + "relative": "1545/4", + "transport": "603/4" + }, + "Y6": { + "absolute": "505/4", + "add": "37", + "copy": "1/2", + "relative": "739/4", + "transport": "355/4" + }, + "Y60": { + "absolute": "203", + "add": "72", + "copy": "1", + "relative": "318", + "transport": "130" + }, + "Y61": { + "absolute": "937/4", + "add": "363/4", + "copy": "5/4", + "relative": "1515/4", + "transport": "569/4" + }, + "Y62": { + "absolute": "271", + "add": "109", + "copy": "3/2", + "relative": "889/2", + "transport": "321/2" + }, + "Y63": { + "absolute": "1017/4", + "add": "365/4", + "copy": "5/4", + "relative": "1597/4", + "transport": "647/4" + }, + "Y64": { + "absolute": "207", + "add": "73", + "copy": "1", + "relative": "323", + "transport": "133" + }, + "Y65": { + "absolute": "963/4", + "add": "367/4", + "copy": "5/4", + "relative": "1545/4", + "transport": "591/4" + }, + "Y66": { + "absolute": "275", + "add": "110", + "copy": "3/2", + "relative": "899/2", + "transport": "327/2" + }, + "Y67": { + "absolute": "1113/4", + "add": "110", + "copy": "3/2", + "relative": "1811/4", + "transport": "667/4" + }, + "Y68": { + "absolute": "248", + "add": "367/4", + "copy": "5/4", + "relative": "787/2", + "transport": "155" + }, + "Y69": { + "absolute": "877/4", + "add": "73", + "copy": "1", + "relative": "1341/4", + "transport": "581/4" + }, + "Y7": { + "absolute": "129", + "add": "36", + "copy": "1/2", + "relative": "373/2", + "transport": "185/2" + }, + "Y70": { + "absolute": "685/4", + "add": "219/4", + "copy": "3/4", + "relative": "1033/4", + "transport": "463/4" + }, + "Y71": { + "absolute": "240", + "add": "369/4", + "copy": "5/4", + "relative": "386", + "transport": "293/2" + }, + "Y72": { + "absolute": "203", + "add": "74", + "copy": "1", + "relative": "320", + "transport": "128" + }, + "Y73": { + "absolute": "349/2", + "add": "221/4", + "copy": "3/4", + "relative": "262", + "transport": "237/2" + }, + "Y74": { + "absolute": "515/4", + "add": "37", + "copy": "1/2", + "relative": "749/4", + "transport": "365/4" + }, + "Y75": { + "absolute": "873/4", + "add": "147/2", + "copy": "1", + "relative": "1339/4", + "transport": "575/4" + }, + "Y76": { + "absolute": "341/2", + "add": "221/4", + "copy": "3/4", + "relative": "258", + "transport": "229/2" + }, + "Y77": { + "absolute": "202", + "add": "74", + "copy": "1", + "relative": "319", + "transport": "127" + }, + "Y78": { + "absolute": "242", + "add": "369/4", + "copy": "5/4", + "relative": "388", + "transport": "297/2" + }, + "Y79": { + "absolute": "200", + "add": "74", + "copy": "1", + "relative": "317", + "transport": "125" + }, + "Y8": { + "absolute": "649/4", + "add": "219/4", + "copy": "3/4", + "relative": "997/4", + "transport": "427/4" + }, + "Y80": { + "absolute": "165", + "add": "223/4", + "copy": "3/4", + "relative": "253", + "transport": "217/2" + }, + "Y81": { + "absolute": "547/4", + "add": "37", + "copy": "1/2", + "relative": "781/4", + "transport": "397/4" + }, + "Y82": { + "absolute": "357/2", + "add": "221/4", + "copy": "3/4", + "relative": "266", + "transport": "245/2" + }, + "Y83": { + "absolute": "130", + "add": "37", + "copy": "1/2", + "relative": "377/2", + "transport": "185/2" + }, + "Y84": { + "absolute": "649/4", + "add": "223/4", + "copy": "3/4", + "relative": "1001/4", + "transport": "423/4" + }, + "Y85": { + "absolute": "815/4", + "add": "74", + "copy": "1", + "relative": "1283/4", + "transport": "515/4" + }, + "Y86": { + "absolute": "829/4", + "add": "73", + "copy": "1", + "relative": "1293/4", + "transport": "533/4" + }, + "Y87": { + "absolute": "323/2", + "add": "219/4", + "copy": "3/4", + "relative": "497/2", + "transport": "106" + }, + "Y88": { + "absolute": "195", + "add": "147/2", + "copy": "1", + "relative": "623/2", + "transport": "241/2" + }, + "Y89": { + "absolute": "239", + "add": "367/4", + "copy": "5/4", + "relative": "769/2", + "transport": "146" + }, + "Y9": { + "absolute": "823/4", + "add": "73", + "copy": "1", + "relative": "1287/4", + "transport": "527/4" + }, + "Y90": { + "absolute": "1085/4", + "add": "110", + "copy": "3/2", + "relative": "1783/4", + "transport": "639/4" + }, + "Y91": { + "absolute": "981/4", + "add": "365/4", + "copy": "5/4", + "relative": "1561/4", + "transport": "611/4" + }, + "Y92": { + "absolute": "793/4", + "add": "73", + "copy": "1", + "relative": "1257/4", + "transport": "497/4" + }, + "Y93": { + "absolute": "1153/4", + "add": "109", + "copy": "3/2", + "relative": "1847/4", + "transport": "711/4" + }, + "Y94": { + "absolute": "997/4", + "add": "363/4", + "copy": "5/4", + "relative": "1575/4", + "transport": "629/4" + }, + "Y95": { + "absolute": "415/2", + "add": "73", + "copy": "1", + "relative": "647/2", + "transport": "267/2" + }, + "Y96": { + "absolute": "1003/4", + "add": "365/4", + "copy": "5/4", + "relative": "1583/4", + "transport": "633/4" + }, + "Y97": { + "absolute": "561/2", + "add": "110", + "copy": "3/2", + "relative": "455", + "transport": "169" + }, + "Y98": { + "absolute": "979/4", + "add": "367/4", + "copy": "5/4", + "relative": "1561/4", + "transport": "607/4" + }, + "Y99": { + "absolute": "201", + "add": "147/2", + "copy": "1", + "relative": "635/2", + "transport": "253/2" + } + }, + "events": 4058, + "initial_independent_roles": 280, + "native_binding": { + "exact_normalized_columns": 948, + "monomial_endpoints": 208, + "paid_occurrences": 1410, + "transport_recipes": 740 + }, + "paid_profile": { + "1": 1074, + "2": 58, + "3": 86, + "4": 104, + "5": 48, + "6": 24, + "7": 8, + "8": 8 + }, + "rank_mass": 2368, + "scope": "Exact finite source-bound native local precision interface; arbitrary independent absolute defects are sharp. State-relative feedback is a sufficient bound, not an attained numerical-kernel error. No side correction, global hosting, tape/all-size supplier admission or new kappa.", + "source_witness_sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e", + "status": "PASS_P104_NATIVE_PRECISION", + "uniform_relative_guard_bits": 17 +} diff --git a/research/p104-native-precision/SELECTION.json b/research/p104-native-precision/SELECTION.json new file mode 100644 index 0000000000..e0ca9a58b6 --- /dev/null +++ b/research/p104-native-precision/SELECTION.json @@ -0,0 +1,91 @@ +{ + "seed": "1be10fd8d275206692a433be1dacd810", + "track": "complex-mechanisms", + "suggestions": [ + { + "task_id": "complex-new-helper-inventory", + "scope_key": "5868e5281a1e63d41a22", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "method": "Propose a changed helper inventory and derive an optimistic exact moment.", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model.", + "first_step": { + "command": ["python3", "-B", "research/complex-local-word-ceiling/verify.py"], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013." + ], + "overlap_terms": ["helper inventory", "heterogeneous-owner", "mutable leaver"], + "scope_rule": "If you change the card's premise, record scope_status=changed and explain why. A package metadata check cannot establish mathematical relevance." + }, + { + "task_id": "p104-side-correction", + "scope_key": "c5367b1a1b7bed20db53", + "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?", + "method": "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "starting_points": ["research/p104-native-channel/README.md", "research/p104-native-channel/PROOF.md", "docs/research/community-efficient1000-review.md"], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.", + "first_step": { + "command": ["python3", "-B", "scripts/research_baseline.py"], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": ["One correction factorization, one chronological cut, or one explicit hosting obstruction.", "A changed correction schedule with an updated full bill and native frame contract."], + "scope_change_triggers": ["Recompiling the already certified low-rank channel without closing a new obligation.", "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier."], + "overlap_terms": ["P104", "I-G/2", "side correction", "native channel", "1972", "1991"], + "scope_rule": "If you change the card's premise, record scope_status=changed and explain why. A package metadata check cannot establish mathematical relevance." + }, + { + "task_id": "complex-rank-shape-decoder", + "scope_key": "02b31ebd160542c86299", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "method": "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "starting_points": ["research/complex-local-word-ceiling/README.md", "research/complex-decoder-field-extension-seed44/README.md", "research/complex-frame-pair-decoders/README.md", "research/selected-k8-unrestricted-ends/README.md", "research/eisenstein-reduction-copy-floor/README.md"], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.", + "first_step": { + "command": ["python3", "-B", "research/complex-local-word-ceiling/verify.py"], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": ["One masked, overcomplete or block decoder family with exact labels and supports.", "A scoped lower bound on effective rank for one alphabet.", "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."], + "scope_change_triggers": ["Repacking idle remainders of an unchanged word (covered by the packing ceiling).", "Repeating the eight-term all-pairs search inside its proved scope.", "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder."], + "overlap_terms": ["rank shape", "block climb", "masked decoder", "overcomplete", "effective rank"], + "scope_rule": "If you change the card's premise, record scope_status=changed and explain why. A package metadata check cannot establish mathematical relevance." + } + ], + "base_commit": "564148b82ae9df72163f22106f15e73efca8aff2", + "catalog_assessed_on": "2026-10-14", + "priority_revision": 4, + "priority_log": "docs/research/research-priority-log.md", + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected": { + "kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "reproduce": "make frontier1094-verify" + }, + "status": "SUGGESTIONS_ONLY_NOT_RESERVED", + "next_step": "Check live overlap, refine one question's object and domain, and record a bounded task card. A different seed or scope key is not evidence of novelty." +} diff --git a/research/p104-native-precision/SOURCES.json b/research/p104-native-precision/SOURCES.json new file mode 100644 index 0000000000..346a35c41f --- /dev/null +++ b/research/p104-native-precision/SOURCES.json @@ -0,0 +1,80 @@ +{ + "schema_version": 1, + "base_commit": "564148b82ae9df72163f22106f15e73efca8aff2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/p104-native-channel/NATIVE-RECIPES.json.gz", + "usage": "input", + "git_blob": "ab129678c2df4f0d39b02b88457d02c37de0d9b6", + "sha256": "a1c4d83d3d5fe1338e99b59272e8cf5d43244c33888597da340b2aa7fef5b3e8" + }, + { + "path": "research/p104-native-channel/PROOF.md", + "usage": "input", + "git_blob": "a69311b74f74a2f8e8f411c1451baacd9bacddce", + "sha256": "5d743145d389ffdfaffc66096fa7e32c7155b18f73d74755403151d0435bb94c" + }, + { + "path": "research/p104-native-channel/SOURCES.json", + "usage": "input", + "git_blob": "901ad0fb42b62eefedecb467ad45c884f494c163", + "sha256": "2ad02321c659c4ebb75fae1a0265437506e7a1fb5ab5ff17444a8be5692fcf73" + }, + { + "path": "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "usage": "input", + "git_blob": "86beaf424e9f0f800ae3a62797d94ec9386b7706", + "sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e" + }, + { + "path": "research/p104-native-channel/inputs/P104-FIXTURE.json", + "usage": "input", + "git_blob": "2e16f99b295bb386fd13bd8fbd57b42ef54143a9", + "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + { + "path": "research/p104-native-channel/vendor/native_verify.py", + "usage": "input", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + } + ], + "predecessors": [ + { + "pr": 1991, + "head": "6e222517e182e98499239bc9a4009f540e1c5520", + "author": "Chafik Boukhalfa", + "role": "Native channel recipes, exact frame/phase realization and dirty endpoint induction; local error transfer is new here." + }, + { + "pr": 1972, + "head": "fd82d172f46933fd253c2c6de4bd5eaff5429cfd", + "author": "Rohan Arun", + "role": "Entire scalar/frame low-rank channel; no construction credit claimed here." + }, + { + "pr": 1940, + "head": "a9b7dfe2809092a9a4c90784d12bb60061e995e8", + "author": "Adam Gall", + "role": "Attaining 32-chain target-order schedule." + } + ], + "scope": "All imported interpreter code and consumed mathematical data are authenticated before execution. No new vendoring; source-specific notices remain in research/p104-native-channel/notices/.", + "canonical_checkpoint": { + "commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "compatibility": "Guidance-only changes; scientific inputs and catalogue unchanged from the pinned base." + } +} diff --git a/research/p104-native-precision/TASK.json b/research/p104-native-precision/TASK.json new file mode 100644 index 0000000000..f618d2769e --- /dev/null +++ b/research/p104-native-precision/TASK.json @@ -0,0 +1,104 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 4, + "base_commit": "564148b82ae9df72163f22106f15e73efca8aff2", + "original_card": { + "id": "p104-side-correction", + "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?", + "starting_points": [ + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991" + ] + }, + "scope_status": "changed", + "actual_scope": "Derive the native P104 channel's source-bound local Hilbert-norm precision interface: signed ideal-prefix bounds, sharp cumulative errors at every instruction cut and at every final role, and a safe state-relative native-child error guard. Include all arbitrary dirty inputs and the eight private-copy lifetimes.", + "scope_change_reason": "The original correction obligation has active terminal and all-cut investigations. This separately closes the concrete precision implication explicitly left open by PR1991. It changes the card's obligation rather than resubmitting the channel or claiming its construction acceptance gate.", + "bottleneck_link": "A future corrected P104 supplier must propagate native-child errors through dirty gather, private copies, delivery and cleanup. Exact endpoint cancellation alone does not bound intermediate magnitude or accumulated restoration defects. This package supplies that local interface, not the missing correction or a new supplier.", + "budget_minutes": 60, + "stop_rule": "Finish the fixed 4058-event channel with exact source authentication, all-cut signed error propagation, independent forward/reverse evidence, meaningful wrong-norm/private-lifetime/feedback controls and a reproducible registered replay. Do not infer global hosting, rounded recursive-child internals or all-size supplier admission.", + "outcome": "completed", + "evidence": "CPython3.12 scientific smoke and full registered replay passed: ideal all-cut norm106, sharp absolute accumulation450, weighted coefficient668, sufficient relative-error guard17bits;740 native recipes,208 adapters,948 normalized columns;62867 endpoint coefficients agree forward/reverse;13 semantic controls;4042 dense rational defects,18 independent impulses,source-drift rejection and optimized read-only export. Native-only all-cut356 versus endpoint336. No full corrected supplier, actual rounded-child implementation or hosted CI claim.", + "author": "Adam Gall", + "ai_assistance": "Substantial OpenAI Codex assistance in research, proof, implementation, verification and writing; no independent human or formal review.", + "open_questions": [ + { + "question": "How does an actual side-correction word alter the complete precision budget?", + "why_it_matters": "The native channel implements G/2, not the desired identity; precision of this channel alone does not admit a supplier.", + "first_step": "Bind the eventual correction's exact chronological word and propagate its error injections through the combined frame invariant.", + "blocked_by": "A corrected native word with legal frames, restoration and full recursive accounting." + }, + { + "question": "Does an actual rounded recursive child meet the required completed-output Hilbert-norm defect bound?", + "why_it_matters": "Native unitarity does not by itself bound a recursive numerical implementation's roundoff or internal precision.", + "first_step": "Bind the primitive precision convention and exercise its rounded implementation at the P104 child ranks.", + "blocked_by": "Source-bound numerical-child implementation and a norm-compatible error contract." + }, + { + "question": "How do actual owner-family magnitude and residual-error bounds propagate across globally hosted corrected calls?", + "why_it_matters": "Local dirty restoration with defects cannot be replaced by exact global reuse without an error budget.", + "first_step": "Bind an admitted corrected owner schedule and propagate familywise input and residual-error bounds.", + "blocked_by": "A fully priced corrected schedule and its all-size precision/tape contracts." + } + ], + "seed": "1be10fd8d275206692a433be1dacd810", + "track": "complex-mechanisms", + "domain": "Exactly the PR1972 LOWRANK-WITNESS retained by PR1991: 104 sources,104 targets,72 arbitrary dirty helpers,4058 events,512-dimensional physical address space. Abstract Hilbert-space lifting is conditional on unitary charts and the same scalar/private-lifetime word.", + "method": "Exact dyadic forward coefficient rows and cumulative error symbols; independent reverse suffix responses; unitary conjugation of common-chart logical errors; exact constructive sign-alignment witnesses and state-relative feedback inequalities.", + "optimistic_complete_bill": "No word or paid profile changes:1074 H1+58 H2+86 H3+104 H4+48 H5+24 H6+8 H7+8 H8,rank mass2368=2312 boundary coverage+COPY56. No additional transport is proposed. Correction,global idle/hosting,all-size and implementation precision charges remain unknown; hence no completed moment or kappa claim is permissible.", + "acceptance": "An exact source-bound local precision theorem with complete all-cut and endpoint constants, constructive sharpness for independent absolute defects, a proved relative-error guard, arbitrary-dirty coverage and rejecting semantic controls. This is a missing-interface result and intentionally does not pass the original supplier-construction gate.", + "predecessors": [ + "Rohan Arun/PR1972 fd82d172f46933fd253c2c6de4bd5eaff5429cfd: complete scalar/frame channel, not new here.", + "Chafik Boukhalfa/PR1991 reviewed at6e222517e182e98499239bc9a4009f540e1c5520: concrete Gaussian-dyadic recipes and arbitrary-dirty induction; precision remains open.", + "Adam Gall/PR1940 a9b7dfe2809092a9a4c90784d12bb60061e995e8: attaining target-order schedule; Josie Elliston/PR1071 fixture,Ali Romman/PR1125 and original geometry lineage.", + "PR2067: sharp all-size PR628 balanced-word leaf endpoint defects, a different word and error domain; not resubmitted.", + "selected1094-wire-prefix-audit and dirty-prefix-monomial-audit: earlier norm/precision methods on different source words; credited,not imported." + ], + "freshness": { + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "checked_utc": "2026-10-14T19:10:49Z", + "open_prs": 353, + "open_prs_fetched_at": "2026-10-14T19:00:33Z", + "discussion_records": 738, + "discussions_fetched_at": "2026-10-14T19:02:09Z", + "local_records": 1538, + "pagination_complete": true, + "limits": "Shared refreshed offline snapshot plus targeted live PR1991,PR2067,Discussion2080 and local predecessor reading; no novelty inference from absence and no exhaustive arbitrary-code/literature search. New canonical checkpoint changes guidance only; catalogue and scientific inputs are unchanged.", + "publication_restriction": "No discussion posts or comments; research claim retained locally and in the final PR." + } +} diff --git a/research/p104-native-precision/VERIFY.json b/research/p104-native-precision/VERIFY.json new file mode 100644 index 0000000000..a5deeba393 --- /dev/null +++ b/research/p104-native-precision/VERIFY.json @@ -0,0 +1,38 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-native-channel/NATIVE-RECIPES.json.gz", + "research/p104-native-channel/PROOF.md", + "research/p104-native-channel/SOURCES.json", + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "research/p104-native-channel/inputs/P104-FIXTURE.json", + "research/p104-native-channel/vendor/native_verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Source-authenticated normalized native recipes and phase; exact arbitrary-input and every-cut precision rows; independent reverse endpoint responses; sharpness and semantic controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 600, + "checks": "Dense rational defects, independent impulses spanning every native rank and private lifetime, corrupted-source rejection before execution, optimized read-only relocated replay." + } + ] +} diff --git a/research/p104-native-precision/test_verify.py b/research/p104-native-precision/test_verify.py new file mode 100755 index 0000000000..92cec91577 --- /dev/null +++ b/research/p104-native-precision/test_verify.py @@ -0,0 +1,86 @@ +#!/usr/bin/env python3 +"""Independent executions and packaging controls for the finite precision bound.""" +from fractions import Fraction as Q +from pathlib import Path +import importlib.util +import json +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("p104_precision", HERE / "verify.py") +V = importlib.util.module_from_spec(spec) +spec.loader.exec_module(V) + + +def main(): + V.authenticate() + word = json.loads((V.ROOT / (V.SOURCE + "inputs/LOWRANK-WITNESS.json")).read_text()) + result = V.forward(word) + inputs = {name: Q((i % 11) - 5, 7) for i, name in enumerate(word["initial_frames"])} + defects = {index: Q((-1 if index % 2 else 1) * (1 + index % 3), 1 + index % 7) + for index in result["kinds"]} + noisy = V.injected_run(word, defects=defects, inputs=inputs) + for name in noisy: + expected = sum((a*inputs[src] for src, a in result["rows"][name].items()), Q(0)) + expected += sum((a*defects[index] for index, a in result["errors"][name].items()), Q(0)) + V.need(noisy[name] == expected, "independent dense rational defect execution") + # One impulse per distinct native rank, every private-copy lifetime, and boundary additions. + selected = {0, len(word["program"])-1} + rank_seen = set() + for index, event in enumerate(word["program"]): + if event[0] == "copy": + selected.add(index) + if event[0] == "transport" and event[4] not in rank_seen: + selected.add(index) + rank_seen.add(event[4]) + for index in sorted(selected): + actual = V.injected_run(word, defects={index: Q(1)}) + V.need(all(actual[name] == result["errors"][name].get(index, Q(0)) for name in actual), + "individual forward physical-role response") + with tempfile.TemporaryDirectory(prefix="p104-precision-export-") as temp: + root = Path(temp) + destination = root / "research" / HERE.name + shutil.copytree(HERE, destination, ignore=shutil.ignore_patterns("__pycache__")) + for name in V.INPUTS: + target = root / name + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(V.ROOT / name, target) + V.authenticate(root) + victim = root / (V.SOURCE + "vendor/native_verify.py") + original = victim.read_bytes() + victim.write_bytes(b"raise RuntimeError('must not execute a changed interpreter')\n") + try: + V.authenticate(root) + except ValueError as error: + V.need("source authentication" in str(error), "source drift rejected for the intended reason") + else: + raise ValueError("modified interpreter authenticated") + victim.write_bytes(original) + files = [path for path in root.rglob("*") if path.is_file()] + before = {str(path.relative_to(root)): path.read_bytes() for path in files} + for path in files: + path.chmod(0o444) + directories = sorted((path for path in root.rglob("*") if path.is_dir()), reverse=True) + for path in directories: + path.chmod(0o555) + try: + replay = subprocess.run([sys.executable, "-I", "-O", "-B", str(destination / "verify.py")], + cwd=root, capture_output=True, text=True, timeout=300) + V.need(replay.returncode == 0 and "PASS_P104_NATIVE_PRECISION" in replay.stdout, + "optimized read-only export replay: " + replay.stdout + replay.stderr) + after = {str(path.relative_to(root)): path.read_bytes() for path in root.rglob("*") if path.is_file()} + V.need(before == after, "read-only export preserved every byte") + finally: + for path in directories: + path.chmod(0o755) + for path in files: + path.chmod(0o644) + print(f"PASS_P104_NATIVE_PRECISION_TESTS dense_defects={len(defects)} independent_impulses={len(selected)} " + "source_drift=reject read_only_optimized_export=pass") + + +if __name__ == "__main__": + main() diff --git a/research/p104-native-precision/verify.py b/research/p104-native-precision/verify.py new file mode 100755 index 0000000000..8540c53dc6 --- /dev/null +++ b/research/p104-native-precision/verify.py @@ -0,0 +1,438 @@ +#!/usr/bin/env python3 +"""Exact P104 local precision interface; standard library, no producer imports. + +Adam Gall, with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from itertools import combinations, product +from pathlib import Path +import argparse +import copy +import gzip +import hashlib +import importlib.util +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCE = "research/p104-native-channel/" +INPUTS = { + SOURCE + name for name in ( + "inputs/LOWRANK-WITNESS.json", "inputs/P104-FIXTURE.json", + "NATIVE-RECIPES.json.gz", "vendor/native_verify.py", "PROOF.md", "SOURCES.json" + ) +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def authenticate(root=ROOT): + pins = json.loads((HERE / "SOURCES.json").read_text())["files"] + found = {item["path"] for item in pins if item["usage"] == "input"} + need(found == INPUTS, "complete precision source inventory") + for item in pins: + if item["usage"] == "input": + actual = hashlib.sha256((root / item["path"]).read_bytes()).hexdigest() + need(actual == item["sha256"], "source authentication: " + item["path"]) + + +def span(values): + result = {0} + for value in values: + result.update(x ^ value for x in tuple(result)) + return tuple(sorted(result)) + + +def add(dst, src, coefficient): + for key, value in src.items(): + total = dst.get(key, Q(0)) + coefficient * value + if total: + dst[key] = total + else: + dst.pop(key, None) + + +def norm(row): + return sum(map(abs, row.values()), Q(0)) + + +def serial_row(row): + return [[key, str(value)] for key, value in sorted(row.items())] + + +def root_ports(fixture): + roots = [] + for i, j in combinations(range(8), 2): + for sign in (-1, 1): + row = [0] * 8 + row[i], row[j] = 2, 2 * sign + roots.append(tuple(row)) + roots += [(1, *signs) for signs in product((-1, 1), repeat=7) + if signs.count(-1) % 2 == 0] + removed = {tuple(row) for row in fixture["F0"] + fixture["C"]} + ports = [row for row in sorted(roots) if row not in removed] + need(len(ports) == 104, "P104 geometry") + return ports + + +def endpoint_check(rows, ports): + for reg, actual in rows.items(): + expected = {reg: Q(1)} + if reg.startswith("Y"): + target = ports[int(reg[1:])] + expected.update({"X" + str(i): Q(sum(a * b for a, b in zip(target, source)), 8) + for i, source in enumerate(ports) + if sum(a * b for a, b in zip(target, source))}) + need(actual == expected, "arbitrary-input endpoint: " + reg) + + +def forward(word): + """Independent input and error symbols, retaining signs until each cut norm.""" + names = list(word["initial_frames"]) + rows = {reg: {reg: Q(1)} for reg in names} + errors = {reg: {} for reg in names} + frames = {reg: span(f) for reg, f in word["initial_frames"].items()} + kinds, weights = {}, {} + peaks = {"input": (Q(1), -1, names[0]), + "absolute": (Q(0), -1, names[0]), + "relative": (Q(0), -1, names[0])} + witnesses = {key: {} for key in peaks} + by_kind = {kind: (Q(0), -1, names[0]) for kind in ("transport", "add", "copy")} + stream = hashlib.sha256() + cuts, paid = [], Counter() + for index, event in enumerate(word["program"]): + op, reg = event[:2] + if op == "zero": + need(reg == "C" and reg not in rows, "fresh owned private lifetime") + rows[reg], errors[reg], frames[reg] = {}, {}, span(event[2]) + continue + need(reg in rows, "live destination") + if op == "erase": + need(reg == "C" and frames[reg] == span(event[2]), "owned discard frame") + rows.pop(reg); errors.pop(reg); frames.pop(reg) + continue + if op == "transport": + _, _, old, new, rank = event + old, new = span(old), span(new) + need(frames[reg] == old, "transport entry") + need(set(old) <= set(new) or set(new) <= set(old), "nested source transport") + need(rank == abs((len(old).bit_length() - 1) - (len(new).bit_length() - 1)), + "literal paid rank") + frames[reg] = new + paid[rank] += 1 + elif op in ("add", "copy"): + src = event[2] + need(src != reg and src in rows, "distinct live scalar operands") + need(frames[src] == frames[reg] == span(event[-1]), "common physical chart") + if op == "copy": + need(reg == "C" and not rows[reg] and not errors[reg], "zero private copy destination") + rows[reg], errors[reg] = dict(rows[src]), dict(errors[src]) + else: + add(rows[reg], rows[src], Q(event[3])) + add(errors[reg], errors[src], Q(event[3])) + else: + raise ValueError("unknown source instruction") + kinds[index] = op + weights[index] = 1 + abs(Q(event[3])) if op == "add" else Q(1) + errors[reg][index] = Q(1) + values = {"input": norm(rows[reg]), "absolute": norm(errors[reg]), + "relative": sum((abs(v) * weights[j] for j, v in errors[reg].items()), Q(0))} + for key, value in values.items(): + if value > peaks[key][0]: + peaks[key] = (value, index, reg) + witnesses[key] = dict(rows[reg] if key == "input" else errors[reg]) + for kind in by_kind: + value = sum((abs(v) for j, v in errors[reg].items() if kinds[j] == kind), Q(0)) + if value > by_kind[kind][0]: + by_kind[kind] = (value, index, reg) + cuts.append([index, reg, *[str(values[k]) for k in ("input", "absolute", "relative")]]) + stream.update(canonical([index, reg, serial_row(rows[reg]), serial_row(errors[reg])]) + b"\n") + need(set(rows) == set(names), "all private lifetimes closed") + need(frames == {reg: span(f) for reg, f in word["final_frames"].items()}, "final frame contract") + return {"rows": rows, "errors": errors, "kinds": kinds, "weights": weights, + "peaks": peaks, "witnesses": witnesses, "by_kind": by_kind, "cuts": cuts, + "cut_coefficients_sha256": stream.hexdigest(), "paid": dict(sorted(paid.items()))} + + +def reverse(word): + """Reverse adjoints of scalar instructions, with private lifetimes explicit.""" + columns = {reg: {reg: Q(1)} for reg in word["final_frames"]} + responses = {} + for index in range(len(word["program"]) - 1, -1, -1): + event = word["program"][index] + op, reg = event[:2] + if op == "erase": + need(reg not in columns, "reverse private birth") + columns[reg] = {} + elif op == "zero": + columns.pop(reg) + else: + responses[index] = dict(columns[reg]) + if op == "add": + add(columns[event[2]], columns[reg], Q(event[3])) + elif op == "copy": + add(columns[event[2]], columns[reg], Q(1)) + columns[reg] = {} + else: + need(op == "transport", "reverse instruction") + return responses, columns + + +def unitary_circuit(native, circuit): + """Structural proof premises, not a floating singular-value calculation.""" + for gate in circuit: + kind = gate[0] + if kind == "P": + need(len(gate[1]) == 9 and all(0 <= x < 512 for x in gate[1]), "nine-bit permutation") + native.inverse(gate[1]) + elif kind == "D": + need(len(gate[1]) == len(gate[2]) == 9, "nine-bit diagonal") + need(all(0 <= x < 512 for x in gate[1]), "diagonal bit range") + need(all(isinstance(x, int) for x in gate[2]), "unit-modulus Gaussian phase") + elif kind == "C": + need(0 < gate[1] < 512 and gate[2] in (-1, 1), "normalized nonzero C direction") + elif kind == "X": + need(0 <= gate[1] < 512, "translation permutation") + else: + need(kind == "phase" and isinstance(gate[1], int), "scalar unit phase") + + +def native_binding(word, certificate): + # authenticate() has run before this retained interpreter is imported. + path = ROOT / (SOURCE + "vendor/native_verify.py") + spec = importlib.util.spec_from_file_location("p104_precision_gaussian", path) + native = importlib.util.module_from_spec(spec) + spec.loader.exec_module(native) + iso = certificate["label_isometry"] + def multiply(rows, value): + return sum(((row & value).bit_count() % 2) << i for i, row in enumerate(rows)) + def convert(value): + dual_value = multiply(iso["compressed_dual_gram"], value) + return sum(((dual_value & vector).bit_count() % 2) << i + for i, vector in enumerate(iso["orthonormal_basis_compressed"])) + need(len(span(convert(1 << i) for i in range(9))) == 512, "invertible physical label map") + def key(frame): + return span(convert(value) for value in frame) + def compare(actual, expected, label): + unitary_circuit(native, actual) + unitary_circuit(native, expected) + need(native.tableau(actual) == native.tableau(expected), label + " signed Pauli action") + actual_state, denominator = native.state(actual) + need((actual_state, denominator) == native.state(expected), label + " exact scalar phase") + need(sum(a*a + b*b for a, b in actual_state.values()) == 4 ** denominator, + label + " normalized Gaussian column") + used = set() + for record in certificate["transports"]: + a, b = tuple(record["old"]), tuple(record["new"]) + compare(native.recipe(record["recipe"]), native.adjoint(native.frame(a, 9)) + native.frame(b, 9), + "native transport") + for index in record["events"]: + need(index not in used, "unique native event binding") + used.add(index) + e = word["program"][index] + need(e[0] == "transport" and key(e[2]) == span(a) and key(e[3]) == span(b), + "physical source-witness edge") + need(e[4] == record["rank"] == record["recipe"]["rank"], "native rank binding") + need(used == {i for i, e in enumerate(word["program"]) if e[0] == "transport"}, "complete native coverage") + adapters = set() + for record in certificate["endpoint_adapters"]: + reg, where = record["register"], record["position"] + normal, frame = record["normal"], tuple(record["frame"]) + need((where, reg) not in adapters and record["recipe"]["rank"] == 0, "unique monomial endpoint") + adapters.add((where, reg)) + if where == "entry": + need(key(word["initial_frames"][reg]) == span(frame), "entry frame binding") + expected = native.adjoint((("C", normal, 1),)) + native.frame(frame, 9) + else: + need(where == "exit" and key(word["final_frames"][reg]) == span(frame), "exit frame binding") + expected = native.adjoint(native.frame(frame, 9)) + (("C", normal, -1),) + native.fourier(9) + compare(native.recipe(record["recipe"]), expected, "endpoint adapter") + need(adapters == {("entry", "X"+str(i)) for i in range(104)} | + {("exit", "Y"+str(i)) for i in range(104)}, "complete endpoint coverage") + return native, {"transport_recipes": len(certificate["transports"]), "paid_occurrences": len(used), + "monomial_endpoints": len(adapters), "exact_normalized_columns": len(certificate["transports"]) + len(adapters)} + + +def injected_run(word, defects=None, inputs=None, stop=None): + """Scalar forward evaluation, independent of the coefficient-row machinery.""" + state = {reg: Q(0) for reg in word["initial_frames"]} + if inputs: + state.update(inputs) + for index, event in enumerate(word["program"]): + op, reg = event[:2] + if op == "zero": + state[reg] = Q(0) + elif op == "erase": + state.pop(reg) + elif op == "copy": + state[reg] = state[event[2]] + elif op == "add": + state[reg] += Q(event[3]) * state[event[2]] + else: + need(op == "transport", "injected execution opcode") + if defects and index in defects: + state[reg] += defects[index] + if index == stop: + break + return state + + +def reject(call, label): + try: + call() + except ValueError: + return label + raise ValueError("control accepted: " + label) + + +def controls(word, ports, result, certificate, native): + passed = [] + for which in ("input", "absolute", "relative"): + value, index, reg = result["peaks"][which] + row = result["witnesses"][which] + signs = {key: (1 if coefficient > 0 else -1) for key, coefficient in row.items()} + if which == "input": + actual = injected_run(word, inputs=signs, stop=index)[reg] + else: + defects = {j: Q(sign) * (result["weights"][j] if which == "relative" else 1) + for j, sign in signs.items()} + actual = injected_run(word, defects=defects, stop=index)[reg] + need(actual == value, "constructive signed attainment: " + which) + passed.append("attained_" + which) + need(norm(result["rows"]["Y0"]) == 26 and result["peaks"]["input"][0] == 106, + "endpoint magnitude cannot replace interior magnitude") + passed.append("endpoint_only_input_cap_rejected") + need(norm(result["errors"]["Q7"]) == 450, "restored dirt has nonzero accumulated defects") + passed.append("error_free_dirty_restoration_rejected") + copy_effect = max(sum((abs(v) for j, v in row.items() if result["kinds"][j] == "copy"), Q(0)) + for name, row in result["errors"].items() if name.startswith("Y")) + need(copy_effect == Q(3, 2), "discarded copies retain propagated errors") + passed.append("discard_erases_prior_output_errors_rejected") + for index, label in ((0, "missing_initial_compensation"), (len(word["program"])-1, "missing_final_cleanup")): + bad = copy.deepcopy(word) + bad["program"][index][3] = 0 + passed.append(reject(lambda: endpoint_check(forward(bad)["rows"], ports), label)) + bad = copy.deepcopy(word) + erase = next(i for i, e in enumerate(bad["program"]) if e[0] == "erase") + del bad["program"][erase] + passed.append(reject(lambda: forward(bad), "private_lifetime_alias")) + # Normalization is essential: omitting C's factor 1/2 multiplies its squared norm by four. + vector, denominator = native.state((("C", 1, 1),)) + need(sum(a*a+b*b for a, b in vector.values()) == 4**denominator, "normalized child control") + need(sum((2*a)**2+(2*b)**2 for a, b in vector.values()) != 4**denominator, "unnormalized child rejected") + passed.append("unnormalized_native_child_rejected") + # The norm is Hilbert, not pointwise: C(e_0+i e_1)=(1+i)e_0. + other, other_denominator = native.state((("C", 1, 1),), 1) + common = max(denominator, other_denominator) + combined = {} + for address in set(vector) | set(other): + a, b = vector.get(address, (0, 0)) + c, d = other.get(address, (0, 0)) + combined[address] = (a*2**(common-denominator) - d*2**(common-other_denominator), + b*2**(common-denominator) + c*2**(common-other_denominator)) + squared = [Q(a*a+b*b, 4**common) for a, b in combined.values()] + need(sum(squared) == 2 and max(squared) == 2, "Hilbert versus pointwise norm") + passed.append("pointwise_contraction_rejected") + # A pure phase leaves this norm interface unchanged; exact native identity must still reject it. + rec = certificate["transports"][0] + circuit = native.recipe(rec["recipe"]) + phased = circuit + (("phase", 1),) + need(native.tableau(circuit) == native.tableau(phased) and native.state(circuit) != native.state(phased), + "phase cannot be authenticated by a norm bound") + passed.append("norm_only_phase_blindness_exhibited") + K, P = Q(668), Q(106) + for bits in (0, 1, 32, 128, 1024): + u = Q(1, 2**(bits+17)) + need(K*u < 1 and P*K*u/(1-K*u) <= Q(1, 2**bits), "complete relative feedback") + insufficient = Q(1, 2**(bits+16)) + need(P*K*insufficient/(1-K*insufficient) > Q(1, 2**bits), "one fewer uniform guard bit fails bound") + need(K * Q(1, 512) >= 1, "feedback threshold is not an endpoint-only test") + passed.append("relative_feedback_and_guard_boundary") + return passed + + +def summarize(word, result, native_report): + endpoint = {} + for reg, row in sorted(result["errors"].items()): + categories = {kind: sum((abs(v) for j, v in row.items() if result["kinds"][j] == kind), Q(0)) + for kind in ("transport", "add", "copy")} + endpoint[reg] = {**{kind: str(value) for kind, value in categories.items()}, + "absolute": str(norm(row)), + "relative": str(sum((abs(v)*result["weights"][j] for j, v in row.items()), Q(0)))} + groups = {} + for group in ("source", "target", "dirty_helper"): + names = [reg for reg in endpoint if (reg.startswith("X") if group == "source" else + reg.startswith("Y") if group == "target" else not reg.startswith(("X", "Y")))] + groups[group] = {} + for kind in ("transport", "add", "copy", "absolute", "relative"): + maximum = max(Q(endpoint[reg][kind]) for reg in names) + groups[group][kind] = {"value": str(maximum), "attainers": [reg for reg in names if Q(endpoint[reg][kind]) == maximum]} + return {"status": "PASS_P104_NATIVE_PRECISION", "events": len(word["program"]), + "initial_independent_roles": len(word["initial_frames"]), + "defect_sites": dict(sorted(Counter(result["kinds"].values()).items())), + "paid_profile": result["paid"], "rank_mass": sum(k*v for k, v in result["paid"].items()), + "native_binding": native_report, + "all_cut_peaks": {key: {"value": str(value), "event": index, "register": reg, + "attaining_row_sha256": digest(serial_row(result["witnesses"][key]))} + for key, (value, index, reg) in result["peaks"].items()}, + "all_cut_type_peaks": {key: {"value": str(value), "event": index, "register": reg} + for key, (value, index, reg) in result["by_kind"].items()}, + "all_cut_count": len(result["cuts"]), "all_cut_norms_sha256": digest(result["cuts"]), + "all_cut_coefficients_sha256": result["cut_coefficients_sha256"], + "endpoint_response_nonzeros": sum(map(len, result["errors"].values())), + "endpoint_responses_sha256": digest({reg: serial_row(row) for reg, row in result["errors"].items()}), + "endpoint_group_maxima": groups, "endpoint_rows": endpoint, + "uniform_relative_guard_bits": 17, + "scope": "Exact finite source-bound native local precision interface; arbitrary independent absolute defects are sharp. State-relative feedback is a sufficient bound, not an attained numerical-kernel error. No side correction, global hosting, tape/all-size supplier admission or new kappa."} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", type=Path, help="write a new canonical receipt exclusively") + args = parser.parse_args() + authenticate() + raw = (ROOT / (SOURCE + "inputs/LOWRANK-WITNESS.json")).read_bytes() + word = json.loads(raw) + fixture = json.loads((ROOT / (SOURCE + "inputs/P104-FIXTURE.json")).read_text())["section4_explicit_P104"] + certificate = json.loads(gzip.decompress((ROOT / (SOURCE + "NATIVE-RECIPES.json.gz")).read_bytes())) + need(hashlib.sha256(raw).hexdigest() == certificate["source_witness_sha256"], "native/scalar source binding") + native, native_report = native_binding(word, certificate) + result = forward(word) + ports = root_ports(fixture) + endpoint_check(result["rows"], ports) + backward, inputs = reverse(word) + transposed = {reg: {} for reg in result["errors"]} + for index, column in backward.items(): + for reg, value in column.items(): + transposed[reg][index] = value + need(transposed == result["errors"], "all signed endpoint sensitivities agree in both directions") + need({out: {src: row[out] for src, row in inputs.items() if out in row} + for out in result["rows"]} == result["rows"], "reverse arbitrary-input map") + receipt = summarize(word, result, native_report) + receipt["controls"] = controls(word, ports, result, certificate, native) + receipt["source_witness_sha256"] = hashlib.sha256(raw).hexdigest() + if args.write: + with args.write.open("x") as stream: + json.dump(receipt, stream, indent=2, sort_keys=True) + stream.write("\n") + else: + need(canonical(receipt) == canonical(json.loads((HERE / "RESULT.json").read_text())), "complete canonical receipt") + print("PASS_P104_NATIVE_PRECISION input=106 absolute=450 relative=668 guard_bits=17 " + f"native_recipes={native_report['transport_recipes']} endpoint_coefficients={receipt['endpoint_response_nonzeros']} " + f"controls={len(receipt['controls'])} no_new_kappa") + + +if __name__ == "__main__": + main()