diff --git a/research/partial-cache-history-observer/KERNEL.json b/research/partial-cache-history-observer/KERNEL.json new file mode 100644 index 0000000000..92ca0f8333 --- /dev/null +++ b/research/partial-cache-history-observer/KERNEL.json @@ -0,0 +1,435 @@ +{ + "schema": "partial-cache-history-kernel/v1", + "original_roles": 632, + "owned_roles": 9, + "original_input_displacement": [ + [ + 0, + "1" + ], + [ + 1, + "-1" + ], + [ + 2, + "2" + ], + [ + 6, + "1" + ], + [ + 7, + "-1" + ], + [ + 12, + "-1" + ], + [ + 13, + "1" + ], + [ + 14, + "1" + ], + [ + 15, + "1" + ], + [ + 16, + "1" + ], + [ + 17, + "-1" + ], + [ + 18, + "-1" + ], + [ + 19, + "-1" + ], + [ + 27, + "-1" + ], + [ + 28, + "-1" + ], + [ + 29, + "-1" + ], + [ + 30, + "-1" + ], + [ + 31, + "1" + ], + [ + 38, + "-1" + ], + [ + 39, + "-1" + ], + [ + 40, + "-1" + ], + [ + 41, + "1" + ], + [ + 42, + "1" + ], + [ + 43, + "1" + ], + [ + 44, + "1" + ], + [ + 51, + "1" + ], + [ + 52, + "1" + ], + [ + 53, + "1" + ], + [ + 54, + "1" + ], + [ + 55, + "1" + ], + [ + 56, + "1" + ], + [ + 57, + "1" + ], + [ + 58, + "-1" + ], + [ + 59, + "-1" + ], + [ + 60, + "-1" + ], + [ + 73, + "1" + ], + [ + 74, + "1" + ], + [ + 75, + "1" + ], + [ + 76, + "1" + ], + [ + 77, + "-1" + ], + [ + 78, + "1" + ], + [ + 81, + "-1" + ], + [ + 82, + "1" + ], + [ + 83, + "1" + ], + [ + 84, + "1" + ], + [ + 86, + "-1" + ], + [ + 87, + "-1" + ], + [ + 92, + "1" + ], + [ + 93, + "-1" + ], + [ + 99, + "1" + ], + [ + 100, + "1" + ], + [ + 101, + "1" + ], + [ + 102, + "1" + ], + [ + 103, + "-1" + ], + [ + 104, + "1" + ], + [ + 105, + "1" + ], + [ + 106, + "1" + ], + [ + 113, + "-2" + ], + [ + 114, + "2" + ], + [ + 124, + "-2" + ], + [ + 224, + "2" + ], + [ + 227, + "1" + ], + [ + 229, + "-1" + ], + [ + 233, + "1" + ], + [ + 234, + "1" + ], + [ + 237, + "-1" + ], + [ + 238, + "-1" + ], + [ + 272, + "1" + ], + [ + 276, + "1" + ], + [ + 280, + "-1" + ], + [ + 283, + "-2" + ], + [ + 286, + "1" + ], + [ + 287, + "-2" + ], + [ + 336, + "1" + ], + [ + 340, + "1" + ], + [ + 347, + "-2" + ], + [ + 350, + "1" + ], + [ + 351, + "-1" + ], + [ + 352, + "1" + ], + [ + 356, + "1" + ], + [ + 366, + "1" + ], + [ + 367, + "-1" + ], + [ + 400, + "1" + ], + [ + 401, + "1" + ], + [ + 402, + "-1" + ], + [ + 403, + "2" + ], + [ + 405, + "1" + ], + [ + 406, + "1" + ], + [ + 409, + "1" + ], + [ + 410, + "-1" + ], + [ + 411, + "2" + ], + [ + 413, + "1" + ], + [ + 414, + "1" + ], + [ + 416, + "1" + ], + [ + 417, + "1" + ], + [ + 418, + "-1" + ], + [ + 419, + "2" + ], + [ + 421, + "1" + ], + [ + 422, + "1" + ], + [ + 425, + "1" + ], + [ + 426, + "-1" + ], + [ + 427, + "2" + ], + [ + 429, + "1" + ], + [ + 430, + "1" + ] + ], + "raw_target_MtY_image": [ + "0", + "-4", + "0", + "0", + "0", + "0", + "0", + "0" + ], + "parameter": "one arbitrary whole field v at every positive width; each role receives its scalar coefficient times v", + "minimality": "No support minimality claimed" +} diff --git a/research/partial-cache-history-observer/PROOF.md b/research/partial-cache-history-observer/PROOF.md new file mode 100644 index 0000000000..4cfe97e3a4 --- /dev/null +++ b/research/partial-cache-history-observer/PROOF.md @@ -0,0 +1,182 @@ +# Eight retained partial caches still do not identify the required observer + +The observation channel is the raw PR5402 backward WORD, with **every** +full-nine-dimensional-frame value retained throughout its execution, enlarged +by all eight nonzero endpoint partial-frame cache values. This is the concrete +channel excluded from PR5447's full-frame-only theorem. We prove that even +arbitrary nonlinear postprocessing of this enlarged channel cannot determine +the actual consumer target `b=ZQY_return=ZRy` on arbitrary independent inputs. + +This is not a statement about the whole machine state. In particular the +lower-frame current main inputs/outputs, original helper observations, +additional paid responses and PR5413's changed completion are not supplied +by this observation interface. No source instruction, cache lifetime or +selected provider is changed. + +## 1. Source object and original-input convention + +The canonical base is `32890bc5de034ab8fc93ac88ead7279a6a416d04`. +SOURCES.json pins the exact raw source, modified WORD, provider contracts and +physical normalizers by Git object and SHA256. The backward WORD contains +21,473 records. Native chart semantics are those of the pinned provider: +ordinary ADD/SCALE/COPY act on normalized rows at compatible charts; paid +climbs change the chart; warp records act by their signed invertible native +letter; only owned fields may be cleared. `phase` records are stage labels, +and `adapter` records retain physical entrance/exit bindings, not row updates. +These inherited native semantics and their all-width physical realization +are explicit premises, not a new supplier admission. + +Let the 632 independent original logical fields be x_0,...,x_111, +y_0,...,y_111 and h_0,...,h_407. The nine initially arbitrary owned fields +are independent too; their displacement in the two inputs below is zero. +The full-row checker initializes all 641 independent columns, verifies their +owned clearing and retains all observation events, including after intended +exits. There are 5,897 full-frame touches, with 4,891 distinct nonzero rows. +The eight endpoint caches have roles C1,...,C8 (indices 633,...,640), at +frames 254,274,619,279,621,280,624,281, respectively; every frame has rank eight. +No current main X or Y value is silently appended to the channel. + +## 2. Exact finite certificate + +KERNEL.json supplies a scalar vector k on the 632 original roles, with 104 +nonzero integer entries. Its Y block has just + + delta y_1=-2v, delta y_2=2v, delta y_12=-2v, + +where v is one arbitrary whole-field value. The file gives every compensating +X and dirty-helper coefficient; no coefficient is inferred from an endpoint +label or a clean-helper assumption. All initial owned displacements are zero. +No support-minimality claim is made. + +Write an actual normalized observation row as + + O_j = sum_(s,w) a_(j,s,w) w z_s, + +where w is a reduced free word in the source warp letters and their inverses, +and a is an exterior rational scalar. The complete full-row replay checks + + sum_s a_(j,s,w) k_s = 0 + +for every word w of every retained full-frame row. It also checks that each +of the eight complete endpoint cache rows annihilates k. The free-word +histories contain 119,521 terms. This is not PR5447's 119,515-term actual +monomial canonicalization: six terms have not been identified by additional +one-column operator relations here. The new certificate is checked in the +stronger free-word grammar, using only adjacent inverse cancellation. + +A separate direct-displacement interpreter starts with k_s v and executes +the same pinned instruction stream. It stores chronological words in the +opposite order and imports no primary parser/row code. Every one of the +5,897 full-frame events has zero displacement, including repeated/zero rows, +and all nine endpoint owned displacements are zero. This is a distinct +execution check; both implementations inherit the same source semantics. + +Let M^T be the source's eight-by-112 `mode_columns` matrix. Exact arithmetic +on the supplied vector gives + + M^T delta y = (0,-4,0,0,0,0,0,0)^T v. (1) + +Thus the target ambiguity is not inferred from dimension counting or a +numerical nonmembership result: it has a complete input witness and nonzero +specified target image. Sparse rational elimination was used only to discover +the vector. Neither its rank nor its search procedure is a proof dependency. + +## 3. Every positive width, and the actual physical target + +At width f assign each free letter its actual conjugated backward native +operator lifted columnwise to f factors, with spectators unchanged. Assign +inverse letters inverse operators. A reduced-word cancellation remains an +operator identity. Exterior rational coefficients k_s and a_(j,s,w) are +applied once; they are not tensor-powered. Therefore the coefficientwise zero +above evaluates to zero at every positive width for every v. No independence +of actual monomial matrices, width-one sum relation, Gram lift or numerical +cutoff is required. + +Physical values at a fixed chart differ from normalized rows by the chart's +invertible frame map. Zero differences remain zero at every observed full +or partial frame. Physical provider entry includes invertible birth frames, +input wrappers and its invertible helper basis/scalings. Hence the raw +logical displacement k v corresponds to two valid physical input states; +we do not claim that preparing that displacement is free. + +To bind (1) to the actual consumer, distinguish raw logical y here from the +standardized physical input y_phys of the provider contract. The checker +evaluates all 112 literal input wrappers on all 512 one-column addresses, +including absolute phase, and establishes `B_Y,j=K_p,j`. Since raw Y enters +ground chart, `y_j=K_p,j y_phys,j`. The pinned provider establishes + + Z = diag(K_m^-1) M^T diag(K_p)/2, + K_p,j R = R K_p,j, Y_return=D y_phys, R=DQ. + +These monomial/full-Gaussian identities lift multiplicatively to every width; +the scalar owner coefficients stay exterior. Consequently the actual target +in raw input coordinates is + + b_k = (1/2) K_m,k^-1 R sum_j M_kj y_j. (2) + +No separate commutation of K_p with Q or D is asserted. Inserting (1) gives +zero change in seven target modes and + + delta b_1 = -2 K_m,1^-1 R v. (3) + +R and K_m,1 are invertible, so (3) is nonzero for every nonzero v and ranges +over the whole target field. Two valid inputs have identical entire supplied +channels and identical other seven b modes, but arbitrary differing b_1. +No deterministic exact decoder of this channel can recover b, or any +nonconstant function of b_1 alone. Randomness cannot give a universally exact +decoder of indistinguishable inputs either. No approximation/error lower bound +or physical price lower bound is inferred. + +## 4. Why helper versions matter + +The checker reconstructs every coefficient of all eight cache rows and binds +their slot, chart, permutation and signed scale to PROVIDER.json: + + c_i = f_i (E_k h_original - M_k^T y), + f_i = 1/(2 cache_scalar_i), k=mode(i). (4) + +For the new witness, `E delta h_original` equals the right side of (1). +The helper changes exactly hide the Y change in every cache. The old +fixed-helper ambiguity `(delta x,delta y,delta h)=(v,v,0)` is insufficient +here: the eight new caches genuinely add information. Eight separate controls +take y=M_k and x=y; full-frame values still agree, while exactly cache mode k +changes, using `M^T M=56 I`. We do not just reuse the earlier kernel. + +If the **original** eight retractions `e=E h_original` were separately supplied, +(4) would give `M_k^T y=e_k-c_i/f_i`, and then (2) is an unrestricted linear +decoder for b. This is a changed observation interface; it does not establish +that e was retained, that an inverse cache-frame map is ordinary, or that the +required R action is free. Every such observation/transform and its retention +would need a physical bill before supplier use. + +The tempting substitute `E h_current` is invalid. Fresh complete-row replay +proves `E h_current=0` at the raw WORD endpoint, for every original input. +For this witness `E delta h_original` has mode one equal to -4v, while the +same endpoint expression remains zero. Using it in the conditional decoder +would return zero change although the true target changes by (3). Freezing +the witness's helper displacements also exposes 821 full-frame observations; +the first is at zero-based event 16,366. Removing its X compensation exposes +924 observations, first at event 15,523. The roles and versions are substantive +parts of the impossibility statement. + +## 5. Scope, consequences and credit + +This closes the passive endpoint-cache candidate for this exact observer: +retaining all full-frame values and all eight already-created endpoint caches +still does not supply `ZQY_return` on unrestricted original inputs. It does not +exclude a different partial-frame history, an original-helper observation, +retained current Y, changed producer, new paid call or a relation restricting +the independent inputs. Ordinary output-basis operations cannot rescue this +channel: they combine already retained full-frame endpoints, and normalizing +or relabelling the eight caches preserves their zero differences. The whole +machine state is not claimed to be Y-blind. No recursive profile, selected +frontier, complete multiplication theorem or new kappa is asserted. + +Credit Dillon Amburgey / dillona's PR5402 source and cache equations; Ali +Romman's cache/retraction and basis lineage; Mark/Matarener's PR5427 event and +versioned-history question; THU New Media Research Center's PR5447 full-frame +kernel and explicitly excluded partial-cache boundary; zxv's PR5415/5419 +actual consumer and observer contract; Cao Yifan's native word and the +retained Cinna Davis, Dugongue, Chris R and native/phase/compiler/analytic +contributors. JoyboyBrian with substantial OpenAI Codex assistance. +Apache-2.0. No independent human or proof-kernel acceptance is claimed. diff --git a/research/partial-cache-history-observer/README.md b/research/partial-cache-history-observer/README.md new file mode 100644 index 0000000000..bd7558899a --- /dev/null +++ b/research/partial-cache-history-observer/README.md @@ -0,0 +1,126 @@ +# Eight endpoint caches do not supply the coupled-query observer + +All eight actual raw-PR5402 partial-frame endpoint caches, together with every +retained full-frame native value, still cannot determine the consumer's +`b=ZQY_return=ZRy` on arbitrary independent original inputs. An exact 104-role +input displacement leaves the entire enlarged channel unchanged but changes +mode one of b by an invertible map of an arbitrary whole field. This is an +all-positive-width information obstruction, with no new kappa or physical +price lower bound. + +The result closes the endpoint-cache case explicitly excluded by +[PR5447](https://github.com/CrocSwap/integer-mult-bounds/pull/5447). Its old +fixed-helper kernel is not reused: each of the eight caches defeats one such +old kernel direction. The new witness changes 57 X inputs, three Y inputs +and 44 dirty helper inputs; all nine initial owned inputs stay fixed. + +[PROOF.md](PROOF.md) states the exact channel and the uniform implication. +[KERNEL.json](KERNEL.json) supplies every displacement coefficient. +[RESULT.json](RESULT.json) records the complete source-bound check: + +- 21,473 source records, 5,897 full-frame touches and 4,891 distinct nonzero + full-frame observations, including all versions after intended exits. +- All eight nonzero rank-eight endpoint caches included at their actual slots + and frames; arbitrary initial owned dirt is represented and cleared. +- Exact `M^T delta Y=(0,-4,0,0,0,0,0,0)` and all 112 input-Y wrapper phase + bindings. The actual observer changes by `-2 K_m,1^-1 R v` in mode one. +- Original helper retraction changes by the same raw target vector, hiding it + in the caches. The corresponding **post-word** helper retraction is exactly + zero on every input, so it is not an interchangeable observation. +- Freezing helper displacements or removing X compensation exposes the + source histories; eight controls show each added cache supplies genuinely + new information relative to the earlier full-frame channel. + +The primary engine tracks all 641 independent input columns in the free-word +algebra and checks every coefficient. The separate direct-displacement engine +imports none of its parser or row code and checks every full-frame event, +storing chronological words in the opposite order. Both inherit the pinned +normalized native semantics. This separation is not independent human review +or a new physical proof of the native instructions. + +## Reproduce and source contract + +```sh +python3.12 -B scripts/research_package.py --package research/partial-cache-history-observer +python3.12 -B scripts/check_research_commit.py --package research/partial-cache-history-observer --check-source-history +``` + +Direct normal and optimized commands use only the standard library: + +```sh +python3.12 -I -B research/partial-cache-history-observer/verify.py +python3.12 -I -O -B research/partial-cache-history-observer/verify.py +python3.12 -I -B research/partial-cache-history-observer/check_displacement.py +python3.12 -I -O -B research/partial-cache-history-observer/check_displacement.py +python3.12 -I -B research/partial-cache-history-observer/test_package.py +``` + +Six disposable on-disk controls reject a changed Y coefficient, a vacuous +kernel, changed input bytes, a missing receipt, a Boolean changed to integer +one, and a wrong event count. Kernel/source controls bypass stored-receipt +comparison; all child checks run under optimization. Typed canonical JSON +comparison prevents Python Boolean/integer equality from authenticating an +altered receipt. + +Four actual JSON/gzip inputs are declared in VERIFY.json and authenticated by +SOURCES.json. The official exporter includes them at their exact paths; no +`--input-ref` is needed because all use the canonical base source bytes. +Direct replay from that export needs no Git or remote object. The older proof +and checker paths are provenance-only references, not runtime imports; the +external PR5447 citation is not a pending Git-object dependency. Source-history +preflight checks the declared canonical pins, not the truth of external prose. + +Sparse rational elimination discovered the witness. The certificate and +replay do not depend on that search, a modular rank, actual monomial +independence or a numerical tensor cutoff. Coefficientwise free-word +cancellation proves the invariant after any consistent all-width native +assignment. The primary representation has 119,521 terms; PR5447's actual +monomial canonicalization has 119,515. They are deliberately not identified +as the same representation or count. + +## Meaning of the negative result + +The whole machine is not claimed to hide Y. Lower-frame main values, other +partial-frame histories, original helper observations, changed words and extra +paid responses give different information. Physical entrance bases and chart +maps are invertible, so the raw witness corresponds to legal independent +physical inputs; no free physical preparation is asserted. Actual normalizers +and their R-commutation are retained source premises, with input-Y equality +checked here including phase. + +If the original eight retractions `E h_original` were supplied, the exact +cache formula would recover `M^T Y` and yield an unrestricted linear decoder +for b. That conditional observation is not available from the post-word +retraction, and its retention, frame transforms and Gaussian action have not +been priced. No decoder, observer job, new return credit, complete supplier +bill, finite-precision guarantee or selected-frontier change is claimed. + +[Discussion5488](https://github.com/CrocSwap/integer-mult-bounds/discussions/5488) +is the canonical investigation. The base is +`32890bc5de034ab8fc93ac88ead7279a6a416d04`, priority revision seven. +The changed task scope and overlap coverage are recorded in TASK.json. +PR5489's parallel local helper-transport contract concerns another fixed block +and role, not this complete-history/cache channel. + +## Open next questions + +Identify one actual correctly versioned source for original helper modes or +another useful partial-frame observation, then test the explicit witness at +that cut and charge its ownership, retention, transforms and cleanup. Merely +postprocessing this unchanged enlarged channel cannot resolve the ambiguity. +TASK.json gives the concrete first steps and missing contracts. + +## Credit + +Dillon Amburgey / dillona's PR5402 supplies the provider and its native row +semantics; Ali Romman supplies the cache/retraction/basis lineage; +Mark/Matarener's PR5427 and THU New Media Research Center's PR5447 supply the +history question and earlier kernel; zxv's PR5415/5419 supplies the actual +consumer and observer interface. Cao Yifan, Cinna Davis, Dugongue, Chris R, +Jacob Alan Sussman and the retained native/phase/compiler/analytic contributors +retain their credit and notices. The literal monomial evaluator adapts zxv's +canonical consumer checker, with attribution in the source. + +JoyboyBrian with substantial OpenAI Codex assistance in source inspection, +witness discovery, proof, implementation, controls and writing. Apache-2.0. +No independent human or formal-kernel acceptance is claimed. diff --git a/research/partial-cache-history-observer/RESULT.json b/research/partial-cache-history-observer/RESULT.json new file mode 100644 index 0000000000..8a92397a47 --- /dev/null +++ b/research/partial-cache-history-observer/RESULT.json @@ -0,0 +1,89 @@ +{ + "cache_frames": [ + 254, + 274, + 619, + 279, + 621, + 280, + 624, + 281 + ], + "cache_slots": [ + 633, + 634, + 635, + 636, + 637, + 638, + 639, + 640 + ], + "current_helper_retraction_is_zero": true, + "distinct_nonzero_full_frame_histories": 4891, + "events": 21473, + "free_word_history_terms": 119521, + "full_frame_touches_including_zero": 5897, + "negative_controls": { + "X-compensator-missing": { + "first_event": 15523, + "full_frame_failures": 924 + }, + "helpers-frozen": { + "first_event": 16366, + "full_frame_failures": 821 + } + }, + "old_kernel_cache_sensitivities": [ + [ + 0 + ], + [ + 1 + ], + [ + 2 + ], + [ + 3 + ], + [ + 4 + ], + [ + 5 + ], + [ + 6 + ], + [ + 7 + ] + ], + "original_helper_retraction_image": [ + "0", + "-4", + "0", + "0", + "0", + "0", + "0", + "0" + ], + "owned_inputs_cleared": 9, + "phase_bound_Y_wrappers": 112, + "physical_target_mode1": "-2 Km_1^-1 R applied to arbitrary displacement field", + "raw_target_image": [ + "0", + "-4", + "0", + "0", + "0", + "0", + "0", + "0" + ], + "scope": "all-width coefficientwise witness; no claim about whole machine state or new observations", + "status": "PASS_PARTIAL_CACHE_HISTORY_OBSERVER_KERNEL", + "witness_nonzero_original_roles": 104 +} diff --git a/research/partial-cache-history-observer/SOURCES.json b/research/partial-cache-history-observer/SOURCES.json new file mode 100644 index 0000000000..2c13b8463d --- /dev/null +++ b/research/partial-cache-history-observer/SOURCES.json @@ -0,0 +1,73 @@ +{ + "schema_version": 1, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/native-rank8-helper-provider/PROVIDER.json", + "usage": "input", + "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455", + "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65" + }, + { + "path": "research/native-rank8-helper-provider/WORD.json.gz", + "usage": "input", + "git_blob": "f3111b47e89496da8ca0ee45b2e4b258c0634d8e", + "sha256": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + }, + { + "path": "research/native-rank8-helper-provider/PROOF.md", + "usage": "provenance", + "git_blob": "5cbfc4fd02dce926c3d235f1549bdb2035dea088", + "sha256": "2d59282f3b5e9fb848d0099ce91729fa433162e6975f877a441e2ab4f57a29c5" + }, + { + "path": "research/native-rank8-helper-provider/verify.py", + "usage": "provenance", + "git_blob": "b62af49c87864ad9337f3964b2515ba53de85d4f", + "sha256": "121d87787c0f76bd530b6e1682704a311e96dfb33d787bea2ba29a1d0e5ee23e" + }, + { + "path": "research/coupled-query-transport/PROOF.md", + "usage": "provenance", + "git_blob": "d25beb53d0ce348699d06ab2592eefe9b9535c2d", + "sha256": "7800d634593e4f8cc71739c89ee3b7f52ddcd43a10a6b275d684006d4e5850d7" + }, + { + "path": "research/coupled-query-transport/verify.py", + "usage": "provenance", + "git_blob": "60e86786badc7323f3f3073733a2a1c593048022", + "sha256": "fc75121baaeb278c160451e21ffa2f903c92283ffbf913eb86ada03fed98056f" + } + ], + "external_references": [ + { + "commit": "be292a4c2724a17c7401bb736f969e898c43f0f2", + "url": "https://github.com/thu-nmrc/integer-mult-bounds/blob/be292a4c2724a17c7401bb736f969e898c43f0f2/research/physical-zqy-scalar-span/KERNEL-PROOF.md", + "role": "Inspected full-frame-only predecessor and explicit omitted-cache interface. No code imported or unmerged-object replay dependency." + } + ] +} diff --git a/research/partial-cache-history-observer/TASK.json b/research/partial-cache-history-observer/TASK.json new file mode 100644 index 0000000000..a5c8008850 --- /dev/null +++ b/research/partial-cache-history-observer/TASK.json @@ -0,0 +1,104 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Determine actual ZQY_return observability after adding all eight raw5402 endpoint partial caches to the complete retained full-frame history, with independent dirty original inputs.", + "scope_change_reason": "Explicit PR5447 partial-frame handoff and assigned current observer supersede historical four-provider dispatch card; no new producer/invoice construction.", + "bottleneck_link": "Closes a concrete candidate source for the eight-field observer required by the actual coupled-query consumer; no free original-helper observation is assumed.", + "budget_minutes": 60, + "stop_rule": "Stop at source-bound all-width witness or decoder for this exact enlarged channel; do not rerun frontier or infer a physical observer price.", + "outcome": "negative-result", + "evidence": "PROOF.md; KERNEL.json; exact full-row RESULT.json; separate direct-displacement check; README.md scope/reproduction.", + "author": "JoyboyBrian", + "ai_assistance": "Substantial OpenAI Codex assistance in source inspection, exact witness discovery, proof, implementation, adversarial checks and writing.", + "open_questions": [ + { + "question": "Which correctly versioned nonfree observation could supply original E h or directly b at the real caller cut?", + "why_it_matters": "The full-frame plus endpoint-cache channel cannot determine b; endpoint E h_current is identically zero and cannot replace original modes.", + "first_step": "Name a real source event and original input ownership, then derive its complete arbitrary-input map and retention/transform/cleanup cost.", + "blocked_by": "No priced source for original helper retractions or alternate b observation is supplied." + }, + { + "question": "Does another specified partial-frame history expose a useful original-helper mode without changing the paid producer?", + "why_it_matters": "Only eight endpoint caches are added here; other partial histories change the observation interface.", + "first_step": "Choose one justified actual chronological cut and test this explicit kernel there before searching for a decoder.", + "blocked_by": "Actual ownership, physical reading permission and complete cost consequence must be specified." + } + ], + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5488", + "overlap": { + "open_prs": 352, + "discussion_records": 4747, + "fetched_at": "2026-10-25T04:14:44.963072+00:00", + "complete_pagination": true, + "parallel_distinction": "PR5489 helper-transport-contract concerns local block[9044,9137) and role505; not this raw5402 complete-history endpoint-cache channel. Unpublished work and all historical diffs not exhaustively covered." + } +} diff --git a/research/partial-cache-history-observer/VERIFY.json b/research/partial-cache-history-observer/VERIFY.json new file mode 100644 index 0000000000..b81f826b6a --- /dev/null +++ b/research/partial-cache-history-observer/VERIFY.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/coded-native-caller/NORMALIZERS.json", + "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "research/native-rank8-helper-provider/PROVIDER.json", + "research/native-rank8-helper-provider/WORD.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Complete641-input free-word observation/cache/target kernel, physical input phases and dirtyhelper/version controls" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Complete641-input free-word observation/cache/target kernel, physical input phases and dirtyhelper/version controls" + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/check_displacement.py" + ], + "timeout_seconds": 60, + "checks": "Separate direct-displacement replay of all5897fullframe events and allendpointcaches without primary imports" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/check_displacement.py" + ], + "timeout_seconds": 60, + "checks": "Separate direct-displacement replay of all5897fullframe events and allendpointcaches without primary imports" + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_package.py" + ], + "timeout_seconds": 120, + "checks": "Six on-disk optimized kernel/source/missing/typed receipt controls; semantic kernel controls bypass stored receipt" + } + ] +} diff --git a/research/partial-cache-history-observer/check_displacement.py b/research/partial-cache-history-observer/check_displacement.py new file mode 100644 index 0000000000..4d692e8fe9 --- /dev/null +++ b/research/partial-cache-history-observer/check_displacement.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +"""Separate direct-displacement execution, without the full-row engine. + +Chronological words are stored in the opposite order to verify.py; no parser, +row operation or result is imported from that engine. Both implement the +source's normalized native chart semantics, which remain an inherited premise. +JoyboyBrian, substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import defaultdict +from fractions import Fraction +from hashlib import sha256 +from pathlib import Path +import gzip +import json + +P = Path(__file__).resolve().parent + + +def demand(ok, why): + if not ok: + raise RuntimeError(why) + + +def load(): + result = {} + for row in json.loads((P/'SOURCES.json').read_text())['files']: + if row['usage'] == 'input': + content = (P.parent.parent/row['path']).read_bytes() + demand(sha256(content).hexdigest() == row['sha256'], 'source hash') + if row['path'].endswith('.gz'): + content = gzip.decompress(content) + result[Path(row['path']).name] = json.loads(content) + return result + + +def run(canonical, word, coefficients): + values = {('L', i): ({(): coefficients[i]} if coefficients.get(i) else {}) for i in range(632)} + charts = {('L', i): frame for i, frame in enumerate(canonical['start'])} + for i in range(9): + values['C', i] = {} + charts['C', i] = None + full_events, failures = 0, [] + for at, record in enumerate(word): + tag = record[0] + changed = None + if tag == 'scalar': + op, chart = record[1:] + kind, changed = op[0], tuple(op[1]) + if kind == 'clear': + demand(changed[0] == 'C', 'persistent clear') + values[changed] = {} + elif kind == 'copy': + demand(not values[changed] and charts[tuple(op[2])] == chart, 'owned copy') + values[changed] = dict(values[tuple(op[2])]) + elif kind == 'scale': + demand(charts[changed] == chart, 'scale chart') + coefficient = Fraction(op[2], op[3]) + values[changed] = {w: x*coefficient for w, x in values[changed].items() if x*coefficient} + else: + demand(kind == 'add' and charts[changed] == charts[tuple(op[2])] == chart, 'ADD chart') + accum = defaultdict(Fraction, values[changed]) + for w, x in values[tuple(op[2])].items(): + accum[w] += x*Fraction(op[3], op[4]) + values[changed] = {w:x for w,x in accum.items() if x} + charts[changed] = chart + elif tag == 'warp': + _, role, symbol, old, new = record + changed = tuple(role) + demand(charts[changed] == old, 'warp chart') + accum = defaultdict(Fraction) + for chronological, x in values[changed].items(): + next_word = chronological[:-1] if chronological and chronological[-1] == -symbol else chronological+(symbol,) + accum[next_word] += x + values[changed] = {w:x for w,x in accum.items() if x} + charts[changed] = new + elif tag == 'climb': + _, _, owner, old, new, rank = record + changed = ('L', owner) + demand(charts[changed] == old and rank == len(canonical['frames'][new])-len(canonical['frames'][old]), 'climb chart') + charts[changed] = new + elif tag == 'center': + _, owner, old, new, rank = record + changed = ('C', owner) + demand(charts[changed] == old and rank == abs(len(canonical['frames'][new])-len(canonical['frames'][old])), 'center chart') + charts[changed] = new + elif tag == 'zero_retag': + _, owner, old, new = record + changed = ('L', owner) + demand(charts[changed] == old and not values[changed], 'zero retag') + charts[changed] = new + else: + demand(tag in ('phase', 'adapter'), 'unexpected record') + if changed is not None and len(canonical['frames'][charts[changed]]) == 9: + full_events += 1 + if values[changed]: + failures.append(at) + return values, charts, full_events, failures + + +def main(): + data = load() + coefficients = {int(j): Fraction(c) for j,c in json.loads((P/'KERNEL.json').read_text())['original_input_displacement']} + values, charts, count, failures = run(data['ACTUAL-WORD.json.gz']['canonical'], data['WORD.json.gz']['word'], coefficients) + demand(not failures and count > 4891, 'all full-frame events invisible, including zero and repeated versions') + demand(all(not values['C', j] for j in range(9)), 'all nine endpoint owned displacements vanish') + m = data['NORMALIZERS.json']['mode_columns'] + image = [sum(Fraction(v)*coefficients.get(112+j, Fraction()) for j,v in enumerate(row)) for row in m] + demand(image == [Fraction(0), Fraction(-4), *([Fraction(0)]*6)], 'actual target image') + # A basis-free conditional decoder needs ORIGINAL E h, not its zero endpoint. + identity_checks = 0 + for rec in data['PROVIDER.json']['mode_boundaries']: + k, slot = rec['mode'], rec['cache_slot']-632 + demand(charts['C', slot] == rec['frame'], 'endpoint cache chart') + original = sum(Fraction(c)*coefficients.get(224+j, Fraction()) + for j,c in data['PROVIDER.json']['canonical_retraction_E'][k]) + demand(original-image[k] == 0, 'cache cancellation by original helper change') + identity_checks += 1 + print(json.dumps({'status':'PASS_DIRECT_PARTIAL_CACHE_DISPLACEMENT', + 'full_frame_events':count, 'endpoint_owned_zero_displacements':9, + 'original_helper_cache_checks':identity_checks, + 'target_image':[str(x) for x in image], + 'execution':'single displacement, chronological free words, independent implementation'}, + sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/partial-cache-history-observer/test_package.py b/research/partial-cache-history-observer/test_package.py new file mode 100644 index 0000000000..30bb601647 --- /dev/null +++ b/research/partial-cache-history-observer/test_package.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +"""On-disk semantic/source/typed-receipt controls in a disposable export layout. + +JoyboyBrian, substantial OpenAI Codex assistance. Apache-2.0. +""" +from pathlib import Path +import json +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent + + +def main(): + with tempfile.TemporaryDirectory(prefix='partial-cache-boundary-') as name: + root = Path(name) + package = root/'research'/HERE.name + package.mkdir(parents=True) + for filename in ('verify.py', 'KERNEL.json', 'RESULT.json', 'SOURCES.json'): + shutil.copyfile(HERE/filename, package/filename) + source_paths = json.loads((HERE/'VERIFY.json').read_text())['inputs'] + for path in source_paths: + destination = root/path + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(HERE.parent.parent/path, destination) + kernel_bytes = (package/'KERNEL.json').read_bytes() + receipt_bytes = (package/'RESULT.json').read_bytes() + source_path = root/source_paths[0] + source_bytes = source_path.read_bytes() + results = [] + for case, diagnostic in [ + ('kernel-Y-sign', 'full-frame witness kernel'), + ('vacuous-kernel', 'original input domain'), + ('source-byte-drift', 'source drift'), + ('missing-receipt', 'RESULT.json'), + ('typed-receipt-bool-as-int', 'typed receipt mismatch'), + ('wrong-receipt-count', 'typed receipt mismatch'), + ]: + (package/'KERNEL.json').write_bytes(kernel_bytes) + (package/'RESULT.json').write_bytes(receipt_bytes) + source_path.write_bytes(source_bytes) + kernel, receipt = json.loads(kernel_bytes), json.loads(receipt_bytes) + if case == 'kernel-Y-sign': + row = next(row for row in kernel['original_input_displacement'] if row[0] == 113) + row[1] = '2' + (package/'KERNEL.json').write_text(json.dumps(kernel)) + elif case == 'vacuous-kernel': + for row in kernel['original_input_displacement']: + row[1] = '0' + (package/'KERNEL.json').write_text(json.dumps(kernel)) + elif case == 'source-byte-drift': + source_path.write_bytes(source_bytes+b' ') + elif case == 'missing-receipt': + (package/'RESULT.json').unlink() + elif case == 'typed-receipt-bool-as-int': + receipt['current_helper_retraction_is_zero'] = 1 + if receipt != json.loads(receipt_bytes): + raise RuntimeError('old untyped comparison control did not match') + (package/'RESULT.json').write_text(json.dumps(receipt)) + else: + receipt['events'] -= 1 + (package/'RESULT.json').write_text(json.dumps(receipt)) + # The kernel controls bypass the stored receipt so an active + # source/witness predicate, not a stale hash, must catch them. + flags = ['--emit'] if case in ('kernel-Y-sign', 'vacuous-kernel', 'source-byte-drift') else [] + run = subprocess.run([sys.executable, '-I', '-O', '-B', str(package/'verify.py'), *flags], + cwd=root, capture_output=True, text=True, timeout=20) + if run.returncode == 0 or diagnostic not in run.stderr: + raise RuntimeError('boundary control escaped '+case+' '+run.stderr) + results.append({'case': case, 'rejection': diagnostic}) + print(json.dumps({'status': 'PASS_PARTIAL_CACHE_PACKAGE_BOUNDARIES', + 'optimized_rejections': results}, indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/partial-cache-history-observer/verify.py b/research/partial-cache-history-observer/verify.py new file mode 100644 index 0000000000..a615ddfc9c --- /dev/null +++ b/research/partial-cache-history-observer/verify.py @@ -0,0 +1,239 @@ +#!/usr/bin/env python3 +"""Full independent-input rows for the actual raw provider observation channel. + +Native event/chart semantics adapted from Dillon Amburgey's canonical +native-rank8-helper-provider/verify.py; free-word observation question credited +to Mark/Matarener #5427 and THU New Media Research Center #5447. +New enlarged-channel witness and checks: JoyboyBrian, substantial OpenAI Codex +assistance. Apache-2.0. No numerical operator independence is assumed. +""" +from collections import Counter +from fractions import Fraction as F +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def inputs(): + manifest = json.loads((HERE/'SOURCES.json').read_text()) + data = {} + for pin in manifest['files']: + if pin['usage'] != 'input': + continue + raw = (ROOT/pin['path']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'], 'source drift '+pin['path']) + data[Path(pin['path']).name] = json.loads(gzip.decompress(raw) if pin['path'].endswith('.gz') else raw) + return data + + +def address(ref): + need(ref[0] in ('L', 'C'), 'role kind') + n = ref[1] + (632 if ref[0] == 'C' else 0) + need(0 <= n < 641, 'role range') + return n + + +def plus(row, other, factor=F(1)): + for key, value in tuple(other.items()): + value = row.get(key, F()) + factor*value + if value: + row[key] = value + else: + row.pop(key, None) + + +def replay(canon, events): + rows = [{(j, ()): F(1)} for j in range(641)] + frames = list(canon['start'])+[None]*9 + full = {j for j, vectors in enumerate(canon['frames']) if len(vectors) == 9} + need(full == {1} and not any(f in full for f in frames), 'full-frame entrance convention') + histories, seen = [], set() + touches = 0 + cleared_dirt = set() + for event, e in enumerate(events): + kind, touched = e[0], None + if kind == 'scalar': + op, frame = e[1:] + dst = address(op[1]); touched = dst + if op[0] == 'clear': + need(dst >= 632, 'no persistent clear') + if any(j >= 632 for j, word in rows[dst]): + cleared_dirt.add(dst) + rows[dst], frames[dst] = {}, frame + elif op[0] in ('add', 'copy'): + src = address(op[2]) + need(frames[src] == frame, 'source frame') + if op[0] == 'copy': + need(dst >= 632 and not rows[dst], 'copy into owned zero') + rows[dst], frames[dst] = dict(rows[src]), frame + else: + need(frames[dst] == frame and dst != src, 'ADD frame and alias') + plus(rows[dst], rows[src], F(op[3], op[4])) + else: + need(op[0] == 'scale' and frames[dst] == frame, 'scale frame') + q = F(op[2], op[3]) + rows[dst] = {key: q*v for key, v in rows[dst].items() if q*v} + elif kind == 'warp': + _, ref, op, old, new = e + dst = address(ref); touched = dst + need(frames[dst] == old and op, 'warp frame/symbol') + out = {} + for (j, word), q in rows[dst].items(): + reduced = word[1:] if word and word[0] == -op else (op,)+word + plus(out, {(j, reduced): q}) + rows[dst], frames[dst] = out, new + elif kind in ('climb', 'center'): + if kind == 'climb': + _, _, dst, old, new, rank = e + expected = len(canon['frames'][new])-len(canon['frames'][old]) + else: + _, slot, old, new, rank = e + dst = 632+slot + expected = abs(len(canon['frames'][new])-len(canon['frames'][old])) + need(frames[dst] == old and rank == expected and rank > 0, 'paid chart transition') + frames[dst], touched = new, dst + elif kind == 'zero_retag': + _, dst, old, new = e + need(frames[dst] == old and not rows[dst], 'exact-zero retag') + frames[dst], touched = new, dst + else: + need(kind in ('phase', 'adapter'), 'unknown event') + if touched is not None and frames[touched] in full: + touches += 1 + if rows[touched]: + key = frozenset(rows[touched].items()) + if key not in seen: + seen.add(key) + histories.append((event, touched, dict(rows[touched]))) + need(cleared_dirt == set(range(632, 641)), 'all nine arbitrary owned inputs cleared') + need(not any(j >= 632 for row in rows for j, word in row), 'owned dirt absent at exit') + return histories, rows, frames, touches + + +def residual(row, displacement): + out = {} + for (owner, word), value in row.items(): + q = value*displacement.get(owner, F()) + if q: + plus(out, {word: q}) + return out + + +def scalar_combine(coefficients, rows, offset): + out = {} + for j, c in coefficients: + plus(out, rows[offset+j], F(c)) + return out + + +def table(word): + """Literal phase-aware monomial action, adapted from zxv's consumer checker.""" + out = [] + for x in range(512): + y, phase = x, 0 + for g in word: + if g[0] == 'P': + y = sum(((r & y).bit_count() % 2) << j for j, r in enumerate(g[1])) + elif g[0] == 'D': + phase += sum(c for j, c in enumerate(g[2]) if y >> j & 1) + phase += 2*sum(((g[1][j] >> (j+1)) & (y >> (j+1))).bit_count() % 2 + for j in range(9) if y >> j & 1) + elif g[0] == 'X': + y ^= g[1] + else: + need(g[0] == 'phase', 'monomial instruction') + phase += g[1] + out.append((y, phase % 4)) + need(len({y for y, phase in out}) == 512, 'monomial invertible') + return out + + +def verify(): + data = inputs() + canon = data['ACTUAL-WORD.json.gz']['canonical'] + program = data['WORD.json.gz']['word'] + provider, normal = data['PROVIDER.json'], data['NORMALIZERS.json'] + kernel = json.loads((HERE/'KERNEL.json').read_text()) + displacement = {j: F(c) for j, c in kernel['original_input_displacement']} + need(len(displacement) == len(kernel['original_input_displacement']) == 104, + 'unique nonzero 104-role witness') + need(all(0 <= j < 632 and c for j, c in displacement.items()), 'original input domain') + histories, rows, frames, touches = replay(canon, program) + need(len(histories) == 4891, 'complete distinct full-frame history') + need(all(not residual(row, displacement) for _, _, row in histories), 'full-frame witness kernel') + need(all(rows[j] and len(canon['frames'][frames[j]]) == 8 for j in range(633, 641)), + 'all eight nonzero partial-frame caches included') + need(all(not residual(rows[j], displacement) for j in range(633, 641)), 'endpoint cache kernel') + m = normal['mode_columns'] + e = provider['canonical_retraction_E'] + image = [sum(F(c)*displacement.get(112+j, F()) for j, c in enumerate(row)) for row in m] + need(image == [F(0), F(-4), *([F(0)]*6)], 'nonzero one-mode target image') + helper_image = [sum(F(c)*displacement.get(224+j, F()) for j, c in row) for row in e] + need(helper_image == image, 'original-helper compensation') + for record in provider['mode_boundaries']: + k, slot = record['mode'], record['cache_slot'] + factor = 1/(2*F(record['cache_scalar'])) + expected = {(j+224, ()): factor*F(c) for j, c in e[k]} + plus(expected, {(j+112, ()): -factor*F(c) for j, c in enumerate(m[k]) if c}) + need(rows[slot] == expected and frames[slot] == record['frame'], 'complete cache formula/version') + need(all(not scalar_combine(row, rows, 224) for row in e), 'current helper retraction is zero') + + # Exact physical input binding; no cost-free execution of these maps claimed. + for port in normal['ports']: + need(table(port['K_word']) == table(port['compiled_wrappers']['backward_input_Y']['word']), + 'BY equals Kp with absolute phase') + controls = {} + for name, mutant in [('helpers-frozen', {j:c for j,c in displacement.items() if j < 224}), + ('X-compensator-missing', {j:c for j,c in displacement.items() if j >= 112})]: + failures = [event for event, _, row in histories if residual(row, mutant)] + need(failures, 'control failed '+name) + controls[name] = {'full_frame_failures': len(failures), 'first_event': failures[0]} + # Each newly included cache defeats one old fixed-helper X=Y kernel direction. + sensitivities = [] + for k in range(8): + old = {j: F(m[k][j % 112]) for j in range(224) if m[k][j % 112]} + need(all(not residual(row, old) for _, _, row in histories), 'old full-frame kernel') + leaking = [r['mode'] for r in provider['mode_boundaries'] if residual(rows[r['cache_slot']], old)] + need(leaking == [k], 'each cache contributes its specified new information') + sensitivities.append(leaking) + # Original helper modes reveal the ambiguity; post-word modes do not. + need(helper_image[1] == -4 and not residual(scalar_combine(e[1], rows, 224), displacement), + 'stale helper version control') + changed = list(normal['ports'][0]['compiled_wrappers']['backward_input_Y']['word'])+[['phase', 2]] + need(table(changed) != table(normal['ports'][0]['K_word']), 'physical phase control') + need(all(not residual(row, {}) for _, _, row in histories) and not any( + sum(F(c)*{}.get(112+j, F()) for j, c in enumerate(row)) for row in m), + 'zero kernel cannot establish target ambiguity') + return {'status': 'PASS_PARTIAL_CACHE_HISTORY_OBSERVER_KERNEL', + 'events': len(program), 'full_frame_touches_including_zero': touches, + 'distinct_nonzero_full_frame_histories': len(histories), + 'free_word_history_terms': sum(len(row) for _, _, row in histories), + 'cache_slots': list(range(633, 641)), 'cache_frames': frames[633:641], + 'witness_nonzero_original_roles': len(displacement), + 'raw_target_image': [str(x) for x in image], + 'original_helper_retraction_image': [str(x) for x in helper_image], + 'current_helper_retraction_is_zero': True, + 'phase_bound_Y_wrappers': 112, 'owned_inputs_cleared': 9, + 'negative_controls': controls, 'old_kernel_cache_sensitivities': sensitivities, + 'physical_target_mode1': '-2 Km_1^-1 R applied to arbitrary displacement field', + 'scope': 'all-width coefficientwise witness; no claim about whole machine state or new observations'} + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--emit', action='store_true') + args = parser.parse_args() + result = verify() + if not args.emit: + need(json.dumps(result, sort_keys=True) == json.dumps(json.loads((HERE/'RESULT.json').read_text()), sort_keys=True), 'typed receipt mismatch') + print(json.dumps(result, sort_keys=True, indent=2))