From 526f2c242202b31b15e09a7502dfb8ff757b2bad Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Fri, 16 Oct 2026 15:39:28 +0100 Subject: [PATCH] feat(research): bound QQ16 completed producer errors --- .../qq16-producer-defect-transfer/README.md | 211 ++ .../qq16-producer-defect-transfer/RESULT.json | 2837 +++++++++++++++++ .../SOURCES.json | 48 + .../qq16-producer-defect-transfer/TASK.json | 109 + .../qq16-producer-defect-transfer/VERIFY.json | 49 + .../independent.py | 319 ++ .../test_verify.py | 216 ++ .../qq16-producer-defect-transfer/verify.py | 246 ++ 8 files changed, 4035 insertions(+) create mode 100644 research/qq16-producer-defect-transfer/README.md create mode 100644 research/qq16-producer-defect-transfer/RESULT.json create mode 100644 research/qq16-producer-defect-transfer/SOURCES.json create mode 100644 research/qq16-producer-defect-transfer/TASK.json create mode 100644 research/qq16-producer-defect-transfer/VERIFY.json create mode 100755 research/qq16-producer-defect-transfer/independent.py create mode 100755 research/qq16-producer-defect-transfer/test_verify.py create mode 100755 research/qq16-producer-defect-transfer/verify.py diff --git a/research/qq16-producer-defect-transfer/README.md b/research/qq16-producer-defect-transfer/README.md new file mode 100644 index 0000000000..16903a0090 --- /dev/null +++ b/research/qq16-producer-defect-transfer/README.md @@ -0,0 +1,211 @@ +# QQ16 producer errors through the zero-retention decoder + +This package supplies a conditional stability bridge for approximate F0 and +B_1_2 execution. It closes the error-propagation question left outside the +[exact-producer entry contract, PR2959](https://github.com/CrocSwap/integer-mult-bounds/pull/2959). +It does not implement the producer or admit a supplier. + +Let F be the reviewed F0 data map, B the reviewed B_1_2 data map, and +D = F^-1 B^-1 the fixed PR2707 zero-retention decoder. Write every field in +its represented logical coordinates. Use the maximum, over all data fields +and cover owners, of the payload Hilbert norm. The inherited physical charts +are payload unitaries, and cover maps permute owners with unitary payload +translations. Thus passage between these physical and logical coordinates +preserves this norm, at every positive common tensor depth. + +Suppose completed approximate producer stages satisfy + +```text +v1 = F v0 + eF, ||eF|| <= epsF, +v2 = B v1 + eB, ||eB|| <= epsB. +``` + +The second defect is relative to B applied to the actual first-stage output. +Errors may be arbitrary, coherent, state-dependent and correlated across stages. +If the implemented decoder differs from D v2 by at most epsD, its original-array +output error is at most + +```text +49 epsF + 1923 epsB + epsD. (1) +``` + +The F0 inverse constant **49 is sharp** for this completed-output error model. +The decoder constant **1923 is a certified upper bound**, without an optimality +claim for the actual chart routes. These are endpoint sensitivities, not +all-cut magnitude bounds or bounds on faults inside producer instructions. +Outputs are the original logical arrays represented in F17; a later endpoint +adapter or consumer is outside the statement. + +## Why the two stage errors have different prices + +Keep the noncommuting order. Linearity and the inherited exact inverse give + +```text +D v2 - v0 = F^-1 B^-1 [B(F v0 + eF) + eB] - v0 + = F^-1 eF + D eB. +``` + +Applying the two certified operator bounds and then the decoder's own error +proves (1). Charging an F0 error as if it were independently injected after B1 +loses the correlation created by B. Treating both stages as having unit error +amplification is also unjustified. + +The following row bounds are recomputed from pinned inputs. A,T are the two +eight-port selected sets and U is the 96-port complement. + +| Inverse and output field | A | T | U | +| --- | ---: | ---: | ---: | +| F^-1, X | 47 | 2 | 3 | +| F^-1, Y | 49 | 4 | 2 | +| D, X | 1921 | 1358 | 81 | +| D, Y | 1923 | 1360 | 1 | + +For F^-1 these are exact absolute row sums of its scalar 224 by 224 matrix. +Every row at a given port class has the displayed value. To attain 49, choose +the 224 F0-output errors to be a common unit payload multiplied by the signs +of the coefficients in an attaining Y_A row. The resulting output has norm 49 +with input maximum norm one. Chart unitarity makes these legitimate physical +endpoint errors as well. This is a completed-output witness, not an exhibited +rounding failure of a particular finite producer. + +For D, represent each logical chart map by an involution g_(s,p). Expand exact +rational coefficients while retaining ordered products of these generators. +Cancel equal adjacent generators using g_(s,p)^2=I; combine equal reduced +words, including their signs. Do not commute different generators. Every +remaining word is a composition of isometries, so the sum of coefficient +absolute values bounds its operator norm. Additional relations between actual +route products can only lower this bound, by combining more terms. + +This uses the source proof that a native line changes a field's physical +chart while preserving its represented logical value, and that an affine +cover map acts by the corresponding logical g. It does not replace a physical +map with a payload-only permutation, drop a tensor factor, or reprove the +native semantics. Involutivity and these isometry properties are inherited +assumptions checked in the predecessor native work. + +## One sufficient original-input error budget + +Suppose ||v0|| <= H with H>0, and beta is a nonnegative integer. The following +completed output tolerances suffice: + +```text +epsF <= H 2^(-beta-8), +epsB <= H 2^(-beta-13), +epsD <= H 2^(-beta-1). +``` + +The resulting error is at most `7587/8192 * H * 2^-beta`, strictly below the +target `H * 2^-beta`. These reserves are sufficient, not minima. + +The existing decoder's state-relative defect theorem can furnish epsD under +its own completed ADD/line/map assumptions, exact owned CLEARs and exclusive +workspace. It needs a bound on the **actual** supplied v2, not the exact +producer's state. Here is one conservative such bound, requiring no input grid: + +```text +||F|| <= 58, ||B|| <= 312, +||v2|| <= 18096 H + 312 epsF + epsB < 2^15 H. +``` + +To verify these coarse forward bounds, each R row has four signed entries in +A, four in T and 48 in U; every K=R*/4 row has absolute sum one. For F, its +X_A/X_T/X_U bounds are 4/56/57 and Y bounds are 6/58/58. For B with input +norm L, `a=ell_(1,T)x` has norm at most 4L. The logger +`u=E_2 y` has A bound 53L and off-A bound L. Consequently `b=R_1 u` is +bounded by 264L. The B output bounds are X_A/X_T/X_U = 55/312/2 and +Y_A/Y_T/Y_U = 53/309/5. The source geometry checker verifies the support +and section premises; the triangle inequalities establish these all-depth +forward bounds. They are not producer-interior range certificates. + +Apply [PR2736's completed-defect theorem](../qq16-zero-retention-defects/PROOF.md) +to actual input bound Bhat = 18096H+312epsF+epsB. Its parameter +`b=beta+16` gives decoder error strictly below `H*2^(-beta-1)` if its +completed relative defect parameter satisfies `u <= 2^(-beta-38)`. +For beta=64, one sufficient triple is F0 output error `H*2^-72`, B1 output +error `H*2^-77` and decoder completed relative parameter `u<=2^-102`. +This is not a component width. A common dyadic input grid and finite-format +realization remain separate obligations. + +## Reproduce and evidence + +From the repository root, with standard-library Python 3.12: + +```sh +python3.12 -Werror -I -B scripts/research_package.py \ + --package research/qq16-producer-defect-transfer +``` + +The primary checker authenticates the source inventory and five inputs, +then interprets the exact 3,823-event logical word. It separately starts the +suffix after the inverse-B1 checkpoint on 224 independent F0-output symbols. +The full decoder has 286,376 final polynomial terms, of degree at most four. +RESULT.json stores each of the 448 rows' exact norm, term count and canonical +polynomial digest. Default replay is read-only; `--write` creates an absent +receipt and refuses to overwrite it. + +The independent checker derives the polynomials from the ordered inverse +equations in PR2681's proof, using R/K and the port partition. It neither reads +the literal word nor imports primary/predecessor executable code. All 448 +row summaries must match, including coefficients and route order through +their digests. This independently checks the arithmetic certificate; the +inherited ideal native semantics remain outside both implementations. + +The tests exercise coherent stage errors on four noncommuting toy cover +owners, the sharp 49 witness, source/receipt failures, optimized execution, +dirty-scratch initialization and a changed scalar operation. These finite +fixtures support the quantified argument; they do not establish an actual +physical caller or native implementation. + +## Scope and decision + +The milestone is a conditional interface lemma. The exact source equations, +native/chart semantics and PR2736 completed-error theorem are inherited. +This package does not verify producer child interiors, dirty-helper range, +helper restoration, a legal common grid, overflow, physical movement/hosting, +storage, cleanup, a consumer invoice, an all-size compiler or multiplication. +No frontier or child tariff changes. The selected cold replay is unrun because +the selected construction and frozen inputs are unchanged. + +Family decision: narrow and stop. + +## Open next questions + +The new test for a finite producer is to +derive its two completed output defects in this norm, including arbitrary +dirty helpers and any correlations. Start with a pinned literal producer, +completed native-child contracts and an intermediate magnitude ledger. That +implementation and its paid physical cost are the blockers, rather than +another inverse or decoder precision constant. The caller must still consume +F17 outputs affordably. Unknown costs remain unknown. + +Scientific base is main `318ba71b8927f81141f41a89c1af74323586f253`, priority +revision 5. TASK.json records the task-card scope change, live overlap and +submission freshness. The [canonical claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/2727#discussioncomment-18975580) +tracks this exact implication. + +New result and checks by Nick Petalas, Apache-2.0. Credit Ali Romman and the +joint-query team for the reviewed F0/B1 maps; Arham Tahir/PR2681 for the ordered +inverse; ywz65/PR2707/2540 for the physical decoder; Nick Petalas/PR2736/2959 +for the numerical and exact-entry predecessors; and starship-s, Sagar Thakrar, +Ross Richardson and the native/geometry lineage retained in those sources. +Substantial automated assistance was used. No independent human or formal-kernel +review is claimed. + +Build the Lever led to a replayable polynomial certificate. Prove It Works led +to two distinct reconstructions and the public-command checks. Test Behavior, +Not Implementation led to injected coherent errors and rejecting CLI controls. + +Power-of-Ten deviations: managed Python arithmetic and collections allocate +during verification, bounded by fixed 224 inputs, 3,823 events, degree four, +50,000 terms per row and 600,000 live state terms. The independent arena caps +2,048 allocated rows; primary summary construction temporarily retains the +F0 rows alongside its full replay. A map replacement may temporarily retain +both its input and output rows. Files are capped at 1 MiB, decompression at +12 MiB, inventory at 16 KiB and JSON objects at 4,096 keys. Rational numerator +and denominator limits are enforced in primary arithmetic; independent +arithmetic has the same fixed authenticated coefficients and finite degree. +Python/JSON allocator overhead is not profiled. JSON's duplicate-key callback +and test-only source loading are bounded dynamic-dispatch deviations. Warning +diagnostics and local Ruff checks cover new code; no fixed-allocation machine +or static type-checker proof is claimed. A variable-size service or physical +implementation requires a separate resource and diagnostics review. diff --git a/research/qq16-producer-defect-transfer/RESULT.json b/research/qq16-producer-defect-transfer/RESULT.json new file mode 100644 index 0000000000..abe7e44c1d --- /dev/null +++ b/research/qq16-producer-defect-transfer/RESULT.json @@ -0,0 +1,2837 @@ +{ + "schema_version": 1, + "geometry": { + "A": [ + 0, + 7, + 20, + 27, + 36, + 46, + 57, + 111 + ], + "T": [ + 21, + 37, + 47, + 76, + 81, + 87, + 92, + 110 + ], + "U": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 22, + 23, + 24, + 25, + 26, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 77, + 78, + 79, + 80, + 82, + 83, + 84, + 85, + 86, + 88, + 89, + 90, + 91, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109 + ], + "R_support": [ + 4, + 4, + 48 + ], + "section_l1": 1, + "F0_forward_bound": 58, + "B1_forward_bound": 312 + }, + "events": 3823, + "operators": { + "F0": [ + { + "row": 0, + "l1": "47", + "terms": 53, + "sha256": "d31d43abf9c8f2602690b5c76356e31cf093b2bca51dafcc7fb3223ce0a9462f" + }, + { + "row": 1, + "l1": "3", + "terms": 5, + "sha256": "7f32583c346936a9534e3111ee45ec7c5a0fdc45d544a260da21c63d9434d34b" + }, + { + "row": 2, + "l1": "3", + "terms": 5, + "sha256": "2c848d022192a5625716826d78183c510bc148a175b9ad7fcf4ea836403f680b" + }, + { + "row": 3, + "l1": "3", + "terms": 5, + "sha256": "56910d0cbe8c11a7f503c7f88027ba5e7e6b19f9ec66302d3f503cadff228227" + }, + { + "row": 4, + "l1": "3", + "terms": 5, + "sha256": "3851be9c7586f98928cf8fcaa53c4273679e3492313c1da8b8e34d0460c8320a" + }, + { + "row": 5, + "l1": "3", + "terms": 5, + "sha256": "ca62852e2cf542e2db5548e833c717c43781fee807a1425f9071c75a8619d26d" + }, + { + "row": 6, + "l1": "3", + "terms": 5, + "sha256": "22eb8c6d17f295a0daef0d1ce5126109d65ae48f46d9f5f7fdc6e843a00b9a3a" + }, + { + "row": 7, + "l1": "47", + "terms": 53, + "sha256": "a7db039160f185dbd1ef838d04586dfb71badea593ed59260dc97b64fe7f253b" + }, + { + "row": 8, + "l1": "3", + "terms": 5, + "sha256": "93fe084e03e654c6b91ac0cd0e0b5a6e6b14db051ec156482f4a6c7d84b507ee" + }, + { + "row": 9, + "l1": "3", + "terms": 5, + "sha256": "f069749048bb7671c4692029adbc81fca3102d21b502c76153f27bdbe8695898" + }, + { + "row": 10, + "l1": "3", + "terms": 5, + "sha256": "1b1e1af01a4b403ab4cd2365342caea132e3f32f536d63a98ac9c195a75d93b1" + }, + { + "row": 11, + "l1": "3", + "terms": 5, + "sha256": "d679ada328097fd506d8bde3af4da91562776b5b55dedf0e9ef4d710cceaff90" + }, + { + "row": 12, + "l1": "3", + "terms": 5, + "sha256": "2a20771c074706551b814e1913294cf1642b3b984166565333de949c935c1f86" + }, + { + "row": 13, + "l1": "3", + "terms": 5, + "sha256": "124001c6ca7965ecec9c3de9e90a4cd3d5f3aacc9e21c5583bcbcbfa6ee52c11" + }, + { + "row": 14, + "l1": "3", + "terms": 5, + "sha256": "844a6eafef5cef304b6de5d8c1448e7e470fa01857d82c0c6e71109777388cd4" + }, + { + "row": 15, + "l1": "3", + "terms": 5, + "sha256": "6300f3fe4a24f67f5d9069be85336159a33e7e150eca8b31dd5ffca6928edf75" + }, + { + "row": 16, + "l1": "3", + "terms": 5, + "sha256": "970973549e53dab34b17d6e30df83f23027e4990b677289dc82e0b8b24f608dd" + }, + { + "row": 17, + "l1": "3", + "terms": 5, + "sha256": "ed1d182b331e5fe4645d7dc8e62bb4b103d10150868cdbc07b4306a47603b500" + }, + { + "row": 18, + "l1": "3", + "terms": 5, + "sha256": "9bce67892e5e5bdc84e7a798ec7740b2935549479ce31498a114277d1d977e19" + }, + { + "row": 19, + "l1": "3", + "terms": 5, + "sha256": "45365daa31952688610c6ec78dab78b97ade54f2a411291add7d02acdfb39386" + }, + { + "row": 20, + "l1": "47", + "terms": 53, + "sha256": "ce76398de1a90fded75e75a38be7705cea49c0e90911ff58a95960f6e8c2b5bf" + }, + { + "row": 21, + "l1": "2", + "terms": 4, + "sha256": "1cd3f379c66c1c2c5cd3b3416da191ee9b976291704e31f306c0824c2c840ecc" + }, + { + "row": 22, + "l1": "3", + "terms": 5, + "sha256": "7d0a8e1062ab16b7063c930e9eee64fe5720ba381f4096da31dcb6220511a2ac" + }, + { + "row": 23, + "l1": "3", + "terms": 5, + "sha256": "ef7085a1b2300da519b3b849669350dfaf9770088e142a03d2d9e6e0f0ae695e" + }, + { + "row": 24, + "l1": "3", + "terms": 5, + "sha256": "8114dfc7bcd5d1fc68f29c3ffb218b78f79c572724dedfa2143ff1b69dcff690" + }, + { + "row": 25, + "l1": "3", + "terms": 5, + "sha256": "916abc15ae00da5f952eba7e4bc78ed28ed84ef7d6b1fe91ef38203d7ba8a29c" + }, + { + "row": 26, + "l1": "3", + "terms": 5, + "sha256": "18f05d988ce8497d8516c44213fc26f88efc0170ff4d7d1794d2fc6816616923" + }, + { + "row": 27, + "l1": "47", + "terms": 53, + "sha256": "b0b4bf1f51f6523b18b23c65f6191b013cd45301e98543770d54c14702590181" + }, + { + "row": 28, + "l1": "3", + "terms": 5, + "sha256": "15d62e2b3e3dbe36d62978dea9f7d71444cc2a936f8eb83410ca6d2ebc5d7676" + }, + { + "row": 29, + "l1": "3", + "terms": 5, + "sha256": "3ff652786c9bc59dc9b0e3cbdee6a080cde12bc4439abf32c0c0bda0aa1d48e6" + }, + { + "row": 30, + "l1": "3", + "terms": 5, + "sha256": "6d1a494917617e73c2a256bbd51c758e33af8a286e6f0d1f6c5d8b426230fc79" + }, + { + "row": 31, + "l1": "3", + "terms": 5, + "sha256": "1ead570b74f09a4568353b4127ac6f3d1c175402766da441774cba6d4f615fef" + }, + { + "row": 32, + "l1": "3", + "terms": 5, + "sha256": "bf0c57ad58c75399390052e7c6a72440f3206d80c24a738af2e0f9aaeb18f394" + }, + { + "row": 33, + "l1": "3", + "terms": 5, + "sha256": "52075f29267c241133a0acb09b9b3ecab5e3591bfccff7edd8ffd66d6493a4a7" + }, + { + "row": 34, + "l1": "3", + "terms": 5, + "sha256": "7a502d1ffb0d9954b0235b391ba31af5d54235424512662146c429eab55f8ab8" + }, + { + "row": 35, + "l1": "3", + "terms": 5, + "sha256": "6ee4058fbe15acf2df68466560232af55085b4d292a4bd6c5cb2ede7b68812be" + }, + { + "row": 36, + "l1": "47", + "terms": 53, + "sha256": "a9554a55296a4510beefba47760118d8465c27c957eb54e8fce632ddbad525f9" + }, + { + "row": 37, + "l1": "2", + "terms": 4, + "sha256": "f137a5e4152e3f91295f018f1e5ad0d786217ca8eac586d560adc80dd81cac8e" + }, + { + "row": 38, + "l1": "3", + "terms": 5, + "sha256": "ef89d6c755c7bd941f2f69bb2924111bdde2ea87308d789273a21dbdc4b6dd80" + }, + { + "row": 39, + "l1": "3", + "terms": 5, + "sha256": "36eae614b41f15652282e9c17cc12831cca8b701c144226f66e171d0cc9a0d07" + }, + { + "row": 40, + "l1": "3", + "terms": 5, + "sha256": "a990073ce10de054de0744a2349950986b1c2752b62c7beb358cb6b032e0f252" + }, + { + "row": 41, + "l1": "3", + "terms": 5, + "sha256": "73279710f5570cbf284742e65e1b74bcdd3a4fa4093f04d95a9a71c2eb36bfec" + }, + { + "row": 42, + "l1": "3", + "terms": 5, + "sha256": "aa089cedf57c91b02294421b77950bfc0be6c1b09ebf5a4abe1a903049ce0444" + }, + { + "row": 43, + "l1": "3", + "terms": 5, + "sha256": "d2a69174e2ca1a15ac9b22d98318eee4899b98b91c26780a0c38408aabac864a" + }, + { + "row": 44, + "l1": "3", + "terms": 5, + "sha256": "341456a753db9f3e32c253669c4682dfdd2e763160d89b3fa42136112f438e31" + }, + { + "row": 45, + "l1": "3", + "terms": 5, + "sha256": "35123b25982643db35d4258268d6a846a1ea7d9c67bb745451d79907814908e9" + }, + { + "row": 46, + "l1": "47", + "terms": 53, + "sha256": "ed52c2528240d6b50105746deb2e3a7f7082ffcd6584b669b81c25227503682e" + }, + { + "row": 47, + "l1": "2", + "terms": 4, + "sha256": "db774ff0f5861d2d3d59c4c9046431673d087f750bbf450cbf03adeda16e7766" + }, + { + "row": 48, + "l1": "3", + "terms": 5, + "sha256": "219debb6941276cb28275afb1239954a6eb00f0bf506d02b20b925508dd9b07c" + }, + { + "row": 49, + "l1": "3", + "terms": 5, + "sha256": "4ea52882af9792f7556b1873b705fa3f5d7fb8c914a988367da8e574e97c3edf" + }, + { + "row": 50, + "l1": "3", + "terms": 5, + "sha256": "404ce0f267243a17f010ca56ba381493e683a3a3c5d563b3f8fa3ed6ef652fa2" + }, + { + "row": 51, + "l1": "3", + "terms": 5, + "sha256": "e0d735e24adf673bee05e19a679e58001c1ad46903248554b3bf42fbee92422d" + }, + { + "row": 52, + "l1": "3", + "terms": 5, + "sha256": "8c32bf126a1a23269be2eeb8a85df9a5601817323ee90ac0410ae22a6ac87ec7" + }, + { + "row": 53, + "l1": "3", + "terms": 5, + "sha256": "d3995a418f42343dd69fe9bf0e57d6e4848d396dc2e9e1275357a0bddbcf1a97" + }, + { + "row": 54, + "l1": "3", + "terms": 5, + "sha256": "11ed89da5d2fdf89db4ad4d65ae0c1840294fa9695192d417dec7a5a294cef71" + }, + { + "row": 55, + "l1": "3", + "terms": 5, + "sha256": "140b08443b81afe13f9e46899026e263fcde5d4f4532b4fb7cc63c743dc26526" + }, + { + "row": 56, + "l1": "3", + "terms": 5, + "sha256": "fed25508b53625bea6a5e83824f3f2d61682b5a113e69f4cc5f82fbc222be78d" + }, + { + "row": 57, + "l1": "47", + "terms": 53, + "sha256": "01832cd2d48178168b4d805a25c6d7048454498715230fe5ba249fe8bb7b403a" + }, + { + "row": 58, + "l1": "3", + "terms": 5, + "sha256": "8f904c70c3e915406bb51b6b955c22c3a4efb5e0c3722c3e0f7871b8c64d83dd" + }, + { + "row": 59, + "l1": "3", + "terms": 5, + "sha256": "565a235306cf98fa5c7c9fcda5b73fa3b73ac7bfdc510ca74e06e3a98fbe64b3" + }, + { + "row": 60, + "l1": "3", + "terms": 5, + "sha256": "ea120b10c55d94a5ad69c41a40bf077274a4e666e42ede93f0189c266d4876a9" + }, + { + "row": 61, + "l1": "3", + "terms": 5, + "sha256": "a9478c684e9b3188ab9937bef3fdd350bd76535af239a00d6be8e49d2fdb3716" + }, + { + "row": 62, + "l1": "3", + "terms": 5, + "sha256": "43c0b194cbbb2adeb45ba4cce49102f88035f3e6e0d2d1ee6bbfd48ef52b7cc7" + }, + { + "row": 63, + "l1": "3", + "terms": 5, + "sha256": "c42eae345e174694e0156113c8561186e8a23f0583c82b0853453fb04c4f3074" + }, + { + "row": 64, + "l1": "3", + "terms": 5, + "sha256": "81c7b3b6a6af835bd9d331de4f4ca46c7b0e7f8fbdf0e54916e55c89f9ad6c68" + }, + { + "row": 65, + "l1": "3", + "terms": 5, + "sha256": "bfd4017029ac94d77ca11a40f9d9024d988115dc7d5388f578460a9352d65223" + }, + { + "row": 66, + "l1": "3", + "terms": 5, + "sha256": "d9e62b22a7c4a867ec0133f424efcf80e539c96353eb2be39c89e6b077886808" + }, + { + "row": 67, + "l1": "3", + "terms": 5, + "sha256": "ec0d780aae510ac8f1e9d930c9dd4a9c980cb4c3994bab3964114aefd0663b3d" + }, + { + "row": 68, + "l1": "3", + "terms": 5, + "sha256": "92d5bf0177878a2f9e4f7ad1ae2bd65c2d11c720c43e6ede586540865ca3bfc4" + }, + { + "row": 69, + "l1": "3", + "terms": 5, + "sha256": "435e90ab73dd2692dbe71929f916c14164f87da840fdf96113e5a01c9cb6db0f" + }, + { + "row": 70, + "l1": "3", + "terms": 5, + "sha256": "7288bf274a98a4a0cd63d8d56a817e446e6ab007ad336010cc2b0366a0dc076e" + }, + { + "row": 71, + "l1": "3", + "terms": 5, + "sha256": "b9f70a3f2afa1ac71ca0dda08d2b733c39bd2bf74f46ba466bebf9287f619278" + }, + { + "row": 72, + "l1": "3", + "terms": 5, + "sha256": "02c818d2ec7d99a1dc67839253d848c38abd0e8f633157bf69d292c68d8c1437" + }, + { + "row": 73, + "l1": "3", + "terms": 5, + "sha256": "b664cc7ac251f3c5b07d1d36d81aaa1b628755ac22b170621eb00f3db5059761" + }, + { + "row": 74, + "l1": "3", + "terms": 5, + "sha256": "7cb412e81d0ac197afd8256fbfec58266383ffccb7f9bcd09fe487a0ef160adf" + }, + { + "row": 75, + "l1": "3", + "terms": 5, + "sha256": "f43eddb2c4c3452e09178f5811daf2a1f8e6a1ce496ce6f754bbdfb71a91fcfe" + }, + { + "row": 76, + "l1": "2", + "terms": 4, + "sha256": "bbd060fceacd01e578197dd2a432b03278d28b9c65c212a58f2415901cb937e2" + }, + { + "row": 77, + "l1": "3", + "terms": 5, + "sha256": "fc1f934774a4a8ec351b05df2e7c46b4350cb2436b57e5c61e1043c04cc6eb87" + }, + { + "row": 78, + "l1": "3", + "terms": 5, + "sha256": "4d162672240ed700af47f6c6c77c940041da726c266815dab016e2cfd9cc81a1" + }, + { + "row": 79, + "l1": "3", + "terms": 5, + "sha256": "bf5d512f98413afadc04528e253ee1c5b5f64f10bdb4529fa07afa59d26f0695" + }, + { + "row": 80, + "l1": "3", + "terms": 5, + "sha256": "a96def16e896fe84f6152cdb8a816a377bc965edcd6d39f631149d14fbc1b400" + }, + { + "row": 81, + "l1": "2", + "terms": 4, + "sha256": "0cf0236fb59c79718dd130a93b3d70991b780d0daecae4160cec93dd1886392e" + }, + { + "row": 82, + "l1": "3", + "terms": 5, + "sha256": "2a0408ffb8b8f245f26e55bffaaec91c5257dd39583ec22ef024e04dfe24d02a" + }, + { + "row": 83, + "l1": "3", + "terms": 5, + "sha256": "d4b0456b69075e861cd1c8da1fa0a540f021284dc8f6f5d97908d305a4fa7460" + }, + { + "row": 84, + "l1": "3", + "terms": 5, + "sha256": "b449acb2bd862ea7ef1398f49bcfb491414aef8136959e8020f5f8a342fd073a" + }, + { + "row": 85, + "l1": "3", + "terms": 5, + "sha256": "1840a8b137c49c59473fce903d1fc82ce98338e282437c1442aa41c554acddd3" + }, + { + "row": 86, + "l1": "3", + "terms": 5, + "sha256": "dc0265ef22d245baee909d4ae6312715d2763dcd252e1ea4922759c08035f964" + }, + { + "row": 87, + "l1": "2", + "terms": 4, + "sha256": "8c662dc3f3bcf34e78ffaef913bab9d2dd7df4f05f329f2bbe652ad2f16506e2" + }, + { + "row": 88, + "l1": "3", + "terms": 5, + "sha256": "fdd877fdab88f74763864f5854a1b65ad1cfdf8142abc17ec28b98ca7b6a96e0" + }, + { + "row": 89, + "l1": "3", + "terms": 5, + "sha256": "ac96fca7d2672b9d19ad9ccfb3771007cb23060ee98114130ce9d75b0320c93b" + }, + { + "row": 90, + "l1": "3", + "terms": 5, + "sha256": "0b98e884fbe4ade90d93d79ea0bda2cb201b9a7c7e6b28f6d927c8284ffa94a3" + }, + { + "row": 91, + "l1": "3", + "terms": 5, + "sha256": "d587a3120fb4831ee1471d55853786a77e5b0806500c942eff7b7cc9e36ad109" + }, + { + "row": 92, + "l1": "2", + "terms": 4, + "sha256": "57d469a0c9247856c3f243edc43619115d7a15b90ecd794a54906d069f18fc94" + }, + { + "row": 93, + "l1": "3", + "terms": 5, + "sha256": "7255f51907f50aedff1b6dad81c7513f953edeeb32e54f34576b65cdae433cc4" + }, + { + "row": 94, + "l1": "3", + "terms": 5, + "sha256": "2b5db61f54b41cff0f151039937fae83b557198783d52c880bb119c6223db17b" + }, + { + "row": 95, + "l1": "3", + "terms": 5, + "sha256": "7b6842123f5d418aa54d06080102a432fcf4cc1c0cd3add8e709b43f9af7c0b4" + }, + { + "row": 96, + "l1": "3", + "terms": 5, + "sha256": "d2350ab53ca3d49e5c6ce7c0c4527cc74cc4388fe8645650fb90f060acb59b5c" + }, + { + "row": 97, + "l1": "3", + "terms": 5, + "sha256": "dd2004ccab92a8dd72384a00072a2f30767707999be27d01dd71ce54ea32bd53" + }, + { + "row": 98, + "l1": "3", + "terms": 5, + "sha256": "f9136690f053e72071f1311eef53e19ac4ab16ec8f203d3bfb7c0233b38fc981" + }, + { + "row": 99, + "l1": "3", + "terms": 5, + "sha256": "701e09d7f30245dbde0f781bed5e9ddf410b604f7274335ba7a496b177c54c2f" + }, + { + "row": 100, + "l1": "3", + "terms": 5, + "sha256": "fbe88c51fd2f60d123d518da83e87931344bf55d8486b45940e8de9c590e6376" + }, + { + "row": 101, + "l1": "3", + "terms": 5, + "sha256": "2633cfb8732fbf0a5e6ffc149945e4f60134c0a2fa0d0be3341452cb2aea61d5" + }, + { + "row": 102, + "l1": "3", + "terms": 5, + "sha256": "89727b07ac9e373b9e6ca5b8cac5c23c5f92fb605444c7034de1410cfe029854" + }, + { + "row": 103, + "l1": "3", + "terms": 5, + "sha256": "10dbd09cff8dd997b1921f4feed2e643de67baa8a491e34a1893f0f047ce9311" + }, + { + "row": 104, + "l1": "3", + "terms": 5, + "sha256": "5fd23c645a9ef84b80223e44c1c40f9f343f16f3307b04f98e93d4a683c5aea7" + }, + { + "row": 105, + "l1": "3", + "terms": 5, + "sha256": "a8e999d8f78ce5bd1c910cff606c8e6d58d9e1735a7d4b5ccbe23c7fc2b02910" + }, + { + "row": 106, + "l1": "3", + "terms": 5, + "sha256": "d8fd96f1ac4f2834785b09eff3d0c28340c2aa4711c9dedbb810c251cb8ed571" + }, + { + "row": 107, + "l1": "3", + "terms": 5, + "sha256": "0b199e7b5f6723a7de0528e8b24fd3d25db6761464c9cd3e54fb46035a8bf4c4" + }, + { + "row": 108, + "l1": "3", + "terms": 5, + "sha256": "446e44cea4b36d0b0e796c388b9bbc94d061718065cf191dcc826f1569760f5d" + }, + { + "row": 109, + "l1": "3", + "terms": 5, + "sha256": "297c32ad2549fdc2c82e9394154f232c77114a4528fe9cb063b258b38fe90995" + }, + { + "row": 110, + "l1": "2", + "terms": 4, + "sha256": "226a41734eceebf15d7574171946bcd761beac233e8f1b98ddf5d0f1efe8ec00" + }, + { + "row": 111, + "l1": "47", + "terms": 53, + "sha256": "158cf31c541bb46c1511808c68711fff90f96b42c4017bc24b4d17b6e4e53d26" + }, + { + "row": 112, + "l1": "49", + "terms": 54, + "sha256": "af79fa3b6123479335c1e27fe5e8c7de4207792d37c9b19337ba9d5e13570fab" + }, + { + "row": 113, + "l1": "2", + "terms": 2, + "sha256": "55a60ed8d6b336f30ac721c6d49a4fde7ad0dac75cce65318c2c5712841c5407" + }, + { + "row": 114, + "l1": "2", + "terms": 2, + "sha256": "a018fd52ee9f14b7135430e8b2f6a29457f17b4d5d12b52388bd0eeef81c67c2" + }, + { + "row": 115, + "l1": "2", + "terms": 2, + "sha256": "ce479cabd87634fb8019cc4d850c07850ed9765105eefe4fb2ab001d1bddfdad" + }, + { + "row": 116, + "l1": "2", + "terms": 2, + "sha256": "2c00b66bdf02f889e73d73b6c83bbc9b7bde747ee759aa0c0228608ce389cdf9" + }, + { + "row": 117, + "l1": "2", + "terms": 2, + "sha256": "f47d394f77accffa2c1e1b8bf21328a178ea5a1806cd9b9dc7e2b3dee9e36697" + }, + { + "row": 118, + "l1": "2", + "terms": 2, + "sha256": "2b54975e9fa97a46b08d245c9f239e071a829337570ca33cd4966c4513b35614" + }, + { + "row": 119, + "l1": "49", + "terms": 54, + "sha256": "c9332ee451d818dc7e8898b852cf13d3e8e4a4c30609ff3b3c60b2ca9900ec42" + }, + { + "row": 120, + "l1": "2", + "terms": 2, + "sha256": "762e388e0d085138755f5e88b797241100f9766b52acab44a850a14b449e63ff" + }, + { + "row": 121, + "l1": "2", + "terms": 2, + "sha256": "7e3673332571b9811c159bfd25dce62af7604bde8cf0c0738c43a6c80f9b145d" + }, + { + "row": 122, + "l1": "2", + "terms": 2, + "sha256": "7b653b0948eebc370501639ea04a858b89261c6fd4d424929583e1080829ace7" + }, + { + "row": 123, + "l1": "2", + "terms": 2, + "sha256": "57073f566da9072352ca42409d2633d57ff4c9c8d98372843254debba56143e5" + }, + { + "row": 124, + "l1": "2", + "terms": 2, + "sha256": "4e732fe889fcea6d43850cac5701b3be868a76357c62e649bd61f3096d3117e8" + }, + { + "row": 125, + "l1": "2", + "terms": 2, + "sha256": "c198f74079ff8ee22e28633385daa82d67d1c3ce61b378900d295f3967753b32" + }, + { + "row": 126, + "l1": "2", + "terms": 2, + "sha256": "2bf28d590bc565bf54193a7015eb6bed36e8ab25278040554597ab2bc487d0e6" + }, + { + "row": 127, + "l1": "2", + "terms": 2, + "sha256": "175999fd47bb2bdae25baf2ceb18e3efc805941116e0dbd0329175f286cfb871" + }, + { + "row": 128, + "l1": "2", + "terms": 2, + "sha256": "d17babbf56ac9134dc92be82d90c7620bdbb669e890a21c80f9ad19e442f4ba1" + }, + { + "row": 129, + "l1": "2", + "terms": 2, + "sha256": "d1a8eb561718030a45d690075c174de37f7084a2584b77e19e2229aa4989c0f0" + }, + { + "row": 130, + "l1": "2", + "terms": 2, + "sha256": "8a5f54ab3e4b35823e29fa3839a06376716731fff5d175bc91508ece0ccc20be" + }, + { + "row": 131, + "l1": "2", + "terms": 2, + "sha256": "00fe6841d597a8d54b18fcd1fd14f7c346d2d7af4ace3999867ed3c6635961a7" + }, + { + "row": 132, + "l1": "49", + "terms": 54, + "sha256": "c49262407c77b570faf576df88bb5e6155c24a342aac3bd566e8f484724bf1a9" + }, + { + "row": 133, + "l1": "4", + "terms": 6, + "sha256": "11d7225347633414025eb25907505960835f23556a5b039810adea0ad1cdaedd" + }, + { + "row": 134, + "l1": "2", + "terms": 2, + "sha256": "63ca136ecd17935deb3e76b2a6490772159c6cbe3c197bb6f9fcc91bef8b978f" + }, + { + "row": 135, + "l1": "2", + "terms": 2, + "sha256": "f52ab16e89b8a352ae38432fc1d5597d4b04bb24f3238e40f748840b97e707d5" + }, + { + "row": 136, + "l1": "2", + "terms": 2, + "sha256": "241980a555c7de70f5d9c96b62c5cfc35f49f0d7ed65d48d4988b5fa7475ca7f" + }, + { + "row": 137, + "l1": "2", + "terms": 2, + "sha256": "99d895524c2f41310f4e48e5710cf230aaa5d93e72babf516e814011fba1ca98" + }, + { + "row": 138, + "l1": "2", + "terms": 2, + "sha256": "c08a5967d19a662e24b549bae4e34b02d9794dd926bee8af76981b63777c1e0d" + }, + { + "row": 139, + "l1": "49", + "terms": 54, + "sha256": "f8fb05f7190a4ebc1c9aa9fa3405a4c8c6c40dfdbe1bb1ac8137598060b82193" + }, + { + "row": 140, + "l1": "2", + "terms": 2, + "sha256": "e9837c1e84c058667ca6bd63702dca9b857d2f841a183e22c262291f641e984e" + }, + { + "row": 141, + "l1": "2", + "terms": 2, + "sha256": "92423ce8e9740e01f127d5cc0dead26ec73904d7cdfe2c3413e09f37361d1f64" + }, + { + "row": 142, + "l1": "2", + "terms": 2, + "sha256": "f47627fa8da030fcd119c5e1df71cf2b7552cc38491088584ec589a88ed29101" + }, + { + "row": 143, + "l1": "2", + "terms": 2, + "sha256": "b8cabff03419b8010342e351c6e5885841ed4ff560ca6bb90bd75b06a71054aa" + }, + { + "row": 144, + "l1": "2", + "terms": 2, + "sha256": "8f6d2944b04d625dc58e0a94dfcf6a52615bfbec3f894868f400860f03e49eba" + }, + { + "row": 145, + "l1": "2", + "terms": 2, + "sha256": "23e8e4cdce367ad170234d406dc601bcc45866ce238d1902254c66403a9f2ff8" + }, + { + "row": 146, + "l1": "2", + "terms": 2, + "sha256": "929112b12bc4cb3afd402a48147b7975d5bfb8df9f9a5947b45fcedf9184308d" + }, + { + "row": 147, + "l1": "2", + "terms": 2, + "sha256": "098e404ecc110efe547a80c71573acd12dfb22ee98ecbd784ace9abf9182bd1e" + }, + { + "row": 148, + "l1": "49", + "terms": 54, + "sha256": "e29621da72c8a140841d2e3e1d7c07a8c529b001a0eef40c83f6190f7e6aaae8" + }, + { + "row": 149, + "l1": "4", + "terms": 6, + "sha256": "33cf52ff5f36e80c2a72486f5b1e9c3158880291116804b60bb13078cbc38f7f" + }, + { + "row": 150, + "l1": "2", + "terms": 2, + "sha256": "fc1fd6d33d2b4493e6b5275ce94416ba1d09be80cfedeb169978896effda3255" + }, + { + "row": 151, + "l1": "2", + "terms": 2, + "sha256": "2a36d7cadca130d839825286d98270e9cb28d648bda1853dafa2b859722652f7" + }, + { + "row": 152, + "l1": "2", + "terms": 2, + "sha256": "07beda79099c239aaf560dfc28a4d4aafd8883caa3edfb46bc1fbe4fd35322d5" + }, + { + "row": 153, + "l1": "2", + "terms": 2, + "sha256": "9edbc98fb93bc049791f041fa3f1216a66d3c0397e7277e0bd9207fcffd260bc" + }, + { + "row": 154, + "l1": "2", + "terms": 2, + "sha256": "54ffd76c9f35667126ab9be9a8b1d913eac8f2c8331c82cf17b44a71ae0214c1" + }, + { + "row": 155, + "l1": "2", + "terms": 2, + "sha256": "628bba15d5d75e7ce2ff9490c7538cb4e52f294bf8ebad70752bcb9692ced244" + }, + { + "row": 156, + "l1": "2", + "terms": 2, + "sha256": "61ae88adc3ddcdf6e2d8540f82a1248e84ecef175a8c55db3a7925953b7abb58" + }, + { + "row": 157, + "l1": "2", + "terms": 2, + "sha256": "fa126488082a78de0c3a95de8995b4175d8f378c32bed8ab27c8501c23af7e44" + }, + { + "row": 158, + "l1": "49", + "terms": 54, + "sha256": "0b4fa7691508619cd016f46cccebcc827f7e6aaa04b621fd5eede372cd48e1c3" + }, + { + "row": 159, + "l1": "4", + "terms": 6, + "sha256": "2baac983679def3c8594fc0a35dc54b1e4860f02dda716374c866bbb61bf6070" + }, + { + "row": 160, + "l1": "2", + "terms": 2, + "sha256": "fb5b73c78e53b42dcf527f5c69f635868514c462addb72ee6a32a3361929952e" + }, + { + "row": 161, + "l1": "2", + "terms": 2, + "sha256": "09d739a44c89f81eb058189887954dcaf1568872145c9b43d04dcbbf1f18185b" + }, + { + "row": 162, + "l1": "2", + "terms": 2, + "sha256": "e264eda8f8603a4a242ac49f8b52a2957c4447ee3d4a4ab7c128f9e4c7e740e9" + }, + { + "row": 163, + "l1": "2", + "terms": 2, + "sha256": "8c95bd8baa00f0685b7f36a52d9782b31e4440cf46cfd4cfa8c7e87eefe27176" + }, + { + "row": 164, + "l1": "2", + "terms": 2, + "sha256": "5e064fb02713f1c7d71981691aa233e298de9d247dc85dd7f25fb981ff458ce8" + }, + { + "row": 165, + "l1": "2", + "terms": 2, + "sha256": "51534c6386514b674b5da54adaf7175ab76a1c21e9c761179cc807dc1291bf86" + }, + { + "row": 166, + "l1": "2", + "terms": 2, + "sha256": "01f5e487ab40b02f6ffe2397bedb0ee82bcc31c49a3327636b7c2d47cdbb99ab" + }, + { + "row": 167, + "l1": "2", + "terms": 2, + "sha256": "444c8dfe8e2451e4732ea400b2fb2b820da8b8fe962e4db9f71a901fca23106b" + }, + { + "row": 168, + "l1": "2", + "terms": 2, + "sha256": "c539fb7917970ef8eada4a756e692b673446334e302d08df83e6f22d6583f484" + }, + { + "row": 169, + "l1": "49", + "terms": 54, + "sha256": "27252ef1f9e4a8ff6698acc8c092dea0c543dfe47c12bbcc65e797e83e797d9c" + }, + { + "row": 170, + "l1": "2", + "terms": 2, + "sha256": "12d4765c0c653716ad9e82715acd62e65e3d3386c331945638feb9c1e6d2cc22" + }, + { + "row": 171, + "l1": "2", + "terms": 2, + "sha256": "7a2fb60df28ef81d7974cdfd706e1e7f55b5671e704016c092d780f88ad1bef7" + }, + { + "row": 172, + "l1": "2", + "terms": 2, + "sha256": "72a7d0b4a0a5d54664294335ae898abeeea7ece9059ff229f255ce7e5c482d34" + }, + { + "row": 173, + "l1": "2", + "terms": 2, + "sha256": "59f7cd31fcbbc5bce63ce3ec48b6ce47d76dfee24385f54050084a9d17e47b8f" + }, + { + "row": 174, + "l1": "2", + "terms": 2, + "sha256": "8710b00177d09dc0e074fc0f6ae1f6b018d4e6587ea6a9f82de01cfb2f017a75" + }, + { + "row": 175, + "l1": "2", + "terms": 2, + "sha256": "86640e6d6948c4ca1520e7b71ac45eac0702ad5df1c37ebf70328ec8aa85e29c" + }, + { + "row": 176, + "l1": "2", + "terms": 2, + "sha256": "69275a575946d536899f98ee826e9338916e003cf1473a4e88e9e86464276a73" + }, + { + "row": 177, + "l1": "2", + "terms": 2, + "sha256": "97a4cbd9dd2b9f8281982a2d81c17ee87c90133d970b241fc1a124fd4e3378e7" + }, + { + "row": 178, + "l1": "2", + "terms": 2, + "sha256": "58084ba981efdcd037101dd8721f23f3a0c1a4c22128d06f10ab827d4850a3e9" + }, + { + "row": 179, + "l1": "2", + "terms": 2, + "sha256": "71b55d2165f1f107dc7c1ce4434c75509087ec5a43405082abb77cdddfa75f51" + }, + { + "row": 180, + "l1": "2", + "terms": 2, + "sha256": "124c9b933dd32aa5cf553ea83603489c67cfd27dd6a3609c2d4550e4143ca8d0" + }, + { + "row": 181, + "l1": "2", + "terms": 2, + "sha256": "4a90695677c88e5d413ee7d82811e879fce8dfb0ccfbd146371bd20f18120699" + }, + { + "row": 182, + "l1": "2", + "terms": 2, + "sha256": "7a642d486ea043a32545c2265a5e86d9796d4cd04ec43486d84ea09931bd5976" + }, + { + "row": 183, + "l1": "2", + "terms": 2, + "sha256": "72613b87eaeabcfa81331014af6361915a65385343611718f472de9975710e8f" + }, + { + "row": 184, + "l1": "2", + "terms": 2, + "sha256": "f210cebe406c597ec181f113115162012130c065ef4e485e8f0a5e71b6fe0487" + }, + { + "row": 185, + "l1": "2", + "terms": 2, + "sha256": "f9039bd1dfdea4005e33d7604af6c7c0d719297f3e05f715ba85383c7fc96e72" + }, + { + "row": 186, + "l1": "2", + "terms": 2, + "sha256": "2b23199481afb02a53dbb32697bb05ed7867545c9dfd459a90767988fafde040" + }, + { + "row": 187, + "l1": "2", + "terms": 2, + "sha256": "1d335f31f317a8f8ced904ff03cc240073c61f6f946163a94121fa3dfae1a0ac" + }, + { + "row": 188, + "l1": "4", + "terms": 6, + "sha256": "f45f5b527167415caae00fd0a9be5f5fde144ba074c69b64d35298bdc756582b" + }, + { + "row": 189, + "l1": "2", + "terms": 2, + "sha256": "3b5cb531f24091ac10d48208a6ac72c1719ec57e94b0d69cd13a62232300cf65" + }, + { + "row": 190, + "l1": "2", + "terms": 2, + "sha256": "8d597b8ca84ad8c6e1a53b20a1f9984e7171467fae09ad34759f99924e07786d" + }, + { + "row": 191, + "l1": "2", + "terms": 2, + "sha256": "f815aafc9487a0e475627ec320b5670619fbe40634e8aaa822a4baa167186d7c" + }, + { + "row": 192, + "l1": "2", + "terms": 2, + "sha256": "197c2c98aa5710c3437aebc4e135bc362b77fd60afbf725aaa8cd26c85338275" + }, + { + "row": 193, + "l1": "4", + "terms": 6, + "sha256": "9413b202104571ea9c7b4c54972016e47ea22ac1abac5f7d73804237bc45af94" + }, + { + "row": 194, + "l1": "2", + "terms": 2, + "sha256": "1c7fad6f8a356f373affbcf705b66f7202bb0e73c87a5a7d27c6be5d3ec66e6b" + }, + { + "row": 195, + "l1": "2", + "terms": 2, + "sha256": "0b7cc499f4d05fc6f5c8c37d0cb7275dbfabc974b85a060995cda5fcef49cb36" + }, + { + "row": 196, + "l1": "2", + "terms": 2, + "sha256": "2c7819db6bf868508f6c2d156ea3e2165967ea736a31223800e95a08071f9848" + }, + { + "row": 197, + "l1": "2", + "terms": 2, + "sha256": "9ab9a2bdc87a5250686e785dbd7cff337e0949433ab7d9dd70831c83742d1697" + }, + { + "row": 198, + "l1": "2", + "terms": 2, + "sha256": "d9e198f4c13e30fa0c18fd0c6d8b8341d08412a25bae670bc6c66f76d135c3df" + }, + { + "row": 199, + "l1": "4", + "terms": 6, + "sha256": "728dc2bac9dcae1129ffefdaf400c4cb1c102cc46ce58725504cd272e04040e0" + }, + { + "row": 200, + "l1": "2", + "terms": 2, + "sha256": "d2810d0205d103ea9a0d8f8b98d1bdbd2921a97bfa3002224c9e1e15b76ff8db" + }, + { + "row": 201, + "l1": "2", + "terms": 2, + "sha256": "3deeb9c6fc105bb1dcd899f1fa63a4d5f1cf9bd3ab04538138ff188d60108194" + }, + { + "row": 202, + "l1": "2", + "terms": 2, + "sha256": "540b118ac5d8c6cb7cb9b2a3433b083460feb7f02f4873a6289fb066dc19adc9" + }, + { + "row": 203, + "l1": "2", + "terms": 2, + "sha256": "20aee127ad8c54fb3a4718386905da56223307d0a30b98a30e6a7249df23a208" + }, + { + "row": 204, + "l1": "4", + "terms": 6, + "sha256": "50c7037cbdb929d23904b2a9378c103fb82cf74d95d93e2ca8937647d4137c3a" + }, + { + "row": 205, + "l1": "2", + "terms": 2, + "sha256": "c6c0627432df38f4a533a305b4c2a3feaf2a163f9c1039e09c879b56043e8de3" + }, + { + "row": 206, + "l1": "2", + "terms": 2, + "sha256": "e90cf89fbe32ef59c25c5342ac569606f5052ece4798711d42da3b7aef893317" + }, + { + "row": 207, + "l1": "2", + "terms": 2, + "sha256": "9add5c4a17f2078be8fb70268b236ce8f5957516e1681eddfa3f88c6ad5ffbe0" + }, + { + "row": 208, + "l1": "2", + "terms": 2, + "sha256": "c69780e21800e491d357987cb702189c8119a9047576c4358834065088a07344" + }, + { + "row": 209, + "l1": "2", + "terms": 2, + "sha256": "f57dfc3e1f2f68f7ae6152a29f9a6bfc4a26f2edb66d7f58e23a42ddb1c582e5" + }, + { + "row": 210, + "l1": "2", + "terms": 2, + "sha256": "94eac9d62e26a006ffcec1692305eea2334f3b44760a0293be0d23edea4c21db" + }, + { + "row": 211, + "l1": "2", + "terms": 2, + "sha256": "71dccab97748a18b2ff43b1a0a45a0f16437a7160026613b280137be4a932b2a" + }, + { + "row": 212, + "l1": "2", + "terms": 2, + "sha256": "15d87f74051f9a847272ad62a50fc6cc35945052319b743948efbf3197044ce6" + }, + { + "row": 213, + "l1": "2", + "terms": 2, + "sha256": "0e7c56ab1056095b8981f8cf1bcb95eb11444370e6d9602f1e2c0542c5f25643" + }, + { + "row": 214, + "l1": "2", + "terms": 2, + "sha256": "264e9cbb454954414ece91f419c46ab79141d9012929ab2d395d6d2574a4ac1d" + }, + { + "row": 215, + "l1": "2", + "terms": 2, + "sha256": "f07ea4b37fb4793f25bfee66b9a97fde91208c5e60af1acb25c5279ea92db2e7" + }, + { + "row": 216, + "l1": "2", + "terms": 2, + "sha256": "e3db576d32ab5636a9c5ffeae96621b4303de0a3be7176b4053bc0e4c98d1fd0" + }, + { + "row": 217, + "l1": "2", + "terms": 2, + "sha256": "07e363ad0aff6d597e63515ed2f3a4bfa8113955ea11033b194ee3783957e82f" + }, + { + "row": 218, + "l1": "2", + "terms": 2, + "sha256": "f9aa8b85aa688a476d6bda004984a6aa3e813d452f94f33b339947b4cd017083" + }, + { + "row": 219, + "l1": "2", + "terms": 2, + "sha256": "61ce2580dfbd3d7b99a84d7d71ae1f3110675a3ab77fbc69df91366ca85335ab" + }, + { + "row": 220, + "l1": "2", + "terms": 2, + "sha256": "3bef25bad562f0d9c16049efe82dd76db39f42018711295f25e9704022c6d60e" + }, + { + "row": 221, + "l1": "2", + "terms": 2, + "sha256": "e48f47cc0761276a2a820c189776622bb527863a8cf33c4eff1d26f05b80a69d" + }, + { + "row": 222, + "l1": "4", + "terms": 6, + "sha256": "b05d45b8e413a6cb0428fb5dfb2cf5b3f9a7866a9233e3550555f98b99c6a0fa" + }, + { + "row": 223, + "l1": "49", + "terms": 54, + "sha256": "059ee5e998508243c4e96edbbc511c402b646d036c487b7c56d66024fc81cddf" + } + ], + "D": [ + { + "row": 0, + "l1": "1921", + "terms": 5465, + "sha256": "aa79ffeb4acf7d6998edd567c026eefab9459ffc14625b0f9f0a2c2abe080c1e" + }, + { + "row": 1, + "l1": "81", + "terms": 265, + "sha256": "ac95f24ead643caef3501c1c673fb2da448326a28c50b748226494e091816525" + }, + { + "row": 2, + "l1": "81", + "terms": 265, + "sha256": "325bab3dfd179384b8d410bab17282bfbe8cd3c60e989a634f264a920afe5c5e" + }, + { + "row": 3, + "l1": "81", + "terms": 265, + "sha256": "6c8e1dcaec36b1ce8cab97b0a264250d6714383aa2e59965922753776242cc82" + }, + { + "row": 4, + "l1": "81", + "terms": 265, + "sha256": "247aa6ecb69e4e4a42e93fe00bfec1f5acfaba11c87c5d3aaddd663a5b6c6434" + }, + { + "row": 5, + "l1": "81", + "terms": 265, + "sha256": "8ec520171198ffe64b3745a78fd780c8e534f28f2a4a16b6a721f11531c604c7" + }, + { + "row": 6, + "l1": "81", + "terms": 265, + "sha256": "a05c6d0b08a64a32f97e4a7595696c8d4c14692079ad002e1a867651ddbad07f" + }, + { + "row": 7, + "l1": "1921", + "terms": 5465, + "sha256": "2a3e36296f922a024b8cf6c87db69a74a9df489997c3e9694d4a63f82b388a30" + }, + { + "row": 8, + "l1": "81", + "terms": 265, + "sha256": "471fb5ce97e1b63b9edffb809e41665b08b6d733577582892539dd1fa0c05735" + }, + { + "row": 9, + "l1": "81", + "terms": 265, + "sha256": "50cc981f596251b445ccb971b886e0b2bce1591e5d3935714019d315b02d7006" + }, + { + "row": 10, + "l1": "81", + "terms": 265, + "sha256": "941c182963401894015cd460b467037641f634b469636b140080c8d81d44f78f" + }, + { + "row": 11, + "l1": "81", + "terms": 265, + "sha256": "d165910af7caae207227f7b657125d5037af0c97518c149af124f93e0de5ca51" + }, + { + "row": 12, + "l1": "81", + "terms": 265, + "sha256": "474f194cc4b7a68c9ac6704b36c0b01db7754ac01e12da7f2e59178226cf37b9" + }, + { + "row": 13, + "l1": "81", + "terms": 265, + "sha256": "502e69babfa84b0548bf4114e720e08bc88e85f9943ebd640abe5924fa6042bb" + }, + { + "row": 14, + "l1": "81", + "terms": 265, + "sha256": "2290af2000444bd5b2a7c9460b37ea53f32528a621e6968a550731f5ea5fc7dc" + }, + { + "row": 15, + "l1": "81", + "terms": 265, + "sha256": "547b3b066fd08b62a6acd39897adc8cbb734ea5dbaf37d1eaa9cd30562e04d9d" + }, + { + "row": 16, + "l1": "81", + "terms": 265, + "sha256": "d94b2bc096b1316cce6ad46fb106fe058764194f74b8631d5293079a210c8b89" + }, + { + "row": 17, + "l1": "81", + "terms": 265, + "sha256": "ce992d2b57c493c6dc294ced7612321b11ca4c1a2db12822f341a7b47dc41599" + }, + { + "row": 18, + "l1": "81", + "terms": 265, + "sha256": "25acb9b7b1193c95aa84494a682f883ddec73682f80cfc6aa9c3baa803938f9c" + }, + { + "row": 19, + "l1": "81", + "terms": 265, + "sha256": "1fe922a46e31a6ece19235010801cbdd01c88b974a1d6e47b5526f7de07120aa" + }, + { + "row": 20, + "l1": "1921", + "terms": 5465, + "sha256": "a5870e7eae8024cac35aecb43770ad022e99dde94d18bb8534d7688d43e2a4d4" + }, + { + "row": 21, + "l1": "1358", + "terms": 10836, + "sha256": "936205ecee78d5852060c8e433ab1372a114a0e3d65ea140b74b8b7529d2436a" + }, + { + "row": 22, + "l1": "81", + "terms": 265, + "sha256": "edaa781816d201c4905cbd5268496846912d9a9e7786aeeff54af43cc7a17b6a" + }, + { + "row": 23, + "l1": "81", + "terms": 265, + "sha256": "2c4ca9a090fbad44f7656a235ec32cb465204251f43caadf38e06acdf004cb24" + }, + { + "row": 24, + "l1": "81", + "terms": 265, + "sha256": "e3f7f5812d57c90edc6833a9667a4c0eba8165d5c17d854fde4de858c99e352b" + }, + { + "row": 25, + "l1": "81", + "terms": 265, + "sha256": "f6589ce53bb07a5bb6c6b91e3264d01486ed828f81b4bbf96e6535b84e4a3ef0" + }, + { + "row": 26, + "l1": "81", + "terms": 265, + "sha256": "0edcaace27a7c14e1365d1bbbdd6a637bb36bf155f3c1620bf14f47ba2d49bf0" + }, + { + "row": 27, + "l1": "1921", + "terms": 5465, + "sha256": "32606f725d76f97b46097df9f29830834ed6dc906445384c66be7afa49c82dad" + }, + { + "row": 28, + "l1": "81", + "terms": 265, + "sha256": "194f73bfbd94a78b7e7bdc595bbe900982fd87782d9d65d30731982f8459a858" + }, + { + "row": 29, + "l1": "81", + "terms": 265, + "sha256": "e695a5fb3d5e9c539948a41dae5749682e04f15c7c3cb779a6720435f8fee377" + }, + { + "row": 30, + "l1": "81", + "terms": 265, + "sha256": "30158f92db6b8eb7f2240a59fce0e01b43fb021b6e5f9fa3983e2865c82003ae" + }, + { + "row": 31, + "l1": "81", + "terms": 265, + "sha256": "f018bc4f98b545821321c3bdfafed315036b5300c4c2d617b8a365966a688630" + }, + { + "row": 32, + "l1": "81", + "terms": 265, + "sha256": "6ef43ed77822127f5de3c8f88615658f50c5caaf8f49801f69712e8a1a37cee6" + }, + { + "row": 33, + "l1": "81", + "terms": 265, + "sha256": "06b9f7f3f1d45156af6a1234b641647c169eaad997a52c04de9c87cb88f81cda" + }, + { + "row": 34, + "l1": "81", + "terms": 265, + "sha256": "e48b8895e1cdb2010003c8ee448ab8ad44e6f18cbf4069124dffc28dcdda8846" + }, + { + "row": 35, + "l1": "81", + "terms": 265, + "sha256": "c7540b7585e6f8ff74a877fe4d644fe84f4de833e2f83966720908285c19e4b8" + }, + { + "row": 36, + "l1": "1921", + "terms": 5465, + "sha256": "eb079778b27b3fa6df1560fd6ab750a322650e050312a617ae5524c67323e83f" + }, + { + "row": 37, + "l1": "1358", + "terms": 10836, + "sha256": "9bb258fa8bc93022afdd8724b5f93946e6304fb90c83efc6df3ce5ba106b9d40" + }, + { + "row": 38, + "l1": "81", + "terms": 265, + "sha256": "d7502b31ddd1fc493cfb891b39c7afae0d4bce8e450da01b9932b3026cf09ced" + }, + { + "row": 39, + "l1": "81", + "terms": 265, + "sha256": "ffd8d46fdd3fbbee5822a2087dbd1c0453a35cb2b62cb8f464e2aac3636c9c04" + }, + { + "row": 40, + "l1": "81", + "terms": 265, + "sha256": "60c136c57a81262153aacd0bbcfd6ae4036e5503b16ba51ce30ffa35a141587b" + }, + { + "row": 41, + "l1": "81", + "terms": 265, + "sha256": "ce8428799f1adc7fa7daafb33172a08698dacb4c980e4b38a2b93621aeea48f9" + }, + { + "row": 42, + "l1": "81", + "terms": 265, + "sha256": "2e70c4cd6398af1aaee78a0261d4c336fc2cdac52317f5d2dfdb7b62806344ba" + }, + { + "row": 43, + "l1": "81", + "terms": 265, + "sha256": "6b93ebff0ba438151a809c76f5452739e4cb42f76a3a74ea845980751e70b89b" + }, + { + "row": 44, + "l1": "81", + "terms": 265, + "sha256": "ce3dc4222077abfe859029c8eba945e2893b05ea0fc8a5cc5137c2b1b929836e" + }, + { + "row": 45, + "l1": "81", + "terms": 265, + "sha256": "75101204004e206008b22c311a6b33e75c22dbd593e83627167fe5b579463463" + }, + { + "row": 46, + "l1": "1921", + "terms": 5465, + "sha256": "b6cadbda9d9f8aa9a3e3569681d5263bc2ffdc3677fa6a12dab44c4fb3d6a992" + }, + { + "row": 47, + "l1": "1358", + "terms": 10836, + "sha256": "b36adfcb0ece7d32d4577bedab57e461850918589ee65df8a5af3edb058f0b55" + }, + { + "row": 48, + "l1": "81", + "terms": 265, + "sha256": "96a6841331ea60ff464a4eca8e57d49d51c2f13262334eec47b6fbc9816ed86e" + }, + { + "row": 49, + "l1": "81", + "terms": 265, + "sha256": "8ff7f9355e83b5743fbdce7c619b971bd540905a5c937379300dbfbd9751732a" + }, + { + "row": 50, + "l1": "81", + "terms": 265, + "sha256": "9cca82123dd809a9a8d48ea9771d770aad95914c634ee96ddfa849c5d3a0a219" + }, + { + "row": 51, + "l1": "81", + "terms": 265, + "sha256": "62617c2e20a2d4a795ae9379651dd6b8081a997930654a3111c801122b6ce0ae" + }, + { + "row": 52, + "l1": "81", + "terms": 265, + "sha256": "a29ee1384c232eff55492d4a5353650dd42825ad2882b75f5652c7108ff84ee0" + }, + { + "row": 53, + "l1": "81", + "terms": 265, + "sha256": "96ade1f88448f9a1a59363525f0d2bb1b2912860897bac795bf0159ba9d7b2a1" + }, + { + "row": 54, + "l1": "81", + "terms": 265, + "sha256": "4a35b7c9578377d058b2b10b1e0d408ca6848ca8e801ab6c9a2aa55314d8d03e" + }, + { + "row": 55, + "l1": "81", + "terms": 265, + "sha256": "1b4b89d818581c15c2bf42e1f1b022c352730cef8c551fd5b67d0b397bdf6ec0" + }, + { + "row": 56, + "l1": "81", + "terms": 265, + "sha256": "11359938116e2556210578e90a15db4e71a7646ff237d90a808b547deb5ef695" + }, + { + "row": 57, + "l1": "1921", + "terms": 5465, + "sha256": "133f48dde8005cacb4a6f2ea4cfd9339101b1e1ce44ae97ccc649c8d3f5dfbd3" + }, + { + "row": 58, + "l1": "81", + "terms": 265, + "sha256": "9c23f2db7d905dcabe64008659c5dd9cb54858ead4cfc4981d7f02f67b85aaab" + }, + { + "row": 59, + "l1": "81", + "terms": 265, + "sha256": "fc31c367d9069280c13439e04a4a8316e673ab286738dd306b832a38cbb197cd" + }, + { + "row": 60, + "l1": "81", + "terms": 265, + "sha256": "917b793b287064b296ed096066bc70834bd3f9bf8be73453275567e3bcda2a0e" + }, + { + "row": 61, + "l1": "81", + "terms": 265, + "sha256": "7643db7cf960acf72241133a0e47247ea4c99ead8ac0b5d74fb5fc286f79eb9c" + }, + { + "row": 62, + "l1": "81", + "terms": 265, + "sha256": "f4f66e453cbc3f5b3b691d0b1fdf8b9eb486631c169069ab64da6e4c98604b85" + }, + { + "row": 63, + "l1": "81", + "terms": 265, + "sha256": "743754264d6c73d4b51f3f8a02b8db4672566f4cfa1e5f6db1dd7b88a948c33b" + }, + { + "row": 64, + "l1": "81", + "terms": 265, + "sha256": "fecad2358337e274a948d75ac5bce6be935fa74087514b6b7a0a0936d6d7f3a7" + }, + { + "row": 65, + "l1": "81", + "terms": 265, + "sha256": "8ac663a1d4e522b26229024375e5fc85dc02d457990fb813953e018185d715ea" + }, + { + "row": 66, + "l1": "81", + "terms": 265, + "sha256": "4d118e615d48754b57eed7434cfaceb50e3acc5028a561d01c64ec3c862bde99" + }, + { + "row": 67, + "l1": "81", + "terms": 265, + "sha256": "c3daf6680a7a18e808b92f1c9e2e6b14c39af6803192375c8af58ee91e038472" + }, + { + "row": 68, + "l1": "81", + "terms": 265, + "sha256": "32e63a24338c1cda9930cb14cd431e0a15f3a61fe35194bcfc438331eaf0c6cf" + }, + { + "row": 69, + "l1": "81", + "terms": 265, + "sha256": "e2fdc0b3874c281ea524454b8ef8a08eafea6d57b4687dc0b7576b2f15036446" + }, + { + "row": 70, + "l1": "81", + "terms": 265, + "sha256": "5af4b6fbd153d1b60a1e356c9bc371ab8d44062d83048b458f1238b80d544618" + }, + { + "row": 71, + "l1": "81", + "terms": 265, + "sha256": "e824f545eff1756728741085827f36f233bdbea5ea5dae9d3301ff5c88ab2d91" + }, + { + "row": 72, + "l1": "81", + "terms": 265, + "sha256": "b4969145a8773f0e53fbe6f32117e176b8a81416dcb74d7318ec793ee189d224" + }, + { + "row": 73, + "l1": "81", + "terms": 265, + "sha256": "eb4bcf7798964c5d9cc7e1f1c25fd1bdb2cad41724b63c6ac5e4bbf1cc1f9bd1" + }, + { + "row": 74, + "l1": "81", + "terms": 265, + "sha256": "19f925d126ccd6df2b1f4c550eaf16435dc6afb8d73674d7c67478d789c553da" + }, + { + "row": 75, + "l1": "81", + "terms": 265, + "sha256": "1e3e5d9c808802c5290149208349d02376edd716d9a56f23d0192222de01a34e" + }, + { + "row": 76, + "l1": "1358", + "terms": 10836, + "sha256": "276fa0701cfb41f14ff1ec85467eb1b33daa1de34a8ff3e7e1e611eaff850ad1" + }, + { + "row": 77, + "l1": "81", + "terms": 265, + "sha256": "b4abc009ede3349b51b2b2e0c297b706ba7d3b44b0ed1a92cb523869d32d56e3" + }, + { + "row": 78, + "l1": "81", + "terms": 265, + "sha256": "0646b843145d22de4d91df73a70177bb73770a3c4cb740e66d4c26851be0cfbb" + }, + { + "row": 79, + "l1": "81", + "terms": 265, + "sha256": "cc491e81a5bd9ab8ef42434f1210748fd30d150721e957f7132639d81b3b6d23" + }, + { + "row": 80, + "l1": "81", + "terms": 265, + "sha256": "408fa5e8a3a6f80da11518d21426ee169df3a119ae21891b17836ad2b95c27f4" + }, + { + "row": 81, + "l1": "1358", + "terms": 10836, + "sha256": "b7eb248c3d30e140e834daab3ef0c6410567bd0fa8378a1bf047d64ab553cd72" + }, + { + "row": 82, + "l1": "81", + "terms": 265, + "sha256": "0883e74e32ce4e033077c637ed58dfec4d018ede13e7804edaa93fe6132b3bc5" + }, + { + "row": 83, + "l1": "81", + "terms": 265, + "sha256": "8debaaf74bc8507ca7aa3ddc6eef9d0ef58a0c44495d42f39262e0dd840d9edf" + }, + { + "row": 84, + "l1": "81", + "terms": 265, + "sha256": "ec5f524d6bc2fde92b0f344ddc3e1c1b21cb9a95bb9ed34454ce397b34ac5ca6" + }, + { + "row": 85, + "l1": "81", + "terms": 265, + "sha256": "199cffc701de28fe27b7ec1ccf45d1ecefde16aca21cb12dc842dbebb0a18551" + }, + { + "row": 86, + "l1": "81", + "terms": 265, + "sha256": "5b67b17ff9afd6d27c526c9e70f9cbacca82af1a96dcc7ea81ed23dfd9a8cd6a" + }, + { + "row": 87, + "l1": "1358", + "terms": 10836, + "sha256": "241ca70752af46ffe2bc5c4876326c7cb342d52e94b20d7036ea40001ad84379" + }, + { + "row": 88, + "l1": "81", + "terms": 265, + "sha256": "df03b2e8ccab67f207bb1e94c24cf1188e0358f1d9d7a8cfbec52930b2f39ab7" + }, + { + "row": 89, + "l1": "81", + "terms": 265, + "sha256": "bd7197bfa7c80ed948a09d1202e29f5413d798aa0b6e67534ae066c61ee98336" + }, + { + "row": 90, + "l1": "81", + "terms": 265, + "sha256": "afddb9271f9de18e9a5fdb701e302b3f0521ac28b41bcf9bd0267f6bdd6f14a3" + }, + { + "row": 91, + "l1": "81", + "terms": 265, + "sha256": "b2af73d54a28f1353ad468f6db417b2eca819c19c809552dc76b16fb15435ea0" + }, + { + "row": 92, + "l1": "1358", + "terms": 10836, + "sha256": "2089d01a40564b694f4b6878adc0c16a610d186ce5b5703431766dbefb883ad2" + }, + { + "row": 93, + "l1": "81", + "terms": 265, + "sha256": "702f6fe858950ea3416ba57c1bb1f6f8e816d8e06b70ee3c57f641aee39f4660" + }, + { + "row": 94, + "l1": "81", + "terms": 265, + "sha256": "c5410bfa18f600aaa818b090e87da33d469efd2d39a86fc200d3a56957c719ae" + }, + { + "row": 95, + "l1": "81", + "terms": 265, + "sha256": "33a63e823b0ca9fd517728a90124657f9002b13c5b10df695d6331c53698781d" + }, + { + "row": 96, + "l1": "81", + "terms": 265, + "sha256": "a1d38f817c822001ef0f38ea96c786528de988c6d81299095cf5357122a9203a" + }, + { + "row": 97, + "l1": "81", + "terms": 265, + "sha256": "79616d66a0fc46f1bad78b9eb8866b0419d7b8fd63ade4b7c861e245bbe566fd" + }, + { + "row": 98, + "l1": "81", + "terms": 265, + "sha256": "5607509937e3235c7c2fe26442c5e7df4a22d387ebd8279d8f2d205962628ffd" + }, + { + "row": 99, + "l1": "81", + "terms": 265, + "sha256": "de3fcbbb40bb34f6860e684153b055057204b44b09f39479cf53671fdbb4def4" + }, + { + "row": 100, + "l1": "81", + "terms": 265, + "sha256": "2a1c5e4d42ce1f7528e2afeba8ececbce9c15777038d9fdeccdcbf5b57e294a5" + }, + { + "row": 101, + "l1": "81", + "terms": 265, + "sha256": "5f1d137c18227eff367708e8ee911584f955f1626b79a5e2ad81aee840f91e91" + }, + { + "row": 102, + "l1": "81", + "terms": 265, + "sha256": "d24824c566cef5a9379c94ddae28e01ffa974b442a4c96796afed8541bb60c50" + }, + { + "row": 103, + "l1": "81", + "terms": 265, + "sha256": "7f59e6cd1464dfb78c3f273559e309f0c54770dae4e3f0469483ebdcccc57012" + }, + { + "row": 104, + "l1": "81", + "terms": 265, + "sha256": "ec7f7a4ca790c0aa4290b7b91a6ccc6628570cdf49ef12f64c7fe0c7ac59711a" + }, + { + "row": 105, + "l1": "81", + "terms": 265, + "sha256": "3aae7435007b5ac9c6b0091aa3185d9a78a0af89d8ceee3598662afe9025b017" + }, + { + "row": 106, + "l1": "81", + "terms": 265, + "sha256": "021b96311404eee6b9afa462993add81a8a3c5a2b33febb17353f7dc3f7916ae" + }, + { + "row": 107, + "l1": "81", + "terms": 265, + "sha256": "2fd2541a6c160d9e4d9e6f1d7ace1506a43da4abff1d5cf97c3a6bd5e7c74029" + }, + { + "row": 108, + "l1": "81", + "terms": 265, + "sha256": "4ceb1b1bcc7f49726271ec681bcdd47e182062fb467f13bcfc210cc8df0a4898" + }, + { + "row": 109, + "l1": "81", + "terms": 265, + "sha256": "3b789a6d55f814db32e91a384031d23caf400390a2efcf0395156969fc303dbb" + }, + { + "row": 110, + "l1": "1358", + "terms": 10836, + "sha256": "4063f8b5b6f5d154dcee9f95695fb904e2e22cacbdb54c3247e29faafee65fa0" + }, + { + "row": 111, + "l1": "1921", + "terms": 5465, + "sha256": "b31ae19090c6b66bb68218eea806cd02e874be11a7c27d40bd75e243b9d06b17" + }, + { + "row": 112, + "l1": "1923", + "terms": 5466, + "sha256": "eccf48a61708258dca8da6d5cb9b55d9dad7a9397635538420d6151933d73fb6" + }, + { + "row": 113, + "l1": "1", + "terms": 1, + "sha256": "bbea2098278cfda7cb6bc9c24fc4dc46d06e7e518681c39ea6c7d5e0ffcc01a6" + }, + { + "row": 114, + "l1": "1", + "terms": 1, + "sha256": "b75ec434dd6cdb6987bcb53a8c6a266e27a0c2a7dd5f0c879b562c5320b0e207" + }, + { + "row": 115, + "l1": "1", + "terms": 1, + "sha256": "a3feafeba5bdf5674a735c3f4dde82d0bec7f620f3713a97e42f443b14b393cc" + }, + { + "row": 116, + "l1": "1", + "terms": 1, + "sha256": "68cb7ac2390e2c783f0081c2578f993bb8de941369baa7b99f654829fc0b72e6" + }, + { + "row": 117, + "l1": "1", + "terms": 1, + "sha256": "f9f8710c9147d96e839001a626aaf94d64efa501beb26a571bdff4f69271dd40" + }, + { + "row": 118, + "l1": "1", + "terms": 1, + "sha256": "85439fba0e7c4859567f982b281488708e0be66caa8365ce9dcb2e345964e119" + }, + { + "row": 119, + "l1": "1923", + "terms": 5466, + "sha256": "aa7c37bc490cf89a3fb52909fa9aa1e6a71140581c8b5ced41ad0156c6d2ba2e" + }, + { + "row": 120, + "l1": "1", + "terms": 1, + "sha256": "3f4cbcb713f32a78eb9fdc18c772f12b222c3fd5f8da9103925fe8f54b15bcc6" + }, + { + "row": 121, + "l1": "1", + "terms": 1, + "sha256": "613b19f9c98871dc963523b23c4fc1266e2d0b47268c980713368c449b8fbdd5" + }, + { + "row": 122, + "l1": "1", + "terms": 1, + "sha256": "30e84e3fecb10ab0f3ba88ae41784aae9ce8dd0eea95a07dda762c2b51ae6e31" + }, + { + "row": 123, + "l1": "1", + "terms": 1, + "sha256": "355c2446be180e7e3f0b8498ebfddec45a627df4bf58ccc6c00f4694a4f67cc3" + }, + { + "row": 124, + "l1": "1", + "terms": 1, + "sha256": "2016f80c1d7327fb085d50ee8b4d65a950aedda44b67ac44bdad5072302a6986" + }, + { + "row": 125, + "l1": "1", + "terms": 1, + "sha256": "e40de2b45c36ab3468aa8d0b4931db4ef021efc1cc1295b30dc9abbe6a623d34" + }, + { + "row": 126, + "l1": "1", + "terms": 1, + "sha256": "e38ba6f0059c030ad67bc82d4f9b8bdc2e8113ffa606c4728882026bb4910824" + }, + { + "row": 127, + "l1": "1", + "terms": 1, + "sha256": "52d599edc8130d7dac52fa74c7fec1a66b853f28c636bbed940b30b2bd035670" + }, + { + "row": 128, + "l1": "1", + "terms": 1, + "sha256": "bae01268e555054da41d286de189ec956e4b25ab7f7d3cc0143980ab703040f7" + }, + { + "row": 129, + "l1": "1", + "terms": 1, + "sha256": "7c22b1725050e4aeb98bd012b874bf966aea62ca757d9affb43664b834f85ed9" + }, + { + "row": 130, + "l1": "1", + "terms": 1, + "sha256": "1c024437040174afc70c0f88b295af9f7229a52d181652017de8c6f7c5f2df16" + }, + { + "row": 131, + "l1": "1", + "terms": 1, + "sha256": "b81ac8196018a1bb9ae1f02586dad6836a607c261f70ffd61d8b5dbae5905c24" + }, + { + "row": 132, + "l1": "1923", + "terms": 5466, + "sha256": "27a17e23e3af0be300d46d198e0bc6ba42f7cf10caf195da0efa503ef3eea012" + }, + { + "row": 133, + "l1": "1360", + "terms": 10838, + "sha256": "fddeb15e0aa67e263af93b3bb781953f47f0d46277dea9b251b2fe1816dcb3f1" + }, + { + "row": 134, + "l1": "1", + "terms": 1, + "sha256": "5b2cb973bf6e8d1e573351af82f20c72314a648d988d00254601617ebae58a6b" + }, + { + "row": 135, + "l1": "1", + "terms": 1, + "sha256": "a62d287b6707d964c20c4e5a81f558d8ae5467715ab438df58c89f24ccf8759f" + }, + { + "row": 136, + "l1": "1", + "terms": 1, + "sha256": "b89d7cdd9e68ec7b72baaa9f01d1bf256e3f86d35fc686004a488ddce9e05a19" + }, + { + "row": 137, + "l1": "1", + "terms": 1, + "sha256": "4e031dce0aeebc7770e6ede4c9ad5f0ddec39ec9b714fabfac93f79c12a19cfd" + }, + { + "row": 138, + "l1": "1", + "terms": 1, + "sha256": "08a29c7860f101f3ee1180b6da4d4de410269fbf20696640cf92aa4a6ee69189" + }, + { + "row": 139, + "l1": "1923", + "terms": 5466, + "sha256": "69eceb1bd247633930b44486ddc8e8dd253566b9ed3851b49d1bc47ab835a63c" + }, + { + "row": 140, + "l1": "1", + "terms": 1, + "sha256": "4129365897d20df88be6093801acc2e9b4e9c318da0b32a30e4f8f7fdd3e6298" + }, + { + "row": 141, + "l1": "1", + "terms": 1, + "sha256": "a9a5423f64f7eb99250c74410770333f0599dc1219c6ddba53431cb685a703f3" + }, + { + "row": 142, + "l1": "1", + "terms": 1, + "sha256": "66f03d210a6fb87ac84793aa65ebabbb033787c2764586ff8b1751a9aa8ad701" + }, + { + "row": 143, + "l1": "1", + "terms": 1, + "sha256": "1a4bde7763435ca5654ae810d3a772472e3bad5028ebec2cf22c5942287cdec5" + }, + { + "row": 144, + "l1": "1", + "terms": 1, + "sha256": "ae97968a00a4ec82a89a69439958d4c2e37898df58426e44497305c94490ca5a" + }, + { + "row": 145, + "l1": "1", + "terms": 1, + "sha256": "f3e662b464c172e05507e280f58db0db476db5d3dfa3abc33612191907c58ba9" + }, + { + "row": 146, + "l1": "1", + "terms": 1, + "sha256": "9a4ae2568a794556474f943b32acec10927900383f92ff6c010e35313075f2f4" + }, + { + "row": 147, + "l1": "1", + "terms": 1, + "sha256": "b42195ecc28876f7d52c6febba5104296c13dbf9158a6cafe7fc3384242ee572" + }, + { + "row": 148, + "l1": "1923", + "terms": 5466, + "sha256": "4b0bfec8bfe1bc2ba84ddebb9a5b3199643891966f1198d9e478ff132e260bd0" + }, + { + "row": 149, + "l1": "1360", + "terms": 10838, + "sha256": "aa40a06849b0e75efa9fc9731e6f9eea3a4e45f03eee17732799dce1aed18728" + }, + { + "row": 150, + "l1": "1", + "terms": 1, + "sha256": "fce0432ff2126b52ff7320d072e4ea12509f0a218e55212a091e56d1df4a17ea" + }, + { + "row": 151, + "l1": "1", + "terms": 1, + "sha256": "084a0453ef8f87f404dbf5acba1d34c38581b56f90ef0c6c0b4f1848f587ffba" + }, + { + "row": 152, + "l1": "1", + "terms": 1, + "sha256": "0a14c62e4efb7d8c1ea9e94a2dc2ec4579fef767976c92446de3400859ac4d2a" + }, + { + "row": 153, + "l1": "1", + "terms": 1, + "sha256": "b96abbc045a7fa01afa96084c544c3bf72fd2679f0da060cd8834b6678211f74" + }, + { + "row": 154, + "l1": "1", + "terms": 1, + "sha256": "c059a78d5cd78403a09a17636ce479b56cbad2c2056dfa6393a0f36af5b4c06b" + }, + { + "row": 155, + "l1": "1", + "terms": 1, + "sha256": "1657e9d5abf8d098f88f82bea94bb0bf46e7d85d8e753ecedf17a012d3b154ad" + }, + { + "row": 156, + "l1": "1", + "terms": 1, + "sha256": "dd817d31f53224927feb43f9cfa0b6ef2a94d7082efba203a04c8474acf55795" + }, + { + "row": 157, + "l1": "1", + "terms": 1, + "sha256": "775ca5155b2ecbf737848e0d1a33f37e417598f12d9ff9f420def24faabd7e3f" + }, + { + "row": 158, + "l1": "1923", + "terms": 5466, + "sha256": "f5f34bf7ab25a4255856fdf3979b716b6cee0aa9902542efc87275843c7f78eb" + }, + { + "row": 159, + "l1": "1360", + "terms": 10838, + "sha256": "07397355070765db1e682cf80cb53b7d757cbe5f704f8fe00c979ea78b069819" + }, + { + "row": 160, + "l1": "1", + "terms": 1, + "sha256": "7916ebf2ef6a11f1aa9d5259dbedc2f45d3823856ba11459c0c53e80b19fd606" + }, + { + "row": 161, + "l1": "1", + "terms": 1, + "sha256": "2b055c902d9c8e90697a209b8dd2ab1eb4ec469d745d4c2250d0f8e4ac5b016a" + }, + { + "row": 162, + "l1": "1", + "terms": 1, + "sha256": "41e508fd6f5db07f114f3429b8ea2855df5cb89bd1fd57595cd930b1f4cb79dc" + }, + { + "row": 163, + "l1": "1", + "terms": 1, + "sha256": "07ba27d1105b1c47e9b15fc0a9fda3542b40bfd3ae6e65495a8332e59e2433d6" + }, + { + "row": 164, + "l1": "1", + "terms": 1, + "sha256": "8a21edfd9900d79153785c5601a4d5e60f164cfa5774a099faa279d421939e2d" + }, + { + "row": 165, + "l1": "1", + "terms": 1, + "sha256": "b8747f7651484eec83f4b0b52a972434979f2c675aed0adff6f3b6c762606200" + }, + { + "row": 166, + "l1": "1", + "terms": 1, + "sha256": "02d3305d4c9cd49dd85db61dc54460e68de586bdc0854f10e1bdbea6adad968d" + }, + { + "row": 167, + "l1": "1", + "terms": 1, + "sha256": "d349d6a4651f651d7c27971a02281995d69aba37199c85b385ddc9c979c8154b" + }, + { + "row": 168, + "l1": "1", + "terms": 1, + "sha256": "adf2c6f48c5b57d8601faa370458b0e540cc22b919fa4a2e977969727ca6476e" + }, + { + "row": 169, + "l1": "1923", + "terms": 5466, + "sha256": "2d3a24b1d60e99f4daf62b8b77cd7c0e22f5c2cdca70e26bab80ec19a97503e9" + }, + { + "row": 170, + "l1": "1", + "terms": 1, + "sha256": "28d121168dc982670a69548a20b99e5d271dc733d5b0a44a28d13d034f61a4bd" + }, + { + "row": 171, + "l1": "1", + "terms": 1, + "sha256": "331e2c782b07e95855fe78f1cb95705298da2155335175f97c0a261e993b0a1f" + }, + { + "row": 172, + "l1": "1", + "terms": 1, + "sha256": "f83edb4817ae09e518d4170aa6b8e77fc718a1ce252114de80544ce8a01ef974" + }, + { + "row": 173, + "l1": "1", + "terms": 1, + "sha256": "155b51c9c85ea2570e8052a4693f195a617bb9e49656d7ebbb312ce76a42dc10" + }, + { + "row": 174, + "l1": "1", + "terms": 1, + "sha256": "a7b931161103c088abe90f5ae0d59302a5eed8ec05e5d8fc2a9903e63390a203" + }, + { + "row": 175, + "l1": "1", + "terms": 1, + "sha256": "4f11f38ecc10a4d500356dfd4d4e9dcdf4d00129c4869596ccec5b4f43395f6e" + }, + { + "row": 176, + "l1": "1", + "terms": 1, + "sha256": "140c21b7ddbabb8fb56203c603f0bb258393f48775ca500bfe368f9d720c723a" + }, + { + "row": 177, + "l1": "1", + "terms": 1, + "sha256": "42243b08f1c3f4a79f0623afb7458a765cf4667a38f790478dd10b33a085c836" + }, + { + "row": 178, + "l1": "1", + "terms": 1, + "sha256": "c860461527cb501ec12478124664aff92ff5ded36da06c803d8f9f68ce7ce269" + }, + { + "row": 179, + "l1": "1", + "terms": 1, + "sha256": "9dee4c0f60536eec0422d45b97b0c1128da836ea5618105dd7ea3db22deaef3e" + }, + { + "row": 180, + "l1": "1", + "terms": 1, + "sha256": "6e67c7f3ae3be7a9a53d64a9bf2d9456632e959d5937bfa953523cb35ef6c211" + }, + { + "row": 181, + "l1": "1", + "terms": 1, + "sha256": "3edd7163c8f21de7236114ab6bb216e07fb38b4f9b4b58a00c5da5726d86e761" + }, + { + "row": 182, + "l1": "1", + "terms": 1, + "sha256": "6d6f1940ebe419658eca0aacf3c35cc7e784a4bc8dfc6b26a40fef3860b5beeb" + }, + { + "row": 183, + "l1": "1", + "terms": 1, + "sha256": "b8435d13e622b8461a4b0989cb9b7eb466c581ea2bb4cd6b671cdd8cf0ca13b3" + }, + { + "row": 184, + "l1": "1", + "terms": 1, + "sha256": "6d9980a3bafc594380aaad5c97c55a5d8091dfdc226f50af122a0fc5a4972904" + }, + { + "row": 185, + "l1": "1", + "terms": 1, + "sha256": "eff9e5222c0e5d701cef537349346fc45414f416d0ba642ec0948f613926058d" + }, + { + "row": 186, + "l1": "1", + "terms": 1, + "sha256": "0af71e0be613e18c4f76f3514c79856e9e2c8fe3db5dc8c9da021332cc8d6410" + }, + { + "row": 187, + "l1": "1", + "terms": 1, + "sha256": "a81fb0da7df2100ebc9d3fb85f437ea0fc72bccc642e57ebf927314dfc25d9b7" + }, + { + "row": 188, + "l1": "1360", + "terms": 10838, + "sha256": "ac3d5c2668a50a136f27764f9176ad307b866903fc45eafe49cc98d610ba1640" + }, + { + "row": 189, + "l1": "1", + "terms": 1, + "sha256": "69ed705b75cd538d282c39fb66e942954079c6377cfca4844849a3fdbeb1e8aa" + }, + { + "row": 190, + "l1": "1", + "terms": 1, + "sha256": "cf3ffbef0e3c5f6c0a42b2a59a47550a30e0a2351a10e83d9f6864f598445a61" + }, + { + "row": 191, + "l1": "1", + "terms": 1, + "sha256": "626f5995ec3a2e8ce18e2cef28cf5d9e3dd9d89a8262458827bc856a39cf7b76" + }, + { + "row": 192, + "l1": "1", + "terms": 1, + "sha256": "aa969846f51ccf999a75cb76ff488fe3d0e8eaf02f7613dc3899b1d625ed4aa3" + }, + { + "row": 193, + "l1": "1360", + "terms": 10838, + "sha256": "840f307ff61b86beeb686312795d7428a587643d80428a49f7c437518a2bc4de" + }, + { + "row": 194, + "l1": "1", + "terms": 1, + "sha256": "5cb8071dbfea4c87f2a7b82935c9c6d8a95f48d61a2bcbf947c3388b729b2211" + }, + { + "row": 195, + "l1": "1", + "terms": 1, + "sha256": "c3e89d176c914cf6bbf89dcd58dba6d9895e80b1807c8a467a967cf40c70c203" + }, + { + "row": 196, + "l1": "1", + "terms": 1, + "sha256": "acd6ff24587da5815ef21c97fc372c2a083412a9c1cce74561963e8031c4b7a6" + }, + { + "row": 197, + "l1": "1", + "terms": 1, + "sha256": "027082d915927968316b9b3d0e1a8356418db32b2d595a8ef6de95754ff70813" + }, + { + "row": 198, + "l1": "1", + "terms": 1, + "sha256": "580183de38fc765bd84e94d4db69f49a68c7d239556b14617562e4c60f148ca3" + }, + { + "row": 199, + "l1": "1360", + "terms": 10838, + "sha256": "8b4b39bd719203d3bb68c8e76ede2e2fda502d20990edcf07e5b5d09da645653" + }, + { + "row": 200, + "l1": "1", + "terms": 1, + "sha256": "40e4de23a03199d5e8cef6057dcc5408f29e58ee27e3c3c241f5c6abd86cd97d" + }, + { + "row": 201, + "l1": "1", + "terms": 1, + "sha256": "96667c3da3aaba2e7ab776b1b810b3953cc750336e7f1536b6dd4b5d7428d9f0" + }, + { + "row": 202, + "l1": "1", + "terms": 1, + "sha256": "eb209ab29eac3428d3dacfd852afdaaccdec4b6c8643f0da0b5fa679676dec5e" + }, + { + "row": 203, + "l1": "1", + "terms": 1, + "sha256": "98f4cebd0c370c44dd6253f299914204f71ea0a98c7c7dd7a9cc5a5d96bfb5da" + }, + { + "row": 204, + "l1": "1360", + "terms": 10838, + "sha256": "a38cfae7a61ac15f4bbc9ee7642cbcaddd0fb381bf180f6e17c0eb48245c65bd" + }, + { + "row": 205, + "l1": "1", + "terms": 1, + "sha256": "ce7d7552e20b27520c6fd6199dc9ee3d50ab0972423f7d73283f2c98dcf7d273" + }, + { + "row": 206, + "l1": "1", + "terms": 1, + "sha256": "66818dfcb006cb2aa0e76330d7189033c9be58cee58c82c7a2bd59ec578717fc" + }, + { + "row": 207, + "l1": "1", + "terms": 1, + "sha256": "b5c5cd8902aeedc0e0c6a487a44aa659585b13f5dc1f0712bd87399211c1ee2c" + }, + { + "row": 208, + "l1": "1", + "terms": 1, + "sha256": "9455642695f3a0587495d96e41c2e4167fc54996e1b77c039e0d3cfa919b2cf1" + }, + { + "row": 209, + "l1": "1", + "terms": 1, + "sha256": "c53a1a5ffb83e102de07f59e5e9a8275b2c70f4b2338e87267e16f5fd021afb6" + }, + { + "row": 210, + "l1": "1", + "terms": 1, + "sha256": "4af43659938b0fa87dc61c9ca2e5812eca4c06b523242fcb51218285ba013a02" + }, + { + "row": 211, + "l1": "1", + "terms": 1, + "sha256": "3fb958b4abbee4683376b32f98b88d823fdba04c9a739c9160293007cff5f853" + }, + { + "row": 212, + "l1": "1", + "terms": 1, + "sha256": "ca411b5694e436bca688b362c71daf3baa6e8337202dd13c9d1a6124e529b407" + }, + { + "row": 213, + "l1": "1", + "terms": 1, + "sha256": "2c27f259974d7e5e20e1d775fa75efa47f5368ea54d1c0d8ce3418838e537801" + }, + { + "row": 214, + "l1": "1", + "terms": 1, + "sha256": "757c49fdb98013f9a386d7c99513fea37782e22ba0f4f4bc488b06bb17aef53e" + }, + { + "row": 215, + "l1": "1", + "terms": 1, + "sha256": "e8b02b98f9d22963bffd62bd5fde362f12f06300fdf84fca2f8792c46a26cd69" + }, + { + "row": 216, + "l1": "1", + "terms": 1, + "sha256": "4597744218a80e744aaa47f096acaa8e91f1b309e8d9aba2c439e827147579d0" + }, + { + "row": 217, + "l1": "1", + "terms": 1, + "sha256": "8bdc3a0ef577581b0b69ba6c2fcbbf499afebfea99fcb5cf40cbdf1f3fc18dd6" + }, + { + "row": 218, + "l1": "1", + "terms": 1, + "sha256": "7deb4d03ea5fe17dab2a44639d36e13fb7140f9be7aa9b43f43c046c04321312" + }, + { + "row": 219, + "l1": "1", + "terms": 1, + "sha256": "4e215c33710b1e9a356f2fbac8ef1b54b0e0f85082f7e46188a94a0fc2a03084" + }, + { + "row": 220, + "l1": "1", + "terms": 1, + "sha256": "9b2cb48b92adec1343e78bc6d28b32159b9b506ccd31c7f6d2ead2d06b6acf7d" + }, + { + "row": 221, + "l1": "1", + "terms": 1, + "sha256": "69b8b8eaa0642b257467ad07d43235b2f067f9580c3955a1c9f9fe68ce4de0a6" + }, + { + "row": 222, + "l1": "1360", + "terms": 10838, + "sha256": "139b969db334e519cb1c9bc6603d7fcc29f0b20a0c58be9b317e72e9094cd34a" + }, + { + "row": 223, + "l1": "1923", + "terms": 5466, + "sha256": "e46ed83c368477d95433618181d7821ea4bb7cbbbbe222def316d492fc2192ec" + } + ] + }, + "peak_terms": { + "F0": 1643, + "D": 351624 + }, + "controls": { + "F0_sharp_witness": "49", + "normalized_error_bound": "7587/8192", + "route_order": "distinguished", + "cancellation": "exact" + }, + "scope": "Conditional endpoint bounds; no physical producer implementation." +} diff --git a/research/qq16-producer-defect-transfer/SOURCES.json b/research/qq16-producer-defect-transfer/SOURCES.json new file mode 100644 index 0000000000..cb634586a1 --- /dev/null +++ b/research/qq16-producer-defect-transfer/SOURCES.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "base_commit": "318ba71b8927f81141f41a89c1af74323586f253", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/qq16-line-normalized-decoder/PROOF.md", + "usage": "input", + "git_blob": "f7c694ff54e590416e4a52fa762f9d3b9474bccb", + "sha256": "0a0995e70f2a64c15cdd1aee66634d1ba221cbcb2a7cfa3a4d4950a37d0e143a" + }, + { + "path": "research/qq16-line-normalized-decoder/WORD.json", + "usage": "input", + "git_blob": "e45320dcb07ef2dc89622e9ca68adfe826a6e9dd", + "sha256": "5623b9cd62635d47f84e78135d817cfddec7ae31c154c565bf6e16cf5ed75475" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/PROOF.md", + "usage": "input", + "git_blob": "38cd38aa1d342f3bfe0d6d7f3c388aff0352f370", + "sha256": "471f6360cdac94d9e1054c6c9530ace1822b11942f7e141dfd344864d2357862" + }, + { + "path": "research/qq16-zero-retention-defects/PROOF.md", + "usage": "input", + "git_blob": "449e1a181d177c7f2ee663e5d9d13898d2872834", + "sha256": "11edf91802c08c75bbddcea5220e04fa612b46e916ca14c44f63263cdd76fa3c" + } + ] +} diff --git a/research/qq16-producer-defect-transfer/TASK.json b/research/qq16-producer-defect-transfer/TASK.json new file mode 100644 index 0000000000..65a89b8e31 --- /dev/null +++ b/research/qq16-producer-defect-transfer/TASK.json @@ -0,0 +1,109 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 5, + "base_commit": "318ba71b8927f81141f41a89c1af74323586f253", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json" + ], + "methods": [ + "Reconstruct the rank ledger from original operations rather than trusting its aggregate.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Record the selected certificate and complex_profile rather than taking a PR headline as input.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "List the existing independent checks for the exact selected or candidate sources. Pick a new changed input, missing binding or distinct failure mode; stop with a handoff if the proposed arithmetic check is already covered.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure" + ] + }, + "scope_status": "changed", + "actual_scope": "Propagate completed F0 and B_1_2 output defects through the fixed zero-retention decoder to original-array error.", + "scope_change_reason": "The rank-ledger card was narrowed to a different missing implication identified by PR2959: exact entry bounds explicitly do not absorb producer errors. The independent-verification track and semantic failure controls are retained.", + "bottleneck_link": "Supplies a source-bound tolerance for the still-missing finite producer; prevents treating approximate producer state as exact input to the numerical decoder.", + "budget_minutes": 60, + "stop_rule": "Stop after the conditional two-stage defect identity, source-bound constants and independent checks. No downstream construction expansion.", + "outcome": "completed", + "evidence": "Literal logical replay and independently derived ordered inverse equations agree on all 448 polynomial row summaries; 49 is sharp for F0 inverse and 1923 is a decoder upper bound.", + "author": "Nick Petalas", + "ai_assistance": "Substantial automated assistance was used for research, implementation and internal checking. No independent human review is claimed.", + "open_questions": [ + { + "question": "Can an actual finite producer meet the two completed output-defect tolerances?", + "why_it_matters": "The transfer theorem supplies output tolerances, not precision inside the dirty-helper/native producer.", + "first_step": "Pin its completed child contracts and a helper-magnitude/range ledger; derive both completed stage errors in the same norm.", + "blocked_by": "Producer interiors, arbitrary dirty-helper magnitudes, numerical grids and physical costs are not supplied." + } + ], + "assignment": { + "seed": "ee4297486d17f5bdbddc009faf377055", + "track": "independent-verification", + "task_id": "independent-moment" + }, + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2727#discussioncomment-18975580", + "family_decision": "Narrow and stop at a conditional interface lemma; no supplier expansion.", + "overlap": { + "searched_at": "2026-10-16T14:38:58.612356+00:00", + "terms": [ + "producer-defect-transfer", + "completed F0", + "1923 eps" + ], + "coverage": { + "open_prs": { + "fetched_at": "2026-10-16T14:38:01.897996+00:00", + "complete_pagination": true, + "records": 238 + }, + "discussions": { + "fetched_at": "2026-10-16T14:38:32.764810+00:00", + "complete_pagination": true, + "records": 1657 + }, + "closed_prs": { + "fetched_at": "2026-10-16T14:38:58.470410+00:00", + "complete_pagination": true, + "records": 2413 + } + }, + "warnings": [], + "matches_total": 4, + "assessment": "Own package and claim plus an unrelated selected-intervention task match. Broader producer search and canonical thread inspected; no matching external defect-transfer result found. Search omissions remain possible.", + "limits": "Remote PR scope includes open and closed/merged titles and bodies, with separate coverage and timestamps. State changes are deduplicated by latest PR update; snapshots are not atomic. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission." + }, + "freshness": { + "checked_at": "2026-10-16T14:39:28.282410+00:00", + "main": "0614abaef427f123d9b844f85a759e64ee3ab29c", + "priority_revision": 5, + "relevant_change": "Relevant guidance, selected record and all five pinned inputs are unchanged from the scientific base. The original pins are retained." + }, + "verification": { + "environment": "macOS arm64; CPython 3.12.15 via uv; optimized tests CPython 3.14.8", + "registered_replay": "PASS_REGISTERED_RESEARCH_PACKAGE outcome=completed", + "behavioral_groups": 6, + "diagnostics": "Ruff and warning-as-error compilation pass; no static type checker run.", + "review": "Separate inverse-equation implementation and independent mathematical review; no substantive flags. Audit-command typo superseded locally.", + "unrun": "Selected cold replay, physical native producer, formal-kernel proof and hosted CI." + } +} diff --git a/research/qq16-producer-defect-transfer/VERIFY.json b/research/qq16-producer-defect-transfer/VERIFY.json new file mode 100644 index 0000000000..33837053ea --- /dev/null +++ b/research/qq16-producer-defect-transfer/VERIFY.json @@ -0,0 +1,49 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/joint-query/certificate.json.gz", + "research/qq16-line-normalized-decoder/PROOF.md", + "research/qq16-line-normalized-decoder/WORD.json", + "research/qq16-line-normalized-decoder/vendor/pr2681/PROOF.md", + "research/qq16-zero-retention-defects/PROOF.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-Werror", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Source authentication, literal polynomial replay, sharp witness and complete row receipt." + }, + { + "argv": [ + "{python}", + "-Werror", + "-I", + "-O", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 120, + "checks": "Independently derive all inverse polynomial rows from ordered equations; no literal word replay or predecessor imports." + }, + { + "argv": [ + "{python}", + "-Werror", + "-I", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 180, + "checks": "Coherent producer faults, noncommuting toy owners, artifact and semantic failure controls." + } + ] +} diff --git a/research/qq16-producer-defect-transfer/independent.py b/research/qq16-producer-defect-transfer/independent.py new file mode 100755 index 0000000000..f92a8f28e2 --- /dev/null +++ b/research/qq16-producer-defect-transfer/independent.py @@ -0,0 +1,319 @@ +#!/usr/bin/env python3 +"""Derive inverse rows from the ordered equations, without replaying WORD.json. + +Paths are reduced words in free involutions. A left action prepends its token; +equal adjacent tokens cancel. Stage zero is the identity chart. The arena owns +all intermediate rows and clears them at their last use. Its entry cap bounds +live sparse storage even under Python's allocating arithmetic. It does not bound +Python's allocator overhead or the interpreter itself. +""" + +from __future__ import annotations + +import argparse +import gzip +import hashlib +import io +import json +import sys +from fractions import Fraction +from pathlib import Path +from typing import Any + +PORTS = 112 +QUERIES = 8 +MAX_PATH = 4 +MAX_ROW_TERMS = 50_000 +MAX_LIVE_TERMS = 600_000 +MAX_ROWS = 2_048 +SOURCE_SHA256 = "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" +Key = tuple[int, tuple[int, ...]] +Polynomial = dict[Key, Fraction] +Vector = list[Polynomial] + + +class Arena: + """Own all derivation dictionaries and reject capacity exhaustion.""" + + def __init__(self) -> None: + self.rows: list[Polynomial] = [] + self.terms = 0 + self.peak_terms = 0 + + def new(self) -> Polynomial: + if len(self.rows) >= MAX_ROWS: + raise ValueError("independent polynomial-row capacity exhausted") + row: Polynomial = {} + self.rows.append(row) + return row + + def add(self, row: Polynomial, key: Key, value: Fraction) -> None: + previous = row.get(key, Fraction(0)) + updated = previous + value + if updated: + if not previous: + if len(row) >= MAX_ROW_TERMS or self.terms >= MAX_LIVE_TERMS: + raise ValueError("independent sparse-term capacity exhausted") + self.terms += 1 + self.peak_terms = max(self.peak_terms, self.terms) + row[key] = updated + elif previous: + del row[key] + self.terms -= 1 + + def release(self, row: Polynomial) -> None: + self.terms -= len(row) + row.clear() + assert self.terms >= 0 + + +def _add( + arena: Arena, target: Polynomial, source: Polynomial, scale: Fraction, + stage: int = 0, port: int = 0, +) -> None: + assert target is not source + assert 0 <= stage <= 2 and 0 <= port < PORTS + token = (stage - 1) * PORTS + port + for (index, path), coefficient in source.items(): + if stage: + path = path[1:] if path and path[0] == token else (token,) + path + if len(path) > MAX_PATH: + raise ValueError("independent route-path capacity exhausted") + arena.add(target, (index, path), coefficient * scale) + + +def _combine(arena: Arena, terms: list[tuple[int, Polynomial]]) -> Polynomial: + assert len(terms) <= 3 + result = arena.new() + for scale, row in terms: + _add(arena, result, row, Fraction(scale)) + return result + + +def _geometry(packet: dict[str, Any]) -> dict[str, Any]: + groups = [] + for name, size in (("A_ports", 8), ("T_ports", 8), ("U_ports", 96)): + values = packet.get(name) + if (type(values) is not list or len(values) != size + or any(type(port) is not int or not 0 <= port < PORTS + for port in values) or len(set(values)) != size): + raise ValueError("invalid independent port partition") + groups.append(tuple(values)) + if len(set(groups[0] + groups[1] + groups[2])) != PORTS: + raise ValueError("independent port groups do not partition all ports") + matrices = [] + for name, height, width, allowed in ( + ("R_rows", QUERIES, PORTS, {"-1", "1"}), + ("K_rows", PORTS, QUERIES, {"-1/4", "1/4"}), + ): + source = packet.get(name) + if type(source) is not list or len(source) != height: + raise ValueError("invalid independent matrix height") + rows = [] + for entries in source: + if type(entries) is not dict or len(entries) > width: + raise ValueError("invalid independent matrix row") + row = {} + for column, value in entries.items(): + if (type(column) is not str or not column.isdecimal() + or str(int(column)) != column or int(column) >= width + or type(value) is not str or value not in allowed): + raise ValueError("invalid independent matrix entry") + row[int(column)] = Fraction(value) + rows.append(row) + matrices.append(rows) + r_rows, k_rows = matrices + for port in range(PORTS): + for query in range(QUERIES): + if k_rows[port].get(query, 0) != r_rows[query].get(port, Fraction(0)) / 4: + raise ValueError("independent K is not R transpose divided by four") + return {"A": groups[0], "T": groups[1], "U": groups[2], "R": r_rows, "K": k_rows} + + +def _query( + arena: Arena, vector: Vector, stage: int, ports: tuple[int, ...], + geometry: dict[str, Any], +) -> Vector: + assert len(vector) == PORTS and len(ports) <= PORTS + selected = set(ports) + result = [] + for coefficients in geometry["R"]: + row = arena.new() + for port, scale in coefficients.items(): + if port in selected: + _add(arena, row, vector[port], scale, stage, port) + result.append(row) + return result + + +def _section( + arena: Arena, query: Vector, stage: int, port: int, + geometry: dict[str, Any], +) -> Polynomial: + assert len(query) == QUERIES + result = arena.new() + for component, scale in geometry["K"][port].items(): + _add(arena, result, query[component], scale, stage, port) + return result + + +def _discard(arena: Arena, vectors: list[Vector]) -> None: + assert len(vectors) <= 4 + for vector in vectors: + assert len(vector) <= 2 * PORTS + for row in vector: + arena.release(row) + + +def _inverse_f0( + arena: Arena, x: Vector, y: Vector, geometry: dict[str, Any], +) -> Vector: + assert len(x) == len(y) == PORTS + f = _query(arena, x, 0, geometry["T"], geometry) + c = _query(arena, x, 0, geometry["A"], geometry) + rw = _query(arena, x, 0, geometry["U"], geometry) + a = [_combine(arena, [(-11, f[k]), (-1, rw[k]), (-1, c[k])]) + for k in range(QUERIES)] + _discard(arena, [rw]) + original_x = [] + for port in range(PORTS): + if port in geometry["U"]: + section = _section(arena, f, 0, port, geometry) + row = _combine(arena, [(1, x[port]), (1, section)]) + arena.release(section) + else: + selected = a if port in geometry["A"] else c + row = _section(arena, selected, 0, port, geometry) + original_x.append(row) + _discard(arena, [f, c, a]) + original_y = [] + for port in range(PORTS): + terms = [(1, y[port]), (-1, x[port])] + if port not in geometry["U"]: + terms = [(1, y[port]), (1, x[port]), (-1, original_x[port])] + original_y.append(_combine(arena, terms)) + return original_x + original_y + + +def _inverse_b1( + arena: Arena, x: Vector, y: Vector, geometry: dict[str, Any], +) -> tuple[Vector, Vector]: + assert len(x) == len(y) == PORTS + a = _query(arena, y, 1, tuple(range(PORTS)), geometry) + u = [] + for port in range(PORTS): + if port in geometry["A"]: + row = _combine(arena, [(1, y[port])]) + else: + ka = _section(arena, a, 1, port, geometry) + terms = [(1, y[port]), (-1, ka)] + if port in geometry["T"]: + terms.append((1, x[port])) + row = _combine(arena, terms) + arena.release(ka) + u.append(row) + _discard(arena, [a]) + off_a = tuple(port for port in range(PORTS) if port not in geometry["A"]) + future_query = _query(arena, u, 2, off_a, geometry) + previous_y = [] + for port in range(PORTS): + terms = [(1, u[port])] + if port in geometry["A"]: + correction = _section(arena, future_query, 2, port, geometry) + terms.append((-1, correction)) + previous_y.append(_combine(arena, terms)) + if port in geometry["A"]: + arena.release(correction) + _discard(arena, [u, future_query]) + previous_x = [] + for port in range(PORTS): + terms = [(1, x[port]), (1, previous_y[port])] + if port not in geometry["U"]: + terms = [(1, x[port]), (1, y[port]), (-1, previous_y[port])] + previous_x.append(_combine(arena, terms)) + return previous_x, previous_y + + +def derive(packet: dict[str, Any]) -> dict[str, Vector]: + """Return F0 inverse and F0 inverse after B1 inverse on 224 inputs.""" + if type(packet) is not dict: + raise ValueError("independent certificate root must be an object") + geometry = _geometry(packet) + arena = Arena() + basis = [] + for index in range(2 * PORTS): + row = arena.new() + arena.add(row, (index, ()), Fraction(1)) + basis.append(row) + x, y = basis[:PORTS], basis[PORTS:] + f0 = _inverse_f0(arena, x, y, geometry) + previous_x, previous_y = _inverse_b1(arena, x, y, geometry) + decoder = _inverse_f0(arena, previous_x, previous_y, geometry) + assert len(f0) == len(decoder) == 2 * PORTS + return {"F0": f0, "D": decoder} + + +def _read(path: Path, limit: int) -> bytes: + with path.open("rb") as stream: + contents = stream.read(limit + 1) + if len(contents) > limit: + raise ValueError("independent input byte capacity exhausted") + return contents + + +def _certificate(path: Path) -> dict[str, Any]: + compressed = _read(path, 1 << 20) + if hashlib.sha256(compressed).hexdigest() != SOURCE_SHA256: + raise ValueError("independent certificate SHA256 mismatch") + with gzip.GzipFile(fileobj=io.BytesIO(compressed)) as stream: + decoded = stream.read((12 << 20) + 1) + if len(decoded) > 12 << 20: + raise ValueError("independent decompression capacity exhausted") + result = json.loads(decoded) + if type(result) is not dict: + raise ValueError("independent certificate root must be an object") + return result + + +def _summaries(rows: Vector) -> list[dict[str, Any]]: + assert len(rows) == 2 * PORTS + summaries = [] + for index, row in enumerate(rows): + encoded = [[column, list(path), str(value)] + for (column, path), value in sorted(row.items())] + digest = hashlib.sha256( + json.dumps(encoded, separators=(",", ":")).encode() + ).hexdigest() + summaries.append({"row": index, "l1": str(sum(map(abs, row.values()))), + "terms": len(row), "sha256": digest}) + return summaries + + +def main() -> int: + package = Path(__file__).resolve().parent + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--certificate", type=Path, + default=package.parent / "joint-query/certificate.json.gz") + parser.add_argument("--result", type=Path, default=package / "RESULT.json") + args = parser.parse_args() + try: + packet = _certificate(args.certificate) + operators = derive(packet) + expected = {name: _summaries(rows) for name, rows in operators.items()} + result = json.loads(_read(args.result, 1 << 20)) + if type(result) is not dict: + raise ValueError("independent result root must be an object") + actual_json = json.dumps(result.get("operators"), sort_keys=True, + separators=(",", ":")) + expected_json = json.dumps(expected, sort_keys=True, separators=(",", ":")) + if actual_json != expected_json: + raise ValueError("independent operator summaries disagree") + except (OSError, ValueError, TypeError, OverflowError) as error: + print(f"FAIL_INDEPENDENT_QQ16_DEFECT_TRANSFER: {error}", file=sys.stderr) + return 1 + print("PASS_INDEPENDENT_QQ16_DEFECT_TRANSFER") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/research/qq16-producer-defect-transfer/test_verify.py b/research/qq16-producer-defect-transfer/test_verify.py new file mode 100755 index 0000000000..bd37d0c63f --- /dev/null +++ b/research/qq16-producer-defect-transfer/test_verify.py @@ -0,0 +1,216 @@ +#!/usr/bin/env python3 +"""Behavioral controls for the completed-stage error bridge. Apache-2.0.""" + +import json +import runpy +import shutil +import subprocess +import sys +import tempfile +import unittest +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ZERO = (Q(0),) * 4 + + +def plus(*terms): + result = list(ZERO) + for coefficient, vector in terms: + for owner in range(4): + result[owner] += coefficient * vector[owner] + return tuple(result) + + +def route(stage, port, vector): + if not stage: + return vector + pair = ((0, 1) if port % 2 else (1, 2)) if stage == 1 else ( + (2, 3) if port % 3 else (0, 2)) + result = list(vector) + result[pair[0]], result[pair[1]] = result[pair[1]], result[pair[0]] + return tuple(result) + + +class Numeric: + """Direct source equations on four noncommuting toy cover owners.""" + + def __init__(self, packet, word): + self.word = word + self.a, self.t, self.u = (packet[name] for name in + ("A_ports", "T_ports", "U_ports")) + self.r = [{int(p): Q(c) for p, c in row.items()} for row in packet["R_rows"]] + self.k = [{int(p): Q(c) for p, c in row.items()} for row in packet["K_rows"]] + + def query(self, vector, stage, ports): + return [plus(*[(c, route(stage, p, vector[p])) + for p, c in row.items() if p in ports]) for row in self.r] + + def section(self, query, stage, port): + return route(stage, port, plus(*[(c, query[k]) for k, c in self.k[port].items()])) + + def f0(self, fields): + x, y = fields[:112], fields[112:] + f, c = self.query(x, 0, range(112)), self.query(x, 0, self.t) + out_x = [] + for p in range(112): + section = self.section(c if p in self.a else f, 0, p) + out_x.append(plus((1, x[p]), (-1, section)) if p in self.u else section) + out_y = [plus((1, y[p]), (1, out_x[p])) if p in self.u else + plus((1, x[p]), (1, y[p]), (-1, out_x[p])) for p in range(112)] + return out_x + out_y + + def b1(self, fields): + x, y = fields[:112], fields[112:] + query = self.query(y, 2, self.u + self.t) + u = [plus((1, y[p]), (1, self.section(query, 2, p))) if p in self.a + else y[p] for p in range(112)] + a, b = self.query(x, 1, self.t), self.query(u, 1, range(112)) + out_x, out_y = [], [] + for p in range(112): + ka, kb = self.section(a, 1, p), self.section(b, 1, p) + if p in self.u: + xp, yp = plus((1, x[p]), (-1, y[p])), plus((1, y[p]), (1, ka)) + elif p in self.a: + xp, yp = plus((1, x[p]), (1, y[p]), (-1, u[p])), u[p] + else: + xp = plus((1, kb), (12, ka)) + yp = plus((1, u[p]), (-1, kb), (-11, ka)) + out_x.append(xp) + out_y.append(yp) + return out_x + out_y + + def decode(self, fields, suffix=False, word=None): + names = "ZW" if suffix else "XY" + state = {f"{c}{p}": fields[i * 112 + p] + for i, c in enumerate(names) for p in range(112)} + events = self.word[2741:] if suffix else self.word + for event in events if word is None else word: + op = event[0] + if op == "clear": + state[event[1]] = ZERO + elif op == "add": + state[event[1]] = plus((1, state[event[1]]), + (Q(event[3]), state[event[2]])) + elif op == "map": + state[event[1]] = route(event[2], event[3], state[event[1]]) + return [state[f"{c}{p}"] for c in "ZW" for p in range(112)] + + +class Tests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.subject = runpy.run_path(str(HERE / "verify.py")) + cls.packet, cls.word = cls.subject["sources"]() + cls.numeric = Numeric(cls.packet, cls.word) + + def test_exact_noncommuting_producer(self): + v = [tuple(Q(((p + 3) * (o + 5)) % 17 - 8, 8) for o in range(4)) + for p in range(224)] + got = self.numeric.decode(self.numeric.b1(self.numeric.f0(v))) + self.assertEqual(got, v) + sample = tuple(map(Q, (1, 2, 3, 4))) + self.assertEqual(route(1, 0, route(2, 0, sample)), tuple(map(Q, (3, 1, 2, 4)))) + self.assertEqual(route(2, 0, route(1, 0, sample)), tuple(map(Q, (2, 3, 1, 4)))) + + def test_coherent_stage_faults(self): + original = [tuple(Q((-1)**(p + o)) for o in range(4)) for p in range(224)] + ef = [tuple(Q((-1)**(p + 2 * o), 256) for o in range(4)) for p in range(224)] + eb = [tuple(Q((-1)**(2 * p + o), 8192) for o in range(4)) for p in range(224)] + first = [plus((1, a), (1, b)) for a, b in zip(self.numeric.f0(original), ef)] + second = [plus((1, a), (1, b)) for a, b in zip(self.numeric.b1(first), eb)] + decoded = self.numeric.decode(second) + error = [plus((1, a), (-1, b)) for a, b in zip(decoded, original)] + expected = [plus((1, a), (1, b)) for a, b in zip( + self.numeric.decode(ef, suffix=True), self.numeric.decode(eb))] + self.assertEqual(error, expected) + self.assertLessEqual(max(abs(c) for row in error for c in row), Q(3491, 8192)) + self.assertEqual(Q(49, 256) + Q(1923, 8192) + Q(1, 2), Q(7587, 8192)) + + def test_sharp_witness_and_scalar_mutation(self): + rows, _ = self.subject["replay"](self.word[2741:], self.subject["OUTPUTS"]) + witness = [ZERO for _ in range(224)] + for (i, path), c in rows[112].items(): + self.assertEqual(path, ()) + witness[i] = (Q(1 if c > 0 else -1),) * 4 + self.assertEqual(self.numeric.decode(witness, suffix=True)[112], (Q(49),) * 4) + altered = [event[:] for event in self.word[2741:]] + altered[-16][3] = "1" # W0 += Z0 instead of W0 -= Z0. + self.assertEqual(altered[-16][:3], ["add", "W0", "Z0"]) + self.assertNotEqual(self.numeric.decode(witness, suffix=True, word=altered)[112], + (Q(49),) * 4) + + def test_state_failures(self): + replay, names = self.subject["replay"], self.subject["OUTPUTS"] + for word in ([['add', 'F0', 'Z0', '1']], [['clear', 'X0', 'current']], + [['begin', 's', 8], ['clear', 'F0', 'q'], + ['add', 'F0', 'Z0', '1'], ['end', 's', 8]]): + with self.subTest(word=word), self.assertRaises(ValueError): + replay(word, names) + rows, _ = replay([['clear', 'Z0', 'current']], names) + self.assertEqual(rows[0], {}) + self.assertEqual(rows[1], {(1, ()): Q(1)}) + + def test_capacities_and_geometry(self): + row = {(0, ()): Q(1)} + for token in range(4): + row = self.subject["mapped"](row, token) + with self.assertRaisesRegex(ValueError, "degree capacity"): + self.subject["mapped"](row, 4) + with self.assertRaisesRegex(ValueError, "coefficient capacity"): + self.subject["add"]({}, {(0, ()): Q(2**33)}, Q(1)) + with self.assertRaisesRegex(ValueError, "duplicate"): + self.subject["decode"]('{"x":1,"x":2}') + packet = dict(self.packet, A_ports=self.packet["A_ports"][:-1]) + with self.assertRaisesRegex(ValueError, "partition"): + self.subject["geometry"](packet) + + def test_cli_export_and_corruption(self): + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) + package = root / "research/qq16-producer-defect-transfer" + shutil.copytree(HERE, package, ignore=shutil.ignore_patterns('__pycache__')) + inventory = json.loads((HERE / "SOURCES.json").read_bytes()) + for item in inventory["files"]: + if item["usage"] == "input": + target = root / item["path"] + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(HERE.parents[1] / item["path"], target) + self.assert_cli(package, 'verify.py', True, optimized=True) + original_receipt = (package / 'RESULT.json').read_bytes() + refused = subprocess.run( + [sys.executable, '-Werror', '-I', '-B', str(package / 'verify.py'), '--write'], + capture_output=True, text=True, timeout=90, check=False) + self.assertNotEqual(refused.returncode, 0) + self.assertIn('FileExistsError', refused.stderr) + self.assertEqual((package / 'RESULT.json').read_bytes(), original_receipt) + source = root / 'research/qq16-line-normalized-decoder/WORD.json' + source.write_bytes(source.read_bytes() + b' ') + self.assert_cli(package, 'verify.py', False, message='source drift') + receipt = json.loads((package / 'RESULT.json').read_bytes()) + receipt['operators']['F0'][0]['l1'] = '0' + (package / 'RESULT.json').write_text(json.dumps(receipt)) + self.assert_cli(package, 'independent.py', False, optimized=True) + receipt = json.loads(original_receipt) + receipt['operators']['F0'][0]['row'] = False + (package / 'RESULT.json').write_text(json.dumps(receipt)) + self.assert_cli(package, 'independent.py', False, optimized=True) + + def assert_cli(self, package, script, success, optimized=False, message=None): + command = [sys.executable, '-Werror', '-I', '-B'] + if optimized: + command.append('-O') + result = subprocess.run(command + [str(package / script)], capture_output=True, + text=True, timeout=90, check=False) + if success: + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn('PASS_QQ16_PRODUCER_DEFECT_TRANSFER', result.stdout) + else: + self.assertNotEqual(result.returncode, 0) + if message: + self.assertIn(message, result.stderr) + + +if __name__ == '__main__': + unittest.main() diff --git a/research/qq16-producer-defect-transfer/verify.py b/research/qq16-producer-defect-transfer/verify.py new file mode 100755 index 0000000000..8dd78e9e36 --- /dev/null +++ b/research/qq16-producer-defect-transfer/verify.py @@ -0,0 +1,246 @@ +#!/usr/bin/env python3 +"""Certify QQ16 endpoint sensitivity. Nick Petalas; Apache-2.0. + +Native semantics are inherited. No predecessor executable is imported. +""" + +import argparse +import gzip +import hashlib +import io +import json +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCE_PIN = "d9e1681b7c7163cf302aa9bb56b71ab963404cc9bcf99a0b0bb597180fcc2f43" +PORTS = 112 +MAX_ROW = 50_000 +MAX_STATE = 600_000 +INPUTS = tuple(f"{c}{p}" for c in "XY" for p in range(PORTS)) +OUTPUTS = tuple(f"{c}{p}" for c in "ZW" for p in range(PORTS)) +SCRATCH = tuple(f"{c}{p}" for c in "FG" for p in range(8)) +SHAPES = {"clear": 3, "add": 4, "line": 4, "map": 5, + "begin": 3, "end": 3, "checkpoint": 2} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path, maximum): + need(path.is_file() and not path.is_symlink(), f"not a plain file: {path}") + with path.open("rb") as stream: + raw = stream.read(maximum + 1) + need(len(raw) <= maximum, f"input capacity: {path}") + return raw + + +def unique(pairs): + need(len(pairs) <= 4096, "JSON object capacity") + result = {} + for key, value in pairs: + need(key not in result, "duplicate JSON key") + result[key] = value + return result + + +def decode(raw): + return json.loads(raw, object_pairs_hook=unique) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def sources(): + raw = read(HERE / "SOURCES.json", 16_384) + need(hashlib.sha256(raw).hexdigest() == SOURCE_PIN, "source inventory drift") + payloads = {} + for item in decode(raw)["files"]: # Digest fixes the inventory size. + if item["usage"] != "input": + continue + data = read(ROOT / item["path"], 1_048_576) + need(hashlib.sha256(data).hexdigest() == item["sha256"], "source drift") + header = f"blob {len(data)}\0".encode() + need(hashlib.sha1(header + data).hexdigest() == item["git_blob"], "blob drift") + payloads[item["path"]] = data + with gzip.GzipFile(fileobj=io.BytesIO( + payloads["research/joint-query/certificate.json.gz"])) as stream: + data = stream.read(12_582_913) + need(len(data) <= 12_582_912, "decoded certificate capacity") + packet = decode(data) + word = decode(payloads["research/qq16-line-normalized-decoder/WORD.json"]) + need(type(word) is list and len(word) == 3823, "literal word size") + return packet, word + + +def geometry(packet): + a, t, u = (packet[k] for k in ("A_ports", "T_ports", "U_ports")) + need(len(a) == len(t) == 8 and len(u) == 96, "partition sizes") + need(sorted(a + t + u) == list(range(PORTS)), "partition coverage") + r = [{int(j): Q(c) for j, c in row.items()} for row in packet["R_rows"]] + k = [{int(j): Q(c) for j, c in row.items()} for row in packet["K_rows"]] + need(len(r) == 8 and len(k) == PORTS, "R/K shapes") + for row in r: + need(set(row) <= set(range(PORTS)), "R coordinates") + need(all(c in (-1, 1) for c in row.values()), "R signs") + need([sum(j in row for j in part) for part in (a, t, u)] == [4, 4, 48], + "query support by partition") + for j, row in enumerate(k): + need(row == {i: r[i][j] / 4 for i in range(8) if j in r[i]}, "K=R*/4") + need(sum(abs(c) for c in row.values()) == 1, "section norm") + for part in (a, t): + for i in range(8): + for j in range(8): + need(sum(r[i].get(p, 0) * r[j].get(p, 0) for p in part) + == (4 if i == j else 0), "orthogonal selected minor") + return {"A": a, "T": t, "U": u, "R_support": [4, 4, 48], + "section_l1": 1, "F0_forward_bound": 58, "B1_forward_bound": 312} + + +def add(dest, source, coefficient): + for key, value in source.items(): + updated = dest.get(key, Q(0)) + coefficient * value + need(abs(updated.numerator) <= 2**32 and updated.denominator <= 256, + "coefficient capacity") + if updated: + dest[key] = updated + else: + dest.pop(key, None) + need(len(dest) <= MAX_ROW, "polynomial row capacity") + + +def mapped(row, token): + result = {} + for (source, path), value in row.items(): + route = path[1:] if path and path[0] == token else (token,) + path + need(len(route) <= 4, "operator degree capacity") + key = (source, route) + need(key not in result, "involution must permute reduced words") + result[key] = value + return result + + +def validate(event, state, active): + need(type(event) is list and bool(event), "invalid event") + op = event[0] + need(type(op) is str and op in SHAPES, "event opcode") + need(len(event) == SHAPES[op] and type(event[1]) is str, "event shape") + if op in ("begin", "end"): + need(type(event[2]) is int and event[2] in (8, 16), "scope capacity") + if op == "begin": + need(active is None, "overlapping scope") + return (event[1], event[2]) + need(active == (event[1], event[2]), "scope mismatch") + need(all(not state.get(name) for name in SCRATCH), "scratch leak") + for name in SCRATCH: + state.pop(name, None) + return None + if op == "checkpoint": + need(active is None and event[1] == "original_F0_outputs", "checkpoint") + return active + dest = event[1] + need(dest in OUTPUTS or (dest in SCRATCH and active), "borrowed/illegal write") + need(op == "clear" or dest in state, "dirty destination read") + if op == "clear": + need(type(event[2]) is str, "clear frame") + elif op == "add": + need(type(event[2]) is str and event[2] in state and event[2] != dest, + "invalid ADD source") + need(event[3] in ("1", "-1", "1/4", "-1/4"), "ADD coefficient") + elif op == "line": + need(type(event[2]) is int and 0 <= event[2] < PORTS, "line port") + need(type(event[3]) is int and event[3] in (-1, 1), "line sign") + elif op == "map": + need(type(event[2]) is int and event[2] in (1, 2), "map stage") + need(type(event[3]) is int and 0 <= event[3] < PORTS, "map port") + need(type(event[4]) is bool, "map inverse flag") + return active + + +def replay(word, names): + need(len(word) <= 3823 and len(names) == 224, "replay capacity") + state = {name: {(i, ()): Q(1)} for i, name in enumerate(names)} + active, peak = None, 224 + for event in word: + active = validate(event, state, active) + op = event[0] + if op == "clear": + state[event[1]] = {} + elif op == "add": + add(state[event[1]], state[event[2]], Q(event[3])) + elif op == "map": + token = (event[2] - 1) * PORTS + event[3] + state[event[1]] = mapped(state[event[1]], token) + # Native lines change physical chart, preserving represented logical value. + live = sum(len(row) for row in state.values()) + need(live <= MAX_STATE, "live term capacity") + peak = max(peak, live) + need(active is None and all(name in state for name in OUTPUTS), "final state") + return [state[name] for name in OUTPUTS], peak + + +def summaries(rows): + result = [] + for i, row in enumerate(rows): + terms = [[source, list(path), str(c)] for (source, path), c in sorted(row.items())] + result.append({"row": i, "l1": str(sum(abs(c) for c in row.values())), + "terms": len(row), "sha256": hashlib.sha256(canonical(terms)).hexdigest()}) + return result + + +def controls(rows): + sample = {(0, ()): Q(1), (1, (0,)): Q(-2)} + need(mapped(mapped(sample, 0), 0) == sample, "double involution control") + need(mapped(mapped(sample, 1), 0) != mapped(mapped(sample, 0), 1), + "noncommuting route control") + cancelled = sample.copy() + add(cancelled, sample, Q(-1)) + need(cancelled == {}, "exact cancellation control") + peak = max(rows, key=lambda row: sum(abs(c) for c in row.values())) + need(all(not path for _, path in peak), "F0 is owner-local") + # A common unit payload with these input signs attains the maximum row norm. + witness = {source: 1 if c > 0 else -1 for (source, _), c in peak.items()} + attained = sum(c * witness[source] for (source, _), c in peak.items()) + need(attained == 49, "sharp F0 coherent-error witness") + need(Q(49, 256) + Q(1923, 8192) + Q(1, 2) == Q(7587, 8192), "budget") + need(18096 + Q(312, 256) + Q(1, 8192) < 2**15, "actual entry bound") + return {"F0_sharp_witness": str(attained), "normalized_error_bound": "7587/8192", + "route_order": "distinguished", "cancellation": "exact"} + + +def compute(packet, word): + geom = geometry(packet) + checkpoints = [i for i, event in enumerate(word) if event[0] == "checkpoint"] + need(checkpoints == [2740], "inverse-B1 cut") + f0, fpeak = replay(word[2741:], OUTPUTS) + full, dpeak = replay(word, INPUTS) + operators = {"F0": summaries(f0), "D": summaries(full)} + need(max(Q(row["l1"]) for row in operators["F0"]) == 49, "F0 norm") + need(max(Q(row["l1"]) for row in operators["D"]) == 1923, "decoder norm") + return {"schema_version": 1, "geometry": geom, "events": len(word), + "operators": operators, "peak_terms": {"F0": fpeak, "D": dpeak}, + "controls": controls(f0), "scope": "Conditional endpoint bounds; no physical producer implementation."} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true", help="create an absent receipt") + args = parser.parse_args() + packet, word = sources() + result = compute(packet, word) + path = HERE / "RESULT.json" + if args.write: + with path.open("x", encoding="utf-8") as output: + written = output.write(json.dumps(result, indent=2) + "\n") + need(written > 0, "empty receipt write") + else: + need(canonical(decode(read(path, 1_048_576))) == canonical(result), "receipt drift") + print("PASS_QQ16_PRODUCER_DEFECT_TRANSFER F0=49 D<=1923 budget=7587/8192") + + +if __name__ == "__main__": + main()