diff --git a/research/qq16-consumer-incidence/PREDECESSORS.json b/research/qq16-consumer-incidence/PREDECESSORS.json new file mode 100644 index 0000000000..facc2c6425 --- /dev/null +++ b/research/qq16-consumer-incidence/PREDECESSORS.json @@ -0,0 +1,54 @@ +{ + "retained_data": [ + { + "pr": 3952, + "head": "996ff698d3efd0bdce606e240f3b00e6ab91e7fc", + "source_path": "research/qq16-f17-demand-projection/WORD.json", + "local_path": "vendor/pr3952/WORD.json", + "sha256": "f513d235b8206211a4716d013a6dacf34aaebda6839da721b0231981cb8b905e", + "git_blob": "c23da2f205170b11f40299c5ec1dcab45b134861" + }, + { + "pr": 3952, + "head": "996ff698d3efd0bdce606e240f3b00e6ab91e7fc", + "source_path": "research/qq16-f17-demand-projection/PROOF.md", + "local_path": "vendor/pr3952/PROOF.md", + "sha256": "9d674364ef3d9d9dbba6ab32805851cc08b222135f6fc2f18e8f5a230d0764a5", + "git_blob": "97c66df9a9f1730c0b2b53da492a304c4ea2edb2" + } + ], + "credit": [ + { + "pr": 3339, + "author": "Nick Petalas", + "head": "123079bef40faf6949ebac7dfc2859c715acea80", + "use": "Nine-word occurrence136H1 ledger and missing idle-credit caution. This package adds full hosted144/16 incidence and site-rate correction, not a new nine-word count." + }, + { + "pr": 3963, + "author": "Clear1nsight", + "head": "82c812c45fbc2bc2751e5a0d02a3631af25c3cba", + "use": "Centre absence and interface-gap background. Exact atanh arithmetic adapted locally, no imported executable." + }, + { + "pr": 3952, + "author": "Clear1nsight", + "use": "112-line projection local contract/invoice; frozen data retained." + }, + { + "pr": 2512, + "author": "ywz65", + "use": "Actual local96-output F17 demand." + }, + { + "pr": 1969, + "author": "Ali Romman", + "use": "QQ16 literal local words and source lineage." + }, + { + "source": "gauge44/T16/frontier1042", + "credit": "Retained supplier, owner and coverage lineage; original notices preserved." + } + ], + "license": "Apache-2.0; new work Chris R / Clear1nsight with substantial OpenAI assistance." +} diff --git a/research/qq16-consumer-incidence/PROOF.md b/research/qq16-consumer-incidence/PROOF.md new file mode 100644 index 0000000000..e3d1efbe8e --- /dev/null +++ b/research/qq16-consumer-incidence/PROOF.md @@ -0,0 +1,156 @@ +# Integer incidence changes the conditional screen + +This is a finite source ledger and a conditional arithmetic result. It supplies +neither a complete QQ16 global consumer nor an admitted new supplier. + +## Exact source and the first missing connection + +The frozen frontier1042-lineage hosted template is member +`t16/global/hosted/GLOBAL-TEMPLATE.json.gz` of the canonical selected-replay +archive. Its compressed member SHA256 is recorded in RESULT. This is the actual +retained template used here, not a new execution or proof of the current +frontier1094 global assembly. The selected kappa is used only as the target in +the explicitly conditional screen below. + +The template contains 144 local invocations, exactly one for each of 16 replicas +and nine stages. Its complete physical schedule has 482 entries:144 local +sweeps,160 idle sweeps,144 bridges,16 terminal translations,16 terminals and +two final sweeps. The checker binds each call to the physical schedule, its +asynchronous order, orientation, active pair, family identifiers and stage +window. All calls still name the original `gauge44` provider. + +The proposed QQ16 sequence on each replica is + + F0, B1_2, F2, B3_4, F4, B5_6, F6, B7_8, F8. + +The pair indices are0,0,0,1,1,2,2,3,3. There is one stage1 cut per replica, +hence **16 proposed module insertion sites /144 local calls=1/9**. There are +64 backward sites, but the others have completed window dimensions33,49,65, +rather than stage1's17. PR3952's literal source-bound F17 demand is established +at the first B1 cut; a transported contract at another stage is an additional +obligation. Counting all backward calls or72 pair-amortized consumers is not +an interpretation of this exact one-stage1-module proposal. + +There are **zero literal PR3952 invocations in the frozen source**. A source +site is not a proved demand. The first missing provider binding is already +schedule index0:the source names gauge44, not QQ16 F0. After the proposed B1 +cut, replica0's next entries are idle pair1 at index5 and bridge1→0 at index6; +F2 is at index18. These are indices in the full 482-entry `execution_schedule`, +not the replica-local `source_event` labels. All16 records are enumerated in RESULT. The bridge reads +current bank families `896*r+112+p` for ordinary ports p, not new owned earlier +y1_U outputs. PR3963 gives the explicit non-factorization witness; this package +does not reprove it or claim no richer continuation can work. The ledger closes +the incidence question for this precisely stated insertion proposal, while +recording the exact provider/read binding required before it becomes a consumer. + +## Complete proposed local incidence + +The frozen QQ16 certificate has five forward and four backward words per +replica. Every core profile is +`{1:2412,2:418,3:432,4:142,5:82}`, with no H8. Counting actual native-line +recipes gives8 extra H1 for each F and24 for each B, totaling136 per replica. +This occurrence count is inherited from Nick Petalas's PR3339 and independently +recounted here for the source-to-schedule binding. It is not a new discovery. + +Thus the complete nine-word producer mean is + + n1=2412+136/9=21844/9, + n2=418,n3=432,n4=142,n5=82. + +The earlier F0/B1 average2428 is different. A hypothetical d-H1 module placed +once at every stage1 cut adds16d H1 globally, or d/9 per local call. This is an +integer16-invocation proposal, not4.5 invocations per nine-call replica. + +The retained PR3952 word borrows all112 current Y fields and no X. Each of its +112 owned W slots is cleared before use, so arbitrary initial owned dirt is +erased. Its per-invocation invoice is112 H1,224 native wrappers,208 maps, +560 unit ADDs,384 quarter ADDs and144 CLEARs, scalar allowance9376. Sixteen +instances therefore add1792 H1,3584 wrappers,3328 maps and150016 scalar +allowance. These are local occurrences, not a globally admitted paid delta. +No old idle work is certified displaced. + +The output-lifetime ledger is also conditional on a specified consumer horizon. +Retaining96 outputs per instance until the next F2 gives peak384 logical output +fields in the actual interleaving; retaining until the corresponding terminal +gives peak1536. Both have1536 output-bank instances. Sixteen owned temporaries +and eight private scratch arrays are additional per-invocation requirements. +These are logical liveness counts, not claims of free allocation, minimal +storage, or a lower bound on physical families: recomputation, encodings and +other release points change the contract. + +## Family coverage cannot be inferred from output count + +The source's productive interval is[0,14336),16*896 arbitrary data families; +its physical capacity is14826 including work. RESULT binds the exact active +X/Y family intervals and next bridge readset at every proposed cut. No source +instruction allocates or reads the new output bank as a productive family. + +A concrete control varies the arbitrary initial dirt in an owned W output slot. +Its first operation is CLEAR, so both dirty states yield the same result. +Therefore appending this slot does not preserve that slot as an arbitrary +productive input under the selected family contract. It cannot merely be +counted as an additional independent source data family in the existing proof. +This does not exclude a different zero-input/encoded supplier theorem; its +coverage and denominator would need to be derived separately. + +Similarly, the actual incidence ledger does not prove that14336 productive +families, centre64, or the selected idle completion survive substitution of +QQ16 locals and a module. PR3339 already warns that unchanged idle additivity +is not an unconditional inference. This package assigns no displaced-idle +credit and does not strengthen that earlier result into an obstruction. + +## Source-rate conditional moment and sharp integer cap + +Assume, only for this screen, m=73,W_global=14336,N=144, fixed mass +T=72W_global+64N, and the inherited halving guard. Every idle rank is at most51. +For a≥0 the cost per rank-mass unit decreases with rank, so replacing all +remaining mass by fractional rank51 idle work is favorable. With the exact +nine-word producer histogram H and sixteen d-H1 modules, use + + H_d=H+16d*{rank1}, + G(d)=[sum_r H_d(r)(r/73)^(1-a) + +(T-sum_r r H_d(r))/51*(51/73)^(1-a)]/14336. + +All maps, wrappers, scalar, movement, precision, storage and placement costs +are favorably zero in this numerical screen. Their local invoices are not +zero-cost implementations. At the selected target +`a=836330098538459/499163669901461541`, exact outward bounds are: + +|H1 per stage1 module|G(d)| +|---:|---| +|112|[0.999955316227494515,0.999955316227494516]| +|208|[0.999965022703802474,0.999965022703802475]| +|224|[0.999966640449853800,0.999966640449853801]| +|304|[0.999974729180110433,0.999974729180110434]| +|336|[0.999977964672213086,0.999977964672213087]| +|553|[0.999999905353034202,0.999999905353034203]| +|554|[1.000000006462162410,1.000000006462162411]| + +The208/224/304 rows are parameter values only, not admissions of contemporaneous +candidates. The112 and336 rows correspond to predecessor local child invoices; +this package does not claim they satisfy the same whole output contract. +The strict integer cap in this fixed model is553 because replacing idle rank +mass by rank1 has strictly positive excess price when a>0; G(d) is affine and +strictly increasing. Both threshold sides are verified using exact Fractions. + +The same implementation independently checks the earlier paired336 model, +whose moment exceeds1.000097677880011248. Its failure therefore **cannot be +transported** to one module per stage1 cut:the336 one-stage1-module screen +passes. Passing supplies no consumer, compatible family stock, idle placement, +physical cost allowance or multiplication theorem. This is a correction of +budget applicability, not evidence that the original full decoder globally fits. + +Arithmetic uses40 positive atanh terms for log, exact geometric remainder, +and degree14 exponential bounds. No predecessor executable is imported. +The helper is locally adapted from Clear1nsight PR3963 and credited there. + +## Decision and next test + +Do not reject a once-per-stage1 module using the older one-per-two-call screen. +The exact cut rate and full nine-word mean leave a favorable conditional margin, +including for336 native children. The next decision is the first real provider +and read binding:choose a complete continuation which consumes the projected +or reconstructed values at one enumerated site, then map its owned/borrowed +lifetimes and native children to displaced old work. Recompute coverage and +both complete supplier bills before claiming a gain. No additional observation, +retention, endpoint tariff or lower bound is justified by arithmetic alone. diff --git a/research/qq16-consumer-incidence/README.md b/research/qq16-consumer-incidence/README.md new file mode 100644 index 0000000000..d04bc2fcf5 --- /dev/null +++ b/research/qq16-consumer-incidence/README.md @@ -0,0 +1,76 @@ +# QQ16 integer cut incidence and conditional consumer budget + +**One proposed module at each first B1 cut means16 invocations per144 calls, +not one invocation per two calls.** The exact frozen hosted schedule has +16 replicas and nine stages. Its corresponding nine-word QQ16 producer mean +is `n1=2412+136/9`, rather than the F0/B1 pair mean2428. + +This changes the conditional budget decision. With the same assumed W=896/9, +centre64 and ideal rank51 idle completion, a336-H1 module at that rate gives +**G in[0.999977964672213086,0.999977964672213087]**, below one. The strict +integer native-module cap is553 H1;554 fails. The earlier paired336 rejection +cannot be carried over to this placement proposal. + +**There is no admitted consumer schedule here.** All144 source calls still +name gauge44. The source contains zero PR3952 invocations. Sixteen is the number +of source-aligned *proposed insertion sites* for its first-cut F17 contract, +not sixteen proved consumer demands. The first missing provider connection is +schedule index0. Each first-cut record then identifies its exact idle sweep, +current-Y bridge read and subsequent F2/terminal boundaries. The48 other +backward sites have different stage windows and need transported contracts. + +The package adds a source-bound complete482-event/144-call ledger, exact +family/readset and logical-retention counts, local invoice multiplication and +a new source-rate conditional screen. It does not repeat the earlier centre +retirement result or claim productive-family growth from extra outputs. +Retaining all96 outputs until next F2 gives384 peak logical fields; until each +replica terminal gives1536. These are explicit horizon sensitivities, not +physical allocation or storage lower bounds. + +[PROOF.md](PROOF.md) states the source distinction, arithmetic and limits. +RESULT.json retains all16 cut records and complete checks. The frozen template +is frontier1042 lineage, while current selected kappa1094 is only the target +parameter. No claim of a fresh current-global-schedule replay is made. + +## Reproduce + +Python3.12, standard library, from repository root: + +``` +python3 -I -Werror -B research/qq16-consumer-incidence/verify.py +python3 -I -O -Werror -B research/qq16-consumer-incidence/test_verify.py +python3 -B scripts/research_package.py --package research/qq16-consumer-incidence +``` + +Default replay is read-only and compares the complete typed RESULT. All runtime +canonical inputs are in SOURCES/VERIFY; PR3952 WORD and PROOF are retained as +hash-pinned data with source head/blob in PREDECESSORS. No pending executable, +Git object, network, third-party dependency or selected cold replay is needed. + +## Open next questions + +Pin one actual provider/consumer replacement at one of the16 enumerated cuts. +Show which current-bank reads or complete recovery operations disappear, and +supply exact frames, field lifetimes, restoration and a displaced-idle map. +Only then recompute productive-family coverage and the whole physical bill. +The positive553-H1 conditional allowance is a screening cap, not a procurement +budget for an unspecified module. The source has no remaining QQ16 H8 centres +to retire. TASK.json records this bounded next step and stop rule. + +## Workflow and credit + +Explicit user assignment following PR3952 and PR3963; canonical main +20ecf2891d80b5acf18d980b2164fb44ea7faa90, priority6. The investigation is coordinated +at https://github.com/CrocSwap/integer-mult-bounds/pull/3963#issuecomment-6262031944. +Live targeted PR search and the repository overlap helper have bounded coverage; +missing gh prevents a full remote snapshot. PR3339 already reports the136-H1 +nine-word count and missing idle-credit problem; the new contribution is the +actual hosted cut/family incidence and resulting source-rate budget distinction. + +Credit Nick Petalas/PR3339; Ali Romman and the retained QQ16/source lineage; +ywz65/PR2512/2707; Arham Tahir/PR2681; the gauge44,T16,frontier1042 supplier and +owner/coverage lineage; and Clear1nsight PR3952/3963. Exact source pins and reuse +are in PREDECESSORS. New work Chris R / Clear1nsight with substantial OpenAI +assistance as a separately assigned parallel agent. Apache-2.0; frozen sources, +selected frontier and predecessor notices unchanged. AI cross-review is distinct +from human or formal verification. diff --git a/research/qq16-consumer-incidence/RESULT.json b/research/qq16-consumer-incidence/RESULT.json new file mode 100644 index 0000000000..aaf829118d --- /dev/null +++ b/research/qq16-consumer-incidence/RESULT.json @@ -0,0 +1,2199 @@ +{ + "canonical_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "complete_producer_profile_144": { + "1": 349504, + "2": 60192, + "3": 62208, + "4": 20448, + "5": 11808 + }, + "conditional_screens": { + "family_count_assumed": 14336, + "module_invocations_per_proposal": 16, + "native_module_parameter_cases": { + "0": { + "decision": "strict_pass", + "lower": "0.999943992005135229", + "upper": "0.999943992005135230" + }, + "112": { + "decision": "strict_pass", + "lower": "0.999955316227494515", + "upper": "0.999955316227494516" + }, + "208": { + "decision": "strict_pass", + "lower": "0.999965022703802474", + "upper": "0.999965022703802475" + }, + "224": { + "decision": "strict_pass", + "lower": "0.999966640449853800", + "upper": "0.999966640449853801" + }, + "304": { + "decision": "strict_pass", + "lower": "0.999974729180110433", + "upper": "0.999974729180110434" + }, + "336": { + "decision": "strict_pass", + "lower": "0.999977964672213086", + "upper": "0.999977964672213087" + }, + "553": { + "decision": "strict_pass", + "lower": "0.999999905353034202", + "upper": "0.999999905353034203" + }, + "554": { + "decision": "strict_fail", + "lower": "1.000000006462162410", + "upper": "1.000000006462162411" + } + }, + "paired336_reference": { + "decision": "strict_fail", + "lower": "1.000097677880011248", + "upper": "1.000097677880011249" + }, + "scope": "All screens conditionally retain W=896/9,centre64 and ideal rank51 idle completion. Source cut counts are exact; a consumer, coverage, displaced remainder map and physical completion are not supplied.208/224/304 are parameter values, not certified sibling candidates.", + "selected_a": "836330098538459/499163669901461541", + "strict_integer_native_H1_cap_per_stage1_module": 553, + "total_mass_assumed": 1041408 + }, + "decision": "The proposed once-per-stage1-cut placement has16sites/144calls, not72/144. It is not an actual admitted consumer schedule: selected provider and downstream read/type binding are missing. One-stage1-module full336 budget passes the conditional fixed-coverage relaxation; the older pair-rate rejection does not transport. No displaced idle credit or productive family extension is proved.", + "producer_mean_H1": "21844/9", + "producer_stage_profiles": [ + { + "added_H1": 8, + "case": "F_0", + "orientation": "forward", + "outside_core_events": { + "native_line": 8, + "retained_core": 1, + "scalar": 936 + }, + "pair": 0, + "profile": { + "1": 2420, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 0 + }, + { + "added_H1": 24, + "case": "B_1_2", + "orientation": "backward", + "outside_core_events": { + "cover_map": 528, + "native_line": 24, + "retained_core": 1, + "scalar": 1312 + }, + "pair": 0, + "profile": { + "1": 2436, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 1 + }, + { + "added_H1": 8, + "case": "F_2", + "orientation": "forward", + "outside_core_events": { + "cover_map": 288, + "native_line": 8, + "retained_core": 1, + "scalar": 936 + }, + "pair": 0, + "profile": { + "1": 2420, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 2 + }, + { + "added_H1": 24, + "case": "B_3_4", + "orientation": "backward", + "outside_core_events": { + "cover_map": 528, + "native_line": 24, + "retained_core": 1, + "scalar": 1312 + }, + "pair": 1, + "profile": { + "1": 2436, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 3 + }, + { + "added_H1": 8, + "case": "F_4", + "orientation": "forward", + "outside_core_events": { + "cover_map": 288, + "native_line": 8, + "retained_core": 1, + "scalar": 936 + }, + "pair": 1, + "profile": { + "1": 2420, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 4 + }, + { + "added_H1": 24, + "case": "B_5_6", + "orientation": "backward", + "outside_core_events": { + "cover_map": 528, + "native_line": 24, + "retained_core": 1, + "scalar": 1312 + }, + "pair": 2, + "profile": { + "1": 2436, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 5 + }, + { + "added_H1": 8, + "case": "F_6", + "orientation": "forward", + "outside_core_events": { + "cover_map": 288, + "native_line": 8, + "retained_core": 1, + "scalar": 936 + }, + "pair": 2, + "profile": { + "1": 2420, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 6 + }, + { + "added_H1": 24, + "case": "B_7_8", + "orientation": "backward", + "outside_core_events": { + "cover_map": 528, + "native_line": 24, + "retained_core": 1, + "scalar": 1312 + }, + "pair": 3, + "profile": { + "1": 2436, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 7 + }, + { + "added_H1": 8, + "case": "F_8", + "orientation": "forward", + "outside_core_events": { + "cover_map": 288, + "native_line": 8, + "retained_core": 1, + "scalar": 936 + }, + "pair": 3, + "profile": { + "1": 2420, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "stage": 8 + } + ], + "projection_invoice": { + "16_site_total": { + "H1": 1792, + "maps": 3328, + "native_wrappers": 3584, + "scalar_allowance": 150016 + }, + "owned_output_fields_per_site": 96, + "owned_temporary_fields_per_site": 16, + "per_invocation": { + "CLEAR": 144, + "H1": 112, + "maps": 208, + "native_wrappers": 224, + "quarter_ADD": 384, + "scalar_allowance": 9376, + "unit_ADD": 560 + }, + "private_scratch_per_site": 8, + "productive_extension_control": { + "first_event_index": 3, + "initial_dirt_erased": true, + "interpretation": "Appending these output slots does not satisfy the selected arbitrary productive-input family contract; a different zero-input supplier theorem would need new coverage.", + "owned_dirt_basis_field": "W1" + } + }, + "schedule_ledger": { + "actual_live_families": 14336, + "actual_physical_families": 14826, + "all_backward_sites": 64, + "first_missing_provider_event": { + "proposed_case": "F_0", + "provider": "gauge44", + "schedule_index": 0 + }, + "literal_projection_invocations": 0, + "physical_event_counts": { + "bank_padding_cover_sweep": 1, + "bridge": 144, + "idle_cover_sweep": 160, + "local_cover_sweep": 144, + "terminal": 16, + "terminal_Y_translations": 16, + "translate_every_live_family": 1 + }, + "productive_families_per_replica": 896, + "retention_sensitivities": { + "until_next_F2": { + "capture_instances": 16, + "output_bank_instances": 1536, + "peak_retained_output_fields": 384, + "scope": "hypothetical logical retention only; no allocation/hosting or consumer admitted" + }, + "until_replica_terminal": { + "capture_instances": 16, + "output_bank_instances": 1536, + "peak_retained_output_fields": 1536, + "scope": "hypothetical logical retention only; no allocation/hosting or consumer admitted" + } + }, + "source_aligned_site_rate": "1/9", + "stage1_insertion_sites": [ + { + "after_schedule_index": 4, + "borrowed_Y_family_interval": [ + 112, + 224 + ], + "call_time": 4, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 18, + "next_bridge_Ydst_ordinary_families": [ + 113, + 114, + 115, + 116, + 117, + 118, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 134, + 135, + 136, + 137, + 138, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 189, + 190, + 191, + 192, + 194, + 195, + 196, + 197, + 198, + 200, + 201, + 202, + 203, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221 + ], + "next_bridge_index": 6, + "next_idle_index": 5, + "replica": 0, + "terminal_index": 233 + }, + { + "after_schedule_index": 7, + "borrowed_Y_family_interval": [ + 7280, + 7392 + ], + "call_time": 5, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 21, + "next_bridge_Ydst_ordinary_families": [ + 7281, + 7282, + 7283, + 7284, + 7285, + 7286, + 7288, + 7289, + 7290, + 7291, + 7292, + 7293, + 7294, + 7295, + 7296, + 7297, + 7298, + 7299, + 7302, + 7303, + 7304, + 7305, + 7306, + 7308, + 7309, + 7310, + 7311, + 7312, + 7313, + 7314, + 7315, + 7318, + 7319, + 7320, + 7321, + 7322, + 7323, + 7324, + 7325, + 7328, + 7329, + 7330, + 7331, + 7332, + 7333, + 7334, + 7335, + 7336, + 7338, + 7339, + 7340, + 7341, + 7342, + 7343, + 7344, + 7345, + 7346, + 7347, + 7348, + 7349, + 7350, + 7351, + 7352, + 7353, + 7354, + 7355, + 7357, + 7358, + 7359, + 7360, + 7362, + 7363, + 7364, + 7365, + 7366, + 7368, + 7369, + 7370, + 7371, + 7373, + 7374, + 7375, + 7376, + 7377, + 7378, + 7379, + 7380, + 7381, + 7382, + 7383, + 7384, + 7385, + 7386, + 7387, + 7388, + 7389 + ], + "next_bridge_index": 9, + "next_idle_index": 8, + "replica": 8, + "terminal_index": 243 + }, + { + "after_schedule_index": 12, + "borrowed_Y_family_interval": [ + 1008, + 1120 + ], + "call_time": 8, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 32, + "next_bridge_Ydst_ordinary_families": [ + 1009, + 1010, + 1011, + 1012, + 1013, + 1014, + 1016, + 1017, + 1018, + 1019, + 1020, + 1021, + 1022, + 1023, + 1024, + 1025, + 1026, + 1027, + 1030, + 1031, + 1032, + 1033, + 1034, + 1036, + 1037, + 1038, + 1039, + 1040, + 1041, + 1042, + 1043, + 1046, + 1047, + 1048, + 1049, + 1050, + 1051, + 1052, + 1053, + 1056, + 1057, + 1058, + 1059, + 1060, + 1061, + 1062, + 1063, + 1064, + 1066, + 1067, + 1068, + 1069, + 1070, + 1071, + 1072, + 1073, + 1074, + 1075, + 1076, + 1077, + 1078, + 1079, + 1080, + 1081, + 1082, + 1083, + 1085, + 1086, + 1087, + 1088, + 1090, + 1091, + 1092, + 1093, + 1094, + 1096, + 1097, + 1098, + 1099, + 1101, + 1102, + 1103, + 1104, + 1105, + 1106, + 1107, + 1108, + 1109, + 1110, + 1111, + 1112, + 1113, + 1114, + 1115, + 1116, + 1117 + ], + "next_bridge_index": 14, + "next_idle_index": 13, + "replica": 1, + "terminal_index": 279 + }, + { + "after_schedule_index": 15, + "borrowed_Y_family_interval": [ + 8176, + 8288 + ], + "call_time": 9, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 35, + "next_bridge_Ydst_ordinary_families": [ + 8177, + 8178, + 8179, + 8180, + 8181, + 8182, + 8184, + 8185, + 8186, + 8187, + 8188, + 8189, + 8190, + 8191, + 8192, + 8193, + 8194, + 8195, + 8198, + 8199, + 8200, + 8201, + 8202, + 8204, + 8205, + 8206, + 8207, + 8208, + 8209, + 8210, + 8211, + 8214, + 8215, + 8216, + 8217, + 8218, + 8219, + 8220, + 8221, + 8224, + 8225, + 8226, + 8227, + 8228, + 8229, + 8230, + 8231, + 8232, + 8234, + 8235, + 8236, + 8237, + 8238, + 8239, + 8240, + 8241, + 8242, + 8243, + 8244, + 8245, + 8246, + 8247, + 8248, + 8249, + 8250, + 8251, + 8253, + 8254, + 8255, + 8256, + 8258, + 8259, + 8260, + 8261, + 8262, + 8264, + 8265, + 8266, + 8267, + 8269, + 8270, + 8271, + 8272, + 8273, + 8274, + 8275, + 8276, + 8277, + 8278, + 8279, + 8280, + 8281, + 8282, + 8283, + 8284, + 8285 + ], + "next_bridge_index": 17, + "next_idle_index": 16, + "replica": 9, + "terminal_index": 289 + }, + { + "after_schedule_index": 26, + "borrowed_Y_family_interval": [ + 1904, + 2016 + ], + "call_time": 14, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 52, + "next_bridge_Ydst_ordinary_families": [ + 1905, + 1906, + 1907, + 1908, + 1909, + 1910, + 1912, + 1913, + 1914, + 1915, + 1916, + 1917, + 1918, + 1919, + 1920, + 1921, + 1922, + 1923, + 1926, + 1927, + 1928, + 1929, + 1930, + 1932, + 1933, + 1934, + 1935, + 1936, + 1937, + 1938, + 1939, + 1942, + 1943, + 1944, + 1945, + 1946, + 1947, + 1948, + 1949, + 1952, + 1953, + 1954, + 1955, + 1956, + 1957, + 1958, + 1959, + 1960, + 1962, + 1963, + 1964, + 1965, + 1966, + 1967, + 1968, + 1969, + 1970, + 1971, + 1972, + 1973, + 1974, + 1975, + 1976, + 1977, + 1978, + 1979, + 1981, + 1982, + 1983, + 1984, + 1986, + 1987, + 1988, + 1989, + 1990, + 1992, + 1993, + 1994, + 1995, + 1997, + 1998, + 1999, + 2000, + 2001, + 2002, + 2003, + 2004, + 2005, + 2006, + 2007, + 2008, + 2009, + 2010, + 2011, + 2012, + 2013 + ], + "next_bridge_index": 28, + "next_idle_index": 27, + "replica": 2, + "terminal_index": 325 + }, + { + "after_schedule_index": 29, + "borrowed_Y_family_interval": [ + 9072, + 9184 + ], + "call_time": 15, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 55, + "next_bridge_Ydst_ordinary_families": [ + 9073, + 9074, + 9075, + 9076, + 9077, + 9078, + 9080, + 9081, + 9082, + 9083, + 9084, + 9085, + 9086, + 9087, + 9088, + 9089, + 9090, + 9091, + 9094, + 9095, + 9096, + 9097, + 9098, + 9100, + 9101, + 9102, + 9103, + 9104, + 9105, + 9106, + 9107, + 9110, + 9111, + 9112, + 9113, + 9114, + 9115, + 9116, + 9117, + 9120, + 9121, + 9122, + 9123, + 9124, + 9125, + 9126, + 9127, + 9128, + 9130, + 9131, + 9132, + 9133, + 9134, + 9135, + 9136, + 9137, + 9138, + 9139, + 9140, + 9141, + 9142, + 9143, + 9144, + 9145, + 9146, + 9147, + 9149, + 9150, + 9151, + 9152, + 9154, + 9155, + 9156, + 9157, + 9158, + 9160, + 9161, + 9162, + 9163, + 9165, + 9166, + 9167, + 9168, + 9169, + 9170, + 9171, + 9172, + 9173, + 9174, + 9175, + 9176, + 9177, + 9178, + 9179, + 9180, + 9181 + ], + "next_bridge_index": 31, + "next_idle_index": 30, + "replica": 10, + "terminal_index": 335 + }, + { + "after_schedule_index": 46, + "borrowed_Y_family_interval": [ + 2800, + 2912 + ], + "call_time": 22, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 78, + "next_bridge_Ydst_ordinary_families": [ + 2801, + 2802, + 2803, + 2804, + 2805, + 2806, + 2808, + 2809, + 2810, + 2811, + 2812, + 2813, + 2814, + 2815, + 2816, + 2817, + 2818, + 2819, + 2822, + 2823, + 2824, + 2825, + 2826, + 2828, + 2829, + 2830, + 2831, + 2832, + 2833, + 2834, + 2835, + 2838, + 2839, + 2840, + 2841, + 2842, + 2843, + 2844, + 2845, + 2848, + 2849, + 2850, + 2851, + 2852, + 2853, + 2854, + 2855, + 2856, + 2858, + 2859, + 2860, + 2861, + 2862, + 2863, + 2864, + 2865, + 2866, + 2867, + 2868, + 2869, + 2870, + 2871, + 2872, + 2873, + 2874, + 2875, + 2877, + 2878, + 2879, + 2880, + 2882, + 2883, + 2884, + 2885, + 2886, + 2888, + 2889, + 2890, + 2891, + 2893, + 2894, + 2895, + 2896, + 2897, + 2898, + 2899, + 2900, + 2901, + 2902, + 2903, + 2904, + 2905, + 2906, + 2907, + 2908, + 2909 + ], + "next_bridge_index": 48, + "next_idle_index": 47, + "replica": 3, + "terminal_index": 365 + }, + { + "after_schedule_index": 49, + "borrowed_Y_family_interval": [ + 9968, + 10080 + ], + "call_time": 23, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 81, + "next_bridge_Ydst_ordinary_families": [ + 9969, + 9970, + 9971, + 9972, + 9973, + 9974, + 9976, + 9977, + 9978, + 9979, + 9980, + 9981, + 9982, + 9983, + 9984, + 9985, + 9986, + 9987, + 9990, + 9991, + 9992, + 9993, + 9994, + 9996, + 9997, + 9998, + 9999, + 10000, + 10001, + 10002, + 10003, + 10006, + 10007, + 10008, + 10009, + 10010, + 10011, + 10012, + 10013, + 10016, + 10017, + 10018, + 10019, + 10020, + 10021, + 10022, + 10023, + 10024, + 10026, + 10027, + 10028, + 10029, + 10030, + 10031, + 10032, + 10033, + 10034, + 10035, + 10036, + 10037, + 10038, + 10039, + 10040, + 10041, + 10042, + 10043, + 10045, + 10046, + 10047, + 10048, + 10050, + 10051, + 10052, + 10053, + 10054, + 10056, + 10057, + 10058, + 10059, + 10061, + 10062, + 10063, + 10064, + 10065, + 10066, + 10067, + 10068, + 10069, + 10070, + 10071, + 10072, + 10073, + 10074, + 10075, + 10076, + 10077 + ], + "next_bridge_index": 51, + "next_idle_index": 50, + "replica": 11, + "terminal_index": 375 + }, + { + "after_schedule_index": 72, + "borrowed_Y_family_interval": [ + 3696, + 3808 + ], + "call_time": 32, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 110, + "next_bridge_Ydst_ordinary_families": [ + 3697, + 3698, + 3699, + 3700, + 3701, + 3702, + 3704, + 3705, + 3706, + 3707, + 3708, + 3709, + 3710, + 3711, + 3712, + 3713, + 3714, + 3715, + 3718, + 3719, + 3720, + 3721, + 3722, + 3724, + 3725, + 3726, + 3727, + 3728, + 3729, + 3730, + 3731, + 3734, + 3735, + 3736, + 3737, + 3738, + 3739, + 3740, + 3741, + 3744, + 3745, + 3746, + 3747, + 3748, + 3749, + 3750, + 3751, + 3752, + 3754, + 3755, + 3756, + 3757, + 3758, + 3759, + 3760, + 3761, + 3762, + 3763, + 3764, + 3765, + 3766, + 3767, + 3768, + 3769, + 3770, + 3771, + 3773, + 3774, + 3775, + 3776, + 3778, + 3779, + 3780, + 3781, + 3782, + 3784, + 3785, + 3786, + 3787, + 3789, + 3790, + 3791, + 3792, + 3793, + 3794, + 3795, + 3796, + 3797, + 3798, + 3799, + 3800, + 3801, + 3802, + 3803, + 3804, + 3805 + ], + "next_bridge_index": 74, + "next_idle_index": 73, + "replica": 4, + "terminal_index": 399 + }, + { + "after_schedule_index": 75, + "borrowed_Y_family_interval": [ + 10864, + 10976 + ], + "call_time": 33, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 113, + "next_bridge_Ydst_ordinary_families": [ + 10865, + 10866, + 10867, + 10868, + 10869, + 10870, + 10872, + 10873, + 10874, + 10875, + 10876, + 10877, + 10878, + 10879, + 10880, + 10881, + 10882, + 10883, + 10886, + 10887, + 10888, + 10889, + 10890, + 10892, + 10893, + 10894, + 10895, + 10896, + 10897, + 10898, + 10899, + 10902, + 10903, + 10904, + 10905, + 10906, + 10907, + 10908, + 10909, + 10912, + 10913, + 10914, + 10915, + 10916, + 10917, + 10918, + 10919, + 10920, + 10922, + 10923, + 10924, + 10925, + 10926, + 10927, + 10928, + 10929, + 10930, + 10931, + 10932, + 10933, + 10934, + 10935, + 10936, + 10937, + 10938, + 10939, + 10941, + 10942, + 10943, + 10944, + 10946, + 10947, + 10948, + 10949, + 10950, + 10952, + 10953, + 10954, + 10955, + 10957, + 10958, + 10959, + 10960, + 10961, + 10962, + 10963, + 10964, + 10965, + 10966, + 10967, + 10968, + 10969, + 10970, + 10971, + 10972, + 10973 + ], + "next_bridge_index": 77, + "next_idle_index": 76, + "replica": 12, + "terminal_index": 409 + }, + { + "after_schedule_index": 104, + "borrowed_Y_family_interval": [ + 4592, + 4704 + ], + "call_time": 44, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 148, + "next_bridge_Ydst_ordinary_families": [ + 4593, + 4594, + 4595, + 4596, + 4597, + 4598, + 4600, + 4601, + 4602, + 4603, + 4604, + 4605, + 4606, + 4607, + 4608, + 4609, + 4610, + 4611, + 4614, + 4615, + 4616, + 4617, + 4618, + 4620, + 4621, + 4622, + 4623, + 4624, + 4625, + 4626, + 4627, + 4630, + 4631, + 4632, + 4633, + 4634, + 4635, + 4636, + 4637, + 4640, + 4641, + 4642, + 4643, + 4644, + 4645, + 4646, + 4647, + 4648, + 4650, + 4651, + 4652, + 4653, + 4654, + 4655, + 4656, + 4657, + 4658, + 4659, + 4660, + 4661, + 4662, + 4663, + 4664, + 4665, + 4666, + 4667, + 4669, + 4670, + 4671, + 4672, + 4674, + 4675, + 4676, + 4677, + 4678, + 4680, + 4681, + 4682, + 4683, + 4685, + 4686, + 4687, + 4688, + 4689, + 4690, + 4691, + 4692, + 4693, + 4694, + 4695, + 4696, + 4697, + 4698, + 4699, + 4700, + 4701 + ], + "next_bridge_index": 106, + "next_idle_index": 105, + "replica": 5, + "terminal_index": 427 + }, + { + "after_schedule_index": 107, + "borrowed_Y_family_interval": [ + 11760, + 11872 + ], + "call_time": 45, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 151, + "next_bridge_Ydst_ordinary_families": [ + 11761, + 11762, + 11763, + 11764, + 11765, + 11766, + 11768, + 11769, + 11770, + 11771, + 11772, + 11773, + 11774, + 11775, + 11776, + 11777, + 11778, + 11779, + 11782, + 11783, + 11784, + 11785, + 11786, + 11788, + 11789, + 11790, + 11791, + 11792, + 11793, + 11794, + 11795, + 11798, + 11799, + 11800, + 11801, + 11802, + 11803, + 11804, + 11805, + 11808, + 11809, + 11810, + 11811, + 11812, + 11813, + 11814, + 11815, + 11816, + 11818, + 11819, + 11820, + 11821, + 11822, + 11823, + 11824, + 11825, + 11826, + 11827, + 11828, + 11829, + 11830, + 11831, + 11832, + 11833, + 11834, + 11835, + 11837, + 11838, + 11839, + 11840, + 11842, + 11843, + 11844, + 11845, + 11846, + 11848, + 11849, + 11850, + 11851, + 11853, + 11854, + 11855, + 11856, + 11857, + 11858, + 11859, + 11860, + 11861, + 11862, + 11863, + 11864, + 11865, + 11866, + 11867, + 11868, + 11869 + ], + "next_bridge_index": 109, + "next_idle_index": 108, + "replica": 13, + "terminal_index": 437 + }, + { + "after_schedule_index": 142, + "borrowed_Y_family_interval": [ + 5488, + 5600 + ], + "call_time": 58, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 186, + "next_bridge_Ydst_ordinary_families": [ + 5489, + 5490, + 5491, + 5492, + 5493, + 5494, + 5496, + 5497, + 5498, + 5499, + 5500, + 5501, + 5502, + 5503, + 5504, + 5505, + 5506, + 5507, + 5510, + 5511, + 5512, + 5513, + 5514, + 5516, + 5517, + 5518, + 5519, + 5520, + 5521, + 5522, + 5523, + 5526, + 5527, + 5528, + 5529, + 5530, + 5531, + 5532, + 5533, + 5536, + 5537, + 5538, + 5539, + 5540, + 5541, + 5542, + 5543, + 5544, + 5546, + 5547, + 5548, + 5549, + 5550, + 5551, + 5552, + 5553, + 5554, + 5555, + 5556, + 5557, + 5558, + 5559, + 5560, + 5561, + 5562, + 5563, + 5565, + 5566, + 5567, + 5568, + 5570, + 5571, + 5572, + 5573, + 5574, + 5576, + 5577, + 5578, + 5579, + 5581, + 5582, + 5583, + 5584, + 5585, + 5586, + 5587, + 5588, + 5589, + 5590, + 5591, + 5592, + 5593, + 5594, + 5595, + 5596, + 5597 + ], + "next_bridge_index": 144, + "next_idle_index": 143, + "replica": 6, + "terminal_index": 449 + }, + { + "after_schedule_index": 145, + "borrowed_Y_family_interval": [ + 12656, + 12768 + ], + "call_time": 59, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 189, + "next_bridge_Ydst_ordinary_families": [ + 12657, + 12658, + 12659, + 12660, + 12661, + 12662, + 12664, + 12665, + 12666, + 12667, + 12668, + 12669, + 12670, + 12671, + 12672, + 12673, + 12674, + 12675, + 12678, + 12679, + 12680, + 12681, + 12682, + 12684, + 12685, + 12686, + 12687, + 12688, + 12689, + 12690, + 12691, + 12694, + 12695, + 12696, + 12697, + 12698, + 12699, + 12700, + 12701, + 12704, + 12705, + 12706, + 12707, + 12708, + 12709, + 12710, + 12711, + 12712, + 12714, + 12715, + 12716, + 12717, + 12718, + 12719, + 12720, + 12721, + 12722, + 12723, + 12724, + 12725, + 12726, + 12727, + 12728, + 12729, + 12730, + 12731, + 12733, + 12734, + 12735, + 12736, + 12738, + 12739, + 12740, + 12741, + 12742, + 12744, + 12745, + 12746, + 12747, + 12749, + 12750, + 12751, + 12752, + 12753, + 12754, + 12755, + 12756, + 12757, + 12758, + 12759, + 12760, + 12761, + 12762, + 12763, + 12764, + 12765 + ], + "next_bridge_index": 147, + "next_idle_index": 146, + "replica": 14, + "terminal_index": 459 + }, + { + "after_schedule_index": 178, + "borrowed_Y_family_interval": [ + 6384, + 6496 + ], + "call_time": 70, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 218, + "next_bridge_Ydst_ordinary_families": [ + 6385, + 6386, + 6387, + 6388, + 6389, + 6390, + 6392, + 6393, + 6394, + 6395, + 6396, + 6397, + 6398, + 6399, + 6400, + 6401, + 6402, + 6403, + 6406, + 6407, + 6408, + 6409, + 6410, + 6412, + 6413, + 6414, + 6415, + 6416, + 6417, + 6418, + 6419, + 6422, + 6423, + 6424, + 6425, + 6426, + 6427, + 6428, + 6429, + 6432, + 6433, + 6434, + 6435, + 6436, + 6437, + 6438, + 6439, + 6440, + 6442, + 6443, + 6444, + 6445, + 6446, + 6447, + 6448, + 6449, + 6450, + 6451, + 6452, + 6453, + 6454, + 6455, + 6456, + 6457, + 6458, + 6459, + 6461, + 6462, + 6463, + 6464, + 6466, + 6467, + 6468, + 6469, + 6470, + 6472, + 6473, + 6474, + 6475, + 6477, + 6478, + 6479, + 6480, + 6481, + 6482, + 6483, + 6484, + 6485, + 6486, + 6487, + 6488, + 6489, + 6490, + 6491, + 6492, + 6493 + ], + "next_bridge_index": 180, + "next_idle_index": 179, + "replica": 7, + "terminal_index": 469 + }, + { + "after_schedule_index": 181, + "borrowed_Y_family_interval": [ + 13552, + 13664 + ], + "call_time": 71, + "literal_projected_output_consumer": null, + "missing_binding": "provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank", + "next_F2_index": 221, + "next_bridge_Ydst_ordinary_families": [ + 13553, + 13554, + 13555, + 13556, + 13557, + 13558, + 13560, + 13561, + 13562, + 13563, + 13564, + 13565, + 13566, + 13567, + 13568, + 13569, + 13570, + 13571, + 13574, + 13575, + 13576, + 13577, + 13578, + 13580, + 13581, + 13582, + 13583, + 13584, + 13585, + 13586, + 13587, + 13590, + 13591, + 13592, + 13593, + 13594, + 13595, + 13596, + 13597, + 13600, + 13601, + 13602, + 13603, + 13604, + 13605, + 13606, + 13607, + 13608, + 13610, + 13611, + 13612, + 13613, + 13614, + 13615, + 13616, + 13617, + 13618, + 13619, + 13620, + 13621, + 13622, + 13623, + 13624, + 13625, + 13626, + 13627, + 13629, + 13630, + 13631, + 13632, + 13634, + 13635, + 13636, + 13637, + 13638, + 13640, + 13641, + 13642, + 13643, + 13645, + 13646, + 13647, + 13648, + 13649, + 13650, + 13651, + 13652, + 13653, + 13654, + 13655, + 13656, + 13657, + 13658, + 13659, + 13660, + 13661 + ], + "next_bridge_index": 183, + "next_idle_index": 182, + "replica": 15, + "terminal_index": 479 + } + ], + "stages": [ + { + "case_under_QQ16_substitution": "F_0", + "completed_window_dimension": 9, + "count": 16, + "pair": 0, + "source_provider": "gauge44", + "stage": 0 + }, + { + "case_under_QQ16_substitution": "B_1_2", + "completed_window_dimension": 17, + "count": 16, + "pair": 0, + "source_provider": "gauge44", + "stage": 1 + }, + { + "case_under_QQ16_substitution": "F_2", + "completed_window_dimension": 25, + "count": 16, + "pair": 0, + "source_provider": "gauge44", + "stage": 2 + }, + { + "case_under_QQ16_substitution": "B_3_4", + "completed_window_dimension": 33, + "count": 16, + "pair": 1, + "source_provider": "gauge44", + "stage": 3 + }, + { + "case_under_QQ16_substitution": "F_4", + "completed_window_dimension": 41, + "count": 16, + "pair": 1, + "source_provider": "gauge44", + "stage": 4 + }, + { + "case_under_QQ16_substitution": "B_5_6", + "completed_window_dimension": 49, + "count": 16, + "pair": 2, + "source_provider": "gauge44", + "stage": 5 + }, + { + "case_under_QQ16_substitution": "F_6", + "completed_window_dimension": 57, + "count": 16, + "pair": 2, + "source_provider": "gauge44", + "stage": 6 + }, + { + "case_under_QQ16_substitution": "B_7_8", + "completed_window_dimension": 65, + "count": 16, + "pair": 3, + "source_provider": "gauge44", + "stage": 7 + }, + { + "case_under_QQ16_substitution": "F_8", + "completed_window_dimension": 73, + "count": 16, + "pair": 3, + "source_provider": "gauge44", + "stage": 8 + } + ] + }, + "status": "PASS_QQ16_INTEGER_CONSUMER_INCIDENCE no_new_kappa", + "template_member": { + "path": "t16/global/hosted/GLOBAL-TEMPLATE.json.gz", + "sha256": "73f47a1e60b1e4ea66dbca9a497c411c8e6adc7984e276a437a10a9a7a13b47a" + } +} diff --git a/research/qq16-consumer-incidence/REVIEWS.json b/research/qq16-consumer-incidence/REVIEWS.json new file mode 100644 index 0000000000..26003dac75 --- /dev/null +++ b/research/qq16-consumer-incidence/REVIEWS.json @@ -0,0 +1,37 @@ +{ + "human_review": "not claimed", + "formal_review": "not claimed", + "independent_AI_reviews": [ + { + "reviewer": "separate full-recovery agent /root/retirement_schedule", + "result": "PASS no concrete blocker", + "scope": [ + "Optimized receipt replay", + "Independent16/144 re-enumeration", + "Retention peaks384/1536", + "136 additional H1 and21844/9 producer mean", + "Exact553/554 and pair336 contrast", + "Conditional coverage and dirty productive-input control" + ], + "reviewed_sha256": { + "verify.py": "8616c81f9e245e88df022a96b6fda8a878ead08fd2fc73a8bbc32360e8f00eb9", + "arithmetic.py": "6c8fee1f43554ae30aa5685bbe328757688199cceb6386880540d1dfe5d537c1", + "PROOF.md": "d86a86cb78219e6178fc86b6b5c14502836eb2ab88d1e898ec757a6fa9b46b7c", + "RESULT.json": "eab730f516cebba863c0182d71259393d9d70344c29c6d0ce8458632ec15d40d" + }, + "subsequent_changes": "PROOF adds explicit full execution_schedule index namespace; no reviewed checker, arithmetic or RESULT change." + }, + { + "reviewer": "coordinating root agent", + "result": "PASS no substantive blocker", + "scope": "Source/provider/coverage scope, literal-versus-proposed incidence, exact arithmetic and predecessor distinction; requested explicit global index namespace was added." + } + ], + "current_scientific_sha256": { + "verify.py": "8616c81f9e245e88df022a96b6fda8a878ead08fd2fc73a8bbc32360e8f00eb9", + "arithmetic.py": "6c8fee1f43554ae30aa5685bbe328757688199cceb6386880540d1dfe5d537c1", + "PROOF.md": "9902b7349f2c5f27b0a537115aa5caa784a11c072775f3cb1eb6619d944dfb33", + "RESULT.json": "eab730f516cebba863c0182d71259393d9d70344c29c6d0ce8458632ec15d40d", + "test_verify.py": "bec476c6b690956f1e6232b32b2471ae8429158ea6021a3a3eacce9b16ea690e" + } +} diff --git a/research/qq16-consumer-incidence/SOURCES.json b/research/qq16-consumer-incidence/SOURCES.json new file mode 100644 index 0000000000..221d3161af --- /dev/null +++ b/research/qq16-consumer-incidence/SOURCES.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "docs/research/qq16-controller-scope-map.md", + "usage": "input", + "git_blob": "388ae2e82277f53a032eb555ffb53ff387f17c29", + "sha256": "9b6d42ff4acc044d8272a405839f0bbb1f42a61813da163e7a27f45b61e6ee8c" + }, + { + "path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b", + "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/qq16-current-frame-consumer/PROOF.md", + "usage": "input", + "git_blob": "37bce9925fc21e970af3d39b36cc899b4ceebfb5", + "sha256": "a485fdf7fd44abe1b9004a8502871ef24d7617809879d1a6550ffa425e1a79f7" + }, + { + "path": "research/qq16-separate-consumer-budget/README.md", + "usage": "input", + "git_blob": "ef0ca64a8a8f2ccd272bdb91c094a96d3084233f", + "sha256": "06bca43ecfa8e0d57e1866d084b9b23708506a8bedf6b598c4adb78df328ccec" + } + ] +} diff --git a/research/qq16-consumer-incidence/TASK.json b/research/qq16-consumer-incidence/TASK.json new file mode 100644 index 0000000000..969584bfdf --- /dev/null +++ b/research/qq16-consumer-incidence/TASK.json @@ -0,0 +1,79 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "joint-query-controller", + "question": "Can a literal QQ16 producer meet the proposed completed-output error budgets with dirty helpers and an affordable physical consumer?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/joint-query/README.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "docs/research/community-efficient1000-review.md", + "research/qq16-producer-defect-transfer/README.md" + ], + "methods": [ + "Derive one literal producer's completed-output defects and intermediate dirty-helper bounds, with its physical bill.", + "Design or audit one consumer, retention or hosting boundary and its complete cost for the pinned producer/decoder." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the revision-6 family record and #2965 producer-defect transfer after the local QQ16 decoder contract. Its author-checked output-error estimate does not implement producer interiors, bound dirty helpers, or pay for the consumer; independently check the implication used.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Pin one literal F0/B1 producer and its native-child contracts; derive the actual intermediate magnitude ledger and completed-output defects, including dirty helpers and correlations. Compare with #2965 budgets and price storage, movement, cleanup and F17 consumption. Stop with a precise missing bound if no producer contract supplies it; do not optimize another decoder precision constant in isolation.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer" + ] + }, + "scope_status": "refined", + "actual_scope": "Bind the frozen hosted 144-call schedule to proposed first-B1 consumer insertion sites and derive the conditional whole-nine-word budget at that integer incidence.", + "scope_change_reason": "Assigned continuation of PR3952/3963 consumer applicability; refine the broad controller card to the actual invocation, productive-family and downstream-read boundary. PR3339 already supplies the nine-word producer occurrence count.", + "bottleneck_link": "The pair-rate obstruction cannot be transferred to one stage1 insertion per replica; exact integer incidence and live-family ownership must precede a global consumer invoice.", + "budget_minutes": 60, + "stop_rule": "Stop at a complete source ledger and discriminating conditional screen, or a precise source binding failure. Do not construct an unpriced global supplier or run further local precision rounds.", + "outcome": "completed", + "evidence": "PROOF.md, complete typed RESULT.json, source-bound verify.py, exact arithmetic.py and test_verify.py establish 16 proposed sites/144 calls, zero actual projection invocations, the 136-H1 nine-word profile, conditional 553/554 cap, and explicit unresolved provider/coverage/physical bindings.", + "author": "Chris R / Clear1nsight with substantial OpenAI assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for source inspection, derivation, implementation, adversarial tests, independent agent review and GitHub publication.", + "open_questions": [ + { + "question": "Can a specific paid QQ16 provider and continuation bind the stage1 demand to the frozen hosted schedule while preserving or rederiving productive-family coverage?", + "why_it_matters": "The conditional 336-H1 module passes at the actual proposed 1/9 insertion rate, so pair-rate failure does not close this route. An actual consumer and physical invoice are still absent.", + "first_step": "Replace or connect event0 gauge44 to a source-pinned QQ16 F0 provider, then exhibit the stage1 continuation read mapping and charge every retained output/helper through a named release event. Recompute the family and displaced-remainder ledger for that exact schedule.", + "blocked_by": "A provider/continuation contract and paid hosting construction, not the conditional native cap. No independent output count authorizes selected W or centre64." + } + ] +} diff --git a/research/qq16-consumer-incidence/VERIFICATION.json b/research/qq16-consumer-incidence/VERIFICATION.json new file mode 100644 index 0000000000..da39d824df --- /dev/null +++ b/research/qq16-consumer-incidence/VERIFICATION.json @@ -0,0 +1,37 @@ +{ + "status": "author_checked_and_independent_AI_cross_checked", + "utc": "2026-10-19T07:46:00Z", + "python": "3.12.3", + "canonical_main_checkpoint": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "checks": [ + { + "command": "python3 -I -Werror -B research/qq16-consumer-incidence/verify.py", + "result": "PASS complete typed RESULT" + }, + { + "command": "python3 -I -O -Werror -B research/qq16-consumer-incidence/verify.py", + "result": "PASS complete typed RESULT" + }, + { + "command": "python3 -I -O -Werror -B research/qq16-consumer-incidence/test_verify.py", + "result": "PASS 7 groups; normal and optimized minimal Git-free read-only export; source/retained/manifest/RESULT negative controls" + }, + { + "command": "python3 -B scripts/research_package.py --package research/qq16-consumer-incidence --check-only", + "result": "PASS_PACKAGE_METADATA_AND_PINS" + }, + { + "command": "python3 -B scripts/research_package.py --package research/qq16-consumer-incidence", + "result": "PASS_REGISTERED_RESEARCH_PACKAGE outcome=completed" + } + ], + "unrun": [ + "No complete selected-supplier cold replay", + "No physical QQ16 provider/consumer execution", + "No all-depth precision or dirty-range proof", + "No global family-coverage or displaced-idle certificate", + "No new kappa or frontier change" + ], + "publication": "Final commit-byte/source-history preflight is reported externally in the PR, avoiding a self-referential committed head." +} diff --git a/research/qq16-consumer-incidence/VERIFY.json b/research/qq16-consumer-incidence/VERIFY.json new file mode 100644 index 0000000000..6a5967dce2 --- /dev/null +++ b/research/qq16-consumer-incidence/VERIFY.json @@ -0,0 +1,40 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/qq16-controller-scope-map.md", + "research/community-frontier1042-audit/selected-replay.tar.gz", + "research/complex-local-word-ceiling/RESULT.json", + "research/joint-query/certificate.json.gz", + "research/qq16-current-frame-consumer/PROOF.md", + "research/qq16-separate-consumer-budget/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-Werror", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Pinned canonical/retained data, all144 source invocations,16 proposed cuts, ownership/readsets, lifetimes, local invoices and complete typed rational RESULT." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-Werror", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 180, + "checks": "Seven groups of provider, incidence, frame, ownership, native-rank, centre-credit, dirty-input, typed-result, source-hash and integer-cap controls; normal and optimized Git-free read-only replay." + } + ] +} diff --git a/research/qq16-consumer-incidence/arithmetic.py b/research/qq16-consumer-incidence/arithmetic.py new file mode 100644 index 0000000000..3771a14c73 --- /dev/null +++ b/research/qq16-consumer-incidence/arithmetic.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python3 +"""Exact arithmetic adapted from Clear1nsight PR3963, independently derived +atanh-series implementation. No predecessor module imported. Apache-2.0. +""" +from fractions import Fraction as F +from functools import lru_cache +M=73 +def require(ok,msg): + if not ok:raise ValueError(msg) + +@lru_cache(None) +def log_unit(x, n=40): + """ln x from the positive atanh series, with an exact geometric remainder.""" + require(1 <= x <= 2, 'failed: 1 <= x <= 2') + z=(x-1)/(x+1) + s=sum((2*z**(2*k+1)/F(2*k+1) for k in range(n)),F(0)) + tail=2*z**(2*n+1)/(F(2*n+1)*(1-z*z)) + return s,s+tail + +@lru_cache(None) +def logarithm(x): + require(x >= 1, 'failed: x >= 1') + k=0 + while x>2: + x/=2; k+=1 + lo,hi=log_unit(x) + a,b=log_unit(F(2)) + return lo+k*a,hi+k*b + +def exp_interval(lo,hi,n=14): + require(0<=lo<=hi=0,'nonnegative idle mass');require(2*51**2<73**2<2*52**2,'idle cap') + lo=sum(n*child(r,a)[0] for r,n in profile.items())+F(idle,51)*child(51,a)[0] + hi=sum(n*child(r,a)[1] for r,n in profile.items())+F(idle,51)*child(51,a)[1] + return lo/live,hi/live + +def view(bounds): + lo,hi=bounds;s=10**18 + l=lo.numerator*s//lo.denominator;u=-((-hi.numerator*s)//hi.denominator) + return {'lower':f'{l//s}.{l%s:018d}','upper':f'{u//s}.{u%s:018d}', + 'decision':'strict_pass' if hi<1 else 'strict_fail' if lo>1 else 'undecided'} + +def screens(producer,a,calls,live,sites): + require((calls,live,sites)==(144,14336,16),'source-bound global incidence') + total=72*live+64*calls + def at(d): + p=dict(producer);p[1]+=sites*d + return enclosing(p,a,live,total) + cases={str(d):view(at(d)) for d in [0,112,208,224,304,336,553,554]} + require(at(553)[1]<11 and at(336)[1]<1,'pair-rate failure must not transport') + return {'selected_a':str(a),'family_count_assumed':live,'total_mass_assumed':total, + 'module_invocations_per_proposal':sites,'native_module_parameter_cases':cases, + 'strict_integer_native_H1_cap_per_stage1_module':553, + 'paired336_reference':view(pair_bounds), + 'scope':'All screens conditionally retain W=896/9,centre64 and ideal rank51 idle completion. Source cut counts are exact; a consumer, coverage, displaced remainder map and physical completion are not supplied.208/224/304 are parameter values, not certified sibling candidates.'} diff --git a/research/qq16-consumer-incidence/test_verify.py b/research/qq16-consumer-incidence/test_verify.py new file mode 100644 index 0000000000..a95d8ad1e6 --- /dev/null +++ b/research/qq16-consumer-incidence/test_verify.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +"""Independent failure controls and minimal Git-free, read-only replay.""" +from pathlib import Path +import copy,gzip,hashlib,json,os,shutil,subprocess,sys,tempfile,types,unittest +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +def module(path): + m=types.ModuleType(path.stem);m.__file__=str(path) + exec(compile(path.read_bytes(),str(path),'exec'),m.__dict__) + return m +V=module(HERE/'verify.py') +class Controls(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.data=V.sources() + cls.template=V.load_template(cls.data['research/community-frontier1042-audit/selected-replay.tar.gz']) + cls.packet=V.parse(gzip.decompress(cls.data['research/joint-query/certificate.json.gz'])) + cls.word=V.parse((HERE/'vendor/pr3952/WORD.json').read_bytes()) + def test_source_provider_and_duplicate_cut(self): + t=copy.deepcopy(self.template);t['calls'][0]['provider_id']='QQ16' + with self.assertRaisesRegex(ValueError,'provider'):V.schedule(t,self.packet) + t=copy.deepcopy(self.template);t['calls'][1]=copy.deepcopy(t['calls'][0]) + t['async_schedule']['order'][1]=t['async_schedule']['order'][0] + with self.assertRaisesRegex(ValueError,'incidence'):V.schedule(t,self.packet) + def test_frame_and_family_identity(self): + t=copy.deepcopy(self.template) + next(c for c in t['calls'] if c['stage']==1)['window']['prefix_axes'].append(17) + with self.assertRaisesRegex(ValueError,'window'):V.schedule(t,self.packet) + t=copy.deepcopy(self.template);t['calls'][0]['owners'][0][0]=14336 + with self.assertRaisesRegex(ValueError,'family map'):V.schedule(t,self.packet) + def test_producer_rank_and_centre_credit(self): + p=copy.deepcopy(self.packet) + for recipe in p['native_line_recipes'].values():recipe['rank']=2 + with self.assertRaisesRegex(ValueError,'rank'):V.producer(p) + p=copy.deepcopy(self.packet);next(iter(p['core_words'].values())).append(['center']) + with self.assertRaisesRegex(ValueError,'centre'):V.producer(p) + def test_owned_dirt_may_not_be_read_before_clear(self): + word=[['add','F0','W0',1]]+copy.deepcopy(self.word) + with self.assertRaisesRegex(ValueError,'read before clear'):V.projection_invoice(word,self.packet['U_ports']) + def test_typed_result_and_duplicate_keys(self): + self.assertNotEqual(V.canonical({'count':1}),V.canonical({'count':True})) + self.assertNotEqual(V.canonical({'count':1}),V.canonical({'count':1.0})) + with self.assertRaises(ValueError):V.canonical({'n':float('nan')}) + with self.assertRaisesRegex(ValueError,'duplicate'):V.parse('{"count":1,"count":2}') + def test_wrong_incidence_and_sharp_integer_cap(self): + a=module(HERE/'arithmetic.py');result=V.parse((HERE/'RESULT.json').read_bytes()) + profile={int(k):v for k,v in result['complete_producer_profile_144'].items()} + target=a.F(result['conditional_screens']['selected_a']) + with self.assertRaisesRegex(ValueError,'incidence'):a.screens(profile,target,144,14336,72) + s=a.screens(profile,target,144,14336,16) + self.assertEqual(s['native_module_parameter_cases']['553']['decision'],'strict_pass') + self.assertEqual(s['native_module_parameter_cases']['554']['decision'],'strict_fail') + self.assertEqual(s['native_module_parameter_cases']['336']['decision'],'strict_pass') + self.assertEqual(s['paired336_reference']['decision'],'strict_fail') + def test_minimal_readonly_export_and_source_tampering(self): + with tempfile.TemporaryDirectory(prefix='qq16-incidence-') as tmp: + root=Path(tmp);dest=root/'research'/HERE.name + shutil.copytree(HERE,dest,ignore=shutil.ignore_patterns('__pycache__')) + for name,raw in self.data.items(): + p=root/name;p.parent.mkdir(parents=True,exist_ok=True);p.write_bytes(raw) + vm=module(dest/'verify.py') + pin=dest/'vendor/pr3952/WORD.json';raw=pin.read_bytes();pin.write_bytes(raw+b' ') + with self.assertRaisesRegex(ValueError,'retained source hash'):vm.sources() + pin.write_bytes(raw) + source=root/'certificates/selected-result.json';raw=source.read_bytes();source.write_bytes(raw+b' ') + with self.assertRaisesRegex(ValueError,'source hash'):vm.sources() + source.write_bytes(raw) + manifest=dest/'SOURCES.json';raw=manifest.read_bytes();manifest.write_bytes(raw+b' ') + with self.assertRaisesRegex(ValueError,'manifest binding'):vm.sources() + manifest.write_bytes(raw) + receipt=dest/'RESULT.json';raw=receipt.read_bytes();r=V.parse(raw) + r['schedule_ledger']['literal_projection_invocations']=False + receipt.write_text(json.dumps(r)) + p=subprocess.run([sys.executable,'-I','-O','-B',str(dest/'verify.py')],cwd=tmp,capture_output=True,text=True) + self.assertNotEqual(p.returncode,0);self.assertIn('complete typed RESULT mismatch',p.stderr) + receipt.write_bytes(raw) + before={str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} + try: + for p in root.rglob('*'):p.chmod(0o555 if p.is_dir() else 0o444) + root.chmod(0o555) + for flags in ([],['-O']): + p=subprocess.run([sys.executable,'-I',*flags,'-Werror','-B',str(dest/'verify.py')],cwd=tmp,capture_output=True,text=True) + self.assertEqual(p.returncode,0,p.stderr) + self.assertEqual(p.stdout.strip(),'PASS_QQ16_INTEGER_CONSUMER_INCIDENCE no_new_kappa') + after={str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} + self.assertEqual(before,after);self.assertFalse((root/'.git').exists()) + finally: + root.chmod(0o755) + for p in root.rglob('*'):p.chmod(0o755 if p.is_dir() else 0o644) +if __name__=='__main__':unittest.main(verbosity=2) diff --git a/research/qq16-consumer-incidence/vendor/pr3952/PROOF.md b/research/qq16-consumer-incidence/vendor/pr3952/PROOF.md new file mode 100644 index 0000000000..97c66df9a9 --- /dev/null +++ b/research/qq16-consumer-incidence/vendor/pr3952/PROOF.md @@ -0,0 +1,216 @@ +# A projected F17 demand and its fixed-profile obstruction + +This is an exact local interface result under the retained QQ16 common-label +cover contract. It is not a global controller, physical supplier, optimal +consumer, or new multiplication bound. + +## 1. An actual demand, and the change of inputs + +PR2512 (`851dd3486a2d0549b51e85978a65ccb4eec619c0`, ywz65) explicitly +ends with 96 consumer subtractions `Z_p -= X2_p`, ordinary ports p in U_ports, +returning logical `y1_U` in `F_U1`. Its proof defines this frame as the product +of C lines on coordinate axes 0 through 16, exactly PR2707's **F17**. The port +set U_ports and the 17-dimensional coordinate subspace are distinct objects. +The verifier authenticates the actual proof, full word and receipt, and checks +the literal 96-event consumer epilogue and its named output contract. + +PR2512 reads 96 current X, 96 current Y and eight retained earlier T arrays. +Here the demand is supplied instead from **all 112 current Y arrays**, with no +X read or early T record. The extra sixteen selected current Y reads are +available under PR2707's 224-current-field contract; they are not available +merely by assuming PR2512's narrower interface. Every Y is borrowed, physically +in `F17 C_qp^-1`. The result needs 96 exclusively owned output arrays and sixteen +owned full-cover temporaries. Arbitrary owned dirt is erased by paid CLEARs. +No borrowed source is written. All sixteen temporaries and eight private scratch +arrays finish at zero in identity frame. There is no storage/hosting admission. + +This pins a real published *local endpoint*, rather than inventing an ordinary +frame tariff. It does not establish that a complete selected outer controller +needs only these 96 values; other outputs may still be required there. + +## 2. The projected logical operator + +Use the actual ordered owner actions D_p in B1 and the pinned eight raw R rows. +Define the query and ordinary injection in the normalization used by PR2681: + + Q(Y)_k = sum_(p=0..111) R[k,p] D_p Y_p, + (K_U q)_p = (1/4) sum_k R[k,p] D_p^-1 q_k, p in U_ports. + +The retained complete B1 inverse first computes + + u_U = Y2_U - K_U Q(Y2). + +Its future-logger reversal writes only selected A ports. Therefore it leaves +u_U unchanged, and + + y1_U = Y2_U - K_U Q(Y2). (1) + +This also follows from the conserved B1 equations: `Q(Y2)` is the old selected +T query and `Y2_U = y1_U + K_U Q(Y2)`. The three conserved queries must not be +interchanged. The source proof gives the identity over the ordered cover +coefficient ring, so no owner matrices are silently commuted. + +The checker compares every demanded routed row of the new word with (1) on +112 independent current Y symbols: 4,992 nonzero owner-labelled terms. It also +forms B1 from 224 *independent x1/y1 symbols*, without imposing an F0 relation, +and verifies that (1) recovers exactly those y1_U symbols. The latter replay +checks the actual selected-row coefficients and future logger, rather than +assuming a payload-constant or identity-owner special case. + +## 3. A legal native word + +`WORD.json` is regenerated deterministically from the complete authenticated +3,823-event PR2707 word. It has 1,410 events: + +1. For every port, clear owned W_p in the Y hole frame, copy borrowed Y_p, and + apply the positive rank-one line C_qp. W now has F17 and logical Y2. +2. Finish the source B1 alignment map on every W. With the actual source-derived + affine translation, `M_p F17 = F17 D_p`. All query operands have common F17. +3. At each owner execute the entire private body: clear eight F_k, form all + eight Q rows from the complete 112-port W bank, subtract `R[k,p] F_k/4` from + ordinary W_p only, then clear all F_k in identity frame. Every query is + formed before any W output is overwritten. Finish the owner body before + visiting the next owner. +4. Undo the alignment map on the 96 ordinary W outputs. Clear the sixteen + selected W temporaries directly in their existing frame, returning them + to zero in identity frame. Clearing owned dirt is a paid primitive; no + inverse map or native child is required to dispose of those owned values. + +The temporary disposal is an explicit addition to the projected prefix. It +prevents an unreported dirty full-cover workspace liability. Every borrowed +Y retains its exact initial content and frame, and every X is untouched. + +This projection is semantic: stage-2 map/line conjugations cancel on U because +that logger writes only A. A naive instruction-liveness pass would retain +conjugations on the demanded W fields. There is no reordering of native reads +or private bodies, and no claim of shortest code or a universal 112-child floor. + +The phase checker uses complete modulo-four quadratic coefficients on all 73 +coordinates at every ADD and output. A line contributes parity, and parity has +no terms above degree two modulo four. Thus these are full phase identities. +By Fourier spanning they hold on arbitrary payload arrays; owner pullback and +per-layer multiplication extend them to all owners and tensor layers under +the inherited cover contract. The source kernels are lowered using a basis +whose first column is q: one positive H1 child plus two inverse monomial +wrappers realizes C_q. All 112 bases and 57,344 basis columns are checked; +the other coordinates are spectators. This is not an execution on a huge +physical tape, or a proof of child precision/placement. + +## 4. Complete local invoice and real removed work + +| Charge | New demand word | Complete PR2707 decoder | Difference removed | +|---|---:|---:|---:| +| Positive rank-one children | 112 | 336 | 224 | +| Rank-eight children | 0 | 0 | 0 | +| Native monomial wrappers | 224 | 672 | 448 | +| Full-cover maps | 208 | 464 | 256 | +| Unit ADD macros | 560 | 1,808 | 1,248 | +| Quarter ADD macros | 384 | 896 | 512 | +| CLEAR macros | 144 | 312 | 168 | +| Real scalar primitive allowance | 9,376 | 25,840 | 16,464 | + +The scalar allowance is `8*560 + 12*384 + 2*144`. Its 144 clears include 112 +initial owned clears, sixteen private entry/exit clears and sixteen final +full-cover temporary clears. There are 96 owned outputs, sixteen full-cover +temporaries, eight owner-private scratch arrays, no early records and no X +reads. All 112 borrowed Y fields are restored by remaining read-only. + +What disappears is the future logger reversal, the F0 inverse and unrelated +X1/selected-output recovery, including the two complete future-frame line +sweeps. The final output contract changes from all 224 original arrays to the +96 published y1_U demand. These are actual deleted operations; no unchanged +recursive child is assigned a lower tariff merely because its bit axis became +cheaper. The comparison is not a same-output full-decoder improvement. + +Against PR2512's same logical *output* with different input/lifetime premises, +this replaces `192 H1 + 16 H8` with `112 H1`, keeps 208 cover maps, and raises +scalar allowance from 7,392 to 9,376. It removes early retention but needs the +sixteen additional current Y fields, sixteen owned temporaries and eight +private scratch arrays rather than one. No dominance or global memory saving +follows from comparing child rank mass alone. + +## 5. What the changed budget proves, and what it does not + +Recounting the literal source F0/B1 words gives per-call average + + n = {1:2428, 2:418, 3:432, 4:142, 5:82}. + +For the **same conditional pair-rate budget used by PR3908/PR3946**, allocate +one demand word per two calls: add 56 H1 per call. Retaining the reported +selected-profile eight H8 charges gives + + n_full = {1:2484, 2:418, 3:432, 4:142, 5:82, 8:8}. + +The eight H8 charges are the retained profile premise, not new children in +this demand word. This package does not prove that all eight remain needed +by an outer controller with a changed demand. That is an explicit next audit. +Likewise, this local pair amortization does not prove a full nine-call schedule +or the number of decoder invocations required globally. + +Keep m=73, W=896/9, centre=64, and total mass T=72W+64=7232. The largest idle +rank allowed by the outer halving guard is R=51 (`2*51^2 < 73^2 < 2*52^2`). +For a>=0, price per rank-mass unit is `73^(a-1) r^(-a)`, nonincreasing in r. +Every legal idle placement is therefore at least as expensive as fractional +rank-51 idle work. If L=sum r*n_r and I=T-L, the favorable necessary screen is + + G(a) = [sum_r n_r (r/73)^(1-a) + + (I/51) (51/73)^(1-a)] / W. + +For n_full, L=5658 and I=1574. For the rank-eight-waived variant, L=5594 and +I=1638. All maps, wrappers, scalar operations, storage, movement, placement, +precision and numerical-error costs are set favorably to zero in this screen. +Thus failure already excludes the fixed profile; passing supplies no physical +construction. The actual complete local invoice above remains a liability. + +At the selected `a=836330098538459/499163669901461541`, exact rational bounds are: + +| Hypothesis | Enclosure for G | +|---|---| +| Eight reported H8 charges retained | [1.000023149708, 1.000023150305] | +| All eight H8 charges waived into rank-51 idle mass | [0.999995759681, 0.999995760274] | + +The previous *rank-eight-waived* obstruction no longer applies to this changed +endpoint. Carrying it over would be wrong. The retained-eight profile still +fails even before physical overhead. With those eight charges fixed, at most +61 integer decoder H1 calls per pair pass this relaxation; 62 fail. Our word +has 112, so it needs at least 51 fewer pair calls, with no compensating charges, +merely to pass the optimistic integer screen. There is no theorem that 61 is +achievable, or that no different operator implementation can do better. + +Waiving all eight charges permits at most 121 integer pair calls; our 112 leaves +only [0.000004239726, 0.000004240319] normalized allowance. Neither removing those +children nor paying the remaining physical liabilities is constructed here. +With 112 H1 fixed, retaining two H8 across the pair gives +[0.999999183434, 0.999999184028], while three gives +[1.000000895311, 1.000000895905]. Thus at least fourteen of the reported sixteen +H8 charges across two calls must disappear, with no other new costs, to pass +this integer relaxation. This is a repayment target, not a claim that a copy +can be removed or that fractional per-call assignment is physically legal. +The exact fixed-profile exclusion is the stopping result; it is not a global +QQ16 obstruction and does not authorize construction expansion. + +The rational arithmetic is explicitly adapted from PR3946's independently +checked midpoint/trapezoid logarithm and exponential remainder implementation. +For convex 1/t on [1,y], midpoint sums are lower and trapezoid sums upper +bounds on log(y). Scale arguments into [1,2], round outwards to 2^-80, and use +the degree-six positive exponential sum with first omitted term divided by +`1-hi/(degree+2)` as geometric tail. Every final decision compares Fractions; +decimal formatting also rounds outward. Both sides of the 61/62 and 121/122 +thresholds are verified, rather than deriving a decision from rounded output. + +## 6. Bounded next question + +Audit the *actual eight H8 centre-copy outputs* in the retained supplier and +whether their downstream uses survive this 96-output demand. First bind each +copy's source, destination, frame and last use in the selected archive and a +single real continuation. Either identify legal retirement and recompute the +coverage mass (centre 64 cannot simply be kept or deleted by assertion), or +prove all eight copies are still required under that continuation. This decides +whether the relaxed opening has a valid premise before optimizing physical +kernels. If retained, stop this recipe unless producer/consumer fusion deletes +at least 51 genuine H1 pair charges or another priced premise changes. + +No new retained-query construction, further precision optimization or centre +change is implemented. Full controller demand, copy lifetimes, both supplier +caps, physical map/wrapper costs, numerical grids/dirty ranges, child placement +and all-depth cleanup remain open. diff --git a/research/qq16-consumer-incidence/vendor/pr3952/WORD.json b/research/qq16-consumer-incidence/vendor/pr3952/WORD.json new file mode 100644 index 0000000000..c23da2f205 --- /dev/null +++ b/research/qq16-consumer-incidence/vendor/pr3952/WORD.json @@ -0,0 +1,1412 @@ +[ + ["clear","W0","hole0"], + ["add","W0","Y0","1"], + ["line","W0",0,1], + ["clear","W1","hole1"], + ["add","W1","Y1","1"], + ["line","W1",1,1], + ["clear","W2","hole2"], + ["add","W2","Y2","1"], + ["line","W2",2,1], + ["clear","W3","hole3"], + ["add","W3","Y3","1"], + ["line","W3",3,1], + ["clear","W4","hole4"], + ["add","W4","Y4","1"], + ["line","W4",4,1], + ["clear","W5","hole5"], + ["add","W5","Y5","1"], + ["line","W5",5,1], + ["clear","W6","hole6"], + ["add","W6","Y6","1"], + ["line","W6",6,1], + ["clear","W7","hole7"], + ["add","W7","Y7","1"], + ["line","W7",7,1], + ["clear","W8","hole8"], + ["add","W8","Y8","1"], + ["line","W8",8,1], + ["clear","W9","hole9"], + ["add","W9","Y9","1"], + ["line","W9",9,1], + ["clear","W10","hole10"], + ["add","W10","Y10","1"], + ["line","W10",10,1], + ["clear","W11","hole11"], + ["add","W11","Y11","1"], + ["line","W11",11,1], + ["clear","W12","hole12"], + ["add","W12","Y12","1"], + ["line","W12",12,1], + ["clear","W13","hole13"], + ["add","W13","Y13","1"], + ["line","W13",13,1], + ["clear","W14","hole14"], + ["add","W14","Y14","1"], + ["line","W14",14,1], + ["clear","W15","hole15"], + ["add","W15","Y15","1"], + ["line","W15",15,1], + ["clear","W16","hole16"], + ["add","W16","Y16","1"], + ["line","W16",16,1], + ["clear","W17","hole17"], + ["add","W17","Y17","1"], + ["line","W17",17,1], + ["clear","W18","hole18"], + ["add","W18","Y18","1"], + ["line","W18",18,1], + ["clear","W19","hole19"], + ["add","W19","Y19","1"], + ["line","W19",19,1], + ["clear","W20","hole20"], + ["add","W20","Y20","1"], + ["line","W20",20,1], + ["clear","W21","hole21"], + ["add","W21","Y21","1"], + ["line","W21",21,1], + ["clear","W22","hole22"], + ["add","W22","Y22","1"], + ["line","W22",22,1], + ["clear","W23","hole23"], + ["add","W23","Y23","1"], + ["line","W23",23,1], + ["clear","W24","hole24"], + ["add","W24","Y24","1"], + ["line","W24",24,1], + ["clear","W25","hole25"], + ["add","W25","Y25","1"], + ["line","W25",25,1], + ["clear","W26","hole26"], + ["add","W26","Y26","1"], + ["line","W26",26,1], + ["clear","W27","hole27"], + ["add","W27","Y27","1"], + ["line","W27",27,1], + ["clear","W28","hole28"], + ["add","W28","Y28","1"], + ["line","W28",28,1], + ["clear","W29","hole29"], + ["add","W29","Y29","1"], + ["line","W29",29,1], + ["clear","W30","hole30"], + ["add","W30","Y30","1"], + ["line","W30",30,1], + ["clear","W31","hole31"], + ["add","W31","Y31","1"], + ["line","W31",31,1], + ["clear","W32","hole32"], + ["add","W32","Y32","1"], + ["line","W32",32,1], + ["clear","W33","hole33"], + ["add","W33","Y33","1"], + ["line","W33",33,1], + ["clear","W34","hole34"], + ["add","W34","Y34","1"], + ["line","W34",34,1], + ["clear","W35","hole35"], + ["add","W35","Y35","1"], + ["line","W35",35,1], + ["clear","W36","hole36"], + ["add","W36","Y36","1"], + ["line","W36",36,1], + ["clear","W37","hole37"], + ["add","W37","Y37","1"], + ["line","W37",37,1], + ["clear","W38","hole38"], + ["add","W38","Y38","1"], + ["line","W38",38,1], + ["clear","W39","hole39"], + ["add","W39","Y39","1"], + ["line","W39",39,1], + ["clear","W40","hole40"], + ["add","W40","Y40","1"], + ["line","W40",40,1], + ["clear","W41","hole41"], + ["add","W41","Y41","1"], + ["line","W41",41,1], + ["clear","W42","hole42"], + ["add","W42","Y42","1"], + ["line","W42",42,1], + ["clear","W43","hole43"], + ["add","W43","Y43","1"], + ["line","W43",43,1], + ["clear","W44","hole44"], + ["add","W44","Y44","1"], + ["line","W44",44,1], + ["clear","W45","hole45"], + ["add","W45","Y45","1"], + ["line","W45",45,1], + ["clear","W46","hole46"], + ["add","W46","Y46","1"], + ["line","W46",46,1], + ["clear","W47","hole47"], + ["add","W47","Y47","1"], + ["line","W47",47,1], + ["clear","W48","hole48"], + ["add","W48","Y48","1"], + ["line","W48",48,1], + ["clear","W49","hole49"], + ["add","W49","Y49","1"], + ["line","W49",49,1], + ["clear","W50","hole50"], + ["add","W50","Y50","1"], + ["line","W50",50,1], + ["clear","W51","hole51"], + ["add","W51","Y51","1"], + ["line","W51",51,1], + ["clear","W52","hole52"], + ["add","W52","Y52","1"], + ["line","W52",52,1], + ["clear","W53","hole53"], + ["add","W53","Y53","1"], + ["line","W53",53,1], + ["clear","W54","hole54"], + ["add","W54","Y54","1"], + ["line","W54",54,1], + ["clear","W55","hole55"], + ["add","W55","Y55","1"], + ["line","W55",55,1], + ["clear","W56","hole56"], + ["add","W56","Y56","1"], + ["line","W56",56,1], + ["clear","W57","hole57"], + ["add","W57","Y57","1"], + ["line","W57",57,1], + ["clear","W58","hole58"], + ["add","W58","Y58","1"], + ["line","W58",58,1], + ["clear","W59","hole59"], + ["add","W59","Y59","1"], + ["line","W59",59,1], + ["clear","W60","hole60"], + ["add","W60","Y60","1"], + ["line","W60",60,1], + ["clear","W61","hole61"], + ["add","W61","Y61","1"], + ["line","W61",61,1], + ["clear","W62","hole62"], + ["add","W62","Y62","1"], + ["line","W62",62,1], + ["clear","W63","hole63"], + ["add","W63","Y63","1"], + ["line","W63",63,1], + ["clear","W64","hole64"], + ["add","W64","Y64","1"], + ["line","W64",64,1], + ["clear","W65","hole65"], + ["add","W65","Y65","1"], + ["line","W65",65,1], + ["clear","W66","hole66"], + ["add","W66","Y66","1"], + ["line","W66",66,1], + ["clear","W67","hole67"], + ["add","W67","Y67","1"], + ["line","W67",67,1], + ["clear","W68","hole68"], + ["add","W68","Y68","1"], + ["line","W68",68,1], + ["clear","W69","hole69"], + ["add","W69","Y69","1"], + ["line","W69",69,1], + ["clear","W70","hole70"], + ["add","W70","Y70","1"], + ["line","W70",70,1], + ["clear","W71","hole71"], + ["add","W71","Y71","1"], + ["line","W71",71,1], + ["clear","W72","hole72"], + ["add","W72","Y72","1"], + ["line","W72",72,1], + ["clear","W73","hole73"], + ["add","W73","Y73","1"], + ["line","W73",73,1], + ["clear","W74","hole74"], + ["add","W74","Y74","1"], + ["line","W74",74,1], + ["clear","W75","hole75"], + ["add","W75","Y75","1"], + ["line","W75",75,1], + ["clear","W76","hole76"], + ["add","W76","Y76","1"], + ["line","W76",76,1], + ["clear","W77","hole77"], + ["add","W77","Y77","1"], + ["line","W77",77,1], + ["clear","W78","hole78"], + ["add","W78","Y78","1"], + ["line","W78",78,1], + ["clear","W79","hole79"], + ["add","W79","Y79","1"], + ["line","W79",79,1], + ["clear","W80","hole80"], + ["add","W80","Y80","1"], + ["line","W80",80,1], + ["clear","W81","hole81"], + ["add","W81","Y81","1"], + ["line","W81",81,1], + ["clear","W82","hole82"], + ["add","W82","Y82","1"], + ["line","W82",82,1], + ["clear","W83","hole83"], + ["add","W83","Y83","1"], + ["line","W83",83,1], + ["clear","W84","hole84"], + ["add","W84","Y84","1"], + ["line","W84",84,1], + ["clear","W85","hole85"], + ["add","W85","Y85","1"], + ["line","W85",85,1], + ["clear","W86","hole86"], + ["add","W86","Y86","1"], + ["line","W86",86,1], + ["clear","W87","hole87"], + ["add","W87","Y87","1"], + ["line","W87",87,1], + ["clear","W88","hole88"], + ["add","W88","Y88","1"], + ["line","W88",88,1], + ["clear","W89","hole89"], + ["add","W89","Y89","1"], + ["line","W89",89,1], + ["clear","W90","hole90"], + ["add","W90","Y90","1"], + ["line","W90",90,1], + ["clear","W91","hole91"], + ["add","W91","Y91","1"], + ["line","W91",91,1], + ["clear","W92","hole92"], + ["add","W92","Y92","1"], + ["line","W92",92,1], + ["clear","W93","hole93"], + ["add","W93","Y93","1"], + ["line","W93",93,1], + ["clear","W94","hole94"], + ["add","W94","Y94","1"], + ["line","W94",94,1], + ["clear","W95","hole95"], + ["add","W95","Y95","1"], + ["line","W95",95,1], + ["clear","W96","hole96"], + ["add","W96","Y96","1"], + ["line","W96",96,1], + ["clear","W97","hole97"], + ["add","W97","Y97","1"], + ["line","W97",97,1], + ["clear","W98","hole98"], + ["add","W98","Y98","1"], + ["line","W98",98,1], + ["clear","W99","hole99"], + ["add","W99","Y99","1"], + ["line","W99",99,1], + ["clear","W100","hole100"], + ["add","W100","Y100","1"], + ["line","W100",100,1], + ["clear","W101","hole101"], + ["add","W101","Y101","1"], + ["line","W101",101,1], + ["clear","W102","hole102"], + ["add","W102","Y102","1"], + ["line","W102",102,1], + ["clear","W103","hole103"], + ["add","W103","Y103","1"], + ["line","W103",103,1], + ["clear","W104","hole104"], + ["add","W104","Y104","1"], + ["line","W104",104,1], + ["clear","W105","hole105"], + ["add","W105","Y105","1"], + ["line","W105",105,1], + ["clear","W106","hole106"], + ["add","W106","Y106","1"], + ["line","W106",106,1], + ["clear","W107","hole107"], + ["add","W107","Y107","1"], + ["line","W107",107,1], + ["clear","W108","hole108"], + ["add","W108","Y108","1"], + ["line","W108",108,1], + ["clear","W109","hole109"], + ["add","W109","Y109","1"], + ["line","W109",109,1], + ["clear","W110","hole110"], + ["add","W110","Y110","1"], + ["line","W110",110,1], + ["clear","W111","hole111"], + ["add","W111","Y111","1"], + ["line","W111",111,1], + ["map","W0",1,0,false], + ["map","W1",1,1,false], + ["map","W2",1,2,false], + ["map","W3",1,3,false], + ["map","W4",1,4,false], + ["map","W5",1,5,false], + ["map","W6",1,6,false], + ["map","W7",1,7,false], + ["map","W8",1,8,false], + ["map","W9",1,9,false], + ["map","W10",1,10,false], + ["map","W11",1,11,false], + ["map","W12",1,12,false], + ["map","W13",1,13,false], + ["map","W14",1,14,false], + ["map","W15",1,15,false], + ["map","W16",1,16,false], + ["map","W17",1,17,false], + ["map","W18",1,18,false], + ["map","W19",1,19,false], + ["map","W20",1,20,false], + ["map","W21",1,21,false], + ["map","W22",1,22,false], + ["map","W23",1,23,false], + ["map","W24",1,24,false], + ["map","W25",1,25,false], + ["map","W26",1,26,false], + ["map","W27",1,27,false], + ["map","W28",1,28,false], + ["map","W29",1,29,false], + ["map","W30",1,30,false], + ["map","W31",1,31,false], + ["map","W32",1,32,false], + ["map","W33",1,33,false], + ["map","W34",1,34,false], + ["map","W35",1,35,false], + ["map","W36",1,36,false], + ["map","W37",1,37,false], + ["map","W38",1,38,false], + ["map","W39",1,39,false], + ["map","W40",1,40,false], + ["map","W41",1,41,false], + ["map","W42",1,42,false], + ["map","W43",1,43,false], + ["map","W44",1,44,false], + ["map","W45",1,45,false], + ["map","W46",1,46,false], + ["map","W47",1,47,false], + ["map","W48",1,48,false], + ["map","W49",1,49,false], + ["map","W50",1,50,false], + ["map","W51",1,51,false], + ["map","W52",1,52,false], + ["map","W53",1,53,false], + ["map","W54",1,54,false], + ["map","W55",1,55,false], + ["map","W56",1,56,false], + ["map","W57",1,57,false], + ["map","W58",1,58,false], + ["map","W59",1,59,false], + ["map","W60",1,60,false], + ["map","W61",1,61,false], + ["map","W62",1,62,false], + ["map","W63",1,63,false], + ["map","W64",1,64,false], + ["map","W65",1,65,false], + ["map","W66",1,66,false], + ["map","W67",1,67,false], + ["map","W68",1,68,false], + ["map","W69",1,69,false], + ["map","W70",1,70,false], + ["map","W71",1,71,false], + ["map","W72",1,72,false], + ["map","W73",1,73,false], + ["map","W74",1,74,false], + ["map","W75",1,75,false], + ["map","W76",1,76,false], + ["map","W77",1,77,false], + ["map","W78",1,78,false], + ["map","W79",1,79,false], + ["map","W80",1,80,false], + ["map","W81",1,81,false], + ["map","W82",1,82,false], + ["map","W83",1,83,false], + ["map","W84",1,84,false], + ["map","W85",1,85,false], + ["map","W86",1,86,false], + ["map","W87",1,87,false], + ["map","W88",1,88,false], + ["map","W89",1,89,false], + ["map","W90",1,90,false], + ["map","W91",1,91,false], + ["map","W92",1,92,false], + ["map","W93",1,93,false], + ["map","W94",1,94,false], + ["map","W95",1,95,false], + ["map","W96",1,96,false], + ["map","W97",1,97,false], + ["map","W98",1,98,false], + ["map","W99",1,99,false], + ["map","W100",1,100,false], + ["map","W101",1,101,false], + ["map","W102",1,102,false], + ["map","W103",1,103,false], + ["map","W104",1,104,false], + ["map","W105",1,105,false], + ["map","W106",1,106,false], + ["map","W107",1,107,false], + ["map","W108",1,108,false], + ["map","W109",1,109,false], + ["map","W110",1,110,false], + ["map","W111",1,111,false], + ["begin","B1_current_query",8], + ["clear","F0","wide"], + ["add","F0","W0","1"], + ["add","F0","W2","1"], + ["add","F0","W7","1"], + ["add","F0","W9","1"], + ["add","F0","W10","1"], + ["add","F0","W11","1"], + ["add","F0","W12","1"], + ["add","F0","W17","1"], + ["add","F0","W18","1"], + ["add","F0","W19","1"], + ["add","F0","W22","1"], + ["add","F0","W23","1"], + ["add","F0","W24","1"], + ["add","F0","W25","1"], + ["add","F0","W27","1"], + ["add","F0","W31","1"], + ["add","F0","W32","1"], + ["add","F0","W33","1"], + ["add","F0","W34","1"], + ["add","F0","W35","1"], + ["add","F0","W38","1"], + ["add","F0","W39","1"], + ["add","F0","W40","1"], + ["add","F0","W45","1"], + ["add","F0","W48","1"], + ["add","F0","W49","1"], + ["add","F0","W50","1"], + ["add","F0","W54","1"], + ["add","F0","W55","1"], + ["add","F0","W56","1"], + ["add","F0","W57","1"], + ["add","F0","W61","1"], + ["add","F0","W62","1"], + ["add","F0","W63","1"], + ["add","F0","W70","1"], + ["add","F0","W71","1"], + ["add","F0","W72","1"], + ["add","F0","W76","1"], + ["add","F0","W77","1"], + ["add","F0","W79","1"], + ["add","F0","W81","1"], + ["add","F0","W85","1"], + ["add","F0","W87","1"], + ["add","F0","W89","1"], + ["add","F0","W90","1"], + ["add","F0","W91","1"], + ["add","F0","W92","1"], + ["add","F0","W94","1"], + ["add","F0","W98","1"], + ["add","F0","W100","1"], + ["add","F0","W101","1"], + ["add","F0","W102","1"], + ["add","F0","W103","1"], + ["add","F0","W107","1"], + ["add","F0","W108","1"], + ["add","F0","W109","1"], + ["clear","F1","wide"], + ["add","F1","W0","1"], + ["add","F1","W1","1"], + ["add","F1","W2","1"], + ["add","F1","W3","1"], + ["add","F1","W4","1"], + ["add","F1","W5","1"], + ["add","F1","W6","1"], + ["add","F1","W7","-1"], + ["add","F1","W8","1"], + ["add","F1","W9","-1"], + ["add","F1","W10","-1"], + ["add","F1","W11","-1"], + ["add","F1","W25","1"], + ["add","F1","W26","1"], + ["add","F1","W27","1"], + ["add","F1","W28","1"], + ["add","F1","W29","1"], + ["add","F1","W30","1"], + ["add","F1","W57","-1"], + ["add","F1","W58","1"], + ["add","F1","W59","1"], + ["add","F1","W60","1"], + ["add","F1","W61","-1"], + ["add","F1","W62","-1"], + ["add","F1","W63","-1"], + ["add","F1","W64","1"], + ["add","F1","W65","1"], + ["add","F1","W66","1"], + ["add","F1","W67","1"], + ["add","F1","W68","1"], + ["add","F1","W69","1"], + ["add","F1","W70","1"], + ["add","F1","W71","1"], + ["add","F1","W72","1"], + ["add","F1","W73","1"], + ["add","F1","W74","1"], + ["add","F1","W75","1"], + ["add","F1","W76","1"], + ["add","F1","W79","-1"], + ["add","F1","W80","1"], + ["add","F1","W81","-1"], + ["add","F1","W82","1"], + ["add","F1","W83","1"], + ["add","F1","W84","1"], + ["add","F1","W86","1"], + ["add","F1","W87","1"], + ["add","F1","W88","1"], + ["add","F1","W89","1"], + ["add","F1","W90","1"], + ["add","F1","W91","1"], + ["add","F1","W92","-1"], + ["add","F1","W93","1"], + ["add","F1","W94","-1"], + ["add","F1","W95","1"], + ["add","F1","W96","1"], + ["add","F1","W97","1"], + ["clear","F2","wide"], + ["add","F2","W0","1"], + ["add","F2","W1","1"], + ["add","F2","W6","1"], + ["add","F2","W7","-1"], + ["add","F2","W12","1"], + ["add","F2","W13","1"], + ["add","F2","W14","1"], + ["add","F2","W15","1"], + ["add","F2","W16","1"], + ["add","F2","W17","-1"], + ["add","F2","W18","-1"], + ["add","F2","W19","-1"], + ["add","F2","W27","-1"], + ["add","F2","W28","-1"], + ["add","F2","W29","-1"], + ["add","F2","W30","-1"], + ["add","F2","W31","1"], + ["add","F2","W38","-1"], + ["add","F2","W39","-1"], + ["add","F2","W40","-1"], + ["add","F2","W41","1"], + ["add","F2","W42","1"], + ["add","F2","W43","1"], + ["add","F2","W44","1"], + ["add","F2","W51","1"], + ["add","F2","W52","1"], + ["add","F2","W53","1"], + ["add","F2","W54","1"], + ["add","F2","W55","1"], + ["add","F2","W56","1"], + ["add","F2","W57","1"], + ["add","F2","W58","-1"], + ["add","F2","W59","-1"], + ["add","F2","W60","-1"], + ["add","F2","W73","1"], + ["add","F2","W74","1"], + ["add","F2","W75","1"], + ["add","F2","W76","1"], + ["add","F2","W77","-1"], + ["add","F2","W78","1"], + ["add","F2","W81","-1"], + ["add","F2","W82","1"], + ["add","F2","W83","1"], + ["add","F2","W84","1"], + ["add","F2","W86","-1"], + ["add","F2","W87","-1"], + ["add","F2","W92","1"], + ["add","F2","W93","-1"], + ["add","F2","W99","1"], + ["add","F2","W100","1"], + ["add","F2","W101","1"], + ["add","F2","W102","1"], + ["add","F2","W103","-1"], + ["add","F2","W104","1"], + ["add","F2","W105","1"], + ["add","F2","W106","1"], + ["clear","F3","wide"], + ["add","F3","W0","1"], + ["add","F3","W3","1"], + ["add","F3","W4","1"], + ["add","F3","W5","1"], + ["add","F3","W7","1"], + ["add","F3","W8","-1"], + ["add","F3","W13","1"], + ["add","F3","W14","1"], + ["add","F3","W15","1"], + ["add","F3","W16","-1"], + ["add","F3","W22","-1"], + ["add","F3","W23","-1"], + ["add","F3","W24","-1"], + ["add","F3","W26","-1"], + ["add","F3","W27","-1"], + ["add","F3","W32","1"], + ["add","F3","W33","1"], + ["add","F3","W34","1"], + ["add","F3","W35","-1"], + ["add","F3","W41","-1"], + ["add","F3","W42","-1"], + ["add","F3","W43","-1"], + ["add","F3","W44","-1"], + ["add","F3","W45","-1"], + ["add","F3","W48","1"], + ["add","F3","W49","1"], + ["add","F3","W50","1"], + ["add","F3","W51","1"], + ["add","F3","W52","1"], + ["add","F3","W53","1"], + ["add","F3","W57","-1"], + ["add","F3","W64","-1"], + ["add","F3","W65","-1"], + ["add","F3","W66","-1"], + ["add","F3","W67","1"], + ["add","F3","W68","1"], + ["add","F3","W69","1"], + ["add","F3","W76","-1"], + ["add","F3","W78","1"], + ["add","F3","W80","1"], + ["add","F3","W81","-1"], + ["add","F3","W85","1"], + ["add","F3","W87","1"], + ["add","F3","W88","1"], + ["add","F3","W92","1"], + ["add","F3","W95","-1"], + ["add","F3","W96","-1"], + ["add","F3","W97","-1"], + ["add","F3","W98","1"], + ["add","F3","W99","1"], + ["add","F3","W104","-1"], + ["add","F3","W105","-1"], + ["add","F3","W106","-1"], + ["add","F3","W107","-1"], + ["add","F3","W108","-1"], + ["add","F3","W109","-1"], + ["clear","F4","wide"], + ["add","F4","W1","-1"], + ["add","F4","W3","-1"], + ["add","F4","W6","1"], + ["add","F4","W8","1"], + ["add","F4","W10","-1"], + ["add","F4","W11","-1"], + ["add","F4","W12","1"], + ["add","F4","W14","1"], + ["add","F4","W15","1"], + ["add","F4","W17","1"], + ["add","F4","W20","1"], + ["add","F4","W21","1"], + ["add","F4","W24","-1"], + ["add","F4","W26","-1"], + ["add","F4","W28","-1"], + ["add","F4","W31","-1"], + ["add","F4","W32","-1"], + ["add","F4","W35","-1"], + ["add","F4","W36","1"], + ["add","F4","W37","1"], + ["add","F4","W38","-1"], + ["add","F4","W41","1"], + ["add","F4","W42","1"], + ["add","F4","W45","1"], + ["add","F4","W46","1"], + ["add","F4","W47","1"], + ["add","F4","W48","1"], + ["add","F4","W52","-1"], + ["add","F4","W53","-1"], + ["add","F4","W56","-1"], + ["add","F4","W58","1"], + ["add","F4","W62","1"], + ["add","F4","W63","1"], + ["add","F4","W66","-1"], + ["add","F4","W67","1"], + ["add","F4","W70","1"], + ["add","F4","W71","1"], + ["add","F4","W75","-1"], + ["add","F4","W77","-1"], + ["add","F4","W80","1"], + ["add","F4","W82","1"], + ["add","F4","W85","-1"], + ["add","F4","W86","-1"], + ["add","F4","W88","-1"], + ["add","F4","W90","-1"], + ["add","F4","W91","-1"], + ["add","F4","W93","1"], + ["add","F4","W95","1"], + ["add","F4","W98","1"], + ["add","F4","W100","1"], + ["add","F4","W103","1"], + ["add","F4","W105","-1"], + ["add","F4","W106","-1"], + ["add","F4","W107","1"], + ["add","F4","W110","1"], + ["add","F4","W111","1"], + ["clear","F5","wide"], + ["add","F5","W4","-1"], + ["add","F5","W5","1"], + ["add","F5","W10","1"], + ["add","F5","W11","-1"], + ["add","F5","W14","-1"], + ["add","F5","W15","1"], + ["add","F5","W18","1"], + ["add","F5","W19","-1"], + ["add","F5","W20","-1"], + ["add","F5","W21","1"], + ["add","F5","W22","1"], + ["add","F5","W23","-1"], + ["add","F5","W29","-1"], + ["add","F5","W30","1"], + ["add","F5","W33","-1"], + ["add","F5","W34","1"], + ["add","F5","W36","1"], + ["add","F5","W37","-1"], + ["add","F5","W39","-1"], + ["add","F5","W40","1"], + ["add","F5","W41","1"], + ["add","F5","W42","-1"], + ["add","F5","W46","-1"], + ["add","F5","W47","1"], + ["add","F5","W49","1"], + ["add","F5","W50","-1"], + ["add","F5","W52","1"], + ["add","F5","W53","-1"], + ["add","F5","W54","1"], + ["add","F5","W55","-1"], + ["add","F5","W59","1"], + ["add","F5","W60","-1"], + ["add","F5","W62","-1"], + ["add","F5","W63","1"], + ["add","F5","W64","1"], + ["add","F5","W65","-1"], + ["add","F5","W68","1"], + ["add","F5","W69","-1"], + ["add","F5","W70","1"], + ["add","F5","W71","-1"], + ["add","F5","W73","1"], + ["add","F5","W74","-1"], + ["add","F5","W83","1"], + ["add","F5","W84","-1"], + ["add","F5","W90","1"], + ["add","F5","W91","-1"], + ["add","F5","W96","1"], + ["add","F5","W97","-1"], + ["add","F5","W101","1"], + ["add","F5","W102","-1"], + ["add","F5","W105","1"], + ["add","F5","W106","-1"], + ["add","F5","W108","1"], + ["add","F5","W109","-1"], + ["add","F5","W110","-1"], + ["add","F5","W111","1"], + ["clear","F6","wide"], + ["add","F6","W2","1"], + ["add","F6","W3","1"], + ["add","F6","W8","1"], + ["add","F6","W9","-1"], + ["add","F6","W12","1"], + ["add","F6","W13","1"], + ["add","F6","W16","1"], + ["add","F6","W17","-1"], + ["add","F6","W20","1"], + ["add","F6","W21","1"], + ["add","F6","W22","-1"], + ["add","F6","W23","-1"], + ["add","F6","W25","-1"], + ["add","F6","W26","-1"], + ["add","F6","W29","-1"], + ["add","F6","W30","-1"], + ["add","F6","W31","-1"], + ["add","F6","W33","-1"], + ["add","F6","W34","-1"], + ["add","F6","W36","1"], + ["add","F6","W37","1"], + ["add","F6","W38","1"], + ["add","F6","W43","1"], + ["add","F6","W44","-1"], + ["add","F6","W46","-1"], + ["add","F6","W47","-1"], + ["add","F6","W49","1"], + ["add","F6","W50","1"], + ["add","F6","W51","-1"], + ["add","F6","W56","1"], + ["add","F6","W59","1"], + ["add","F6","W60","1"], + ["add","F6","W61","1"], + ["add","F6","W66","1"], + ["add","F6","W67","-1"], + ["add","F6","W72","1"], + ["add","F6","W73","-1"], + ["add","F6","W74","-1"], + ["add","F6","W77","-1"], + ["add","F6","W78","1"], + ["add","F6","W79","-1"], + ["add","F6","W80","1"], + ["add","F6","W83","1"], + ["add","F6","W84","1"], + ["add","F6","W88","-1"], + ["add","F6","W89","-1"], + ["add","F6","W94","1"], + ["add","F6","W95","-1"], + ["add","F6","W99","-1"], + ["add","F6","W100","-1"], + ["add","F6","W103","1"], + ["add","F6","W104","-1"], + ["add","F6","W108","1"], + ["add","F6","W109","1"], + ["add","F6","W110","-1"], + ["add","F6","W111","-1"], + ["clear","F7","wide"], + ["add","F7","W1","-1"], + ["add","F7","W2","-1"], + ["add","F7","W4","-1"], + ["add","F7","W5","-1"], + ["add","F7","W6","1"], + ["add","F7","W9","-1"], + ["add","F7","W13","1"], + ["add","F7","W16","-1"], + ["add","F7","W18","1"], + ["add","F7","W19","1"], + ["add","F7","W20","-1"], + ["add","F7","W21","-1"], + ["add","F7","W24","1"], + ["add","F7","W25","1"], + ["add","F7","W28","1"], + ["add","F7","W32","1"], + ["add","F7","W35","-1"], + ["add","F7","W36","1"], + ["add","F7","W37","1"], + ["add","F7","W39","-1"], + ["add","F7","W40","-1"], + ["add","F7","W43","1"], + ["add","F7","W44","1"], + ["add","F7","W45","1"], + ["add","F7","W46","1"], + ["add","F7","W47","1"], + ["add","F7","W48","-1"], + ["add","F7","W51","-1"], + ["add","F7","W54","-1"], + ["add","F7","W55","-1"], + ["add","F7","W58","-1"], + ["add","F7","W61","1"], + ["add","F7","W64","-1"], + ["add","F7","W65","-1"], + ["add","F7","W68","1"], + ["add","F7","W69","1"], + ["add","F7","W72","1"], + ["add","F7","W75","1"], + ["add","F7","W78","-1"], + ["add","F7","W79","1"], + ["add","F7","W82","-1"], + ["add","F7","W85","-1"], + ["add","F7","W86","-1"], + ["add","F7","W89","-1"], + ["add","F7","W93","1"], + ["add","F7","W94","-1"], + ["add","F7","W96","1"], + ["add","F7","W97","1"], + ["add","F7","W98","1"], + ["add","F7","W99","1"], + ["add","F7","W101","1"], + ["add","F7","W102","1"], + ["add","F7","W104","-1"], + ["add","F7","W107","-1"], + ["add","F7","W110","-1"], + ["add","F7","W111","-1"], + ["add","W1","F1","-1/4"], + ["add","W1","F2","-1/4"], + ["add","W1","F4","1/4"], + ["add","W1","F7","1/4"], + ["add","W2","F0","-1/4"], + ["add","W2","F1","-1/4"], + ["add","W2","F6","-1/4"], + ["add","W2","F7","1/4"], + ["add","W3","F1","-1/4"], + ["add","W3","F3","-1/4"], + ["add","W3","F4","1/4"], + ["add","W3","F6","-1/4"], + ["add","W4","F1","-1/4"], + ["add","W4","F3","-1/4"], + ["add","W4","F5","1/4"], + ["add","W4","F7","1/4"], + ["add","W5","F1","-1/4"], + ["add","W5","F3","-1/4"], + ["add","W5","F5","-1/4"], + ["add","W5","F7","1/4"], + ["add","W6","F1","-1/4"], + ["add","W6","F2","-1/4"], + ["add","W6","F4","-1/4"], + ["add","W6","F7","-1/4"], + ["add","W8","F1","-1/4"], + ["add","W8","F3","1/4"], + ["add","W8","F4","-1/4"], + ["add","W8","F6","-1/4"], + ["add","W9","F0","-1/4"], + ["add","W9","F1","1/4"], + ["add","W9","F6","1/4"], + ["add","W9","F7","1/4"], + ["add","W10","F0","-1/4"], + ["add","W10","F1","1/4"], + ["add","W10","F4","1/4"], + ["add","W10","F5","-1/4"], + ["add","W11","F0","-1/4"], + ["add","W11","F1","1/4"], + ["add","W11","F4","1/4"], + ["add","W11","F5","1/4"], + ["add","W12","F0","-1/4"], + ["add","W12","F2","-1/4"], + ["add","W12","F4","-1/4"], + ["add","W12","F6","-1/4"], + ["add","W13","F2","-1/4"], + ["add","W13","F3","-1/4"], + ["add","W13","F6","-1/4"], + ["add","W13","F7","-1/4"], + ["add","W14","F2","-1/4"], + ["add","W14","F3","-1/4"], + ["add","W14","F4","-1/4"], + ["add","W14","F5","1/4"], + ["add","W15","F2","-1/4"], + ["add","W15","F3","-1/4"], + ["add","W15","F4","-1/4"], + ["add","W15","F5","-1/4"], + ["add","W16","F2","-1/4"], + ["add","W16","F3","1/4"], + ["add","W16","F6","-1/4"], + ["add","W16","F7","1/4"], + ["add","W17","F0","-1/4"], + ["add","W17","F2","1/4"], + ["add","W17","F4","-1/4"], + ["add","W17","F6","1/4"], + ["add","W18","F0","-1/4"], + ["add","W18","F2","1/4"], + ["add","W18","F5","-1/4"], + ["add","W18","F7","-1/4"], + ["add","W19","F0","-1/4"], + ["add","W19","F2","1/4"], + ["add","W19","F5","1/4"], + ["add","W19","F7","-1/4"], + ["add","W22","F0","-1/4"], + ["add","W22","F3","1/4"], + ["add","W22","F5","-1/4"], + ["add","W22","F6","1/4"], + ["add","W23","F0","-1/4"], + ["add","W23","F3","1/4"], + ["add","W23","F5","1/4"], + ["add","W23","F6","1/4"], + ["add","W24","F0","-1/4"], + ["add","W24","F3","1/4"], + ["add","W24","F4","1/4"], + ["add","W24","F7","-1/4"], + ["add","W25","F0","-1/4"], + ["add","W25","F1","-1/4"], + ["add","W25","F6","1/4"], + ["add","W25","F7","-1/4"], + ["add","W26","F1","-1/4"], + ["add","W26","F3","1/4"], + ["add","W26","F4","1/4"], + ["add","W26","F6","1/4"], + ["add","W28","F1","-1/4"], + ["add","W28","F2","1/4"], + ["add","W28","F4","1/4"], + ["add","W28","F7","-1/4"], + ["add","W29","F1","-1/4"], + ["add","W29","F2","1/4"], + ["add","W29","F5","1/4"], + ["add","W29","F6","1/4"], + ["add","W30","F1","-1/4"], + ["add","W30","F2","1/4"], + ["add","W30","F5","-1/4"], + ["add","W30","F6","1/4"], + ["add","W31","F0","-1/4"], + ["add","W31","F2","-1/4"], + ["add","W31","F4","1/4"], + ["add","W31","F6","1/4"], + ["add","W32","F0","-1/4"], + ["add","W32","F3","-1/4"], + ["add","W32","F4","1/4"], + ["add","W32","F7","-1/4"], + ["add","W33","F0","-1/4"], + ["add","W33","F3","-1/4"], + ["add","W33","F5","1/4"], + ["add","W33","F6","1/4"], + ["add","W34","F0","-1/4"], + ["add","W34","F3","-1/4"], + ["add","W34","F5","-1/4"], + ["add","W34","F6","1/4"], + ["add","W35","F0","-1/4"], + ["add","W35","F3","1/4"], + ["add","W35","F4","1/4"], + ["add","W35","F7","1/4"], + ["add","W38","F0","-1/4"], + ["add","W38","F2","1/4"], + ["add","W38","F4","1/4"], + ["add","W38","F6","-1/4"], + ["add","W39","F0","-1/4"], + ["add","W39","F2","1/4"], + ["add","W39","F5","1/4"], + ["add","W39","F7","1/4"], + ["add","W40","F0","-1/4"], + ["add","W40","F2","1/4"], + ["add","W40","F5","-1/4"], + ["add","W40","F7","1/4"], + ["add","W41","F2","-1/4"], + ["add","W41","F3","1/4"], + ["add","W41","F4","-1/4"], + ["add","W41","F5","-1/4"], + ["add","W42","F2","-1/4"], + ["add","W42","F3","1/4"], + ["add","W42","F4","-1/4"], + ["add","W42","F5","1/4"], + ["add","W43","F2","-1/4"], + ["add","W43","F3","1/4"], + ["add","W43","F6","-1/4"], + ["add","W43","F7","-1/4"], + ["add","W44","F2","-1/4"], + ["add","W44","F3","1/4"], + ["add","W44","F6","1/4"], + ["add","W44","F7","-1/4"], + ["add","W45","F0","-1/4"], + ["add","W45","F3","1/4"], + ["add","W45","F4","-1/4"], + ["add","W45","F7","-1/4"], + ["add","W48","F0","-1/4"], + ["add","W48","F3","-1/4"], + ["add","W48","F4","-1/4"], + ["add","W48","F7","1/4"], + ["add","W49","F0","-1/4"], + ["add","W49","F3","-1/4"], + ["add","W49","F5","-1/4"], + ["add","W49","F6","-1/4"], + ["add","W50","F0","-1/4"], + ["add","W50","F3","-1/4"], + ["add","W50","F5","1/4"], + ["add","W50","F6","-1/4"], + ["add","W51","F2","-1/4"], + ["add","W51","F3","-1/4"], + ["add","W51","F6","1/4"], + ["add","W51","F7","1/4"], + ["add","W52","F2","-1/4"], + ["add","W52","F3","-1/4"], + ["add","W52","F4","1/4"], + ["add","W52","F5","-1/4"], + ["add","W53","F2","-1/4"], + ["add","W53","F3","-1/4"], + ["add","W53","F4","1/4"], + ["add","W53","F5","1/4"], + ["add","W54","F0","-1/4"], + ["add","W54","F2","-1/4"], + ["add","W54","F5","-1/4"], + ["add","W54","F7","1/4"], + ["add","W55","F0","-1/4"], + ["add","W55","F2","-1/4"], + ["add","W55","F5","1/4"], + ["add","W55","F7","1/4"], + ["add","W56","F0","-1/4"], + ["add","W56","F2","-1/4"], + ["add","W56","F4","1/4"], + ["add","W56","F6","-1/4"], + ["add","W58","F1","-1/4"], + ["add","W58","F2","1/4"], + ["add","W58","F4","-1/4"], + ["add","W58","F7","1/4"], + ["add","W59","F1","-1/4"], + ["add","W59","F2","1/4"], + ["add","W59","F5","-1/4"], + ["add","W59","F6","-1/4"], + ["add","W60","F1","-1/4"], + ["add","W60","F2","1/4"], + ["add","W60","F5","1/4"], + ["add","W60","F6","-1/4"], + ["add","W61","F0","-1/4"], + ["add","W61","F1","1/4"], + ["add","W61","F6","-1/4"], + ["add","W61","F7","-1/4"], + ["add","W62","F0","-1/4"], + ["add","W62","F1","1/4"], + ["add","W62","F4","-1/4"], + ["add","W62","F5","1/4"], + ["add","W63","F0","-1/4"], + ["add","W63","F1","1/4"], + ["add","W63","F4","-1/4"], + ["add","W63","F5","-1/4"], + ["add","W64","F1","-1/4"], + ["add","W64","F3","1/4"], + ["add","W64","F5","-1/4"], + ["add","W64","F7","1/4"], + ["add","W65","F1","-1/4"], + ["add","W65","F3","1/4"], + ["add","W65","F5","1/4"], + ["add","W65","F7","1/4"], + ["add","W66","F1","-1/4"], + ["add","W66","F3","1/4"], + ["add","W66","F4","1/4"], + ["add","W66","F6","-1/4"], + ["add","W67","F1","-1/4"], + ["add","W67","F3","-1/4"], + ["add","W67","F4","-1/4"], + ["add","W67","F6","1/4"], + ["add","W68","F1","-1/4"], + ["add","W68","F3","-1/4"], + ["add","W68","F5","-1/4"], + ["add","W68","F7","-1/4"], + ["add","W69","F1","-1/4"], + ["add","W69","F3","-1/4"], + ["add","W69","F5","1/4"], + ["add","W69","F7","-1/4"], + ["add","W70","F0","-1/4"], + ["add","W70","F1","-1/4"], + ["add","W70","F4","-1/4"], + ["add","W70","F5","-1/4"], + ["add","W71","F0","-1/4"], + ["add","W71","F1","-1/4"], + ["add","W71","F4","-1/4"], + ["add","W71","F5","1/4"], + ["add","W72","F0","-1/4"], + ["add","W72","F1","-1/4"], + ["add","W72","F6","-1/4"], + ["add","W72","F7","-1/4"], + ["add","W73","F1","-1/4"], + ["add","W73","F2","-1/4"], + ["add","W73","F5","-1/4"], + ["add","W73","F6","1/4"], + ["add","W74","F1","-1/4"], + ["add","W74","F2","-1/4"], + ["add","W74","F5","1/4"], + ["add","W74","F6","1/4"], + ["add","W75","F1","-1/4"], + ["add","W75","F2","-1/4"], + ["add","W75","F4","1/4"], + ["add","W75","F7","-1/4"], + ["add","W77","F0","-1/4"], + ["add","W77","F2","1/4"], + ["add","W77","F4","1/4"], + ["add","W77","F6","1/4"], + ["add","W78","F2","-1/4"], + ["add","W78","F3","-1/4"], + ["add","W78","F6","-1/4"], + ["add","W78","F7","1/4"], + ["add","W79","F0","-1/4"], + ["add","W79","F1","1/4"], + ["add","W79","F6","1/4"], + ["add","W79","F7","-1/4"], + ["add","W80","F1","-1/4"], + ["add","W80","F3","-1/4"], + ["add","W80","F4","-1/4"], + ["add","W80","F6","-1/4"], + ["add","W82","F1","-1/4"], + ["add","W82","F2","-1/4"], + ["add","W82","F4","-1/4"], + ["add","W82","F7","1/4"], + ["add","W83","F1","-1/4"], + ["add","W83","F2","-1/4"], + ["add","W83","F5","-1/4"], + ["add","W83","F6","-1/4"], + ["add","W84","F1","-1/4"], + ["add","W84","F2","-1/4"], + ["add","W84","F5","1/4"], + ["add","W84","F6","-1/4"], + ["add","W85","F0","-1/4"], + ["add","W85","F3","-1/4"], + ["add","W85","F4","1/4"], + ["add","W85","F7","1/4"], + ["add","W86","F1","-1/4"], + ["add","W86","F2","1/4"], + ["add","W86","F4","1/4"], + ["add","W86","F7","1/4"], + ["add","W88","F1","-1/4"], + ["add","W88","F3","-1/4"], + ["add","W88","F4","1/4"], + ["add","W88","F6","1/4"], + ["add","W89","F0","-1/4"], + ["add","W89","F1","-1/4"], + ["add","W89","F6","1/4"], + ["add","W89","F7","1/4"], + ["add","W90","F0","-1/4"], + ["add","W90","F1","-1/4"], + ["add","W90","F4","1/4"], + ["add","W90","F5","-1/4"], + ["add","W91","F0","-1/4"], + ["add","W91","F1","-1/4"], + ["add","W91","F4","1/4"], + ["add","W91","F5","1/4"], + ["add","W93","F1","-1/4"], + ["add","W93","F2","1/4"], + ["add","W93","F4","-1/4"], + ["add","W93","F7","-1/4"], + ["add","W94","F0","-1/4"], + ["add","W94","F1","1/4"], + ["add","W94","F6","-1/4"], + ["add","W94","F7","1/4"], + ["add","W95","F1","-1/4"], + ["add","W95","F3","1/4"], + ["add","W95","F4","-1/4"], + ["add","W95","F6","1/4"], + ["add","W96","F1","-1/4"], + ["add","W96","F3","1/4"], + ["add","W96","F5","-1/4"], + ["add","W96","F7","-1/4"], + ["add","W97","F1","-1/4"], + ["add","W97","F3","1/4"], + ["add","W97","F5","1/4"], + ["add","W97","F7","-1/4"], + ["add","W98","F0","-1/4"], + ["add","W98","F3","-1/4"], + ["add","W98","F4","-1/4"], + ["add","W98","F7","-1/4"], + ["add","W99","F2","-1/4"], + ["add","W99","F3","-1/4"], + ["add","W99","F6","1/4"], + ["add","W99","F7","-1/4"], + ["add","W100","F0","-1/4"], + ["add","W100","F2","-1/4"], + ["add","W100","F4","-1/4"], + ["add","W100","F6","1/4"], + ["add","W101","F0","-1/4"], + ["add","W101","F2","-1/4"], + ["add","W101","F5","-1/4"], + ["add","W101","F7","-1/4"], + ["add","W102","F0","-1/4"], + ["add","W102","F2","-1/4"], + ["add","W102","F5","1/4"], + ["add","W102","F7","-1/4"], + ["add","W103","F0","-1/4"], + ["add","W103","F2","1/4"], + ["add","W103","F4","-1/4"], + ["add","W103","F6","-1/4"], + ["add","W104","F2","-1/4"], + ["add","W104","F3","1/4"], + ["add","W104","F6","1/4"], + ["add","W104","F7","1/4"], + ["add","W105","F2","-1/4"], + ["add","W105","F3","1/4"], + ["add","W105","F4","1/4"], + ["add","W105","F5","-1/4"], + ["add","W106","F2","-1/4"], + ["add","W106","F3","1/4"], + ["add","W106","F4","1/4"], + ["add","W106","F5","1/4"], + ["add","W107","F0","-1/4"], + ["add","W107","F3","1/4"], + ["add","W107","F4","-1/4"], + ["add","W107","F7","1/4"], + ["add","W108","F0","-1/4"], + ["add","W108","F3","1/4"], + ["add","W108","F5","-1/4"], + ["add","W108","F6","-1/4"], + ["add","W109","F0","-1/4"], + ["add","W109","F3","1/4"], + ["add","W109","F5","1/4"], + ["add","W109","F6","-1/4"], + ["clear","F0","identity"], + ["clear","F1","identity"], + ["clear","F2","identity"], + ["clear","F3","identity"], + ["clear","F4","identity"], + ["clear","F5","identity"], + ["clear","F6","identity"], + ["clear","F7","identity"], + ["end","B1_current_query",8], + ["map","W1",1,1,true], + ["map","W2",1,2,true], + ["map","W3",1,3,true], + ["map","W4",1,4,true], + ["map","W5",1,5,true], + ["map","W6",1,6,true], + ["map","W8",1,8,true], + ["map","W9",1,9,true], + ["map","W10",1,10,true], + ["map","W11",1,11,true], + ["map","W12",1,12,true], + ["map","W13",1,13,true], + ["map","W14",1,14,true], + ["map","W15",1,15,true], + ["map","W16",1,16,true], + ["map","W17",1,17,true], + ["map","W18",1,18,true], + ["map","W19",1,19,true], + ["map","W22",1,22,true], + ["map","W23",1,23,true], + ["map","W24",1,24,true], + ["map","W25",1,25,true], + ["map","W26",1,26,true], + ["map","W28",1,28,true], + ["map","W29",1,29,true], + ["map","W30",1,30,true], + ["map","W31",1,31,true], + ["map","W32",1,32,true], + ["map","W33",1,33,true], + ["map","W34",1,34,true], + ["map","W35",1,35,true], + ["map","W38",1,38,true], + ["map","W39",1,39,true], + ["map","W40",1,40,true], + ["map","W41",1,41,true], + ["map","W42",1,42,true], + ["map","W43",1,43,true], + ["map","W44",1,44,true], + ["map","W45",1,45,true], + ["map","W48",1,48,true], + ["map","W49",1,49,true], + ["map","W50",1,50,true], + ["map","W51",1,51,true], + ["map","W52",1,52,true], + ["map","W53",1,53,true], + ["map","W54",1,54,true], + ["map","W55",1,55,true], + ["map","W56",1,56,true], + ["map","W58",1,58,true], + ["map","W59",1,59,true], + ["map","W60",1,60,true], + ["map","W61",1,61,true], + ["map","W62",1,62,true], + ["map","W63",1,63,true], + ["map","W64",1,64,true], + ["map","W65",1,65,true], + ["map","W66",1,66,true], + ["map","W67",1,67,true], + ["map","W68",1,68,true], + ["map","W69",1,69,true], + ["map","W70",1,70,true], + ["map","W71",1,71,true], + ["map","W72",1,72,true], + ["map","W73",1,73,true], + ["map","W74",1,74,true], + ["map","W75",1,75,true], + ["map","W77",1,77,true], + ["map","W78",1,78,true], + ["map","W79",1,79,true], + ["map","W80",1,80,true], + ["map","W82",1,82,true], + ["map","W83",1,83,true], + ["map","W84",1,84,true], + ["map","W85",1,85,true], + ["map","W86",1,86,true], + ["map","W88",1,88,true], + ["map","W89",1,89,true], + ["map","W90",1,90,true], + ["map","W91",1,91,true], + ["map","W93",1,93,true], + ["map","W94",1,94,true], + ["map","W95",1,95,true], + ["map","W96",1,96,true], + ["map","W97",1,97,true], + ["map","W98",1,98,true], + ["map","W99",1,99,true], + ["map","W100",1,100,true], + ["map","W101",1,101,true], + ["map","W102",1,102,true], + ["map","W103",1,103,true], + ["map","W104",1,104,true], + ["map","W105",1,105,true], + ["map","W106",1,106,true], + ["map","W107",1,107,true], + ["map","W108",1,108,true], + ["map","W109",1,109,true], + ["clear","W0","identity"], + ["clear","W7","identity"], + ["clear","W20","identity"], + ["clear","W27","identity"], + ["clear","W36","identity"], + ["clear","W46","identity"], + ["clear","W57","identity"], + ["clear","W111","identity"], + ["clear","W21","identity"], + ["clear","W37","identity"], + ["clear","W47","identity"], + ["clear","W76","identity"], + ["clear","W81","identity"], + ["clear","W87","identity"], + ["clear","W92","identity"], + ["clear","W110","identity"] +] diff --git a/research/qq16-consumer-incidence/verify.py b/research/qq16-consumer-incidence/verify.py new file mode 100644 index 0000000000..8e263f98e0 --- /dev/null +++ b/research/qq16-consumer-incidence/verify.py @@ -0,0 +1,184 @@ +#!/usr/bin/env python3 +"""Source-bound integer incidence and conditional QQ16 budget. Apache-2.0. +Chris R / Clear1nsight with substantial OpenAI assistance. +No predecessor executable is imported; numerical helper is package-local. +""" +import argparse +from collections import Counter +from fractions import Fraction as Q +import gzip,hashlib,io,json,tarfile,types +from pathlib import Path +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +BASE='20ecf2891d80b5acf18d980b2164fb44ea7faa90' +MEMBER='t16/global/hosted/GLOBAL-TEMPLATE.json.gz' +MEMBER_SHA='73f47a1e60b1e4ea66dbca9a497c411c8e6adc7984e276a437a10a9a7a13b47a' +CASES=['F_0','B_1_2','F_2','B_3_4','F_4','B_5_6','F_6','B_7_8','F_8'] +PAIRS=[0,0,0,1,1,2,2,3,3] +CORE={1:2412,2:418,3:432,4:142,5:82} + +def need(ok,why): + if not ok:raise ValueError(why) + +def parse(raw): + def pairs(items): + d=dict(items);need(len(d)==len(items),'duplicate JSON key');return d + return json.loads(raw,object_pairs_hook=pairs) + +def canonical(x):return json.dumps(x,sort_keys=True,separators=(',',':'),allow_nan=False) + +def sources(): + need(hashlib.sha256((HERE/'SOURCES.json').read_bytes()).hexdigest()=='958f1d29b31e8aa25d2f078ac0e8ac7ca53ce98029fd265446a2ce5900815e60','source manifest binding') + need(hashlib.sha256((HERE/'PREDECESSORS.json').read_bytes()).hexdigest()=='eed9ddb0e7339b0fd75a8fa2f9ddb0c7556c43c1450185d16bfd3f6c3ca62599','predecessor manifest binding') + manifest=parse((HERE/'SOURCES.json').read_bytes()) + need(manifest['base_commit']==BASE,'source base') + data={} + for pin in manifest['files']: + if pin['usage']!='input':continue + raw=(ROOT/pin['path']).read_bytes() + need(hashlib.sha256(raw).hexdigest()==pin['sha256'],'source hash '+pin['path']) + need(hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==pin['git_blob'],'source Git blob') + data[pin['path']]=raw + for pin in parse((HERE/'PREDECESSORS.json').read_bytes())['retained_data']: + raw=(HERE/pin['local_path']).read_bytes() + need(hashlib.sha256(raw).hexdigest()==pin['sha256'],'retained source hash') + need(hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==pin['git_blob'],'retained Git blob') + return data + +def load_template(raw): + with tarfile.open(fileobj=io.BytesIO(raw),mode='r:gz') as archive: + members=[m for m in archive.getmembers() if m.name==MEMBER] + need(len(members)==1 and members[0].isfile(),'unique source member') + blob=archive.extractfile(members[0]).read() + need(hashlib.sha256(blob).hexdigest()==MEMBER_SHA,'template member hash') + return parse(gzip.decompress(blob)) + +def flatten(seq): + for e in seq: + if e[0] in ('private_sweep','cover_sweep'):yield from flatten(e[2]) + else:yield e + +def producer(packet): + for word in packet['core_words'].values(): + need(not any(e[0]=='center' for e in word),'already removed centre') + need(dict(Counter(e[5] for e in word if e[0]=='climb'))==CORE,'literal core profile') + rows=[] + for stage,name in enumerate(CASES): + ev=list(flatten(packet['programs'][name]));counts=Counter(e[0] for e in ev) + retained=[e for e in ev if e[0]=='retained_core'] + need(len(retained)==1 and retained[0][1]==('backward' if stage%2 else 'forward'),'core orientation') + lines=[e for e in ev if e[0]=='native_line'] + for e in lines: + r=packet['native_line_recipes'][e[2]] + need(r['rank']==r['recipe']['rank']==1,'native line rank') + profile=dict(CORE);profile[1]+=len(lines) + rows.append({'stage':stage,'pair':PAIRS[stage],'case':name,'orientation':retained[0][1], + 'added_H1':len(lines),'profile':profile,'outside_core_events':dict(sorted(counts.items()))}) + need(sum(x['added_H1'] for x in rows)==136,'nine-stage line total') + return rows + +def schedule(template,packet): + events=template['execution_schedule'];calls=template['calls'];order=template['async_schedule']['order'] + need(template['live']==14336 and template['replica_lift']['replicas']==16,'family/replica source') + need(template['physical']==14826,'selected physical capacity') + need(len(calls)==144 and len(events)==482,'complete schedule dimensions') + need([[c['stage'],c['replica']] for c in calls]==order,'call order binding') + need({(c['replica'],c['stage']) for c in calls}=={(r,s) for r in range(16) for s in range(9)},'unique replica-stage incidence') + need([c['time'] for c in calls]==list(range(144)),'serial complete call times') + need(all(c['provider_id']=='gauge44' for c in calls),'actual provider unchanged') + local=[(i,e) for i,e in enumerate(events) if e['kind']=='local_cover_sweep'] + need([(e['replica'],e['stage'],e['time']) for i,e in local]==[(c['replica'],c['stage'],c['time']) for c in calls],'physical local inventory') + need(dict(Counter(e['kind'] for e in events))=={'local_cover_sweep':144,'idle_cover_sweep':160,'bridge':144,'terminal_Y_translations':16,'terminal':16,'bank_padding_cover_sweep':1,'translate_every_live_family':1},'physical event grammar') + need(template['cover_final_correction']['families']==[0,14336],'productive family boundary') + stages=[] + for s in range(9): + subset=[c for c in calls if c['stage']==s] + for c in subset: + need(c['pair']==PAIRS[s] and c['orientation']==('backward' if s%2 else 'forward'),'actual local pair/orientation') + need(c['window']=={'local_axes':list(range(9)),'prefix_axes':list(range(9,9+8*s))},'actual stage frame window') + first=896*c['replica']+224*c['pair'] + need([x[0] for x in c['owners'][:224]]==list(range(first,first+224)),'actual active family map') + stages.append({'stage':s,'case_under_QQ16_substitution':CASES[s], 'count':len(subset),'pair':PAIRS[s], + 'completed_window_dimension':9+8*s,'source_provider':'gauge44'}) + cuts=[] + for i,e in local: + if e['stage']!=1:continue + r=e['replica'];tail=[(j,x) for j,x in enumerate(events) if j>i and x.get('replica')==r] + j,idle=tail[0];k,bridge=tail[1] + need(idle['kind']=='idle_cover_sweep' and idle['pair']==1 and idle['source_event']==2,'first postcut idle') + need(bridge['kind']=='bridge' and (bridge['src'],bridge['dst'],bridge['coefficient'])==(1,0,1),'first demanded current-bank read') + f2=next(j for j,x in tail if x['kind']=='local_cover_sweep' and x['stage']==2) + terminal=next(j for j,x in tail if x['kind']=='terminal') + cuts.append({'replica':r,'call_time':e['time'],'after_schedule_index':i,'next_idle_index':j, + 'next_bridge_index':k,'next_F2_index':f2,'terminal_index':terminal, + 'borrowed_Y_family_interval':[896*r+112,896*r+224], + 'next_bridge_Ydst_ordinary_families':[896*r+112+p for p in packet['U_ports']], + 'literal_projected_output_consumer':None, + 'missing_binding':'provider gauge44 must first be replaced/connected to QQ16; bridge reads current Y2_U, not a fresh y1_U output bank'}) + need(len(cuts)==16,'stage1 cut count') + def retention(endkey): + changes=[] + for c in cuts:changes.extend([(2*c['after_schedule_index']+1,96),(2*c[endkey],-96)]) + live=peak=0 + for _,d in sorted(changes):live+=d;peak=max(peak,live) + need(live==0,'retention balance') + return {'capture_instances':16,'output_bank_instances':1536,'peak_retained_output_fields':peak, + 'scope':'hypothetical logical retention only; no allocation/hosting or consumer admitted'} + return {'physical_event_counts':dict(sorted(Counter(e['kind'] for e in events).items())), + 'stages':stages,'stage1_insertion_sites':cuts,'source_aligned_site_rate':'1/9', + 'literal_projection_invocations':0,'all_backward_sites':64, + 'retention_sensitivities':{'until_next_F2':retention('next_F2_index'),'until_replica_terminal':retention('terminal_index')}, + 'actual_live_families':14336,'actual_physical_families':14826,'productive_families_per_replica':896, + 'first_missing_provider_event':{'schedule_index':0,'provider':'gauge44','proposed_case':'F_0'}} + +def projection_invoice(word,U): + counts=Counter(e[0] for e in word) + reads={e[2] for e in word if e[0]=='add' and isinstance(e[2],str) and e[2].startswith(('X','Y'))} + need(reads=={'Y'+str(p) for p in range(112)},'all112 current Y and no X reads') + owned={'W'+str(p) for p in range(112)} + first={} + for i,e in enumerate(word): + if e[0] in ('clear','add','line','map') and e[1] in owned:first.setdefault(e[1],(i,e)) + need(all(e[0]=='clear' for i,e in first.values()) and len(first)==112,'owned dirt erased before use') + for name,(cut,_) in first.items(): + need(not any(e[0]=='add' and e[2]==name for e in word[:cut]),'owned dirt read before clear') + need(counts['line']==112 and counts['map']==208 and counts['clear']==144,'projection local invoice') + unit=sum(e[0]=='add' and abs(Q(e[3]))==1 for e in word) + quarter=sum(e[0]=='add' and abs(Q(e[3]))==Q(1,4) for e in word) + need((unit,quarter)==(560,384),'projection scalar counts') + return {'per_invocation':{'H1':112,'native_wrappers':224,'maps':208,'unit_ADD':unit,'quarter_ADD':quarter,'CLEAR':144,'scalar_allowance':8*unit+12*quarter+288}, + '16_site_total':{'H1':1792,'native_wrappers':3584,'maps':3328,'scalar_allowance':150016}, + 'owned_output_fields_per_site':96,'owned_temporary_fields_per_site':16,'private_scratch_per_site':8, + 'productive_extension_control':{'owned_dirt_basis_field':'W'+str(U[0]),'first_event_index':first['W'+str(U[0])][0], + 'initial_dirt_erased':True,'interpretation':'Appending these output slots does not satisfy the selected arbitrary productive-input family contract; a different zero-input supplier theorem would need new coverage.'}} + +def calculate(): + data=sources();template=load_template(data['research/community-frontier1042-audit/selected-replay.tar.gz']) + packet=parse(gzip.decompress(data['research/joint-query/certificate.json.gz'])) + rows=producer(packet);ledger=schedule(template,packet) + word=parse((HERE/'vendor/pr3952/WORD.json').read_bytes());invoice=projection_invoice(word,packet['U_ports']) + module=types.ModuleType('arithmetic');path=HERE/'arithmetic.py' + exec(compile(path.read_bytes(),str(path),'exec'),module.__dict__) + selected=parse(data['certificates/selected-result.json']);kappa=Q(selected['kappa']) + a=kappa/(1-kappa) + profile=Counter() + for row in rows: + for r,n in row['profile'].items():profile[r]+=16*n + screens=module.screens(dict(profile),a,144,14336,16) + ceiling=parse(data['research/complex-local-word-ceiling/RESULT.json']) + need(ceiling['model']['centre_per_call']==64 and ceiling['model']['live_families_per_call']=='896/9','conditional coverage source') + return {'status':'PASS_QQ16_INTEGER_CONSUMER_INCIDENCE no_new_kappa','canonical_main':BASE, + 'template_member':{'path':MEMBER,'sha256':MEMBER_SHA},'producer_stage_profiles':rows, + 'complete_producer_profile_144':dict(sorted(profile.items())), + 'producer_mean_H1':str(Q(profile[1],144)), 'schedule_ledger':ledger,'projection_invoice':invoice, + 'conditional_screens':screens, + 'decision':'The proposed once-per-stage1-cut placement has16sites/144calls, not72/144. It is not an actual admitted consumer schedule: selected provider and downstream read/type binding are missing. One-stage1-module full336 budget passes the conditional fixed-coverage relaxation; the older pair-rate rejection does not transport. No displaced idle credit or productive family extension is proved.'} + +def main(): + p=argparse.ArgumentParser();p.add_argument('--emit',action='store_true');args=p.parse_args() + result=calculate() + if args.emit:print(json.dumps(result,indent=2,sort_keys=True)) + else: + need(canonical(result)==canonical(parse((HERE/'RESULT.json').read_bytes())),'complete typed RESULT mismatch') + print(result['status']) +if __name__=='__main__':main()