From 0b082d22a0e9a442d264ab0633e35ef26c790630 Mon Sep 17 00:00:00 2001 From: Chris R <22630354+Clear1nsight@users.noreply.github.com> Date: Tue, 20 Oct 2026 15:39:36 +1100 Subject: [PATCH] Install the source-bound QQ16 caller and retain complete child protocol costs --- research/qq16-caller-install/ADMISSION.json | 85 +++ research/qq16-caller-install/BILL.json | 430 ++++++++++++++ research/qq16-caller-install/COMPILATION.json | 270 +++++++++ research/qq16-caller-install/CONTINUATION.md | 173 ++++++ research/qq16-caller-install/COST.md | 503 ++++++++++++++++ research/qq16-caller-install/DECODER.md | 131 +++++ research/qq16-caller-install/EXECUTION.json | 390 +++++++++++++ research/qq16-caller-install/LIFECYCLE.md | 298 ++++++++++ research/qq16-caller-install/PACKET.md | 280 +++++++++ .../qq16-caller-install/PREDECESSORS.json | 159 ++++++ research/qq16-caller-install/PRODUCER.md | 222 ++++++++ research/qq16-caller-install/PROOF.md | 276 +++++++++ research/qq16-caller-install/README.md | 79 +++ research/qq16-caller-install/RESULT.json | 297 ++++++++++ research/qq16-caller-install/REUSE.json | 86 +++ research/qq16-caller-install/REVIEW.json | 39 ++ research/qq16-caller-install/SOURCES.json | 493 ++++++++++++++++ research/qq16-caller-install/TASK.json | 105 ++++ research/qq16-caller-install/VERIFY.json | 110 ++++ research/qq16-caller-install/auth.py | 36 ++ research/qq16-caller-install/connection.py | 62 ++ research/qq16-caller-install/continuation.py | 172 ++++++ research/qq16-caller-install/cost.py | 406 +++++++++++++ .../qq16-caller-install/decoder-fixture.py | 161 ++++++ research/qq16-caller-install/decoder.py | 301 ++++++++++ .../inputs/PR3055-PROOF.md | 334 +++++++++++ .../inputs/PR3380-PROOF.md | 168 ++++++ .../inputs/PR3464-PROOF.md | 227 ++++++++ .../inputs/PR3464-bank_packets.py | 194 +++++++ .../inputs/PR3464-machine.py | 477 ++++++++++++++++ .../inputs/PR3464-parking.py | 132 +++++ .../inputs/PR3464-selected_binding.py | 239 ++++++++ .../inputs/PR3607-PROOF.md | 264 +++++++++ .../inputs/PR3619-PROOF.md | 269 +++++++++ .../inputs/PR3993-PROOF.md | 85 +++ .../inputs/PR4106-WORD.json | 1 + .../inputs/PR4114-README.md | 94 +++ .../qq16-caller-install/inputs/PR4129-COST.md | 273 +++++++++ .../inputs/PR4129-NATIVE.md | 195 +++++++ .../inputs/PR4129-PREDECESSORS.json | 54 ++ .../inputs/PR4129-PROOF.md | 302 ++++++++++ .../inputs/PR4129-README.md | 102 ++++ .../inputs/PR4129-RESULT.json | 399 +++++++++++++ .../inputs/PR4129-SOURCES.json | 330 +++++++++++ .../inputs/PR4129-TASK.json | 158 ++++++ .../inputs/PR4129-bridge.py | 114 ++++ .../inputs/PR4129-construction.py | 224 ++++++++ research/qq16-caller-install/installer.py | 186 ++++++ .../qq16-caller-install/integrated-fixture.py | 286 ++++++++++ research/qq16-caller-install/lifecycle.py | 537 ++++++++++++++++++ research/qq16-caller-install/packet.py | 420 ++++++++++++++ research/qq16-caller-install/physical.py | 20 + .../qq16-caller-install/producer-fixture.py | 240 ++++++++ research/qq16-caller-install/producer.py | 478 ++++++++++++++++ research/qq16-caller-install/runtime.py | 42 ++ research/qq16-caller-install/test_verify.py | 73 +++ research/qq16-caller-install/verify.py | 114 ++++ 57 files changed, 12595 insertions(+) create mode 100644 research/qq16-caller-install/ADMISSION.json create mode 100644 research/qq16-caller-install/BILL.json create mode 100644 research/qq16-caller-install/COMPILATION.json create mode 100644 research/qq16-caller-install/CONTINUATION.md create mode 100644 research/qq16-caller-install/COST.md create mode 100644 research/qq16-caller-install/DECODER.md create mode 100644 research/qq16-caller-install/EXECUTION.json create mode 100644 research/qq16-caller-install/LIFECYCLE.md create mode 100644 research/qq16-caller-install/PACKET.md create mode 100644 research/qq16-caller-install/PREDECESSORS.json create mode 100644 research/qq16-caller-install/PRODUCER.md create mode 100644 research/qq16-caller-install/PROOF.md create mode 100644 research/qq16-caller-install/README.md create mode 100644 research/qq16-caller-install/RESULT.json create mode 100644 research/qq16-caller-install/REUSE.json create mode 100644 research/qq16-caller-install/REVIEW.json create mode 100644 research/qq16-caller-install/SOURCES.json create mode 100644 research/qq16-caller-install/TASK.json create mode 100644 research/qq16-caller-install/VERIFY.json create mode 100644 research/qq16-caller-install/auth.py create mode 100644 research/qq16-caller-install/connection.py create mode 100644 research/qq16-caller-install/continuation.py create mode 100644 research/qq16-caller-install/cost.py create mode 100644 research/qq16-caller-install/decoder-fixture.py create mode 100644 research/qq16-caller-install/decoder.py create mode 100644 research/qq16-caller-install/inputs/PR3055-PROOF.md create mode 100644 research/qq16-caller-install/inputs/PR3380-PROOF.md create mode 100644 research/qq16-caller-install/inputs/PR3464-PROOF.md create mode 100644 research/qq16-caller-install/inputs/PR3464-bank_packets.py create mode 100644 research/qq16-caller-install/inputs/PR3464-machine.py create mode 100644 research/qq16-caller-install/inputs/PR3464-parking.py create mode 100644 research/qq16-caller-install/inputs/PR3464-selected_binding.py create mode 100644 research/qq16-caller-install/inputs/PR3607-PROOF.md create mode 100644 research/qq16-caller-install/inputs/PR3619-PROOF.md create mode 100644 research/qq16-caller-install/inputs/PR3993-PROOF.md create mode 100644 research/qq16-caller-install/inputs/PR4106-WORD.json create mode 100644 research/qq16-caller-install/inputs/PR4114-README.md create mode 100644 research/qq16-caller-install/inputs/PR4129-COST.md create mode 100644 research/qq16-caller-install/inputs/PR4129-NATIVE.md create mode 100644 research/qq16-caller-install/inputs/PR4129-PREDECESSORS.json create mode 100644 research/qq16-caller-install/inputs/PR4129-PROOF.md create mode 100644 research/qq16-caller-install/inputs/PR4129-README.md create mode 100644 research/qq16-caller-install/inputs/PR4129-RESULT.json create mode 100644 research/qq16-caller-install/inputs/PR4129-SOURCES.json create mode 100644 research/qq16-caller-install/inputs/PR4129-TASK.json create mode 100644 research/qq16-caller-install/inputs/PR4129-bridge.py create mode 100644 research/qq16-caller-install/inputs/PR4129-construction.py create mode 100644 research/qq16-caller-install/installer.py create mode 100644 research/qq16-caller-install/integrated-fixture.py create mode 100644 research/qq16-caller-install/lifecycle.py create mode 100644 research/qq16-caller-install/packet.py create mode 100644 research/qq16-caller-install/physical.py create mode 100644 research/qq16-caller-install/producer-fixture.py create mode 100644 research/qq16-caller-install/producer.py create mode 100644 research/qq16-caller-install/runtime.py create mode 100644 research/qq16-caller-install/test_verify.py create mode 100644 research/qq16-caller-install/verify.py diff --git a/research/qq16-caller-install/ADMISSION.json b/research/qq16-caller-install/ADMISSION.json new file mode 100644 index 0000000000..804c010ce8 --- /dev/null +++ b/research/qq16-caller-install/ADMISSION.json @@ -0,0 +1,85 @@ +{ + "schema_version": 1, + "domain": "PROOF.md statement; actual admitted nonleaf root cut, arbitrary source-admitted nonconstant/dirty payload", + "items": [ + { + "item": "producer", + "source": "PRODUCER.md;producer.py:ProducerBinding", + "obligation": "Actual first0/4 words, all-owner barriers, helper native endpoints, events1\u20133 isolation", + "check": "full selected compiler/helper replay + nonsymmetric physical router", + "cost": "32C1 + outer scalar/maps/full bank scans", + "status": "new conditional source-bound discharge" + }, + { + "item": "acquisition", + "source": "PACKET.md;packet.py:compile_global", + "obligation": "actual full fields, encoded14 descriptors, stock, unchanged passive/address/physical width", + "check": "actual source gather/compiler/prepare_child/return; descriptor and stock controls", + "cost": "full parent scan + Count arithmetic, field validation,78tapes", + "status": "new encoded implementation; inherited root stock" + }, + { + "item": "native", + "source": "inputs/PR4129-NATIVE.md;decoder.py", + "obligation": "all224signed recipes and112negative current-return lines with actual original C", + "check": "all73Drecipe/source bindings + both signed physical C fixtures", + "cost": "336C1 +1344line monomials, exclusive original inventory", + "status": "inherited exact C refinement; newly connected calls" + }, + { + "item": "numbers", + "source": "COST.md;cost.py", + "obligation": "fine q_s/H_b, full producer dirty range/debt and unfinished reserve", + "check": "literal46body sum, exact all-parameter inequality + rejection controls", + "cost": "retain actual H_b; no coarse conversions credited", + "status": "new sufficient one-cut bound conditional on source entry/native" + }, + { + "item": "inventory", + "source": "LIFECYCLE.md;installer.py", + "obligation": "dedicated224/16 + separate3Ordinary/Machine inventories, no active reentry", + "check": "fixed-role census, aliases/dirty/private/engine boundary controls", + "cost": "3I+2^20 plus unchanged root/ancestors; backing separately paid", + "status": "new installation; inherited engines/parking" + }, + { + "item": "current", + "source": "CONTINUATION.md;continuation.py", + "obligation": "G=(-y,x+y), same-port owners, F17 and negative Y gauge; bothbridge legs", + "check": "full selected shadows, all224columns, owner-varying tests; continuous native fixture", + "cost": "224unitADD +112C1 and448line monomials", + "status": "new current reconstruction conditional on source lift" + }, + { + "item": "return", + "source": "LIFECYCLE.md;lifecycle.py", + "obligation": "preflight224outputs, all bindings, immutable public ports, private/old backing retirement", + "check": "full224storage +2generation continuous chain; adoption counters/parking controls", + "cost": "224transfers, full scatter,9B+26adopt plus c_R and cleanup", + "status": "new physical-role adaptation of3380;3464premises inherited" + }, + { + "item": "cost", + "source": "COST.md;BILL.json", + "obligation": "same-boundary operation sum and recursivefrequency", + "check": "compiled census vs independent cost; exact matched publication difference", + "cost": "all terms retained;368C1vs16C8screen", + "status": "complete local operation-sum bill plus full-root protocol census; isolated native profile fails, overall physical dominance unresolved" + }, + { + "item": "recursive_scope", + "source": "PROOF.md;connection.py", + "obligation": "once at nonleaf modified root; unchanged original C descendants", + "check": "actual child backend split/closed protocol; reduced multiple generations", + "cost": "one local interval, all descendant C invoices unchanged", + "status": "new local construction; all-node substitution deferred" + } + ], + "open": [ + "Inherited native/common-label/hosting/ordinary/Compact/long-record premises", + "Production payload/full RootLayer.run not executed", + "No affordable supplier or changed exponent", + "No all-node modified recursive substitution", + "Whole physical dominance unresolved: all changed root child-call protocols, including493097Gamma suffix calls, explicitly retained in the symbolic bill." + ] +} diff --git a/research/qq16-caller-install/BILL.json b/research/qq16-caller-install/BILL.json new file mode 100644 index 0000000000..674b8493d8 --- /dev/null +++ b/research/qq16-caller-install/BILL.json @@ -0,0 +1,430 @@ +{ + "bank_volumes": { + "original_parent_B": "14336*V", + "owner_packet_v": "P*U*row_bits", + "service_protected_return": "448*V", + "service_source_S": "448*V", + "whole_family_V": "Gamma*v" + }, + "coefficient_unit": "Multiply producer_outer and decoder_service occurrence coefficients by Gamma. Publication executes once per reached global service fence; B already includes the complete cover.", + "decoder_service": { + "ADD_scalar_calls": 2940, + "all_gather_scatter_commit_groups": 2022, + "all_monomial_calls_including_map_translations": 1696, + "direct_dispatch_excludes_exchange_internal": true, + "exchange_charge_note": "Each source exchange_step has one internal ScalarEngine negation plus transfers; these are included in T_exchange, not in the direct-dispatch3484 or charged a second time.", + "exchange_internal_scalar_calls": 176, + "intrinsic_wrappers": 672, + "map_router": { + "direct_dispatch_excludes_exchange_internal": true, + "exchange_internal_scalar_negations_per_Gamma": "176", + "extra_sign_scales_per_Gamma": "176", + "gather_scatter_commit_groups_per_Gamma": "176", + "maps": 352, + "orders": { + "2": 352 + }, + "owner_control_visits_per_Gamma": 352, + "scope": "Full-bank scans per emitted cycle. T_exchange includes its internal ScalarEngine negation and transfers; extra sign scale is an additional direct scalar dispatch. Do not charge the nested negation twice.", + "source_exchanges_per_Gamma": "176", + "translation_monomials_per_Gamma": 352 + }, + "nonmap_groups": 1846, + "owner_basis_monomials": 672, + "physical_line_monomials": 1344, + "private_zero_calls": 48, + "public_CLEAR_scalar_calls": 368, + "rank_one_children": 336, + "scalar_engine_calls_including_map_sign_corrections": 3484 + }, + "inventory": "Existing modified producer Machine, separate decoder Machine, separate original recursive C Machine, plus acquisition/compiler/service roles. Separate Ordinary instances and protected-return backing are charged.", + "logical": { + "current_reconnection_bound": { + "denominator_bits": 0, + "derivation": "W+=Z gives at most2M; Z-=W prefix at most3M<4M, exact endpoint -oldW.", + "growth_bits": 2 + }, + "decoder": { + "clear": 416, + "map": 352, + "native_rank_one": 224, + "quarter_add": 896, + "scalar_allowance": 26144, + "unit_add": 1820, + "wrapper": 448 + }, + "native_screen": { + "added_rank_one": 368, + "added_width_sum_over_lambda": 368, + "formula": "(added - removed*8**(1-alpha))*73**(alpha-1)", + "minimum_added_over_removed_charge_alpha_0_to_1": "23/8", + "positive_charge_difference_at_alpha_0_over_lambda": 240, + "ratio_at_alpha_1": "23", + "removed_rank_eight": 16, + "removed_width_sum_over_lambda": 128, + "scope": "Isolated same-volume homogeneous native-component tariff, alpha in [0,1]. Does not reject whole-connection affordability: changed retained-root protocols may supply compensating credit. No runtime lower bound or exponent claim.", + "zero_native_repair_added_rank_one": 256, + "zero_native_repair_deficit_alpha_0": 128 + }, + "reconnection": { + "affine_port_map": 0, + "bridge_legs_retained": 2, + "clear": 0, + "fixed_port_copyback": 224, + "native_rank_one": 112, + "native_wrapper": 224, + "owner_basis_monomial": 224, + "physical_line_monomial": 448, + "quarter_scale": 0, + "scalar_microinstructions_shear_only": 672, + "scope": "Actual G=(-y,x+y): W+=Z; Z-=W. Endpoint requires source lift and owner/frame proof. Copyback, disposal, bridge and routing priced separately.", + "unit_add": 224 + }, + "recovery_and_reconnection": { + "clear": 416, + "maps": 352, + "native_rank_one": 336, + "native_wrapper": 672, + "owner_basis_monomial": 672, + "physical_line_monomial": 1344, + "quarter_add": 896, + "quarter_scale": 0, + "scalar_allowance": 27936, + "scalar_microinstructions_before_copyback": 11028, + "unit_add": 2044 + }, + "same_boundary_difference": "Compare N_inst + sum_root_inst(P_inst + A_external + Run_C_external + Z_external) + T_service against N_base + sum_root_base(P_base + E_embedded + C_embedded + R_embedded). Apply at entry-through-bridge first, and retain the later-root protocol delta separately. Do not cancel retained children or their C execution contexts from equal ranks or outputs. Only the fixed/adopted variants of the same installation have the proved role-equivariant publication cancellation.", + "separately_charged_source_tariff_terms": [ + "encoded descriptor work", + "actual C calls at each packet geometry", + "ordinary map/wrapper work", + "output fixed-port movement and disposal", + "private/engine inventory", + "long-record setup outside inherited rate domain" + ] + }, + "numerical_controls": [ + { + "Delta_bit_length": 210007, + "admitted": true, + "bridge_growth_bits": 1, + "debt_strictly_below_Delta": true, + "grid": "2**(-p-Delta)", + "growth_strictly_below_Delta": true, + "lambda": 1, + "maximum_debt_bit_length": 100008, + "maximum_growth_bit_length": 100008, + "physical_component_bits": "p+2*Delta+3", + "producer_denominator_bits": 112256, + "producer_growth_bits": 257958, + "root_width": 73, + "scope": "Conditional all-size arithmetic admission at unchanged source entry. Physical lowering, producer correctness, long records and original source height theorem remain premises." + }, + { + "Delta_bit_length": 210008, + "admitted": true, + "bridge_growth_bits": 1, + "debt_strictly_below_Delta": true, + "grid": "2**(-p-Delta)", + "growth_strictly_below_Delta": true, + "lambda": 2, + "maximum_debt_bit_length": 100009, + "maximum_growth_bit_length": 100009, + "physical_component_bits": "p+2*Delta+3", + "producer_denominator_bits": 140090, + "producer_growth_bits": 285792, + "root_width": 146, + "scope": "Conditional all-size arithmetic admission at unchanged source entry. Physical lowering, producer correctness, long records and original source height theorem remain premises." + }, + { + "Delta_bit_length": 210010, + "admitted": true, + "bridge_growth_bits": 1, + "debt_strictly_below_Delta": true, + "grid": "2**(-p-Delta)", + "growth_strictly_below_Delta": true, + "lambda": 8, + "maximum_debt_bit_length": 100011, + "maximum_growth_bit_length": 100011, + "physical_component_bits": "p+2*Delta+3", + "producer_denominator_bits": 307094, + "producer_growth_bits": 452796, + "root_width": 584, + "scope": "Conditional all-size arithmetic admission at unchanged source entry. Physical lowering, producer correctness, long records and original source height theorem remain premises." + }, + { + "Delta_bit_length": 210013, + "admitted": true, + "bridge_growth_bits": 1, + "debt_strictly_below_Delta": true, + "grid": "2**(-p-Delta)", + "growth_strictly_below_Delta": true, + "lambda": 73, + "maximum_debt_bit_length": 100014, + "maximum_growth_bit_length": 100014, + "physical_component_bits": "p+2*Delta+3", + "producer_denominator_bits": 2116304, + "producer_growth_bits": 2262006, + "root_width": 5329, + "scope": "Conditional all-size arithmetic admission at unchanged source entry. Physical lowering, producer correctness, long records and original source height theorem remain premises." + } + ], + "paid_service_boundaries": [ + "P-dependent assembly of224borrowed family fields plus initialization224owned zero fields", + "service Machine.run source copy, encoded node setup, every group full-service-bank scan", + "service protected return; compare all224borrowed fields; extract224owned fields", + "erase service assembly bank and protected return", + "224 fixed-destination transfers plus parent full-bank scatter/adopt/release; original fixed-copy commit retained as matched alternative" + ], + "producer_outer": { + "SCALE": 16, + "all_gather_scatter_commit_groups": "14479/51", + "intrinsic_wrappers": 64, + "map_router": { + "direct_dispatch_excludes_exchange_internal": true, + "exchange_internal_scalar_negations_per_Gamma": "14642/51", + "extra_sign_scales_per_Gamma": "14642/51", + "gather_scatter_commit_groups_per_Gamma": "12286/51", + "maps": 528, + "orders": { + "2": 464, + "5": 24, + "6": 12, + "12": 20, + "17": 4, + "20": 4 + }, + "owner_control_visits_per_Gamma": 528, + "scope": "Full-bank scans per emitted cycle. T_exchange includes its internal ScalarEngine negation and transfers; extra sign scale is an additional direct scalar dispatch. Do not charge the nested negation twice.", + "source_exchanges_per_Gamma": "14642/51", + "translation_monomials_per_Gamma": 528 + }, + "nonmap_groups": 43, + "original_replaced_group_coefficient": 2, + "owner_basis_monomials": 64, + "physical_line_monomials": 128, + "private_CLEAR": 32, + "rank_one_children": 32, + "unit_or_other_ADD": 2200 + }, + "publication_controls": [ + { + "adopted_commit": { + "moves": 18, + "reads": 15, + "writes": 2 + }, + "bank_bits": 1, + "complete_comparison": "T_install_adopt = T_install_fixed - (11B+4) + c_R", + "finite_control_charge": "c_R additional to tape actions", + "fixed_commit": { + "moves": 24, + "reads": 22, + "writes": 4 + }, + "saved_cell_actions": 15, + "saved_cell_actions_by_kind": { + "moves": 6, + "reads": 7, + "writes": 2 + }, + "scope": "Same read-complete/scattered state and same continuation, fixed public ports, all internal current bindings updated. No source arithmetic credit." + }, + { + "adopted_commit": { + "moves": 22, + "reads": 19, + "writes": 3 + }, + "bank_bits": 2, + "complete_comparison": "T_install_adopt = T_install_fixed - (11B+4) + c_R", + "finite_control_charge": "c_R additional to tape actions", + "fixed_commit": { + "moves": 32, + "reads": 31, + "writes": 7 + }, + "saved_cell_actions": 26, + "saved_cell_actions_by_kind": { + "moves": 10, + "reads": 12, + "writes": 4 + }, + "scope": "Same read-complete/scattered state and same continuation, fixed public ports, all internal current bindings updated. No source arithmetic credit." + }, + { + "adopted_commit": { + "moves": 38, + "reads": 35, + "writes": 7 + }, + "bank_bits": 6, + "complete_comparison": "T_install_adopt = T_install_fixed - (11B+4) + c_R", + "finite_control_charge": "c_R additional to tape actions", + "fixed_commit": { + "moves": 64, + "reads": 67, + "writes": 19 + }, + "saved_cell_actions": 70, + "saved_cell_actions_by_kind": { + "moves": 26, + "reads": 32, + "writes": 12 + }, + "scope": "Same read-complete/scattered state and same continuation, fixed public ports, all internal current bindings updated. No source arithmetic credit." + }, + { + "adopted_commit": { + "moves": 86, + "reads": 83, + "writes": 19 + }, + "bank_bits": 18, + "complete_comparison": "T_install_adopt = T_install_fixed - (11B+4) + c_R", + "finite_control_charge": "c_R additional to tape actions", + "fixed_commit": { + "moves": 160, + "reads": 175, + "writes": 55 + }, + "saved_cell_actions": 202, + "saved_cell_actions_by_kind": { + "moves": 74, + "reads": 92, + "writes": 36 + }, + "scope": "Same read-complete/scattered state and same continuation, fixed public ports, all internal current bindings updated. No source arithmetic credit." + }, + { + "adopted_commit": { + "moves": 278, + "reads": 275, + "writes": 67 + }, + "bank_bits": 66, + "complete_comparison": "T_install_adopt = T_install_fixed - (11B+4) + c_R", + "finite_control_charge": "c_R additional to tape actions", + "fixed_commit": { + "moves": 544, + "reads": 607, + "writes": 199 + }, + "saved_cell_actions": 730, + "saved_cell_actions_by_kind": { + "moves": 266, + "reads": 332, + "writes": 132 + }, + "scope": "Same read-complete/scattered state and same continuation, fixed public ports, all internal current bindings updated. No source arithmetic credit." + }, + { + "adopted_commit": { + "moves": 4000014, + "reads": 4000011, + "writes": 1000001 + }, + "bank_bits": 1000000, + "complete_comparison": "T_install_adopt = T_install_fixed - (11B+4) + c_R", + "finite_control_charge": "c_R additional to tape actions", + "fixed_commit": { + "moves": 8000016, + "reads": 9000013, + "writes": 3000001 + }, + "saved_cell_actions": 11000004, + "saved_cell_actions_by_kind": { + "moves": 4000002, + "reads": 5000002, + "writes": 2000000 + }, + "scope": "Same read-complete/scattered state and same continuation, fixed public ports, all internal current bindings updated. No source arithmetic credit." + } + ], + "rejection_controls": [ + "missing native occurrence", + "unsupported scalar tariff", + "unknown decoder operation", + "under-counted native screen", + "parent narrower than prepared rank-one domain", + "non-dyadic producer arithmetic", + "insufficient physical range" + ], + "scope": "Constructive operation-sum invoice. Source authentication, map-order/census binding and exact operator refinement are required. No elapsed runtime claim.", + "selected_publication": { + "adopt_cell_actions": "9B+26", + "fixed_commit_cell_actions": "20B+30", + "frequency": "once per completed global installation", + "matched_cell_action_saving": "11B+4", + "protocol": "whole-bank adoption", + "saving_with_additional_finite_control": "11B+4-c_R", + "scope": "Matched publication implementations only; all other local installation work identical. No original QQ16 arithmetic or kappa credit." + }, + "service_assembly_extract_bound": "4096*(S+448P*(bE+1)+bP+D_service+1)", + "uniform_source_grid_proof": { + "debt_constant": 84422, + "debt_lambda_slope": 27834, + "growth_constant": 230124, + "growth_lambda_slope": 27834, + "maximum_child_rank": 8, + "programs": 46, + "scope": "Actual complete producer interval, per-owner source traversal with family/owner permutation proof; not just the largest one-group PC.", + "strict_margin": "4B+2**24 < 2**210000", + "uniform_height_bound": "2**22*(lambda+1)" + }, + "whole_root_child_protocol": { + "all_external_runs": 511014, + "baseline_prefix_calls": 17565, + "baseline_rank_counts": { + "1": 349604, + "2": 60192, + "3": 62585, + "4": 20448, + "5": 11808, + "7": 7, + "8": 1152, + "48": 4866 + }, + "baseline_root_calls": 510662, + "body_context_cancellation_proved": false, + "component_screen_only": true, + "embedded_call_operation_sum": [ + "P_b: prepare_child arithmetic, capsule payload and descriptor copies, encoded header, Count closure", + "E_b: primitive boundary and role origins, Parking.park on every live parked role, capsule-to-active transfers and child control setup", + "C_emb: actual original child node/body and recursive descendants in embedded nonroot context; excludes its final parent return", + "R_b: output transfer, active child role cleanup, Parking.restore, header read/clear, group reconstruction, output-to-parent target transfer and bank/head rebinding" + ], + "exact_execution_comparison": "N_i + sum_inst(P_i+A_i+Run_C_ext+Z_i) + T_service < N_b + sum_base(P_b+E_b+C_emb+R_b)", + "external_call_operation_sum": [ + "P_i: actual prepare_child arithmetic, capsule copies, encoded header and Count closure, with installed event indices", + "A_i: boundary/header/instruction checks and finite descriptor views", + "Run_C_ext: complete separate original Machine.run, borrowed input and descriptor copies, node setup, body/descendants, root protected return and engine closure", + "Z_i: protected output-to-target transfer, output-marker erase, all capsule and header cleanup and PC update" + ], + "installed_prefix_and_service_calls": 17917, + "installed_rank_counts": { + "1": 349636, + "2": 60192, + "3": 62585, + "4": 20448, + "5": 11808, + "7": 7, + "8": 1136, + "48": 4866 + }, + "installed_root_calls": 510678, + "later_obligation": "493097*Gamma changed root child protocols plus any later nonchild/control/context delta; retained source instructions alone do not cancel these costs.", + "later_root_calls_with_changed_protocol": 493097, + "next_discriminator": "Meter paired source embedded versus external child calls with actual live parent bank/descriptors/dirty backing and descendant context; then compare the constructive protocol credit against all added bank scans and service costs.", + "nonchild_operation_sum": [ + "N_b or N_i: root Machine.run input/descriptors/setup, all nonchild scalar/monomial/exchange and group bank operations, event/owner control, final root output/cleanup", + "N_i includes every installed finish_group fence predicate, including after the local continuation", + "T_service contains assembly/compiler/lifecycle, service nonchild Machine.run/setup/return, and all336 external service child sums exactly once" + ], + "retained_prefix_calls_with_changed_protocol": 17549, + "retained_protocol_credit": "sum_retained[(P_b+E_b+C_emb+R_b)-(P_i+A_i+Run_C_ext+Z_i)]", + "retained_root_calls_with_changed_protocol": 510646, + "service_external_calls": 336, + "unit": "Each occurrence coefficient multiplies Gamma at this one modified outer root; original recursive descendants are inside their C execution terms." + } +} diff --git a/research/qq16-caller-install/COMPILATION.json b/research/qq16-caller-install/COMPILATION.json new file mode 100644 index 0000000000..a9f8017f06 --- /dev/null +++ b/research/qq16-caller-install/COMPILATION.json @@ -0,0 +1,270 @@ +{ + "all336_signed73D_recipe_sha256": "2bb68ec57c90cb55686488347f36dba0c99528ef38e39e1b6dcf4015028f0fa0", + "continuation": { + "all_data_columns": 224, + "all_port_frame_checks": 605248, + "census": { + "add": 224, + "line": 112 + }, + "complete_actual_caller_installation": false, + "inherited": [ + "actual selected common-label and exact unary refinement", + "actual DATA-PHASES external gauges and chronological hosting" + ], + "logical_endpoint": "(-y,x+y)", + "native_entry": "224 recovered originals in F17", + "native_exit": "X:F17; Y:F17 Cq^-1", + "owner_character_port_cases": 2240, + "positive_line_rejections": 624, + "private_fields": 0, + "remaining": [ + "actual QQ16 producer and full-cover scheduling", + "encoded packets and actual signed child execution", + "exclusive storage, fixed-port copyback and both-leg bridge" + ], + "source_word_events": { + "backward": 24767, + "forward": 24767 + }, + "status": "PASS_SELECTED_SHADOW_LIFT_AND_PHYSICAL_RECONSTRUCTION" + }, + "decoder": { + "compiled_identity_owner_census": { + "child": 336, + "exchange": 352, + "monomial": 2048, + "scalar": 3660, + "zero": 48 + }, + "compiled_identity_owner_sha256": "b06c390ade7d5f2223591553535eed13e608c31429dd608935ff5d9ae2185ecd", + "decoder_native_calls": 224, + "events": 2199, + "families": 448, + "literal_decoder_events": 3713, + "maximum_pc": 952, + "physical_per_cover": { + "all_gather_scatter_commit_groups": 2022, + "all_monomial_calls_including_map_translations": 1696, + "intrinsic_wrappers": 672, + "map_control_visits": 352, + "map_exchanges": 176, + "map_gather_scatter_commit_groups": 176, + "map_identity_leader_translation_monomials": 704, + "map_order_histogram": { + "2": 352 + }, + "map_sign_corrections": 176, + "map_translation_monomials": 352, + "nonmap_groups": 1846, + "owner_basis_monomials": 672, + "physical_line_monomials": 1344, + "private_zero_calls": 48, + "rank_one_children": 336, + "scalar_engine_calls_including_map_sign_corrections": 3484, + "unit": "per full cover divided by Gamma, except identity-leader translation diagnostic" + }, + "private": 16, + "private_words": 2, + "scope": "All finite signed occurrences and cover-barrier compiler; arithmetic correctness inherits authenticated D and source primitive refinements.", + "slots": 448, + "status": "PASS_FULL_COVER_DECODER_COMPILATION" + }, + "parent_return_byte_compatibility": { + "bank_packets.py": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "machine.py": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "parking.py": "33e6d2a6fcdc648de31b374132bf885259eec9748bafa6facca3822a78427e94", + "selected_binding.py": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985" + }, + "producer": { + "both_bridge_legs_bound": 112, + "expanded_events": 1051, + "global_fence_last_event": 573, + "helper_endpoint_common_label_checks": { + "backward": { + "normalized_helper_unit_rows": 480, + "persistent_final_labels": 704, + "persistent_native_sequences_identical": true, + "private_zero_returns": 8 + }, + "forward": { + "normalized_helper_unit_rows": 480, + "persistent_final_labels": 704, + "persistent_native_sequences_identical": true, + "private_zero_returns": 8 + } + }, + "idle_groups_exclude_pair0": 224, + "intervening_pair0_owner_intersections": { + "1": [], + "2": [], + "3": [] + }, + "map_groups_per_cover": "12286/51", + "map_orders": { + "2": 464, + "5": 24, + "6": 12, + "12": 20, + "17": 4, + "20": 4 + }, + "map_owner_control_visits_per_cover": 528, + "maximum_map_packet_slots": 20, + "nonmap_groups_per_cover": 43, + "outer_macro_counts": { + "native_line": 32, + "scalar:add": 2200, + "scalar:clear": 32, + "scalar:scale": 16 + }, + "plain_swaps_per_cover": "14642/51", + "root_child_census": { + "baseline_entry_through_bridge": { + "calls": 17565, + "rank_counts": { + "1": 12060, + "2": 2090, + "3": 2255, + "4": 710, + "5": 410, + "8": 40 + }, + "rank_mass": 28215 + }, + "baseline_events": 482, + "baseline_whole_root": { + "calls": 510662, + "rank_counts": { + "1": 349604, + "2": 60192, + "3": 62585, + "4": 20448, + "5": 11808, + "7": 7, + "8": 1152, + "48": 4866 + }, + "rank_mass": 1041408 + }, + "bridge_source_6": { + "calls": 0, + "rank_counts": {}, + "rank_mass": 0 + }, + "clean_retained_pair_cores": { + "calls": 6972, + "rank_counts": { + "1": 4824, + "2": 836, + "3": 864, + "4": 284, + "5": 164 + }, + "rank_mass": 11044 + }, + "idle_rank_dispatch_witnesses": 4, + "idle_source_5": { + "calls": 95, + "rank_counts": { + "3": 95 + }, + "rank_mass": 285 + }, + "installed_entry_through_bridge": { + "calls": 17581, + "rank_counts": { + "1": 12092, + "2": 2090, + "3": 2255, + "4": 710, + "5": 410, + "8": 24 + }, + "rank_mass": 28119 + }, + "installed_events": 1051, + "installed_whole_root": { + "calls": 510678, + "rank_counts": { + "1": 349636, + "2": 60192, + "3": 62585, + "4": 20448, + "5": 11808, + "7": 7, + "8": 1136, + "48": 4866 + }, + "rank_mass": 1041312 + }, + "intervening_source_1_3": { + "calls": 10482, + "rank_counts": { + "1": 7236, + "2": 1254, + "3": 1296, + "4": 426, + "5": 246, + "8": 24 + }, + "rank_mass": 16758 + }, + "original_pair_0_4": { + "calls": 6988, + "rank_counts": { + "1": 4824, + "2": 836, + "3": 864, + "4": 284, + "5": 164, + "8": 16 + }, + "rank_mass": 11172 + }, + "protocol_scope": "Every installed root child uses external-child transfer; same rank does not cancel differing parent protocols or packet contexts.", + "qq16_added_lines": { + "calls": 32, + "rank_counts": { + "1": 32 + }, + "rank_mass": 32 + }, + "removed_centres": { + "calls": 16, + "rank_counts": { + "8": 16 + }, + "rank_mass": 128 + }, + "retained_later_source_7_481": { + "calls": 493097, + "rank_counts": { + "1": 337544, + "2": 58102, + "3": 60330, + "4": 19738, + "5": 11398, + "7": 7, + "8": 1112, + "48": 4866 + }, + "rank_mass": 1013193 + }, + "source_event_kinds": { + "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 + }, + "units": "root child invocations per Gamma; service children separate" + }, + "scope": "Finite control and operator lowering; separate original recursive native endpoint required. No production payload execution.", + "source_events_retained": 480, + "status": "PASS_SOURCE_BOUND_PRODUCER_PLAN", + "translated_map_calls_per_cover": 528 + } +} diff --git a/research/qq16-caller-install/CONTINUATION.md b/research/qq16-caller-install/CONTINUATION.md new file mode 100644 index 0000000000..c3d5959ec2 --- /dev/null +++ b/research/qq16-caller-install/CONTINUATION.md @@ -0,0 +1,173 @@ +# Reconstruct the selected current endpoint in the recovered common frame + +This component provides a physical continuation word after the frozen decoder +has returned all original logical values in F17. It removes the need to compile +#4108's owner-routed query factor gate by gate. It is not, by itself, an actual +producer installation: the full-cover producer schedule, packet compiler, +exclusive output storage, completed-bank commit, and encoded child execution are +separate items in the integrated admission matrix. + +New derivation and compiler: Chris R / Clear1nsight with OpenAI Codex assistance. +The full source scalar-shadow replay uses the retained #4105 algorithm, with +its attribution preserved. The selected common-label/native lift is the +canonical Jose Manuel construction and its credited native and hosting lineage. +The decoder output contract and signed-line recipes remain those of +#3985/#4015/#4106/#4109/#4129 and their credited predecessors. Apache-2.0. + +## The actual selected endpoint and the needed hypothesis + +The selected source archive is +`research/community-frontier1042-audit/selected-replay.tar.gz`, SHA256 +`22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754`. +Its called words are `t16/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz`. +Its hosted template selects replica 0, pair 0 in calls[0] (forward stage 0) +and calls[4] (backward stage 1). They are execution events 0 and 4. The original +source work being replaced is those two complete local cover sweeps; events +1--3 remain in order. Event 5 is pair-1 idle preparation; event 6 is the named +bridge, with src=1, dst=0 and coefficient +1. + +`continuation.selected_shadow` replays all 712 independent scalar columns of +both actual 24,767-event selected words. It checks data shadows + + S_F(x,y) = (x,y+x), S_B(x,y) = (x-y,y), + +identity rows on 480 scalar helper coordinates, no helper/private dependence +in data outputs, and zero final private coordinates. This is a scalar result. +It does not assert that physical productive helpers undergo identity: their +native frame progress remains part of the retained source. + +The all-payload lift requires the retained exact unary/common-label invariant +in `research/selected-complex-layer-closure/PROOF.md`, section 2: + + Run_f = diag(T_out^tensor f) (S tensor I) diag(T_in^-tensor f). + +The native recipes, source endpoint adapters, and external DATA-PHASES gauges +must refer to these exact source words. This dependency is an inherited +scientific hypothesis, not a conclusion from the scalar replay or reduced +fixtures. In particular it must not be substituted by the centre-free +`BRIDGE-REVIEW.md` statement with shadow J=I-R^T R/4. That is a different word. + +At each stage the actual template gives the same owner route to X_p and Y_p, +namely [1,stage,p]. Because the selected data shadow only couples these two +same-port fields, conjugation by that owner route cancels, even when all owners +carry independent nonconstant arrays. The actual entry/exit translations +supply the stated external gauges under the retained DATA-PHASES identities. +Thus, conditional on that source-native binding, the selected pair acts on +logical coefficients as + + G(x,y)=(-y,x+y) + +at every port and owner, with final physical frames F17 on X and +F17 C_(d q_p)^-1 on Y. Tensoring keeps the scalar coefficients unchanged. +No map of the 712-coordinate state including private CLEARs is inverted. + +## Explicit new word + +The decoder returns owned Z_p=F17 x_p and W_p=F17 y_p. For each port execute + + W_p += Z_p; + Z_p -= W_p; + W_p <- C_(d q_p)^-1 W_p. + +The second ADD reads the updated W. The first two operations share exactly +one frame, so their required native transport is identity. They give +Z=-F17 y and W=F17(x+y). The final negative line produces the required +selected Y frame and value. F17 and the line commute because both are +convolutions. Each negative line uses #4129's actual recipe with translation +q fused in the left wrapper; replacing it by the positive line is invalid. + +The word is emitted for all 112 ports: 224 signed unit ADDs, 112 negative +rank-one native children and 224 native wrappers. There are no additional +quarter operations, owner maps, or private fields in this reconstruction. +Its input and output fields are the already-owned decoder outputs. The +backend and wrapper engine inventories remain separately closed and paid. +The scalar operations and native lines operate on complete current packets; +a host-language numeric oracle does not implement them. + +A discarded preliminary route used four J/J^-1 applications and then a +one-accumulator J shear. Besides extra work, it targeted the centre-free +endpoint rather than the selected pair. The current word uses neither +that endpoint substitution nor the odd division in J^-1. + +## Four boundaries and actual continuation + +1. Producer entry: the complete selected bank immediately before source + execution event 0, including arbitrary data, productive helper values, + encoded geometry, and the active caller's own scratch and control state. +2. Prepared recovery/native entry: after the actual QQ16 replacements of + events 0 and 4, with intervening source events retained. All current X/Y + fields have the prescribed completed frames; their packet descriptors and + 224-output/16-private exclusive lease have been installed and checked. +3. Completed recovery return: current QQ16 X/Y are preserved, all 224 owned + originals Z/W are in F17, local decoder scratch is closed, and actual native + engines have completed the original exact C endpoint at the admitted + physical width H_b and fine quantum q_s. The integrated full-interval + height and grid argument supplies this numerical admission. The selected + path performs no coarse downprojection; #4129's low-zero/sign-extension + projection remains a separate coarse-format variant. The new word + transforms Z/W into G's current endpoint. +4. Continuation exit: after charged output transfers and complete scatter, + completed-bank commit, retirement of owned Z/W, unchanged event 5 and both + scalar legs of actual event 6. Commit either copies to the original internal + current-bank tape or uses the proved whole-bank adoption transaction, + updating every relevant internal binding and clearing the old bank. + Public output and borrowed input ports retain their physical identities. + Pair-1 data and productive helper progress must be preserved throughout + acquisition and replacement. + +Recovery and reconstruction are full-cover phases. They cannot be inserted +inside one gathered 704-role group if their cover maps read other owners. +The producer adapter must preserve every sweep barrier, the source entry/exit +monomials, actual helper keys, and the chronological ordering. This is a +material installation obligation, rather than a choice of array notation. + +At event 6 the two observations are + + X0_p <- X0_p + X1_p; Y1_p <- Y1_p - Y0_p. + +Exact equality of both reconstructed pair-0 fields in their required external +frames, together with preservation of independent pair-1 inputs, gives exact +equality after both legs. No original inputs or old private queries are read +at this boundary. The ordered QQ16 inverse, including its T contribution, +remains the frozen decoder; the new continuation neither simplifies nor +commutes that inverse algebra. + +## Evidence and limits + +The executable audit checks both full scalar shadows, same-port source owner +routes, all 224 reconstructed output columns, and the actual signed bridge. +It evaluates 2,240 owner/character/port cases with independently varying +Gaussian-integer values in both pairs, including nonconstant characters. +624 cases reject the wrong sign of the exit line. These cases test the frame +and bridge formula; they are not execution of a production O(73,2) native +payload. General owner and tensor coverage follows from the displayed +source-relative common-label argument, not extrapolation from those cases. + +The caller supplies the exact producer/range, physical packet, lifecycle and +cost evidence. The component audit therefore reports +`complete_actual_caller_installation: false`; integration can discharge the +remaining entries only with matching evidence at the four boundaries. + +## Compatible bill and decision + +Beyond Q and the frozen decoder D, this reconstruction costs + + 224 T_unit_add + sum_(p=0)^111 [T_Cminus(p)+T_right(p)+T_left(p)]. + +Add acquisition, descriptor construction, output transfers, scatter, the chosen +completed-bank commit, old-bank clearing, output retirement, and actual bridge +costs. The default copy and optional whole-bank adoption paths have distinct +constructive bills in `LIFECYCLE.md`; adoption changes only the permitted +internal role bindings, with public physical ports fixed. Preserve all unchanged +source work on both sides. The 16 removed rank-eight centres are credited only +once against Q plus D plus this continuation. No upper-bound subtraction is +treated as a runtime improvement. + +Under the separate common-interface model C_r=c(r lambda)^(1-a), 0<=a<=1, +Q contributes 32 rank-one children, D contributes 224 and this word adds 112: +368 C1 versus removed credit 16 C8<=128 C1. The explicit route is therefore +at least 240 C1 over that optimistic native credit before all other positive +costs. This rejects affordability of this particular construction in that +model; it is not a lower bound on fused decoders, changed consumers, or all +QQ16 mechanisms. A complete installed version can still be a substantial +enabling contract, but it cannot claim an improved supplier or exponent. diff --git a/research/qq16-caller-install/COST.md b/research/qq16-caller-install/COST.md new file mode 100644 index 0000000000..122f19d101 --- /dev/null +++ b/research/qq16-caller-install/COST.md @@ -0,0 +1,503 @@ +# Actual caller cost and numerical ledger + +This is a local implementation ledger for the selected first F0/B1 connection. +It does not infer runtime improvement from two upper bounds. Numerical and +arithmetic quantities below are distinct from tape actions and physical tapes. +Source authentication and the actual producer/continuation trace are performed +by the integrated verifier before these independent counting functions run. + +## One external boundary + +Compare the original source interval from the selected producer entry through +its next required two-leg bridge with the installed route at exactly those +same immutable caller ports. This local boundary does not hide implementation +changes after the bridge: the installed root uses an external child adapter at +**every** root child, including retained source instructions later in the root. +The complete root extension of the bill is recorded below. Retained scalar, +owner-exit and bridge instructions may be paired only after their actual state, +head, descriptor and operation traces are proved to agree. Equal mathematical +outputs or equal child ranks do not justify physical cost cancellation. + +In particular, the original and installed child protocols differ; the original +parks the parent while the installed implementation retains it beside a separate +engine. Their costs and C execution contexts remain separate. The proved finite +internal-role permutation justifies the later publication comparison between +the **fixed-copy and adopted versions of this same installed protocol**. It does +not establish original-versus-installed child trace equivalence. + +The proposed route replaces the named sixteen rank-eight centre children in +the producer by its thirty-two rank-one children, applies the frozen 4106 +recovery, reconstructs current data using the actual G unit shears, returns all 112 Y +ports through their required negative line, and performs 224 fixed-port +copybacks before the actual continuation. The central source trace must bind +those sixteen centre occurrences and thirty-two replacements. A scalar query +that is no longer live is not an available input to this bill. + +The recovery plus reconstruction invoice is: + +| Term | Recovery D | Current reconstruction/return | Total | +| --- | ---: | ---: | ---: | +| Rank-one C calls | 224 | 112 | 336 | +| Intrinsic signed native wrappers | 448 | 224 | 672 | +| Owner-basis monomial calls | 448 | 224 | 672 | +| Actual line monomial calls | 896 | 448 | 1,344 | +| Cover/affine port maps | 352 | 0 | 352 | +| Signed unit ADD | 1,820 | 224 | 2,044 | +| Quarter ADD | 896 | 0 | 896 | +| Quarter SCALE | 0 | 0 | 0 | +| Logical CLEAR | 416 | 0 | 416 | +| Fixed destination copyback | 0 | 224 | 224 | + +Each native invocation in the compiled source has **four** physical monomial +calls: owner inverse view, signed right recipe, signed left recipe, and owner +return view. The intrinsic wrapper count alone omits half these calls. Thus +D plus reconnection has 1,344 actual line monomial calls per cover; the +producer's additional32 lines have128, including64 owner-basis calls. + +Add the producer's thirty-two rank-one children and its complete scalar/map +change separately. Neither that producer nor acquisition, encoded setup, +return movement, source preservation, output disposal and native ordinary +inventories are free. D's 26,144 scalar allowance has its inherited units; +the current reconstruction adds 1,792 units for signed unit ADD. The compatible +scalar subtotal is 27,936 before the producer delta. This is higher than D's +26,144 because recovered original values must become actual current values. + +Under the literal `physical-complex-controller/scalar_program.py` lowering, +a signed unit ADD has three elementary scalar passes (copy scratch, add, +clear), and a quarter ADD has five. The two new unit shears therefore cost +672 such passes; D and those shears total 11,028. This is a scalar microinstruction count, not an exact tape-action +count: each pass has complete input/output, descriptor and cleanup charges. +An implementation which uses a different exact transducer must price that +transducer. Borrowed copying, logical COPY and transfer-to-fixed-port have +separate endpoints and cannot share credit without a proved ownership change. + +The compiled routing and service costs are also explicit. All coefficients +below multiply Gamma for the complete first F0/B1 interval and decoder sweep. +The producer's528 map orders are `{2:464,5:24,6:12,12:20,17:4,20:4}`. +Right-multiplication cycles give12286/51 map groups,14642/51 source exchanges, +the same number of extra sign scales, and528 translation monomials. Every +exchange performs the source's sign-changing exchange plus its extra sign +correction; it is not a free ownership relabeling. Including43 non-map groups, +the producer uses14479/51 gather/scatter/commit groups versus2 originally. +Its outer scalar word adds2200 ADDs,32 private CLEARs and16 SCALEs before map +cycle corrections. The two retained cores retain their source arithmetic instructions, but their +child entry/return protocol charges change and are recorded below. + +The decoder service has352 order-two maps, each emitting Gamma/2 cycle groups. +Its1846 non-map groups plus176 map groups total2022 per Gamma. Its physical +monomial count is1696 per Gamma:1344 line calls and352 map translations. +There are176 source exchanges and176 extra sign scales. Its **direct scalar +dispatches** are2940 ADDs,368 public zero scales and176 map sign corrections, +total3484, with48 separate private zero calls. This3484 excludes the176 +ScalarEngine negations called internally by the source `exchange_step`: +those negations and their transfers are already included in each T_exchange. +Thus the direct-dispatch count must not be reported as every nested scalar +invocation, and the exchange-internal negations must not be charged a second +time. The same distinction applies to the producer’s14642/51 exchanges and +additional14642/51 direct sign corrections per Gamma. The earlier11028 arithmetic pass count +includes the48 private zero passes but excludes map swaps/sign corrections, +all engine entry/exit copying, and every bank scan. These are disjoint additional +terms in the physical invoice, not costs absorbed by the logical scalar tariff. +`physical_invoice` records this complete operation decomposition; the integrated +source audit must bind its expected coefficients to the compiled source. + +Let v=P*U*row_bits be one owner packet, V=Gamma*v be one complete family field, +and B=14336V the original parent bank. The assembled decoder bank is S=448V. +Every emitted producer group scans B; every emitted decoder group scans S. +Nonleader map visits still execute finite cycle-control work:528Gamma producer +visits and352Gamma decoder visits. Include that fixed source-control invoice +even when a nonleader emits no payload group. +The service's P-dependent assembly reads224 borrowed family fields and writes +their224 copies plus224 new zero fields. It retains that S-bit source while +its Machine creates its own current and replacement banks and protected return. +Extraction checks every borrowed return bit, copies224 owned return fields and +erases both the assembly bank and protected result. Its encoded rows are +448GammaU; constructing that Count and all setup/retirement work is paid. + +For the assembly/extraction loops themselves, a conservative additional bound +is + + 4096*(S + 448P*(bE+1) + bP + D_service + 1), + +where bE=bitlength(Gamma U row_bits), bP=bitlength(P), and D_service is the +initial service/owned-output backing discarded by those loops. This counts +all per-prefix segment counters, source/output rewinds, input comparison, +zero initialization, copies and final bank/result erasure. Use the same +amortized Count countdown bound as LIFECYCLE.md:64*(n+b+1) actions for a +canonical b-bit counter decremented n times, including setup and closure. +There are448P segment counters in assembly and448P in extraction, with total +counter decrements2S and a fixed number of scans/moves/writes per bit; factor4096 +dominates these explicit terms. Construction of the field-prefix Count, +outer encoded setup and the service Machine's own execution are outside this +bound and remain separately charged. This is an upper bound on the implemented +loops, not an asymptotic assumption that input-sized metadata is free. + +After extraction, the lifecycle mechanism pays224 fixed-destination transfers. +For equal V-bit old/new fields the retained literal transfer costs16V+17 cell +actions, followed by full-parent-bank scatter/commit/release. Its constructive +storage bound and P-dependent counter costs are given in LIFECYCLE.md; those +bounds do not include the additional assembly/extraction bound above or the +service-Machine execution. The private zero-generation and lease +checks remain charged, including initially longer dirty backing. + +The integrated driver selects **whole-bank adoption** after that common +scatter. Public input and output ports remain fixed. Only the internal current +role exchanges with the completed replacement, and the roles, parked-role and +Parking bindings are all updated as proved and checked in LIFECYCLE.md. This +is a new adaptation of #3380's ownership idea to the actual source machinery; +its different22V+13 result is not imported. + +Compare the two publication implementations from exactly the same completed +scatter state until their common release. Literal tape-action counts are: + +| Action | Retained fixed-copy commit | Selected adoption | Saved | +| --- | ---: | ---: | ---: | +| Reads | 9B+13 | 4B+11 | 5B+2 | +| Writes | 3B+1 | B+1 | 2B | +| Unit moves | 8B+16 | 4B+14 | 4B+2 | +| Total | 20B+30 | 9B+26 | 11B+4 | + +The adoption bill includes the full binary scan, origin checks and paid old +bank erasure. All earlier acquisition, arithmetic, service, output-transfer and +scatter work is identical. Release and the later source continuation have +matching cell-action traces under the proved finite internal-role permutation; +all relevant bindings are updated and public ports remain fixed. Consequently +this is a constructive difference of two matched executions: + + T_install_adopt = T_install_fixed - (11B+4) + c_R, + +where c_R is the additional fixed finite-role selector/control cost if the +machine model prices it separately. In the tape-action model the saving is +exactly11B+4; with additional control it improves that local bill precisely +when c_R<11B+4. This is not subtraction of unrelated upper bounds. Charge it +once at the reached global installation fence; B already includes Gamma, so +multiplying the saving by Gamma again is incorrect. Across multiple reached +installations sum their distinct B_u terms and their control charges. + +The adopted publication reduces an expense of this new installed connection. +It removes no additional original QQ16 arithmetic or native interval and does +not alter the isolated native-component screen or selected kappa. The fixed-copy +publication remains an executable matched alternative. Physical tape inventory +and the conservative high-water bound are unchanged; internal backing changes +owner, and erasure does not imply allocation reclamation. + +Three distinct Machine inventories can be simultaneously required: the modified +producer parent, the decoder service, and the original recursive C child +engine shared sequentially by the two callers under a proved closed protocol. +The parent remains suspended while the service runs; the child engine is never +re-entered. Their Ordinary backends are distinct. A conservative total bound +is3I+2^20 fixed physical roles, where I=2q^2+100696823 is the inherited original +Machine bound and the remaining compiler/acquisition/service roles must be +listed below that reserve. Relative to an already paid original parent, the +increment is at most2I+2^20. This is a sufficient inventory, not a minimal count. +The decoder's extra eight private slots are outweighed by its256 fewer packet +slots; numerical engine inventories retain their inherited upper bounds. +High-water backing is additional to tape count: in particular, assembly and +protected return each have448V bits, and parent/native suspended state remains +live. Erasure is not release of the emulator's historical allocation. + +## Complete child protocols and the extended root bill + +`ProducerMachine.enter_child` overrides every root child instruction. It also +serves every decoder-service child. The original source executes its recursive +children in the same Machine with parent parking; the installed caller invokes +a distinct original `Machine.run`. The original implementation continues to +handle that separate engine's recursive descendants, so this installation does +not recursively apply the modified producer at every node. + +The authenticated `ProducerBinding.root_child_census()` enumerates all482 source +events, every compiled local child and all idle remainders, and checks the actual +dispatcher at every idle rank. `root_protocol_invoice` independently binds its +histograms and boundary partitions. Counts below multiply Gamma: + +| Root interval | Original child calls | Installed root child calls | Additional service calls | +| --- | ---: | ---: | ---: | +| Entry through original source bridge6 | 17,565 | 17,581 | 336 | +| Later source events7 through481 | 493,097 | 493,097 | 0 | +| Complete root | 510,662 | 510,678 | 336 | + +The original whole-root rank histogram is +`{1:349604,2:60192,3:62585,4:20448,5:11808,7:7,8:1152,48:4866}`. +The installed root adds32 rank-one occurrences and removes16 rank-eight +occurrences; all other multiplicities agree. Thus **511,014 Gamma external +original-Machine runs** occur across root and service, including +**510,646 Gamma retained root occurrences with changed protocols**. Of those, +17,549 Gamma are before the local exit and493,097 Gamma are after it. The +unchanged later rank histogram is +`{1:337544,2:58102,3:60330,4:19738,5:11398,7:7,8:1112,48:4866}`. +These are invocation frequencies, not an equality of payloads or physical bills. + +For each original root occurrence j, define the following disjoint operation +sums at its actual geometry, descriptor lengths, dirty backing and live state: + +- P_b(j): original `prepare_child` arithmetic, payload and fourteen descriptor + copies into the capsule, encoded header construction and temporary closure. +- E_b(j): entry boundary/origin checks, `Parking.park` of every live parked role, + capsule-to-active transfers and child control setup. +- C_emb(j): actual original child node/body and descendants in the embedded, + nonroot execution context, stopping before its final parent return. +- R_b(j): child-current to protected-output transfer, child-active-role cleanup, + `Parking.restore`, header read/clear, parent group reconstruction, output to + parent target transfer and bank/head/control reconnection. + +For an installed root or service occurrence k, define: + +- P_i(k): its actual `prepare_child` work and capsule/header construction. Even + shared source code can have different encoded event-index lengths; no equality + of P_b and P_i is silently assumed. +- A_i(k): boundary, header and child-instruction checks and finite descriptor + views at external entry. +- Run_C_ext(k): the **complete** separate original `Machine.run`: borrowed + payload/descriptor copying, node setup, actual C body and descendants, root + protected return and engine closure. Its own recursive parking, native and + ordinary work is included once here. +- Z_i(k): protected output to parent target transfer, marker erasure, capsule and + header cleanup, and parent PC update. + +Write F_b=P_b+E_b+C_emb+R_b and F_i=P_i+A_i+Run_C_ext+Z_i. C_emb and Run_C_ext +are intentionally different terms. The latter includes input copying and a +root-return path absent from the former; their C bodies execute with different +parent/stack/root contexts. A source-relative context/trace argument could +justify cancelling a precisely delimited subtrace, but matching ranks and +semantic endpoints do not supply that argument. Do not charge the complete +Run_C_ext and then add its input copying, native parking or root cleanup again. + +Let N_b and N_i be the actual root costs excluding child preparations, entries, +bodies and returns: root input/descriptors/setup, all nonchild arithmetic, +monomials, exchanges, bank gather/scatter/commit, owner/event control and final +root output/cleanup. N_i includes the additional fence predicate at **every** +root `finish_group`, not just at the installation. Let T_s include the entire +service and fence: encoded preparation and assembly, the service Machine's +nonchild setup/input/output and bank operations, its336 Gamma F_i terms, +extraction, fixed copybacks, adopted publication and disposal. The earlier +assembly bound is only one component of T_s. + +At either the local prefix boundary or the complete root boundary, a measured +compatible comparison is exactly + + T_b = N_b + sum(original root occurrences j) F_b(j) + T_i = N_i + sum(installed root occurrences k) F_i(k) + T_s. + +The full-root version includes the493,097 Gamma later externalized calls and +all later control costs. The local prefix is not a claim that later adapter +expenses vanish. Fixed root ports and completed state refinement allow the +external boundary to be matched; they alone establish no inequality of T_i +and T_b. Every term is an operation sum of the actual implementation, not a +subtracted unrelated upper bound. + +Pair the retained source occurrences using their literal source positions, +not merely their ranks. Define their possibly signed protocol/context credit + + C_ret = sum(retained j) [F_b(j) - F_i(j)]. + +For the complete root, an improvement is equivalent to + + C_ret > (N_i-N_b) + T_s + + sum(32 Gamma new producer lines) F_i + - sum(16 Gamma removed centres) F_b. + +This identity retains all C-body/context differences and every new expense. +C_ret has prefix and later parts; both remain unevaluated. If only upper +bounds are available, the expression is an admission target, not a proved +saving. The original parent parking serializes its live bank and additional +roles; avoiding it can provide real credit. It must not be set to zero or +assumed smaller than the added native component. The next discriminating +experiment is paired metering/proof of the original embedded and external +protocols with actual bank geometry and dirty backing, including descendant +context and cleanup, followed by comparison against the new full-bank scans. +This may change affordability even while the native-component screen fails. + +## Isolated native-component charge screen + +For the stated mechanism the newly introduced rank-one occurrences are +32+224+112=368, versus sixteen rank-eight occurrences removed. With identical +packet volumes and the same homogeneous child charge at exponent +0<=alpha<=1, the ratio of introduced to removed charge is + + 368 / (16 * 8^(1-alpha)) = 23 / 8^(1-alpha) >= 23/8. + +The normalized difference is +`(368-16*8^(1-alpha))*73^(alpha-1)>0`. Its width-linear endpoint already adds +240 lambda units; its alpha=1 ratio is 23. This rejects an improvement of +that *specified native-charge budget* before considering the additional +positive scalar/map/copy work. It is not a runtime lower bound, a lower bound +on all current-value reconstructions or a contradiction of a sharper physical +implementation. The hypotheses include equal actual packet volume and the +same tariff. A coordinated route that removes different source work, fuses +native operations with a proved endpoint, or changes a consumer can escape +this screen and needs a new comparison. + +A stronger restricted decision screen does not depend on this particular +current reconstruction. Any route retaining the full D224 and the same +producer32, while adding only nonnegative further native charge and removing +only those sixteen H8, already introduces256 C1. Even a hypothetical free +native reconnection leaves at least128 C1 of width-linear charge deficit. +Consequently optimizing only the post-D repair cannot improve this isolated +native-component tariff. This does **not** reject affordability of the complete +installed connection or of every full-D mechanism: C_ret above can supply +compensating physical credit from avoided parent parking. Changing recovery, +proving native cancellation or removing more source work can improve the native +component, while a different caller protocol can improve the total bill. +No ordering between those unlike costs has been proved here. + +The local 800-allowance improvement from 4015 to 4106 survives its matched +word comparison but cannot pay this native-charge deficit by a change of +units. This route is an enabling installation candidate whose total affordability +remains unresolved by the unevaluated protocol/context and scan balance; it is +not an established affordable supplier or a new selected recursion. The precise recursive +frequency must be given before charging any whole-tree budget; one installed +first F0 cut proves no all-node substitution theorem. + +## Row stock and actual physical volume + +The actual controller uses `L=14336 Gamma` and gathers complete per-family, +per-cover packets. Let `U=R/L`. The physical Gaussian count of a gathered +packet is + + prefixes * U * 2^(front+3*compact_bits+before+73*lambda*K+after+back) + * coefficients. + +Twice this number times actual component width H_b is its payload bit volume. +Changing the child active width to lambda and appending 72 lambda K to +`after` preserves that entire volume; spectators are never collapsed. +The parent must already satisfy its actual row-stock predicate. The root +planner's paid padding and final zero-row removal are inherited, not newly +supplied by the decoder. The encoded compiler's validation of U and the +D0 child divisor makes that dependency explicit. It does not authorize using +logical `2^(73 lambda)` as the physical packet size. + +## A source-grid admission certificate + +Keep the four widths distinct: logical coarse W_c, native reserve a, +physical coefficient width H_b and address guard H_g. The inherited physical +root has + + Delta = 2^210000 d, q_s = 2^(-p-Delta), H_b = p+2Delta+3, + G = 4 ceil(log2 p)+6, H_g = dG. + +The actual component Count, spacing, Compact guards, root p and root d are +unchanged. `compact_bits` is an address descriptor and is not H_b. + +A safe sufficient local argument starts at an unchanged source entry whose +inherited height is at most h0=2Bd, where +`B=1041408 Gamma+2^100000`. It bounds every component by `2^h0` and places +it on grid `2^(-p-h0)`. Such an entry hypothesis includes arbitrary correlated +and dirty live families; it does not assume their numerical values vanish. +It has to be justified at the actual chosen entry by the inherited source +execution. A completed-output norm bound cannot replace it. + +Charge the *changed* producer in full after that entry. Let g_P and d_P be +its conservative modulus-growth and denominator-debt exponents, derived from +its complete physical instruction word. `literal_height` charges every dyadic +scalar occurrence, including the Horner scratch numerator before division, +and every completed native rank r by r lambda. Unit-phase monomials preserve +modulus and grid. One unfinished rank-r child has a separate native interior +reserve at most `2Br lambda`; it is not charged r lambda until completion. +This deliberately generous bound avoids borrowing the unchanged original +producer's height theorem for a changed circuit. + +For t=lambda-1, 4109 bounds the complete decoder's interpreted scalar values +by an additional `19+3t` growth bits and `9+3t` denominator bits. Its largest +unfinished native callback requires reserve a<=2B lambda plus the Gaussian +modulus headroom bit; subsequent exact returns reuse that reserve. + +The actual source continuation is G(x,y)=(-y,x+y), conditional on the +source lift, owner-routing and endpoint-frame proof supplied by the semantic +module. On recovered owned banks Z=x,W=y, execute W+=Z and then Z-=W. +The first operation has magnitude at most2M, and the second's conservative +prefix bound is3M<4M; its endpoint is exactly -y. The bound is valid for +arbitrary correlated nonconstant payloads. No extra denominator bit or +private query is introduced. A centre-free J map is not substituted for the +actual G endpoint. + +After the final signed C lambda tensor and the two actual bridge legs with +coefficient c, completed bounds are + + growth <= h0+g_P+19+3t+2+lambda+ceil(log2(1+|c|)), + debt <= h0+d_P+9+3t+lambda. + +Use the maximum of these and the unfinished-producer/decoder/final-native +bounds in `fixed_grid_admission`. Requiring growth and debt at most Delta +makes all interpreted coefficients exact integers on q_s and fits H_b: +their encoded magnitude is at most `2^(p+Delta+growth)`, strictly below the +signed H_b limit `2^(p+2Delta+2)`. Thus a correctly implemented full-width +route can keep the source's actual grid and width throughout. This is a +conditional admission calculation; payload execution and the absence of +premature arithmetic rounding must still be checked in the actual lowering. + +For the complete producer interval, the verifier sums the actual scalar +literal height and native rank mass across both changed cores, all outer macro +bodies and the three retained intervening source groups. Each owner-family +traversal is bijective, so a maximum-norm bound charges each group body once +per scalar field, rather than multiplying numerical growth by Gamma. Map-cycle +operations are exact signed permutations and do not grow coefficients. This +whole-interval source argument is necessary: the65536-PC bound of one group +alone does not bound all the producer barriers. + +The authenticated46-body compilation gives the explicit conservative values + + g_P = 230124 + 27834 lambda, + d_P = 84422 + 27834 lambda, + +with maximum local child rank8. These sums include the three unchanged +intervening source cores; they are not estimates from scalar-event counts. +The rank48 bound below is retained as a sufficient upper domain. Source event5 +(the pair-1 idle preparation) remains unchanged after service return and before +the bridge. Its untouched families retain the original source height bound; +that reuse of the numerical bound relies on helper/end-state preservation +proved by the composed source connection. It does not cancel event5's changed +physical child entry/return protocol. + +`uniform_interval_domain` validates each constituent source word and checks +that the measured aggregate constant and lambda slope are both below2^22. +Therefore g_P,d_P<2^22(lambda+1). With d>=73lambda and |c|<=1, every completed +and unfinished bound above is strictly below + + (4B+2^24)d < 2^210000 d = Delta. + +The first inequality uses the producer interior bound +`2Bd+96B lambda+1`, plus the generous literal word allowance; the other +stages are smaller. The last integer inequality is checked exactly. The +written inequalities establish the all-lambda claim; evaluating a few lambda +values is only a control. In particular this is a one-cut sufficient bound, +not a proof that inserting this work at every recursive node preserves the +original all-depth height or time recurrence. + +The primary implementation retains q_s and H_b throughout, using this new +admission proof and exact physical scalar/native execution. It does not require +a coarse down-projection between children. #4129 supplies the inherited exact +C interior/refinement and return reasoning; its coarse-format bridge remains +a separately available protocol. If that protocol is used instead, it must +pay those conversions and verify low-zero/sign-extension conditions. Taking +W_c=H_b in that contract is invalid because it violates +`H_b>=W_c+2a+1`. No integer calculation in this ledger is an encoded compiler. +The chosen physical implementation and its numeric certificate must agree. + +#4114 gives a useful regression against a smaller unjustified premise: its +L359 dirty ray reaches 128T in data and68T in a helper before exact return. +The completed-output norm58 is therefore not an interior range certificate. +That scalar projection alone is not an arbitrary-payload operator norm. + +## Reuse decisions in this ledger + +- **#3055: reuse unchanged.** The actual 4129 controller already inherits + physical Compact and its ordinary/native premises. Its root proof derives + K>3G and the repair inequality, and retains long-record setup conditions. + This installation claims no new Compact implementation or saving. +- **#3619: adapt only with a new endpoint/layout proof and cost.** The physical + support router permutes address coordinates in complete opaque-record + rectangles. That can implement appropriate coordinate permutations, but it + is not a generic Gaussian-frame transform. Its faster tariff additionally + requires cp<=n<=C0p, support k<=2p^(997/1000) and log2(R+1)<=A0p. Outside + that domain retain its literal/unabsorbed invoice. No such tariff is + credited automatically to the 352 maps above. +- **#4114: regression evidence only.** Retain its dirty-ray warning and exact + witness scope; do not turn it into a new uniform height theorem. + +Source lineage credit: Jose Manuel for the physical C, Compact and support +router implementations and their retained native/ordinary/hosting premises; +Ali Romman and the joint-query authors for the source producer; Arham Tahir, +ywz65 and the 3985/4015/4106/4109/4129 authors for recovery, ranges and exact +native-return contracts; unpaidmoon for the dirty-ray regression. This +independent ledger was prepared with OpenAI Codex assistance. Shared source +and checker assumptions remain shared; it is not human or formal acceptance. diff --git a/research/qq16-caller-install/DECODER.md b/research/qq16-caller-install/DECODER.md new file mode 100644 index 0000000000..2961fd8d8a --- /dev/null +++ b/research/qq16-caller-install/DECODER.md @@ -0,0 +1,131 @@ +# Actual finite full-cover decoder service + +Chris R with OpenAI Codex assistance. The source physical `Machine`, `Count`, +`BankPackets`, scalar and monomial engines, and original recursive C endpoint +retain Jose Manuel's attribution. The logical word is frozen PR4106; its +algebraic and frame correctness retain the #3985/#4015 and ywz65/Arham Tahir +line-normalized decoder lineage. This component adapts their interfaces; it +does not claim their source/refinement premises as new results. + +## Four physical boundaries + +1. **Producer fence.** The active parent has completed every owner in its + designated whole-cover event. Its bank is closed, all productive roles and + ancestor state remain live. Paid acquisition supplies 224 immutable fields + in order `prefix, cover, U row, complete physical row`. +2. **Service entry.** `ServiceBank.assemble` constructs a new bank in order + `prefix, family, cover, U row, complete physical row`. Families 0–111 are X, + 112–223 Y, 224–335 owned Z, and 336–447 owned W. It copies every borrowed + bit and writes every bit of the newly owned zero fields. Source lengths + and outer-prefix counts remain encoded `Count` objects. +3. **Completed service.** A distinct physical `Machine` executes the compiled + full D and current endpoint reconstruction. The borrowed X/Y families have + their original values and frames. All 224 Z/W families are complete. The + source `finish_group` checks and retires the sixteen private roles after + each private word. Every native output has already been consumed. +4. **Continuation exit.** `extract` compares every returned borrowed bit with + the original acquired field and copies each owned family to its fixed + output field, then consumes both service-bank copies. The lifecycle module + performs the separately charged publication into the immutable parent bank + and continues the actual source schedule. Extraction is not publication. + +The implementation supports arbitrary positive encoded prefix count. Appending +224 complete field tapes would give family-major order and would be incorrect +when the prefix count exceeds one. The implemented outer loop is the encoded +prefix countdown, with a fixed inner loop over all 448 families. + +## Actual row and numerical contract + +Let the admitted source parent have active width `73 lambda`, original rows R, +cover size Gamma and original divisor L=14336 Gamma. Its already computed +`unused` descriptor is U=R/L. The service keeps all source physical row fields, +including global component width H_b, guards, spacing, compact fields, root +width, front/back fields, residue, coefficients and spectators. Its top-level +rows descriptor is constructed by encoded multiplication as 448 Gamma U. +The service's source node therefore computes precisely U as its per-owner rows. + +Each `prepare_child(target,1)` keeps prefixes P, rows U, child width lambda, +and moves the remaining 72 lambda coordinates into the suffix. The capsule is +executed by a separately closed **original** recursive C Machine. In particular, +its recursive divisor is the original 14336 Gamma, not 448 Gamma. Required stock +is inherited from the actual admitted parent: + +`L^D0(73 lambda) | R` implies `L^D0(lambda) | U`. + +The service does not supply missing row stock at an arbitrary cut and does not +run its D binding recursively. Its entry must remain a nonleaf source node; the +actual producer cut has already passed the source nonleaf test. Physical width +is retained. No assignment `W_c=H_b`, no uncharged promotion and no implicit +rounding is introduced. The cost/numerical component proves the common fine-grid +subdomain for this one installed cut, conditional on inherited source height +and exact backend hypotheses. + +## Compiler and cover barriers + +`DecoderBinding` accepts only authenticated finite word, port labels and map +records. It never reads payloads or decodes variable-sized descriptors. Every +public scalar, native line and map is one complete cover barrier. The two +`begin`/`end` words are grouped so all private scalar instructions run at one +owner before advancing to the next owner. Moving the global acquisition or a +map into that private word is rejected by the compiler grammar. + +Public clears lower to the retained `ScalarProgram('scale',0,1)` because source +`zero_step` only accepts private ports. A private clear uses that source +`zero_step`; its zero backing is explicitly written. All addition literals are +among signed one and signed one-quarter and use source exact scalar programs. +Only Z/W/F/G can be destinations; X/Y remain immutable. + +Each signed q line lowers in chronological order to + +`owner inverse; right(q); original C child; left(q,sign); owner`. + +Thus the physical invoice has **four monomial calls per native occurrence**. +The two extra owner-basis calls are not included in the logical two-wrapper +census. Negative left wrappers contain the q XOR. All 224 frozen D occurrences +and all 112 negative reconstruction occurrences use this lowering, including +frozen event 4 W0/q11/+ and event1705 Z10/port76/q448/−. + +`finite_maps` reconstructs the exact stage-one F17 alignment and stage-two +bridge shift from the retained source routes. Inverse maps transform the shift +by g, as required for these authenticated involutive routes. `map_group` uses +paid whole-owner cycles: each cycle of h owners needs h−1 physical exchanges, +h−1 sign corrections, and its nonzero output-owner translations. The source +bank acquisition/scatter of every participating packet remains charged. + +## Cost and cleanup boundary + +For P prefixes and B=Gamma U row_bits bits per family per prefix, assembly +writes 448PB bits and reads all 224PB borrowed bits, in addition to all encoded +countdown and head-return actions. Extraction checks 224PB borrowed bits, +reads/copies all 224PB output bits, then clears both 448PB bank tapes. These +are operation descriptions, not a replacement for the control-inclusive +source primitive bill. Descriptor construction, source Machine input copy, +all group gathers/scatters, four monomials per line, child execution, scalar +scratch, output preflight, fixed-bank return and retirement remain distinct +cost terms in the central ledger. Unknown costs are never cancelled. + +The service owns its bank; all fields, returned output and bank must have +pairwise distinct physical tape identities. On malformed assembly/extraction, +borrowed heads are restored. Partial owned bank/output contents remain in the +service's exclusive inventory and must be cleared by the orchestrator's error +cleanup. Such rejection is not reported as a completed closed service. A +successful extraction consumes both the input service bank and returned bank. + +## Executable evidence and quantifiers + +The bounded `decoder-fixture.py` test runs actual source Tape/Count, +BankPackets, MonomialPackets, scalar engine and recursive C Machine in +2-dimensional geometry. It covers nonconstant signed complex values, two +prefixes, both owners, both line signs, a nontrivial owner cycle and translation +with its inverse, signed quarter arithmetic, private retirement, current G +reconstruction and the negative output frame. Independent coordinate arithmetic +checks all 128 complex outputs. It does not execute the selected O73 word. + +A distinct three-prefix test verifies all 224 borrowed fields, all 224 returned +fields and the 448-family interleaving, including truncated-source rejection. +The full selected compiler audit binds every frozen occurrence and its finite +control lowering. The all-parameter composed correctness statement additionally +inherits the authenticated D algebra, map refinement, source exact C contract, +actual producer equation, numerical admission and lifecycle theorem. These +premises must join in the central proof; compatible fixture labels alone do +not establish that join. diff --git a/research/qq16-caller-install/EXECUTION.json b/research/qq16-caller-install/EXECUTION.json new file mode 100644 index 0000000000..72e5c299de --- /dev/null +++ b/research/qq16-caller-install/EXECUTION.json @@ -0,0 +1,390 @@ +{ + "decoder-fixture.py": { + "negative_sign_rejected": true, + "physical": { + "both_signs": true, + "compiler": { + "compiled_identity_owner_census": { + "child": 4, + "exchange": 2, + "monomial": 20, + "scalar": 18, + "zero": 2 + }, + "compiled_identity_owner_sha256": "454887c037a6863ea2c9b40db5ed312b13bfd2b213b9781e0186cbdc25073f6a", + "decoder_native_calls": 2, + "events": 20, + "families": 8, + "literal_decoder_events": 21, + "maximum_pc": 6, + "physical_per_cover": { + "all_gather_scatter_commit_groups": 18, + "all_monomial_calls_including_map_translations": 18, + "intrinsic_wrappers": 8, + "map_control_visits": 2, + "map_exchanges": 1, + "map_gather_scatter_commit_groups": 1, + "map_identity_leader_translation_monomials": 4, + "map_order_histogram": { + "2": 2 + }, + "map_sign_corrections": 1, + "map_translation_monomials": 2, + "nonmap_groups": 17, + "owner_basis_monomials": 8, + "physical_line_monomials": 16, + "private_zero_calls": 2, + "rank_one_children": 4, + "scalar_engine_calls_including_map_sign_corrections": 17, + "unit": "per full cover divided by Gamma, except identity-leader translation diagnostic" + }, + "private": 16, + "private_words": 1, + "scope": "All finite signed occurrences and cover-barrier compiler; arithmetic correctness inherits authenticated D and source primitive refinements.", + "slots": 8, + "status": "PASS_FULL_COVER_DECODER_COMPILATION" + }, + "component_bits": 20, + "cover": 2, + "dimension": 2, + "endpoint_sha256": "65b7a34589818bfd0a2288a6e4ef3ce9b278be04350fd5611ff468be09feec81", + "nonconstant_complex_values": 128, + "prefixes": 2, + "private_scope": 8, + "scope": "Reduced full grammar on actual source Machine/MonomialPackets/native C, not selected full D or O73 production execution.", + "status": "PASS_ACTUAL_REDUCED_DECODER_GRAMMAR" + }, + "zipper": { + "all_outputs_checked": true, + "assembled_sha256": "419fa68e47e220444483b053dba49363c1387ee8832606a6720c6cf587f98bf5", + "bits_per_family_prefix": 7, + "borrowed": 224, + "owned": 224, + "prefixes": 3, + "short_input_rejected": true, + "status": "PASS_224_OUTPUT_ENCODED_PREFIX_ZIPPER" + } + }, + "integrated-fixture.py": { + "continuous": { + "actual_connection_factory_checked": true, + "actual_root_layer_attachment_checked": true, + "actual_signed_original_C_calls": true, + "all_entry_exit_outputs_checked": true, + "borrowed_preserved": true, + "both_bridge_legs": true, + "completed_generations": 2, + "complex_values": 64, + "dirty_owned_scratch_retired": true, + "factory_inventory_rejection_checked": true, + "families": 4, + "outer_prefixes": 2, + "owners": 2, + "physical_component_bits": 32, + "root_attachment_negative_controls": 6, + "same_engine_second_generation_sha256": "7f9e3e9514e1645324e8907a7736f691ded6ea0f6495711fc5ec59c2139a93ae", + "scope": "Reduced physical composition; selected O73 proof and production cost remain separate.", + "sha256": "fa12c5b1d81bc2d3c7cae2f0fc5e7783276cdef52c230a7f183a3fd911ead99f", + "source_preparation": "test oracle only", + "status": "PASS_CONTINUOUS_PHYSICAL_CALLER_INSTALLATION" + }, + "internal_rejection_cleanup_checked_before_fixture_recovery": true, + "rejections": { + "early_fence": "actual completed whole-cover producer fence", + "output_alias": "exclusive physical caller/native/wrapper inventory", + "wrong_producer_sign": "composed producer recovery current-return and both bridge outputs" + } + }, + "lifecycle": { + "adoption": { + "cases": [ + { + "adopted": { + "moves": 30, + "reads": 27, + "writes": 5 + }, + "bank_bits": 2, + "baseline": { + "moves": 40, + "reads": 39, + "writes": 9 + }, + "saved": { + "moves": 10, + "reads": 12, + "writes": 4 + } + }, + { + "adopted": { + "moves": 50, + "reads": 47, + "writes": 11 + }, + "bank_bits": 6, + "baseline": { + "moves": 76, + "reads": 79, + "writes": 23 + }, + "saved": { + "moves": 26, + "reads": 32, + "writes": 12 + } + }, + { + "adopted": { + "moves": 110, + "reads": 107, + "writes": 29 + }, + "bank_bits": 18, + "baseline": { + "moves": 184, + "reads": 199, + "writes": 65 + }, + "saved": { + "moves": 74, + "reads": 92, + "writes": 36 + } + }, + { + "adopted": { + "moves": 350, + "reads": 347, + "writes": 101 + }, + "bank_bits": 66, + "baseline": { + "moves": 616, + "reads": 679, + "writes": 233 + }, + "saved": { + "moves": 266, + "reads": 332, + "writes": 132 + } + } + ], + "mutations": [ + "omitted parked binding", + "omitted parking binding", + "omitted parked binding", + "omitted parking binding", + "omitted parked binding", + "omitted parking binding", + "omitted parked binding", + "omitted parking binding", + "cached external current alias", + "invalid returned binary symbol" + ], + "nonempty_ancestor_codec_cases": 4, + "saving": "11*B+4 tape cell actions; plus separately charged finite role-control cost", + "scope": "Actual source commit, Tape and Parking at synthetic admitted body boundaries; full actual controller adoption/continuation is fixture(adopt=True).", + "status": "PASS_EXACT_BANK_ADOPTION_AND_REBOUND_PARKING" + }, + "full224": { + "actual_bridge_legs_per_cover": 2, + "actual_recursive_boundaries": { + "enter": 20, + "return": 20 + }, + "all_parent_roles_preserved": true, + "ancestor_frames_preserved_at_fences": 0, + "cleanup": true, + "complex_values": 3584, + "control_inclusive_service_cell_actions": { + "moves": 10594180, + "reads": 11760870, + "writes": 3194906 + }, + "covers": 2, + "endpoint_sha256": "3c256fb346096edf7ac66074420d5f1801a9dc61ab161217c25c78ab9ff39115", + "exact_transfer_tariff_checks": [ + { + "actions": { + "moves": 10, + "reads": 7, + "writes": 0 + }, + "new_bits": 0, + "old_bits": 0 + }, + { + "actions": { + "moves": 16, + "reads": 14, + "writes": 3 + }, + "new_bits": 1, + "old_bits": 1 + }, + { + "actions": { + "moves": 40, + "reads": 42, + "writes": 15 + }, + "new_bits": 5, + "old_bits": 5 + }, + { + "actions": { + "moves": 112, + "reads": 126, + "writes": 51 + }, + "new_bits": 17, + "old_bits": 17 + }, + { + "actions": { + "moves": 60, + "reads": 68, + "writes": 25 + }, + "new_bits": 11, + "old_bits": 3 + } + ], + "fixed_service_tapes": 545, + "geometry_dimension": 2, + "internal_bank_adoption": true, + "mutation_rejections": [ + "premature fixed-bank commit", + "parent/output alias", + "unrestored private dirt", + "unclosed native output", + "short final output", + "retired output access", + "double commit", + "premature fixed-bank commit", + "parent/output alias", + "unrestored private dirt", + "unclosed native output", + "short final output", + "retired output access", + "double commit" + ], + "outer_prefixes": 2, + "outputs": 224, + "private": 16, + "producer_width": 2, + "reached_fences": 2, + "root_invocations": 2, + "scope": "Actual source Machine, BankPackets, Tape/Count and both bridge scalar legs; identity service tests storage only, not QQ16 arithmetic, selected O73 execution or complete supplier.", + "status": "PASS_ACTUAL_FULL_BANK_LIFECYCLE_AND_BRIDGE", + "whole_cover_families": 224 + } + }, + "packet": { + "global": { + "fixed_compiler_tapes": 78, + "fixture": { + "coefficients": 2, + "compiler_retirement_actions": { + "moves": 128, + "reads": 114, + "writes": 36 + }, + "compiler_setup_validation_actions": { + "moves": 14710, + "reads": 16161, + "writes": 3441 + }, + "controls": [ + "wrong producer fence", + "short whole-family field", + "pre-remainder nonleaf does not admit service", + "insufficient actual child stock" + ], + "covers": 2, + "endpoint_sha256": "690c39b78ad30696f465dba8eb7b00f60b7999870b3998b67d84be1216886f4b", + "field_complex_values": 32, + "native_prefixes": 4, + "prefixes": 2, + "rows": 1 + }, + "scope": "Actual cover2 parent, whole-family BankPackets acquisition, encoded compiler, actual rank-one C child and completed parent; reduced geometry, not full QQ16 semantic installation.", + "source_and_descriptors_preserved": true, + "status": "PASS_ACTUAL_GLOBAL_FAMILY_PACKET_COMPILER" + }, + "group": { + "actual_child_descriptor_match": true, + "coefficients": 2, + "compiler_retired": true, + "complex_values": 64, + "endpoint_sha256": "6d3552366813ac868c9cc99bd320add6e95d2da10cb2cab60135070effd00502", + "fixed_compiler_tapes": 78, + "geometry_dimension": 2, + "mutation_rejections": [ + "actual owner rows", + "post-remainder", + "actual spacing" + ], + "optional_fixture_snapshot_tapes": 2, + "paid_compiler_snapshot_retirement": { + "moves": 9384, + "reads": 10645, + "writes": 2841 + }, + "prefixes": 2, + "rows": 4, + "scope": "Actual retained Machine/gather/prepare_child/return/scatter and new encoded compiler; reduced geometry, no selected O73 native fixture or reconnection theorem.", + "source_and_descriptors_preserved": true, + "status": "PASS_ACTUAL_ENCODED_CALLER_PACKET_COMPILER" + } + }, + "producer-fixture.py": { + "cycle": { + "actual_global_fence_callbacks": 0, + "borrowed_preserved": true, + "closed": true, + "discardable_private_dirty_on_entry": true, + "outer_prefixes": 2, + "sha256": "577ce7c7559db74c49f3ce80d131f4d0200c4c39339a48938e7efac173c61121", + "values": 32 + }, + "external_original_child": { + "actual_global_fence_callbacks": 1, + "borrowed_preserved": true, + "closed": true, + "discardable_private_dirty_on_entry": true, + "outer_prefixes": 2, + "sha256": "bffe01f431090d1453915b299b3e50f8a7a7fba88c3da301918c97b8881c157d", + "values": 32 + }, + "nonsymmetric_row_column_cycle": { + "actual_global_fence_callbacks": 0, + "borrowed_preserved": true, + "closed": true, + "discardable_private_dirty_on_entry": true, + "outer_prefixes": 2, + "sha256": "7dd3830c4a9e293b5ab22d662f385e1b4508da70b64b89939463fecd9dc2e89f", + "values": 192 + }, + "nonsymmetric_signed_native_conjugation": { + "actual_global_fence_callbacks": 1, + "borrowed_preserved": true, + "closed": true, + "discardable_private_dirty_on_entry": true, + "outer_prefixes": 2, + "sha256": "6c56fa6e95dbb3796ed62e1774b1a49e5e79882e46fe3019fe8d28d7793760ab", + "values": 192 + }, + "rejected": [ + "omit_exchange", + "omit_translation", + "omit_sign", + "transpose_record", + "transpose_owner_translation", + "reverse_owner_conjugation" + ], + "scope": "Reduced actual Tape/BankPackets/MonomialPackets/Ordinary/Machine execution; no selected O73 payload or supplier theorem." + } +} diff --git a/research/qq16-caller-install/LIFECYCLE.md b/research/qq16-caller-install/LIFECYCLE.md new file mode 100644 index 0000000000..ed1e42e347 --- /dev/null +++ b/research/qq16-caller-install/LIFECYCLE.md @@ -0,0 +1,298 @@ +# Whole-cover storage installation and immutable current-bank return + +This is the storage component of the proposed post-QQ16 connection. It does +not identify the recovery's original values with the caller's required current +values. The continuation component must first perform its proved current-value +and frame reconstruction, in the actual parent numerical representation. + +The selected fence is after the complete `QQ16 B_1_2` local-cover sweep +(original event 4), before original event 5's idle sweep and event 6's two-legged bridge. The new global producer binding expands the original event into explicit barriered groups and exposes its `global_fence` (573 in the frozen compilation); the service passes that authenticated fixed event to `expected_event`. It is +not a cut inside one 704-packet gathered local group. Recovery's cover maps +require entire fields and barriers between cover sweeps. The actual source +`finish_group` commits the last group's modifications to `roles['current']`, +sets `group=None`, advances `cover_index` to the cover cardinality and resets +`pc=0`. At this fence the parent's BankPackets is closed. Its next original +`next_group` advances to the next event. `CallerStorage` checks this finite +control fence; the integrated source binding separately authenticates that +its expanded fence corresponds to original selected event 4. + +## Physical boundaries + +1. **Producer entry/fence.** The active caller owns its complete current bank, + fourteen input and four derived descriptor roles, finite control and any + ancestor continuation stack. All original 704 bank packets and eight private + packets are closed after group commit. Their bodies being empty grants no + permission to reuse hidden primitive scratch. The parent is not closed and + cannot be passed to `Machine.run` again. +2. **Prepared service entry.** A separate `BankPackets(F,1,224)` gathers the 224 + selected entire families. Its per-row extent is `Gamma * parent.row_bits`, + supplied by encoded `Count` multiplication, and its row count is parent + `unused=U`. Its source remains the exact parent current bank. Each acquired + field has `V=P*Gamma*U*row_bits` bits and order prefix, cover, unused-row, + complete within-row address/coefficient/component. The separate native + compiler interprets this as `P*Gamma` prefixes and `U` rows. No cover, + spectator, compact field or outer row is discarded. These 224 acquired + fields remain borrowed inputs while the decoder owns 224 separate outputs + and 16 separate private fields. +3. **Completed recovery/reconnection return.** D has completed every borrowed + read. All its private fields are zero or empty and are physically erased. + Reconnection may reuse those now-retired private roles; its last use also + closes them. The 224 outputs contain the proved current values in the + parent's actual frame and numerical representation. The separate native + Machine and wrapper must be closed, their outputs consumed and their scratch + closed. `ready` checks every output's exact complete extent before the first + destructive parent publication. This is a length/ownership test, not an + arithmetic certificate. +4. **Continuation exit.** Each output is physically transferred to its now + read-complete acquisition packet. The inherited acquisition `scatter` + reconstructs the full bank, preserving every unselected family verbatim; + inherited `commit` copies it to the immutable parent `current` tape and + retires its acquisition packets. All 240 service fields are empty. The + parent's control, descriptors and ancestor stack still identify the same + fence. Original next-group execution performs the idle work, both bridge + legs and later return. Semantic equality of their inputs must be supplied + by the integrated continuation proof. The implementation's optional engine tuple checks actual closed/consumed-output flags when supplied; the production integration supplies its real engines. A fixture with no service native calls does not imply their production closure. + +## Ownership, generations and return proof + +The service constructors allocate fresh, pairwise distinct physical Tapes before +execution: 240 output/private tapes; 224 acquisition tapes, one acquisition +output and 16 acquisition scratch tapes; and a 64-tape descriptor pool. This is +**545 new fixed roles**, in addition to the existing caller, numerical bridge, +separate closed C Machine and wrapper Ordinary inventories. The packed decoder's input/output banks and its controller inventory are additional to these 545 roles and must be retained in the integrated ledger. The two distinct +backend inventories required by #4129 are retained. No parent productive helper, +parent scratch lease, or reserve-bank address is counted as service storage. +The service's own allocation scope runs with the parent scope suspended. Native +execution must likewise suspend the service scope and use its own inventory. + +`CallerStorage` uses a fixed finite output/private selector and phases +`closed -> decode -> reconnect -> ready -> closed`. It permits no new generation +before the preceding outputs retire, no early commit, and no indexed output +access after retirement. Only a compiled, nonescaping use of these selectors is +claimed. An unrestricted Python client can retain a raw Tape reference, so this +is **not** a general revocable-handle API or a claim that arbitrary stale Python +references become harmless. The actual inherited ScratchPool has its own +active-lease discipline; its contracts remain separate. + +At the fence, the whole current bank is preserved by acquisition. All subsequent +arithmetic operates on disjoint service storage and dedicated engines. The +parent descriptors, primitive pools, capsule, protected output, other live +roles and ancestor stack are unreachable from these declared destinations. +Thus their complete bodies and canonical heads are preserved. The baseline keeps the fixed +current-bank identity; the opt-in internal-role adoption below updates every +source role binding while preserving the public output and borrowed input identities. At publication, source `transfer` +consumes each output into its acquisition packet. Since all input reads have +ended, erasing that old acquired packet is legal. Source `scatter` emits exactly +one full replacement bank, choosing the selected packet at each selected family +and the original bank at each other family. `commit` then pays the physical copy +into the original current role. Every output retires after its actual last +publication use. The parent is ready to execute its original next instruction. + +This proof is at arbitrary admitted packet extent. It is conditional on correct +arithmetic, source closed-scratch and admission contracts. It does not promise +rollback from arbitrary malformed primitive failures after publication begins. +All returned extents and closure conditions are checked before publication; +source mutation during the suspended interval is outside the admitted execution. + +For the default fixed-copy path, the unchanged #3464 source-relative parent-return theorem applies directly: +current `machine.py`, `parking.py`, `bank_packets.py`, and `selected_binding.py` +are byte-equal to that package's `inputs/pr3385` files. Therefore subsequent +recursive descendants preserve the restored continuation under #3464's callee +completion and primitive-closure premises. Its `4B+733` stack-frame length is an +encoding identity, not the service invoice or a new arithmetic theorem. + +## Constructive local bill and high-water backing + +Let F=14336, Gamma be the selected cover cardinality, P the outer-prefix count, +U the exact unused-row quotient, and E=Gamma*row_bits. Then + +``` +B = P*F*E*U complete immutable parent bank bits +V = P*E*U one full family field bits +bE = bitlength(E*U) encoded within-prefix field extent +bP = bitlength(P) +``` + +`row_bits` retains the actual component width H_b, both real/imaginary +components, coefficient count and every address field. It is not based on W_c +unless a separate proved representation conversion produces the parent's actual +format before publication. + +The local storage invoice is the **sum of executed disjoint intervals**: + +``` +T_descriptor ++ T_gather(B,P,F,E,U) ++ T_discard_owned_dirt ++ T_private_zero_check_and_retire_at_D_end ++ T_private_zero_check_and_retire_at_reconnection_end ++ T_validate_224_outputs ++ sum(i=0..223) T_transfer(old_acquired_i, completed_output_i) ++ T_scatter(B,P,F,E,U) ++ T_commit_and_release(B,224,V) ++ T_finite_control. +``` + +Every term names source or new physical loops. `T_descriptor` includes encoded +multiplication, division/stock checks, construction and retirement of Counts; +it is the packet/compiler component's bill and must not be treated as zero or +counted twice. The arithmetic/native/correction invoice is additional. The +baseline's unchanged work remains in both full comparisons. This storage +mechanism removes no original arithmetic interval by itself. + +For equal old/new field lengths V and canonical heads, literal counting of the +current `parking.transfer` gives `7V+7` reads, `3V` writes and `6V+10` moves, +**16V+17** cell actions per output publication into acquisition storage. For +unequal old/new lengths A/V the corresponding total is `5A+11V+17`. This +transfer is actually executed; #3380's different implementation's 22V+13 saving +is not imported. `scatter` and `commit` subsequently perform full-bank passes +and are charged separately. + +A deliberately loose explicit bound for the storage loops (excluding encoded +arithmetic in `T_descriptor` and finite-control instructions) is + +``` +4096 * (B + P*F*(bE+1) + 240*V + D_dirty + bP + 1), +``` + +where D_dirty is the total discarded service-body length at entry. The bound +allows both private closure phases, all output checks and all source rewind, +clear, gather, scatter, commit and release loops. To verify the bound, a Counter +initialized from a b-bit nonnegative canonical Count and decremented n times +has at most `64*(n+b+1)` physical actions: initialization/closure is linear in +b and the sum of trailing-zero ripple lengths over a full countdown is below n. +Each bit scan/copy adds a fixed number of reads/writes/moves. There are at most +2PF per-prefix field counters in scatter and PF in gather, plus the fixed +output/private checks; rewind/clear passes are linear in their actual bodies. +The factor4096 dominates these explicit multiples. Descriptor arithmetic is +outside this estimate and must retain its separately executed Count bill. + +Additional simultaneously retained payload volume is at most `B+464V+D_dirty` during +publication (acquisition bank output B, 224 old/new acquisition fields, 224 +recovery outputs, 16 private fields, and retained backing from any initially longer discarded dirt), plus encoded descriptors and the numerical +engines/bridge's separately charged high-water backing. Some lifetimes overlap +less; this upper bound deliberately does not claim that erasure releases Python +allocation. Across sequential invocations fixed physical roles retain their +maximum backing. Parent ancestry and the inherited native recursive workspace +are additional and already belong to their own source contracts. + +## Optional completed whole-bank adoption + +`commit(..., adopt=True)` replaces only the final `BankPackets.commit` interval, +after the same output transfers and actual complete scatter. The parent +`roles['current']` is an internal role; its public `Machine.output` and the +borrowed root input remain on their original physical tapes. A caller insisting +on an immutable internal current-bank physical tape uses the default copy path. + +At this completed fence, the exact source's relevant current aliases are: + +- `parent.roles['current']`; +- its single position in `parent.parked`; +- the same logical position in `parent.parking.roles`; +- `acquisition.source`, whose last read ended during scatter. + +The parent's own BankPackets is closed with `source=None`. Group is None and no +primitive is active. Capsules, public output, numerical descriptors, native and +wrapper inventories are separate. The returned bank is the complete binary bank +created by actual scatter; exact length is inherited from that completed source +scatter and the prior output preflight, not established by a binary scan alone; the optional code additionally scans its complete +binary body and preserves the removed copy loop's alphabet rejection. It checks +both origins by actual head-relative marker reads. Registered external-role +inventories may name neither exchanged tape; this explicit precondition prevents +a stale cached external alias from silently surviving the exchange. Raw current +aliases must not escape the fixed compiled service boundary. + +The finite-control transaction swaps the old current physical tape with +`acquisition.output`, updates `roles['current']`, `parked`, and `parking.roles` +together, and ends `acquisition.source`. It then physically clears the old bank, +now the acquisition output, erases its owned marker and performs the same source +acquisition release. Every other physical role and its body/head is unchanged. +The fixed role universe has not grown. Finite control can represent this as one +permutation of the fixed physical roles; pointer assignments are a host +representation of that finite selector, not data-dependent RAM addressing. + +`current_bindings` checks the entire original constructor correspondence +`parked == (*roles.values(), *bank.packets, *private)` and the identical Parking +role tuple before and after the transaction. Omitting either parked or parking +updates rejects. The default publication and adopted publication leave the same +logical bank and subsequent source continuation. All next source operations use +these updated tables. A second invocation on the same closed Machine is allowed +after its public output is consumed; acquisition's next `arm_empty` rearms the +old current tape as its now-empty output. + +An ancestor frame contains only four-bit encodings of role bodies and fixed +role delimiters, not physical aliases. Its logical role order and length do not +change under the transaction. Consequently, after child roles close, actual +`Parking.restore` restores each ancestor word into the current binding of that +logical position. The #3464 induction therefore extends under this finite +permutation: decoded ancestor values and all next-continuation selections are +unchanged. This is a new role-binding adaptation of its unchanged codec, not a +claim that #3464 already proved the opt-in modification. Synthetic nonempty +frames are exercised through actual source Parking, explicitly as codec oracles. + +Let B>0 be the complete old/new current-bank bit length. Between completed +scatter and the common `release` interval, literal source counting gives: + +| Tape actions | Default fixed-copy commit | Optional adopted commit | Saved | +|---|---:|---:|---:| +| Reads | 9B+13 | 4B+11 | 5B+2 | +| Writes | 3B+1 | B+1 | 2B | +| Unit moves | 8B+16 | 4B+14 | 4B+2 | +| Total | 20B+30 | 9B+26 | **11B+4** | + +The adopted column includes the origin tests, complete binary scan and paid old +bank erasure. The same release of all acquired fields cancels constructively. +Everything before completed scatter is identical. Thus in this tape-I/O model + +``` +T_install_adopt = T_install_copy - (11B+4). +``` + +A model charging finite control additionally retains its explicit fixed-role +selector cost `c_R` (and accounts for any common control cancellation). No +unqualified wall-time saving is inferred. Across reached installations, subtract +`sum(11B_u+4)` once per completed installation and charge the corresponding +finite-control terms; do not subtract it again from native descendants. This +reduces an actual expense of the new connection, not the original source's +arithmetic toll, and by itself establishes no affordable supplier or new kappa. +The 545-role inventory and payload/high-water bound remain unchanged; per-role +backing may move between the two owners but no backing is claimed released. + +## Reuse and evidence + +| Contribution | Classification | What is reused and what is not | +|---|---|---| +| Sagar Thakrar #3464, head56b856a8c6dbd44c4a15bde694c08bbaff6f3e2f | Reuse unchanged | Four principal controller files are byte-identical; successful arbitrary-depth parent return applies under original callee and closure premises. No new whole-service cost follows from frame length. | +| Tekalign #3380, head072fd13a64095122bdad44009ab216aa4e1c1c1c | Adapt with new proof and cost | Reuse its finite internal-role permutation idea at the completed full-bank boundary, with the actual complex Machine's three current-role bindings updated. Baseline fixed-copy commit remains available; the new saving is 11B+4, not 22V+13. | +| Victor Li #3993, heade4fa89214086fb096c4276bbea891a1e6fae6c7b | Regression evidence only | Its stale-lease and CALL empty-pool examples motivate phase/closed-pool tests. It is a BIT Machine contract, not an imported invariant about the complex service. | +| Jose Manuel #3055 / actual source cohort | Reuse unchanged where inherited | Compact/native dirty-restoration support remains in #4129's actual source closure. Service storage does not reprove or replace its ordinary/native admission premises. | + +`lifecycle.fixture()` executes the actual retained Machine, BankPackets, +Tape/Count operations, original child entry/return and two actual bridge scalar +legs per cover. It uses two-dimensional reduced geometry with 224 whole cover +families, two covers, two outer prefixes and 3,584 owner/address-dependent complex +values. All224 outputs and all16 private roles are exercised. The service +transformation is identity and is labelled **storage-only**; it is not an +endpoint double being called actual QQ16 arithmetic. Original and installed +complete runs have the same endpoint. It checks all other parent role bodies and +heads including the empty root ancestor stack, the baseline immutable current identity, borrowed +root/descriptor preservation and eventual cleanup. Controls reject early commit, +parent/output alias, unrestored private dirt, unclosed native output, a short +224th output before destructive publication, retired selector access and double +commit. The optional `fixture(adopt=True)` executes two complete root invocations +on the same actual Machine, with 20 original child entries and 20 returns; the +second root exercises original recursive returns after the first role exchange. +Both roots produce the same reference endpoint and preserve public output/input +contracts. `adoption_fixture()` separately meters both commit paths at bank +lengths 2, 6, 18, 66; exercises four nonempty frames through actual Parking and +restoration into rebound logical roles; and rejects omitted parked/parking +updates, a cached external current alias, and an invalid returned binary symbol. +These nonempty frames are explicit codec fixtures, not a claimed selected native +execution. The all-depth adaptation is the logical-role-order argument above. +The full lifecycle fixture's metered subtotal includes its deliberately executed +rejection controls and is labelled accordingly, not used as the production bill. + +Open next question: compose this storage mechanism with the independently +source-bound D/current-value reconstruction and actual numerical/native route +at the selected global fence. The storage witness alone is not significance B; +publication requires the integrated mechanism and its same-boundary invoice. diff --git a/research/qq16-caller-install/PACKET.md b/research/qq16-caller-install/PACKET.md new file mode 100644 index 0000000000..3e3142d427 --- /dev/null +++ b/research/qq16-caller-install/PACKET.md @@ -0,0 +1,280 @@ +# Actual caller packet and encoded descriptor boundary + +Chris R, with substantial OpenAI Codex assistance. Apache-2.0. The retained +physical controller, encoded Count operations, gather/scatter and recursive +capsule implementation are credited to Jose Manuel and their source lineage. + +## The cut must respect complete cover sweeps + +The selected mechanism's producer boundary is the **complete bank after the +QQ16 replacement of the first B1 sweep**, before the next source idle sweep and +bridge. It is not one local F0/B1 group. The selected producer and decoder have +cover-wide barriers and owner maps; completing a single 704-packet gather does +not complete those operations. The central continuation proof must identify +and justify that global program boundary. + +The compiler here is a building block at the actual gathered-group boundaries +inside such a global program. Its interface is an actual retained `Machine` +with `mode == 'group'`, nonempty `group`, `bank.state == 'gathered'`, and closed +scalar/leaf/monomial scratch. It does not infer a global cut from those local +conditions. It does not assert that a QQ16 recovery invocation appears in the +unchanged selected binding. + +The four boundaries relevant to this component are: + +1. Producer entry: an admitted complete physical parent bank, with encoded + root and current-node descriptors. The root's row padding, numerical grid, + arbitrary dirty helper values and initial ownership are inherited or proved + by the integrated producer contract, not fabricated by this compiler. +2. Prepared native entry: a current owner packet acquired by the actual + `BankPackets.gather` path, then the decoder's owned copy and signed right + wrapper, together with the encoded child descriptors below. The decoder + owns its output/private banks; the original current bank remains borrowed. +3. Completed native return: the exact retained C endpoint returns the same + complete rectangle. Two numerical interfaces are distinguished below. The + installed fine-grid route retains the actual source quantum and width, using + the new full-pipeline range/divisibility argument. Both positive and negative + calls use identical physical geometry; their right/left monomials, including + the negative XOR, remain paid work. +4. Continuation exit: the new current values are written to the required fixed + source owner ports, every cover sweep is committed, both subsequent source + bridge legs run, and all protected decoder/compiler storage is retired. + Packet construction alone proves none of these semantic exit conditions. + +## Encoded compiler and complete packet preservation + +`packet.py:PacketCompiler.compile` takes the actual source Count roles. No +packet length, row count or width is decoded into a Python integer. Binding +constants (dimension, maximum child rank, families, cover cardinality) are +finite source program constants. Count arithmetic is executed under its own +fixed 64-tape scratch scope; the caller scope must be suspended and empty. + +Write n=73, m=48, L=14336 Gamma in the selected source. Let the actual parent +have e=n lambda after remainder processing, R rows, spacing K and suffix A. +The compiler checks with encoded arithmetic: + +* lambda=`columns` is positive, e=n lambda, and e<=root_width; +* prefixes, unused rows, K, guard, physical component width, coefficient count + and root_width are positive; residue (y,-x)`; a subsequent `scale(-1)` on its +second output converts it to a plain swap. Then, for output owner `d`, an actual +identity-matrix monomial translates every active column by `d delta`. Scattering +the gathered packets restores each result to its immutable physical owner. +Outer prefixes, unused rows, coefficients and spectator fields follow the +existing BankPackets/MonomialPackets contracts and are not removed. + +The 528 literal maps have orders `{2:464,5:24,6:12,12:20,17:4,20:4}`. Thus at +most 20 packet slots suffice, within the admitted 704. All translation vectors +are nonzero. Every group code is below the source 65536-PC limit. These are +fixed supplier control alphabets; no numerical payload or variable Count is +decoded to obtain the cycle. Production execution would still pay every bank +scan; the finite group algorithm is not an efficiency claim. + +This resolves a specific dispatcher issue: a payload monomial inside one +704-owner gather cannot change cover owner. The new cycle dispatch changes the +actual selected bank keys and retains the full-cover barrier order. + +## Original child endpoint and suspended parent + +Running the changed binding recursively without further proof would silently +change every child supplier. `machine_class` therefore supplies a narrow +`ProducerMachine` adaptation. At `prepare_child` it uses the source-created +capsule and source header, verifies the exact target/rank/program counter, then +calls a distinct closed **original-binding Machine**. It consumes that result +into the designated parent packet, erases the capsule and header, and resumes +at the source's next PC. The parent is not re-entered; its group, other packets +and private fields remain protected while the separate engine executes. +All original child recursion, parking and restoration remain within that +original engine. The complete bill includes both engine inventories and +simultaneously occupied parent/capsule/child backing. + +The optional `at_fence` hook runs only once after the final B group has closed, +with the parent scratch scope suspended. Before and after the hook, all actual +parent primitive engines must be closed. Its callback must separately prove +recovery, owner reconnection, leases and eventual retirement. A hook's presence +is not evidence that those duties have been discharged. + +## Constructive producer invoice + +Keep the original and new construction on the same entry/exit boundary. The +new route replaces two original local-cover sweeps, retains their two +centre-free cores, and pays these additional literal QQ16 outer operations: + +- `2200 Gamma` ADD, `32 Gamma` private CLEAR, `16 Gamma` SCALE; +- `32 Gamma` original rank-one child invocations, each with four physical + monomial calls (`g^-1`, right recipe, left recipe, `g`); +- `(12286/51) Gamma` map-cycle gather/scatter/commit groups; +- `(14642/51) Gamma` source exchanges and the same number of extra sign scales; +- `528 Gamma` actual owner-dependent translation monomials. + +There are `43 Gamma` non-map groups, so the two changed producer intervals use +`(14479/51) Gamma` total gather/scatter/commit groups versus `2 Gamma` originally. +`Gamma` is divisible by all listed orders because each is an order in the +finite group. Each group scans the complete parent bank; counting one frame +length or only the moved packet omits this charge. Scalar allowance, physical +actions and child recurrence charges must remain different units. No physical +runtime dominance follows from these counts, and no saving from a removed +centre child may be credited twice by the recovery or continuation comparison. + +The external-child adapter applies to **every root child invocation**, including +the retained later source events. `root_child_census` therefore counts the entire +482-event original and 1051-event installed root, using the actual compiled +local words and every finite idle remainder. It checks each idle family's +pending-axis suffix and an actual dispatcher witness for each of the four idle +ranks. Local outer owner views and the other source event branches contain no +children; consequently these histograms are independent of the cover owner. + +| Root interval or component | Original child calls per Gamma | Installed child calls per Gamma | +| --- | ---: | ---: | +| Changed source events 0 and 4, including new producer lines | 6,988 | 7,004 | +| Intervening source events 1–3 | 10,482 | 10,482 | +| Source idle event 5 | 95, all rank 3 | 95, all rank 3 | +| Source bridge event 6 | 0 | 0 | +| Entry through source bridge 6 | 17,565 | 17,581 | +| Later source events 7–481 | 493,097 | 493,097 | +| Complete root | 510,662 | 510,678 | + +The retained clean pair contributes 6,972 calls; the new outer lines contribute +32 rank-one calls. The only removed calls are 16 rank-eight centres. The whole +original rank histogram is `{1:349604, 2:60192, 3:62585, 4:20448, 5:11808, +7:7, 8:1152, 48:4866}`; the installed root adds 32 to rank one and subtracts +16 from rank eight. Decoder service children are separate from this census. +Matching a retained rank or even its invocation count does not cancel source +parking/restoration against the new external transfer protocol. The complete +invoice must price both protocols over the full root, with their actual packet +contexts and coexisting storage. + +## Executable evidence and limits + +`producer-fixture.py` runs the actual Tape, Count, BankPackets, scalar, +MonomialPackets, Ordinary and Machine code on a two-dimensional complete cover, +with two outer prefixes, nonconstant owner-dependent signed complex values, +and an untouched second family. It separately exercises an original-child +return through the new controller. Independent expected arrays are test oracles, +not claimed input loaders. Omitted exchanges, omitted translation and omitted +sign correction each reject. A second actual fixture uses the full six-owner +O(3,2) cover and a nonsymmetric order-three map on 192 complex values. An +independent dense row-matrix oracle checks its owner product and address action; +transposed map-record and transposed owner-translation controls both reject. +An additional O(3,2) fixture applies both signed native lines through the +actual original rank-one child, conjugated by every owner, on 192 nonconstant +complex values across two prefixes. Its independent dense row-dot-vector +oracle computes the direction `d e0`; reversing the `g^-1`/`g` conjugation +rejects at the nonsymmetric owners. These calls exercise the actual native +leaf endpoint, not a recursive non-leaf production payload. +These executions preserve borrowed payloads and +encoded descriptors and close the parent/child engines. + +The reduced fixture does not execute a selected O(73,2) payload, all 224 +recovery outputs, or the entire integrated QQ16 continuation. Production +applicability requires the central packet/range/lifecycle admissions and the +source-relative all-depth primitive and clean-core contracts. A module-level +scalar oracle does not by itself check physical composition. + +`integrated-fixture.py` additionally runs one continuous reduced physical +caller. Its producer applies opposite signed actual C lines to two fields, +preserves a nonconstant intervening helper through actual translations, reaches +the completed cover fence, and calls the real `Installation`. That installation +uses the encoded whole-family compiler, acquisition, ServiceBank, DecoderBinding +and original C engine, extracts both outputs, retires private generations and +publishes to fixed parent fields. The parent then executes an actual idle child +and both signed bridge instructions before returning. An independent exact +Gaussian oracle checks every one of 64 complex entry/exit values across two +prefixes, four families and two cover owners. A second generation uses different +nonconstant input on the same parent, original-child and service engines and +the same installation, checking reuse after publication and retirement. +The fixture also attaches the producer to an actual reduced `RootLayer`, +preserving its public roles and plan and rejecting an active root or a wrong +inherited child, as well as each changed dimension, rank, family-count or cover +geometry. It then exercises the installed kernel directly; it does not +claim execution of `RootLayer.run` or its full outer protocol. +Wrong producer sign, early fence +and output/acquired-field alias each reject. This is a reduced composition test +of the real implementation, with explicitly test-only initial arrays and +reduced finite control; the full 224-output/source-Q word remains covered by its +separate source-relative compilation and semantic obligations. + +## Attribution and next questions + +Jose Manuel's physical C controller, encoded packet transport and compiler are +reused. The joint-query source retains the original QQ16, local-core, phase and +helper-owner contributors and their notices. New finite cycle dispatch and the +separate-child adapter are by Chris R with substantial OpenAI Codex assistance. + +The reduced integrated fence callback now passes through the encoded whole-field +compiler, exclusive lease protocol, current-value reconstruction, intervening +child and both bridge legs. The remaining discriminating questions concern the +production parameter admission and compatible complete invoice: the selected +224-output compilation, full source interval range, physical high-water stock, +and the charges for the new owner routing and separately closed engines must +all agree with this controller. Reduced execution alone does not establish +affordability or an exponent improvement. diff --git a/research/qq16-caller-install/PROOF.md b/research/qq16-caller-install/PROOF.md new file mode 100644 index 0000000000..a19beac6fc --- /dev/null +++ b/research/qq16-caller-install/PROOF.md @@ -0,0 +1,276 @@ +# One actual QQ16 caller installation + +Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0. +All source notices remain intact. This is a conditional source-relative +construction and constructive local bill, not formal-kernel verification, +human acceptance, an affordable supplier or a new multiplication exponent. + +## Statement and significance + +Fix canonical main bb4bccbf42844d2801487450727c2f63e10d1d0f and the authenticated +inputs in SOURCES.json/PREDECESSORS.json. Assume the original physical complex +controller's exact C/native/common-label and chronological hosting refinements, +its ordinary B1/C0, Compact, root-layout, long-record and source-entry height +hypotheses. At a nonleaf original root node after remainder processing write +e=73 lambda, lambda>=1, d>=e and d<=e^1000. Retain its actual global p,d,K,G, +H_g=dG, physical width H_b=p+2 Delta+3, Delta=2^210000 d, all passive fields, +coefficients, residue and complete row stock. The input is any admitted +nonconstant owner-dependent payload, with arbitrary correlated productive +helpers satisfying that source entry bound. + +`connection.bindings` compiles the actual selected producer with just execution +events0 and4 replaced by the QQ16 F_0/B_1_2 macros. `connection.install` installs +it in the actual RootLayer.fast_core machine before input, keeping the former +original C Machine as a distinct, sequential child endpoint. A separate service +Machine, with its own Ordinary backend, runs all frozen #4106 recovery events +and the current-value reconstruction at the completed global B fence. All +original recursive descendants use the unchanged original C binding. + +Under the stated hypotheses this returns the same logical complete caller bank +as the original producer at that fence, including all live helpers and outer +rows, up to the proved internal current-role exchange. It then executes the +original event5 and both legs of event6, and the remaining source instruction schedule. The external-child adapter changes every root child-call protocol, including the later suffix; its full invoice is retained below. Immutable public root input/output ports and encoded plan are retained. +The material new implication is **actual producer bank -> paid encoded service +entry -> exact all224 current outputs -> actual continuation and retirement**. +#4129 supplied only prepared native packets; its theorem is inherited, not +renamed as this installation. Local arithmetic and callback evidence alone +would not establish this statement. + +The package meets enabling-mechanism class B only subject to this proof's +explicit premises and final verification. Its complete local invoice is +constructive but fails the stated homogeneous native-charge screen. A favorable +runtime comparison and full supplier/bootstrap admission remain unproved. + +## Source-bound decision and four typed boundaries + +**Producer entry.** The actual selected root bank precedes event0. RootPlan +padding and reserved/remainder leaf work are unchanged and paid. The current +bank contains14336 complete families over Gamma=|O(73,2)| owners, including +productive helpers and independent other pairs; caller frames, descriptors and +all source engine inventories remain live. No original input is imported later. + +**Prepared recovery entry.** Replace source local cover sweeps0 and4, leaving +all480 other source events in their order. The new fence is expanded event573, +after every owner has completed and scattered, with group=None, pc=0, +subgroup=0, cover_index=Gamma and bank closed. Actual BankPackets(14336,1,224) +acquires whole families0..223, not one704-role local gather. They are borrowed +immutable current X/Y in their QQ16 frames. PacketCompiler validates this +whole-family rectangle and constructs a paid auxiliary descriptor block with +prefixes P Gamma, rows U=R/(14336 Gamma), width lambda and suffix extended by +72 lambda K. The compiler retires this auxiliary block; it is not passed to +the installed decoder or its native calls. The installed service instead +receives encoded descriptors with prefixes P, rows448 Gamma U and width73lambda. +Its source node computes unused rows U; each owner's actual prepare_child(target,1) +supplies prefixes P, rows U, width lambda and the extended suffix to original C. +All other physical fields are preserved. +The service bank, made by encoded outer-prefix countdown and finite family +loops, has order P,family,cover,U,row,448 families and rows448 Gamma U. Its +224 new output families and private16 roles are exclusively owned. Its source +copy, current/replacement bank and protected return are additional backing. + +**Completed recovery/current return.** D runs in a separate source Machine; +its actual prepare_child capsule goes to the original C endpoint. Every +signed recipe uses owner inverse, right wrapper, original C, left wrapper and +owner return; no active Machine is re-entered. D returns224 originals in F17 +and leaves all224 borrowed fields unchanged. Apply W+=Z; Z-=W; then112 negative +C_(d q) lines on W, giving current X=-F17 y and Y=F17 C_(d q)^-1(x+y). +Extraction compares every borrowed bit, copies every owned result and consumes +both service banks. The physical quantum remains q_s=2^(-p-Delta), without +coarse projection; exact original C completion and the interval bound below +supply exact return. #4129's different coarse adapter still requires its own +low-zero/sign-extension tests if chosen. + +**Continuation exit.** Preflight every output and engine boundary before the +first destructive publication. Transfer224 completed fields into their +read-complete acquisition fields; scatter all of the parent bank, preserving +every other family/spectator. Default integrated publication adopts that +completed internal bank and updates roles['current'], parked and Parking's +role list, erasing the displaced bank. Public RootLayer input/output ports +stay fixed. All service generations, fields and private storage retire before +event574 (source idle5) and575 (source bridge6). Both X0+=X1 and Y1-=Y0 run on +the required immutable family ports and current frames. Later source instructions see the same logical state under the changed, paid external-child protocol; no old private query survives for free. + +## Composition argument + +1. **Producer semantics and barriers.** The certificate's centre-free cores +are compiled through the same source compiler, owner charts, entry/exit +translations and actual helper families. `helper_contract` checks every +normalized helper unit row, persistent final label and private zero return in +both original and clean words. The persistent native progress is identical; +this is not physical helper identity and is conditional on original centre +refinement. Under the inherited labelled lift, both have identical helper +endpoints for arbitrary correlated inputs. All704 owner families in each +intervening event1--3 are disjoint from pair0 families0..223; source event5 also +excludes them. Hence changing pair0 before recovery cannot change those other +operations. QQ16 global macros retain every cover barrier; their cyclic owner +router gathers actual physical keys. Matrix rows and columns are explicitly +converted: stored registry columns A become row representation for dA, while +d(delta) is a row-dot-vector action. Each finite right-multiplication orbit +of order k is rotated by k-1 paid exchanges plus sign corrections, followed +by actual payload translations. No owner routing is an address oracle. + +2. **Recovery and current values.** Inherit the authenticated D algebra, +including its ordered Q2(X_T)-M21 Q1(Y) residual, route order and T port. +The compiler changes only legal physical lowering and bank placement. All224 +frozen signed occurrences and all112 continuation-negative lines are bound to actual73D source wrappers; firstpositive +event4 is W0/q11 and firstnegative event1705 is Z10/port76/q448. The two full +24767-event selected scalar shadows give S_F(x,y)=(x,y+x) and S_B(x,y)=(x-y,y). +The selected-complex-layer-closure/PROOF.md section2 common-label tensor lift, +with actual DATA-PHASES gauges, lifts these equations. X/Y at a port have the +same actual owner route so the scalar coupling commutes with it. Their pair +therefore has logical G(x,y)=(-y,x+y), not the centre-free J map. Two unit +shears on recovered F17 outputs construct that G; the negative Y line supplies +the actual hole frame. F17 and that line commute as convolutions. This resolves +the current-value/frame premise beyond #4105/#4108 without inverting a private +CLEAR transition or using a constant-payload repair as a native implementation. +Read those obstructions within their fixed-producer/query classes: this route +changes the actual producer and pays the complete recovery/current return. + +3. **Geometry and stock.** PacketCompiler uses only encoded Count operations, +never decoded numerical sizes. It checks actual positivity, residue, root/current +width, complete field extent, divisibility and actual inherited unused rows. +Rank-one prepare_child moves72 lambda coordinates to the suffix, preserving +front/back/compact/passive address volume exactly. With L=14336 Gamma and +D0(e) the source depth law, L^D0(73lambda)|R implies +L^D0(lambda)|U since D0(lambda)<=D0(73lambda)-1. The service top divisor is +448 Gamma solely to expose U; its children explicitly use the original L. +The service retests leaf admission on the post-remainder width: PacketCompiler computes its capped encoded1000th power and rejects if it is below d. Passing the original pre-remainder test alone is insufficient. Root padding supplies stock only on the inherited admitted root domain and +removes padding at the unchanged final boundary. No arbitrary cut receives +stock from the conditional #4129 implication alone. See PACKET.md/DECODER.md. + +4. **Numerical admission.** Separate logical W_c, reserve a, physical H_b and +address H_g. We retain actual H_b and fine q_s for the entire installed interval. +Start from inherited bound h0=2Bd on all current data/helpers, where +B=1041408 Gamma+2^100000. The actual complete46-body changed producer including +intervening source groups has conservative growth g_P=230124+27834lambda and +denominator debt d_P=84422+27834lambda, including Horner intermediates and +completed native ranks. Each coefficient is below2^22, so both are bounded +by2^22(lambda+1). A full-cover permutation charges each per-owner body once +in the maximum norm, not Gamma times. The inherited D bounds are19+3t growth, +9+3t debt for t=lambda-1; one unfinished original C has its own2Br lambda +interior reserve. Current shears add at most2 growth bits; final line and +both bridge legs are separately included. All complete/interior bounds fit +(4B+2^24)d < 2^210000 d=Delta. Thus every ideal intermediate lies on q_s and +fits signed H_b; applying the inherited exact bit implementation yields exact +arithmetic, with zero completed error. This argument proceeds from ideal +range/divisibility to bit refinement, rather than assuming bit exactness to +prove its own admission. No completed norm58 bounds dirty interiors (#4114 +is a countercontrol). See COST.md for the full inequalities and domain. + +5. **Exclusive inventory, return and recursion.** Before input three distinct +Machine/Ordinary inventories are constructed: modified parent, decoder service +and original recursive C. The latter is shared sequentially only while closed; +all parent/service productive helpers, pools and suspended banks remain owned. +A fixed-role census excludes aliases across these inventories and compiler, +acquisition and output tapes. It traverses no numerical payload. All engines +must be closed, outputs consumed and pools empty at a service boundary. The +source root plan keeps its exact dimension/rank/family/cover geometry; a changed +plan is rejected before attachment. Source-history comparison shows the four +principal #3464 files are byte-identical, so its original parent return applies +with its successful-callee/closed-scratch premises. The new bank-adoption proof +uses the unchanged logical role order in its serialized stack; every internal +binding is updated. Raw Tape selectors never escape their compiled scope; +this is not a general revocable host-object capability system. The installed +first-pair service occurs once per reached nonleaf modified root invocation; +all original C descendants recurse under the unchanged binding. No all-node +QQ16 recurrence or native-child substitution theorem is claimed. See LIFECYCLE.md. + +## Constructive complete invoice and decision + +COST.md/BILL.json enumerate actual operations at the same producer-entry / +continuation-exit boundary. Only the two original local sweeps0,4 are replaced; +credit their16 rank8 centres once. Retain both clean cores and all other arithmetic. Their child-call transport/parking protocols do not cancel against external calls. +The new producer outer bill is2200 Gamma ADD,32 Gamma private CLEAR,16 Gamma +SCALE,32 Gamma C1,128 Gamma line monomials,528 Gamma map translations and +(14479/51) Gamma bank groups. D plus return adds336 Gamma C1,1344 Gamma line +monomials,352 Gamma map translations,2022 Gamma full448-family bank groups, +3484 Gamma direct scalar dispatches (exchange-internal scalar work is separately included in each exchange charge) and48 Gamma private-zero calls. Every group +performs the source's full appropriate bank scan. All native calls use their +actual complete packet volume, actual H_b and original recursive invoice; +internally paid parking is not charged again. Counts in different units never +pay one another. Both required bridge legs remain paid work. Common arithmetic counts do not prove identical physical child-call traces. + +Add actual full-family acquisition, encoded validation/setup (including the post-remainder nonleaf guard),448-family +assembly/owned zero initialization, service input copy/setup/protected return, +all borrowed comparisons/extraction,224 fixed field transfers, full-bank +scatter, private/old-backing erasure, output consumption and marker restoration. +Assembly/extraction has constructive bound4096*(S+448P*(bE+1)+bP+D_service+1), +S=448 Gamma P U row_bits; its engine/setup costs remain separate. The source +primitive operation sum is the complete constructive bill, not a numeric +runtime bound. Long-record rate domains remain explicit; unsupported optimized +routing prices are not imported from #3619. A sufficient fixed-role bound is +3I+2^20 for these three engines plus installation, I=2q_*^2+100696823; root and +prior suspended inventories remain additional. The finite extra545 caller roles, +78 compiler tapes,256 installer pool, service banks/descriptors and stack +high-water backing are separately accounted. Erasure does not reclaim historic +emulator allocation. + +After the common scatter, original fixed-copy publication costs20B_parent+30 +cell actions, adoption9B_parent+26: exact local reduction11B_parent+4-c_R, +with additional finite-selector cost c_R. This is a constructive trace pairing +under a proved internal-role permutation, public ports fixed. It is not a +reduction of original QQ16 arithmetic nor subtraction of unrelated upper bounds. + +The whole installed route adds368 C1 against16 C8 removed. For the specified +common packet-volume charge C_r=c(r lambda)^(1-alpha),0<=alpha<=1, +added/removed=23/8^(1-alpha)>=23/8. Even free post-D native reconnection leaves +256 C1 against at most128 C1 credit. This excludes that isolated homogeneous native-component charge comparison. Avoided original parent parking is a potential physical credit, while external-run copying is a new charge; those terms are not zero and can have either net sign. This is a budget screen, not a physical runtime +lower bound or universal QQ16 obstruction. The implementation is usable as a conditional source-bound caller mechanism. A successor targeting the native profile must change D demand/circuit, prove fusion/cancellation or remove more native work. Overall finite physical affordability additionally requires the complete protocol comparison, and is not decided by this screen alone. No new kappa is justified; selected kappa remains +836330098538459/500000000000000000. + +## Whole-root child protocol, including the later continuation + +The adapter overrides every child entry at the modified root. The source-derived +census is510662 Gamma original root child invocations versus510678 Gamma +installed, excluding the separate336 Gamma service children. The prefix through +source bridge6 is17565 Gamma versus17581 Gamma; the later suffix493097 Gamma +has unchanged ranks but a changed return protocol. The root census in +COMPILATION.json and protocol invoice in BILL.json retain all these occurrences. +They are not hidden in an unchanged-work cancellation. + +For each baseline child, charge actual prepare_child, primitive/origin checks, +parent parking, capsule transfers, the embedded original C execution in its +actual stack context, protected return/role clearing, parent restoration, +header decode, group rebinding and result replacement. For each installed child, +charge actual preparation/header validation, original Machine.run input and +14descriptor copies, exact C execution in its root context, protected root +return, result transfer and marker erasure, capsule/header retirement and PC +restoration. Service336 uses the same external protocol, with its own bank and +geometry. Descendant original C calls remain inside each actual C invoice. +Even equal C values/ranks do not authorize cancellation of context-dependent +physical body or outer protocol costs without an equivariance proof. + +Thus the complete comparison through the bridge includes every prefix protocol +on each side; full-root continuation adds the corresponding suffix difference +for all493097 Gamma calls, plus remaining instruction/return costs. This is +an explicit complete source-relative operation sum with actual context-indexed +primitive costs. It is not a numerical dominance claim. The next cheapest +physical discriminator is to price/measure those matched park/restore versus +external-run/copy protocols at actual packet/bank extents, together with the +new full-bank routing. Original parking can be a substantial avoided expense; +we do not treat it as free or infer its net benefit from endpoint equality. +The local11B+4 publication comparison is unaffected because its two alternatives +share the very same installed external-child protocol. + +## Evidence and explicit limitations + +COMPILATION.json binds the full selected finite program and all224 signed +recipes, source event isolation, frames and operation census. EXECUTION.json +records actual source Tape/Count/BankPackets/MonomialPackets/scalar/original C +execution in reduced geometry: nonsymmetric O3 routing with192 complex values, +actual both-signed decoder128 outputs, full224-field packing and storage checks, +and one continuous producer/fence/compiler/service/current/bridge chain on64 +complex values repeated with new input on the same engines. The initial payload +and expected arrays are explicitly test oracles. They do not implement entry +acquisition and are not endpoint doubles being passed as production C. + +Rejection controls cover descriptors/stock, wrong line/producer signs, wrong +matrix convention, premature fence/output reuse, aliases, incomplete final +output, dirty private return, unconsumed native output, altered root geometry, +shared Ordinary instances, stale selectors and repeated commit. Controlled +failure cleanup is scoped; arbitrary asynchronous interruption is not promised. +Production O73 payloads and complete RootLayer.run are not numerically executed; +all-size claims rely on the written composition and inherited refinements. +Assisted adversarial review shares sources and primitives, and does not mean +independent human acceptance. Hosted CI and committed-byte/export evidence are +reported separately from mathematical scope. diff --git a/research/qq16-caller-install/README.md b/research/qq16-caller-install/README.md new file mode 100644 index 0000000000..d1d42d5e49 --- /dev/null +++ b/research/qq16-caller-install/README.md @@ -0,0 +1,79 @@ +# Install the first actual QQ16 caller connection + +This package connects the actual selected F0/B1 producer, all224-output recovery, +the original recursive complex C endpoint and both legs of the named next +bridge. It replaces the actual RootLayer.fast_core binding before input; +encoded acquisition and a dedicated448-family service join its physical banks. +The new current-value word uses the selected G(x,y)=(-y,x+y), with the correct +owner-dependent F17/negative-line frames. All output/private storage is +exclusive, published and retired before the actual continuation. + +This is an enabling caller mechanism (class B), conditional on the inherited +source/native/hosting and physical admission hypotheses in [PROOF.md](PROOF.md). +No affordable supplier is established. Its explicit route adds368 rank-one children +against16 rank-eight centres removed, so the isolated common native-component charge comparison fails by a ratio of at least23/8. Even free final native repair does not fix that profile. The adapter also changes every retained root child-call protocol:510662Gamma baseline calls versus510678Gamma installed, plus336Gamma service calls. Avoided parent parking and new external input/return work remain explicitly priced; the whole physical comparison is unresolved. An internal whole-bank +publication adaptation saves exactly11B+4 tape actions (less separately charged +finite control) compared with this installation's fixed-copy path. That local +saving does not establish overall physical dominance or a new exponent. +Selected kappa remains0.001672660197076918. + +## Reproduction and evidence + +``` +python3.12 -I -O -Werror -B research/qq16-caller-install/verify.py +python3.12 -I -O -Werror -B research/qq16-caller-install/test_verify.py +python3.12 scripts/research_package.py --package research/qq16-caller-install +``` + +The first command authenticates every canonical and retained input before +inherited execution, compiles the full selected finite program, reconciles its +bill and numerical admission, and checks all typed committed receipts. Actual +reduced physical fixtures cover the continuous producer/fence/compiler/service/ +current-return/both-bridge chain twice on the same engines. Separate tests +exercise nonsymmetric O3 routing, both native signs, full224-field service +packing and lifecycle, dirty state, bad descriptors/stock, aliasing and reuse. +The full73-dimensional finite compilation is not production-size numerical +execution. Neither production O73 payload nor complete RootLayer.run is claimed. +Fixture payload loaders and expected integers are explicitly test oracles. + +[ADMISSION.json](ADMISSION.json) records each typed obligation, source, executable +control, cost and status. [COST.md](COST.md) gives the complete constructive local +operation sum, actual packet geometry, fine-grid proof and qualified decision +screen. [REUSE.json](REUSE.json) records all eight requested compatibility checks. +[SOURCES.json](SOURCES.json) pins canonical main; +[PREDECESSORS.json](PREDECESSORS.json) pins retained PR inputs, including #4129 +and the original #3464 controller bytes. Scientific pins are frozen independently +of later review/publication heads. [TASK.json](TASK.json) records the assigned +card and bounded search coverage. At most one PR is produced by this team. + +`connection.bindings()` compiles authenticated finite bindings after +`runtime.cold()`; `connection.install(root,producer,service,ordinary_factory)` +constructs distinct admitted Ordinary inventories, retains root.machine as the +original C backend and attaches the changed parent. Runtime inputs/descriptors +come through the actual source root interface and encoded compiler, not through +a host packet loader. The factory is exercised in the reduced continuous test. +Its caller must supply admitted original RootLayer/Ordinary constructors and +satisfy the proof's parameter domain; construction does not manufacture native +refinement or long-record admission. + +## Credit and review boundaries + +Chris R / Clear1nsight with substantial coordinated OpenAI Codex assistance. +Credit Ali Romman and QQ16/source authors; Arham Tahir and ywz65 for ordered +recovery, source routing and native normalization; #3985/#4015/#4106/#4109/#4129 +for the frozen decoder/precision/return lineage; Jose Manuel for physical C, +Compact, scalar/monomial and support machinery; Sagar Thakrar #3464/#3607 for +parent return/layout; Tekalign #3380 for the ownership-exchange idea; unpaidmoon +#4114/#4123 and Victor Li #3993 for scoped regression evidence. Exact reuse, +adaptations and limits appear in REUSE.json. Notices and frozen references are +preserved. Worker review shares sources and checkers; it is not independent +human acceptance or formal-kernel verification. Committed-byte/export replay, +hosted CI and review status are separate from the theorem's inherited premises. + +## Open next questions + +**Question:** Does the complete matched parent park/restore versus external-call protocol bill outweigh new routing/service costs at this actual cut, and can a smaller demand or fused recovery improve the native profile? +It matters because the native-component profile loses while the adapter also removes real parent-parking work on retained calls. First meter or derive the matched protocols at actual complete bank/packet geometry; retain every later root call. For native-profile improvement, pin both bridge observations and derive a smaller source-compatible demand or literal cancellation at the same boundary. Stop the specified charge comparison if its complete necessary inequality fails. No such +smaller decoder/cancellation is established here; changing the actual demand, +circuit or removable source interval is required. A complete supplier also +retains all inherited physical/admission/bootstrap obligations. diff --git a/research/qq16-caller-install/RESULT.json b/research/qq16-caller-install/RESULT.json new file mode 100644 index 0000000000..94f0c6dc81 --- /dev/null +++ b/research/qq16-caller-install/RESULT.json @@ -0,0 +1,297 @@ +{ + "D_plus_G_allowance": 27936, + "code_sha256": { + "auth.py": "98cd015d9b6c9501f36a305b58f9bef88b904b9d6bbd921e0a6ecd351b960a79", + "connection.py": "3da2ac158a6f36a568d0873cbb45f230ba8fa609cf8092bfbd55da83bae498c2", + "continuation.py": "9fa2de5d79768b4130f81a74f29f388ffc28c990512a9fa22921ec2d75401aca", + "cost.py": "935b23fee0abdce52279820febce93d23a2095f347ddf0da4fbd424995b99842", + "decoder-fixture.py": "b09b2751fccc37e3c2c864ce89aa13bbdc6bfba3296bbb816b9636ff1fbffea4", + "decoder.py": "e169a8b160bfa89dd22bc618df1ed947ebe668e82bca1014c70781ff9dcf75ce", + "installer.py": "6af289c0b21c11dad7efaa2f7373ad0f61a3d1d6975bcfb5d1560320373260df", + "integrated-fixture.py": "e4f8bcc947e761ca4f1efb825794210dfd56ca79e049a5207fbfad26ee7e71ae", + "lifecycle.py": "2eadca77717ee28c24dd6ff175a115277a83d852c56d320cc93937cab27e5191", + "packet.py": "d8f4e63feae1ed372951ba5643dadf02e2af006bf3632d29137e92d05067234e", + "physical.py": "d37813bcfbdd95f2e1b756d6f978ba2fdd4ec2b82212f2b7b228cb3422ee9b0a", + "producer-fixture.py": "4744a12cc9c015f6cfa6bddff6886f2eb163fec4ff2e3e07556cb37152c2ebf3", + "producer.py": "69a7cc6c9545a0d8684a529d6365345c337276f9c8faaf2dcdb0923ca72c396d", + "runtime.py": "ec760da8c8799ebb0c02e4ec0464d50c627e24d6a64514ab8f753d9d10cb8764", + "verify.py": "46f16651383d5677e641c3e2fed86b6c2f3b62834d0be1699cfa03a1de0385ec" + }, + "connection": "RootLayer.fast_core first actual F0/B1 cut: source events0,4; whole-cover fence573; idle574; both bridge legs575", + "logical_D_allowance": 26144, + "native_charge_screen": { + "added_rank_one": 368, + "added_width_sum_over_lambda": 368, + "formula": "(added - removed*8**(1-alpha))*73**(alpha-1)", + "minimum_added_over_removed_charge_alpha_0_to_1": "23/8", + "positive_charge_difference_at_alpha_0_over_lambda": 240, + "ratio_at_alpha_1": "23", + "removed_rank_eight": 16, + "removed_width_sum_over_lambda": 128, + "scope": "Isolated same-volume homogeneous native-component tariff, alpha in [0,1]. Does not reject whole-connection affordability: changed retained-root protocols may supply compensating credit. No runtime lower bound or exponent claim.", + "zero_native_repair_added_rank_one": 256, + "zero_native_repair_deficit_alpha_0": 128 + }, + "new_implication": "Actual producer bank to encoded448-family decoder bank to all224 current G outputs, immutable-port continuation and paid retirement; coarse prepared input/output lease/frame premises replaced by source-bound mechanisms.", + "outcome_class": "B: source-bound caller installation with complete local contract and constructive symbolic bill; native-component charge comparison fails; total physical dominance unresolved", + "physical_inventory": "3I+2**20 fixed roles total for controller stage; I=2q_*^2+100696823; root layer and earlier suspended inventories remain separately paid", + "proof_inputs": { + "ADMISSION.json": "fef2407cc8cc081bfd5e5fa9dbee23d1d119b2b59b6fad0b3484593cdcfb0187", + "PROOF.md": "fde109910f348266a4781239d9b673e27ed335a33549d29a1914fa485855f158", + "REUSE.json": "3c1954483d8f8769335ac81cbc87ec9fdf9956b0ffac6bd82b5d999e77ce5f8d" + }, + "remaining": [ + "Inherited exact original C/native/common-label/hosting, ordinary B1/C0, Compact and long-record hypotheses.", + "No production O73 numerical execution or full RootLayer.run claimed.", + "No affordable supplier established: isolated fullD224+producer32 native profile exceeds16H8; changed outer-call protocol credits/charges require complete physical comparison.", + "No all-node modified-recursion theorem; installed once in changed root Machine and original C handles all recursive descendants.", + "A sharper concrete runtime comparison still needs actual primitive tariffs; the operation-sum invoice treats no unknown cost as zero." + ], + "scientific_base": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "scope": "One first-pair installation in the modified root Machine; all descendants use unchanged original C. The all-size connection is conditional on explicit native/source refinements and admission, not inferred from reduced fixtures.", + "source_inputs": { + "certificates/selected-result.json": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "notes/batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "notes/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "notes/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "research/bit2234-stock-threshold/README.md": "1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7", + "research/community-frontier1042-audit/selected-replay.tar.gz": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "research/community-frontier1094-audit/selected-replay.tar.gz": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6", + "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f", + "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734", + "research/complex-grid-prefix-audit/PROOF.md": "9c2473e080a64de5139abf66680534043143ec9f4488ceabf62403702047a3ad", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "research/gaussian-normalization-stream/SOURCES.json": "c434302f4489366c1763f918ba59e2f57efc0a41d72310fd3c6bbe1553370275", + "research/gaussian-normalization-stream/normalizer.py": "2b0acaa831219faf3e7776969bdcffc3f0f9c608b15d6b4c343ff20cf6a50107", + "research/gaussian-parity-synthesis/REVIEW.md": "7d7b9ac63ccd2927f592e9edac1b4c11d58a6c74c5813d488e112f729090f60c", + "research/gaussian-parity/gaussian-parity-certificates.tex": "e21e1063141cbc798e73052e22d01eec57f1c173a580041e55aa196b1b0479f8", + "research/joint-query/certificate.json.gz": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "research/joint-query/evidence/BRIDGE-REVIEW.md": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75", + "research/joint-query/source_data.py": "d23924511e3aed41e5e64511ca70126a636d91c8aa02e656cb61d6ceca1fe0a0", + "research/joint-query/verify_native.py": "1c58e7b6e8e1cde4df455c2129601c145ed763fc63a3ab427eb1058d1fc08bd2", + "research/joint-query/verify_scalar.py": "33bdbad17a0531fe527aff306eb235d9c38c1629db4fd167b989725930b0327a", + "research/p104-whole-word-internal-grid/README.md": "d98c0b0a4835d766852e960299dd87112375990ed645d2c9e84edb08b79500e4", + "research/physical-complex-controller/PROOF.md": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e", + "research/physical-complex-controller/SOURCES.json": "c9c47d9df2445fc554673316d42f68f0a1b800ea3593ac568835c9b063025eb4", + "research/physical-complex-controller/bank_packets.py": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "research/physical-complex-controller/cohort.py": "8fb650c0cc3dfaad94811149b0c0e725777a8cff195c5f21e21a7576494e84f1", + "research/physical-complex-controller/cover.py": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da", + "research/physical-complex-controller/fixture_binding.py": "efcb94cf050412ccd2d5eea592d77f294f6124f6feebc86580b16a73e5c2c202", + "research/physical-complex-controller/grid_boundary.py": "55f32b8cfaa3482d5d62127ac90c2370fc0dc8122263815e1564ee95093ffccc", + "research/physical-complex-controller/machine.py": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "research/physical-complex-controller/monomial_packets.py": "6856e80c13ebf3b6e9e0e142ed65420579b5a1b4892f23859d3c6e5f17a334b4", + "research/physical-complex-controller/native_program.py": "177d87445659d7ddbef11370d0b4cdc0596732147ed26c1fa11bad16ae53c93b", + "research/physical-complex-controller/parking.py": "33e6d2a6fcdc648de31b374132bf885259eec9748bafa6facca3822a78427e94", + "research/physical-complex-controller/root_layer.py": "247b82feefecedc12142379fd7c9c6cdd5ac7e5309e443c4b4fa703d6b995c21", + "research/physical-complex-controller/root_plan.py": "494cad3edc376928684f380cd16568076b286a53bd763d910d49efa5b03f07c9", + "research/physical-complex-controller/root_streams.py": "b67daf3de591b6788220a016b0394cfe2cc8e94ffd41426bb2544ad578b715c8", + "research/physical-complex-controller/scalar_packets.py": "cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35", + "research/physical-complex-controller/scalar_program.py": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a", + "research/physical-complex-controller/selected_binding.py": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985", + "research/physical-complex-controller/selected_source.py": "02601c9e7d88e58e62d63509ff709c6498a40fbbc0f95fab328379ae6acaa87a", + "research/physical-gaussian-leaf/PROOF.md": "29ebd43146f921077f980a408915ecc3a5199a07fcdadc624a8282c06b0b8104", + "research/physical-gaussian-leaf/SOURCES.json": "c693fc79212652d7427560189ad8eb5e841fe71325e6d7a0d61e05f97438a5e1", + "research/physical-gaussian-leaf/axis_stream.py": "40dea1c6fa41effd8e7a61f39a3a599e897370ca118e332ee5301a905dbb2998", + "research/physical-gaussian-leaf/coefficient_engine.py": "fff28cbc27b95ed546ac65f70279fa41a933421f1cd32b988ae8910632f0efcf", + "research/physical-gaussian-leaf/inputs/pr3087.tar": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53", + "research/physical-gaussian-leaf/leaf_sources.py": "e0f958a0169257ba08eac5e025a3fc7ce99009efc18974cdd231f16758004014", + "research/physical-gaussian-leaf/signed_linear.py": "5b86afc33042e1c43eaa6957f94e0ebf403d1b07bb26d30ba89aa14d71f76078", + "research/physical-scalar-stream/scalar_engine.py": "be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6", + "research/physical-scalar-stream/scalar_words.py": "f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00", + "research/pr589-five-helper-hosting/PROOF.md": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647", + "research/pr589-five-helper-hosting/verify.py": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367", + "research/qq16-all-depth-producer-grid/PROOF.md": "6dd878aa01807eecf4a37f7ce3fbc1105d79f6b1b06791b23d4deeef90b7d994", + "research/qq16-caller-install/inputs/PR3055-PROOF.md": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48", + "research/qq16-caller-install/inputs/PR3380-PROOF.md": "c208f16c93be22795b9b01a5a1702a446541163ebf823251b12a891597077826", + "research/qq16-caller-install/inputs/PR3464-PROOF.md": "b3c41ea0f812315a7bab877edecc911e6dffb5b596f4135a39c3d5b99aae14c5", + "research/qq16-caller-install/inputs/PR3464-bank_packets.py": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "research/qq16-caller-install/inputs/PR3464-machine.py": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "research/qq16-caller-install/inputs/PR3464-parking.py": "33e6d2a6fcdc648de31b374132bf885259eec9748bafa6facca3822a78427e94", + "research/qq16-caller-install/inputs/PR3464-selected_binding.py": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985", + "research/qq16-caller-install/inputs/PR3607-PROOF.md": "fab92623c04ff43868c1cf787b0fbdf619e81301a83f6272f6d33cadf6c42f9d", + "research/qq16-caller-install/inputs/PR3619-PROOF.md": "88edbc9718c00302c0aae2036a32e4d9f534090a9754eb7d267707e637971cbb", + "research/qq16-caller-install/inputs/PR3993-PROOF.md": "18a0b88a25817aee02356fc8156ecfb6f175a3689dc16b2eb31e23ad4bdf83e9", + "research/qq16-caller-install/inputs/PR4106-WORD.json": "b4f2b5662734178d02a5d620ebd071bc284abd4d9b6dbe11b5d9646455a0f021", + "research/qq16-caller-install/inputs/PR4114-README.md": "734d8d3578be00e6899bd500b91f0fe992e13d3921faebc9fc2400d32e208bd6", + "research/qq16-caller-install/inputs/PR4129-COST.md": "05699f427530cc0417e28bd1c3a94b018ffdd0d5c4bc9f4261d49a557e293d9b", + "research/qq16-caller-install/inputs/PR4129-NATIVE.md": "567e4d12ac7d57f5916d7ecc24c77cd351ce3fcc966acf8348d7288ee9801b03", + "research/qq16-caller-install/inputs/PR4129-PREDECESSORS.json": "209170a530f2ec5897edb102c029863bada01409fb2f838132a94127ff768315", + "research/qq16-caller-install/inputs/PR4129-PROOF.md": "b547277ab5380b218893908a3e8e8874efc0cf3f9717b582f8972698d87418a2", + "research/qq16-caller-install/inputs/PR4129-README.md": "fd47f198b534ae0b9a1d1896614100c56145dc5004650de6c9d4b27a8cba219a", + "research/qq16-caller-install/inputs/PR4129-RESULT.json": "7dd05d54817202d86de77b550b0e68517756eb8ec71d3b591ebde0cb4e9e2389", + "research/qq16-caller-install/inputs/PR4129-SOURCES.json": "d4b3343f6f6b1d08a2879df693e6d2ab89246615f20fb978a4e9cbfd5ee2e26d", + "research/qq16-caller-install/inputs/PR4129-TASK.json": "73729ec6260d118bd0a73fd89576f2c33aff772d4a932bb56330ac42fdb326d3", + "research/qq16-caller-install/inputs/PR4129-bridge.py": "120cd3a2d0deb44b9c059636b1ac9bdd8a6b998143718f4252794780edf7decb", + "research/qq16-caller-install/inputs/PR4129-construction.py": "bbfb0014e8636ab4f66ff925189fd523fd4e8e377aec51509f4f3fe6877c3007", + "research/qq16-line-normalized-decoder/PREDECESSORS.json": "a8be0439e350d7a634a188176894ec51180efc0d236a56b293d39dc96383a87d", + "research/qq16-line-normalized-decoder/PROOF.md": "0a0995e70f2a64c15cdd1aee66634d1ba221cbcb2a7cfa3a4d4950a37d0e143a", + "research/qq16-line-normalized-decoder/RESULT.json": "58df4ad68e2ff335ee58fa4336a449d0f73f3366d840574e5e30b50f507c358d", + "research/qq16-line-normalized-decoder/SOURCES.json": "66bf8f57019632ef45780769c6f112d287e145e23ff03336998589b474165fbe", + "research/qq16-line-normalized-decoder/vendor/pr2681/PROOF.md": "471f6360cdac94d9e1054c6c9530ace1822b11942f7e141dfd344864d2357862", + "research/qq16-line-normalized-decoder/vendor/pr2681/README.md": "b658e00db095f1097b9ae7ec49d8dd465c1a317cdc84da4251cbdd3e0af597d3", + "research/qq16-line-normalized-decoder/vendor/pr2681/RESULT.json": "e4f3ff28be27f96c341b225a62a2ba84d3907ed3466122d18bcaaf5a60da740e", + "research/qq16-line-normalized-decoder/vendor/pr2681/SOURCES.json": "30a88d8bf33c603836fffdcab3c3dabf663b98f2deda95893685e394c60ea95c", + "research/qq16-line-normalized-decoder/vendor/pr2681/WORD.json": "f02e57d238f127c8fd195dc6a4a9dce6db6bee9f6050bd9d5b9c14cf6e1946d0", + "research/qq16-line-normalized-decoder/vendor/pr2681/references/PR2540-PROOF.md": "09d587f1d6bc250e90e29fa8751a40f45be79f1a8a56af0b645c144cefaefa46", + "research/qq16-line-normalized-decoder/vendor/pr2681/references/PR2540-README.md": "07588c3863b8d686497d9c0b263c35c47424fa3b63d43b7c2e5f788bd31a8d3f", + "research/qq16-line-normalized-decoder/vendor/pr2681/verify.py": "71f9a010553691e892703e3ec8d5eedf3e48d72b7f6af24b954a5442f4a52ccf", + "research/qq16-line-normalized-decoder/verify.py": "0f6fb86aafb74b9722f20cc97af70a3a3c78bd012c142b2eaa19cb00e02d1fe9", + "research/qq16-tagged-cover-routing/PROOF.md": "1b32c88e6c6ace2b41a1f2168a6754c329fb1bf9a5b64cf3fec53b31085604ea", + "research/qq16-tagged-cover-routing/oracle.py": "00328380126faa55b9f8027c81872663985610a247d0a61108951b394ad27fff", + "research/qq16-tagged-cover-routing/router.py": "a5221ec8a3a38b5d0133abc685ec28e392e946ef5b60dec37f69a605a45ba7ce", + "research/qq16-tagged-cover-routing/verify.py": "05b06299545c7fc74de34d13951e083cc7f8f8ab1e9b9c8eb96df892a430776e", + "research/recursive-parking-boundary/README.md": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18", + "research/selected-bit-local-ring-sweeps/PROOF.md": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7", + "research/selected-bit-recursive-closure/PROOF.md": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344", + "research/selected-complex-layer-closure/PROOF.md": "43feda0342c07a9429699c3a44e8936a3f3fb57ce9b32f38ff3dc06ac887b265", + "research/selected-complex-layer-closure/arithmetic.py": "31e4b21bb64924d723d1248a7eccf4e9c80d323ba8784804af79a75da18c346a", + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "status": "PASS_QQ16_ACTUAL_CALLER_INSTALLATION_CONTRACT", + "unchanged_kappa": "836330098538459/500000000000000000", + "whole_root_child_census": { + "baseline_entry_through_bridge": { + "calls": 17565, + "rank_counts": { + "1": 12060, + "2": 2090, + "3": 2255, + "4": 710, + "5": 410, + "8": 40 + }, + "rank_mass": 28215 + }, + "baseline_events": 482, + "baseline_whole_root": { + "calls": 510662, + "rank_counts": { + "1": 349604, + "2": 60192, + "3": 62585, + "4": 20448, + "48": 4866, + "5": 11808, + "7": 7, + "8": 1152 + }, + "rank_mass": 1041408 + }, + "bridge_source_6": { + "calls": 0, + "rank_counts": {}, + "rank_mass": 0 + }, + "clean_retained_pair_cores": { + "calls": 6972, + "rank_counts": { + "1": 4824, + "2": 836, + "3": 864, + "4": 284, + "5": 164 + }, + "rank_mass": 11044 + }, + "idle_rank_dispatch_witnesses": 4, + "idle_source_5": { + "calls": 95, + "rank_counts": { + "3": 95 + }, + "rank_mass": 285 + }, + "installed_entry_through_bridge": { + "calls": 17581, + "rank_counts": { + "1": 12092, + "2": 2090, + "3": 2255, + "4": 710, + "5": 410, + "8": 24 + }, + "rank_mass": 28119 + }, + "installed_events": 1051, + "installed_whole_root": { + "calls": 510678, + "rank_counts": { + "1": 349636, + "2": 60192, + "3": 62585, + "4": 20448, + "48": 4866, + "5": 11808, + "7": 7, + "8": 1136 + }, + "rank_mass": 1041312 + }, + "intervening_source_1_3": { + "calls": 10482, + "rank_counts": { + "1": 7236, + "2": 1254, + "3": 1296, + "4": 426, + "5": 246, + "8": 24 + }, + "rank_mass": 16758 + }, + "original_pair_0_4": { + "calls": 6988, + "rank_counts": { + "1": 4824, + "2": 836, + "3": 864, + "4": 284, + "5": 164, + "8": 16 + }, + "rank_mass": 11172 + }, + "protocol_scope": "Every installed root child uses external-child transfer; same rank does not cancel differing parent protocols or packet contexts.", + "qq16_added_lines": { + "calls": 32, + "rank_counts": { + "1": 32 + }, + "rank_mass": 32 + }, + "removed_centres": { + "calls": 16, + "rank_counts": { + "8": 16 + }, + "rank_mass": 128 + }, + "retained_later_source_7_481": { + "calls": 493097, + "rank_counts": { + "1": 337544, + "2": 58102, + "3": 60330, + "4": 19738, + "48": 4866, + "5": 11398, + "7": 7, + "8": 1112 + }, + "rank_mass": 1013193 + }, + "source_event_kinds": { + "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 + }, + "units": "root child invocations per Gamma; service children separate" + } +} diff --git a/research/qq16-caller-install/REUSE.json b/research/qq16-caller-install/REUSE.json new file mode 100644 index 0000000000..7439823c3c --- /dev/null +++ b/research/qq16-caller-install/REUSE.json @@ -0,0 +1,86 @@ +{ + "schema_version": 1, + "candidates": [ + { + "pr": 3464, + "author": "Sagar Thakrar", + "frozen_head": "56b856a8c6dbd44c4a15bde694c08bbaff6f3e2f", + "classification": "reuse unchanged", + "implication": "four principal exact bytes; parent parking/return", + "limit": "actual original controller; successful callee/closed scratch; not a full invoice", + "numerical_endpoint": "unchanged actual C fine-grid endpoint where inherited; no substitution", + "ownership_endpoint": "explicit current/all-role contract in PROOF.md" + }, + { + "pr": 3607, + "author": "Sagar Thakrar", + "frozen_head": "8f656674e660ce67abd8ae7d23f0d1068ea6d410", + "classification": "reuse unchanged", + "implication": "conditional address/prefix padding and source RootPlan", + "limit": "declared endpoint doubles in layout fixtures; not arithmetic/compiler/time proof", + "numerical_endpoint": "unchanged actual C fine-grid endpoint where inherited; no substitution", + "ownership_endpoint": "explicit current/all-role contract in PROOF.md" + }, + { + "pr": 3055, + "author": "Jose Manuel", + "frozen_head": "9dc841c9a101435fdd15e0f7623bf16b6d0363e9", + "classification": "reuse unchanged", + "implication": "physical Compact already inherited by source closure", + "limit": "ordinary/native and long-record premises retained; no new integration credit", + "numerical_endpoint": "unchanged actual C fine-grid endpoint where inherited; no substitution", + "ownership_endpoint": "explicit current/all-role contract in PROOF.md" + }, + { + "pr": 3380, + "author": "Tekalign", + "frozen_head": "072fd13a64095122bdad44009ab216aa4e1c1c1c", + "classification": "adapt with a new proof/cost", + "implication": "internal finite role exchange at completed bank", + "limit": "different C1/B1implementation; new all-binding proof and11B+4bill, not22V+13", + "numerical_endpoint": "unchanged actual C fine-grid endpoint where inherited; no substitution", + "ownership_endpoint": "explicit current/all-role contract in PROOF.md" + }, + { + "pr": 3619, + "author": "Jose Manuel", + "frozen_head": "51f3254a54aa5f419778c6e4bee89f7442a0d9c1", + "classification": "incompatible/deferred", + "implication": "no optimized support-router credit", + "limit": "needs endpoint/layout proof and cp<=n<=C0p,support cap,record-width bound; our owner cycles fully billed", + "numerical_endpoint": "unchanged actual C fine-grid endpoint where inherited; no substitution", + "ownership_endpoint": "explicit current/all-role contract in PROOF.md" + }, + { + "pr": 4123, + "author": "unpaidmoon", + "frozen_head": "499427578245cbd3d2b07680945a94f6e927d020", + "classification": "regression evidence only", + "implication": "finite-width/bit-order/rounding controls", + "limit": "one normalized H0round/truncation not recursive exact C", + "numerical_endpoint": "unchanged actual C fine-grid endpoint where inherited; no substitution", + "ownership_endpoint": "explicit current/all-role contract in PROOF.md" + }, + { + "pr": 4114, + "author": "unpaidmoon", + "frozen_head": "cc32c9704c9b67649a310c1ce8c17d08f3eb7355", + "classification": "regression evidence only", + "implication": "dirty-ray128T/68T challenges completed-norm58 bound", + "limit": "scalar ray not arbitrary-payload norm/frame proof", + "numerical_endpoint": "unchanged actual C fine-grid endpoint where inherited; no substitution", + "ownership_endpoint": "explicit current/all-role contract in PROOF.md" + }, + { + "pr": 3993, + "author": "Victor Li", + "frozen_head": "e4fa89214086fb096c4276bbea891a1e6fae6c7b", + "classification": "regression evidence only", + "implication": "phase/generation/reentry mutations", + "limit": "different BIT pool/lease contract; no invariant imported", + "numerical_endpoint": "unchanged actual C fine-grid endpoint where inherited; no substitution", + "ownership_endpoint": "explicit current/all-role contract in PROOF.md" + } + ], + "reviews": "Current metadata/comments checked at entry; no scientific acceptance inferred from merged/open status. Publication refresh recorded separately." +} diff --git a/research/qq16-caller-install/REVIEW.json b/research/qq16-caller-install/REVIEW.json new file mode 100644 index 0000000000..23bea95cf4 --- /dev/null +++ b/research/qq16-caller-install/REVIEW.json @@ -0,0 +1,39 @@ +{ + "reviewer": "caller_adversary coordinated OpenAI Codex agent", + "verdict": "No unresolved blocking scientific/composition defect for conditional class B at reviewed snapshot", + "aggregate_sha256": "86eb21731f3af3473d1a4ea41e80552506915ae4947a7de15aca08ca8169f493", + "files": { + "PROOF.md": "fde109910f348266a4781239d9b673e27ed335a33549d29a1914fa485855f158", + "COST.md": "cf6d68babc70ac268f02fe53f3abfa5172b5204dbef692a94c4942a65bfc5b40", + "ADMISSION.json": "fef2407cc8cc081bfd5e5fa9dbee23d1d119b2b59b6fad0b3484593cdcfb0187", + "REUSE.json": "3c1954483d8f8769335ac81cbc87ec9fdf9956b0ffac6bd82b5d999e77ce5f8d", + "connection.py": "3da2ac158a6f36a568d0873cbb45f230ba8fa609cf8092bfbd55da83bae498c2", + "installer.py": "6af289c0b21c11dad7efaa2f7373ad0f61a3d1d6975bcfb5d1560320373260df", + "producer.py": "69a7cc6c9545a0d8684a529d6365345c337276f9c8faaf2dcdb0923ca72c396d", + "decoder.py": "e169a8b160bfa89dd22bc618df1ed947ebe668e82bca1014c70781ff9dcf75ce", + "packet.py": "d8f4e63feae1ed372951ba5643dadf02e2af006bf3632d29137e92d05067234e", + "lifecycle.py": "2eadca77717ee28c24dd6ff175a115277a83d852c56d320cc93937cab27e5191", + "continuation.py": "9fa2de5d79768b4130f81a74f29f388ffc28c990512a9fa22921ec2d75401aca", + "cost.py": "935b23fee0abdce52279820febce93d23a2095f347ddf0da4fbd424995b99842", + "verify.py": "46f16651383d5677e641c3e2fed86b6c2f3b62834d0be1699cfa03a1de0385ec", + "producer-fixture.py": "4744a12cc9c015f6cfa6bddff6886f2eb163fec4ff2e3e07556cb37152c2ebf3", + "integrated-fixture.py": "e4f8bcc947e761ca4f1efb825794210dfd56ca79e049a5207fbfad26ee7e71ae", + "PACKET.md": "dab89829f5553d945866219c2f668cec6a71a8f694effbe9ac0e3e091ee3e99b" + }, + "independent_execution": "Ordinary isolated continuous fixture, two64-complex-value generations; prior to added controlled-cleanup assertions, which were subsequently inspected", + "resolved": [ + "post-remainder encoded nonleaf guard and separating3^1000width2test", + "nonsymmetric owner rows/columns and both signed native conjugation", + "all336installedsigned73Drecipes", + "dedicated inventories and internal failure cleanup before fixture recovery", + "all changed root child protocols including493097Gamma latercalls; independent bill/source census binding" + ], + "limitations": [ + "No affordability or new kappa", + "Inherited exactC/commonlabel/hosting/ordinary/Compact/sourceentry/longrecord premises", + "Reduced execution, no productionO73payload or completeRootLayer.run", + "Shared sources/checker lineage; not independent human or formal-kernel acceptance", + "Receipt/registered/export/publication checks are separate orchestrator gates" + ], + "final_description_clarification": "Reviewer-requested distinction between auxiliary P Gamma whole-family descriptors and actual P-prefix per-owner native capsules; no implementation/cost/domain change." +} diff --git a/research/qq16-caller-install/SOURCES.json b/research/qq16-caller-install/SOURCES.json new file mode 100644 index 0000000000..54df1264ec --- /dev/null +++ b/research/qq16-caller-install/SOURCES.json @@ -0,0 +1,493 @@ +{ + "schema_version": 1, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81" + }, + { + "path": "notes/batched-complex-rows.tex", + "usage": "input", + "sha256": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "git_blob": "e13bd96eb29bdc6526f10dc32e0a146bc17848a4" + }, + { + "path": "notes/compact-control-layout.tex", + "usage": "input", + "sha256": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "git_blob": "16f4d233471a7d189163ae7e7902becadecbba64" + }, + { + "path": "notes/compact-control-movement.tex", + "usage": "input", + "sha256": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "git_blob": "06b6a9ef24245ac7b724c53a204635415b402357" + }, + { + "path": "research/bit2234-stock-threshold/README.md", + "usage": "input", + "sha256": "1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7", + "git_blob": "ede0d322c477af91d4c2cc33db0fd10958f45eab" + }, + { + "path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b", + "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "usage": "input", + "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f", + "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "usage": "input", + "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734", + "git_blob": "44006542202ca6037533a754f0bcd00549d7e088" + }, + { + "path": "research/complex-grid-prefix-audit/PROOF.md", + "usage": "input", + "sha256": "9c2473e080a64de5139abf66680534043143ec9f4488ceabf62403702047a3ad", + "git_blob": "30f019e14866200660cbd2ad82f3bff707003210" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a" + }, + { + "path": "research/gaussian-normalization-stream/SOURCES.json", + "usage": "input", + "sha256": "c434302f4489366c1763f918ba59e2f57efc0a41d72310fd3c6bbe1553370275", + "git_blob": "58fce750dc2814f36ac096b407dd28293539bf8f" + }, + { + "path": "research/gaussian-normalization-stream/normalizer.py", + "usage": "input", + "sha256": "2b0acaa831219faf3e7776969bdcffc3f0f9c608b15d6b4c343ff20cf6a50107", + "git_blob": "5d1a0961ace6b7edccb26c05780623c5509a7597" + }, + { + "path": "research/gaussian-parity-synthesis/REVIEW.md", + "usage": "input", + "sha256": "7d7b9ac63ccd2927f592e9edac1b4c11d58a6c74c5813d488e112f729090f60c", + "git_blob": "0a6a4c7c1e8bef9c9aa9c7fb636e5ad6c0c411ae" + }, + { + "path": "research/gaussian-parity/gaussian-parity-certificates.tex", + "usage": "input", + "sha256": "e21e1063141cbc798e73052e22d01eec57f1c173a580041e55aa196b1b0479f8", + "git_blob": "e364cff719a12a5dfd52f2975cd07cc0318da511" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/joint-query/evidence/BRIDGE-REVIEW.md", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "86139908c418235588045324f0873de6ac9f9707", + "sha256": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3" + }, + { + "path": "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "a6805c58f23132f9420efebf90f5b7e863c2e179", + "sha256": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75" + }, + { + "path": "research/joint-query/source_data.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "c9d465ed47500304bef65fcb588befe356c5cf09", + "sha256": "d23924511e3aed41e5e64511ca70126a636d91c8aa02e656cb61d6ceca1fe0a0" + }, + { + "path": "research/joint-query/verify_native.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "ede9e7e42744dd0c96790516a9acdfe07d180018", + "sha256": "1c58e7b6e8e1cde4df455c2129601c145ed763fc63a3ab427eb1058d1fc08bd2" + }, + { + "path": "research/joint-query/verify_scalar.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "7a7051fa8a70f48589fa1fccd5c38fccb5eacbf7", + "sha256": "33bdbad17a0531fe527aff306eb235d9c38c1629db4fd167b989725930b0327a" + }, + { + "path": "research/p104-whole-word-internal-grid/README.md", + "usage": "input", + "sha256": "d98c0b0a4835d766852e960299dd87112375990ed645d2c9e84edb08b79500e4", + "git_blob": "4075bb303592ccc53cd7d29399f15ff01c89da5d" + }, + { + "path": "research/physical-complex-controller/PROOF.md", + "usage": "input", + "sha256": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e", + "git_blob": "c505caecc7ced19a4efc35c423efedda9427bea5" + }, + { + "path": "research/physical-complex-controller/SOURCES.json", + "usage": "input", + "sha256": "c9c47d9df2445fc554673316d42f68f0a1b800ea3593ac568835c9b063025eb4", + "git_blob": "a56a247ecb28c77fcb055fac031be471b291777d" + }, + { + "path": "research/physical-complex-controller/bank_packets.py", + "usage": "input", + "sha256": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "git_blob": "defda707199e8eba83ee483daf5ae7acb642c43c" + }, + { + "path": "research/physical-complex-controller/cohort.py", + "usage": "input", + "sha256": "8fb650c0cc3dfaad94811149b0c0e725777a8cff195c5f21e21a7576494e84f1", + "git_blob": "3876ab737f3c2a90100749e4ba141f1923caff79" + }, + { + "path": "research/physical-complex-controller/cover.py", + "usage": "input", + "sha256": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da", + "git_blob": "2b9b9df832a747bcb02505d5495f79d38deffa43" + }, + { + "path": "research/physical-complex-controller/fixture_binding.py", + "usage": "input", + "sha256": "efcb94cf050412ccd2d5eea592d77f294f6124f6feebc86580b16a73e5c2c202", + "git_blob": "447ddc84d7dd9905c767c91acc7467a495093475" + }, + { + "path": "research/physical-complex-controller/grid_boundary.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "387576fc2f0701709237430febed7ea5b730828b", + "sha256": "55f32b8cfaa3482d5d62127ac90c2370fc0dc8122263815e1564ee95093ffccc" + }, + { + "path": "research/physical-complex-controller/machine.py", + "usage": "input", + "sha256": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "git_blob": "92f9467ffd3346d672a0e2c56f2508e33ed21689" + }, + { + "path": "research/physical-complex-controller/monomial_packets.py", + "usage": "input", + "sha256": "6856e80c13ebf3b6e9e0e142ed65420579b5a1b4892f23859d3c6e5f17a334b4", + "git_blob": "5b4eaf49b3847cafa7bd99e7147c8818b248a021" + }, + { + "path": "research/physical-complex-controller/native_program.py", + "usage": "input", + "sha256": "177d87445659d7ddbef11370d0b4cdc0596732147ed26c1fa11bad16ae53c93b", + "git_blob": "7d1c54c7d1394de28585d48b1a703d4b00069e98" + }, + { + "path": "research/physical-complex-controller/parking.py", + "usage": "input", + "sha256": "33e6d2a6fcdc648de31b374132bf885259eec9748bafa6facca3822a78427e94", + "git_blob": "34bc6a0bd0daade7ccc69d0c236984f024d22ef4" + }, + { + "path": "research/physical-complex-controller/root_layer.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "389efd17af0f8d68711f0e7c6d8b6be65421e846", + "sha256": "247b82feefecedc12142379fd7c9c6cdd5ac7e5309e443c4b4fa703d6b995c21" + }, + { + "path": "research/physical-complex-controller/root_plan.py", + "usage": "input", + "sha256": "494cad3edc376928684f380cd16568076b286a53bd763d910d49efa5b03f07c9", + "git_blob": "78390164c3551bfcce8da6b0f23197a4048a7e5e" + }, + { + "path": "research/physical-complex-controller/root_streams.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "213144a6c905ac5dfbec9aaadc43f14eb4b1044d", + "sha256": "b67daf3de591b6788220a016b0394cfe2cc8e94ffd41426bb2544ad578b715c8" + }, + { + "path": "research/physical-complex-controller/scalar_packets.py", + "usage": "input", + "sha256": "cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35", + "git_blob": "66ea778399423005695bdea1e43ef9dcde903402" + }, + { + "path": "research/physical-complex-controller/scalar_program.py", + "usage": "input", + "sha256": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a", + "git_blob": "30ba678c7b828285d549e923b34e315e439b8452" + }, + { + "path": "research/physical-complex-controller/selected_binding.py", + "usage": "input", + "sha256": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985", + "git_blob": "5fe097ff688f5304a45945054e9d4a4af05f13d8" + }, + { + "path": "research/physical-complex-controller/selected_source.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "6bdc133472e85d2230d59c91813390b3547caf8d", + "sha256": "02601c9e7d88e58e62d63509ff709c6498a40fbbc0f95fab328379ae6acaa87a" + }, + { + "path": "research/physical-gaussian-leaf/PROOF.md", + "usage": "input", + "sha256": "29ebd43146f921077f980a408915ecc3a5199a07fcdadc624a8282c06b0b8104", + "git_blob": "e98db470cdb8bfc49e9da86c39c0d6ae16e92716" + }, + { + "path": "research/physical-gaussian-leaf/SOURCES.json", + "usage": "input", + "sha256": "c693fc79212652d7427560189ad8eb5e841fe71325e6d7a0d61e05f97438a5e1", + "git_blob": "2ae5d4a9bd2b62bf21fee81106fa9e38bbd84bd0" + }, + { + "path": "research/physical-gaussian-leaf/axis_stream.py", + "usage": "input", + "sha256": "40dea1c6fa41effd8e7a61f39a3a599e897370ca118e332ee5301a905dbb2998", + "git_blob": "ba8230443fdb0370b72a7a617ba7d88eb23a9c37" + }, + { + "path": "research/physical-gaussian-leaf/coefficient_engine.py", + "usage": "input", + "sha256": "fff28cbc27b95ed546ac65f70279fa41a933421f1cd32b988ae8910632f0efcf", + "git_blob": "dff2f099b60c23310a10665cd81e443282b249e8" + }, + { + "path": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "usage": "input", + "sha256": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53", + "git_blob": "6daedf70a927fa1359caec68d56fc0cbdaeb54dd" + }, + { + "path": "research/physical-gaussian-leaf/leaf_sources.py", + "usage": "input", + "sha256": "e0f958a0169257ba08eac5e025a3fc7ce99009efc18974cdd231f16758004014", + "git_blob": "31c33dbed6061ca7c0455a9170fd05fb388f4607" + }, + { + "path": "research/physical-gaussian-leaf/signed_linear.py", + "usage": "input", + "sha256": "5b86afc33042e1c43eaa6957f94e0ebf403d1b07bb26d30ba89aa14d71f76078", + "git_blob": "d17018a976ea4af15b6b5828a091d799435bacfc" + }, + { + "path": "research/physical-scalar-stream/scalar_engine.py", + "usage": "input", + "sha256": "be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6", + "git_blob": "aea19253f6a772047f22d2f0e1927b9bf319aba9" + }, + { + "path": "research/physical-scalar-stream/scalar_words.py", + "usage": "input", + "sha256": "f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00", + "git_blob": "36919dc569678656a1696f23454cba2d1fb0f393" + }, + { + "path": "research/pr589-five-helper-hosting/PROOF.md", + "usage": "input", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647", + "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02" + }, + { + "path": "research/pr589-five-helper-hosting/verify.py", + "usage": "input", + "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367", + "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39" + }, + { + "path": "research/qq16-all-depth-producer-grid/PROOF.md", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "9cf1ec57646fb760fd26f206d754e52c99c347e3", + "sha256": "6dd878aa01807eecf4a37f7ce3fbc1105d79f6b1b06791b23d4deeef90b7d994" + }, + { + "path": "research/qq16-line-normalized-decoder/PREDECESSORS.json", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "db77dbf21b0f89b1f5bdbd308ab20d0045f61561", + "sha256": "a8be0439e350d7a634a188176894ec51180efc0d236a56b293d39dc96383a87d" + }, + { + "path": "research/qq16-line-normalized-decoder/PROOF.md", + "usage": "input", + "sha256": "0a0995e70f2a64c15cdd1aee66634d1ba221cbcb2a7cfa3a4d4950a37d0e143a", + "git_blob": "f7c694ff54e590416e4a52fa762f9d3b9474bccb" + }, + { + "path": "research/qq16-line-normalized-decoder/RESULT.json", + "usage": "input", + "sha256": "58df4ad68e2ff335ee58fa4336a449d0f73f3366d840574e5e30b50f507c358d", + "git_blob": "ba4167dbf133cff51513bb832802c290edcdffea" + }, + { + "path": "research/qq16-line-normalized-decoder/SOURCES.json", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "300c183db8d263899ee1795033af215ba6522b9f", + "sha256": "66bf8f57019632ef45780769c6f112d287e145e23ff03336998589b474165fbe" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/PROOF.md", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "38cd38aa1d342f3bfe0d6d7f3c388aff0352f370", + "sha256": "471f6360cdac94d9e1054c6c9530ace1822b11942f7e141dfd344864d2357862" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/README.md", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "c3d4d76b28fa47b86da37cc7428d5da362c7bf9a", + "sha256": "b658e00db095f1097b9ae7ec49d8dd465c1a317cdc84da4251cbdd3e0af597d3" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/RESULT.json", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "a16a8f9a23cd00c9030f9b03cf0ae52c0ff4b526", + "sha256": "e4f3ff28be27f96c341b225a62a2ba84d3907ed3466122d18bcaaf5a60da740e" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/SOURCES.json", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "1db7201ed145d1ef3707ab24bb599d341439050d", + "sha256": "30a88d8bf33c603836fffdcab3c3dabf663b98f2deda95893685e394c60ea95c" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/WORD.json", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "80de97cf168441a888e7d05fc2c3cace919f31ec", + "sha256": "f02e57d238f127c8fd195dc6a4a9dce6db6bee9f6050bd9d5b9c14cf6e1946d0" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/references/PR2540-PROOF.md", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "6ae136c8baef4793f4f7ae630720afff6c23a953", + "sha256": "09d587f1d6bc250e90e29fa8751a40f45be79f1a8a56af0b645c144cefaefa46" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/references/PR2540-README.md", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "e91138fb0fabbc0fe0e9fd80ee189ed4366a0f61", + "sha256": "07588c3863b8d686497d9c0b263c35c47424fa3b63d43b7c2e5f788bd31a8d3f" + }, + { + "path": "research/qq16-line-normalized-decoder/vendor/pr2681/verify.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "99bd60a9139b4d7ef070b69f38a954e64e0f8aa1", + "sha256": "71f9a010553691e892703e3ec8d5eedf3e48d72b7f6af24b954a5442f4a52ccf" + }, + { + "path": "research/qq16-line-normalized-decoder/verify.py", + "usage": "input", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "a8f3c811108414eda0b507d295cfc9301c04d585", + "sha256": "0f6fb86aafb74b9722f20cc97af70a3a3c78bd012c142b2eaa19cb00e02d1fe9" + }, + { + "path": "research/qq16-tagged-cover-routing/PROOF.md", + "usage": "input", + "sha256": "1b32c88e6c6ace2b41a1f2168a6754c329fb1bf9a5b64cf3fec53b31085604ea", + "git_blob": "44725131a9ecb8b41533492efa7a83bd65aca9ae" + }, + { + "path": "research/qq16-tagged-cover-routing/oracle.py", + "usage": "input", + "sha256": "00328380126faa55b9f8027c81872663985610a247d0a61108951b394ad27fff", + "git_blob": "555efb4b105c6bc59395f445625eb335688cd6aa" + }, + { + "path": "research/qq16-tagged-cover-routing/router.py", + "usage": "input", + "sha256": "a5221ec8a3a38b5d0133abc685ec28e392e946ef5b60dec37f69a605a45ba7ce", + "git_blob": "1994ad9fa80e5fbce5b58dffed0c44d89a7259a7" + }, + { + "path": "research/qq16-tagged-cover-routing/verify.py", + "usage": "input", + "sha256": "05b06299545c7fc74de34d13951e083cc7f8f8ab1e9b9c8eb96df892a430776e", + "git_blob": "c89b57e23f8e5167c64128763807f4c379e862a0" + }, + { + "path": "research/recursive-parking-boundary/README.md", + "usage": "input", + "sha256": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18", + "git_blob": "251f335ebaccc11d69393ee7aeb5a2e84526d0bb" + }, + { + "path": "research/selected-bit-local-ring-sweeps/PROOF.md", + "usage": "input", + "sha256": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7", + "git_blob": "4330de85dd9862ed15d84ab917887d249753df99" + }, + { + "path": "research/selected-bit-recursive-closure/PROOF.md", + "usage": "input", + "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344", + "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531" + }, + { + "path": "research/selected-complex-layer-closure/PROOF.md", + "usage": "input", + "sha256": "43feda0342c07a9429699c3a44e8936a3f3fb57ce9b32f38ff3dc06ac887b265", + "git_blob": "d7ec0d101405a5f099f55f6a73e9791731737fd0" + }, + { + "path": "research/selected-complex-layer-closure/arithmetic.py", + "usage": "input", + "sha256": "31e4b21bb64924d723d1248a7eccf4e9c80d323ba8784804af79a75da18c346a", + "git_blob": "009d7b7166718832ebbf11893cb1ef258184a4f9" + }, + { + "path": "upstream/build/sections/02-streams.tex", + "usage": "input", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + } + ] +} diff --git a/research/qq16-caller-install/TASK.json b/research/qq16-caller-install/TASK.json new file mode 100644 index 0000000000..4a960f1803 --- /dev/null +++ b/research/qq16-caller-install/TASK.json @@ -0,0 +1,105 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 6, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "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": "changed", + "actual_scope": "One source-bound actual producer/full-cover recovery/current G/both-leg continuation installation with a complete local operation-sum bill.", + "scope_change_reason": "Assigned successor beyond4129; replace actual acquisition,exclusive storage and current-frame premises, no scalar20percent target.", + "bottleneck_link": "The logical decoder lacks an implementation-bound native interior, precision and scratch contract; an inherited physical parent capsule plus paid promotion may provide it without substituting the coordinate reference at a recursive tariff.", + "budget_minutes": null, + "stop_rule": "At most one substantial PR after integrated significance and verification gate; otherwise preserve checkpoint. Continue bounded meaningful rounds, never unattended indefinite work.", + "outcome": "completed", + "evidence": "Conditional class-B actual source-bound caller installation, full local operation-sum bill and whole-root protocol census. No improved exponent or proved overall physical dominance. Final registered/export gates reported in verification handoff.", + "author": "Chris R / Clear1nsight with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in source analysis, construction, proofs, checkers and integration. Separate workers with explicit ownership; read-only adversarial review required before publication. Shared source/context and reused primitives disclosed.", + "open_questions": [ + { + "question": "Can the matched parent parking versus external-run protocol bill establish physical benefit, or a proved smaller demanded recovery improve the losing native profile?", + "why_it_matters": "The isolated native-component tariff loses, while avoided parent parking may be a material physical credit on510646Gamma retained root calls.", + "first_step": "Price actual matched child transport/parking at complete parent/packet geometry, including493097Gamma suffix calls; separately test smaller both-bridge demand/native fusion.", + "blocked_by": "Matched embedded-versus-external context/transport costs and all added bank scans remain unevaluated; no smaller source-compatible decoder or native cancellation proved." + } + ], + "scope_key": "5423eef254a4943f6bf1", + "publication_limit": 1, + "decision": { + "source": "canonicalbb4 actual RootLayer/SelectedBinding events0,4; QQ16F_0/B_1_2; actual idle5 and bridge6", + "missing_implication": "Prepared4129 native packets are not actual acquired QQ16bank/current G outputs with exclusive return storage.", + "four_boundaries": "PROOF.md", + "removed_work": "Only source local-cover sweeps0,4;16rank8centres credited once;480events retained", + "inequality": "COST.md before/after operation sums with all whole-root child protocols; isolated368C1vs16C8 native profile fails, total physical dominance unresolved; local publication11B+4-c_R.", + "discriminator": "actual firstsigned native interface, source-helper/intervening isolation, nonsymmetric owner map, continuous reduced producer-to-bothbridge execution", + "fallback": "Incorrect centre-free J/current inverse discarded; source selected Gtwo-shear reconstruction chosen. Cheap postrepair optimization rejected by256C1vs128credit screen.", + "success": "Class B complete actual source-bound local installation with constructive bill and no blocking composition defect; classA affordability not met", + "stop": "Failed admission/inventory/framejoin or unresolved final blockingreview => no PR" + }, + "checkpoint": { + "start_utc": "2026-10-20T03:33:34Z", + "scientific_main": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "priority_revision": 6, + "coverage": "Atentry allstateQQ16search top25; namedPRheads/comments; Discussion1163/1166/index bounded. Helper67localrecords24matches but remotePR/Discussioncache unavailable(ghmissing). Not exhaustive novelty evidence.", + "prepublication_refresh": "2026-10-20T04:33Z canonicalmain bb4 unchanged/priority6; allnameddependencyheads unchanged, lastupdated metadata unchanged. Allstate QQ16 top25 and quoted4129query(onehit), Discussion1163/1166/index bounded refresh; helper remotecoverage unavailable. New4162oneADDframe and4149ADDRESS scopes distinct. Frozen scientific pins preserved; this is not exhaustive novelty evidence." + }, + "candidate": { + "outcome_class": "B", + "new_implication": "Actual producer acquisition, encoded packet, dedicated full decoder/current G return and both bridge legs installed beyond prepared4129contract.", + "affordability": "Isolated native-component charge loses; complete physical comparison unresolved pending matched parent-protocol prices.", + "review": "Assisted integrated review closed post-remainder admission, row/column orientation, owner-conjugation, exact signed coverage, controlled cleanup and full-root protocol accounting defects; final receipts/checks pending." + } +} diff --git a/research/qq16-caller-install/VERIFY.json b/research/qq16-caller-install/VERIFY.json new file mode 100644 index 0000000000..fa219dde4e --- /dev/null +++ b/research/qq16-caller-install/VERIFY.json @@ -0,0 +1,110 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "notes/batched-complex-rows.tex", + "notes/compact-control-layout.tex", + "notes/compact-control-movement.tex", + "research/bit2234-stock-threshold/README.md", + "research/community-frontier1042-audit/selected-replay.tar.gz", + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "research/complex-grid-prefix-audit/PROOF.md", + "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/gaussian-normalization-stream/SOURCES.json", + "research/gaussian-normalization-stream/normalizer.py", + "research/gaussian-parity-synthesis/REVIEW.md", + "research/gaussian-parity/gaussian-parity-certificates.tex", + "research/joint-query/certificate.json.gz", + "research/joint-query/evidence/BRIDGE-REVIEW.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "research/joint-query/source_data.py", + "research/joint-query/verify_native.py", + "research/joint-query/verify_scalar.py", + "research/p104-whole-word-internal-grid/README.md", + "research/physical-complex-controller/PROOF.md", + "research/physical-complex-controller/SOURCES.json", + "research/physical-complex-controller/bank_packets.py", + "research/physical-complex-controller/cohort.py", + "research/physical-complex-controller/cover.py", + "research/physical-complex-controller/fixture_binding.py", + "research/physical-complex-controller/grid_boundary.py", + "research/physical-complex-controller/machine.py", + "research/physical-complex-controller/monomial_packets.py", + "research/physical-complex-controller/native_program.py", + "research/physical-complex-controller/parking.py", + "research/physical-complex-controller/root_layer.py", + "research/physical-complex-controller/root_plan.py", + "research/physical-complex-controller/root_streams.py", + "research/physical-complex-controller/scalar_packets.py", + "research/physical-complex-controller/scalar_program.py", + "research/physical-complex-controller/selected_binding.py", + "research/physical-complex-controller/selected_source.py", + "research/physical-gaussian-leaf/PROOF.md", + "research/physical-gaussian-leaf/SOURCES.json", + "research/physical-gaussian-leaf/axis_stream.py", + "research/physical-gaussian-leaf/coefficient_engine.py", + "research/physical-gaussian-leaf/inputs/pr3087.tar", + "research/physical-gaussian-leaf/leaf_sources.py", + "research/physical-gaussian-leaf/signed_linear.py", + "research/physical-scalar-stream/scalar_engine.py", + "research/physical-scalar-stream/scalar_words.py", + "research/pr589-five-helper-hosting/PROOF.md", + "research/pr589-five-helper-hosting/verify.py", + "research/qq16-all-depth-producer-grid/PROOF.md", + "research/qq16-line-normalized-decoder/PREDECESSORS.json", + "research/qq16-line-normalized-decoder/PROOF.md", + "research/qq16-line-normalized-decoder/RESULT.json", + "research/qq16-line-normalized-decoder/SOURCES.json", + "research/qq16-line-normalized-decoder/vendor/pr2681/PROOF.md", + "research/qq16-line-normalized-decoder/vendor/pr2681/README.md", + "research/qq16-line-normalized-decoder/vendor/pr2681/RESULT.json", + "research/qq16-line-normalized-decoder/vendor/pr2681/SOURCES.json", + "research/qq16-line-normalized-decoder/vendor/pr2681/WORD.json", + "research/qq16-line-normalized-decoder/vendor/pr2681/references/PR2540-PROOF.md", + "research/qq16-line-normalized-decoder/vendor/pr2681/references/PR2540-README.md", + "research/qq16-line-normalized-decoder/vendor/pr2681/verify.py", + "research/qq16-line-normalized-decoder/verify.py", + "research/qq16-tagged-cover-routing/PROOF.md", + "research/qq16-tagged-cover-routing/oracle.py", + "research/qq16-tagged-cover-routing/router.py", + "research/qq16-tagged-cover-routing/verify.py", + "research/recursive-parking-boundary/README.md", + "research/selected-bit-local-ring-sweeps/PROOF.md", + "research/selected-bit-recursive-closure/PROOF.md", + "research/selected-complex-layer-closure/PROOF.md", + "research/selected-complex-layer-closure/arithmetic.py", + "upstream/build/sections/02-streams.tex" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-Werror", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 420, + "checks": "Authenticate source closure before execution; actual full selected producer/decoder/current-frame compilation, complete bill and fine-grid admission; continuous actual reduced C composition and full224storage/packet checks; all typed receipts." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-Werror", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 600, + "checks": "Normal and optimized Git-free read-only export replay; immutable content; source-first refusal, input/manifest corruption, typed full receipt/duplicate controls and exclusive generation." + } + ] +} diff --git a/research/qq16-caller-install/auth.py b/research/qq16-caller-install/auth.py new file mode 100644 index 0000000000..b49b3a8770 --- /dev/null +++ b/research/qq16-caller-install/auth.py @@ -0,0 +1,36 @@ +"""Authenticate canonical and retained input bytes before inherited execution. + +Chris R / Clear1nsight, substantial OpenAI Codex assistance. Apache-2.0. +""" +import hashlib,json +from pathlib import Path +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +def need(ok,why): + if not ok:raise ValueError(why) +def unique(pairs): + d={} + for k,v in pairs: + need(k not in d,'duplicate JSON key:'+k);d[k]=v + return d +def parse(raw):return json.loads(raw,object_pairs_hook=unique) +def sha(raw):return hashlib.sha256(raw).hexdigest() +def blob(raw):return hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() +def typed(v): + if isinstance(v,dict):return ('dict',tuple((k,typed(x)) for k,x in sorted(v.items()))) + if isinstance(v,list):return ('list',tuple(map(typed,v))) + return (type(v).__name__,v) +def authenticate(): + result={} + for name,digest in MANIFESTS.items(): + raw=(HERE/name).read_bytes();need(sha(raw)==digest,'manifest integrity:'+name) + rows=parse(raw)['files'];seen=set() + for r in rows: + if name=='SOURCES.json' and r['usage']!='input':continue + rel=r['path'] if name=='SOURCES.json' else r['local'] + need(rel not in seen,'duplicate source path:'+rel);seen.add(rel) + path=(ROOT if name=='SOURCES.json' else HERE)/rel + b=path.read_bytes();need(sha(b)==r['sha256'] and blob(b)==r['git_blob'],'source integrity:'+str(path)) + result[str(path.relative_to(ROOT))]=sha(b) + return result +MANIFESTS={'SOURCES.json': '3ba36d49185c81691dc8c5a87f3f80a0540579bfd8b97658a52037aaa62274a6', 'PREDECESSORS.json': '57440a9f5cae02f123b38ad68e43928b694e7ca4e6569098c7904d7fe846b0c4'} diff --git a/research/qq16-caller-install/connection.py b/research/qq16-caller-install/connection.py new file mode 100644 index 0000000000..8d010eeece --- /dev/null +++ b/research/qq16-caller-install/connection.py @@ -0,0 +1,62 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Authenticated finite binding and actual root installation constructor. +Chris R / Clear1nsight, substantial OpenAI Codex assistance. +""" +from pathlib import Path +import gzip,json +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] + +def bindings(): + # Authentication is repeated even when the caller already joined the cohort. + import qq16_auth as A + import runtime + A.authenticate() + from selected_source import load + from selected_binding import SelectedBinding,Group,embed,literal + from native_program import compile_local + from scalar_program import ScalarProgram + data=load() + packet=A.parse(gzip.decompress((ROOT/'research/joint-query/certificate.json.gz').read_bytes())) + word=A.parse((HERE/'inputs/PR4106-WORD.json').read_bytes()) + P=runtime.module('qq16_producer',HERE/'producer.py') + D=runtime.module('qq16_decoder',HERE/'decoder.py') + C=runtime.module('qq16_signed',HERE/'inputs/PR4129-construction.py') + L=runtime.module('qq16_line_source',ROOT/'research/qq16-line-normalized-decoder/verify.py') + algebra,R,routes,labels,pins=L.load_source() + maps=D.finite_maps(word,algebra,routes,labels,L.bridge) + parent=P.ProducerBinding(data,packet,SelectedBinding,Group,compile_local,embed,literal,ScalarProgram) + service=D.DecoderBinding(word,data['phases'],maps,parent.cover,Group,literal, + ScalarProgram,C.signed_recipe,P.map_group,P.order) + return data,packet,word,parent,service + +def install(root_layer, producer_binding, service_binding, ordinary_factory, adopt=True): + """Compile before input; create two distinct paid Ordinary backends. + + `root_layer` is the actual original RootLayer. Its original exact C Machine + is retained and used sequentially by producer and service. `ordinary_factory` + must construct admitted source Ordinary instances, not endpoint doubles. + Runtime descriptors are generated by Installation, never by this factory. + """ + import runtime + from machine import Machine,transfer + from cardinal_counts import Count + from session import erase_marker + I=runtime.module('qq16_installer',HERE/'installer.py') + P=runtime.module('qq16_packet',HERE/'packet.py') + S=runtime.module('qq16_lifecycle',HERE/'lifecycle.py') + from qq16_producer import machine_class + from qq16_decoder import ServiceBank + cls=machine_class(Machine,Count,transfer,erase_marker) + original=root_layer.machine + producer_native,service_native=ordinary_factory(),ordinary_factory() + I.need(len({id(original.monomial.compact.binary.native),id(producer_native),id(service_native)})==3, + 'three distinct admitted Ordinary inventories') + parent=cls(producer_binding,producer_native,producer_binding.catalogue,original) + service=cls(service_binding,service_native,service_binding.catalogue,original) + installation=I.Installation(producer_binding,service,original, + P.PacketCompiler,S.CallerStorage,ServiceBank, + fields=2*service_binding.ports,adopt=adopt) + parent.at_fence=installation + I.attach_root(root_layer,parent) + return installation diff --git a/research/qq16-caller-install/continuation.py b/research/qq16-caller-install/continuation.py new file mode 100644 index 0000000000..0639356935 --- /dev/null +++ b/research/qq16-caller-install/continuation.py @@ -0,0 +1,172 @@ +"""Paid common-F17 reconstruction of the selected first pair. + +This compiler accepts already-authenticated canonical packet and phase records. +It emits operations; it does not claim that a host-language payload loader is a +physical packet implementation. New work: Chris R, OpenAI Codex assistance. +SPDX-License-Identifier: Apache-2.0 +""" +from collections import Counter +from fractions import Fraction as F +import hashlib +import json + +I = tuple(1 << j for j in range(73)) + + +def need(ok, reason): + if not ok: + raise ValueError(reason) + + +def emit(packet, phases): + """Selected G on recovered originals in common F17, then exact Y exit. + + This uses the selected full word's scalar shadow, NOT the centre-free + core's J shadow. Selected native/common-label refinement is inherited. + """ + need(len(phases['recipes']) == 112, 'all actual ports') + events = [('add', 'W'+str(p), 'Z'+str(p), 1) for p in range(112)] + events.extend(('add', 'Z'+str(p), 'W'+str(p), -1) for p in range(112)) + for p, record in enumerate(phases['recipes']): + events.append(('line', 'W'+str(p), p, record['q'], -1)) + return events + + +def add(a, b, c): + out = a.copy() + for key, value in b.items(): + out[key] = out.get(key, 0) + c*value + if not out[key]: + del out[key] + return out + + +def phase(axes, u): + return sum((axis & u).bit_count() % 2 for axis in axes) % 4 + + +def selected_shadow(programs): + """Literal source 712-column shadow, with no inverse of private CLEARs.""" + result = {} + for orientation in ('forward', 'backward'): + state = [{i: F(1)} for i in range(712)] + def role(raw): + kind, index = raw + need(kind in ('L', 'C'), 'actual source role kind') + return index + (704 if kind == 'C' else 0) + for event in programs[orientation]: + if event[0] != 'scalar': + need(event[0] in ('phase', 'climb', 'center', 'adapter', 'residual_adapter'), + 'source native alphabet') + continue + e = event[1] + target = role(e[1]) + if e[0] == 'clear': + need(target >= 704, 'only private clear') + state[target] = {} + elif e[0] == 'copy': + state[target] = state[role(e[2])].copy() + elif e[0] == 'scale': + state[target] = {k: v*F(e[2], e[3]) for k, v in state[target].items()} + else: + need(e[0] == 'add', 'known scalar event') + state[target] = add(state[target], state[role(e[2])], F(e[3], e[4])) + identity = [{i: F(1)} for i in range(712)] + expected = identity[:224] + if orientation == 'forward': + expected = identity[:112] + [add(identity[112+p], identity[p], 1) for p in range(112)] + else: + expected = [add(identity[p], identity[112+p], -1) for p in range(112)] + identity[112:224] + need(state[:224] == expected, 'actual full selected data shadow') + need(state[224:704] == identity[224:704], 'helper scalar identity only; native progress retained') + need(state[704:] == [{} for _ in range(8)], 'private cleared; never inverted') + result[orientation] = len(programs[orientation]) + return result + + +def audit(packet, phases, programs=None, template=None): + need(programs is not None and template is not None, 'authenticated actual selected source required') + source = selected_shadow(programs) + calls = [template['calls'][i] for i in (0, 4)] + for stage, call in enumerate(calls): + need(call['replica'] == 0 and call['pair'] == 0 and call['stage'] == stage, + 'actual selected first pair') + digest = hashlib.sha256(json.dumps(programs[call['orientation']], sort_keys=True, separators=(',', ':')).encode()).hexdigest() + need(digest == call['local_program_sha256'], 'actual selected called word hash') + need(call['owners'][:224] == [[p, [1, stage, p % 112]] for p in range(224)], + 'same-port X/Y owner routes cancel in the selected unit shear') + bridge = template['execution_schedule'][6] + need(bridge['kind'] == 'bridge' and bridge['src'] == 1 and bridge['dst'] == 0 + and bridge['coefficient'] == 1, 'actual named two-leg bridge') + word = emit(packet, phases) + census = dict(Counter(e[0] for e in word)) + need(census == {'add': 224, 'line': 112}, 'complete reconstruction census') + # Every bank column; line changes the output frame, not logical content. + state = {side+str(p): {p+(112 if side == 'W' else 0): F(1)} + for side in ('Z', 'W') for p in range(112)} + for e in word: + if e[0] == 'add': + state[e[1]] = add(state[e[1]], state[e[2]], e[3]) + for p in range(112): + need(state['Z'+str(p)] == {112+p: F(-1)}, 'current X, all columns') + need(state['W'+str(p)] == {p: F(1),112+p: F(1)}, 'current Y, all columns') + # Pointwise nonconstant owner/payload certificate. The arbitrary values + # depend on owner, port and character; source units act independently at + # every point. Both bridge legs retain independent pair-1 inputs. + tests = [0] + list(I) + [I[i] ^ I[j] for i in range(73) for j in range(i)] + exact_frame_checks = 0 + for record in phases['recipes']: + q = record['q'] + need(q > 0 and q < 512 and q.bit_count() % 2 == 1, 'actual odd port label') + for u in tests: + current = phase(I[:17], u) + negative_line = -((q & u).bit_count() % 2) + # Product phases add; canonical parity-polynomial samples determine + # every degree-at-most-two Z4 phase, not just these characters. + want_y = (sum((axis & u).bit_count() % 2 for axis in I[:17]) - ((q & u).bit_count() % 2)) % 4 + parity = (q & u).bit_count() % 2 + kernel = ((1+1j) + (1-1j)*((-1)**parity))/2 + actual_x = (1j)**current + actual_y = actual_x*((-1)**parity)*kernel + need(actual_x == (1j)**phase(I[:17], u) and actual_y == (1j)**want_y, + 'actual negative line kernel and all-port output gauges') + exact_frame_checks += 2 + cases = 0 + sign_rejections = 0 + axes = I[:17] + for owner_key in (0, 1, 13, 448): + for u in (1, 2, 1 << 9, (1 << 16) | 1, 0): + for p, record in enumerate(phases['recipes']): + x = complex(3*p + 5*owner_key + u.bit_count(), p-owner_key) + y = complex(7*p - 2*owner_key + (u & 3), owner_key+3) + incoming_x = complex(11-p, owner_key+2) + incoming_y = complex(p+17, -owner_key) + factor = (1j)**phase(axes, u) + line_phase = (record['q'] & u).bit_count() % 2 + current_x = -factor*y + current_y = factor*(x+y)*(1j)**(-line_phase) + actual = (current_x + factor*incoming_x, + factor*(1j)**(-line_phase)*incoming_y-current_y) + expected = (factor*(-y+incoming_x), + factor*(1j)**(-line_phase)*(incoming_y-x-y)) + need(actual == expected, 'both bridge legs on varying owner/payload coefficients') + if line_phase and x+y: + need(factor*(x+y)*(1j)**line_phase != current_y, + 'positive line rejected') + sign_rejections += 1 + cases += 1 + need(phases['recipes'][0]['q'] == 11 and sign_rejections > 0, 'actual signed occurrence regression') + return {'status': 'PASS_SELECTED_SHADOW_LIFT_AND_PHYSICAL_RECONSTRUCTION', + 'source_word_events': source, 'census': census, + 'all_data_columns': 224, 'all_port_frame_checks': exact_frame_checks, 'owner_character_port_cases': cases, + 'positive_line_rejections': sign_rejections, + 'logical_endpoint': '(-y,x+y)', + 'native_entry': '224 recovered originals in F17', + 'native_exit': 'X:F17; Y:F17 Cq^-1', + 'private_fields': 0, + 'inherited': ['actual selected common-label and exact unary refinement', + 'actual DATA-PHASES external gauges and chronological hosting'], + 'complete_actual_caller_installation': False, + 'remaining': ['actual QQ16 producer and full-cover scheduling', + 'encoded packets and actual signed child execution', + 'exclusive storage, fixed-port copyback and both-leg bridge']} diff --git a/research/qq16-caller-install/cost.py b/research/qq16-caller-install/cost.py new file mode 100644 index 0000000000..01da502449 --- /dev/null +++ b/research/qq16-caller-install/cost.py @@ -0,0 +1,406 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent local QQ16 invoice and fixed-grid admission arithmetic. + +The caller authenticates all supplied source objects before calling audit. +Counts are not tape-action prices. A charge-screen failure is not a lower +bound on runtime. Chris R / Clear1nsight with OpenAI Codex assistance. +""" +from collections import Counter +from fractions import Fraction as Q + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def gamma(): + result = 1 << 1296 + for i in range(1, 37): + result *= (1 << (2 * i)) - 1 + return result + + +def ceil_log2_ratio(x): + x = Q(x) + need(x >= 1, 'growth factor at least one') + k = max(0, x.numerator.bit_length() - x.denominator.bit_length()) + while Q(1 << k) < x: + k += 1 + return k + + +def decoder_census(word): + count = Counter() + for event in word: + kind = event[0] + if kind == 'line': + need(event[3] in (-1, 1), 'signed line') + count['native_rank_one'] += 1 + elif kind == 'map': + count['map'] += 1 + elif kind == 'clear': + count['clear'] += 1 + elif kind == 'add': + q = Q(event[3]) + need(abs(q) in (1, Q(1, 4)), 'known decoder ADD') + count['unit_add' if abs(q) == 1 else 'quarter_add'] += 1 + else: + need(kind in ('begin', 'end', 'checkpoint'), 'complete frozen decoder alphabet') + need(tuple(count[k] for k in ('native_rank_one', 'map', 'clear', 'unit_add', 'quarter_add')) + == (224, 352, 416, 1820, 896), 'complete frozen decoder census') + count['wrapper'] = 2 * count['native_rank_one'] + count['scalar_allowance'] = 8 * count['unit_add'] + 12 * count['quarter_add'] + 2 * count['clear'] + return dict(count) + + +def native_screen(producer_lines=32, decoder_lines=224, return_lines=112, + removed_rank_eight=16): + need(all(type(x) is int and x >= 0 for x in + (producer_lines, decoder_lines, return_lines, removed_rank_eight)), 'nonnegative occurrence counts') + need(removed_rank_eight > 0, 'positive removed native charge') + added = producer_lines + decoder_lines + return_lines + ratio_zero = Q(added, 8 * removed_rank_eight) + need(added > 8 * removed_rank_eight, 'strict endpoint screen') + return {'added_rank_one': added, 'removed_rank_eight': removed_rank_eight, + 'added_width_sum_over_lambda': added, + 'removed_width_sum_over_lambda': 8 * removed_rank_eight, + 'minimum_added_over_removed_charge_alpha_0_to_1': str(ratio_zero), + 'ratio_at_alpha_1': str(Q(added, removed_rank_eight)), + 'positive_charge_difference_at_alpha_0_over_lambda': added - 8 * removed_rank_eight, + 'zero_native_repair_added_rank_one': producer_lines + decoder_lines, + 'zero_native_repair_deficit_alpha_0': producer_lines + decoder_lines - 8 * removed_rank_eight, + 'formula': '(added - removed*8**(1-alpha))*73**(alpha-1)', + 'scope': 'Isolated same-volume homogeneous native-component tariff, alpha in [0,1]. Does not reject whole-connection affordability: changed retained-root protocols may supply compensating credit. No runtime lower bound or exponent claim.'} + + +def literal_height(events, lam): + """Conservative growth/debt of an authenticated physical producer code. + +Uses literal op kinds from native_program.compile_local, not final norms. +Completed C tensor contributes rank*lambda; the unfinished native interior +is recorded separately by maximum rank. Horner scratch costs are included. +""" + need(type(lam) is int and lam >= 1, 'positive lambda') + growth = debt = maxrank = 0 + count = Counter() + for op in events: + kind = op[0] + count[kind] += 1 + if kind == 'child': + rank = op[3] + need(type(rank) is int and 1 <= rank < 73, 'proper native rank') + growth += rank * lam + debt += rank * lam + maxrank = max(maxrank, rank) + elif kind == 'scalar': + key = op[4] + scalar, n, den = key + q = Q(n, den) + need(q.denominator & (q.denominator - 1) == 0, 'dyadic scalar') + need(scalar in ('add', 'scale'), 'scalar operation') + # Include the Horner scratch numerator before division, not only + # the completed affine coefficient. Prefix size <= 2|n|+1. + growth += ceil_log2_ratio(max(Q(1), Q(2 * abs(q.numerator) + 1))) + debt += q.denominator.bit_length() - 1 + else: + need(kind in ('marker', 'zero', 'copy', 'monomial', 'identity', 'exchange'), 'complete physical alphabet') + # Monomials include Gaussian unit phases only. exchange changes a sign. + return {'growth_bits': growth, 'denominator_bits': debt, + 'maximum_child_rank': maxrank, 'counts': dict(sorted(count.items()))} + + +def fixed_grid_admission(lam, d, producer_growth, producer_debt, + producer_maxrank=48, bridge_coefficient=1): + """Exact symbolic-integer sufficient local admission; never executes payload. + +Entry is an unchanged admitted source cut with component modulus <=2**(2Bd) + and grid 2**(-p-2Bd). The inserted producer is charged in full afterwards. + """ + need(type(lam) is int and type(d) is int and 1 <= 73 * lam <= d, 'actual parent width within root') + need(all(type(x) is int and x >= 0 for x in (producer_growth, producer_debt)), 'producer literal heights') + need(type(producer_maxrank) is int and 1 <= producer_maxrank < 73, 'producer maximum rank') + B = 1041408 * gamma() + (1 << 100000) + Delta = (1 << 210000) * d + prior = 2 * B * d + a = 2 * B * lam + bridge_bits = ceil_log2_ratio(1 + abs(Q(bridge_coefficient))) + # D whole-word completed bound: growth19+3t, denominator9+3t. + # Actual current G uses two unit shears: growth2, no denominator debt. + t = lam - 1 + completed_growth = prior + producer_growth + 19 + 3*t + 2 + lam + bridge_bits + completed_debt = prior + producer_debt + 9 + 3*t + lam + # Bound one unfinished callback at each possible stage, including producer. + interior_growth = max(prior + producer_growth + 2*B*producer_maxrank*lam + 1, + prior + producer_growth + 20 + 3*t + a, + prior + producer_growth + 22 + 3*t + a) + interior_debt = max(prior + producer_debt + 2*B*producer_maxrank*lam, + prior + producer_debt + 9 + 3*t + a, + prior + producer_debt + 9 + 3*t + a) + growth = max(completed_growth, interior_growth) + debt = max(completed_debt, interior_debt) + admitted = growth <= Delta and debt <= Delta + return {'admitted': admitted, 'lambda': lam, 'root_width': d, + 'producer_growth_bits': producer_growth, 'producer_denominator_bits': producer_debt, + 'bridge_growth_bits': bridge_bits, 'Delta_bit_length': Delta.bit_length(), + 'maximum_growth_bit_length': growth.bit_length(), + 'maximum_debt_bit_length': debt.bit_length(), + 'growth_strictly_below_Delta': growth < Delta, + 'debt_strictly_below_Delta': debt < Delta, + 'grid': '2**(-p-Delta)', 'physical_component_bits': 'p+2*Delta+3', + 'scope': 'Conditional all-size arithmetic admission at unchanged source entry. Physical lowering, producer correctness, long records and original source height theorem remain premises.'} + + +def module_invoice(word, rows=None): + decoder = decoder_census(word) + return {'decoder': decoder, 'reconnection': { + 'unit_add': 224, 'quarter_scale': 0, 'clear': 0, + 'affine_port_map': 0, 'native_rank_one': 112, + 'native_wrapper': 224, 'owner_basis_monomial': 224, + 'physical_line_monomial': 448, 'fixed_port_copyback': 224, + 'bridge_legs_retained': 2, + 'scalar_microinstructions_shear_only': 224*3, + 'scope': 'Actual G=(-y,x+y): W+=Z; Z-=W. Endpoint requires source lift and owner/frame proof. Copyback, disposal, bridge and routing priced separately.'}, + 'recovery_and_reconnection': { + 'native_rank_one': decoder['native_rank_one'] + 112, + 'native_wrapper': decoder['wrapper'] + 224, + 'owner_basis_monomial': decoder['wrapper'] + 224, + 'physical_line_monomial': 4*(decoder['native_rank_one'] + 112), + 'maps': decoder['map'], + 'unit_add': decoder['unit_add'] + 224, + 'quarter_add': decoder['quarter_add'], 'quarter_scale': 0, + 'clear': decoder['clear'], + 'scalar_microinstructions_before_copyback': + decoder['unit_add']*3 + decoder['quarter_add']*5 + decoder['clear'] + 672, + 'scalar_allowance': decoder['scalar_allowance'] + 8*224}, + 'same_boundary_difference': + 'Compare N_inst + sum_root_inst(P_inst + A_external + Run_C_external + Z_external) ' + '+ T_service against N_base + sum_root_base(P_base + E_embedded + C_embedded + R_embedded). ' + 'Apply at entry-through-bridge first, and retain the later-root protocol delta separately. ' + 'Do not cancel retained children or their C execution contexts from equal ranks or outputs. ' + 'Only the fixed/adopted variants of the same installation have the proved role-equivariant publication cancellation.', + 'separately_charged_source_tariff_terms': ['encoded descriptor work', + 'actual C calls at each packet geometry', 'ordinary map/wrapper work', + 'output fixed-port movement and disposal', 'private/engine inventory', + 'long-record setup outside inherited rate domain'], + 'native_screen': native_screen(), + 'current_reconnection_bound': {'growth_bits': 2, 'denominator_bits': 0, + 'derivation': 'W+=Z gives at most2M; Z-=W prefix at most3M<4M, exact endpoint -oldW.'}} + + +def uniform_word_domain(events): + """Finite source checks supporting the all-lambda inequality in COST.md.""" + need(0 < len(events) < 65536, 'source finite-PC program domain') + for op in events: + if op[0] == 'child': + need(type(op[3]) is int and 1 <= op[3] <= 48, 'selected rank domain') + if op[0] == 'scalar': + kind, num, den = op[4] + q = Q(num, den) + need(abs(q.numerator) <= 65537 and q.denominator <= 65536, + 'selected scalar literal domain') + one = literal_height(events, 1) + two = literal_height(events, 2) + growth_slope = two['growth_bits'] - one['growth_bits'] + debt_slope = two['denominator_bits'] - one['denominator_bits'] + growth_constant = one['growth_bits'] - growth_slope + debt_constant = one['denominator_bits'] - debt_slope + need(max(growth_constant, debt_constant, growth_slope, debt_slope) < (1 << 22), + 'uniform conservative word-height bound') + B = 1041408*gamma() + (1 << 100000) + need(4*B + (1 << 24) < (1 << 210000), 'uniform numerical margin') + return {'growth_constant': growth_constant, 'growth_lambda_slope': growth_slope, + 'debt_constant': debt_constant, 'debt_lambda_slope': debt_slope, + 'maximum_child_rank': one['maximum_child_rank'], + 'uniform_height_bound': '2**22*(lambda+1)', + 'fixed_grid_all_lambda_domain': 'd>=73lambda, lambda>=1, |bridge coefficient|<=1', + 'strict_margin': '4B+2**24 < 2**210000', 'counts': one['counts']} + + +def rejection_controls(word): + rejected = [] + def reject(name, action): + try: + action() + except (ValueError, ZeroDivisionError): + rejected.append(name) + return + raise ValueError('accepted cost mutation: ' + name) + removed = [list(e) for e in word] + removed.pop(next(i for i,e in enumerate(removed) if e[0] == 'line')) + reject('missing native occurrence', lambda: decoder_census(removed)) + wrong = [list(e) for e in word] + next(e for e in wrong if e[0] == 'add')[3] = '1/3' + reject('unsupported scalar tariff', lambda: decoder_census(wrong)) + reject('unknown decoder operation', lambda: decoder_census(word + [['teleport']])) + reject('under-counted native screen', lambda: native_screen(0, 1, 0, 16)) + reject('parent narrower than prepared rank-one domain', + lambda: fixed_grid_admission(2, 73, 0, 0)) + reject('non-dyadic producer arithmetic', + lambda: literal_height([('scalar',0,0,1,('add',1,3))],1)) + fail = fixed_grid_admission(1,73,1 << 220000,0) + need(not fail['admitted'], 'huge actual growth must reject fixed-grid admission') + rejected.append('insufficient physical range') + return rejected + + +def router_invoice(orders, nonzero_translation_maps=None): + """Per-cover coefficients for source cycle groups; exact rational counts.""" + orders = {int(k): int(v) for k,v in orders.items()} + need(orders and all(k>=1 and v>=0 for k,v in orders.items()), 'finite positive map orders') + maps = sum(orders.values()) + translations = maps if nonzero_translation_maps is None else nonzero_translation_maps + need(type(translations) is int and 0 <= translations <= maps, 'translation map census') + groups = sum((Q(v,k) for k,v in orders.items()), Q(0)) + swaps = maps-groups + return {'maps': maps, 'orders': dict(sorted(orders.items())), + 'owner_control_visits_per_Gamma': maps, + 'gather_scatter_commit_groups_per_Gamma': str(groups), + 'source_exchanges_per_Gamma': str(swaps), + 'extra_sign_scales_per_Gamma': str(swaps), + 'exchange_internal_scalar_negations_per_Gamma':str(swaps), + 'direct_dispatch_excludes_exchange_internal':True, + 'translation_monomials_per_Gamma': translations, + 'scope': 'Full-bank scans per emitted cycle. T_exchange includes its internal ScalarEngine negation and transfers; extra sign scale is an additional direct scalar dispatch. Do not charge the nested negation twice.'} + + +def physical_invoice(word): + logical = module_invoice(word) + producer = router_invoice({2:464,5:24,6:12,12:20,17:4,20:4}) + decoder = router_invoice({2:352}) + need(producer['gather_scatter_commit_groups_per_Gamma']=='12286/51', 'producer source map-group coefficient') + return {'logical': logical, 'coefficient_unit': 'Multiply producer_outer and decoder_service occurrence coefficients by Gamma. Publication executes once per reached global service fence; B already includes the complete cover.', + 'producer_outer': {'unit_or_other_ADD':2200, 'private_CLEAR':32, 'SCALE':16, + 'rank_one_children':32,'intrinsic_wrappers':64,'owner_basis_monomials':64, + 'physical_line_monomials':128,'nonmap_groups':43, + 'all_gather_scatter_commit_groups':'14479/51', + 'original_replaced_group_coefficient':2,'map_router':producer}, + 'decoder_service': {'rank_one_children':336,'physical_line_monomials':1344, + 'intrinsic_wrappers':672,'owner_basis_monomials':672, + 'public_CLEAR_scalar_calls':368,'private_zero_calls':48, + 'ADD_scalar_calls':2940,'map_router':decoder, + 'nonmap_groups':1846,'all_gather_scatter_commit_groups':2022, + 'all_monomial_calls_including_map_translations':1696, + 'scalar_engine_calls_including_map_sign_corrections':3484, + 'direct_dispatch_excludes_exchange_internal':True, + 'exchange_internal_scalar_calls':176, + 'exchange_charge_note':'Each source exchange_step has one internal ScalarEngine negation plus transfers; these are included in T_exchange, not in the direct-dispatch3484 or charged a second time.'}, + 'bank_volumes': {'owner_packet_v':'P*U*row_bits', 'whole_family_V':'Gamma*v', + 'original_parent_B':'14336*V','service_source_S':'448*V', + 'service_protected_return':'448*V'}, + 'service_assembly_extract_bound': '4096*(S+448P*(bE+1)+bP+D_service+1)', + 'selected_publication': {'protocol': 'whole-bank adoption', + 'frequency': 'once per completed global installation', + 'fixed_commit_cell_actions': '20B+30', 'adopt_cell_actions': '9B+26', + 'matched_cell_action_saving': '11B+4', + 'saving_with_additional_finite_control': '11B+4-c_R', + 'scope': 'Matched publication implementations only; all other local installation work identical. No original QQ16 arithmetic or kappa credit.'}, + 'paid_service_boundaries': [ + 'P-dependent assembly of224borrowed family fields plus initialization224owned zero fields', + 'service Machine.run source copy, encoded node setup, every group full-service-bank scan', + 'service protected return; compare all224borrowed fields; extract224owned fields', + 'erase service assembly bank and protected return', + '224 fixed-destination transfers plus parent full-bank scatter/adopt/release; original fixed-copy commit retained as matched alternative'], + 'inventory': 'Existing modified producer Machine, separate decoder Machine, separate original recursive C Machine, plus acquisition/compiler/service roles. Separate Ordinary instances and protected-return backing are charged.', + 'scope': 'Constructive operation-sum invoice. Source authentication, map-order/census binding and exact operator refinement are required. No elapsed runtime claim.'} + + +def uniform_interval_domain(programs): + """Aggregate source-bound height, including retained intervening groups. + + A supplied code list represents one per-owner complete group body. The + integrator proves family uniqueness and owner-chart bijectivity, so one + maximum-norm envelope charges each body once across a complete cover. + Map cycles are unit-phase permutations and add no numerical height. + """ + need(type(programs) in (tuple,list) and programs, 'complete source interval programs') + certificates=[uniform_word_domain(program) for program in programs] + keys=('growth_constant','growth_lambda_slope','debt_constant','debt_lambda_slope') + total={key:sum(c[key] for c in certificates) for key in keys} + need(max(total.values()) < (1 << 22), 'whole interval conservative height bound') + total.update({'programs':len(programs), + 'maximum_child_rank':max(c['maximum_child_rank'] for c in certificates), + 'uniform_height_bound':'2**22*(lambda+1)', + 'strict_margin':'4B+2**24 < 2**210000', + 'scope':'Actual complete producer interval, per-owner source traversal with family/owner permutation proof; not just the largest one-group PC.'}) + return total + + +def publication_invoice(bank_bits): + """Exact matched cell-action difference after common completed scatter. + + Actual operation counts/protocol correspondence are proved and metered in + lifecycle.py; this independently checks subtraction and distinct units. + Public ports are fixed, while all internal current-role bindings exchange. + """ + need(type(bank_bits) is int and bank_bits > 0, 'positive complete bank extent') + B=bank_bits + fixed={'reads':9*B+13,'writes':3*B+1,'moves':8*B+16} + adopted={'reads':4*B+11,'writes':B+1,'moves':4*B+14} + saved={key:fixed[key]-adopted[key] for key in fixed} + need(saved=={'reads':5*B+2,'writes':2*B,'moves':4*B+2}, 'literal matched action difference') + need(sum(saved.values())==11*B+4, 'publication saving exactly once') + return {'bank_bits':B,'fixed_commit':fixed,'adopted_commit':adopted, + 'saved_cell_actions_by_kind':saved,'saved_cell_actions':sum(saved.values()), + 'finite_control_charge':'c_R additional to tape actions', + 'complete_comparison':'T_install_adopt = T_install_fixed - (11B+4) + c_R', + 'scope':'Same read-complete/scattered state and same continuation, fixed public ports, all internal current bindings updated. No source arithmetic credit.'} + + +def root_protocol_invoice(census): + """Bind independently checked counts to an authenticated actual source census. + + This enumerates operation sums; it does not estimate an unmeasured protocol + delta or identify embedded and external C contexts from matching ranks. + """ + def hist(name): + row=census[name] + h={int(k):v for k,v in row['rank_counts'].items()} + need(all(type(v) is int and v>=0 for v in h.values()), 'root rank multiplicity') + need(sum(h.values())==row['calls'], 'root call sum') + need(sum(k*v for k,v in h.items())==row['rank_mass'], 'root rank mass') + return Counter(h) + baseline=hist('baseline_whole_root');installed=hist('installed_whole_root') + prefix=hist('baseline_entry_through_bridge');newprefix=hist('installed_entry_through_bridge') + suffix=hist('retained_later_source_7_481') + need(baseline==Counter({1:349604,2:60192,3:62585,4:20448,5:11808,7:7,8:1152,48:4866}), + 'frozen original whole-root child census') + need(baseline==prefix+suffix and installed==newprefix+suffix, 'prefix and later root partition') + removed=Counter({8:16});added=Counter({1:32}) + need(installed==baseline-removed+added and newprefix==prefix-removed+added, + 'only named native replacements') + need((sum(prefix.values()),sum(newprefix.values()),sum(suffix.values()))==(17565,17581,493097), + 'source boundary multiplicities') + retained=baseline-removed + return {'unit':'Each occurrence coefficient multiplies Gamma at this one modified outer root; original recursive descendants are inside their C execution terms.', + 'baseline_root_calls':sum(baseline.values()), + 'installed_root_calls':sum(installed.values()), + 'service_external_calls':336, + 'all_external_runs':sum(installed.values())+336, + 'retained_root_calls_with_changed_protocol':sum(retained.values()), + 'retained_prefix_calls_with_changed_protocol':sum((prefix-removed).values()), + 'later_root_calls_with_changed_protocol':sum(suffix.values()), + 'baseline_prefix_calls':sum(prefix.values()), + 'installed_prefix_and_service_calls':sum(newprefix.values())+336, + 'baseline_rank_counts':dict(sorted(baseline.items())), + 'installed_rank_counts':dict(sorted(installed.items())), + 'embedded_call_operation_sum':[ + 'P_b: prepare_child arithmetic, capsule payload and descriptor copies, encoded header, Count closure', + 'E_b: primitive boundary and role origins, Parking.park on every live parked role, capsule-to-active transfers and child control setup', + 'C_emb: actual original child node/body and recursive descendants in embedded nonroot context; excludes its final parent return', + 'R_b: output transfer, active child role cleanup, Parking.restore, header read/clear, group reconstruction, output-to-parent target transfer and bank/head rebinding'], + 'external_call_operation_sum':[ + 'P_i: actual prepare_child arithmetic, capsule copies, encoded header and Count closure, with installed event indices', + 'A_i: boundary/header/instruction checks and finite descriptor views', + 'Run_C_ext: complete separate original Machine.run, borrowed input and descriptor copies, node setup, body/descendants, root protected return and engine closure', + 'Z_i: protected output-to-target transfer, output-marker erase, all capsule and header cleanup and PC update'], + 'nonchild_operation_sum':[ + 'N_b or N_i: root Machine.run input/descriptors/setup, all nonchild scalar/monomial/exchange and group bank operations, event/owner control, final root output/cleanup', + 'N_i includes every installed finish_group fence predicate, including after the local continuation', + 'T_service contains assembly/compiler/lifecycle, service nonchild Machine.run/setup/return, and all336 external service child sums exactly once'], + 'exact_execution_comparison':'N_i + sum_inst(P_i+A_i+Run_C_ext+Z_i) + T_service < N_b + sum_base(P_b+E_b+C_emb+R_b)', + 'retained_protocol_credit':'sum_retained[(P_b+E_b+C_emb+R_b)-(P_i+A_i+Run_C_ext+Z_i)]', + 'later_obligation':'493097*Gamma changed root child protocols plus any later nonchild/control/context delta; retained source instructions alone do not cancel these costs.', + 'component_screen_only':True, + 'body_context_cancellation_proved':False, + 'next_discriminator':'Meter paired source embedded versus external child calls with actual live parent bank/descriptors/dirty backing and descendant context; then compare the constructive protocol credit against all added bank scans and service costs.'} diff --git a/research/qq16-caller-install/decoder-fixture.py b/research/qq16-caller-install/decoder-fixture.py new file mode 100644 index 0000000000..c6829e39be --- /dev/null +++ b/research/qq16-caller-install/decoder-fixture.py @@ -0,0 +1,161 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Reduced actual decoder grammar and all-output prefix zipper controls. + +Authenticate source closure before execution. Initial payloads/expected arrays +are test oracles only. This does not execute selected O73 production geometry. +""" +from pathlib import Path +from types import SimpleNamespace +import importlib.util +import sys,json +from hashlib import sha256 +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +sys.path.insert(0,str(HERE)) +import runtime +runtime.cold() +runtime.module('producer',HERE/'producer.py') +runtime.module('decoder',HERE/'decoder.py') +from cardinal_counts import Count +from records import Tape +from ordinary import Ordinary +from macro_code import Code +from machine import Machine,transfer +from session import erase_marker +from selected_binding import Group,literal +from fixture_binding import FixtureBinding +from cover import OrthogonalCover +from scalar_program import ScalarProgram +from words import BLANK +from stream import Counter +from producer import map_group,machine_class,order,need +from decoder import DecoderBinding,ServiceBank + + +def native(): + return Ordinary(2,SimpleNamespace(codes=SimpleNamespace(q=2)), + SimpleNamespace(families=0),(Code((('unreachable',),),0),),capacity=64) + + +def raw(t):return bytes(t.cells[1:]).rstrip(bytes([BLANK])) + +def encode(values,h):return bytes((x>>b)&1 for pair in values for x in pair for b in range(h)) + +def recipe(q,sign,dimension): + need(dimension==2 and q in (1,2),'reduced signed orthogonal axes') + axes=(1,2) if q==1 else (2,1) + return {'right':literal(axes),'left':literal(axes,0 if sign==1 else q)} + + +def zipper(): + fields=224;inputs=tuple(Tape() for _ in range(fields));outputs=tuple(Tape() for _ in range(fields)) + service=ServiceBank(Tape,Counter,BLANK,fields) + p,n=Count.literal(3),Count.literal(7) + images=[] + for family,t in enumerate(inputs): + bits=bytes(((family*7+prefix*5+bit*3)>>(bit%3))&1 for prefix in range(3) for bit in range(7)) + images.append(bits) + for b in bits:t.append(b) + t.rewind() + bank=service.assemble(inputs,p,n) + expected=b''.join(b''.join(x[k*7:(k+1)*7] for x in images)+bytes(fields*7) for k in range(3)) + need(raw(bank)==expected,'prefix-major all448family bank order') + returned=Tape();returned_bits=bytearray(expected) + outimages=[bytes((family+prefix+bit)%2 for prefix in range(3) for bit in range(7)) for family in range(fields)] + for prefix in range(3): + start=prefix*fields*14+fields*7 + returned_bits[start:start+fields*7]=b''.join(x[prefix*7:(prefix+1)*7] for x in outimages) + for b in returned_bits:returned.append(b) + returned.rewind() + service.extract(returned,inputs,outputs,p,n) + need(all(raw(t)==v for t,v in zip(inputs,images)),'all224 borrowed values preserved') + need(all(raw(t)==v for t,v in zip(outputs,outimages)),'all224 output family order') + need(raw(service.bank)==raw(returned)==b'' and service.state=='closed','bank/output consumed') + # Prefix truncation is rejected without changing a borrowed source. + short=Tape() + for b in images[0][:-1]:short.append(b) + short.rewind();rejected=False + try:service.assemble((short,*inputs[1:]),p,n) + except ValueError:rejected=True + need(rejected and all(raw(t)==v for t,v in zip(inputs,images)),'short-source rejected with original sources preserved') + answer={'status':'PASS_224_OUTPUT_ENCODED_PREFIX_ZIPPER','prefixes':3,'borrowed':224,'owned':224, + 'bits_per_family_prefix':7,'assembled_sha256':sha256(expected).hexdigest(), + 'all_outputs_checked':True,'short_input_rejected':True} + for t in (*inputs,*outputs,short,service.bank):t.clear() + p.close();n.close() + return answer + + +def physical(mutation=None): + word=[['clear','Z0','current'],['add','Z0','X0','1'], + ['clear','Z1','current'],['add','Z1','X1','1'], + ['clear','W0','current'],['add','W0','Y0','1'], + ['clear','W1','current'],['add','W1','Y1','1'], + ['line','W0',0,1],['map','W1',1,0,False], + ['begin','private',8],['clear','F0','current'], + ['add','F0','Z0','1'],['add','Z1','F0','1/4'], + ['add','Z1','F0','-1/4'],['add','F0','Z0','-1'], + ['clear','F0','current'],['end','private',8], + ['map','W1',1,0,True],['line','W0',0,-1], + ['checkpoint','return']] + if mutation=='negative_sign': word[19][3]=1 + maps={(1,0,False):{'owner_right_matrix_columns':[2,1],'payload_translation_at_identity_owner':1}, + (1,0,True):{'owner_right_matrix_columns':[2,1],'payload_translation_at_identity_owner':2}} + binding=DecoderBinding(word,{'recipes':[{'q':1},{'q':2}]},maps,OrthogonalCover(2),Group,literal, + ScalarProgram,recipe,map_group,order,ports=2,dimension=2) + childbinding=FixtureBinding();child=Machine(childbinding,native(),childbinding.catalogue) + engine=machine_class(Machine,Count,transfer,erase_marker)(binding,native(),binding.catalogue,child) + h=20;rows=16;prefixes=2 + desc={k:Count.literal(v) for k,v in dict(prefixes=prefixes,rows=rows,front=0,compact_bits=0,before=0, + width=2,after=0,back=0,spacing=1,guard=1,residue=0,component_bits=h,coefficients=1,root_width=2).items()} + # Physical order P, family8, owner2, payload4. Includes arbitrary nonzero owned dirt. + values=[(256*(3+i%17),256*((i*5)%13-6)) for i in range(prefixes*rows*4)] + src=Tape();data=encode(values,h) + for b in data:src.append(b) + src.rewind();snapshots={k:raw(v.tape) for k,v in desc.items()} + out=engine.run(src,desc) + expected=values[:] + def cm(a,b,negative): + x=complex(*a);y=complex(*b) + pair=((x+y+1j*(x-y))/2,(x+y-1j*(x-y))/2) + if negative:pair=pair[::-1] + return [(int(z.real),int(z.imag)) for z in pair] + for prefix in range(prefixes): + for owner in range(2): + for port in range(2): + xx=prefix*64+port*8+owner*4 + yy=prefix*64+(2+port)*8+owner*4 + zz=prefix*64+(4+port)*8+owner*4 + ww=prefix*64+(6+port)*8+owner*4 + for z in range(4): + expected[zz+z]=tuple(-a for a in values[yy+z]) + expected[ww+z]=tuple(a+b for a,b in zip(values[xx+z],values[yy+z])) + # Cover owner swaps the two intrinsic q axes. + axis=(2 if port==0 else 1) if owner==0 else (1 if port==0 else 2) + for z in range(4): + if not z&axis: + expected[ww+z],expected[ww+(z^axis)]=cm(expected[ww+z],expected[ww+(z^axis)],True) + need(raw(out)==encode(expected,h),'actual D-grammar both-sign/current-return endpoint') + need(raw(src)==data and all(raw(v.tape)==snapshots[k] for k,v in desc.items()),'borrowed inputs and descriptors preserved') + need(engine.closed and child.closed and all(t.read()==BLANK for t in engine.parked),'all service/native state closed') + result={'status':'PASS_ACTUAL_REDUCED_DECODER_GRAMMAR','prefixes':prefixes,'cover':2, + 'nonconstant_complex_values':len(values),'dimension':2,'component_bits':h, + 'endpoint_sha256':sha256(raw(out)).hexdigest(),'both_signs':True,'private_scope':8, + 'compiler':binding.audit(),'scope':'Reduced full grammar on actual source Machine/MonomialPackets/native C, not selected full D or O73 production execution.'} + out.clear();src.clear() + for v in desc.values():v.close() + return result + + +def run(): + result={'zipper':zipper(),'physical':physical()} + try: physical('negative_sign') + except ValueError as exc: + need('actual D-grammar both-sign/current-return endpoint' in str(exc), 'targeted native sign failure') + result['negative_sign_rejected']=True + else: raise ValueError('native sign mutation accepted') + return result + +if __name__=='__main__': + try:print(json.dumps(run(),sort_keys=True)) + finally:runtime.cleanup() diff --git a/research/qq16-caller-install/decoder.py b/research/qq16-caller-install/decoder.py new file mode 100644 index 0000000000..edc8bdbd22 --- /dev/null +++ b/research/qq16-caller-install/decoder.py @@ -0,0 +1,301 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Finite full-cover D/current-return compiler and encoded service-bank join. + +Chris R with OpenAI Codex assistance. Physical primitives and original recursive +C retain Jose Manuel's source/refinement credit. Authenticate dependencies first. +""" +from collections import Counter +from fractions import Fraction +from copy import copy +from functools import lru_cache +from hashlib import sha256 +import json + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +class DecoderBinding: + """Every event is a complete cover barrier; private words stay per owner. + + The binding has no access to payloads or encoded input sizes. Signed line + recipes and owner maps are finite authenticated compilation constants. + The service must dispatch child capsules to a separate ORIGINAL C Machine. + """ + maximum_rank = 1 + private = 16 + + def __init__(self, word, phases, maps, cover, Group, literal, ScalarProgram, + signed_recipe, map_group, order, ports=112, dimension=73, + continuation=True): + self.dimension, self.ports, self.families = dimension, ports, 4*ports + self.cover, self.Group, self.literal = cover, Group, literal + self.signed_recipe, self.map_group = signed_recipe, map_group + self.map_order = order + self.maps = maps + self.labels = tuple(r['q'] for r in phases['recipes']) + need(len(self.labels) == ports, 'complete finite port labels') + self.slots = max([4*ports] + [order(tuple(m['owner_right_matrix_columns'])) for m in maps.values()]) + need(self.slots <= self.families*cover.size, 'finite group slots fit service bank') + self.catalogue = {k: ScalarProgram(*k) for k in + [('scale', 0, 1), ('scale', -1, 1)] + + [('add', n, d) for n,d in ((1,1),(-1,1),(1,4),(-1,4))]} + self.word = tuple(tuple(e) for e in word) + events, block = [], None + for i, raw in enumerate(word): + e = tuple(raw) + if e[0] == 'begin': + need(block is None and e[2] in (8,16), 'non-nested finite private word') + block = [i, e[1], e[2], []] + elif e[0] == 'end': + need(block is not None and tuple(e[1:]) == tuple(block[1:3]), 'matching private end') + events.append(('private', block[0], tuple(block[3]), block[2])) + block = None + elif block is not None: + need(e[0] in ('clear','add'), 'private scope contains only scalar operations') + block[3].append((i,e)) + elif e[0] == 'checkpoint': + events.append(('checkpoint', i, (), 0)) + else: + need(e[0] in ('clear','add','line','map'), 'complete decoder grammar') + events.append(('public', i, ((i,e),), 0)) + need(block is None, 'closed decoder private scope') + self.decoder_events = len(events) + if continuation: + for p in range(ports): + events.append(('public',len(word)+p,((len(word)+p,('add','W'+str(p),'Z'+str(p),'1')),),0)) + for p in range(ports): + events.append(('public',len(word)+ports+p,((len(word)+ports+p,('add','Z'+str(p),'W'+str(p),'-1')),),0)) + for p in range(ports): + events.append(('public',len(word)+2*ports+p,((len(word)+2*ports+p,('line','W'+str(p),p,-1)),),0)) + self.events = tuple(events) + # No producer fence is part of this service. The shared child adapter's + # fence hook is disabled by an unreachable finite event value. + self.global_fence = len(events) + for event in self.events: + for _,e in event[2]: + if e[0] in ('clear','add','line','map'): + need(e[1][0] in ('Z','W','F','G'), 'borrowed X/Y are immutable') + + def family(self, name): + need(type(name) is str and name[0] in 'XYZW' and name[1:].isdigit(), 'persistent role') + p=int(name[1:]); need(0 <= p < self.ports, 'persistent port') + return 'XYZW'.index(name[0])*self.ports+p + + def group_count(self, event): + need(0 <= event < len(self.events), 'finite decoder event') + return 1 + + def group(self, event, subgroup, owner): + need(subgroup == 0, 'complete cover before next decoder event') + kind,index,body,private = self.events[event] + if kind == 'checkpoint': + return self.Group(((0,owner),), (), {}) + if len(body)==1 and body[0][1][0]=='map': + e=body[0][1] + return self.map_group(self.cover,owner,self.family(e[1]), + self.maps[(e[2],e[3],e[4])],self.Group,self.literal) + names=[] + for _,e in body: + for name in (e[1:3] if e[0]=='add' else e[1:2]): + if name[0] in 'XYZW' and name not in names: names.append(name) + need(names and len(names)<=self.slots, 'gathered persistent decoder roles') + keys=tuple((self.family(name),owner) for name in names) + def role(name): + if name[0] in 'XYZW': return names.index(name) + need(name[0] in 'FG' and name[1:].isdigit(), 'private role alphabet') + r=int(name[1:])+(8 if name[0]=='G' else 0) + need(0 <= r < private, 'private role within current generation') + return self.slots+r + code=[]; recipes={} + for occurrence,e in body: + target=role(e[1]) + if e[0]=='clear': + code.append(('zero',occurrence,target) if target>=self.slots else + ('scalar',occurrence,target,None,('scale',0,1))) + elif e[0]=='add': + c=Fraction(e[3]);key=('add',c.numerator,c.denominator) + need(key in self.catalogue and target!=role(e[2]), 'paid scalar literal and distinct ports') + code.append(('scalar',occurrence,target,role(e[2]),key)) + else: + need(e[0]=='line' and private==0 and e[3] in (-1,1), 'native outside private word') + q=self.labels[e[2]]; pair=self.signed_recipe(q,e[3],self.dimension) + g=self.literal(self.cover.unrank(owner)) + recipes.update({'owner':g,'right':pair['right'],'left':pair['left']}) + code.extend((('monomial',occurrence,target,'owner',True), + ('monomial',occurrence,target,'right',False), + ('child',occurrence,target,1), + ('monomial',occurrence,target,'left',False), + ('monomial',occurrence,target,'owner',False))) + need(len(code)<65536, 'finite service program counter') + return self.Group(keys,tuple(code),recipes) + + def audit(self): + # Checker-only memoization of exact finite geometry. The production + # binding/cover and its charged runtime instructions remain unchanged. + audit_binding=copy(self) + audit_binding.cover=copy(self.cover) + audit_binding.cover.rank=lru_cache(maxsize=None)(self.cover.rank) + audit_binding.cover.unrank=lru_cache(maxsize=None)(self.cover.unrank) + lines=[(i,e) for i,e in enumerate(self.word) if e[0]=='line'] + if self.ports==112: + need(lines[0]==(4,('line','W0',0,1)), 'frozen first positive line') + need(next((i,e) for i,e in lines if e[3]<0)==(1705,('line','Z10',76,-1)), 'frozen first negative line') + need(self.labels[0]==11 and self.labels[76]==448, 'actual literal source labels') + need(len(lines)==224, 'all frozen native events') + census=Counter();private_words=0;maxpc=0; compiled=[] + map_orders=Counter(); map_groups=Fraction(0); map_swaps=Fraction(0) + map_translations=identity_translations=nonmap_groups=0 + nonmap_census=Counter(); intrinsic=owner_basis=0 + for i,event in enumerate(self.events): + private_words+=event[0]=='private' + g=audit_binding.group(i,0,0);maxpc=max(maxpc,len(g.code)) + for op in g.code:census[op[0]]+=1 + compiled.append([g.keys,g.code,g.recipes]) + body=event[2] + if len(body)==1 and body[0][1][0]=='map': + e=body[0][1];record=self.maps[(e[2],e[3],e[4])] + h=self.map_order(tuple(record['owner_right_matrix_columns'])) + map_orders[h]+=1 + nonzero=record['payload_translation_at_identity_owner']!=0 + # Right multiplication acts freely: every orbit has size h. + # Every orthogonal owner is invertible, so d(delta) is nonzero + # precisely when delta is. Count each actual map occurrence. + if h>1 or nonzero:map_groups+=Fraction(1,h) + map_swaps+=Fraction(h-1,h) + map_translations+=int(nonzero) + identity_translations+=sum(op[0]=='monomial' for op in g.code) + else: + nonmap_groups+=int(bool(g.code)) + for op in g.code: + nonmap_census[op[0]]+=1 + if op[0]=='monomial': + intrinsic+=int(op[3] in ('right','left')) + owner_basis+=int(op[3]=='owner') + def number(q): + q=Fraction(q) + return q.numerator if q.denominator==1 else str(q) + physical={'map_order_histogram':dict(sorted(map_orders.items())), + 'map_control_visits':sum(map_orders.values()), + 'map_gather_scatter_commit_groups':number(map_groups), + 'map_exchanges':number(map_swaps), + 'map_sign_corrections':number(map_swaps), + 'map_translation_monomials':map_translations, + 'map_identity_leader_translation_monomials':identity_translations, + 'nonmap_groups':nonmap_groups, + 'all_gather_scatter_commit_groups':number(nonmap_groups+map_groups), + 'rank_one_children':nonmap_census['child'], + 'physical_line_monomials':nonmap_census['monomial'], + 'intrinsic_wrappers':intrinsic,'owner_basis_monomials':owner_basis, + 'all_monomial_calls_including_map_translations':nonmap_census['monomial']+map_translations, + 'scalar_engine_calls_including_map_sign_corrections':number(nonmap_census['scalar']+map_swaps), + 'private_zero_calls':nonmap_census['zero'], + 'unit':'per full cover divided by Gamma, except identity-leader translation diagnostic'} + return {'status':'PASS_FULL_COVER_DECODER_COMPILATION','events':len(self.events), + 'literal_decoder_events':len(self.word),'decoder_native_calls':len(lines), + 'compiled_identity_owner_census':dict(sorted(census.items())), + 'physical_per_cover':physical, + 'private_words':private_words,'maximum_pc':maxpc,'families':self.families, + 'slots':self.slots,'private':self.private, + 'compiled_identity_owner_sha256':sha256(json.dumps(compiled,sort_keys=True,separators=(',',':')).encode()).hexdigest(), + 'scope':'All finite signed occurrences and cover-barrier compiler; arithmetic correctness inherits authenticated D and source primitive refinements.'} + + +class ServiceBank: + """Paid P,family,cover,U,row assembly and fixed-field return extraction. + + Entire source fields are read-only. Every length stays an encoded Count. + The 224 zero families are newly owned backing; initialization is charged. + Invoke under an independently installed fixed scratch scope. + """ + def __init__(self,Tape,Counter,blank,fields=224): + self.bank=Tape();self.Counter,self.blank=Counter,blank + self.fields=fields;self.state='closed' + + def _segment(self,source,target,extent,zeros=False): + remaining=self.Counter(extent) + try: + while not remaining.finished: + value=0 if zeros else source.read() + need(value in (0,1),'complete binary service segment') + target.append(value) + if not zeros:source.step(1) + remaining.decrement() + finally:remaining.close() + + def assemble(self,borrowed,prefixes,field_prefix_bits): + need(self.state=='closed' and len(borrowed)==self.fields, 'closed complete service inputs') + need(len({id(t) for t in (*borrowed,self.bank)})==self.fields+1,'distinct borrowed/service tapes') + self.bank.clear() + for tape in borrowed:tape.rewind() + counter=self.Counter(prefixes) + try: + while not counter.finished: + for tape in borrowed:self._segment(tape,self.bank,field_prefix_bits) + for _ in range(self.fields):self._segment(None,self.bank,field_prefix_bits,True) + counter.decrement() + need(all(t.read()==self.blank for t in borrowed),'exact whole-family service inputs') + self.state='assembled' + finally: + counter.close();self.bank.rewind() + for tape in borrowed:tape.rewind() + return self.bank + + def extract(self,returned,borrowed,outputs,prefixes,field_prefix_bits): + need(self.state=='assembled' and len(outputs)==len(borrowed)==self.fields,'live complete return') + need(len({id(t) for t in (*outputs,*borrowed,returned,self.bank)})==2*self.fields+2, + 'exclusive returned and immutable source roles') + returned.rewind() + for t in borrowed:t.rewind() + for t in outputs:t.clear() + counter=self.Counter(prefixes) + try: + while not counter.finished: + for tape in borrowed: + count=self.Counter(field_prefix_bits) + try: + while not count.finished: + need(returned.read() in (0,1) and returned.read()==tape.read(), + 'all borrowed returned fields preserved') + returned.step(1);tape.step(1);count.decrement() + finally:count.close() + for tape in outputs:self._segment(returned,tape,field_prefix_bits) + counter.decrement() + need(returned.read()==self.blank and all(t.read()==self.blank for t in borrowed),'exact complete service return') + finally: + counter.close();returned.rewind() + for t in (*borrowed,*outputs):t.rewind() + returned.clear();self.bank.clear();self.state='closed' + + +def finite_maps(word, P, routes, labels, bridge): + """Compile exact retained affine owner maps before any numerical input.""" + maps={} + for e in word: + if e[0]!='map':continue + _,_,stage,p,inverse=e + need(stage in (1,2) and type(inverse) is bool,'literal signed map selector') + g=routes[stage][p] + b=P.alignment(g,P.F17) if stage==1 else bridge(P,g,labels[p]) + if inverse:b=P.act(g,b) + maps[(stage,p,inverse)]={'owner_right_matrix_columns':list(g), + 'payload_translation_at_identity_owner':b} + return maps + + +def service_descriptors(caller,Count,families): + """Paid encoded node descriptors; caller already passed its actual stock cut. + + Allocate/retire these Counts inside the external service's fixed pool. + source child rows stay U, with ORIGINAL C depth stock, even though this + finite service's top-level divisor is families*Gamma. + """ + from machine import INPUTS + need(caller.group is None and caller.bank.state=='closed', 'completed acquisition fence') + result={name:Count(caller.c(name)) for name in INPUTS} + result['rows'].close() + result['rows']=Count(caller.c('unused')) + result['rows'].multiply_small(families*caller.binding.cover.size) + return result diff --git a/research/qq16-caller-install/inputs/PR3055-PROOF.md b/research/qq16-caller-install/inputs/PR3055-PROOF.md new file mode 100644 index 0000000000..f65f38123c --- /dev/null +++ b/research/qq16-caller-install/inputs/PR3055-PROOF.md @@ -0,0 +1,334 @@ +# Encoded physical completion of the compact operation + +Jose Manuel (`jmbarrancoml`), with substantial OpenAI Codex assistance. + +I refine the compact algorithm from PR2250, head +`d404b48a1e7b147556b309497d55089c837dddb2`, into marked unit-step streams and +encoded control arithmetic. I use PR2899, head +`2f0911ad735643a069b9790302fbf179e49f74f8`, for the completed binary ordinary +callee. I preserve those exact archives and their source arguments. I do not +derive their universal claims from the small fixtures in this package. + +## 1. Domain and result + +Fix a finite field schema with m named fields. Compile distinct wide source and +target names, or a constant toggle, and the earlier/later source order. Supply +canonical Count tapes for n>=1, K>=1, G>=1, 0<=rho infinity`, with R exceeding each fixed power of p, I obtain +`O_q,m(V*(1+((f-1)G)^tau))` time and linear workspace for a fresh invocation, +plus fixed compilation storage. I retain the displayed terms at independent +finite sizes. I state occupied and retained backing space separately below. + +I prove successful admitted execution. I make no rollback guarantee after an +interrupted or invalid internal operation. The caller consumes the protected +output before reuse. I do not complete a Gaussian monomial, recursive complex +layer, formal machine refinement or multiplication theorem in this package. + +## 2. Encode the numerical controls + +I keep numerical parameters, field values, extents, keys and loop indices on +canonical binary Count tapes. I use the inherited ripple Counter for countdowns. +The fields' names, their order, the finite operation tags and source-order flag +belong to compiled control; I do not decode widths or addresses into that control. + +`compact_counts.py` implements variable bit windows, shifts, XOR, modular sums +and fixed-width key serialization through sequential reads, writes and unit +moves. I build an empty Count body through its borrowed physical view so that +I retain its active scratch lease. I normalize the result and release the lease +only when the Count closes. I include discarded high zeros and markers in the +write/erase accounting. + +`compact_layout.py` constructs field radices and complete-row extents by encoded +arithmetic. I decode an address by repeated binary division through the fixed +field tuple, and encode it by the inverse multiply/add sequence. Prefix decoding +sets later fields to zero; rotation controls all precede their target, so those +zeros cannot change the offset. I use a fixed number of field Counts, not one +control register per address or per selected digit. + +For `compact_control.py`, I copy the finite operation word from the authenticated +PR2250 `operations()` method. Its dummy numerical constructor constants never +enter runtime arithmetic. I implement offsets, inverse execution, selected masks +and the guard in the new encoded routines. The checker disables the reference +class's numerical methods during physical execution. + +For each of n digits I extract the source bit and dirty t digit and accumulate +the packed offset modulo the target radix. For `1-2t_i`, I branch only on zero: +otherwise I form the positive magnitude `2t_i-1` and negate its reduced residue. +I retain modular overflow on exceptional addresses. During inverse execution I +reverse the finite word and evaluate each offset on the current inverse state. +I never use the original forward controls for a later inverse step. + +Let `B=2^G`. I test the original guard using encoded comparisons: + + t_i < B-1, + 2B <= g_i < 2^(K-1)-2B, + u_i < B-1 for a later source, + +where g_i contains the K-1 target bits above selected bit i. If +`2^(K-1)<=4B`, I mark the address exceptional: the guarded interval is empty. +This handles negative or empty upper thresholds without unsigned underflow. + +## 3. Realize the raw word and binary boundary + +I retain Douglas Colkitt's raw modular word and the proof in PR2250. An earlier +source or toggle uses four rotations and four width-nG swaps. A later source +uses ten rotations and twelve swaps. The scalar dirty-control identity is + + y += 2*z*t; + t += parity(y); + y += z*(1-2*t); + t -= parity(y) XOR z. + +On the guarded packed domain, this toggles the selected parity by z and restores +t. The load/unload swaps move a front compact field to the complete back field; +they do not initialize the original dirty back value. + +For a rotation with target radix Q and suffix extent L, I compute the offset +u modulo Q from the encoded prefix ordinal. I split the next Q blocks into +lengths `(Q-u)L` and `uL` on two owned streams. I recompute the same offset during +merge and emit the second piece before the first. Both traversals enumerate +prefixes in the same order. Thus I realize the modular address rotation for +arbitrary wraparound while preserving the order inside each suffix block. + +For a compact swap I derive the complete preceding, intervening and trailing +extents from the fixed field schema. I suspend the compact allocation scope and +invoke the actual `Binary.run` with borrowed physical views. B1 uses its own +fixed roles and its sealed C0 path. After return I restore the compact scope, +copy the protected binary output into an owned lease, and clear its output and +marker. I then consume the old owned row stream. This preserves B1's source +contract and the compact interpreter's consuming-intermediate contract together. + +I use the binary interface here. PR2899 pads each active field to the least +q-power above `2^(nG)` and restricts afterward; its native volume is below +`q^2*v0`. Its bound already includes that fixed factor and its internal reserve. +The native same-q shortcut used by the BIT successor does not apply to these +binary compact fields. + +## 4. Complete exceptional repair and the final bit + +Let S be the raw word and T the desired operation on its low n selected bits. +I retain the original exceptional set E. From PR2250's guarded identity, S=T +on its complement. T preserves E because it changes selected parities while +fixing the guard bits and dirty compact labels. Each raw rotation has a +target-independent offset, and each swap is invertible. Thus S is a bijection; +since it agrees with T on the complement, it also preserves E. + +I enumerate current row addresses q with an encoded counter. For each record +I append its exception flag to the hole stream. I append a good record to the +good stream. For an exceptional record I compute the full encoded destination +`T(S^-1(q))` and append its fixed a-bit key followed by its opaque R-bit record. +I use current inverse controls and the declared modular field widths throughout. + +`stable_radix` performs a literal stable two-bucket partition for each key bit, +from least to most significant. It reads one key into a Count, visits the +encoded pass position, writes the fixed-width key and copies the complete +record into the chosen bucket. It concatenates bucket0 then bucket1 and clears +the old stream and buckets. Induction on the pass position gives increasing +order of the processed suffix of each key, with stability among equal suffixes. +After a passes I obtain full numeric key order. I allocate no bucket per key. + +Because `T S^-1` permutes E, its destination keys are distinct and occupy +exactly the recorded holes. During reinsertion I consume the next good record +at a zero hole. At a one hole I read the next sorted key, require equality with +the current encoded address, and consume its record. I check complete exhaustion +of all three streams, clear them and rewind the output. The resulting payload +has the low-selected endpoint T on the original input. + +I then apply the highest selected bit at `rho+nK`: a toggle or an XOR from +the matching source bit. I derive its absolute address position on Count tapes. +The toggle uses two complete suffix buckets; XOR uses four, with a fixed +four-state permutation. I preserve the intervening and trailing extents and +erase each owned bucket after its complete slab. This gives the requested f-bit +endpoint and restores all other labels. + +I repair one complete outer row at a time. The raw and ideal words preserve +that row label, so the domain is closed under both. A fixed dirty-field slice +need not be closed. For example, the retained n=2,K=2,G=1,rho=1 early word sends +`(u,t,x,y,b)=(0,1,2,2,0)` to `(0,3,2,8,0)`, whereas the ideal low endpoint is +`(0,1,2,0,0)`. Repair must cross the two t slices. I retain that witness as a +control and do not partition repair along dirty coordinates. + +The outer loop copies one complete row from the borrowed source, finishes its +operation, appends its result to the protected output and clears the row lease. +I advance the source cursor without rereading earlier rows and rewind it after +the complete packet. I reassemble all rows before return; I introduce no complex +child per row and no altered recursive schedule. + +## 5. Charge arithmetic, sorting and disposal + +All new field/control operands have O(A) bits. A shifted packed term can exceed +its target width before reduction, but its bit length remains O(A): it has at +most one compact digit's width plus one wide-field position and a constant +margin. The number of fields and raw operations is fixed. + +The inherited Count product and division use O(A) iterations of linear scans, +so I charge O(A^2). Dynamic power and shift routines perform at most O(A) such +linear scans. Bit windows and the fixed tuple's encode/decode routines have +polynomial cost. An offset processes n<=a digits; O(A^3) suffices for its shifts, +modular reductions and sums. I use the conservative envelope O_m(A^6) for the +complete preparation, inverse, guard and key work, including counter setup, +normalization, copies, rewinds and erasure. + +For each rotation I compute an offset twice per prefix fibre and move each +payload bit a bounded number of times. There are at most M0 fibres per row. +I therefore charge `O_m(v0+M0*A^6)` per rotation, including its piece-length +products and clearing. The highest-bit operation has one encoded extent setup +and linear complete-slab movement. A suffix counter's initialization costs +O(log(1+suffix)), which its ensuing complete suffix copy pays. + +During repair I evaluate the guard on all M0 addresses and compute inverse +states and destinations on the exceptional ones. I charge `O_m(M0*A^6)`. +For each of a radix passes I move at most `delta*M0` records of R+a bits. +I include key scanning, serialization, bucket concatenation, rewinds and +clearing in `O(delta*M0*a*(R+a))`. Any conservative extra polynomial key-control +charge fits the already included `M0*A^6` term. Hole generation and reinsertion +add O(v0) movement. Empty exceptional streams need only the polynomial pass +overhead; they do not trigger a scan of the full payload for each radix bit. + +I create `Counter(C)` once, outside these preparations. Its complete ripple +traversal costs `O(C+log(C+1))`; no row ordinal enters offset, guard, inverse +or destination arithmetic. Since each row contains at least one bit, I absorb +this charge into O(V). Initial row copies, final appending and the borrowed +source rewind also cost O(V). + +I charge the sC binary calls with their individual row volumes, including the +returned-port copies and marker operations. The uniform B1 upper bound then +gives the time statement in section 1. I include fixed source compilation once; +fixed q-dependent marker work per call belongs to its volume-linear constant. + +For asymptotic absorption, eventually `K>=G+4*ceil(log2 p)+10`. With n<=p and +the retained G, the source estimate gives `delta<=5/(128*p^3)`. Consequently + + M*A^6/V = A^6/R -> 0, + delta*M*A*(R+A)/V = delta*A*(1+A/R) = O(p^-2). + +I obtain the stated compact bound in that domain. I do not infer a practical +cutoff or use finite timings to establish it. + +## 6. Fixed roles, blank return and backing extent + +I allocate `8*m+256` compact scratch tapes before reading numerical inputs. +The layout retains m+3 Counts; at most one decoded state retains m Counts; +fewer than 64 additional Count, Counter and payload roles suffice for the active +branch, including nested product/division temporaries, keys and buckets. I close +predecessors before advancing or replacing a result. Thus `2*m+64` gives a +conservative live census within the configured allowance. + +I count the protected output, borrowed descriptors, Binary's 96-slot pool and +the native ordinary inventory separately. I suspend the compact factories +while the binary/native scopes use their own roles. The global constructor +guard remains active during this switch. I never allocate a physical tape per +row, prefix, selected digit, exceptional key or radix pass. + +For occupied contents, a conservative compact-side envelope, including borrowed +input and protected output, is + + 4V+2*delta*M*a+M+O_m(A+log(C+1)). + +I include the good/bad/hole streams, current/output row streams, key buckets +and fixed numerical operands. I add B1's private workspace and fixed source +compilation storage. In the long-record domain, `a/R` is bounded and I obtain +linear occupied workspace. + +I distinguish erasure from backing allocation. The retained Tape implementation +blanks its cells but does not shrink the Python bytearray. For a fresh engine, +each compact-pool tape has maximum extent + + O(v0+delta*M0*a+A+log(C+1)). + +Multiplying by the fixed pool capacity bounds its backing storage. I add the +global input/output and the inherited B1 backing allowance. For a reused engine, +I take each role's maximum extent over preceding invocations. I do not bound +retained arrays from an earlier larger input by a later smaller V. If these +calls belong to one enclosing invocation, I use that enclosing volume to bound +the maxima, with its retained source allowances. + +On successful return I require no live scratch leases, erase their markers, +close numerical contexts and leave their heads at their local origins. I retain +only the protected output contents. At reuse I restore blank markers with local +writes. I do not scan an old blank backing tail to reclaim it. This gives the +claimed locality independently of earlier physical extents. + +I treat Python object bookkeeping, Tape meters and provenance masks as simulator +or checker machinery, not extra numerical registers of the tape program. The +implementation selects no instruction or operand from those observations. I +have not expanded this structured program into a complete transition table or +proved its correspondence in a proof assistant. + +## 7. Evidence and the remaining complex boundary + +I compare encoded controls with the authenticated indexed oracle on 151 states, +including 904 offsets, both guard regimes, modular inverse chronology and the +cross-dirty-slice witness. I check complete physical early/late/toggle rows, +odd-prime binary padding, reuse after erasing the protected marker, and two +complete 4096-record two-digit rectangles. I check 8192 mixed-guard records +through actual raw movement, repair and the final bit. For payloads I carry an +independent mask per input bit in checker state while runtime cells remain +Boolean. I disable indexed reference arithmetic during physical execution. + +The separate 1024-column handoff uses the actual Binary wrapper and a declared +reduced fitted B1 body with two C0 roots. I verify its live parent numerical +objects and suspended factory scope. The small complete Compact cases use +B1's elementary branch. I retain its universal faster-rate argument as an +explicit predecessor, not an inference from those timings or endpoints. + +The failure controls reject omitted repair, omitted inverse-key computation, +reversed radix order, altered source archives, namespace contamination and +physical allocation inside a sealed call. I also reject reuse of an unconsumed +output while preserving its contents. These controls do not establish recovery +after an arbitrary internal interruption. + +PR2534 already executes selected child 7 with retained Compact on complete dirty +outer rows. I add encoded controls, fixed physical roles and the actual B1 +boundary. I do not claim that earlier fixture as new work. PR2378/2422 supply +separate formal phase results; PR2476/2700/2756 supply repair accounting and +partition boundaries. I preserve that division of scope. + +A complete Gaussian monomial still needs its encoded phase pass and signed +record traversal, followed by integration with the actual complex caller, +proper-width children, private lifetimes and root precision grid. The written +PR2287/2298 implications remain separate from that payload execution. I leave +the selected exponent unchanged. I also do not transfer B1's coarse rate to +the higher modern candidate in PR2979: that would require a stronger ordinary +contract or a different transfer argument. diff --git a/research/qq16-caller-install/inputs/PR3380-PROOF.md b/research/qq16-caller-install/inputs/PR3380-PROOF.md new file mode 100644 index 0000000000..d32e60ad65 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR3380-PROOF.md @@ -0,0 +1,168 @@ +# Completed output handoffs without payload copies + +This opt-in specialization changes two completed boundaries in the retained +PR2915 `C1 -> B1 -> C0 -> A0` implementation. The preceding C0 execution, native +child sequence, source maps and numerical parameters are unchanged. The changed +interface permits a **finite permutation of internal tape-role bindings** at a +completed output handoff. It does not identify two live buffers or assert that +moving a payload between two fixed physical tapes is free. + +## Named expense and new contract + +PR2899 `Ordinary.execute_plan` obtains a completed scratch lease, calls +`role_parking.transfer(result, self.output)`, and ends the old lease. PR2915 +`Adapter.swap` then copies that ordinary output into a parent scratch lease, +rewinds the result and clears the ordinary output. Both outputs are distinct +from the borrowed input; the new implementation preserves that property. + +At either boundary let L be one live scratch lease, with slot s in a fixed pool, +and let O be the separate ordinary output role. Require: + +- the lease is active and registered at s, with the correct physical binding; +- O is not a tape of that pool, and the two role origins have LEFT immediately + before their current heads; +- at publication O is empty; at adoption the newly acquired L is empty and the + ordinary execution is closed; +- the completed result has the inherited dense BODY alphabet. The replacement + retains `transfer`'s rejection check as a read-only scan before publication. + +Exchange the physical role bindings of O and L, updating **both** the pool's +slot table and the lease's physical view. The slot number, lease object and +liveness relation do not change. At publication O now denotes the completed +result and L denotes the empty old output; the original `result.clear()` ends +that empty lease. At adoption the parent lease denotes the completed result, +and O denotes the empty old parent role, ready for native rearm. + +Every premise is checked before the transposition. Marker checks restore their +one-step head movement even on rejection. The dense scan also restores its +source head. Arbitrary interrupted native computations still have the inherited +source's limited recovery contract; this is a successful completed-call result. + +## Why this is a fixed-tape operation + +Let R be the total number of physical stream roles of the fixed compiled parent +pool, ordinary pool and ordinary output. R depends on the compiled source and q, +not on payload width or recursion depth. Replace the original finite control Q +by `(Q, pi)`, where pi is a permutation of those R physical roles, together with +the already finite pool-slot liveness state. An instruction on logical role j +executes on physical role pi(j). A completed handoff changes pi by one +transposition. No payload cell moves, no physical head is reset and no numerical +address is decoded by that control transition. + +This is an explicit finite-control refinement: at most R! permutation states +per original control state suffice. It can be large, but is a fixed compilation +allowance of the same kind as the inherited F_q. The Python tuple/reference +updates in `exchange.py` represent that finite selector; they are not a unit-cost +claim about arbitrary RAM pointers or an infinite collection of tape addresses. +Their host implementation is O(R), and their compiled control overhead is O_q(1). +The complete tape-I/O invoice below charges every actual head move/read/write. +An exhaustive emitted R!-state transition table and formal proof-kernel check +are not supplied. + +The transposition acts only on the completed lease and the separate empty role. +Every other active lease keeps its physical role, bytes and head. A stale ended +lease remains inactive; its repeated clear is a no-op and cannot erase a new +borrower. Updating only `lease.physical` while leaving `pool.tapes` unchanged +would violate the ownership invariant: that explicit mutant is rejected by the +inventory check. Role identity is not inferred from numerical payload data. + +The opted-in source sites have no remaining use of a stale output alias: after +publication the old local `destination` is unused, and `execute_plan` returns +the current `self.output`; after adoption the replacement `swap` does not clear +the old `returned` alias. Subsequent rearm, finish, allocation and cleanup read +the updated role tables. Other ordinary instances retain their original transfer +function. Context exit restores the original module binding even on exceptions. +The C0/A0 bindings remain suspended/restored exactly as in PR2915, so the change +does not introduce a circular backend call. + +This internal role contract is necessary. A consumer that insists on the result +in a particular immutable physical output tape must still pay a transfer to it. +The selected outer fixed output contracts and other transfer sites are not +changed. The public opt-in adapter still returns a distinct owned parent lease. + +## Exact local cost and complete recurrence + +Let V be the number of BODY symbols returned by the completed ordinary call. +Count literal physical tape reads, writes and unit head moves across the two +handoffs, from the completed inner result at its origin through the owned parent +output at its origin. Include acquisition and ending the inner lease. Direct +counting of the retained `transfer`, `append_tape`, `rewind` and `clear` loops, +and of the new validation/origin checks, gives: + +| Operation count | Retained boundary | Exchanged boundary | +|---|---:|---:| +| Reads | 12V + 18 | 2V + 13 | +| Writes | 4V | 0 | +| Unit head moves | 10V + 24 | 2V + 16 | +| Total | 26V + 42 | 4V + 29 | + +The exact saving is **22V + 13 physical tape operations**. The new linear term +is validation, not an uncharged copy. Eight literal fixtures, including empty +and record-alphabet bodies, independently meter these coefficients. The dense +BODY check and owned final-output erasure remain present; output erasure occurs +when the parent consumes that lease and is common to both executions. + +For one actual B1 call write its complete old physical cost as + + A_old(V,E) = A_core(V,E) + H_publish_old(V). + +Here A_core includes parameter selection, padding, both fitted C0 roots or the +elementary fallback, all child returns, numerical scratch, restoration, private +erasure, and every other source operation. No part of A_core is discarded. +For the enclosing C1 swap, let J be its unchanged encoded setup and closing cost. +Then, on the same admitted input and native branch, + + S_old = J + A_core + H_publish_old + H_adopt_old, + S_new = J + A_core + H_publish_new + H_adopt_new + = S_old - (22V+13). + +These equalities use the source's tape-I/O model. In a model also charging finite +control, add an explicit constant `c_R` per exchanged boundary; there are no +width-dependent control or hidden numerical-word charges. On the Python host, +the finite selector's O(R) cost is included in measured wall time. + +For an enclosing C1 recursion tree, count each complete B1 invocation as one +whole local primitive interval, including all its C0 descendants. Keep those +full local bills L_u and the unchanged recursive C1 child calls. At node u let +H_u be its reached opted-in completed B1 handoffs. In tape-I/O units the recurrence is + + T_new(u) = L_old(u) - sum_(h in H_u)(22V_h+13) + + sum_(v child of u) T_new(v). + +Only handoffs actually contained in L_old are subtracted; a handoff is never +counted again in its child's toll. All other recursive children and restoration +terms remain. Telescoping subtracts the stated saving once per reached handoff. +Equivalently, apply the single-call formula without changing any C0 child cost. +With finite-control charges add `2c_R |H_u|` explicitly. The inherited asymptotic +bound `O_q(V(n+w^(1-a1)))`, with `a1=169711/10^8`, remains valid. This is a lower +linear boundary expense, not a new exponent or an alteration of the paid child +histogram. + +No new physical stream roles or numerical words are allocated. At each exchange +the set of physical tapes, their backing and all cell contents are unchanged; +only the role permutation changes. The omitted parent copy also avoids its +temporary second payload. Future high-water backing may be distributed among +different roles, so an unchanged per-role byte high-water mark is not claimed. +The fixed R-role bound and inherited `O_q(V_root)+F_q` total-space form remain; +their original compiler, stock and root-coupling premises are still required. + +## Evidence and scope + +Complete q=3/5 route fixtures retain every original independent address column, +borrowed input, low carry, dirty occupied lease and head check. They audit the +entire union of parent/ordinary physical roles after every native handoff. +The first 486-bit route falls from 284,709 to 263,273 physical operations; its +four 243-symbol native handoffs account for exactly `4*(22*243+13)` saved steps. +An identity-high route has no native handoffs and is unchanged. + +The fitted test executes two genuine C0 roots under original A0 bindings, then +checks all 1,024 source columns, parent numerical objects, distinct output, +cleanup and the complete physical inventory. The saved handoff is only one +component of that much larger run. This is not selected GL64 payload execution, +a full selected supplier replay, an independent proof of the inherited all-size +caller, or an implementation of the separately claimed complex controller. + +Credit Jose Manuel/jmbarrancoml PR2809/2899/2915, David Arias PR2753, +Nick Petalas PR2808, the fixed-role/ordinary and PR2157 factor lineage, and the +retained high-cube accounting work. Tekalign, substantial OpenAI Codex assistance. +Apache-2.0. The finite-control argument remains subject to independent review. diff --git a/research/qq16-caller-install/inputs/PR3464-PROOF.md b/research/qq16-caller-install/inputs/PR3464-PROOF.md new file mode 100644 index 0000000000..1e241b1e9e --- /dev/null +++ b/research/qq16-caller-install/inputs/PR3464-PROOF.md @@ -0,0 +1,227 @@ +# Parent-return refinement for the original physical complex controller + +This is an independent, source-relative proof of the successful recursive +call/return boundary in Jose Manuel's +[PR 3385](https://github.com/CrocSwap/integer-mult-bounds/pull/3385), exact head +`7e5a187214126d31afc241a8f89f4a652352b58c`. The audited operations are +`Machine.prepare_child`, `enter_child`, `return_node`, and the `Parking` +codec. The original selected R480/T16 binding is fixed throughout. + +The conclusion is conditional on the callee returning its specified complete +packet and closing its primitive scratch. It does not establish that +arithmetic endpoint, the complete controller's cost bound, root normalization, +an outer multiplication theorem, or a changed T74 binding. + +## 1. Representation and precise claim + +A well-formed role has a finite dense word over + +\[ +\mathcal B=\{0,1,3,5,6,7,8,9,10,11,12,13\}, +\] + +followed by blank cells. Its canonical head is at the first body position. +An owned origin marker may be `LEFT` or erased: `Machine.origin` explicitly +rearms an erased marker before parking. Equality of role contents below means +equality of this entire dense word. It does not require identical trailing +blank allocation, nor preservation of an erased marker; restored roles have +the canonical `LEFT` marker and body-origin head. + +The fixed parked inventory is, in source order: + +1. `current`, `header`, the fourteen `INPUTS`, and four `DERIVED` roles; +2. all 704 bank packet roles; +3. all eight private packet roles. + +Thus the selected binding has 732 parked roles. The capsule, protected output, +parking stack, and reversing port are separate fresh tapes. The source +constructors allocate distinct roles; `Parking` also checks their identities. +The indexed packet accessor selects one of the 712 packet roles, including +private targets, without accessing a different role. + +At a successful call boundary assume: + +- the bank is gathered for the current group, its selection corresponds to + that group's distinct keys, and the current PC names the actual child + instruction `(target,rank)`; its temporary scratch and output are closed; +- Count descriptors are well formed, copied borrowed inputs are preserved by + the inherited Count operations, and the child descriptor checks succeed; +- all owned role words and heads satisfy the representation above; the capsule + and protected output are available, and `primitive_boundary` succeeds; +- the stack is a sequence of the encoded ancestor frames below, with its head + at the blank top, and the reversing port is empty at its origin; +- the finite binding stays unchanged, reconstructs the same group from its + event/subgroup/cover coordinates, and the saved values fit the source's + finite header bounds; +- the callee returns a well-formed complete packet of the prescribed extent, + restores the recursive boundary conventions, and closes its primitive and + bank scratch. Descendants use this same controller and codec; other + primitives respect their declared disjoint ports and do not write the + parking stack or reversing port. A successful descendant return obeys this + same contract. + +Then the source operations resume the same parent at its next instruction. +They replace exactly the designated packet with the child's returned word, +restore every other parent role word except the consumed header, and restore +the parent's logical bank view. Older parked frames remain unchanged. The +capsule and protected return port are empty after the child handoff completes. +These claims hold at arbitrary finite nesting depth. + +The finite checker exercises this theorem on concrete states; its finite +coverage is not the justification for the arbitrary-depth statement. + +## 2. Exact stack codec + +For a body symbol `s`, let `bits4(s)` be its four binary digits in +least-significant-first order. For the fixed role words `w1,...,wk`, define + +\[ +E(w_1,\ldots,w_k)= +\operatorname{bits4}(w_1)\,13\; +\operatorname{bits4}(w_2)\,13\;\cdots\; +\operatorname{bits4}(w_k)\,13\;12. +\] + +The frame consists only of binary digits and the two delimiters. A body +symbol equal to 12 or 13 is encoded into four digits, so it cannot be +confused with a delimiter. Empty roles have an immediate role delimiter. +If the role words contain `B` symbols altogether, the frame length is +exactly `4B+k+1`, hence `4B+733` for the original selected binding. This is +an encoding-length identity, not a complete time or physical-space invoice. + +`park` begins at the blank top of an existing stack prefix. It writes exactly +this frame, clears each consumed body symbol, and leaves every role at its +body origin. It neither reads nor modifies the older stack prefix. The final +stack head is the blank immediately following the new frame; the reverse +port remains empty. + +`restore` first removes the final frame delimiter and then processes the +roles in reverse order. For each role it removes the role delimiter and +copies the preceding binary run, in reverse order, into the reversing port. +The scan stops at the preceding role/frame delimiter or `LEFT`, and leaves +that preceding delimiter untouched. Reading the reversing port backwards +therefore recovers the original bit order. Each four digits decode exactly +one original symbol; the code clears the digits while decoding and appends +the symbols in their original order to the restored role. + +After the last role the stack head is the blank immediately after the +unchanged older prefix. The reverse port is empty at its origin and all +restored roles are at their origins. Thus `restore` is a left inverse of +`park` on every admitted tuple of role words, independently of their lengths +or contents. Induction on the number of stacked frames proves arbitrary +finite nesting. In particular, no frame length or buried ancestor payload +has to be retained in Python control. + +`FiniteFields.write/read` provides the same elementary round-trip fact for +the bounded header: each value uses its prescribed fixed bit width, and +`read` checks both its bound and the exact end of the header. These checks +are used on the intact header preserved by the codec. They are not an +authentication theorem for arbitrary corrupted headers; a different valid +header can, for example, name another occurrence of an identical child +instruction. + +## 3. Child descriptors and conservation of packet extent + +At an active parent group write `d` for the fixed matrix dimension, `f` for +`columns`, and `K` for `spacing`. After the source's remainder-leaf step, +the active width is `e=df`; any removed left chunks have been added to +`before`. Write `a` for `after` and `U` for the exact positive `unused` +row quotient. For a child of rank `r`, `prepare_child` sets + +\[ +e'=rf,\qquad a'=a+(d-r)fK,\qquad R'=U. +\] + +Every other `INPUTS` descriptor is copied unchanged. In particular, + +\[ +e'K+a'=eK+a. +\] + +`shape` depends on the address exponent + +\[ +\texttt{front}+3\,\texttt{compact\_bits}+\texttt{before} + +eK+\texttt{after}+\texttt{back}, +\] + +and multiplies its power of two by twice `component_bits` and by +`coefficients`. The equation therefore preserves the entire within-row +extent, including every spectator field. With unchanged `prefixes` and +child row count `U`, the child input has exactly the extent of one gathered +parent packet. The check `0 0 and type(covers) is int and covers > 0 + and type(slots) is int and 0 < slots <= families * covers, + "fixed finite bank alphabet") + self.families, self.covers, self.slots = families, covers, slots + self.packets = tuple(Tape() for _ in range(slots)) + self.output = Tape() + self.pool = ScratchPool(16) + self.scope = OuterScope(self.pool) + for tape in (*self.packets, self.output, *self.pool.tapes): + erase_marker(tape) + self.selection = None + self.source = None + self.state = "closed" + + def select(self, keys): + need(self.state == "closed" and not self.pool.live and + all(t.read() == BLANK for t in (*self.packets, self.output)), "closed bank selection") + need(type(keys) is tuple and 0 < len(keys) <= self.slots and len(set(keys)) == len(keys), + "distinct compiled owner slots") + need(all(type(key) is tuple and len(key) == 2 and + type(key[0]) is int and 0 <= key[0] < self.families and + type(key[1]) is int and 0 <= key[1] < self.covers for key in keys), + "owner keys in fixed alphabet") + self.selection = {key: slot for slot, key in enumerate(keys)} + + def _start_scratch(self): + need(not self.pool.live, "empty packet scratch") + for tape in self.pool.tapes: + initialize_marker(tape) + + def _close_scratch(self): + self.pool.empty() + for tape in self.pool.tapes: + erase_marker(tape) + + def gather(self, bank, prefixes, unused_rows, row_bits): + need(self.state == "closed" and self.selection is not None, "compiled acquisition boundary") + for count in (prefixes, unused_rows, row_bits): + positive(count) + source = borrowed_tape(bank) + need(source not in (*self.packets, self.output, *self.pool.tapes), "distinct borrowed bank") + for tape in self.packets: + arm_empty(tape) + self._start_scratch() + extent = remaining = None + self.source = source + source.rewind() + try: + with sealed_constructors(), self.scope.installed(): + try: + extent = Count.product(unused_rows, row_bits) + remaining = Counter(prefixes) + while not remaining.finished: + for family in range(self.families): + for cover in range(self.covers): + slot = self.selection.get((family, cover)) + if slot is None: + skip(source, extent) + else: + copy_bits(source, self.packets[slot], extent) + remaining.decrement() + need(source.read() == BLANK, "complete acquisition bank") + finally: + for value in (extent, remaining): + if value is not None: + value.close() + for tape in self.packets: + tape.rewind() + self.state = "gathered" + return self.packets + except BaseException: + for tape in self.packets: + tape.clear() + erase_marker(tape) + self.source = None + raise + finally: + source.rewind() + self._close_scratch() + + def scatter(self, bank, prefixes, unused_rows, row_bits): + source = borrowed_tape(bank) + need(self.state == "gathered" and source is self.source, + "replace the acquired current bank") + for count in (prefixes, unused_rows, row_bits): + positive(count) + need(self.output.read() == BLANK, "consume earlier replacement") + arm_empty(self.output) + self._start_scratch() + extent = remaining = None + source.rewind() + for tape in self.packets: + tape.rewind() + try: + with sealed_constructors(), self.scope.installed(): + try: + extent = Count.product(unused_rows, row_bits) + remaining = Counter(prefixes) + while not remaining.finished: + for family in range(self.families): + for cover in range(self.covers): + slot = self.selection.get((family, cover)) + if slot is None: + copy_bits(source, self.output, extent) + else: + skip(source, extent) + copy_bits(self.packets[slot], self.output, extent) + remaining.decrement() + need(source.read() == BLANK and all(t.read() == BLANK for t in self.packets), + "complete replacement and local packet extents") + finally: + for value in (extent, remaining): + if value is not None: + value.close() + self.output.rewind() + self.state = "returned" + return self.output + except BaseException: + self.output.clear() + erase_marker(self.output) + raise + finally: + source.rewind() + for tape in self.packets: + tape.rewind() + self._close_scratch() + + def commit(self, bank): + """Caller authorizes destructive replacement of its owned current bank.""" + target = borrowed_tape(bank) + need(self.state == "returned" and target is self.source and self.output.read() in (0, 1), + "complete current-bank return before commit") + target.clear() + append_bits(self.output, target) + target.rewind() + self.output.clear() + erase_marker(self.output) + self.release() + + def release(self): + need(self.output.read() == BLANK and not self.pool.live, "consume bank return before release") + for tape in self.packets: + tape.clear() + erase_marker(tape) + self.source = None + self.state = "closed" diff --git a/research/qq16-caller-install/inputs/PR3464-machine.py b/research/qq16-caller-install/inputs/PR3464-machine.py new file mode 100644 index 0000000000..92f9467ffd --- /dev/null +++ b/research/qq16-caller-install/inputs/PR3464-machine.py @@ -0,0 +1,477 @@ +# SPDX-License-Identifier: Apache-2.0 +"""One active complex node and a physical stack of parent continuations. + +I adapt PR2809's finite-PC protocol to Count descriptors and Gaussian packets. +The selected binding supplies finite source groups; it never receives payloads. +""" +import cohort +api = cohort.activate() +from bank_packets import BankPackets, skip +from cardinal_counts import Count, positive +from compact_counts import power_two +from encoded import compare, divide, fixed_power, subtract +from monomial_packets import MonomialPackets +from parking import BODY, FiniteFields, Parking, transfer +from records import Tape +from scalar_packets import FullScalarEngine +from scalar_words import require_zero +from scratch_pool import ScratchPool +from session import (OuterScope, borrowed_count, borrowed_tape, erase_marker, + initialize_marker, sealed_constructors) +from stream import Counter +from words import BLANK, LEFT, need + +INPUTS = ("prefixes", "rows", "front", "compact_bits", "before", "width", "after", "back", + "spacing", "guard", "residue", "component_bits", "coefficients", "root_width") +DERIVED = ("columns", "unused", "row_bits", "gaussians") +LEAF_NAMES = ("front", "u", "t", "before", "active", "after", "b", "back") + + +def origin(tape): + """Rearm an owned marker at a known canonical head, preserving its body.""" + tape.step(-1) + try: + need(tape.read() in (LEFT, BLANK), "canonical owned origin") + if tape.read() == BLANK: + tape.write(LEFT) + finally: + tape.step(1) + + +def copy_symbols(source, target): + source = borrowed_tape(source) + need(source is not target, "distinct preserved-copy ports") + source.rewind() + target.clear() + while source.read() != BLANK: + symbol = source.read() + need(symbol in BODY, "dense copied role") + target.append(symbol) + source.step(1) + source.rewind() + target.rewind() + + +class Machine: + def __init__(self, binding, native, catalogue, observe=None): + self.binding = binding + self.bank = BankPackets(binding.families, binding.cover.size, binding.slots) + self.private = tuple(Tape() for _ in range(binding.private)) + self.roles = {name: Tape() for name in ("current", "header", *INPUTS, *DERIVED)} + self.capsule = {name: Tape() for name in ("current", *INPUTS)} + self.output = Tape() + self.pool = ScratchPool(256) + self.scope = OuterScope(self.pool) + self.scalar = FullScalarEngine(catalogue) + self.leaf = api["coefficient_engine"].CoefficientEngine(LEAF_NAMES, "active") + vectors = tuple("v" + str(i) for i in range(binding.dimension)) + names = ("front", "u0", "u", "t0", "t", "before", *vectors, "after", "b0", "b", "back") + self.monomial = MonomialPackets(names, vectors, native) + self.parked = (*self.roles.values(), *self.bank.packets, *self.private) + self.parking = Parking(self.parked) + groups = max(1, *(binding.group_count(i) for i in range(len(binding.events)))) + self.header = FiniteFields((2, len(binding.events), groups, binding.cover.size, + 65536, binding.slots + binding.private, binding.dimension)) + self.root = True + self.event = self.subgroup = self.cover_index = self.pc = 0 + self.group = None + self.mode = "closed" + self.closed = True + self.observe = observe # Checker-only. Its return value never affects execution. + + def c(self, name): + value = object.__new__(Count) + value.tape = self.roles[name] + return value + + def save(self, value, name): + try: + transfer(value.tape, self.roles[name]) + finally: + value.close() + + def packet(self, index): + need(type(index) is int and 0 <= index < self.binding.slots + self.binding.private, + "compiled packet role") + return self.bank.packets[index] if index < self.binding.slots else self.private[index - self.binding.slots] + + def primitive_boundary(self): + self.pool.empty() + need(self.scalar.closed and not self.scalar.pool.live and self.scalar.output.read() == BLANK, + "scalar closes before recursive cut") + need(self.leaf.closed and not self.leaf.pool.live and self.leaf.output.read() == BLANK, + "leaf closes before recursive cut") + need(self.monomial.closed and not self.monomial.pool.live and self.monomial.output.read() == BLANK + and self.monomial.compact.closed and self.monomial.compact.binary.native.closed, + "monomial closes before recursive cut") + + def shape(self): + active = Count.product(self.c("width"), self.c("spacing")) + bits = Count(self.c("compact_bits")) + records = row_bits = None + try: + bits.multiply_small(3) + for name in ("front", "before", "after", "back"): + bits.add(self.c(name)) + bits.add(active) + records = power_two(bits) + row_bits = Count.product(records, self.c("coefficients")) + expanded = Count.product(row_bits, self.c("component_bits")) + expanded.multiply_small(2) + self.save(expanded, "row_bits") + finally: + for value in (active, bits, records, row_bits): + if value is not None: + value.close() + + def complete_extent(self): + rows = Count.product(self.c("prefixes"), self.c("rows")) + try: + return Count.product(rows, self.c("row_bits")) + finally: + rows.close() + + def apply_leaf(self, width, before, after): + if width.zero(): + return + active = Count.product(width, self.c("spacing")) + rows = Count.product(self.c("prefixes"), self.c("rows")) + widths = tuple(Count(v) for v in (self.c("front"), self.c("compact_bits"), self.c("compact_bits"), + before, active, after, self.c("compact_bits"), self.c("back"))) + try: + with self.scope.suspended(): + returned = self.leaf.run_leaf(self.roles["current"], tuple(borrowed_count(v) for v in widths), + *(borrowed_count(v) for v in (width, self.c("spacing"), self.c("residue"), + self.c("component_bits"), self.c("coefficients"), rows))) + transfer(returned, self.roles["current"]) + erase_marker(returned) + finally: + for value in (*widths, active, rows): + value.close() + + def node(self): + dimension = Count.literal(self.binding.dimension) + test = extent = columns = removed = rest = suffix = shift = divisor = unused = remainder = None + try: + for name in ("prefixes", "rows", "spacing", "guard", "component_bits", "coefficients", "root_width"): + positive(self.c(name)) + need(compare(self.c("width"), self.c("root_width")) <= 0, "node within global width") + self.shape() + extent = self.complete_extent() + self.roles["current"].rewind() + skip(self.roles["current"], extent) + need(self.roles["current"].read() == BLANK, "complete node input") + self.roles["current"].rewind() + if self.c("width").zero() or compare(self.c("width"), dimension) < 0: + self.apply_leaf(self.c("width"), self.c("before"), self.c("after")) + self.mode = "return" + return + test = fixed_power(self.c("width"), 1000, self.c("root_width")) + if compare(test, self.c("root_width")) < 0: + self.apply_leaf(self.c("width"), self.c("before"), self.c("after")) + self.mode = "return" + return + columns = Count(self.c("width")) + delta = columns.divide_small(self.binding.dimension) + if delta: + removed = Count.literal(delta) + rest = subtract(self.c("width"), removed) + suffix = Count.product(rest, self.c("spacing")) + suffix.add(self.c("after")) + self.apply_leaf(removed, self.c("before"), suffix) + shift = Count.product(removed, self.c("spacing")) + shift.add(self.c("before")) + self.save(shift, "before") + shift = None + self.save(rest, "width") + rest = None + self.save(columns, "columns") + columns = None + divisor = Count.literal(self.binding.families * self.binding.cover.size) + unused, remainder = divide(self.c("rows"), divisor) + need(remainder.zero() and not unused.zero(), "complete fresh row divisor at node") + self.save(unused, "unused") + unused = None + local_bits = Count.product(self.c("prefixes"), self.c("unused")) + local_extent = Count.product(local_bits, self.c("row_bits")) + local_bits.close() + divisor2 = Count(self.c("component_bits")) + divisor2.multiply_small(2) + gaussian_count, rem2 = divide(local_extent, divisor2) + try: + need(rem2.zero(), "complete Gaussian local packet") + self.save(gaussian_count, "gaussians") + gaussian_count = None + finally: + if gaussian_count is not None: + gaussian_count.close() + local_extent.close() + divisor2.close() + rem2.close() + self.event = self.subgroup = self.cover_index = self.pc = 0 + self.group = None + self.mode = "group" + finally: + for value in (dimension, test, extent, columns, removed, rest, suffix, shift, divisor, unused, remainder): + if value is not None: + value.close() + + def scalar_step(self, target, source, key): + self.scalar.select(key) + with self.scope.suspended(): + returned = self.scalar.run(self.packet(target), None if source is None else self.packet(source), + borrowed_count(self.c("component_bits")), borrowed_count(self.c("gaussians"))) + transfer(returned, self.packet(target)) + erase_marker(returned) + + def packet_extent(self): + extent = Count.product(self.c("gaussians"), self.c("component_bits")) + extent.multiply_small(2) + return extent + + def zero_step(self, target): + need(target >= self.binding.slots, "only compiled private logical CLEAR") + extent = self.packet_extent() + remaining = Counter(extent) + tape = self.packet(target) + tape.clear() + try: + while not remaining.finished: + tape.append(0) + remaining.decrement() + finally: + tape.rewind() + remaining.close() + extent.close() + + def copy_step(self, target, source): + need(target >= self.binding.slots and target != source, "compiled private COPY") + extent = self.packet_extent() + try: + require_zero(self.packet(target), extent) + copy_symbols(self.packet(source), self.packet(target)) + finally: + extent.close() + + def exchange_step(self, x, y): + self.scalar.select(("scale", -1, 1)) + with self.scope.suspended(): + returned = self.scalar.run(self.packet(x), None, borrowed_count(self.c("component_bits")), + borrowed_count(self.c("gaussians"))) + transfer(self.packet(y), self.packet(x)) + transfer(returned, self.packet(y)) + erase_marker(returned) + + def monomial_step(self, target, key, inverse): + self.monomial.select(self.group.recipes[key]) + one = Count.literal(1) + columns = compact = extra = wide = rows = None + widths = () + try: + columns = subtract(self.c("columns"), one) + compact = Count.product(columns, self.c("guard")) + extra = subtract(self.c("compact_bits"), compact) + wide = Count.product(self.c("columns"), self.c("spacing")) + rows = Count.product(self.c("prefixes"), self.c("unused")) + template = (self.c("front"), extra, compact, extra, compact, self.c("before"), + *((wide,) * self.binding.dimension), self.c("after"), extra, compact, self.c("back")) + widths = tuple(Count(value) for value in template) + with self.scope.suspended(): + returned = self.monomial.run(self.packet(target), tuple(borrowed_count(v) for v in widths), + *(borrowed_count(v) for v in (self.c("columns"), self.c("spacing"), self.c("guard"), + self.c("residue"), self.c("component_bits"), self.c("coefficients"), rows)), inverse=inverse) + transfer(returned, self.packet(target)) + erase_marker(returned) + finally: + for value in (*widths, one, columns, compact, extra, wide, rows): + if value is not None: + value.close() + + def next_group(self): + while self.event < len(self.binding.events): + count = self.binding.group_count(self.event) + if self.subgroup >= count: + self.event += 1 + self.subgroup = self.cover_index = 0 + continue + if self.cover_index >= self.binding.cover.size: + self.cover_index = 0 + self.subgroup += 1 + continue + group = self.binding.group(self.event, self.subgroup, self.cover_index) + need(len(group.code) < 65536, "finite group program-counter bound") + if not group.code: + self.cover_index += 1 + continue + self.group = group + self.bank.select(group.keys) + with self.scope.suspended(): + self.bank.gather(self.roles["current"], *(borrowed_count(self.c(name)) + for name in ("prefixes", "unused", "row_bits"))) + for tape in self.private: + origin(tape) + tape.clear() + self.pc = 0 + return + self.mode = "return" + + def finish_group(self): + extent = self.packet_extent() + try: + for tape in self.private: + if tape.read() != BLANK: + require_zero(tape, extent) + tape.clear() + finally: + extent.close() + with self.scope.suspended(): + self.bank.scatter(self.roles["current"], *(borrowed_count(self.c(name)) + for name in ("prefixes", "unused", "row_bits"))) + self.bank.commit(self.roles["current"]) + self.group = None + self.cover_index += 1 + self.pc = 0 + + def prepare_child(self, target, rank): + need(self.group is not None and self.bank.state == "gathered", "child belongs to active group") + need(type(rank) is int and 0 < rank < self.binding.dimension, "source child rank contracts") + width = Count(self.c("columns")) + if rank > 1: + width.multiply_small(rank) + tail = Count(self.c("columns")) + if self.binding.dimension - rank > 1: + tail.multiply_small(self.binding.dimension - rank) + after = Count.product(tail, self.c("spacing")) + try: + need(not width.zero() and compare(width, self.c("width")) < 0, "strict complex child contraction") + after.add(self.c("after")) + copy_symbols(self.packet(target), self.capsule["current"]) + for name in INPUTS: + value = self.c("unused") if name == "rows" else width if name == "width" else after if name == "after" else self.c(name) + copy_symbols(value.tape, self.capsule[name]) + self.header.write(self.roles["header"], (int(self.root), self.event, self.subgroup, + self.cover_index, self.pc + 1, target, rank)) + finally: + width.close() + tail.close() + after.close() + + def enter_child(self): + self.primitive_boundary() + for tape in self.parked: + origin(tape) + self.parking.park() + for name, tape in self.capsule.items(): + transfer(tape, self.roles[name]) + self.bank.state = "closed" + self.bank.source = None + self.bank.selection = None + self.group = None + self.root = False + self.mode = "node" + self.event = self.subgroup = self.cover_index = self.pc = 0 + if self.observe: + self.observe(self, "enter") + + def return_node(self): + self.primitive_boundary() + need(self.output.read() == BLANK, "consume preceding complex output") + origin(self.output) + transfer(self.roles["current"], self.output) + for tape in self.parked: + origin(tape) + tape.clear() + self.bank.state = "closed" + self.bank.source = None + self.bank.selection = None + if self.root: + self.parking.empty() + self.closed = True + self.mode = "closed" + return True + self.parking.restore() + root, self.event, self.subgroup, self.cover_index, self.pc, target, rank = self.header.read(self.roles["header"]) + self.roles["header"].clear() + self.root = bool(root) + self.group = self.binding.group(self.event, self.subgroup, self.cover_index) + need(0 < self.pc <= len(self.group.code) and + self.group.code[self.pc - 1][0] == "child" and + self.group.code[self.pc - 1][2:] == (target, rank), "return matches exact parent child instruction") + transfer(self.output, self.packet(target)) + self.bank.selection = {key: slot for slot, key in enumerate(self.group.keys)} + self.bank.source = self.roles["current"] + self.bank.state = "gathered" + self.mode = "group" + if self.observe: + self.observe(self, "return") + return False + + def discard(self): + for tape in (*self.parked, *self.capsule.values(), self.output, self.bank.output): + origin(tape) + tape.clear() + self.parking.stack.clear() + self.parking.reverse.clear() + self.bank.state = "closed" + self.bank.source = self.bank.selection = None + self.group = None + self.mode = "closed" + self.closed = True + + def run(self, payload, descriptors): + need(self.closed and self.output.read() == BLANK and set(descriptors) == set(INPUTS), + "closed prepared complex entry and complete descriptors") + self.parking.empty() + source = borrowed_tape(payload) + need(source not in self.parked and source is not self.output, "borrowed complex input is separate") + need(all(isinstance(descriptors[name], Count) for name in INPUTS), "encoded prepared descriptor") + self.root, self.closed, self.mode = True, False, "node" + self.group = None + try: + copy_symbols(source, self.roles["current"]) + for name in INPUTS: + copy_symbols(descriptors[name].tape, self.roles[name]) + while True: + child = False + with sealed_constructors(), self.scope.installed(): + if self.mode == "node": + self.node() + elif self.mode == "group": + if self.group is None: + self.next_group() + elif self.pc == len(self.group.code): + self.finish_group() + else: + op = self.group.code[self.pc] + kind = op[0] + if kind == "scalar": + self.scalar_step(*op[2:]) + elif kind == "zero": + self.zero_step(op[2]) + elif kind == "copy": + self.copy_step(*op[2:]) + elif kind == "monomial": + self.monomial_step(*op[2:]) + elif kind == "exchange": + self.exchange_step(*op[2:]) + elif kind == "child": + self.prepare_child(*op[2:]) + child = True + else: + need(kind in ("identity", "marker"), "implemented physical instruction") + if not child: + self.pc += 1 + else: + need(self.mode == "return", "finite complex controller state") + self.pool.empty() + if child: + self.enter_child() + elif self.mode == "return" and self.return_node(): + source.rewind() + return self.output + except BaseException: + for tape in (*self.roles.values(), *self.capsule.values()): + tape.rewind() + self.discard() + source.rewind() + raise diff --git a/research/qq16-caller-install/inputs/PR3464-parking.py b/research/qq16-caller-install/inputs/PR3464-parking.py new file mode 100644 index 0000000000..34bc6a0bd0 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR3464-parking.py @@ -0,0 +1,132 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Park fixed complex roles on one physical stack without a Python continuation. + +I use the fixed-role protocol of PR2809. Complex numerical descriptors are +Count bodies, so this stack does not need the BIT caller's second Arena bank. +""" +import cohort +cohort.activate() +from records import Tape +from words import BLANK, LEFT, need + +BODY = (0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13) +# Body symbols use four binary digits; these two existing record symbols +# therefore remain unambiguous delimiters without extending Tape's alphabet. +ROLE_END = 13 +FRAME_END = 12 + + +class Parking: + def __init__(self, roles): + self.roles = tuple(roles) + need(self.roles and len({id(t) for t in self.roles}) == len(self.roles), "fixed distinct parked roles") + self.stack = Tape() + self.reverse = Tape() + + def park(self): + need(self.stack.read() == BLANK and self.reverse.read() == BLANK, "canonical parking ports") + for tape in self.roles: + tape.rewind() + while tape.read() != BLANK: + symbol = tape.read() + need(symbol in BODY, "dense complex role alphabet") + for bit in range(4): + self.stack.write((symbol >> bit) & 1) + self.stack.step(1) + tape.write(BLANK) + tape.step(1) + self.stack.write(ROLE_END) + self.stack.step(1) + tape.rewind() + self.stack.write(FRAME_END) + self.stack.step(1) + + def restore(self): + need(self.stack.read() == BLANK and self.reverse.read() == BLANK, "canonical restoration ports") + need(all(t.read() == BLANK for t in self.roles), "child closes roles before restoration") + self.stack.step(-1) + need(self.stack.read() == FRAME_END, "one parent frame available") + self.stack.write(BLANK) + for tape in reversed(self.roles): + self.stack.step(-1) + need(self.stack.read() == ROLE_END, "fixed parent role delimiter") + self.stack.write(BLANK) + while True: + self.stack.step(-1) + symbol = self.stack.read() + if symbol in (ROLE_END, FRAME_END, LEFT): + self.stack.step(1) + break + need(symbol in (0, 1), "complete parked role bits") + self.reverse.append(symbol) + self.stack.write(BLANK) + # Reversing twice restores the original order. The physical head + # finds LEFT; no role length or stack position enters control. + self.reverse.step(-1) + while self.reverse.read() != LEFT: + symbol = 0 + for bit in range(4): + digit = self.reverse.read() + need(digit in (0, 1), "complete reverse port") + symbol |= digit << bit + self.reverse.write(BLANK) + self.reverse.step(-1) + need(symbol in BODY, "restored fixed role symbol") + tape.append(symbol) + self.reverse.step(1) + tape.rewind() + need(self.stack.read() == BLANK and self.reverse.read() == BLANK, "restored canonical ports") + + def empty(self): + """Check the root boundary without consuming an ancestor frame.""" + need(self.stack.read() == BLANK and self.reverse.read() == BLANK, "closed parking ports") + self.stack.step(-1) + value = self.stack.read() + self.stack.step(1) + need(value == LEFT, "empty root continuation stack") + + +class FiniteFields: + """Only bounded source/PC/cover labels; widths and cardinalities stay on tapes.""" + def __init__(self, bounds): + self.bounds = tuple(bounds) + need(all(type(b) is int and b > 0 for b in self.bounds), "finite continuation alphabet") + self.widths = tuple(max(1, (b - 1).bit_length()) for b in self.bounds) + + def write(self, tape, values): + need(len(values) == len(self.bounds) and tape.read() == BLANK, "empty finite header") + for value, bound, width in zip(values, self.bounds, self.widths): + need(type(value) is int and 0 <= value < bound, "bounded continuation value") + for bit in range(width): + tape.append((value >> bit) & 1) + tape.rewind() + + def read(self, tape): + tape.rewind() + result = [] + for bound, width in zip(self.bounds, self.widths): + value = 0 + for bit in range(width): + symbol = tape.read() + need(symbol in (0, 1), "complete finite header") + value |= symbol << bit + tape.step(1) + need(value < bound, "finite header value") + result.append(value) + need(tape.read() == BLANK, "exact finite header extent") + tape.rewind() + return tuple(result) + + +def transfer(source, target): + need(source is not target, "distinct owned transfer ports") + source.rewind() + target.clear() + while source.read() != BLANK: + symbol = source.read() + need(symbol in BODY, "dense transferred packet or Count") + target.append(symbol) + source.write(BLANK) + source.step(1) + source.rewind() + target.rewind() diff --git a/research/qq16-caller-install/inputs/PR3464-selected_binding.py b/research/qq16-caller-install/inputs/PR3464-selected_binding.py new file mode 100644 index 0000000000..5fe097ff68 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR3464-selected_binding.py @@ -0,0 +1,239 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Finite selected global groups and exact cover/common-view conventions. + +I retain PR2287's chronological construction, Gareth Davidson's actual helper +charts and the selected DATA-PHASES conventions. This compiles their physical +dispatch; it does not replace their native operator proofs. +""" +from collections import Counter +from dataclasses import dataclass +from hashlib import sha256 +import json + +from cover import OrthogonalCover, act, is_orthogonal, multiply, parity, transpose +from native_program import compile_local + + +def require(ok, reason): + if not ok: + raise ValueError(reason) + + +def canonical(obj): + return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode() + + +def literal(rows, offset=0): + n = len(rows) + return dict(matrix_rows=list(rows), offset=offset, phase=0, + linear_Z4=[0] * n, quadratic_rows=[0] * n) + + +def embed(record, dimension): + n = len(record["matrix_rows"]) + require(n <= dimension, "native embedding") + return dict(matrix_rows=list(record["matrix_rows"]) + [1 << i for i in range(n, dimension)], + offset=record["offset"], phase=record["phase"], + linear_Z4=list(record["linear_Z4"]) + [0] * (dimension - n), + quadratic_rows=list(record["quadratic_rows"]) + [0] * (dimension - n)) + + +def port_basis(q, dimension=73): + missing = next(i for i in range(9) if not (q >> i & 1)) + v = q ^ (1 << missing) + order = list(range(dimension)) + order[0], order[missing] = order[missing], order[0] + return tuple((1 << i) ^ (v if v >> i & 1 else 0) for i in order) + + +def data_route(basis, stage): + identity = tuple(1 << i for i in range(len(basis))) + if stage == 0: + return identity + swaps = [basis[1 + i] ^ (1 << (9 + 8 * (stage - 1) + i)) for i in range(8)] + cols = [] + for coordinate in identity: + value = coordinate + for vector in swaps: + if parity(coordinate & vector): + value ^= vector + cols.append(value) + return tuple(cols) + + +@dataclass(frozen=True) +class Owner: + family: int + sigma_columns: tuple + entry: int = 0 + exit: int = 0 + + +@dataclass(frozen=True) +class Group: + keys: tuple + code: tuple + recipes: dict + + +class SelectedBinding: + dimension = 73 + maximum_rank = 48 + families = 14336 + slots = 704 + private = 8 + + def __init__(self, data): + self.data = data + self.template = data["template"] + self.events = tuple(self.template["execution_schedule"]) + self.cover = OrthogonalCover(self.dimension) + self.identity = tuple(1 << i for i in range(self.dimension)) + self.bases = tuple(port_basis(q) for q in data["word"]["ports"]) + require(all(is_orthogonal(b) for b in self.bases), "selected port bases") + self.codes, self.recipes = {}, {} + for direction in ("forward", "backward"): + code, recipes, _ = compile_local(data, direction) + self.codes[direction] = code + for key, record in recipes.items(): + extended = embed(record, self.dimension) + if key in self.recipes: + require(self.recipes[key] == extended, "shared native recipe") + self.recipes[key] = extended + self.calls = {c["time"]: c for c in self.template["calls"]} + self.remainders = {(r["replica"], r["child"], r["port"]): r + for r in self.template["idle_children"]} + self.owner_specs = {} + cached = {} + used = set() + for time, call in self.calls.items(): + owners = [] + for role, (family, route) in enumerate(call["owners"]): + if role < 224: + port = role % 112 + stage = call["stage"] + require(route == [1, stage, port], "literal data owner route") + key = ("data", stage, port) + if key not in cached: + cached[key] = data_route(self.bases[port], stage) + sigma = cached[key] + alignment = data["phases"]["recipes"][port]["stage_alignment"][stage] + side = "X" if role < 112 else "Y" + owners.append(Owner(family, sigma, act(sigma, alignment["entry_" + side]), + act(sigma, alignment["exit_" + side]))) + else: + port = family % 112 + typ, child, offset = route[:3] + width = 9 if typ == 3 else route[3] + spectators = () if typ == 3 else tuple(route[4]) + require(typ in (3, 4), "helper owner type") + key = ("helper", port, child, offset, width, spectators) + if key not in cached: + basis = self.bases[port] + axes = data["phases"]["recipes"][port]["idle_children"][child]["orthogonal_axes"] + active = tuple(axes[offset:offset + width]) + positions = tuple(basis.index(v) for v in active) + expected = tuple(i for i in range(73) if i not in positions)[:9 - width] + require(spectators == expected, "serialized helper spectator completion") + order = positions + spectators + tuple(i for i in range(73) + if i not in positions and i not in spectators) + sigma = tuple(basis[i] for i in order) + digest = sha256(canonical(sigma)).hexdigest() + require(data["sigmas"].get(digest) == list(sigma), "actual emitted helper chart") + used.add(digest) + cached[key] = sigma + owners.append(Owner(family, cached[key])) + require(len(owners) == len({o.family for o in owners}) == 704, "distinct local owner families") + self.owner_specs[time] = tuple(owners) + require(len(used) == len(data["sigmas"]) == 10002, "complete emitted helper chart inventory") + require(not self.template["bank_padding"]["children"], "selected padding has no child") + + def group_count(self, event_index): + kind = self.events[event_index]["kind"] + counts = {"local_cover_sweep": 1, "idle_cover_sweep": 224, "bridge": 112, + "terminal_Y_translations": 112, "terminal": 112, + "bank_padding_cover_sweep": 0, "translate_every_live_family": self.families} + require(kind in counts, "complete selected global alphabet") + return counts[kind] + + def group(self, event_index, subgroup, cover_index): + require(0 <= subgroup < self.group_count(event_index), "finite global subgroup") + event = self.events[event_index] + kind = event["kind"] + g = self.cover.unrank(cover_index) + code, recipes = [], {} + + def mono(role, rows, offset=0, inverse=False): + record = literal(rows, offset) + key = "global:" + sha256(canonical(record)).hexdigest() + recipes[key] = record + code.append(("monomial", -1, role, key, inverse)) + + if kind == "local_cover_sweep": + call = self.calls[event["time"]] + owners = self.owner_specs[call["time"]] + keys = tuple((o.family, self.cover.rank(multiply(g, o.sigma_columns))) for o in owners) + for role, owner in enumerate(owners): + mono(role, g, inverse=True) + if owner.entry: + mono(role, self.identity, owner.entry) + code.extend(self.codes[call["orientation"]]) + recipes.update(self.recipes) + for role, owner in enumerate(owners): + if owner.exit: + mono(role, self.identity, owner.exit) + mono(role, g) + elif kind == "idle_cover_sweep": + side, port = divmod(subgroup, 112) + child = event["child_indices"][side] + family = 896 * event["replica"] + (2 * event["pair"] + side) * 112 + port + original = self.data["phases"]["recipes"][port]["idle_children"][child] + remainder = self.remainders.get((event["replica"], child, port)) + if remainder: + require(remainder["family"] == family, "idle family binding") + active = tuple(original["orthogonal_axes"][remainder["pending_offset"]:]) + require(len(active) == remainder["rank"], "exact pending suffix") + basis = self.bases[port] + chart = active + tuple(v for v in basis if v not in active) + frame = multiply(g, transpose(chart)) + mono(0, frame, inverse=True) + code.append(("child", -1, 0, len(active))) + mono(0, frame) + theta = act(g, original["translation_after"]) + if theta: + mono(0, self.identity, theta) + keys = ((family, cover_index),) + elif kind == "bridge": + port = subgroup + base = 896 * event["replica"] + port + src, dst, c = event["src"], event["dst"], event["coefficient"] + keys = tuple((base + 224 * pair + 112 * side, cover_index) + for pair, side in ((dst, 0), (src, 0), (src, 1), (dst, 1))) + code = [("scalar", -1, 0, 1, ("add", c, 1)), + ("scalar", -1, 2, 3, ("add", -c, 1))] + elif kind in ("terminal_Y_translations", "terminal"): + port = subgroup + base = 896 * event["replica"] + port + if kind == "terminal_Y_translations": + keys = tuple((base + 224 * pair + 112, cover_index) for pair in range(4)) + theta = act(g, self.data["phases"]["recipes"][port]["terminal_Y_translation"]) + for role in range(4): + mono(role, self.identity, theta) + else: + keys = tuple((base + 112 * role, cover_index) for role in range(8)) + code = [("exchange", -1, 2 * pair, 2 * pair + 1) for pair in range(4)] + else: + require(kind == "translate_every_live_family", "final global correction") + mask = sum((((row.bit_count() - 1) // 2) & 1) << i for i, row in enumerate(g)) + keys = ((subgroup, cover_index),) + if mask: + mono(0, self.identity, mask) + require(len(keys) == len(set(keys)) and 0 < len(keys) <= self.slots, "distinct global packets") + return Group(tuple(keys), tuple(code), recipes) + + def inventory(self): + return {"events": len(self.events), "event_counts": dict(Counter(e["kind"] for e in self.events)), + "calls": len(self.calls), "owner_entries": sum(len(v) for v in self.owner_specs.values()), + "helper_charts": len(self.data["sigmas"]), "cover_bits": self.cover.size.bit_length(), + "subgroups_per_cover": sum(self.group_count(i) for i in range(len(self.events))), + "scope": "Finite complete global dispatcher binding; numerical fixtures use reduced geometry."} diff --git a/research/qq16-caller-install/inputs/PR3607-PROOF.md b/research/qq16-caller-install/inputs/PR3607-PROOF.md new file mode 100644 index 0000000000..158cd78492 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR3607-PROOF.md @@ -0,0 +1,264 @@ +# The original root's reserved axes and padded core rectangle + +Copyright 2026 Sagar Thakrar. Apache-2.0. +Prepared with substantial OpenAI Codex assistance. + +This is a conditional address refinement of `reserved_leaves` and `fast_core` +in Jose Manuel's original PR3385 `root_layer.py`, at +`7e5a187214126d31afc241a8f89f4a652352b58c`. It explains how the three source +calls cover exactly the selected tensor axes and why the temporary row +padding can be removed. It does not independently prove the recursive +machine, its numerical precision, the normalized root, or its cost bound. +The source and its predecessors already claim the tensor decomposition; +the contribution here is an independent derivation at these literal +descriptor and serialization boundaries. + +## 1. Domain and endpoint contracts + +Let $D,q_0,q_F,q_B,H,l,r$ be nonnegative integers, and let $K,O,F,w$ +be positive integers. Here $l,r$ are the left and right spectator widths, +$O$ is the outer-row count, $F$ is the number of Gaussian coefficients per +address, and $w$ is a signed component width. Let $0\le\rho0, + \qquad f=q_FK-2H\ge0,\qquad b=q_BK-H+r\ge0. +\] + +The fast branch has the strict inequality $D>Q_0=q_0+q_F+q_B$. +The two nonnegative-width conditions hold for the production choices +$q_F=\lceil2H/K\rceil$ and $q_B=\lceil H/K\rceil$. + +Within each outer row the payload is ordered by increasing binary address +of width $l+DK+r$. Within each address the $F$ Gaussian coefficients occur +in order, each with a real and imaginary component of width $w$. +Address bit positions are counted from the least significant bit. The +selected positions are + +\[ + S=\{r+\rho+jK:0\le j1$; the source loops over prefixes. + +## 4. The recursive descriptor selects the middle axes + +The source passes `before=after=0`, `width=c`, `spacing=K`, `residue=rho`, +`compact_bits=H`, `front=f`, and `back=b` to the recursive machine. Its +row geometry is therefore + +\[ + [f]\ [H]\ [H]\ [cK]\ [H]\ [b]. +\] + +The source identifies this with the preceding rectangle because + +\[ + f+2H=q_FK,\qquad H+b=q_BK+r, +\] + +and hence + +\[ + f+3H+cK+b=(D-q_0)K+r=A. +\] + +Thus its selected position $t$ is + +\[ + b+H+\rho+tK=r+\rho+(q_B+t)K,\qquad0\le t1$ and coarse depth $h\ge0$, the +plan sets + +\[ + q_0=h\lceil\log_2 L\rceil,\qquad T=L^h. +\] + +Since $K\ge1$, $R=2^{q_0K}\ge L^h=T$. For positive $R,T$, + +\[ + R\le R'=T\lceil R/T\rceil=1, precision p>=2, listed +support size 0<=k<=n, position width w=max(1,ceil(log2 n)), positive record +width R and arbitrary positive outer-row count C. Supply exactly k pairs of +w-bit unsigned positions, least-significant bit first within each field. +List the source positions in increasing order. Require distinct image positions +and equality of the source and image sets. I extend the listed map by the +identity outside that set; listed fixed points are permitted. I number address +coordinates from the least significant end and use + + output_coordinate[pi(i)] = input_coordinate[i]. + +Supply the complete C by 2^n rectangle of opaque R-bit records. Its volume is +V=C*2^n*R. The caller supplies distinct borrowed payload/descriptor ports and +canonical parameter ports at their origins. I return a distinct protected +output, preserve those inputs and erase owned work on successful return. +The caller consumes the output before reuse. I retain the predecessors' +successful-input contract, without interruption recovery. + +For correctness I need the retained exact B1 and sparse-batch endpoints. +For the faster rate I additionally fix c,C0,A0>0 and require + + c*p <= n <= C0*p, + k <= 2*p^(997/1000), + log2(R+1) <= A0*p. + +Assume the retained completed binary B1 bound, uniform over arbitrary complete +spectator cardinalities, + + T_B1(v,h) <= B_q*v*(1+h^tau), + tau=332353/332929, + +and its linear workspace bound plus fixed compilation F_q. In PR3562 I give the +retuned exponent argument for PR3608's actual ordinary cohort. I also retain +PR3608's sparse guard, repair, refinement and complete cost arguments. I prove + + T_router = O_(q,c,C0,A0)(V*(k+1)^tau*(log2 p)^(1+tau)), + S_router = O_(q,c,C0,A0)(V) + F_q. + +The functional program accepts valid inputs outside this rate domain. I retain +their literal or unabsorbed physical invoice instead of claiming the displayed +rate there. I do not derive a multiplication theorem or change the selected +frontier. + +## Two involutions and the literal route + +I validate the descriptor with repeated scans. I then traverse each cycle from +each listed vertex, keeping one cycle on a reusable tape. I emit edges only +when the starting vertex is the least coordinate of that cycle. For a cycle +with pi(c_i)=c_(i+1 mod m), define + + J0(c_i)=c_(-i mod m), + J1(c_i)=c_(1-i mod m). + +I execute J0 first and J1 second. Then J1(J0(c_i))=c_(i+1 mod m). +For each involution I emit an edge only when i is smaller than its partner +index. I obtain disjoint transpositions, at most floor(k/2) in each matching. +I handle identity before constructing any positive reservoir width. + +On the literal branch I execute these at most k single-coordinate swaps +through completed B1 with h=1. I charge O_q(V*(k+1)) plus metadata setup. +I preserve the same cycle orientation on both routing branches. + +## Actual record preparation + +Set l=ceil(log2 p), ell=l^2, G=4*l+6, K=64*G and +H=floor(k/2)*G for a nonidentity permutation. I first require n>ell and +N=n-ell>=10H. I search for a contiguous ell-bit interval U outside the +listed support and disjoint from the actual suffix E=[0,ell). +I search from ell upward through the sorted support, advancing a candidate +past any coordinate that intersects it. If either test fails, I use the +literal route. + +On the fast branch I physically exchange U and E using completed B1; call +this coordinate exchange W. I conjugate each listed edge by W and subtract +ell. Since pi fixes U pointwise, W*pi*W fixes E pointwise. I can therefore +group the actual suffix into opaque records of width + + R'=2^ell*R, N=n-ell, C*2^N*R'=V. + +I route the conjugated permutation on the remaining prefix. At the end I +restore the original record interpretation and execute W again. The full +coordinate map is W*(W*pi*W)*W=pi. I do not manufacture record width by +declaring a longer scalar or fixing a coarse label. + +For any disjoint blocks [a,a+h),[b,b+h) with a+h<=b and b+h<=n, I call B1 with + + width=h, + prefixes=C*2^(n-b-h), + gap=2^(b-a-h), + suffix=R*2^a. + +These are actual complete extents. The preceding and intervening cardinalities +may equal one. The inherited B1 contract already pays its binary padding, +restriction and cleanup and does not require long records. Thus I can use it +for the two width-ell preparation/restoration swaps before invoking the +long-record sparse-batch bound. + +## Reservoir placement, recoloring and complete matching execution + +In most-significant order on the N-bit prefix, choose three reservoirs +[0,3H),[3H,6H),[6H,9H). An edge has two endpoints, so it avoids at least one +reservoir. I assign it to the first reservoir it avoids. Within each matching +I process the three resulting cohorts in order. + +For one cohort, place the reservoir's three H-bit chunks at u=[0,H), +t=[H,2H),b=[N-H,N). Since N>=10H, b starts at or after 9H. For reservoir 0, +the first two chunks already occupy their destinations; I omit those identity +swaps. For reservoirs 1 and 2, the three source chunks and destinations are +disjoint. I execute at most three H-bit swaps and undo them in reverse order. + +An edge avoiding the chosen reservoir lands entirely in y=[2H,N-H) in +most-significant order. In the code's least-significant convention this is +[H,N-2H). I apply the actual block-exchange map to both endpoints after each +placement, then subtract H. I recompute the canonical position width for +Y=N-3H. I color these new target coordinates, not their earlier positions. + +I execute each transposition with three XOR stages: a^=b, b^=a, a^=b. +Within a stage the sources are distinct and disjoint from the target set. +For targets j with j+K<=Y, I group by j modulo K and sort only the pair +metadata by target. Equal-color target guards are disjoint. Every batch has +at most floor(k/2) pairs and therefore requires at most H compact bits. +In PR3608 I implement exactly these encoded sparse XOR endpoints, including their +full exceptional-record repair. I keep the actual full H in its bill. + +For a target without a complete guard, I execute an exact CNOT. There are +fewer than K such target positions per stage. I avoid an unsigned subtraction +Y-K by testing j+K<=Y. The CNOT uses the retained four-bucket complete-row +permutation; I iterate arbitrary C outer rows with an encoded counter. I +convert its two positions from least-significant to left-numbered coordinates. + +I process distinct edges in any cohort/color order because the complete XOR +stage has disjoint source and target sets. Within a matching, disjoint +transpositions commute. The prefix operations do not touch the grouped +suffix; the inverse placements restore the surrounding address interpretation. + +## Encoded execution and fixed physical ownership + +I compile the plan onto one binary tape with six fixed three-bit opcodes. +I encode numerical fields with the validated position width; batch pairs use +the recomputed y width. Counts of nonempty batch pairs, positions and block +widths fit these fields. I keep variable cycles, matchings, cohorts and sorted +metadata on a fixed number of tapes, not in size-dependent host collections. +The interpreter checks the exact instruction ending and executes the complete +prepared/restored packet. + +I construct one SparseEngine and retain its existing Binary and native cohort. +The router owns 256 scratch roles and one protected output. I suspend only the +router scope before a Binary or SparseEngine call. I pass borrowed physical +views, copy the protected child return into router-owned scratch, erase that +child output and then consume the previous owned packet. I call neither child +until its predecessor output has been consumed and its work has closed. + +For a conservative fixed-role proof, I allow 24 leases for persistent plan, +instruction and matching fields; 32 for nested scans, two pair contexts, +cycle/reflection and reindex frames; 32 for arithmetic intermediates; and +24 for the packet interpreter, row layout and exact-gate buckets. The sum is +112, below 128 and the allocated 256. Planning and physical execution do not +overlap their deepest frames. I count child pools separately through their +retained bounds. The measured peaks are only finite controls for this count. + +Each metadata stream has O((k+1)w) cells: each matching edge occurs in at most +three XOR stages, and I emit only nonempty batches. I reuse color buckets. +I bound physical payload streams by V and the inherited linear child bounds. +Global cardinality fields occupy O(p+log(C+1)) cells in the rate domain. +For simulator reuse I charge each role's largest preceding visited extent; +erasing a body does not shrink its retained backing array. + +## Complete time invoice + +Let D=2kw and A=2+p+n+D+ceil(log2(R+1)). I obtain D=O(p) from the support +cap and n<=C0*p: p^(-.003)*log p has a finite supremum. Thus A=O(p). +One repeated pair read, including rewind, skip, arithmetic and disposal, costs +O(A^2). I use O(k^2) lookups for validation, O(k^3) for rediscovering cycles +and O(K*k^2) for cohort/color scans. Metadata radix sorting adds a polynomial +in D and w. A conservative O(p^6) allowance covers the actual planner. + +Before grouping, V>=2^(c*p). For each fixed j>0, + + p^j / 2^(c*p) <= (j/(c*e*log 2))^j. + +I can therefore pay that planner allowance with O_c(V). I handle arbitrary +C separately: for L_C=ceil(log2(C+1)), L_C^j/C<=2^(j+1)*j!. Any fixed-degree +global setup polynomial in p+L_C also has a uniform O_c(V) charge. In the +actual code, only global extents and outer counters involve C. The retained +counter traversal costs O(C+L_C); the sparse offsets and repair keys use local +row addresses, so their repeated per-record arithmetic does not contain L_C. + +On the fast branch I have at most 18K sparse batches, 216K internal H-bit B1 +swaps, 36 placement/restoration H-bit swaps, 18K exact tail CNOTs and two +ell-bit preparation/restoration swaps. I include output copies and disposal. +The sparse source invoice uses M=C*2^N, R', and local A'=O(p): + + 12*sum_rows T_B1(2^N*R',H) + + O(V + M*(A')^6 + delta*M*A'*(R'+A')), + delta <= min(1, r*(2/2^G + 8*2^(G-K))), + +where r is the actual batch size. With G=4l+6 and K=64G, I retain PR3608's bound +delta=O(p^-3). Since R'>=2^(l^2), + + p^j/R' <= 2^(j^2/4). + +I pay the remaining per-record and exceptional terms with O(V) per batch. +I obtain the full fast invoice + + O_q(V*((216K+36)*(1+H^tau) + 2*(1+ell^tau) + K+1)) + + O(poly(p+L_C)). + +Substitute H<=kG/2 and K=64G=Theta(log p). Also 2tau<=1+tau because tau<=1. +I obtain the stated fast-rate expression, including actual record preparation. + +## Uniform literal fallback + +I give an explicit cutoff so that a geometry failure does not hide a second +asymptotic regime. Put + + c1=min(c,1), + L=ceil(log2(672/c1)), + X=1024*(L+11), + P*=2^X. + +Here L>=10. For x=log2 p>=X, use .003>1/512 and +2^(x/512)>2^L*(x+1)^2. At X, the latter inequality follows from +2^(L+22)>(1024*(L+11)+1)^2 for L>=10; the logarithmic difference increases +afterward. Hence + + p^.003 > (672/c1)*(log2 p+1)^2. + +Since k<=2p^.997 and ell<=(log2 p+1)^2, I get +n>2(k+1)ell. Among the free intervals after E, at most k+1 gaps remain; +if each had fewer than ell coordinates, their total together with E and k +listed positions would be below 2(k+1)ell. Thus an admissible U exists. +The same inequality gives ell12kG>=10H. + +Consequently a geometric failure implies p=c*p matters. A generic actual-width T74 interface gives no +such lower bound by itself. A future enclosing caller must bind its full +address rectangle and online precision, preserve the global coarse ranges, +and pay its root, restoration, error and packing ledger. The offline setup +precision cannot replace the online p in this argument. I leave that combined +caller and the multiplication theorem open. diff --git a/research/qq16-caller-install/inputs/PR3993-PROOF.md b/research/qq16-caller-install/inputs/PR3993-PROOF.md new file mode 100644 index 0000000000..51e4fade5f --- /dev/null +++ b/research/qq16-caller-install/inputs/PR3993-PROOF.md @@ -0,0 +1,85 @@ +# Lease-end annotations and the CALL empty-pool cut (PR2809) + +## Claim + +Pin Jose Manuel / jmbarrancoml's PR2809 archive on this repository at base +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`, specifically +`research/selected-bit-physical-caller/scratch_pool.py` and +`macro_machine.py`, together with the written annotations in that package's +`PROOF.md` and the named remaining boundary in +`docs/research/selected-bit-physical-contract-map.md`. + +Under the source's own ScratchPool contract: + +1. **Lease-end.** Clearing an owned scratch value ends that lease: `active` + becomes false and the slot is removed from `pool.live`. A later stale + `clear` is a no-op. A stale `read` (or other live operation) rejects. In + particular, a stale `clear` cannot erase a newer borrower of the same + physical role. +2. **CALL cut.** `Machine.call` begins with `self.pool.empty()` before + parking parent streams. `ScratchPool.empty` rejects whenever `pool.live` + is nonempty. Hence no live lease identity crosses the recursive CALL cut + on the successful path the source claims. + +These are source-bound finite obligations. They do not establish the full +all-size physical refinement, selected GL64 execution, H2 primitives, stock +envelope constants, or supplier admission. Selected decimal kappa remains +`0.001672660197076918`. + +## Independent algebra + +Model a fixed inventory of physical roles. A lease holds a slot label and an +active bit. Acquire selects an empty role; clear ends the lease only when +active; empty requires no live leases and blank bodies. + +Correctness of borrower preservation: end lease A, reacquire the same slot as +lease B, write a payload under B, then call A's `clear`. Because A is inactive, +the call returns immediately, B's payload and live map entry survive, and a +subsequent A read rejects. + +CALL cut: with a live lease, `empty()` raises; after that lease ends, `empty()` +succeeds. Thus the first statement of `call` is an acceptance gate for the +cut invariant, not a documentation-only remark. + +## Semantic counterexamples (acceptance gaps for omitted annotations) + +The following mutants are **not** defects of the pinned source. They show that +each named annotation is load-bearing. + +1. **Stale clear without an active guard.** A clear that always erases the + physical role and drops whatever currently owns the slot lets an ended + lease wipe a later borrower's payload and live map entry. The source's + early `if not self.active: return` blocks this. +2. **Clear that forgets `del pool.live[slot]`.** Ending active without + releasing the live map leaves the slot occupied, so reacquire reports + inventory exhaustion even though the role is blank. The source's + `del self.pool.live[self.slot]` is required for reuse. +3. **CALL that skips `pool.empty()`.** A no-op empty lets a live parent lease + and its dirt remain across the simulated CALL cut. The source's leading + `self.pool.empty()` in `call`, together with empty's live check, rejects + that crossing. + +## Source correspondence + +Authenticated against the pinned bytes: + +- `scratch_pool.py` documents "No lease crosses CALL", implements the active + guard, live-map deletion, stale `ValueError("live scratch lease")`, and + `need(not self.live, ...)` inside `empty`. +- `macro_machine.py` method `call` has `self.pool.empty()` as its first body + statement, before `self.streams.park()`. +- `PROOF.md` records stale-close/no-op, stale-read reject, borrower + protection, and "none crosses CALL". +- The physical-contract map names "lease-end annotations and CALL invariants" + as the open independent-audit handoff after opcode/source work. + +## What this does not claim + +- It does not re-run PR2809's GL2 fixtures or claim formal refinement of the + whole caller. +- It does not audit residual block implications already treated by + `research/residual-call-refinement`, nor the compiler/Driver admission gap + in `research/physical-compiler-correspondence`. +- It does not touch stock-envelope A/B/rho, route-cube fibre/key meters, + gate-operand retargets, or rate-substitution reprints. +- No new kappa. diff --git a/research/qq16-caller-install/inputs/PR4106-WORD.json b/research/qq16-caller-install/inputs/PR4106-WORD.json new file mode 100644 index 0000000000..6c6f726cd1 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4106-WORD.json @@ -0,0 +1 @@ +[["clear","Z0","current"],["add","Z0","X0","1"],["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","Z7","current"],["add","Z7","X7","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","Z12","current"],["add","Z12","X12","1"],["clear","W12","hole12"],["add","W12","Y12","1"],["line","W12",12,1],["clear","Z13","current"],["add","Z13","X13","1"],["clear","W13","hole13"],["add","W13","Y13","1"],["line","W13",13,1],["clear","Z14","current"],["add","Z14","X14","1"],["clear","W14","hole14"],["add","W14","Y14","1"],["line","W14",14,1],["clear","Z15","current"],["add","Z15","X15","1"],["clear","W15","hole15"],["add","W15","Y15","1"],["line","W15",15,1],["clear","Z16","current"],["add","Z16","X16","1"],["clear","W16","hole16"],["add","W16","Y16","1"],["line","W16",16,1],["clear","Z17","current"],["add","Z17","X17","1"],["clear","W17","hole17"],["add","W17","Y17","1"],["line","W17",17,1],["clear","Z18","current"],["add","Z18","X18","1"],["clear","W18","hole18"],["add","W18","Y18","1"],["line","W18",18,1],["clear","Z19","current"],["add","Z19","X19","1"],["clear","W19","hole19"],["add","W19","Y19","1"],["line","W19",19,1],["clear","Z20","current"],["add","Z20","X20","1"],["clear","W20","hole20"],["add","W20","Y20","1"],["line","W20",20,1],["clear","Z21","current"],["add","Z21","X21","1"],["clear","W21","hole21"],["add","W21","Y21","1"],["line","W21",21,1],["clear","Z22","current"],["add","Z22","X22","1"],["clear","W22","hole22"],["add","W22","Y22","1"],["line","W22",22,1],["clear","Z23","current"],["add","Z23","X23","1"],["clear","W23","hole23"],["add","W23","Y23","1"],["line","W23",23,1],["clear","Z24","current"],["add","Z24","X24","1"],["clear","W24","hole24"],["add","W24","Y24","1"],["line","W24",24,1],["clear","Z25","current"],["add","Z25","X25","1"],["clear","W25","hole25"],["add","W25","Y25","1"],["line","W25",25,1],["clear","Z26","current"],["add","Z26","X26","1"],["clear","W26","hole26"],["add","W26","Y26","1"],["line","W26",26,1],["clear","Z27","current"],["add","Z27","X27","1"],["clear","W27","hole27"],["add","W27","Y27","1"],["line","W27",27,1],["clear","Z28","current"],["add","Z28","X28","1"],["clear","W28","hole28"],["add","W28","Y28","1"],["line","W28",28,1],["clear","Z29","current"],["add","Z29","X29","1"],["clear","W29","hole29"],["add","W29","Y29","1"],["line","W29",29,1],["clear","Z30","current"],["add","Z30","X30","1"],["clear","W30","hole30"],["add","W30","Y30","1"],["line","W30",30,1],["clear","Z31","current"],["add","Z31","X31","1"],["clear","W31","hole31"],["add","W31","Y31","1"],["line","W31",31,1],["clear","Z32","current"],["add","Z32","X32","1"],["clear","W32","hole32"],["add","W32","Y32","1"],["line","W32",32,1],["clear","Z33","current"],["add","Z33","X33","1"],["clear","W33","hole33"],["add","W33","Y33","1"],["line","W33",33,1],["clear","Z34","current"],["add","Z34","X34","1"],["clear","W34","hole34"],["add","W34","Y34","1"],["line","W34",34,1],["clear","Z35","current"],["add","Z35","X35","1"],["clear","W35","hole35"],["add","W35","Y35","1"],["line","W35",35,1],["clear","Z36","current"],["add","Z36","X36","1"],["clear","W36","hole36"],["add","W36","Y36","1"],["line","W36",36,1],["clear","Z37","current"],["add","Z37","X37","1"],["clear","W37","hole37"],["add","W37","Y37","1"],["line","W37",37,1],["clear","Z38","current"],["add","Z38","X38","1"],["clear","W38","hole38"],["add","W38","Y38","1"],["line","W38",38,1],["clear","Z39","current"],["add","Z39","X39","1"],["clear","W39","hole39"],["add","W39","Y39","1"],["line","W39",39,1],["clear","Z40","current"],["add","Z40","X40","1"],["clear","W40","hole40"],["add","W40","Y40","1"],["line","W40",40,1],["clear","Z41","current"],["add","Z41","X41","1"],["clear","W41","hole41"],["add","W41","Y41","1"],["line","W41",41,1],["clear","Z42","current"],["add","Z42","X42","1"],["clear","W42","hole42"],["add","W42","Y42","1"],["line","W42",42,1],["clear","Z43","current"],["add","Z43","X43","1"],["clear","W43","hole43"],["add","W43","Y43","1"],["line","W43",43,1],["clear","Z44","current"],["add","Z44","X44","1"],["clear","W44","hole44"],["add","W44","Y44","1"],["line","W44",44,1],["clear","Z45","current"],["add","Z45","X45","1"],["clear","W45","hole45"],["add","W45","Y45","1"],["line","W45",45,1],["clear","Z46","current"],["add","Z46","X46","1"],["clear","W46","hole46"],["add","W46","Y46","1"],["line","W46",46,1],["clear","Z47","current"],["add","Z47","X47","1"],["clear","W47","hole47"],["add","W47","Y47","1"],["line","W47",47,1],["clear","Z48","current"],["add","Z48","X48","1"],["clear","W48","hole48"],["add","W48","Y48","1"],["line","W48",48,1],["clear","Z49","current"],["add","Z49","X49","1"],["clear","W49","hole49"],["add","W49","Y49","1"],["line","W49",49,1],["clear","Z50","current"],["add","Z50","X50","1"],["clear","W50","hole50"],["add","W50","Y50","1"],["line","W50",50,1],["clear","Z51","current"],["add","Z51","X51","1"],["clear","W51","hole51"],["add","W51","Y51","1"],["line","W51",51,1],["clear","Z52","current"],["add","Z52","X52","1"],["clear","W52","hole52"],["add","W52","Y52","1"],["line","W52",52,1],["clear","Z53","current"],["add","Z53","X53","1"],["clear","W53","hole53"],["add","W53","Y53","1"],["line","W53",53,1],["clear","Z54","current"],["add","Z54","X54","1"],["clear","W54","hole54"],["add","W54","Y54","1"],["line","W54",54,1],["clear","Z55","current"],["add","Z55","X55","1"],["clear","W55","hole55"],["add","W55","Y55","1"],["line","W55",55,1],["clear","Z56","current"],["add","Z56","X56","1"],["clear","W56","hole56"],["add","W56","Y56","1"],["line","W56",56,1],["clear","Z57","current"],["add","Z57","X57","1"],["clear","W57","hole57"],["add","W57","Y57","1"],["line","W57",57,1],["clear","Z58","current"],["add","Z58","X58","1"],["clear","W58","hole58"],["add","W58","Y58","1"],["line","W58",58,1],["clear","Z59","current"],["add","Z59","X59","1"],["clear","W59","hole59"],["add","W59","Y59","1"],["line","W59",59,1],["clear","Z60","current"],["add","Z60","X60","1"],["clear","W60","hole60"],["add","W60","Y60","1"],["line","W60",60,1],["clear","Z61","current"],["add","Z61","X61","1"],["clear","W61","hole61"],["add","W61","Y61","1"],["line","W61",61,1],["clear","Z62","current"],["add","Z62","X62","1"],["clear","W62","hole62"],["add","W62","Y62","1"],["line","W62",62,1],["clear","Z63","current"],["add","Z63","X63","1"],["clear","W63","hole63"],["add","W63","Y63","1"],["line","W63",63,1],["clear","Z64","current"],["add","Z64","X64","1"],["clear","W64","hole64"],["add","W64","Y64","1"],["line","W64",64,1],["clear","Z65","current"],["add","Z65","X65","1"],["clear","W65","hole65"],["add","W65","Y65","1"],["line","W65",65,1],["clear","Z66","current"],["add","Z66","X66","1"],["clear","W66","hole66"],["add","W66","Y66","1"],["line","W66",66,1],["clear","Z67","current"],["add","Z67","X67","1"],["clear","W67","hole67"],["add","W67","Y67","1"],["line","W67",67,1],["clear","Z68","current"],["add","Z68","X68","1"],["clear","W68","hole68"],["add","W68","Y68","1"],["line","W68",68,1],["clear","Z69","current"],["add","Z69","X69","1"],["clear","W69","hole69"],["add","W69","Y69","1"],["line","W69",69,1],["clear","Z70","current"],["add","Z70","X70","1"],["clear","W70","hole70"],["add","W70","Y70","1"],["line","W70",70,1],["clear","Z71","current"],["add","Z71","X71","1"],["clear","W71","hole71"],["add","W71","Y71","1"],["line","W71",71,1],["clear","Z72","current"],["add","Z72","X72","1"],["clear","W72","hole72"],["add","W72","Y72","1"],["line","W72",72,1],["clear","Z73","current"],["add","Z73","X73","1"],["clear","W73","hole73"],["add","W73","Y73","1"],["line","W73",73,1],["clear","Z74","current"],["add","Z74","X74","1"],["clear","W74","hole74"],["add","W74","Y74","1"],["line","W74",74,1],["clear","Z75","current"],["add","Z75","X75","1"],["clear","W75","hole75"],["add","W75","Y75","1"],["line","W75",75,1],["clear","Z76","current"],["add","Z76","X76","1"],["clear","W76","hole76"],["add","W76","Y76","1"],["line","W76",76,1],["clear","Z77","current"],["add","Z77","X77","1"],["clear","W77","hole77"],["add","W77","Y77","1"],["line","W77",77,1],["clear","Z78","current"],["add","Z78","X78","1"],["clear","W78","hole78"],["add","W78","Y78","1"],["line","W78",78,1],["clear","Z79","current"],["add","Z79","X79","1"],["clear","W79","hole79"],["add","W79","Y79","1"],["line","W79",79,1],["clear","Z80","current"],["add","Z80","X80","1"],["clear","W80","hole80"],["add","W80","Y80","1"],["line","W80",80,1],["clear","Z81","current"],["add","Z81","X81","1"],["clear","W81","hole81"],["add","W81","Y81","1"],["line","W81",81,1],["clear","Z82","current"],["add","Z82","X82","1"],["clear","W82","hole82"],["add","W82","Y82","1"],["line","W82",82,1],["clear","Z83","current"],["add","Z83","X83","1"],["clear","W83","hole83"],["add","W83","Y83","1"],["line","W83",83,1],["clear","Z84","current"],["add","Z84","X84","1"],["clear","W84","hole84"],["add","W84","Y84","1"],["line","W84",84,1],["clear","Z85","current"],["add","Z85","X85","1"],["clear","W85","hole85"],["add","W85","Y85","1"],["line","W85",85,1],["clear","Z86","current"],["add","Z86","X86","1"],["clear","W86","hole86"],["add","W86","Y86","1"],["line","W86",86,1],["clear","Z87","current"],["add","Z87","X87","1"],["clear","W87","hole87"],["add","W87","Y87","1"],["line","W87",87,1],["clear","Z88","current"],["add","Z88","X88","1"],["clear","W88","hole88"],["add","W88","Y88","1"],["line","W88",88,1],["clear","Z89","current"],["add","Z89","X89","1"],["clear","W89","hole89"],["add","W89","Y89","1"],["line","W89",89,1],["clear","Z90","current"],["add","Z90","X90","1"],["clear","W90","hole90"],["add","W90","Y90","1"],["line","W90",90,1],["clear","Z91","current"],["add","Z91","X91","1"],["clear","W91","hole91"],["add","W91","Y91","1"],["line","W91",91,1],["clear","Z92","current"],["add","Z92","X92","1"],["clear","W92","hole92"],["add","W92","Y92","1"],["line","W92",92,1],["clear","Z93","current"],["add","Z93","X93","1"],["clear","W93","hole93"],["add","W93","Y93","1"],["line","W93",93,1],["clear","Z94","current"],["add","Z94","X94","1"],["clear","W94","hole94"],["add","W94","Y94","1"],["line","W94",94,1],["clear","Z95","current"],["add","Z95","X95","1"],["clear","W95","hole95"],["add","W95","Y95","1"],["line","W95",95,1],["clear","Z96","current"],["add","Z96","X96","1"],["clear","W96","hole96"],["add","W96","Y96","1"],["line","W96",96,1],["clear","Z97","current"],["add","Z97","X97","1"],["clear","W97","hole97"],["add","W97","Y97","1"],["line","W97",97,1],["clear","Z98","current"],["add","Z98","X98","1"],["clear","W98","hole98"],["add","W98","Y98","1"],["line","W98",98,1],["clear","Z99","current"],["add","Z99","X99","1"],["clear","W99","hole99"],["add","W99","Y99","1"],["line","W99",99,1],["clear","Z100","current"],["add","Z100","X100","1"],["clear","W100","hole100"],["add","W100","Y100","1"],["line","W100",100,1],["clear","Z101","current"],["add","Z101","X101","1"],["clear","W101","hole101"],["add","W101","Y101","1"],["line","W101",101,1],["clear","Z102","current"],["add","Z102","X102","1"],["clear","W102","hole102"],["add","W102","Y102","1"],["line","W102",102,1],["clear","Z103","current"],["add","Z103","X103","1"],["clear","W103","hole103"],["add","W103","Y103","1"],["line","W103",103,1],["clear","Z104","current"],["add","Z104","X104","1"],["clear","W104","hole104"],["add","W104","Y104","1"],["line","W104",104,1],["clear","Z105","current"],["add","Z105","X105","1"],["clear","W105","hole105"],["add","W105","Y105","1"],["line","W105",105,1],["clear","Z106","current"],["add","Z106","X106","1"],["clear","W106","hole106"],["add","W106","Y106","1"],["line","W106",106,1],["clear","Z107","current"],["add","Z107","X107","1"],["clear","W107","hole107"],["add","W107","Y107","1"],["line","W107",107,1],["clear","Z108","current"],["add","Z108","X108","1"],["clear","W108","hole108"],["add","W108","Y108","1"],["line","W108",108,1],["clear","Z109","current"],["add","Z109","X109","1"],["clear","W109","hole109"],["add","W109","Y109","1"],["line","W109",109,1],["clear","Z110","current"],["add","Z110","X110","1"],["clear","W110","hole110"],["add","W110","Y110","1"],["line","W110",110,1],["clear","Z111","current"],["add","Z111","X111","1"],["clear","W111","hole111"],["add","W111","Y111","1"],["line","W111",111,1],["add","Z0","W0","1"],["add","Z7","W7","1"],["add","Z20","W20","1"],["add","Z27","W27","1"],["add","Z36","W36","1"],["add","Z46","W46","1"],["add","Z57","W57","1"],["add","Z111","W111","1"],["add","Z21","W21","1"],["add","Z37","W37","1"],["add","Z47","W47","1"],["add","Z76","W76","1"],["add","Z81","W81","1"],["add","Z87","W87","1"],["add","Z92","W92","1"],["add","Z110","W110","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],["map","Z21",1,21,false],["map","Z37",1,37,false],["map","Z47",1,47,false],["map","Z76",1,76,false],["map","Z81",1,81,false],["map","Z87",1,87,false],["map","Z92",1,92,false],["map","Z110",1,110,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","W21","wide"],["add","W21","Z21","1"],["add","W21","F4","-1/4"],["add","W21","F5","-1/4"],["add","W21","F6","-1/4"],["add","W21","F7","1/4"],["clear","W37","wide"],["add","W37","Z37","1"],["add","W37","F4","-1/4"],["add","W37","F5","1/4"],["add","W37","F6","-1/4"],["add","W37","F7","-1/4"],["clear","W47","wide"],["add","W47","Z47","1"],["add","W47","F4","-1/4"],["add","W47","F5","-1/4"],["add","W47","F6","1/4"],["add","W47","F7","-1/4"],["clear","W76","wide"],["add","W76","Z76","1"],["add","W76","F0","-1/4"],["add","W76","F1","-1/4"],["add","W76","F2","-1/4"],["add","W76","F3","1/4"],["clear","W81","wide"],["add","W81","Z81","1"],["add","W81","F0","-1/4"],["add","W81","F1","1/4"],["add","W81","F2","1/4"],["add","W81","F3","1/4"],["clear","W87","wide"],["add","W87","Z87","1"],["add","W87","F0","-1/4"],["add","W87","F1","-1/4"],["add","W87","F2","1/4"],["add","W87","F3","-1/4"],["clear","W92","wide"],["add","W92","Z92","1"],["add","W92","F0","-1/4"],["add","W92","F1","1/4"],["add","W92","F2","-1/4"],["add","W92","F3","-1/4"],["clear","W110","wide"],["add","W110","Z110","1"],["add","W110","F4","-1/4"],["add","W110","F5","1/4"],["add","W110","F6","1/4"],["add","W110","F7","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","W0",1,0,true],["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","W7",1,7,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","W20",1,20,true],["map","W21",1,21,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","W27",1,27,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","W36",1,36,true],["map","W37",1,37,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","W46",1,46,true],["map","W47",1,47,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","W57",1,57,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","W76",1,76,true],["map","W77",1,77,true],["map","W78",1,78,true],["map","W79",1,79,true],["map","W80",1,80,true],["map","W81",1,81,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","W87",1,87,true],["map","W88",1,88,true],["map","W89",1,89,true],["map","W90",1,90,true],["map","W91",1,91,true],["map","W92",1,92,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],["map","W110",1,110,true],["map","W111",1,111,true],["map","Z21",1,21,true],["map","Z37",1,37,true],["map","Z47",1,47,true],["map","Z76",1,76,true],["map","Z81",1,81,true],["map","Z87",1,87,true],["map","Z92",1,92,true],["map","Z110",1,110,true],["clear","Z1","query2"],["clear","Z2","query2"],["clear","Z3","query2"],["clear","Z4","query2"],["clear","Z5","query2"],["clear","Z6","query2"],["clear","Z8","query2"],["clear","Z9","query2"],["clear","Z10","current"],["add","Z10","W76","1"],["map","Z10",2,76,false],["line","Z10",76,-1],["clear","Z11","current"],["add","Z11","W81","1"],["map","Z11",2,81,false],["line","Z11",81,-1],["add","Z2","Z10","1"],["add","Z2","Z11","-1"],["add","Z3","Z10","1"],["add","Z3","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z4","Z10","-1"],["clear","Z10","current"],["add","Z10","W87","1"],["map","Z10",2,87,false],["line","Z10",87,-1],["clear","Z11","current"],["add","Z11","W92","1"],["map","Z11",2,92,false],["line","Z11",92,-1],["add","Z2","Z10","1"],["add","Z2","Z11","-1"],["add","Z3","Z10","-1"],["add","Z3","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z4","Z10","1"],["clear","Z10","current"],["add","Z10","W10","1"],["map","Z10",2,10,false],["line","Z10",10,-1],["clear","Z11","current"],["add","Z11","W11","1"],["map","Z11",2,11,false],["line","Z11",11,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z2","Z10","-1"],["add","Z5","Z10","-1"],["clear","Z10","current"],["add","Z10","W62","1"],["map","Z10",2,62,false],["line","Z10",62,-1],["clear","Z11","current"],["add","Z11","W63","1"],["map","Z11",2,63,false],["line","Z11",63,-1],["add","Z6","Z10","-1"],["add","Z6","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z2","Z10","-1"],["add","Z5","Z10","1"],["clear","Z10","current"],["add","Z10","W70","1"],["map","Z10",2,70,false],["line","Z10",70,-1],["clear","Z11","current"],["add","Z11","W71","1"],["map","Z11",2,71,false],["line","Z11",71,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z2","Z10","1"],["add","Z5","Z10","1"],["clear","Z10","current"],["add","Z10","W90","1"],["map","Z10",2,90,false],["line","Z10",90,-1],["clear","Z11","current"],["add","Z11","W91","1"],["map","Z11",2,91,false],["line","Z11",91,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z2","Z10","1"],["add","Z5","Z10","-1"],["clear","Z10","current"],["add","Z10","W2","1"],["map","Z10",2,2,false],["line","Z10",2,-1],["clear","Z11","current"],["add","Z11","W72","1"],["map","Z11",2,72,false],["line","Z11",72,-1],["add","Z9","Z10","-1"],["add","Z9","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z2","Z10","1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W9","1"],["map","Z10",2,9,false],["line","Z10",9,-1],["clear","Z11","current"],["add","Z11","W79","1"],["map","Z11",2,79,false],["line","Z11",79,-1],["add","Z9","Z10","-1"],["add","Z9","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z2","Z10","-1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W25","1"],["map","Z10",2,25,false],["line","Z10",25,-1],["clear","Z11","current"],["add","Z11","W89","1"],["map","Z11",2,89,false],["line","Z11",89,-1],["add","Z9","Z10","1"],["add","Z9","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z2","Z10","1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W61","1"],["map","Z10",2,61,false],["line","Z10",61,-1],["clear","Z11","current"],["add","Z11","W94","1"],["map","Z11",2,94,false],["line","Z11",94,-1],["add","Z9","Z10","1"],["add","Z9","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z2","Z10","-1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W12","1"],["map","Z10",2,12,false],["line","Z10",12,-1],["clear","Z11","current"],["add","Z11","W56","1"],["map","Z11",2,56,false],["line","Z11",56,-1],["add","Z5","Z10","1"],["add","Z5","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z3","Z10","1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W17","1"],["map","Z10",2,17,false],["line","Z10",17,-1],["clear","Z11","current"],["add","Z11","W77","1"],["map","Z11",2,77,false],["line","Z11",77,-1],["add","Z5","Z10","1"],["add","Z5","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z3","Z10","-1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W31","1"],["map","Z10",2,31,false],["line","Z10",31,-1],["clear","Z11","current"],["add","Z11","W100","1"],["map","Z11",2,100,false],["line","Z11",100,-1],["add","Z5","Z10","-1"],["add","Z5","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z3","Z10","1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W38","1"],["map","Z10",2,38,false],["line","Z10",38,-1],["clear","Z11","current"],["add","Z11","W103","1"],["map","Z11",2,103,false],["line","Z11",103,-1],["add","Z5","Z10","-1"],["add","Z5","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z3","Z10","-1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W18","1"],["map","Z10",2,18,false],["line","Z10",18,-1],["clear","Z11","current"],["add","Z11","W19","1"],["map","Z11",2,19,false],["line","Z11",19,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z3","Z10","-1"],["add","Z9","Z10","1"],["clear","Z10","current"],["add","Z10","W39","1"],["map","Z10",2,39,false],["line","Z10",39,-1],["clear","Z11","current"],["add","Z11","W40","1"],["map","Z11",2,40,false],["line","Z11",40,-1],["add","Z6","Z10","-1"],["add","Z6","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z3","Z10","-1"],["add","Z9","Z10","-1"],["clear","Z10","current"],["add","Z10","W54","1"],["map","Z10",2,54,false],["line","Z10",54,-1],["clear","Z11","current"],["add","Z11","W55","1"],["map","Z11",2,55,false],["line","Z11",55,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z3","Z10","1"],["add","Z9","Z10","-1"],["clear","Z10","current"],["add","Z10","W101","1"],["map","Z10",2,101,false],["line","Z10",101,-1],["clear","Z11","current"],["add","Z11","W102","1"],["map","Z11",2,102,false],["line","Z11",102,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z3","Z10","1"],["add","Z9","Z10","1"],["clear","Z10","current"],["add","Z10","W24","1"],["map","Z10",2,24,false],["line","Z10",24,-1],["clear","Z11","current"],["add","Z11","W32","1"],["map","Z11",2,32,false],["line","Z11",32,-1],["add","Z4","Z10","-1"],["add","Z4","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z5","Z10","-1"],["add","Z9","Z10","1"],["clear","Z10","current"],["add","Z10","W35","1"],["map","Z10",2,35,false],["line","Z10",35,-1],["clear","Z11","current"],["add","Z11","W85","1"],["map","Z11",2,85,false],["line","Z11",85,-1],["add","Z4","Z10","-1"],["add","Z4","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z5","Z10","-1"],["add","Z9","Z10","-1"],["clear","Z10","current"],["add","Z10","W45","1"],["map","Z10",2,45,false],["line","Z10",45,-1],["clear","Z11","current"],["add","Z11","W98","1"],["map","Z11",2,98,false],["line","Z11",98,-1],["add","Z4","Z10","-1"],["add","Z4","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z5","Z10","1"],["add","Z9","Z10","1"],["clear","Z10","current"],["add","Z10","W48","1"],["map","Z10",2,48,false],["line","Z10",48,-1],["clear","Z11","current"],["add","Z11","W107","1"],["map","Z11",2,107,false],["line","Z11",107,-1],["add","Z4","Z10","1"],["add","Z4","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z5","Z10","1"],["add","Z9","Z10","-1"],["clear","Z10","current"],["add","Z10","W22","1"],["map","Z10",2,22,false],["line","Z10",22,-1],["clear","Z11","current"],["add","Z11","W23","1"],["map","Z11",2,23,false],["line","Z11",23,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z4","Z10","-1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W33","1"],["map","Z10",2,33,false],["line","Z10",33,-1],["clear","Z11","current"],["add","Z11","W34","1"],["map","Z11",2,34,false],["line","Z11",34,-1],["add","Z6","Z10","-1"],["add","Z6","Z11","1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z4","Z10","1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W49","1"],["map","Z10",2,49,false],["line","Z10",49,-1],["clear","Z11","current"],["add","Z11","W50","1"],["map","Z11",2,50,false],["line","Z11",50,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z4","Z10","1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W108","1"],["map","Z10",2,108,false],["line","Z10",108,-1],["clear","Z11","current"],["add","Z11","W109","1"],["map","Z11",2,109,false],["line","Z11",109,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z1","Z10","1"],["add","Z4","Z10","-1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W1","1"],["map","Z10",2,1,false],["line","Z10",1,-1],["clear","Z11","current"],["add","Z11","W75","1"],["map","Z11",2,75,false],["line","Z11",75,-1],["add","Z9","Z10","-1"],["add","Z9","Z11","1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z3","Z10","1"],["add","Z5","Z10","-1"],["clear","Z10","current"],["add","Z10","W6","1"],["map","Z10",2,6,false],["line","Z10",6,-1],["clear","Z11","current"],["add","Z11","W82","1"],["map","Z11",2,82,false],["line","Z11",82,-1],["add","Z9","Z10","1"],["add","Z9","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z3","Z10","1"],["add","Z5","Z10","1"],["clear","Z10","current"],["add","Z10","W28","1"],["map","Z10",2,28,false],["line","Z10",28,-1],["clear","Z11","current"],["add","Z11","W86","1"],["map","Z11",2,86,false],["line","Z11",86,-1],["add","Z9","Z10","1"],["add","Z9","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z3","Z10","-1"],["add","Z5","Z10","-1"],["clear","Z10","current"],["add","Z10","W58","1"],["map","Z10",2,58,false],["line","Z10",58,-1],["clear","Z11","current"],["add","Z11","W93","1"],["map","Z11",2,93,false],["line","Z11",93,-1],["add","Z9","Z10","-1"],["add","Z9","Z11","1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z3","Z10","-1"],["add","Z5","Z10","1"],["clear","Z10","current"],["add","Z10","W29","1"],["map","Z10",2,29,false],["line","Z10",29,-1],["clear","Z11","current"],["add","Z11","W30","1"],["map","Z11",2,30,false],["line","Z11",30,-1],["add","Z6","Z10","-1"],["add","Z6","Z11","1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z3","Z10","-1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W59","1"],["map","Z10",2,59,false],["line","Z10",59,-1],["clear","Z11","current"],["add","Z11","W60","1"],["map","Z11",2,60,false],["line","Z11",60,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z3","Z10","-1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W73","1"],["map","Z10",2,73,false],["line","Z10",73,-1],["clear","Z11","current"],["add","Z11","W74","1"],["map","Z11",2,74,false],["line","Z11",74,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z3","Z10","1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W83","1"],["map","Z10",2,83,false],["line","Z10",83,-1],["clear","Z11","current"],["add","Z11","W84","1"],["map","Z11",2,84,false],["line","Z11",84,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z3","Z10","1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W3","1"],["map","Z10",2,3,false],["line","Z10",3,-1],["clear","Z11","current"],["add","Z11","W66","1"],["map","Z11",2,66,false],["line","Z11",66,-1],["add","Z4","Z10","1"],["add","Z4","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z5","Z10","-1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W8","1"],["map","Z10",2,8,false],["line","Z10",8,-1],["clear","Z11","current"],["add","Z11","W80","1"],["map","Z11",2,80,false],["line","Z11",80,-1],["add","Z4","Z10","-1"],["add","Z4","Z11","1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z5","Z10","1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W26","1"],["map","Z10",2,26,false],["line","Z10",26,-1],["clear","Z11","current"],["add","Z11","W88","1"],["map","Z11",2,88,false],["line","Z11",88,-1],["add","Z4","Z10","-1"],["add","Z4","Z11","1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z5","Z10","-1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W67","1"],["map","Z10",2,67,false],["line","Z10",67,-1],["clear","Z11","current"],["add","Z11","W95","1"],["map","Z11",2,95,false],["line","Z11",95,-1],["add","Z4","Z10","1"],["add","Z4","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z5","Z10","1"],["add","Z8","Z10","-1"],["clear","Z10","current"],["add","Z10","W4","1"],["map","Z10",2,4,false],["line","Z10",4,-1],["clear","Z11","current"],["add","Z11","W5","1"],["map","Z11",2,5,false],["line","Z11",5,-1],["add","Z6","Z10","-1"],["add","Z6","Z11","1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z4","Z10","1"],["add","Z9","Z10","-1"],["clear","Z10","current"],["add","Z10","W64","1"],["map","Z10",2,64,false],["line","Z10",64,-1],["clear","Z11","current"],["add","Z11","W65","1"],["map","Z11",2,65,false],["line","Z11",65,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z4","Z10","-1"],["add","Z9","Z10","-1"],["clear","Z10","current"],["add","Z10","W68","1"],["map","Z10",2,68,false],["line","Z10",68,-1],["clear","Z11","current"],["add","Z11","W69","1"],["map","Z11",2,69,false],["line","Z11",69,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z4","Z10","1"],["add","Z9","Z10","1"],["clear","Z10","current"],["add","Z10","W96","1"],["map","Z10",2,96,false],["line","Z10",96,-1],["clear","Z11","current"],["add","Z11","W97","1"],["map","Z11",2,97,false],["line","Z11",97,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z2","Z10","1"],["add","Z4","Z10","-1"],["add","Z9","Z10","1"],["clear","Z10","current"],["add","Z10","W14","1"],["map","Z10",2,14,false],["line","Z10",14,-1],["clear","Z11","current"],["add","Z11","W15","1"],["map","Z11",2,15,false],["line","Z11",15,-1],["add","Z6","Z10","-1"],["add","Z6","Z11","1"],["add","Z10","Z11","1"],["add","Z3","Z10","1"],["add","Z4","Z10","1"],["add","Z5","Z10","1"],["clear","Z10","current"],["add","Z10","W41","1"],["map","Z10",2,41,false],["line","Z10",41,-1],["clear","Z11","current"],["add","Z11","W42","1"],["map","Z11",2,42,false],["line","Z11",42,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z3","Z10","1"],["add","Z4","Z10","-1"],["add","Z5","Z10","1"],["clear","Z10","current"],["add","Z10","W52","1"],["map","Z10",2,52,false],["line","Z10",52,-1],["clear","Z11","current"],["add","Z11","W53","1"],["map","Z11",2,53,false],["line","Z11",53,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z3","Z10","1"],["add","Z4","Z10","1"],["add","Z5","Z10","-1"],["clear","Z10","current"],["add","Z10","W105","1"],["map","Z10",2,105,false],["line","Z10",105,-1],["clear","Z11","current"],["add","Z11","W106","1"],["map","Z11",2,106,false],["line","Z11",106,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z10","Z11","1"],["add","Z3","Z10","1"],["add","Z4","Z10","-1"],["add","Z5","Z10","-1"],["clear","Z10","current"],["add","Z10","W13","1"],["map","Z10",2,13,false],["line","Z10",13,-1],["clear","Z11","current"],["add","Z11","W43","1"],["map","Z11",2,43,false],["line","Z11",43,-1],["add","Z4","Z10","1"],["add","Z4","Z11","-1"],["add","Z10","Z11","1"],["add","Z3","Z10","1"],["add","Z8","Z10","1"],["add","Z9","Z10","1"],["clear","Z10","current"],["add","Z10","W16","1"],["map","Z10",2,16,false],["line","Z10",16,-1],["clear","Z11","current"],["add","Z11","W78","1"],["map","Z11",2,78,false],["line","Z11",78,-1],["add","Z4","Z10","-1"],["add","Z4","Z11","1"],["add","Z10","Z11","1"],["add","Z3","Z10","1"],["add","Z8","Z10","1"],["add","Z9","Z10","-1"],["clear","Z10","current"],["add","Z10","W44","1"],["map","Z10",2,44,false],["line","Z10",44,-1],["clear","Z11","current"],["add","Z11","W99","1"],["map","Z11",2,99,false],["line","Z11",99,-1],["add","Z4","Z10","-1"],["add","Z4","Z11","1"],["add","Z10","Z11","1"],["add","Z3","Z10","1"],["add","Z8","Z10","-1"],["add","Z9","Z10","1"],["clear","Z10","current"],["add","Z10","W51","1"],["map","Z10",2,51,false],["line","Z10",51,-1],["clear","Z11","current"],["add","Z11","W104","1"],["map","Z11",2,104,false],["line","Z11",104,-1],["add","Z4","Z10","1"],["add","Z4","Z11","-1"],["add","Z10","Z11","1"],["add","Z3","Z10","1"],["add","Z8","Z10","-1"],["add","Z9","Z10","-1"],["clear","Z10","current"],["add","Z10","W21","1"],["map","Z10",2,21,false],["line","Z10",21,-1],["clear","Z11","current"],["add","Z11","W37","1"],["map","Z11",2,37,false],["line","Z11",37,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z9","Z10","-1"],["add","Z9","Z11","1"],["add","Z10","Z11","1"],["add","Z5","Z10","1"],["add","Z8","Z10","1"],["clear","Z10","current"],["add","Z10","W47","1"],["map","Z10",2,47,false],["line","Z10",47,-1],["clear","Z11","current"],["add","Z11","W110","1"],["map","Z11",2,110,false],["line","Z11",110,-1],["add","Z6","Z10","1"],["add","Z6","Z11","-1"],["add","Z9","Z10","1"],["add","Z9","Z11","-1"],["add","Z10","Z11","1"],["add","Z5","Z10","1"],["add","Z8","Z10","-1"],["clear","Z10","query2"],["add","Z10","Z1","-1/4"],["add","Z10","Z2","-1/4"],["add","Z10","Z3","-1/4"],["add","Z10","Z4","-1/4"],["line","Z10",0,1],["map","Z10",2,0,true],["add","W0","Z10","1"],["clear","Z10","query2"],["add","Z10","Z1","-1/4"],["add","Z10","Z2","1/4"],["add","Z10","Z3","1/4"],["add","Z10","Z4","-1/4"],["line","Z10",7,1],["map","Z10",2,7,true],["add","W7","Z10","1"],["clear","Z10","query2"],["add","Z10","Z5","-1/4"],["add","Z10","Z6","1/4"],["add","Z10","Z8","-1/4"],["add","Z10","Z9","1/4"],["line","Z10",20,1],["map","Z10",2,20,true],["add","W20","Z10","1"],["clear","Z10","query2"],["add","Z10","Z1","-1/4"],["add","Z10","Z2","-1/4"],["add","Z10","Z3","1/4"],["add","Z10","Z4","1/4"],["line","Z10",27,1],["map","Z10",2,27,true],["add","W27","Z10","1"],["clear","Z10","query2"],["add","Z10","Z5","-1/4"],["add","Z10","Z6","-1/4"],["add","Z10","Z8","-1/4"],["add","Z10","Z9","-1/4"],["line","Z10",36,1],["map","Z10",2,36,true],["add","W36","Z10","1"],["clear","Z10","query2"],["add","Z10","Z5","-1/4"],["add","Z10","Z6","1/4"],["add","Z10","Z8","1/4"],["add","Z10","Z9","-1/4"],["line","Z10",46,1],["map","Z10",2,46,true],["add","W46","Z10","1"],["clear","Z10","query2"],["add","Z10","Z1","-1/4"],["add","Z10","Z2","1/4"],["add","Z10","Z3","-1/4"],["add","Z10","Z4","1/4"],["line","Z10",57,1],["map","Z10",2,57,true],["add","W57","Z10","1"],["clear","Z10","query2"],["add","Z10","Z5","-1/4"],["add","Z10","Z6","-1/4"],["add","Z10","Z8","1/4"],["add","Z10","Z9","1/4"],["line","Z10",111,1],["map","Z10",2,111,true],["add","W111","Z10","1"],["clear","Z1","current"],["add","Z1","X1","1"],["clear","Z2","current"],["add","Z2","X2","1"],["clear","Z3","current"],["add","Z3","X3","1"],["clear","Z4","current"],["add","Z4","X4","1"],["clear","Z5","current"],["add","Z5","X5","1"],["clear","Z6","current"],["add","Z6","X6","1"],["clear","Z8","current"],["add","Z8","X8","1"],["clear","Z9","current"],["add","Z9","X9","1"],["clear","Z10","current"],["add","Z10","X10","1"],["clear","Z11","current"],["add","Z11","X11","1"],["add","Z0","W0","-1"],["add","Z1","W1","1"],["add","Z2","W2","1"],["add","Z3","W3","1"],["add","Z4","W4","1"],["add","Z5","W5","1"],["add","Z6","W6","1"],["add","Z7","W7","-1"],["add","Z8","W8","1"],["add","Z9","W9","1"],["add","Z10","W10","1"],["add","Z11","W11","1"],["add","Z12","W12","1"],["add","Z13","W13","1"],["add","Z14","W14","1"],["add","Z15","W15","1"],["add","Z16","W16","1"],["add","Z17","W17","1"],["add","Z18","W18","1"],["add","Z19","W19","1"],["add","Z20","W20","-1"],["add","Z21","W21","-1"],["add","Z22","W22","1"],["add","Z23","W23","1"],["add","Z24","W24","1"],["add","Z25","W25","1"],["add","Z26","W26","1"],["add","Z27","W27","-1"],["add","Z28","W28","1"],["add","Z29","W29","1"],["add","Z30","W30","1"],["add","Z31","W31","1"],["add","Z32","W32","1"],["add","Z33","W33","1"],["add","Z34","W34","1"],["add","Z35","W35","1"],["add","Z36","W36","-1"],["add","Z37","W37","-1"],["add","Z38","W38","1"],["add","Z39","W39","1"],["add","Z40","W40","1"],["add","Z41","W41","1"],["add","Z42","W42","1"],["add","Z43","W43","1"],["add","Z44","W44","1"],["add","Z45","W45","1"],["add","Z46","W46","-1"],["add","Z47","W47","-1"],["add","Z48","W48","1"],["add","Z49","W49","1"],["add","Z50","W50","1"],["add","Z51","W51","1"],["add","Z52","W52","1"],["add","Z53","W53","1"],["add","Z54","W54","1"],["add","Z55","W55","1"],["add","Z56","W56","1"],["add","Z57","W57","-1"],["add","Z58","W58","1"],["add","Z59","W59","1"],["add","Z60","W60","1"],["add","Z61","W61","1"],["add","Z62","W62","1"],["add","Z63","W63","1"],["add","Z64","W64","1"],["add","Z65","W65","1"],["add","Z66","W66","1"],["add","Z67","W67","1"],["add","Z68","W68","1"],["add","Z69","W69","1"],["add","Z70","W70","1"],["add","Z71","W71","1"],["add","Z72","W72","1"],["add","Z73","W73","1"],["add","Z74","W74","1"],["add","Z75","W75","1"],["add","Z76","W76","-1"],["add","Z77","W77","1"],["add","Z78","W78","1"],["add","Z79","W79","1"],["add","Z80","W80","1"],["add","Z81","W81","-1"],["add","Z82","W82","1"],["add","Z83","W83","1"],["add","Z84","W84","1"],["add","Z85","W85","1"],["add","Z86","W86","1"],["add","Z87","W87","-1"],["add","Z88","W88","1"],["add","Z89","W89","1"],["add","Z90","W90","1"],["add","Z91","W91","1"],["add","Z92","W92","-1"],["add","Z93","W93","1"],["add","Z94","W94","1"],["add","Z95","W95","1"],["add","Z96","W96","1"],["add","Z97","W97","1"],["add","Z98","W98","1"],["add","Z99","W99","1"],["add","Z100","W100","1"],["add","Z101","W101","1"],["add","Z102","W102","1"],["add","Z103","W103","1"],["add","Z104","W104","1"],["add","Z105","W105","1"],["add","Z106","W106","1"],["add","Z107","W107","1"],["add","Z108","W108","1"],["add","Z109","W109","1"],["add","Z110","W110","-1"],["add","Z111","W111","-1"],["checkpoint","original_F0_outputs"],["add","W0","Z0","1"],["add","W1","Z1","-1"],["add","W2","Z2","-1"],["add","W3","Z3","-1"],["add","W4","Z4","-1"],["add","W5","Z5","-1"],["add","W6","Z6","-1"],["add","W7","Z7","1"],["add","W8","Z8","-1"],["add","W9","Z9","-1"],["add","W10","Z10","-1"],["add","W11","Z11","-1"],["add","W12","Z12","-1"],["add","W13","Z13","-1"],["add","W14","Z14","-1"],["add","W15","Z15","-1"],["add","W16","Z16","-1"],["add","W17","Z17","-1"],["add","W18","Z18","-1"],["add","W19","Z19","-1"],["add","W20","Z20","1"],["add","W21","Z21","1"],["add","W22","Z22","-1"],["add","W23","Z23","-1"],["add","W24","Z24","-1"],["add","W25","Z25","-1"],["add","W26","Z26","-1"],["add","W27","Z27","1"],["add","W28","Z28","-1"],["add","W29","Z29","-1"],["add","W30","Z30","-1"],["add","W31","Z31","-1"],["add","W32","Z32","-1"],["add","W33","Z33","-1"],["add","W34","Z34","-1"],["add","W35","Z35","-1"],["add","W36","Z36","1"],["add","W37","Z37","1"],["add","W38","Z38","-1"],["add","W39","Z39","-1"],["add","W40","Z40","-1"],["add","W41","Z41","-1"],["add","W42","Z42","-1"],["add","W43","Z43","-1"],["add","W44","Z44","-1"],["add","W45","Z45","-1"],["add","W46","Z46","1"],["add","W47","Z47","1"],["add","W48","Z48","-1"],["add","W49","Z49","-1"],["add","W50","Z50","-1"],["add","W51","Z51","-1"],["add","W52","Z52","-1"],["add","W53","Z53","-1"],["add","W54","Z54","-1"],["add","W55","Z55","-1"],["add","W56","Z56","-1"],["add","W57","Z57","1"],["add","W58","Z58","-1"],["add","W59","Z59","-1"],["add","W60","Z60","-1"],["add","W61","Z61","-1"],["add","W62","Z62","-1"],["add","W63","Z63","-1"],["add","W64","Z64","-1"],["add","W65","Z65","-1"],["add","W66","Z66","-1"],["add","W67","Z67","-1"],["add","W68","Z68","-1"],["add","W69","Z69","-1"],["add","W70","Z70","-1"],["add","W71","Z71","-1"],["add","W72","Z72","-1"],["add","W73","Z73","-1"],["add","W74","Z74","-1"],["add","W75","Z75","-1"],["add","W76","Z76","1"],["add","W77","Z77","-1"],["add","W78","Z78","-1"],["add","W79","Z79","-1"],["add","W80","Z80","-1"],["add","W81","Z81","1"],["add","W82","Z82","-1"],["add","W83","Z83","-1"],["add","W84","Z84","-1"],["add","W85","Z85","-1"],["add","W86","Z86","-1"],["add","W87","Z87","1"],["add","W88","Z88","-1"],["add","W89","Z89","-1"],["add","W90","Z90","-1"],["add","W91","Z91","-1"],["add","W92","Z92","1"],["add","W93","Z93","-1"],["add","W94","Z94","-1"],["add","W95","Z95","-1"],["add","W96","Z96","-1"],["add","W97","Z97","-1"],["add","W98","Z98","-1"],["add","W99","Z99","-1"],["add","W100","Z100","-1"],["add","W101","Z101","-1"],["add","W102","Z102","-1"],["add","W103","Z103","-1"],["add","W104","Z104","-1"],["add","W105","Z105","-1"],["add","W106","Z106","-1"],["add","W107","Z107","-1"],["add","W108","Z108","-1"],["add","W109","Z109","-1"],["add","W110","Z110","1"],["add","W111","Z111","1"],["begin","F0_inverse",16],["clear","F0","wide"],["clear","G0","wide"],["add","F0","Z76","1"],["add","F0","Z81","1"],["add","F0","Z87","1"],["add","F0","Z92","1"],["add","G0","Z0","1"],["add","G0","Z7","1"],["add","G0","Z27","1"],["add","G0","Z57","1"],["clear","F1","wide"],["clear","G1","wide"],["add","F1","Z76","1"],["add","F1","Z81","-1"],["add","F1","Z87","1"],["add","F1","Z92","-1"],["add","G1","Z0","1"],["add","G1","Z7","-1"],["add","G1","Z27","1"],["add","G1","Z57","-1"],["clear","F2","wide"],["clear","G2","wide"],["add","F2","Z76","1"],["add","F2","Z81","-1"],["add","F2","Z87","-1"],["add","F2","Z92","1"],["add","G2","Z0","1"],["add","G2","Z7","-1"],["add","G2","Z27","-1"],["add","G2","Z57","1"],["clear","F3","wide"],["clear","G3","wide"],["add","F3","Z76","-1"],["add","F3","Z81","-1"],["add","F3","Z87","1"],["add","F3","Z92","1"],["add","G3","Z0","1"],["add","G3","Z7","1"],["add","G3","Z27","-1"],["add","G3","Z57","-1"],["clear","F4","wide"],["clear","G4","wide"],["add","F4","Z21","1"],["add","F4","Z37","1"],["add","F4","Z47","1"],["add","F4","Z110","1"],["add","G4","Z20","1"],["add","G4","Z36","1"],["add","G4","Z46","1"],["add","G4","Z111","1"],["clear","F5","wide"],["clear","G5","wide"],["add","F5","Z21","1"],["add","F5","Z37","-1"],["add","F5","Z47","1"],["add","F5","Z110","-1"],["add","G5","Z20","-1"],["add","G5","Z36","1"],["add","G5","Z46","-1"],["add","G5","Z111","1"],["clear","F6","wide"],["clear","G6","wide"],["add","F6","Z21","1"],["add","F6","Z37","1"],["add","F6","Z47","-1"],["add","F6","Z110","-1"],["add","G6","Z20","1"],["add","G6","Z36","1"],["add","G6","Z46","-1"],["add","G6","Z111","-1"],["clear","F7","wide"],["clear","G7","wide"],["add","F7","Z21","-1"],["add","F7","Z37","1"],["add","F7","Z47","1"],["add","F7","Z110","-1"],["add","G7","Z20","-1"],["add","G7","Z36","1"],["add","G7","Z46","1"],["add","G7","Z111","-1"],["add","Z1","F1","1/4"],["add","Z1","F2","1/4"],["add","Z1","F4","-1/4"],["add","Z1","F7","-1/4"],["add","Z2","F0","1/4"],["add","Z2","F1","1/4"],["add","Z2","F6","1/4"],["add","Z2","F7","-1/4"],["add","Z3","F1","1/4"],["add","Z3","F3","1/4"],["add","Z3","F4","-1/4"],["add","Z3","F6","1/4"],["add","Z4","F1","1/4"],["add","Z4","F3","1/4"],["add","Z4","F5","-1/4"],["add","Z4","F7","-1/4"],["add","Z5","F1","1/4"],["add","Z5","F3","1/4"],["add","Z5","F5","1/4"],["add","Z5","F7","-1/4"],["add","Z6","F1","1/4"],["add","Z6","F2","1/4"],["add","Z6","F4","1/4"],["add","Z6","F7","1/4"],["add","Z8","F1","1/4"],["add","Z8","F3","-1/4"],["add","Z8","F4","1/4"],["add","Z8","F6","1/4"],["add","Z9","F0","1/4"],["add","Z9","F1","-1/4"],["add","Z9","F6","-1/4"],["add","Z9","F7","-1/4"],["add","Z10","F0","1/4"],["add","Z10","F1","-1/4"],["add","Z10","F4","-1/4"],["add","Z10","F5","1/4"],["add","Z11","F0","1/4"],["add","Z11","F1","-1/4"],["add","Z11","F4","-1/4"],["add","Z11","F5","-1/4"],["add","Z12","F0","1/4"],["add","Z12","F2","1/4"],["add","Z12","F4","1/4"],["add","Z12","F6","1/4"],["add","Z13","F2","1/4"],["add","Z13","F3","1/4"],["add","Z13","F6","1/4"],["add","Z13","F7","1/4"],["add","Z14","F2","1/4"],["add","Z14","F3","1/4"],["add","Z14","F4","1/4"],["add","Z14","F5","-1/4"],["add","Z15","F2","1/4"],["add","Z15","F3","1/4"],["add","Z15","F4","1/4"],["add","Z15","F5","1/4"],["add","Z16","F2","1/4"],["add","Z16","F3","-1/4"],["add","Z16","F6","1/4"],["add","Z16","F7","-1/4"],["add","Z17","F0","1/4"],["add","Z17","F2","-1/4"],["add","Z17","F4","1/4"],["add","Z17","F6","-1/4"],["add","Z18","F0","1/4"],["add","Z18","F2","-1/4"],["add","Z18","F5","1/4"],["add","Z18","F7","1/4"],["add","Z19","F0","1/4"],["add","Z19","F2","-1/4"],["add","Z19","F5","-1/4"],["add","Z19","F7","1/4"],["add","Z22","F0","1/4"],["add","Z22","F3","-1/4"],["add","Z22","F5","1/4"],["add","Z22","F6","-1/4"],["add","Z23","F0","1/4"],["add","Z23","F3","-1/4"],["add","Z23","F5","-1/4"],["add","Z23","F6","-1/4"],["add","Z24","F0","1/4"],["add","Z24","F3","-1/4"],["add","Z24","F4","-1/4"],["add","Z24","F7","1/4"],["add","Z25","F0","1/4"],["add","Z25","F1","1/4"],["add","Z25","F6","-1/4"],["add","Z25","F7","1/4"],["add","Z26","F1","1/4"],["add","Z26","F3","-1/4"],["add","Z26","F4","-1/4"],["add","Z26","F6","-1/4"],["add","Z28","F1","1/4"],["add","Z28","F2","-1/4"],["add","Z28","F4","-1/4"],["add","Z28","F7","1/4"],["add","Z29","F1","1/4"],["add","Z29","F2","-1/4"],["add","Z29","F5","-1/4"],["add","Z29","F6","-1/4"],["add","Z30","F1","1/4"],["add","Z30","F2","-1/4"],["add","Z30","F5","1/4"],["add","Z30","F6","-1/4"],["add","Z31","F0","1/4"],["add","Z31","F2","1/4"],["add","Z31","F4","-1/4"],["add","Z31","F6","-1/4"],["add","Z32","F0","1/4"],["add","Z32","F3","1/4"],["add","Z32","F4","-1/4"],["add","Z32","F7","1/4"],["add","Z33","F0","1/4"],["add","Z33","F3","1/4"],["add","Z33","F5","-1/4"],["add","Z33","F6","-1/4"],["add","Z34","F0","1/4"],["add","Z34","F3","1/4"],["add","Z34","F5","1/4"],["add","Z34","F6","-1/4"],["add","Z35","F0","1/4"],["add","Z35","F3","-1/4"],["add","Z35","F4","-1/4"],["add","Z35","F7","-1/4"],["add","Z38","F0","1/4"],["add","Z38","F2","-1/4"],["add","Z38","F4","-1/4"],["add","Z38","F6","1/4"],["add","Z39","F0","1/4"],["add","Z39","F2","-1/4"],["add","Z39","F5","-1/4"],["add","Z39","F7","-1/4"],["add","Z40","F0","1/4"],["add","Z40","F2","-1/4"],["add","Z40","F5","1/4"],["add","Z40","F7","-1/4"],["add","Z41","F2","1/4"],["add","Z41","F3","-1/4"],["add","Z41","F4","1/4"],["add","Z41","F5","1/4"],["add","Z42","F2","1/4"],["add","Z42","F3","-1/4"],["add","Z42","F4","1/4"],["add","Z42","F5","-1/4"],["add","Z43","F2","1/4"],["add","Z43","F3","-1/4"],["add","Z43","F6","1/4"],["add","Z43","F7","1/4"],["add","Z44","F2","1/4"],["add","Z44","F3","-1/4"],["add","Z44","F6","-1/4"],["add","Z44","F7","1/4"],["add","Z45","F0","1/4"],["add","Z45","F3","-1/4"],["add","Z45","F4","1/4"],["add","Z45","F7","1/4"],["add","Z48","F0","1/4"],["add","Z48","F3","1/4"],["add","Z48","F4","1/4"],["add","Z48","F7","-1/4"],["add","Z49","F0","1/4"],["add","Z49","F3","1/4"],["add","Z49","F5","1/4"],["add","Z49","F6","1/4"],["add","Z50","F0","1/4"],["add","Z50","F3","1/4"],["add","Z50","F5","-1/4"],["add","Z50","F6","1/4"],["add","Z51","F2","1/4"],["add","Z51","F3","1/4"],["add","Z51","F6","-1/4"],["add","Z51","F7","-1/4"],["add","Z52","F2","1/4"],["add","Z52","F3","1/4"],["add","Z52","F4","-1/4"],["add","Z52","F5","1/4"],["add","Z53","F2","1/4"],["add","Z53","F3","1/4"],["add","Z53","F4","-1/4"],["add","Z53","F5","-1/4"],["add","Z54","F0","1/4"],["add","Z54","F2","1/4"],["add","Z54","F5","1/4"],["add","Z54","F7","-1/4"],["add","Z55","F0","1/4"],["add","Z55","F2","1/4"],["add","Z55","F5","-1/4"],["add","Z55","F7","-1/4"],["add","Z56","F0","1/4"],["add","Z56","F2","1/4"],["add","Z56","F4","-1/4"],["add","Z56","F6","1/4"],["add","Z58","F1","1/4"],["add","Z58","F2","-1/4"],["add","Z58","F4","1/4"],["add","Z58","F7","-1/4"],["add","Z59","F1","1/4"],["add","Z59","F2","-1/4"],["add","Z59","F5","1/4"],["add","Z59","F6","1/4"],["add","Z60","F1","1/4"],["add","Z60","F2","-1/4"],["add","Z60","F5","-1/4"],["add","Z60","F6","1/4"],["add","Z61","F0","1/4"],["add","Z61","F1","-1/4"],["add","Z61","F6","1/4"],["add","Z61","F7","1/4"],["add","Z62","F0","1/4"],["add","Z62","F1","-1/4"],["add","Z62","F4","1/4"],["add","Z62","F5","-1/4"],["add","Z63","F0","1/4"],["add","Z63","F1","-1/4"],["add","Z63","F4","1/4"],["add","Z63","F5","1/4"],["add","Z64","F1","1/4"],["add","Z64","F3","-1/4"],["add","Z64","F5","1/4"],["add","Z64","F7","-1/4"],["add","Z65","F1","1/4"],["add","Z65","F3","-1/4"],["add","Z65","F5","-1/4"],["add","Z65","F7","-1/4"],["add","Z66","F1","1/4"],["add","Z66","F3","-1/4"],["add","Z66","F4","-1/4"],["add","Z66","F6","1/4"],["add","Z67","F1","1/4"],["add","Z67","F3","1/4"],["add","Z67","F4","1/4"],["add","Z67","F6","-1/4"],["add","Z68","F1","1/4"],["add","Z68","F3","1/4"],["add","Z68","F5","1/4"],["add","Z68","F7","1/4"],["add","Z69","F1","1/4"],["add","Z69","F3","1/4"],["add","Z69","F5","-1/4"],["add","Z69","F7","1/4"],["add","Z70","F0","1/4"],["add","Z70","F1","1/4"],["add","Z70","F4","1/4"],["add","Z70","F5","1/4"],["add","Z71","F0","1/4"],["add","Z71","F1","1/4"],["add","Z71","F4","1/4"],["add","Z71","F5","-1/4"],["add","Z72","F0","1/4"],["add","Z72","F1","1/4"],["add","Z72","F6","1/4"],["add","Z72","F7","1/4"],["add","Z73","F1","1/4"],["add","Z73","F2","1/4"],["add","Z73","F5","1/4"],["add","Z73","F6","-1/4"],["add","Z74","F1","1/4"],["add","Z74","F2","1/4"],["add","Z74","F5","-1/4"],["add","Z74","F6","-1/4"],["add","Z75","F1","1/4"],["add","Z75","F2","1/4"],["add","Z75","F4","-1/4"],["add","Z75","F7","1/4"],["add","Z77","F0","1/4"],["add","Z77","F2","-1/4"],["add","Z77","F4","-1/4"],["add","Z77","F6","-1/4"],["add","Z78","F2","1/4"],["add","Z78","F3","1/4"],["add","Z78","F6","1/4"],["add","Z78","F7","-1/4"],["add","Z79","F0","1/4"],["add","Z79","F1","-1/4"],["add","Z79","F6","-1/4"],["add","Z79","F7","1/4"],["add","Z80","F1","1/4"],["add","Z80","F3","1/4"],["add","Z80","F4","1/4"],["add","Z80","F6","1/4"],["add","Z82","F1","1/4"],["add","Z82","F2","1/4"],["add","Z82","F4","1/4"],["add","Z82","F7","-1/4"],["add","Z83","F1","1/4"],["add","Z83","F2","1/4"],["add","Z83","F5","1/4"],["add","Z83","F6","1/4"],["add","Z84","F1","1/4"],["add","Z84","F2","1/4"],["add","Z84","F5","-1/4"],["add","Z84","F6","1/4"],["add","Z85","F0","1/4"],["add","Z85","F3","1/4"],["add","Z85","F4","-1/4"],["add","Z85","F7","-1/4"],["add","Z86","F1","1/4"],["add","Z86","F2","-1/4"],["add","Z86","F4","-1/4"],["add","Z86","F7","-1/4"],["add","Z88","F1","1/4"],["add","Z88","F3","1/4"],["add","Z88","F4","-1/4"],["add","Z88","F6","-1/4"],["add","Z89","F0","1/4"],["add","Z89","F1","1/4"],["add","Z89","F6","-1/4"],["add","Z89","F7","-1/4"],["add","Z90","F0","1/4"],["add","Z90","F1","1/4"],["add","Z90","F4","-1/4"],["add","Z90","F5","1/4"],["add","Z91","F0","1/4"],["add","Z91","F1","1/4"],["add","Z91","F4","-1/4"],["add","Z91","F5","-1/4"],["add","Z93","F1","1/4"],["add","Z93","F2","-1/4"],["add","Z93","F4","1/4"],["add","Z93","F7","1/4"],["add","Z94","F0","1/4"],["add","Z94","F1","-1/4"],["add","Z94","F6","1/4"],["add","Z94","F7","-1/4"],["add","Z95","F1","1/4"],["add","Z95","F3","-1/4"],["add","Z95","F4","1/4"],["add","Z95","F6","-1/4"],["add","Z96","F1","1/4"],["add","Z96","F3","-1/4"],["add","Z96","F5","1/4"],["add","Z96","F7","1/4"],["add","Z97","F1","1/4"],["add","Z97","F3","-1/4"],["add","Z97","F5","-1/4"],["add","Z97","F7","1/4"],["add","Z98","F0","1/4"],["add","Z98","F3","1/4"],["add","Z98","F4","1/4"],["add","Z98","F7","1/4"],["add","Z99","F2","1/4"],["add","Z99","F3","1/4"],["add","Z99","F6","-1/4"],["add","Z99","F7","1/4"],["add","Z100","F0","1/4"],["add","Z100","F2","1/4"],["add","Z100","F4","1/4"],["add","Z100","F6","-1/4"],["add","Z101","F0","1/4"],["add","Z101","F2","1/4"],["add","Z101","F5","1/4"],["add","Z101","F7","1/4"],["add","Z102","F0","1/4"],["add","Z102","F2","1/4"],["add","Z102","F5","-1/4"],["add","Z102","F7","1/4"],["add","Z103","F0","1/4"],["add","Z103","F2","-1/4"],["add","Z103","F4","1/4"],["add","Z103","F6","1/4"],["add","Z104","F2","1/4"],["add","Z104","F3","-1/4"],["add","Z104","F6","-1/4"],["add","Z104","F7","-1/4"],["add","Z105","F2","1/4"],["add","Z105","F3","-1/4"],["add","Z105","F4","-1/4"],["add","Z105","F5","1/4"],["add","Z106","F2","1/4"],["add","Z106","F3","-1/4"],["add","Z106","F4","-1/4"],["add","Z106","F5","-1/4"],["add","Z107","F0","1/4"],["add","Z107","F3","-1/4"],["add","Z107","F4","1/4"],["add","Z107","F7","-1/4"],["add","Z108","F0","1/4"],["add","Z108","F3","-1/4"],["add","Z108","F5","1/4"],["add","Z108","F6","1/4"],["add","Z109","F0","1/4"],["add","Z109","F3","-1/4"],["add","Z109","F5","-1/4"],["add","Z109","F6","1/4"],["add","F0","G0","-1"],["add","F0","Z2","-1"],["add","F0","Z9","-1"],["add","F0","Z10","-1"],["add","F0","Z11","-1"],["add","F0","Z12","-1"],["add","F0","Z17","-1"],["add","F0","Z18","-1"],["add","F0","Z19","-1"],["add","F0","Z22","-1"],["add","F0","Z23","-1"],["add","F0","Z24","-1"],["add","F0","Z25","-1"],["add","F0","Z31","-1"],["add","F0","Z32","-1"],["add","F0","Z33","-1"],["add","F0","Z34","-1"],["add","F0","Z35","-1"],["add","F0","Z38","-1"],["add","F0","Z39","-1"],["add","F0","Z40","-1"],["add","F0","Z45","-1"],["add","F0","Z48","-1"],["add","F0","Z49","-1"],["add","F0","Z50","-1"],["add","F0","Z54","-1"],["add","F0","Z55","-1"],["add","F0","Z56","-1"],["add","F0","Z61","-1"],["add","F0","Z62","-1"],["add","F0","Z63","-1"],["add","F0","Z70","-1"],["add","F0","Z71","-1"],["add","F0","Z72","-1"],["add","F0","Z77","-1"],["add","F0","Z79","-1"],["add","F0","Z85","-1"],["add","F0","Z89","-1"],["add","F0","Z90","-1"],["add","F0","Z91","-1"],["add","F0","Z94","-1"],["add","F0","Z98","-1"],["add","F0","Z100","-1"],["add","F0","Z101","-1"],["add","F0","Z102","-1"],["add","F0","Z103","-1"],["add","F0","Z107","-1"],["add","F0","Z108","-1"],["add","F0","Z109","-1"],["add","F1","G1","-1"],["add","F1","Z1","-1"],["add","F1","Z2","-1"],["add","F1","Z3","-1"],["add","F1","Z4","-1"],["add","F1","Z5","-1"],["add","F1","Z6","-1"],["add","F1","Z8","-1"],["add","F1","Z9","1"],["add","F1","Z10","1"],["add","F1","Z11","1"],["add","F1","Z25","-1"],["add","F1","Z26","-1"],["add","F1","Z28","-1"],["add","F1","Z29","-1"],["add","F1","Z30","-1"],["add","F1","Z58","-1"],["add","F1","Z59","-1"],["add","F1","Z60","-1"],["add","F1","Z61","1"],["add","F1","Z62","1"],["add","F1","Z63","1"],["add","F1","Z64","-1"],["add","F1","Z65","-1"],["add","F1","Z66","-1"],["add","F1","Z67","-1"],["add","F1","Z68","-1"],["add","F1","Z69","-1"],["add","F1","Z70","-1"],["add","F1","Z71","-1"],["add","F1","Z72","-1"],["add","F1","Z73","-1"],["add","F1","Z74","-1"],["add","F1","Z75","-1"],["add","F1","Z79","1"],["add","F1","Z80","-1"],["add","F1","Z82","-1"],["add","F1","Z83","-1"],["add","F1","Z84","-1"],["add","F1","Z86","-1"],["add","F1","Z88","-1"],["add","F1","Z89","-1"],["add","F1","Z90","-1"],["add","F1","Z91","-1"],["add","F1","Z93","-1"],["add","F1","Z94","1"],["add","F1","Z95","-1"],["add","F1","Z96","-1"],["add","F1","Z97","-1"],["add","F2","G2","-1"],["add","F2","Z1","-1"],["add","F2","Z6","-1"],["add","F2","Z12","-1"],["add","F2","Z13","-1"],["add","F2","Z14","-1"],["add","F2","Z15","-1"],["add","F2","Z16","-1"],["add","F2","Z17","1"],["add","F2","Z18","1"],["add","F2","Z19","1"],["add","F2","Z28","1"],["add","F2","Z29","1"],["add","F2","Z30","1"],["add","F2","Z31","-1"],["add","F2","Z38","1"],["add","F2","Z39","1"],["add","F2","Z40","1"],["add","F2","Z41","-1"],["add","F2","Z42","-1"],["add","F2","Z43","-1"],["add","F2","Z44","-1"],["add","F2","Z51","-1"],["add","F2","Z52","-1"],["add","F2","Z53","-1"],["add","F2","Z54","-1"],["add","F2","Z55","-1"],["add","F2","Z56","-1"],["add","F2","Z58","1"],["add","F2","Z59","1"],["add","F2","Z60","1"],["add","F2","Z73","-1"],["add","F2","Z74","-1"],["add","F2","Z75","-1"],["add","F2","Z77","1"],["add","F2","Z78","-1"],["add","F2","Z82","-1"],["add","F2","Z83","-1"],["add","F2","Z84","-1"],["add","F2","Z86","1"],["add","F2","Z93","1"],["add","F2","Z99","-1"],["add","F2","Z100","-1"],["add","F2","Z101","-1"],["add","F2","Z102","-1"],["add","F2","Z103","1"],["add","F2","Z104","-1"],["add","F2","Z105","-1"],["add","F2","Z106","-1"],["add","F3","G3","-1"],["add","F3","Z3","-1"],["add","F3","Z4","-1"],["add","F3","Z5","-1"],["add","F3","Z8","1"],["add","F3","Z13","-1"],["add","F3","Z14","-1"],["add","F3","Z15","-1"],["add","F3","Z16","1"],["add","F3","Z22","1"],["add","F3","Z23","1"],["add","F3","Z24","1"],["add","F3","Z26","1"],["add","F3","Z32","-1"],["add","F3","Z33","-1"],["add","F3","Z34","-1"],["add","F3","Z35","1"],["add","F3","Z41","1"],["add","F3","Z42","1"],["add","F3","Z43","1"],["add","F3","Z44","1"],["add","F3","Z45","1"],["add","F3","Z48","-1"],["add","F3","Z49","-1"],["add","F3","Z50","-1"],["add","F3","Z51","-1"],["add","F3","Z52","-1"],["add","F3","Z53","-1"],["add","F3","Z64","1"],["add","F3","Z65","1"],["add","F3","Z66","1"],["add","F3","Z67","-1"],["add","F3","Z68","-1"],["add","F3","Z69","-1"],["add","F3","Z78","-1"],["add","F3","Z80","-1"],["add","F3","Z85","-1"],["add","F3","Z88","-1"],["add","F3","Z95","1"],["add","F3","Z96","1"],["add","F3","Z97","1"],["add","F3","Z98","-1"],["add","F3","Z99","-1"],["add","F3","Z104","1"],["add","F3","Z105","1"],["add","F3","Z106","1"],["add","F3","Z107","1"],["add","F3","Z108","1"],["add","F3","Z109","1"],["add","F4","G4","-1"],["add","F4","Z1","1"],["add","F4","Z3","1"],["add","F4","Z6","-1"],["add","F4","Z8","-1"],["add","F4","Z10","1"],["add","F4","Z11","1"],["add","F4","Z12","-1"],["add","F4","Z14","-1"],["add","F4","Z15","-1"],["add","F4","Z17","-1"],["add","F4","Z24","1"],["add","F4","Z26","1"],["add","F4","Z28","1"],["add","F4","Z31","1"],["add","F4","Z32","1"],["add","F4","Z35","1"],["add","F4","Z38","1"],["add","F4","Z41","-1"],["add","F4","Z42","-1"],["add","F4","Z45","-1"],["add","F4","Z48","-1"],["add","F4","Z52","1"],["add","F4","Z53","1"],["add","F4","Z56","1"],["add","F4","Z58","-1"],["add","F4","Z62","-1"],["add","F4","Z63","-1"],["add","F4","Z66","1"],["add","F4","Z67","-1"],["add","F4","Z70","-1"],["add","F4","Z71","-1"],["add","F4","Z75","1"],["add","F4","Z77","1"],["add","F4","Z80","-1"],["add","F4","Z82","-1"],["add","F4","Z85","1"],["add","F4","Z86","1"],["add","F4","Z88","1"],["add","F4","Z90","1"],["add","F4","Z91","1"],["add","F4","Z93","-1"],["add","F4","Z95","-1"],["add","F4","Z98","-1"],["add","F4","Z100","-1"],["add","F4","Z103","-1"],["add","F4","Z105","1"],["add","F4","Z106","1"],["add","F4","Z107","-1"],["add","F5","G5","-1"],["add","F5","Z4","1"],["add","F5","Z5","-1"],["add","F5","Z10","-1"],["add","F5","Z11","1"],["add","F5","Z14","1"],["add","F5","Z15","-1"],["add","F5","Z18","-1"],["add","F5","Z19","1"],["add","F5","Z22","-1"],["add","F5","Z23","1"],["add","F5","Z29","1"],["add","F5","Z30","-1"],["add","F5","Z33","1"],["add","F5","Z34","-1"],["add","F5","Z39","1"],["add","F5","Z40","-1"],["add","F5","Z41","-1"],["add","F5","Z42","1"],["add","F5","Z49","-1"],["add","F5","Z50","1"],["add","F5","Z52","-1"],["add","F5","Z53","1"],["add","F5","Z54","-1"],["add","F5","Z55","1"],["add","F5","Z59","-1"],["add","F5","Z60","1"],["add","F5","Z62","1"],["add","F5","Z63","-1"],["add","F5","Z64","-1"],["add","F5","Z65","1"],["add","F5","Z68","-1"],["add","F5","Z69","1"],["add","F5","Z70","-1"],["add","F5","Z71","1"],["add","F5","Z73","-1"],["add","F5","Z74","1"],["add","F5","Z83","-1"],["add","F5","Z84","1"],["add","F5","Z90","-1"],["add","F5","Z91","1"],["add","F5","Z96","-1"],["add","F5","Z97","1"],["add","F5","Z101","-1"],["add","F5","Z102","1"],["add","F5","Z105","-1"],["add","F5","Z106","1"],["add","F5","Z108","-1"],["add","F5","Z109","1"],["add","F6","G6","-1"],["add","F6","Z2","-1"],["add","F6","Z3","-1"],["add","F6","Z8","-1"],["add","F6","Z9","1"],["add","F6","Z12","-1"],["add","F6","Z13","-1"],["add","F6","Z16","-1"],["add","F6","Z17","1"],["add","F6","Z22","1"],["add","F6","Z23","1"],["add","F6","Z25","1"],["add","F6","Z26","1"],["add","F6","Z29","1"],["add","F6","Z30","1"],["add","F6","Z31","1"],["add","F6","Z33","1"],["add","F6","Z34","1"],["add","F6","Z38","-1"],["add","F6","Z43","-1"],["add","F6","Z44","1"],["add","F6","Z49","-1"],["add","F6","Z50","-1"],["add","F6","Z51","1"],["add","F6","Z56","-1"],["add","F6","Z59","-1"],["add","F6","Z60","-1"],["add","F6","Z61","-1"],["add","F6","Z66","-1"],["add","F6","Z67","1"],["add","F6","Z72","-1"],["add","F6","Z73","1"],["add","F6","Z74","1"],["add","F6","Z77","1"],["add","F6","Z78","-1"],["add","F6","Z79","1"],["add","F6","Z80","-1"],["add","F6","Z83","-1"],["add","F6","Z84","-1"],["add","F6","Z88","1"],["add","F6","Z89","1"],["add","F6","Z94","-1"],["add","F6","Z95","1"],["add","F6","Z99","1"],["add","F6","Z100","1"],["add","F6","Z103","-1"],["add","F6","Z104","1"],["add","F6","Z108","-1"],["add","F6","Z109","-1"],["add","F7","G7","-1"],["add","F7","Z1","1"],["add","F7","Z2","1"],["add","F7","Z4","1"],["add","F7","Z5","1"],["add","F7","Z6","-1"],["add","F7","Z9","1"],["add","F7","Z13","-1"],["add","F7","Z16","1"],["add","F7","Z18","-1"],["add","F7","Z19","-1"],["add","F7","Z24","-1"],["add","F7","Z25","-1"],["add","F7","Z28","-1"],["add","F7","Z32","-1"],["add","F7","Z35","1"],["add","F7","Z39","1"],["add","F7","Z40","1"],["add","F7","Z43","-1"],["add","F7","Z44","-1"],["add","F7","Z45","-1"],["add","F7","Z48","1"],["add","F7","Z51","1"],["add","F7","Z54","1"],["add","F7","Z55","1"],["add","F7","Z58","1"],["add","F7","Z61","-1"],["add","F7","Z64","1"],["add","F7","Z65","1"],["add","F7","Z68","-1"],["add","F7","Z69","-1"],["add","F7","Z72","-1"],["add","F7","Z75","-1"],["add","F7","Z78","1"],["add","F7","Z79","-1"],["add","F7","Z82","1"],["add","F7","Z85","1"],["add","F7","Z86","1"],["add","F7","Z89","1"],["add","F7","Z93","-1"],["add","F7","Z94","1"],["add","F7","Z96","-1"],["add","F7","Z97","-1"],["add","F7","Z98","-1"],["add","F7","Z99","-1"],["add","F7","Z101","-1"],["add","F7","Z102","-1"],["add","F7","Z104","1"],["add","F7","Z107","1"],["clear","Z0","wide"],["add","Z0","F0","1/4"],["add","Z0","F1","1/4"],["add","Z0","F2","1/4"],["add","Z0","F3","1/4"],["clear","Z7","wide"],["add","Z7","F0","1/4"],["add","Z7","F1","-1/4"],["add","Z7","F2","-1/4"],["add","Z7","F3","1/4"],["clear","Z20","wide"],["add","Z20","F4","1/4"],["add","Z20","F5","-1/4"],["add","Z20","F6","1/4"],["add","Z20","F7","-1/4"],["clear","Z27","wide"],["add","Z27","F0","1/4"],["add","Z27","F1","1/4"],["add","Z27","F2","-1/4"],["add","Z27","F3","-1/4"],["clear","Z36","wide"],["add","Z36","F4","1/4"],["add","Z36","F5","1/4"],["add","Z36","F6","1/4"],["add","Z36","F7","1/4"],["clear","Z46","wide"],["add","Z46","F4","1/4"],["add","Z46","F5","-1/4"],["add","Z46","F6","-1/4"],["add","Z46","F7","1/4"],["clear","Z57","wide"],["add","Z57","F0","1/4"],["add","Z57","F1","-1/4"],["add","Z57","F2","1/4"],["add","Z57","F3","-1/4"],["clear","Z111","wide"],["add","Z111","F4","1/4"],["add","Z111","F5","1/4"],["add","Z111","F6","-1/4"],["add","Z111","F7","-1/4"],["clear","Z21","wide"],["add","Z21","G4","1/4"],["add","Z21","G5","1/4"],["add","Z21","G6","1/4"],["add","Z21","G7","-1/4"],["clear","Z37","wide"],["add","Z37","G4","1/4"],["add","Z37","G5","-1/4"],["add","Z37","G6","1/4"],["add","Z37","G7","1/4"],["clear","Z47","wide"],["add","Z47","G4","1/4"],["add","Z47","G5","1/4"],["add","Z47","G6","-1/4"],["add","Z47","G7","1/4"],["clear","Z76","wide"],["add","Z76","G0","1/4"],["add","Z76","G1","1/4"],["add","Z76","G2","1/4"],["add","Z76","G3","-1/4"],["clear","Z81","wide"],["add","Z81","G0","1/4"],["add","Z81","G1","-1/4"],["add","Z81","G2","-1/4"],["add","Z81","G3","-1/4"],["clear","Z87","wide"],["add","Z87","G0","1/4"],["add","Z87","G1","1/4"],["add","Z87","G2","-1/4"],["add","Z87","G3","1/4"],["clear","Z92","wide"],["add","Z92","G0","1/4"],["add","Z92","G1","-1/4"],["add","Z92","G2","1/4"],["add","Z92","G3","1/4"],["clear","Z110","wide"],["add","Z110","G4","1/4"],["add","Z110","G5","-1/4"],["add","Z110","G6","-1/4"],["add","Z110","G7","-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"],["clear","G0","identity"],["clear","G1","identity"],["clear","G2","identity"],["clear","G3","identity"],["clear","G4","identity"],["clear","G5","identity"],["clear","G6","identity"],["clear","G7","identity"],["end","F0_inverse",16],["add","W0","Z0","-1"],["add","W7","Z7","-1"],["add","W20","Z20","-1"],["add","W27","Z27","-1"],["add","W36","Z36","-1"],["add","W46","Z46","-1"],["add","W57","Z57","-1"],["add","W111","Z111","-1"],["add","W21","Z21","-1"],["add","W37","Z37","-1"],["add","W47","Z47","-1"],["add","W76","Z76","-1"],["add","W81","Z81","-1"],["add","W87","Z87","-1"],["add","W92","Z92","-1"],["add","W110","Z110","-1"]] diff --git a/research/qq16-caller-install/inputs/PR4114-README.md b/research/qq16-caller-install/inputs/PR4114-README.md new file mode 100644 index 0000000000..cc4743dd9d --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4114-README.md @@ -0,0 +1,94 @@ +# Intermediate magnitudes on one F0 dirty-helper ray + +**Scoped scalar ledger. No new exponent.** + +On the common-chart scalar projection of the literal reviewed `programs.F_0` +word, the initial state `L359 = T` (every data and private register zero) +reaches intermediate coefficient **128T in data register L103** and **68T in +helper L609**. The same word then restores that input exactly. The published +cut used by the restoration-preserving fault is only **4T**. Selected κ stays +`0.001672660197076918`. + +This is the intermediate ledger asked for by one ray. It is not a bound for +every dirty helper, not a Hilbert-norm certificate, and not an F17 consumer bill. + +## Statement + +Expand `programs.F_0` exactly as the scalar fault audit does: 26,099 events, +of which 21,025 are scalar. Non-scalar events do not change this projection. +Coefficients below are for `T = 1`; the word is linear and homogeneous, so the +`T` ray is the same scan multiplied by `T`. + +| Class | Peak absolute coefficient | First attained | Gate, frame annotation | +| --- | ---: | --- | --- | +| Data `L0..L223` | 128 | after event 24280, `L103 = -128` | `L103 += 64 L354`, annotation `1` | +| Helpers `L224..L703` | 68 | after event 24338, `L609 = 68` | `L609 += -34 L354`, annotation `1` | +| Private `C0..C7` | 0 | — | never written on this ray | + +Immediately before the data-peak add, `L103 = -64` and `L354 = -1`. A relative +destination defect `u(|d| + |c| |s|)` at that add therefore has allowance +**128 u T**. The coefficient `-128` then sits only in `L103` across the next +154 scalar states. At the published fault index 24438 the pre-state is still +`L39 = -4`, `L359 = 1`, and the final state is exactly the input. + +The data ray `L112 = 1` is the control. Its largest absolute coefficient is 1, +every helper and private register stays 0, and it also restores exactly. At +event 24438 that ray contributes nothing to `L39` or `L359`. + +A unit injection into `L103` after event 24280 does **not** preserve helper +restoration. Its final image has 78 nonzero data fields, maximum `1/16`, and +71 nonzero helpers, maximum `17/32`. The published fault at event 24438 is a +different site: there the helpers restore and the completed data factor is +`4 u T`. The intermediate peak does not replace that necessary reserve. + +## What this does not say + +`||F|| <= 58` in the #2965 completed-output contract is a bound on the finished +data map. An intermediate register coefficient 128 does not contradict it. +Frame annotation `1` is the word's label at the two peak adds. This package +does not load native frame vectors, so it does not promote 128T or 68T to +payload Hilbert norms. Exact execution of this ray has completed data error 0; +the peak is not an exhibited rounding failure. + +Open [PR #3552](https://github.com/CrocSwap/integer-mult-bounds/pull/3552) +compares four stored final magnitudes with the #2965 tolerance and does not +replay intermediate states. The scalar-projection digest here equals that +package's published `scalar_projection_sha256`. + +## Reproduce + +From the repository root, CPython 3.12: + +```sh +python3.12 -B research/qq16-f0-dirty-ray-magnitude/verify.py +python3.12 -B research/qq16-f0-dirty-ray-magnitude/test_verify.py +python3.12 -B scripts/research_package.py --package research/qq16-f0-dirty-ray-magnitude +``` + +`verify.py` is read-only. Dense lists and sparse dictionaries are separate +forward scans; both must report the same peaks, cut and final state. The tests +use a three-operation synthetic word and change the peak coefficient from 64 +to 63. The full literal scan takes well under a minute. + +## Open next questions + +1. Do the frame annotations `1` at events 24280 and 24338 denote the constant + payload vector, so the Hilbert norms are exactly 128T and 68T? The native + dirty-fault package already checks frame 1's canonical vector on its own + witness; this ledger does not. +2. Is register 359 special, or does another helper force an intermediate data + coefficient at least this large? A uniform dirty range has to cover the + worst ray. Only this ray was scanned. + +## Credit + +The literal F0 word and scalar projection are the reviewed joint-query +program. Arham Tahir's `qq16-producer-dirty-fault` package supplies the +expansion, the cut `(-4, 1)`, and the final-defect formula this ledger does +not replace. Nick Petalas's #2965 contract supplies the completed-output norm +`||F|| <= 58` and the open producer-interior question. Ali Romman and the +joint-query lineage retain the program. Tekalign's native binding is the +frame-vector predecessor named above and is not replayed here. + +Prepared by unpaidmoon, with substantial assistance from Grok 4.7 in Cursor. +Apache-2.0. No independent human review is claimed. diff --git a/research/qq16-caller-install/inputs/PR4129-COST.md b/research/qq16-caller-install/inputs/PR4129-COST.md new file mode 100644 index 0000000000..989da4b71d --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4129-COST.md @@ -0,0 +1,273 @@ +# Recursive height promotion and a compatible complete bill + +This ledger separates the new conditional callback implementation from the +unchanged global QQ16 supplier problem. The rank-one child is the exact +recursive `Machine` of `research/physical-complex-controller`, rather than +PR4109's coordinate Gaussian reference. Its mathematical refinement, selected +native identities, ordinary B1/C0 backend, chronological hosting and long-record +premises remain inherited. The adapter must establish its literal physical +entry and return; the arithmetic below alone does not execute that adapter. + +## One callback and its precision + +Use the first frozen PR4106 event `['line','W0',0,1]` as the discriminating +instance. Every line has the same tensor width lambda; signed monomial recipes +surround one positive C tensor. Let `t=lambda-1`. PR4109's authenticated +whole-caller exact-grid theorem supplies + +``` +q_c = h 2^(-9-3t), W_c = P+28+6t. +``` + +At every callback entry, the encoded integer components have strict magnitude +less than `2^(W_c-1)`. This permits arbitrary correlations; it imposes no +independence or stochastic-rounding assumption. PR4109 supplies the same +coarse format for every completed signed child output, not merely the final +224 recovered outputs. + +The actual inherited controller's `PROOF.md`, **Inventory, height, time and +space**, gives + +``` +Gamma = 2^1296 product(i=1..36)(2^(2i)-1), +s = 1041408 Gamma, E=2^100000, B=s+E, +A(e) <= 2 B e. +``` + +Here A is an elementary coefficient-height/denominator bound. Its scalar +microinstructions are additions, signs, exact halves and powers of two; +address permutations introduce no coefficient height. The proof charges +completed earlier children by their completed widths and at most one +unfinished recursive child by its full internal height. It derives +`A(e)<=A(48 floor(e/73))+s floor(e/73)+E` internally and `A(e)<=8e` +at leaves. We use this inherited theorem, not a finite-depth extrapolation. + +Use the sharper inherited leaf bound `a=8lambda` when the literal predicate +`lambda<73 or lambda^1000= W_req. +``` + +Promotion writes a low zero block of length a, the W_c coarse bits, then +H-W_c-a sign bits. Projection checks all surplus high bits as well as the +a low bits. All callbacks execute at H, with the original global p,d,K,G, +compact fields and long-record descriptors. Thus the actual physical width, +Compact admission and coefficient-volume accounting remain the inherited +ones; their validity is not deduced from big-O notation. + +Here is a sufficient explicit entry subdomain. If +`P<=p+4Bd+1`, `lambda<=d`, and d>=1, then + +``` +W_req <= p+(8B+6)d+24 < p+2C0d+3 = H. +``` + +Indeed `Gamma<2^2628`, `s<2^2648`, `B<2^100001`, and the exact integer +inequality `8B+26<2C0` implies the even integer `2C0-8B-6` is at +least 22, so `(2C0-8B-6)d>21`. The code checks that +constant inequality exactly. Inputs of source height at most 2Bd admit the +entry representation `h=2^(-p-2Bd)`, `P=p+4Bd+1`. The extra bit makes the coarse input bound strict even +when the source height bound is attained: `2^(2Bd)<2^(2Bd+1)`. This is +an explicit compatible entry subdomain. It does **not** prove that the actual +QQ16 F0/B1 producer supplies that height or that the selected parent already +has spare height for an inserted decoder. + +Small numerical fixtures may choose H=W_req in their explicitly reduced +backend domain. They do not instantiate the production Compact or global +width parameters and must not be presented as production-width execution. + +The outer root's normalized Hadamard/truncating interface is not used as a +C callback. The exact internal Machine entry is the relevant interface. + +## Row stock and the actual admitted parent + +The physical parent after its individually handled remainder has width +`73 lambda`, row count R and divisor `L=14336 Gamma`. It already carries +complete compact ranges, spectator ranges, spacing K and the source global +parameters. A rank-one child descriptor is + +``` +width' = lambda, rows' = U=R/L, +after' = after+72 lambda K, +``` + +with all global parameters unchanged. These are literal `prepare_child` +assignments, not an inferred allocation from a logical array dimension. +Let `D0(e)=0` for e<73 and otherwise +`D0(e)=1+D0(48 floor(e/73))`. D0 is monotone by induction. Therefore + +``` +D0(lambda) <= D0(48lambda) = D0(73lambda)-1. +``` + +If the admitted parent has `L^D0(73lambda) | R`, then +`L^D0(lambda) | U`. Sequential calls reuse U; they do not multiply the +reservation by 224. The child capsule already includes the 72lambda K +spectator bits and complete compact fields. The minimal logical reference +volume `2^(73lambda)` is not its actual bit volume. + +A standalone bank with only a power-of-two row count is not automatically an +admitted Machine input: L has a factor seven. This is a rejection control +against inventing row stock, not an obstruction to the source-bound parent. +Adding fresh rows, treating existing spectator axes as rows or padding a bare +packet requires its own complete semantic and physical bill. The primary +connection reuses the admitted parent's existing reservation. + +## Charges, storage and comparable boundaries + +The frozen PR4106 census is 224 rank-one children, 448 monomial wrappers, +352 full-cover maps, 1,820 unit ADDs, 896 quarter ADDs and 416 CLEARs. Its +scalar allowance is `8*1820+12*896+2*416=26144`. These are exact occurrence +counts. They are not physical times or global paid-profile coefficients. + +Write `v_j` for the complete actual packet bit volume at callback j after +promotion; it includes rows, spectators, all coefficient fields and the actual H. +A complete symbolic physical bill is + +``` +sum(j=1..224) T_C(lambda,v_j;p,d,K,H,global descriptors) + + 448 T_monomial + 352 T_cover + + 1820 T_unit + 896 T_quarter + 416 T_clear + + T_promote + T_project + T_external_continuation + T_retire. +``` + +Each term uses its matching widths, packets and chronology. T_C includes its +own internal parking, native work, copying, cleanup and protected return; these +must not be added a second time. External continuation/retirement names only +work outside that inherited callback. Unknown terms are not zero. Literal +ownership/layout evidence must decide which additional terms are needed. + +Promotion reads the entire coarse packet and writes H bits per component, +including the two new blocks. Projection reads the entire wide result, +checks its low and high blocks and writes W_c bits per component. Each is +O(v_j), including rewinds and erased owned temporaries under a proper stream +implementation. These are extra paid passes. This ledger does not assert that +an unimplemented Python integer shift has that physical tariff. + +An isolated wide backend can be reused sequentially while the caller's other +banks remain on separate protected storage. Its occupied/visited space is +`O_q(v_max)+F_q` under the inherited backend contract, plus the complete +coarse caller and its retained source/output copies. Promotion and projection +add O(v_max) space, not 224 simultaneous wide packets. The inherited +controller has `2q^2+100696823` fixed physical tapes plus eight caller ports; +this is not a six-tape implementation. Source-local logical private peak16 +and the physical tape inventory measure different things. Erased work is +not a promise that a Python emulator releases backing allocation. + +The decoder's owned output banks and private arrays also require an actual +outer lifetime contract. The 704 persistent F0 producer fields include dirty +helpers whose return obligations remain live. Their existence does not grant +224 free clean output banks. A fresh isolated output/work inventory may be a +fixed constant enlargement; its occupied volume, acquisition, clearing and +retirement must nevertheless be accounted for. + +The physical controller stops at `e<73 or e^1000=W_req must hold independently; a replacement +O(p) width alone would not establish this implication. + +## What improvement is and is not established + +PR4015 and PR4106 have the same 224 signed child occurrences, wrapper and map +counts and complete output/borrowed-state boundary. Use the same promoted +backend, admitted callback width H, coarse caller width and conversion protocol +for both. The prescribed +native/conversion bounds are equal. PR4106 removes exactly 100 whole-field +unit additions; at a fixed full bank of N complex coordinates this is +200N real-component additions. All other physical costs must be compared +using an actual compatible schedule; differing temporary addresses or +reordered callbacks are not assumed cost-free. The 800 logical allowance +advantage is a separate unit from this numerical count. + +The complete selected moment is `sum n_r(r/73)^(1-a)/W` with its proved +coverage/usage coefficients. The 224 calls here contribute a local +`224(1/73)^(1-a)` before that coefficient. Refining them with an actual +recursive implementation does not create a negative global charge. No +selected idle work is certified removed by this adapter. The earlier +separate-consumer, common-frame and bridge investigations keep their scope +and credit; their missing continuation credits are not silently discharged. + +The material enabling implication is narrower: an exact-grid callback can +admit the real recursive interior by explicit temporary precision promotion +and return exactly to the caller grid, with a common width and paid conversion +for the two recovery words. Complete decoder placement and the consumer's +budget are distinct remaining implications. Neither a new global profile nor +an improved selected kappa follows from this ledger. + +`feasibility.py` independently recounts the frozen word, proves the finite +constant comparisons with exact integers, checks stock induction instances, +and exercises signed lift/project controls and strict component bounds. The +written induction carries the all-depth claim. It imports no predecessor +executable. Finite checks are not a proof-kernel or physical execution claim. + +Credit Jose Manuel/jmbarrancoml for the physical controller and Gaussian leaf, +PR2287 and the selected native/ordinary/hosting lineage for its underlying +recursive contract, PR4015/4106 for the two exact words, and PR4109's range +and rounding authors for the coarse endpoint format. All proof hypotheses +retain their original scope. This integration is AI-assisted. diff --git a/research/qq16-caller-install/inputs/PR4129-NATIVE.md b/research/qq16-caller-install/inputs/PR4129-NATIVE.md new file mode 100644 index 0000000000..c0133ac0e7 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4129-NATIVE.md @@ -0,0 +1,195 @@ +# Binding QQ16 lines to the physical recursive C machine + +This is a source-relative construction contract. It uses the actual +`physical-complex-controller` descriptor, parking and return implementation, +not a coordinate Gaussian loop assigned the recursive price. Its retained +all-size refinement, selected native/common-label identities, chronological +hosting and ordinary B1/C0 backend remain hypotheses. No production O(73,2) +payload or GL64 factory has been executed for this contribution. + +## Literal boundary and the three event variants + +At frozen PR4106 event 4 the instruction is `line W0 0 +1`. Events 2 and 3 +are `CLEAR W0 hole0` and `W0 += Y0`. The input is therefore an owned copy +of the current borrowed Y0 value, in physical frame F17 C_q^-1. The positive +line returns W0 in F17. Arbitrary original dirt in W0 has been removed by the +charged clear. There is no permission to write borrowed Y0. + +The complete 224-event inventory has three classes: + +* 112 positive initial normalizations on W0 through W111; +* 104 negative streamed query normalizations on Z10/Z11; +* eight positive response conversions on Z10. + +All native calls are outside the scalar F/G private scopes. Their operand +values and correlations can be arbitrary within the caller's admitted entry +range and grid. The signed recipes inherited from the frozen native proof +use a right monomial, a positive rank-one C child and a left monomial; the +negative sign includes the necessary output XOR. That XOR is part of the +paid wrapper. The middle operator at tensor depth lambda is C^{tensor lambda} +on lambda selected directions, with identity on the other directions. +No inverse of a state-clearing producer is used. + +## Actual physical caller, including its existing spectators + +The physical selected controller has 73 active directions per local factor, +14,336 families and the actual orthogonal cover of cardinality Gamma. Its +group gather obtains complete current owner packets in the layout + +``` +[P][U][front][H][H][before][73 lambda K][after][H][back][r Gaussian fields]. +``` + +Here K, H, the surrounding complete fields, r and the encoded global root +width d come from the already admitted physical parent. They are not inferred +from the logical reference size 2^{73 lambda}. `BankPackets.gather` preserves +the current bank, selects the source-bound family/cover keys and copies the +entire within-row packet. The complete replacement is committed only after +the local group returns. + +In particular the existing active field already has the K spacing between +selected bits. Treating the logical size as the entire physical allocation +would erase real parent inputs and give an inapplicable padding obstruction. +Conversely an isolated minimal 73 lambda-bit reference cannot simply claim +these extra parent fields. The theorem below starts at the physical parent's +prepared packet boundary. + +Write L=14336 Gamma and define the conservative source recursion depth + +``` +D0(e)=0 if e<73, +D0(e)=1+D0(48 floor(e/73)) otherwise. +``` + +The physical root construction supplies row stock divisible by L^{D0(d)} +after its explicit reservation and less-than-two row padding. At subsequent +nodes the same invariant holds with their active width. This is an existing +paid root preparation; it is not rerun or treated as new free work here. + +## Capsule inheritance theorem + +Fix positive integer lambda, an admitted physical parent after remainder +processing with width e=73 lambda, root width d>=e and row count R divisible +by L^{D0(e)}. Keep its actual K, H, front/before/after/back fields, coefficient +count and common grid. At the local owner packet let U=R/L. + +For any of the 224 rank-one events, the source `prepare_child(target,1)` +constructs the descriptor + +``` +child.width = lambda +child.rows = U +child.after = parent.after + 72 lambda K +``` + +and copies every other descriptor unchanged. It preserves the complete packet +volume because + +``` +before + 73 lambda K + after + = before + lambda K + (after + 72 lambda K). +``` + +There is no fresh copy of an absent spectator, no missing owner slice, and no +division by a logical payload size. The right native monomial has already +put the selected rank-one direction first; the left monomial restores its +source recipe after return. + +The integer function D0 is nondecreasing. This follows by induction because +floor(e/73), multiplication by 48, and addition of one preserve order, while +the recursive argument is strictly smaller than e for e>=73. Therefore + +``` +D0(lambda) <= D0(48 lambda) = D0(73 lambda)-1. +``` + +Consequently L^{D0(lambda)} divides U. Every internal recursive division of +this child has sufficient exact stock. This proves the implication for all +positive lambda, rather than extrapolating from finite depths. The stopping +test `lambda<73 or lambda^1000=1, t=lambda-1, P>=0 be integers and h=2^z, z integer. Use the +unchanged PR4106 word and its PR4109 entry domain: each real/imaginary component +of the224 borrowed current X/Y arrays is in hZ and has magnitude<2^P h. +The224 owned Z/W outputs may initially be dirty; charged CLEARs precede their +reads. All224 outputs are required in F17, borrowed X/Y values and frames +remain unchanged, and the scalar private peak16 remains inherited. No T-port +or inverse-prefix contribution is removed. + +In addition, a callback must receive a **prepared actual packet** of the +retained physical controller. Its parent has active width73lambda, root width +d>=73lambda, source global p,d,K,G,H_g, complete compact and spectator fields, +long Gaussian records and sufficient row stock. These fields are already part +of the admitted parent; the logical reference size2^(73lambda) cannot supply +them by itself. The caller supplies valid encoded descriptors and distinct +borrowed input/protected output ports. A separately closed backend and a +separate wrapper ordinary inventory are exclusive to this bridge. They do not +alias any live caller query, output or dirty productive helper. + +All retained backend hypotheses remain: selected native/common-label identities, +chronological hosting, ordinary B1/C0 interchange, Compact admission and the +source-relative all-size refinement. We preserve the admitted `component_bits` +Count H_b and all geometry descriptors. An actual caller must still establish +that its QQ16 values occupy these packets and that its output banks are leased. +This theorem starts at that explicit boundary; it is not evidence that the +current selected compiler already invokes D_4106. + +## 1. Bind every actual signed occurrence + +The first literal line is event4, `line W0 0 +1`, immediately after the owned +W0 clear and copy of borrowed Y0. Its normal q is11. The first negative is +event1705 on Z10/port76/q448. The old q19 negative witness is not this first +new event. + +There are112 initial positive W normalizations,104 negative query +normalizations and8 positive response conversions:120 positive/104 negative, +224 total, all outside scalar-private scopes. The216 distinct port/sign recipes +are authenticated against the canonical native receipt. For nonzero q, let B_q +have first column q and the ordinary basis columns excluding its pivot. The +right monomial is B_q^-1; the left is B_q with offset0 for positive sign and +q for negative sign. New `signed_recipe` emits actual `MonomialPackets` literal +dictionaries, with identity on coordinates9..72 and no uncharged phase. + +Both inverse orders and every canonical column are checked. The512-column +signed identity per occurrence, followed by the independent tensor-product +extension, proves all lambda factors. It is not a sampled-depth assertion. +`MonomialPackets.select` accepts this finite GL/affine geometry using its actual +universal affine alphabet; its physical execution and Compact premises are +inherited. Both wrappers remain paid. Owner-cover maps remain separate352 +operations; the native bridge does not silently implement their routes. + +## 2. Inherit a real recursive capsule + +Let Gamma=2^1296 product(i=1..36)(2^(2i)-1) and L=14336Gamma. Set + +``` +D0(e)=0 for e<73, +D0(e)=1+D0(48 floor(e/73)) otherwise. +``` + +At an admitted parent e=73lambda with L^D0(e) dividing R, the actual +`prepare_child(target,1)` supplies widthlambda, rows U=R/L and +`after'=after+72lambda K`. Every other descriptor is inherited. Consequently +`before+73lambda K+after = before+lambda K+after'`: the complete packet volume +is unchanged, including all existing passive fields. + +D0 is nondecreasing by strong induction on its strictly contracting recursive +argument. Thus D0(lambda)<=D0(48lambda)=D0(73lambda)-1, and +L^D0(lambda) divides U. The global cutoff `e<73 or e^1000=W_req`. Promote each little-endian signed coarse integer by writing a +low zero block of length a, copying W_c bits and writing H_b-W_c-a copies of +its sign bit. This is a source-preserving bit-stream operation. It changes the +interpreted quantum to q_w, not the geometry or the component-width Count. +Thus the Compact/ordinary width assumptions remain those of the same admitted +backend. An asymptotic O(p) estimate alone would not establish this admission. + +A useful sufficient subdomain is `P<=p+4Bd+1`, lambda<=d. Then +`W_req<=p+(8B+6)d+24 < p+2C0d+3=H_b`. The exact integer check +`8B+26<2C0` gives an even gap `2C0-8B-6>=22`, proving the last strict +inequality for d>=1. An inherited height<=2Bd entry can be expressed with +h=2^-(p+2Bd), P=p+4Bd+1; the added1 preserves PR4109's strict entry bound. +This is an explicit compatible entry domain, not a newly proved QQ16 producer +height or cut mapping. + +## 4. Exact return with no accumulating precision debt + +The exact backend returns T_lambda. The paid signed wrappers give the canonical +signed q tensor. Since this is exactly the same completed operator as the +unchanged caller theorem, its completed value is again on q_c and fits W_c. +Check every one of the a low bits for zero and every surplus high bit for the +retained sign. Only then copy the W_c middle bits to the protected coarse output. +Nonzero discarded bits or incompatible high bits reject; no rounding occurs. + +This proves completed native error nu=0 on this prepared ABI, conditional on +the retained exact backend refinement. After every callback, the external +representation is again q_c,W_c. The next call starts from that coarse state; +a is a reusable working reserve, not224a accumulated precision. Absolute caller +correctness still requires the unchanged word's authenticated endpoint/frame +proof and actual input/caller mapping. A floating approximate callback cannot +use this return argument automatically. + +## 5. Implement and pay the encoding protocol + +`bridge.py` executes the lift and projection with the actual source Tape API: +reads, writes and unit moves only. Payload bits never enter an unbounded host +integer. The immutable pattern uses three finite symbols disjoint from the +source bit/marker alphabet. Unary width/reserve/high descriptors are paid +inputs; `unary_from_count` constructs them with the actual encoded Count +countdown and its amortized ripple protocol. Descriptor arithmetic computing +a and the surplus remains a separately charged encoded setup step. + +The pattern has a LOW cells, W_c COPY cells and b=H_b-W_c-a HIGH cells. Its +setup checks b>=a+1 without decoding a variable length. A scan emits/validates +one component, rewinds the pattern and repeats; a finite parity flag requires +complete real/imaginary pairs. Only the last sign bit is retained in finite +control. Setup failure erases a partial pattern and returns borrowed descriptor +heads. Runtime failure erases partial output and returns source/pattern heads. +A protected output must be consumed before reuse. Closing erases the pattern. + +For m real/imaginary components, each pattern traversal is H_b unit positions. +Promotion traverses mW_c source cells; projection traverses mH_b source cells. +Outputs, complete rewinds, protected-return erasures and pattern retirement are +linear in these extents. A conservative finite-state bound for the conversion +body, including setup/close, is + +``` +64 [m H_b+H_b+W_c+a+b+1] literal cell actions. +``` + +This bound grants unused slack for complete return copies/erasures. The actual +Count-to-unary setup and its input/counter/output tape meters are recorded +separately; binary countdown amortization gives O(H_b+log H_b). Charge the +encoded parameter arithmetic as T_descriptor. In particular the Python fixture +loader is not claimed to be the physical descriptor compiler. Combined with +the metered body, this is a constructive O(mH_b+H_b) conversion bound plus that +explicit setup. Extra wide packets/protected outputs are included in occupied +space and erasure charges, rather than treated as free pointer swaps. + +The callback uses one complete source Machine inventory I=2q_*^2+100696823 +and a separate external monomial/ordinary inventory, bounded above by another +complete I. The source constructor requires a fresh private ordinary engine; +sharing the active engine was rejected during integration. Reserve at most256 +new metadata/stream tape roles per each of the224 fixed occurrences, plus32 +fixed bridge/control roles. This exceeds the two83-field wrapper layouts, +encoded parameters, unary descriptors/countdowns, patterns, coarse/wide ports +and fixed setup temporaries in the specified protocol. Thus a conservative +owned inventory bound is `2I+2^20`, excluding the enclosing caller's inventory. +It is deliberately generous. No tape is allocated per component by the bridge; +backend recursive depth uses its inherited fixed inventory/physical stack. +Only one callback's wide occupied packet is live. The whole caller, retained +copies and protected outputs are also charged. Erased work does not promise +that a Python list releases historical capacity. + +## 6. Compatible cost and the changed construction decision + +For actual promoted packet volumes v_j, a complete symbolic decoder ledger is + +``` +sum_224 T_C(lambda,v_j,H_b;global descriptors) ++448 T_M +352 T_cover ++1820 T_unit +896 T_quarter +416 T_clear ++T_lift/project +T_descriptor +T_caller_acquire/reconnect/retire. +``` + +T_C includes its own internal recursion, parking, copies and cleanup. T_M +includes actual physical wrappers. Every term uses its own actual packet, +width and chronology; unknown external terms remain unknown. See COST.md for +the inherited stopping/weighted-tree exponents and exact occurrence census. +The new conversion is linear in actual H_b-bit volume, within the retained +long-record framework. We do not replace actual volume by2^(73lambda), give +a direct coordinate loop the recursive price or assign zero movement/control. + +PR4015 and PR4106 have identical signed child multisets. Under the same admitted +backend, H_b, wrappers and conversion protocol, their prescribed native and +conversion bills agree. PR4106 removes100 whole-field unit ADDs, giving800 +logical allowance or200 real additions per complex coordinate. The actual +physical total still requires compatible placement and access costs; no runtime +dominance or selected idle credit is established by subtracting upper bills. +The new zero-error native contract advances the implementation decision, while +caller output lease, current-endpoint connection and full usage remain binding. + +## 7. Closest alternatives and remaining boundary + +The separate tagged/raw axis implementation has a new paid seven-tape adapter +and exact signed fixtures, including the actual first normals11 and448. Its +lexicographic tags serialize low-to-high bits, so the raw conversion must include +bit reversal. Omitting it changes an attainable endpoint. Its direct seek bill +is quadratic in its stated raw layout; this is not a lower bound on other radix +or compressed layouts. It supplies a constructive fallback, not an affordable +recursive substitution. PHYSICAL.md gives the complete model and invoice. + +Whole-field seven-lane pooling can satisfy the first odd row divisor, and a +literal lifetime check finds additional output hosts. It cannot provide deeper +stock under the unchanged row/spectator split. With Gamma=2^1296O, the exact +minimum pooling count is `7^D O^(D-1)2^max(0,1307D-1296-s)`. For D>=2 this +exceeds224. Source-compatible parent stock avoids this problem without pooling. +This rejects only that no-padding pooling class; BATCH.md preserves its shallow +escape and all unknown charges. Neither alternative alone justifies publication. + +The next experiment must bind a real QQ16 F0/B1 recovery cut to these prepared +packet descriptors and a disjoint224-output/16-private lease. Current selected +G and QQ16 Q have different current endpoints; original-input recovery cannot +be substituted for the bridge's current X/Y. Preserve #4105/#4108's ordered +owner/native restrictions and #4003/#4030's query/frame scopes. Then reconstruct +a complete compatible usage and physical bill with actual removed source work. +No selected supplier, frontier or kappa changes here. + +## Evidence and attribution + +The primary fixture joins the new paid conversion to the unchanged actual +Machine on nonconstant complex data, with ten recursive entries/returns and +reentrant-entry rejection. Signed fixtures execute actual MonomialPackets on +both sides of that Machine for both signs. These use declared reduced dimension2 +and q=2 ordinary geometry; they are not production O73/GL64 executions. The +all-depth result is the written composition of retained source hypotheses and +new guard/stock/return proofs. Seven physical conversion failures, signed axis +mutations, source/word/receipt corruption and read-only export tests are distinct +from that proof. All inherited bytes authenticate before execution. + +Credit Jose Manuel/jmbarrancoml for the physical controller, Gaussian/monomial/ +scalar streams, Compact, parking and ordinary integration, PR2287 and all +retained selected native/hosting/compiler/geometry authors; Tekalign/#3127 +normalization, which is not used as the C endpoint. Preserve Ali Romman/QQ16, +ywz65/#2707, Arham Tahir/#2681, #3985 native reduction, #4015 streaming, #4106 +pairing and #4109 coarse precision. Nick Petalas/#3303 and ToikY/#3652 producer +results remain distinct; #4105/#4108 and Tekalign/#4003/#4030 keep their scopes. +New integration by Chris R/Clear1nsight with substantial OpenAI Codex assistance +from construction, cost, physical, alternative and read-only adversarial agents. +No independent human or formal-kernel approval is claimed. Apache-2.0. diff --git a/research/qq16-caller-install/inputs/PR4129-README.md b/research/qq16-caller-install/inputs/PR4129-README.md new file mode 100644 index 0000000000..71858dcdde --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4129-README.md @@ -0,0 +1,102 @@ +# QQ16 recovery: a paid bridge to the actual recursive C implementation + +**This implements the missing native precision/return contract on an admitted +physical packet.** PR4109 certified a coordinate Gaussian reference. Here a +finite-state bit-stream adapter runs the retained actual recursive Machine on +a protected working grid and checks exact return to the caller's coarse grid. +The same contract covers all224 frozen PR4106 native occurrences. Actual QQ16 +caller placement, current-value reconnection and whole-supplier affordability +remain open; no kappa change is claimed. + +The scientific result is a source-relative implementation contract (assignment +outcome B), with a new paid bridge and source-bound proofs. The retained backend's +all-size/refinement, native/common-label, ordinary B1/C0, chronological hosting, +Compact and long-record hypotheses remain explicit. Reduced physical executions +support the joins; they are not production O73/GL64 or human/formal acceptance. + +| Obligation | PR4109 boundary | This contribution | +|---|---|---| +| Native interior/rounding | Actual child unspecified | Retained recursive whole-array height, paid promotion, exact completed error0 on the prepared ABI | +| Working width | Common coarse W_c | Keep actual admitted width H_b; require H_b>=W_c+2a+1 | +| Recursive rows/passives | No actual capsule | Bind source widthlambda, rowsR/L, after+72lambdaK; all-depth stock inheritance | +| Representation return | Common-grid premise | Actual tape lift, low-zero/sign checks, projection and cleanup | +| Signed implementation | Ideal recipes | All224 authenticated73D recipes; actual signed monomial/Machine fixtures | +| Whole caller/supplier | Unestablished | Still requires packet acquisition, output lease, reconnection and complete usage/cost | + +Put t=lambda-1 and retain q_c=h2^(-9-3t), W_c=P+28+6t. For the actual backend +height take a=8lambda at a valid direct leaf, otherwise a=2Blambda, with +B=1041408Gamma+2^100000. Work on q_w=q_c2^-a. The sufficient minimum +W_req=W_c+2a+1 includes Gaussian-modulus headroom. **The backend stores the +unchanged admitted H_b=p+2C0d+3 bits, C0=2^210000**, not a replacement width +inferred merely from big-O. A compatible entry subdomain and exact H_b>=W_req +check are proved. Each exact projection restores q_c,W_c, so sequential calls +reuse the reserve and one wide workspace. + +[PROOF.md](PROOF.md) states the complete theorem, paid protocol and its parameter +quantifiers. [NATIVE.md](NATIVE.md) binds the actual prepared capsule and signed +recipes. [COST.md](COST.md) gives the compatible complete symbolic ledger, source +stopping/volume model and unknown caller terms. The first native is event4, +W0/port0/q11/+1; the first negative is event1705, Z10/port76/q448/-1. Coverage is +112 initial positive,104 query negative and8 response positive. All remain paid. + +The actual source Machine runs through ten recursive child entries and ten returns in the new +nonconstant complex fixture. Separate signed tests execute actual MonomialPackets +right/left wrappers around Machine for both signs. They use reduced dimension2 +and q=2 ordinary geometry. The finite-state bridge exercises signed extrema, +source preservation, surplus sign padding, rejected low/sign bits, partial +components, setup rollback and marker disjointness. Its loops decode no payload +integer and allocate no tape per component. Code meters read/write/unit moves; +Count-to-unary descriptor setup is executed and charged separately. + +The complete invoice includes224 native calls,448 wrappers,352 maps,1820 unit +ADDs,896 quarter ADDs,416 CLEARs, conversion/descriptor work and explicit caller +acquisition/reconnection/retirement terms. Two exclusive fixed native/ordinary +inventories and all wide copies are paid. Both PR4015/4106 use the same native +multiset and promotion; their prescribed native bills agree. The100 unit ADD / +800 allowance difference remains a relative local result. No full physical +runtime dominance, selected idle credit or new global profile is inferred. + +Supporting alternatives stay in this one package. [PHYSICAL.md](PHYSICAL.md) +constructs a metered seven-tape tagged/raw signed adapter and shows why its direct +seek layout is expensive. [BATCH.md](BATCH.md) shows that extra hosts permit +shallow seven-lane batching, while whole-field pooling cannot furnish deeper +stock under the fixed ABI. Neither is a universal obstruction or a second PR. + +## Reproduce + +From the repository root, standard-library CPython3.12: + +```sh +python3 -B scripts/research_package.py --package research/qq16-recursive-binding --check-only +python3.12 -B scripts/research_package.py --package research/qq16-recursive-binding +``` + +The primary verifies all source pins before inherited execution, regenerates +six complete typed receipts and executes the physical bridge/backend fixtures. +Boundary tests cover authentication, source/word/type corruption, overwrite +refusal and normal/optimized Git-free read-only replay. Success is +`PASS_QQ16_ACTUAL_RECURSIVE_BRIDGE_CONTRACT`. Exact source/retained bytes, hashes, +review scope and verification status are recorded in SOURCES, PREDECESSORS, +REVIEWS and VERIFICATION. No selected cold replay or full production payload is +claimed. The selected conditional kappa remains0.001672660197076918. + +## Open next questions + +Pin one real QQ16 F0/B1 cut and map its current bank/owner/frame data into these +prepared descriptors, with an exclusive224-output/16-private lease. First check +its row/spacing/guard/width metadata, distinct engine ownership and the actual +current-value bridge observations; source G and QQ16 Q differ. Then price the +literal acquisition, wrappers/maps, retirement and recursive usage against work +actually removed. This is now the next decision, rather than another native +precision constant. The backend's retained assumptions and the actual caller +mapping are separate obligations. See TASK.json for the structured first test +and stop criterion. + +Credit Jose Manuel/jmbarrancoml and the physical/selected controller, Gaussian, +monomial, scalar, Compact, ordinary and parking lineage; Ali Romman/QQ16, +ywz65/#2707, Arham Tahir/#2681; #3985 native reduction, #4015 streaming, #4106 +pairing, #4109 coarse precision; Nick Petalas/#3303, ToikY/#3652 and Tekalign's +normalization/query/frame work at their distinct scopes. New integration by +Chris R/Clear1nsight with substantial OpenAI Codex assistance from coordinated +construction, cost, physical, bounded alternative and read-only adversarial +agents. Apache-2.0; retained source notices remain unchanged. diff --git a/research/qq16-caller-install/inputs/PR4129-RESULT.json b/research/qq16-caller-install/inputs/PR4129-RESULT.json new file mode 100644 index 0000000000..af630ea7b9 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4129-RESULT.json @@ -0,0 +1,399 @@ +{ + "actual73D_recipe_count": 224, + "actual73D_recipes_sha256": "f4dc768cafbf4773fae26fab66ced77d22ddc697c55e9d78dd2690ae4ef8dca4", + "alternative_controls": [ + "missing corrected-W source", + "premature Z12 reuse" + ], + "complete_compatible_invoice": { + "additional": "Actual decoder acquisition/placement, descriptor arithmetic, current endpoint reconnection and retirement remain explicit nonzero unknown terms for a complete caller.", + "callback_inventory_upper": "2I+2^20 owned physical tapes, I=2q_*^2+100696823; separate native Machine and ordinary/monomial inventory plus bounded bridge metadata. Existing caller inventory separate.", + "coarse_arithmetic": "1820 T_unit(W_c)+896 T_quarter(W_c)+416 T_clear(W_c)", + "conversions": "Paid Count-to-unary setup; pattern construction, source-preserving promotion, checked projection, protected copies, erasure and marker returns. See bridge.py and PROOF.md for linear finite-state bound.", + "native": "sum actual224 T_C(lambda,v_j,H,p,d,K,guards,rows) with unchanged source recursion and internal parking included", + "relative": "4015/4106 use identical signed child multisets and common actualH; prescribed native/conversion bills agree.4106removes100whole-field unitADDs;800logicalallowance is separate. No fullphysical runtime dominance or globalcredit established.", + "space": "Complete coarse caller and retained returns + O_q(max_j v_j)+F_q, including working/protected copies; one callback active.", + "wrappers_maps": "448 T_M(H)+352 T_cover(W_c), each on actual domains; numerical head counts are not tape prices" + }, + "execution": { + "2": { + "active_backend_reentry_rejected": true, + "active_width": 2, + "actual_backend_bits": 48, + "all_work_blank": true, + "coarse_bits": 12, + "complex_values": 16, + "endpoint_sha256": "1e6d5cceaeba2d854800b0f97e0e4c19a862d0c30f60e77ec72f49db41efdfa3", + "geometry_dimension": 2, + "lift_cell_actions": { + "move": 10448, + "read": 10541, + "write": 3168 + }, + "minimum_bits": 45, + "ordinary_q": 2, + "project_cell_actions": { + "move": 11220, + "read": 12466, + "write": 2400 + }, + "recursive_boundaries": { + "enter": 10, + "return": 10 + }, + "reserve": 16, + "rows": 4, + "scope": "Actual unchanged source Machine/cohort and new tape bridge; reduced dimension2/q2 fixture, not production O73/GL64 or all-depth execution. Height proof and production native/refinement assumptions inherited separately.", + "source_descriptors_preserved": true, + "status": "PASS_PROMOTED_ACTUAL_RECURSIVE_MACHINE" + }, + "conversion": { + "cases": [ + { + "backend_bits": 3, + "cell_actions": { + "move": 284, + "read": 318, + "write": 58 + }, + "coarse_bits": 2, + "components": 4, + "conservative_cell_bound": 1216, + "paid_unary_generation_actions": { + "moves": 106, + "reads": 89, + "writes": 32 + }, + "paid_unary_retirement_actions": { + "moves": 44, + "reads": 38, + "writes": 10 + }, + "reserve": 0, + "unary_counter_actions": [ + { + "allocations": 0, + "moves": 32, + "peak_live": 0, + "reads": 27, + "writes": 13 + }, + { + "allocations": 0, + "moves": 20, + "peak_live": 0, + "reads": 14, + "writes": 8 + }, + { + "allocations": 0, + "moves": 22, + "peak_live": 0, + "reads": 18, + "writes": 8 + } + ] + }, + { + "backend_bits": 8, + "cell_actions": { + "move": 586, + "read": 639, + "write": 136 + }, + "coarse_bits": 3, + "components": 4, + "conservative_cell_bound": 3136, + "paid_unary_generation_actions": { + "moves": 152, + "reads": 139, + "writes": 50 + }, + "paid_unary_retirement_actions": { + "moves": 58, + "reads": 52, + "writes": 17 + }, + "reserve": 1, + "unary_counter_actions": [ + { + "allocations": 0, + "moves": 36, + "peak_live": 0, + "reads": 32, + "writes": 14 + }, + { + "allocations": 0, + "moves": 22, + "peak_live": 0, + "reads": 18, + "writes": 8 + }, + { + "allocations": 0, + "moves": 48, + "peak_live": 0, + "reads": 43, + "writes": 20 + } + ] + }, + { + "backend_bits": 19, + "cell_actions": { + "move": 1312, + "read": 1393, + "write": 330 + }, + "coarse_bits": 8, + "components": 4, + "conservative_cell_bound": 7360, + "paid_unary_generation_actions": { + "moves": 264, + "reads": 258, + "writes": 95 + }, + "paid_unary_retirement_actions": { + "moves": 88, + "reads": 82, + "writes": 32 + }, + "reserve": 3, + "unary_counter_actions": [ + { + "allocations": 0, + "moves": 76, + "peak_live": 0, + "reads": 73, + "writes": 31 + }, + { + "allocations": 0, + "moves": 36, + "peak_live": 0, + "reads": 32, + "writes": 14 + }, + { + "allocations": 0, + "moves": 76, + "peak_live": 0, + "reads": 73, + "writes": 31 + } + ] + }, + { + "backend_bits": 31, + "cell_actions": { + "move": 2094, + "read": 2205, + "write": 538 + }, + "coarse_bits": 13, + "components": 4, + "conservative_cell_bound": 11968, + "paid_unary_generation_actions": { + "moves": 368, + "reads": 372, + "writes": 135 + }, + "paid_unary_retirement_actions": { + "moves": 116, + "reads": 110, + "writes": 46 + }, + "reserve": 8, + "unary_counter_actions": [ + { + "allocations": 0, + "moves": 102, + "peak_live": 0, + "reads": 104, + "writes": 39 + }, + { + "allocations": 0, + "moves": 76, + "peak_live": 0, + "reads": 73, + "writes": 31 + }, + { + "allocations": 0, + "moves": 86, + "peak_live": 0, + "reads": 85, + "writes": 34 + } + ] + } + ], + "rejections": { + "malformed unary setup rollback": "unary descriptor bit", + "negative nonzero low bit": "nonzero discarded fractional bit", + "nonzero low bit": "nonzero discarded fractional bit", + "odd coarse component": "complete Gaussian real/imaginary pair", + "pattern/alphabet collision": "rejected before execution", + "short wide suffix": "complete wide component", + "wrong sign extension": "incompatible return sign extension" + }, + "scope": "Actual source tape/countdown, metered new finite-state adapter. Unary descriptor generation/retirement paid, sources preserved including rejected calls.", + "status": "PASS_PHYSICAL_CONVERSION_CONTROLS" + }, + "signs": { + "fixtures": [ + { + "active_width": 1, + "backend_bits": 29, + "coarse_bits": 10, + "complex_values": 8, + "endpoint_sha256": "064970b150c65679c266600174490ccdef6228fbc5c2b044223b3d94d065764b", + "geometry_dimension": 2, + "lift_cell_actions": { + "move": 3388, + "read": 3440, + "write": 986 + }, + "project_cell_actions": { + "move": 5576, + "read": 5935, + "write": 1770 + }, + "q": 3, + "reserve": 8, + "sign": 1 + }, + { + "active_width": 1, + "backend_bits": 29, + "coarse_bits": 10, + "complex_values": 8, + "endpoint_sha256": "3e1280f6a0827dd9d7d7153e6565e30d574150ac2eb9dc5686d1028c00979cdd", + "geometry_dimension": 2, + "lift_cell_actions": { + "move": 3388, + "read": 3440, + "write": 986 + }, + "project_cell_actions": { + "move": 5576, + "read": 5935, + "write": 1770 + }, + "q": 3, + "reserve": 8, + "sign": -1 + } + ], + "scope": "Actual source MonomialPackets right/left and Machine.run with paid new bridge; reduced q3/dimension2/width1, not full production recipe payload.", + "status": "PASS_ACTUAL_SIGNED_MONOMIAL_MACHINE_BRIDGE" + } + }, + "external_boundary": { + "backend": "Actual physical-complex-controller Machine C endpoint; inherited source-relative refinement, selected native/common-label, chronological hosting, ordinary B1/C0, Compact and long-record assumptions.", + "caller": "Unchanged4106word and4109 entry domain, with actual admitted e=73lambda physical parent capsule, complete passives/guards/stock, original component_bits H, disjoint closed native/wrapper inventories and borrowed source/output ports.", + "return": "Every exact signed native callback projects to q_c,W_c, preserving borrowed payload/encoded descriptors and clearing owned bridge/backend work. No invocation on an active Machine." + }, + "literal_native_variants": { + "initial_positive": 112, + "query_negative": 104, + "response_positive": 8 + }, + "new_code_sha256": { + "batch.py": "d513e7ac0f2538a50319055b5868d18f4bbeb979d3e05bcb3b0e9dcde94e2785", + "bridge.py": "120cd3a2d0deb44b9c059636b1ac9bdd8a6b998143718f4252794780edf7decb", + "construction.py": "bbfb0014e8636ab4f66ff925189fd523fd4e8e377aec51509f4f3fe6877c3007", + "feasibility.py": "7a67ce998aa3e054f9d2d0e4f66468b112cb147d03722bb555c01131fba95f74", + "physical_fixture.py": "b2b8e6da5496c8e94b88e99601b39122f93ced024a3ac19f1cd2f81981426aa2", + "realization.py": "d1d6a80a0ed2c529b9e9ef4abdd0cad1eae80b2810c8c22e93d0c9de6d1d8d2c" + }, + "outcome_class": "B: implemented reusable prepared-packet native precision/return contract; complete QQ16 supplier/caller affordability unestablished", + "precision": { + "actual_signed_bits": "H=p+2C0d+3, C0=2^210000, unchanged admitted parent component_bits", + "admission": "H>=W_req; promote lowa zeros and H-W_c-a high sign bits; check exact fractional divisibility and signed return before projection", + "coarse_component_bits": "W_c=P+28+6t", + "coarse_quantum": "h*2^(-9-3t), t=lambda-1>=0", + "completed_error": "zero conditional on retained exact Machine refinement and admission; reserve reusable after every exact return, no224a debt", + "minimum_signed_bits": "W_req=W_c+2a+1; extra1 covers Gaussian modulus vs component supremum", + "reserve": "a=8lambda at admitted directleaf, otherwise2Blambda; B=1041408Gamma+2^100000", + "sufficient_subdomain": "P<=p+4Bd+1, lambda<=d => W_req=2 without padding/changed row split. No universal batch impossibility.", + "tagged_axis": "Constructive7-tape signed ABI with exact invoice; directseek route has quadratic movement in its stated layout, no cheap recursive tariff. Other radix/layout routes remain open." + }, + "remaining_obligations": [ + "Install224owned recovery outputs and16private arrays without borrowing480dirty producer helpers or clobbering live query state.", + "Bind actual F0/B1 Q-to-G/currentbridge owner/phase and caller packet acquisition; no original-input/current-endpoint substitution.", + "Pay covers, physical layout/control/usage/retirement and prove a favorable complete supplier moment; no selected idle credit here.", + "Retained production backend all-size/refinement assumptions are inherited; reduced physical fixtures are not full O73/GL64 execution or human/formal approval." + ], + "scientific_base": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "selected_kappa": "836330098538459/500000000000000000 unchanged; no new supplier, merge or frontier admission", + "significance": "Supplies an implemented paid source-tape bridge and zero completed native error/interior reserve for a named real recursive backend on its prepared ABI. Moves the missing decision to actual caller packet/output lease and full usage/reconnection bill. Descriptor or logical-coordinate reference alone is insufficient.", + "source_inputs": { + "certificates/selected-result.json": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "notes/batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "notes/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "notes/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "research/bit2234-stock-threshold/README.md": "1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7", + "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f", + "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734", + "research/complex-grid-prefix-audit/PROOF.md": "9c2473e080a64de5139abf66680534043143ec9f4488ceabf62403702047a3ad", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "research/gaussian-normalization-stream/SOURCES.json": "c434302f4489366c1763f918ba59e2f57efc0a41d72310fd3c6bbe1553370275", + "research/gaussian-normalization-stream/normalizer.py": "2b0acaa831219faf3e7776969bdcffc3f0f9c608b15d6b4c343ff20cf6a50107", + "research/gaussian-parity-synthesis/REVIEW.md": "7d7b9ac63ccd2927f592e9edac1b4c11d58a6c74c5813d488e112f729090f60c", + "research/gaussian-parity/gaussian-parity-certificates.tex": "e21e1063141cbc798e73052e22d01eec57f1c173a580041e55aa196b1b0479f8", + "research/p104-whole-word-internal-grid/README.md": "d98c0b0a4835d766852e960299dd87112375990ed645d2c9e84edb08b79500e4", + "research/physical-complex-controller/PROOF.md": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e", + "research/physical-complex-controller/SOURCES.json": "c9c47d9df2445fc554673316d42f68f0a1b800ea3593ac568835c9b063025eb4", + "research/physical-complex-controller/bank_packets.py": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "research/physical-complex-controller/cohort.py": "8fb650c0cc3dfaad94811149b0c0e725777a8cff195c5f21e21a7576494e84f1", + "research/physical-complex-controller/cover.py": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da", + "research/physical-complex-controller/fixture_binding.py": "efcb94cf050412ccd2d5eea592d77f294f6124f6feebc86580b16a73e5c2c202", + "research/physical-complex-controller/machine.py": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "research/physical-complex-controller/monomial_packets.py": "6856e80c13ebf3b6e9e0e142ed65420579b5a1b4892f23859d3c6e5f17a334b4", + "research/physical-complex-controller/native_program.py": "177d87445659d7ddbef11370d0b4cdc0596732147ed26c1fa11bad16ae53c93b", + "research/physical-complex-controller/parking.py": "33e6d2a6fcdc648de31b374132bf885259eec9748bafa6facca3822a78427e94", + "research/physical-complex-controller/root_plan.py": "494cad3edc376928684f380cd16568076b286a53bd763d910d49efa5b03f07c9", + "research/physical-complex-controller/scalar_packets.py": "cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35", + "research/physical-complex-controller/scalar_program.py": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a", + "research/physical-complex-controller/selected_binding.py": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985", + "research/physical-gaussian-leaf/PROOF.md": "29ebd43146f921077f980a408915ecc3a5199a07fcdadc624a8282c06b0b8104", + "research/physical-gaussian-leaf/SOURCES.json": "c693fc79212652d7427560189ad8eb5e841fe71325e6d7a0d61e05f97438a5e1", + "research/physical-gaussian-leaf/axis_stream.py": "40dea1c6fa41effd8e7a61f39a3a599e897370ca118e332ee5301a905dbb2998", + "research/physical-gaussian-leaf/coefficient_engine.py": "fff28cbc27b95ed546ac65f70279fa41a933421f1cd32b988ae8910632f0efcf", + "research/physical-gaussian-leaf/inputs/pr3087.tar": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53", + "research/physical-gaussian-leaf/leaf_sources.py": "e0f958a0169257ba08eac5e025a3fc7ce99009efc18974cdd231f16758004014", + "research/physical-gaussian-leaf/signed_linear.py": "5b86afc33042e1c43eaa6957f94e0ebf403d1b07bb26d30ba89aa14d71f76078", + "research/physical-scalar-stream/scalar_engine.py": "be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6", + "research/physical-scalar-stream/scalar_words.py": "f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00", + "research/pr589-five-helper-hosting/PROOF.md": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647", + "research/pr589-five-helper-hosting/verify.py": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367", + "research/qq16-line-normalized-decoder/PROOF.md": "0a0995e70f2a64c15cdd1aee66634d1ba221cbcb2a7cfa3a4d4950a37d0e143a", + "research/qq16-line-normalized-decoder/RESULT.json": "58df4ad68e2ff335ee58fa4336a449d0f73f3366d840574e5e30b50f507c358d", + "research/qq16-line-normalized-decoder/verify.py": "0f6fb86aafb74b9722f20cc97af70a3a3c78bd012c142b2eaa19cb00e02d1fe9", + "research/qq16-recursive-binding/vendor/PR3884-README.md": "4bb8a6ce64a01f4adb3749bbf72f3ed3b084d34e6c4c654ac4fa0738d12f540b", + "research/qq16-recursive-binding/vendor/PR3884-tapes.py": "a3ad668b94d44ff1b9d7093e95c5af3ea0d80cdb798365ea7631c0e2a3dcae10", + "research/qq16-recursive-binding/vendor/PR4015-WORD.json": "272d8c1bd172c29044eb227ec6d67a882501250978234685e035158f4479aa58", + "research/qq16-recursive-binding/vendor/PR4106-WORD.json": "b4f2b5662734178d02a5d620ebd071bc284abd4d9b6dbe11b5d9646455a0f021", + "research/qq16-recursive-binding/vendor/PR4109-PROOF.md": "d9c13e5128800015b04f3a3060d1e7dfc0bdbb6285d4ee799019da4c033813bc", + "research/qq16-recursive-binding/vendor/PR4109-RESULT.json": "f5dcaa599862d60493a1a9a9fcdd5bbfaf814d2cb426d2aa1bcff8183fb6d7bf", + "research/qq16-tagged-cover-routing/PROOF.md": "1b32c88e6c6ace2b41a1f2168a6754c329fb1bf9a5b64cf3fec53b31085604ea", + "research/qq16-tagged-cover-routing/oracle.py": "00328380126faa55b9f8027c81872663985610a247d0a61108951b394ad27fff", + "research/qq16-tagged-cover-routing/router.py": "a5221ec8a3a38b5d0133abc685ec28e392e946ef5b60dec37f69a605a45ba7ce", + "research/qq16-tagged-cover-routing/verify.py": "05b06299545c7fc74de34d13951e083cc7f8f8ab1e9b9c8eb96df892a430776e", + "research/recursive-parking-boundary/README.md": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18", + "research/selected-bit-local-ring-sweeps/PROOF.md": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7", + "research/selected-bit-recursive-closure/PROOF.md": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344", + "research/selected-complex-layer-closure/PROOF.md": "43feda0342c07a9429699c3a44e8936a3f3fb57ce9b32f38ff3dc06ac887b265", + "research/selected-complex-layer-closure/arithmetic.py": "31e4b21bb64924d723d1248a7eccf4e9c80d323ba8784804af79a75da18c346a", + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "status": "PASS_QQ16_ACTUAL_RECURSIVE_BRIDGE_CONTRACT" +} diff --git a/research/qq16-caller-install/inputs/PR4129-SOURCES.json b/research/qq16-caller-install/inputs/PR4129-SOURCES.json new file mode 100644 index 0000000000..e7121d9892 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4129-SOURCES.json @@ -0,0 +1,330 @@ +{ + "schema_version": 1, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5" + }, + { + "path": "notes/batched-complex-rows.tex", + "usage": "input", + "sha256": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "git_blob": "e13bd96eb29bdc6526f10dc32e0a146bc17848a4" + }, + { + "path": "notes/compact-control-layout.tex", + "usage": "input", + "sha256": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "git_blob": "16f4d233471a7d189163ae7e7902becadecbba64" + }, + { + "path": "notes/compact-control-movement.tex", + "usage": "input", + "sha256": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "git_blob": "06b6a9ef24245ac7b724c53a204635415b402357" + }, + { + "path": "research/bit2234-stock-threshold/README.md", + "usage": "input", + "sha256": "1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7", + "git_blob": "ede0d322c477af91d4c2cc33db0fd10958f45eab" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "usage": "input", + "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f", + "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "usage": "input", + "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734", + "git_blob": "44006542202ca6037533a754f0bcd00549d7e088" + }, + { + "path": "research/complex-grid-prefix-audit/PROOF.md", + "usage": "input", + "sha256": "9c2473e080a64de5139abf66680534043143ec9f4488ceabf62403702047a3ad", + "git_blob": "30f019e14866200660cbd2ad82f3bff707003210" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a" + }, + { + "path": "research/gaussian-normalization-stream/SOURCES.json", + "usage": "input", + "sha256": "c434302f4489366c1763f918ba59e2f57efc0a41d72310fd3c6bbe1553370275", + "git_blob": "58fce750dc2814f36ac096b407dd28293539bf8f" + }, + { + "path": "research/gaussian-normalization-stream/normalizer.py", + "usage": "input", + "sha256": "2b0acaa831219faf3e7776969bdcffc3f0f9c608b15d6b4c343ff20cf6a50107", + "git_blob": "5d1a0961ace6b7edccb26c05780623c5509a7597" + }, + { + "path": "research/gaussian-parity-synthesis/REVIEW.md", + "usage": "input", + "sha256": "7d7b9ac63ccd2927f592e9edac1b4c11d58a6c74c5813d488e112f729090f60c", + "git_blob": "0a6a4c7c1e8bef9c9aa9c7fb636e5ad6c0c411ae" + }, + { + "path": "research/gaussian-parity/gaussian-parity-certificates.tex", + "usage": "input", + "sha256": "e21e1063141cbc798e73052e22d01eec57f1c173a580041e55aa196b1b0479f8", + "git_blob": "e364cff719a12a5dfd52f2975cd07cc0318da511" + }, + { + "path": "research/p104-whole-word-internal-grid/README.md", + "usage": "input", + "sha256": "d98c0b0a4835d766852e960299dd87112375990ed645d2c9e84edb08b79500e4", + "git_blob": "4075bb303592ccc53cd7d29399f15ff01c89da5d" + }, + { + "path": "research/physical-complex-controller/PROOF.md", + "usage": "input", + "sha256": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e", + "git_blob": "c505caecc7ced19a4efc35c423efedda9427bea5" + }, + { + "path": "research/physical-complex-controller/SOURCES.json", + "usage": "input", + "sha256": "c9c47d9df2445fc554673316d42f68f0a1b800ea3593ac568835c9b063025eb4", + "git_blob": "a56a247ecb28c77fcb055fac031be471b291777d" + }, + { + "path": "research/physical-complex-controller/bank_packets.py", + "usage": "input", + "sha256": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "git_blob": "defda707199e8eba83ee483daf5ae7acb642c43c" + }, + { + "path": "research/physical-complex-controller/cohort.py", + "usage": "input", + "sha256": "8fb650c0cc3dfaad94811149b0c0e725777a8cff195c5f21e21a7576494e84f1", + "git_blob": "3876ab737f3c2a90100749e4ba141f1923caff79" + }, + { + "path": "research/physical-complex-controller/cover.py", + "usage": "input", + "sha256": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da", + "git_blob": "2b9b9df832a747bcb02505d5495f79d38deffa43" + }, + { + "path": "research/physical-complex-controller/fixture_binding.py", + "usage": "input", + "sha256": "efcb94cf050412ccd2d5eea592d77f294f6124f6feebc86580b16a73e5c2c202", + "git_blob": "447ddc84d7dd9905c767c91acc7467a495093475" + }, + { + "path": "research/physical-complex-controller/machine.py", + "usage": "input", + "sha256": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "git_blob": "92f9467ffd3346d672a0e2c56f2508e33ed21689" + }, + { + "path": "research/physical-complex-controller/monomial_packets.py", + "usage": "input", + "sha256": "6856e80c13ebf3b6e9e0e142ed65420579b5a1b4892f23859d3c6e5f17a334b4", + "git_blob": "5b4eaf49b3847cafa7bd99e7147c8818b248a021" + }, + { + "path": "research/physical-complex-controller/native_program.py", + "usage": "input", + "sha256": "177d87445659d7ddbef11370d0b4cdc0596732147ed26c1fa11bad16ae53c93b", + "git_blob": "7d1c54c7d1394de28585d48b1a703d4b00069e98" + }, + { + "path": "research/physical-complex-controller/parking.py", + "usage": "input", + "sha256": "33e6d2a6fcdc648de31b374132bf885259eec9748bafa6facca3822a78427e94", + "git_blob": "34bc6a0bd0daade7ccc69d0c236984f024d22ef4" + }, + { + "path": "research/physical-complex-controller/root_plan.py", + "usage": "input", + "sha256": "494cad3edc376928684f380cd16568076b286a53bd763d910d49efa5b03f07c9", + "git_blob": "78390164c3551bfcce8da6b0f23197a4048a7e5e" + }, + { + "path": "research/physical-complex-controller/scalar_packets.py", + "usage": "input", + "sha256": "cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35", + "git_blob": "66ea778399423005695bdea1e43ef9dcde903402" + }, + { + "path": "research/physical-complex-controller/scalar_program.py", + "usage": "input", + "sha256": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a", + "git_blob": "30ba678c7b828285d549e923b34e315e439b8452" + }, + { + "path": "research/physical-complex-controller/selected_binding.py", + "usage": "input", + "sha256": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985", + "git_blob": "5fe097ff688f5304a45945054e9d4a4af05f13d8" + }, + { + "path": "research/physical-gaussian-leaf/PROOF.md", + "usage": "input", + "sha256": "29ebd43146f921077f980a408915ecc3a5199a07fcdadc624a8282c06b0b8104", + "git_blob": "e98db470cdb8bfc49e9da86c39c0d6ae16e92716" + }, + { + "path": "research/physical-gaussian-leaf/SOURCES.json", + "usage": "input", + "sha256": "c693fc79212652d7427560189ad8eb5e841fe71325e6d7a0d61e05f97438a5e1", + "git_blob": "2ae5d4a9bd2b62bf21fee81106fa9e38bbd84bd0" + }, + { + "path": "research/physical-gaussian-leaf/axis_stream.py", + "usage": "input", + "sha256": "40dea1c6fa41effd8e7a61f39a3a599e897370ca118e332ee5301a905dbb2998", + "git_blob": "ba8230443fdb0370b72a7a617ba7d88eb23a9c37" + }, + { + "path": "research/physical-gaussian-leaf/coefficient_engine.py", + "usage": "input", + "sha256": "fff28cbc27b95ed546ac65f70279fa41a933421f1cd32b988ae8910632f0efcf", + "git_blob": "dff2f099b60c23310a10665cd81e443282b249e8" + }, + { + "path": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "usage": "input", + "sha256": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53", + "git_blob": "6daedf70a927fa1359caec68d56fc0cbdaeb54dd" + }, + { + "path": "research/physical-gaussian-leaf/leaf_sources.py", + "usage": "input", + "sha256": "e0f958a0169257ba08eac5e025a3fc7ce99009efc18974cdd231f16758004014", + "git_blob": "31c33dbed6061ca7c0455a9170fd05fb388f4607" + }, + { + "path": "research/physical-gaussian-leaf/signed_linear.py", + "usage": "input", + "sha256": "5b86afc33042e1c43eaa6957f94e0ebf403d1b07bb26d30ba89aa14d71f76078", + "git_blob": "d17018a976ea4af15b6b5828a091d799435bacfc" + }, + { + "path": "research/physical-scalar-stream/scalar_engine.py", + "usage": "input", + "sha256": "be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6", + "git_blob": "aea19253f6a772047f22d2f0e1927b9bf319aba9" + }, + { + "path": "research/physical-scalar-stream/scalar_words.py", + "usage": "input", + "sha256": "f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00", + "git_blob": "36919dc569678656a1696f23454cba2d1fb0f393" + }, + { + "path": "research/pr589-five-helper-hosting/PROOF.md", + "usage": "input", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647", + "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02" + }, + { + "path": "research/pr589-five-helper-hosting/verify.py", + "usage": "input", + "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367", + "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39" + }, + { + "path": "research/qq16-line-normalized-decoder/PROOF.md", + "usage": "input", + "sha256": "0a0995e70f2a64c15cdd1aee66634d1ba221cbcb2a7cfa3a4d4950a37d0e143a", + "git_blob": "f7c694ff54e590416e4a52fa762f9d3b9474bccb" + }, + { + "path": "research/qq16-line-normalized-decoder/RESULT.json", + "usage": "input", + "sha256": "58df4ad68e2ff335ee58fa4336a449d0f73f3366d840574e5e30b50f507c358d", + "git_blob": "ba4167dbf133cff51513bb832802c290edcdffea" + }, + { + "path": "research/qq16-line-normalized-decoder/verify.py", + "usage": "input", + "sha256": "0f6fb86aafb74b9722f20cc97af70a3a3c78bd012c142b2eaa19cb00e02d1fe9", + "git_blob": "a8f3c811108414eda0b507d295cfc9301c04d585" + }, + { + "path": "research/qq16-tagged-cover-routing/PROOF.md", + "usage": "input", + "sha256": "1b32c88e6c6ace2b41a1f2168a6754c329fb1bf9a5b64cf3fec53b31085604ea", + "git_blob": "44725131a9ecb8b41533492efa7a83bd65aca9ae" + }, + { + "path": "research/qq16-tagged-cover-routing/oracle.py", + "usage": "input", + "sha256": "00328380126faa55b9f8027c81872663985610a247d0a61108951b394ad27fff", + "git_blob": "555efb4b105c6bc59395f445625eb335688cd6aa" + }, + { + "path": "research/qq16-tagged-cover-routing/router.py", + "usage": "input", + "sha256": "a5221ec8a3a38b5d0133abc685ec28e392e946ef5b60dec37f69a605a45ba7ce", + "git_blob": "1994ad9fa80e5fbce5b58dffed0c44d89a7259a7" + }, + { + "path": "research/qq16-tagged-cover-routing/verify.py", + "usage": "input", + "sha256": "05b06299545c7fc74de34d13951e083cc7f8f8ab1e9b9c8eb96df892a430776e", + "git_blob": "c89b57e23f8e5167c64128763807f4c379e862a0" + }, + { + "path": "research/recursive-parking-boundary/README.md", + "usage": "input", + "sha256": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18", + "git_blob": "251f335ebaccc11d69393ee7aeb5a2e84526d0bb" + }, + { + "path": "research/selected-bit-local-ring-sweeps/PROOF.md", + "usage": "input", + "sha256": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7", + "git_blob": "4330de85dd9862ed15d84ab917887d249753df99" + }, + { + "path": "research/selected-bit-recursive-closure/PROOF.md", + "usage": "input", + "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344", + "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531" + }, + { + "path": "research/selected-complex-layer-closure/PROOF.md", + "usage": "input", + "sha256": "43feda0342c07a9429699c3a44e8936a3f3fb57ce9b32f38ff3dc06ac887b265", + "git_blob": "d7ec0d101405a5f099f55f6a73e9791731737fd0" + }, + { + "path": "research/selected-complex-layer-closure/arithmetic.py", + "usage": "input", + "sha256": "31e4b21bb64924d723d1248a7eccf4e9c80d323ba8784804af79a75da18c346a", + "git_blob": "009d7b7166718832ebbf11893cb1ef258184a4f9" + }, + { + "path": "upstream/build/sections/02-streams.tex", + "usage": "input", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039" + } + ] +} diff --git a/research/qq16-caller-install/inputs/PR4129-TASK.json b/research/qq16-caller-install/inputs/PR4129-TASK.json new file mode 100644 index 0000000000..e031101d7f --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4129-TASK.json @@ -0,0 +1,158 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 6, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "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": "changed", + "actual_scope": "Bind every frozen4106 H1 occurrence to an actual recursive capsule and a paid exact working-grid adapter, with full conditional cost and source-domain alternatives.", + "scope_change_reason": "Explicit integrated assignment addresses4109 missing actual recursive implementation; no scalar percentage target or unrelated card.", + "bottleneck_link": "The logical decoder lacks an implementation-bound native interior, precision and scratch contract; an inherited physical parent capsule plus paid promotion may provide it without substituting the coordinate reference at a recursive tariff.", + "budget_minutes": 60, + "stop_rule": "Use successive bounded milestones. First decide actual capsule/precision contract; preserve failed routes. Publish at most one integrated substantial result after significance and adversarial gates; otherwise retain a checkpoint. Reserve final quarter of each round for verification. User allows continued work beyond one hour while meaningful routes remain.", + "outcome": "completed", + "evidence": "Implemented paid finite-state stream bridge, actual recursive Machine fixture (ten child entries and ten returns), both actual signed MonomialPackets/Machine fixtures,53 canonical input closure and all224 signed73D recipes. Quantified stock/height/return proof retains explicit refinement premises. Complete symbolic invoice and two scoped alternatives. Final registered primary/all4boundary groups PASS; frozen assisted adversarial review found no blocker. Commit/export/hosted receipts recorded externally.", + "author": "Chris R / Clear1nsight with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in source analysis, construction, proofs, checkers and integration. Separate workers with explicit ownership; read-only adversarial review required before publication. Shared source/context and reused primitives disclosed.", + "open_questions": [ + { + "question": "Can one actualQQ16F0/B1cut supplythesephysicalcapsulesand224ownedoutputs/16privatefieldswithanexclusiveleaseandaffordablecompletecontinuation?", + "why_it_matters": "The newbackendprecision/returncontractremovesonecriticalunknown; actualcalleracquisition andcurrent-value/ownerconnectionstilldetermineconstructionfeasibility.", + "first_step": "Pinoneactualcut sourceevent; extractrows,L-stock,K,H_guard,component_bitsH_b,globalp/d,source/carrierframes andoutput/scratchleases; requirethebridgeadmissionandbothcurrentX/Ybridgeobservations,theninvoicethewholematchedcontinuationwithactualremovedwork.", + "blocked_by": "NoactualQQ16-to-selectedGcurrentendpoint/ownermappingorexclusiveoutputleaseisinstalledbythispackage; inheritedbackendrefinementassumptionsalsoexplicit." + } + ], + "boundary": { + "inputs": "224borrowed currentXYarrays/frames; owneddecoderZ/W224 with arbitrary dirt cleared before use. Actual recursive entry additionally requires admitted parent e=73lambda capsule, completepassives/spacers/compactguards, rowstock and longrecords, with disjoint physicalwork tapes. This mapping is a named premise until proved.", + "outputs": "224originaloutputsF17 and borrowedXYunchanged inherited4106 exactword; everypreparednativecallbackmustreturntoq_c withoutresidual, descriptors/sourcepreserved andworkblank. ActualselectedG/currentbridgeconnection remains separate.", + "precision": "Coarse4109q_c=h2^(-9-3t),W_c=P+28+6t. Actualrecursiveinteriors useheightreserve a=8lambda atsourceleafotherwise2Blambda. W_req=W_c+2a+1; retainactualadmittedcomponent_bits H_b=p+2C0d+3 andrequireH_b>=W_req. Lowzero/signcheckedexactreturn. No224areservedebt.", + "objective": "Discharge native implementation/precision premise with a complete compatible symbolic bill in the real source domain; no selectedsupplier/kappa claim." + }, + "expansion_decision": { + "source_status": "4106/4109exactheads unchanged; sourcephysical-complex-controller is canonical inherited source-relative conditional construction with reduced fixtures, not human/formal production acceptance.", + "missing_implication": "Ideal signed H1 and a coordinateGaussian bound do not supply a recursivelypriced physicalcallback; need realcapsule, exact finitegrid/nativeinteriors and disjointscratchreturn.", + "costs": "Exactlogical26144vs26944;224H1/448wrappers/352maps unchanged. Reference200Nrealaddition saving inherited4109. Actualrecursivework, promotion/copies/layout/stock mustbe priced separately. GlobalQQ16currentendpoint/owner/idle/supplierobligationsunknown.", + "condition": "Construct a callback at eachactual224event with correctsignedoperator, actualparentstock, finitegrid/interiorbounds andreturnedsource/work. Uniformwidth/costcomponentcancellation requires the samecallbackmultiset on4015 and4106. CompleteQQ16supplierpositiveglobalmargin notassumed.", + "primary_experiment": "Compose actualMachine inherited rank1capsule with exact precisionpromotion and checkedreturn projection, then test on actualreducedphysicalrecursiveexecution and source-bound all224variants.", + "fallback": "Buildmetredtagged/rawsignedaxisadapter and test shallowsevenfieldbatchstock; use asclosestalternatives, rejectfree recursivepricing or implicitpadding.", + "decision": "Continue oneintegratednativecontract; nooptimizationcampaign orintermediatePRs.", + "stop": "At invalidheight/returnimplication, unattainablecapsule, incompatibleallocation or costdefeatingcontract, preservecounterexample and reassessthemeaningfulalternative. IfneithersignificanceA/B/Csupported, publishnoPR." + }, + "round": { + "start_utc": "2026-10-20T02:08:57Z", + "upstream_main": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "priority_revision": 6, + "overlap": "Live3985handoff and4109reviews refreshed; all-stateQQ16 search15recentPRs includes4114dirty-raymagnitude and4113embeddingreview, distinct scopes. CurrentDiscussion1163/1166/indexread, remotehelpercoveragepartial. Refreshed all-state QQ16 search at02:42; #4123 head499427578245cbd3d2b07680945a94f6e927d020 source PROOF inspected: normalized one-round H0 and toward-zero return, not this exact recursive-C capsule/precision bridge. Complementary, no mathematical dependency. Search/Discussion coverage bounded, not novelty proof.", + "verification_checkpoint_utc": "2026-10-20T02:45:32Z", + "submission_refresh": { + "utc": "2026-10-20T02:47:55Z", + "canonical_main": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "priority_revision": 6, + "decision": "No drift; preserve frozen base and dependencies." + } + }, + "candidate": { + "status": "Substantial prepared-ABI implementation contract; final assisted review found no unresolved blocker. Registered/publication gates required.", + "outcome_class": "B", + "new_implication": "Actualrecursivechildcompletederror0 and interiorfiniteprecision now available viaimplementedpaidpromotion/projectiononadmittedcapsules.", + "missing": "ActualQQ16bankacquisition/outputlease,currentG/Qbridgeconnectionandfavorablefullusagebill remain unknown." + }, + "scope_key": "5423eef254a4943f6bf1", + "workers": [ + { + "agent": "native_contract", + "ownership": "construction.py,NATIVE.md,CONTRACT.json", + "role": "Actualrecursiveimplementation/capsuletrace and quantifiedcontract" + }, + { + "agent": "native_feasibility", + "ownership": "feasibility.py,COST.md,BILL.json", + "role": "Independentcompatible cost/width/stock ledger" + }, + { + "agent": "native_realization", + "ownership": "realization.py,PHYSICAL.md,TRACE.json", + "role": "Actualsignedtagged/rawphysicalABIandmeteredalternative" + }, + { + "agent": "batch_escape", + "ownership": "batch.py,BATCH.md", + "role": "Boundedsevenfieldbatch/lifetimeroute, notanotherfullprogramme" + }, + { + "agent": "root", + "ownership": "integration,bridge.py,verify.py,tests,metadata,sourcepins,publication", + "role": "Singleintegratedobjective and significance/verificationgate" + } + ], + "next_discriminating_test": { + "target": "One source-pinned actual QQ16 F0/B1 recovery cut", + "admission": [ + "Both current X/Y observations with literal route order, owner and frame", + "Parent active width73lambda, rows divisible by L^D0(73lambda), global K/guards/passives and unchanged H_b", + "Entry grid/range in the proved subdomain or direct H_b>=W_req proof", + "Exclusive224-output/16-private lease plus disjoint closed backend and wrapper inventories" + ], + "price": [ + "Literal acquisition and descriptor arithmetic", + "Wrappers/maps, wide bridge, all retained outputs and retirement", + "Current endpoint reconnection and recursive usage against named removed source work" + ], + "success": "A legal same-boundary continuation with positive complete margin, or a precise source-bound violated admission/inequality.", + "stop": "Reject that cut at the first failed current-value, geometry, ownership or budget obligation; do not infer a universal QQ16 barrier." + } +} diff --git a/research/qq16-caller-install/inputs/PR4129-bridge.py b/research/qq16-caller-install/inputs/PR4129-bridge.py new file mode 100644 index 0000000000..4d5d99ee8f --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4129-bridge.py @@ -0,0 +1,114 @@ +"""Finite-state stream lift/projection around a separately closed C backend. + +Chris R / Clear1nsight with substantial OpenAI Codex assistance. Apache-2.0. +The injected Tape/markers are the authenticated physical controller's actual API. +The execution loops use only tape symbols, unit moves and finite-state flags. +An immutable unary pattern is built once from paid unary width/reserve descriptors. +No payload is decoded into a Python integer by this adapter. +""" +LOW,COPY,HIGH=5,6,7 + +def need(ok,why): + if not ok:raise ValueError(why) + +class Bridge: + def __init__(self,Tape,blank,left): + need(not {LOW,COPY,HIGH}&{blank,left,0,1},'disjoint pattern and payload markers') + self.blank,self.left=blank,left + self.pattern,self.output=Tape(),Tape() + self.counts={'read':0,'write':0,'move':0} + self.ready=False;self.returned=False + def read(self,t): + self.counts['read']+=1;return t.read() + def write(self,t,v): + self.counts['write']+=1;t.write(v) + def step(self,t,d): + need(d in (-1,1),'unit move');self.counts['move']+=1;t.step(d) + def append(self,t,v):self.write(t,v);self.step(t,1) + def home(self,t): + while self.read(t)!=self.left:self.step(t,-1) + self.step(t,1) + def erase(self,t): + self.home(t) + while self.read(t)!=self.blank: + self.write(t,self.blank);self.step(t,1) + self.home(t) + def _unary(self,t,symbol): + self.home(t) + while self.read(t)!=self.blank: + need(self.read(t)==1,'unary descriptor bit');self.append(self.pattern,symbol);self.step(t,1) + self.home(t) + def _prepare(self,coarse_width,reserve,high_padding=None): + need(not self.ready and not self.returned,'closed pattern setup') + need(len({id(t) for t in (coarse_width,reserve,self.pattern,self.output)})==4,'distinct setup ports') + self.home(coarse_width);need(self.read(coarse_width)==1,'nonempty component width') + if high_padding is not None: + need(high_padding not in (coarse_width,reserve,self.pattern,self.output),'distinct high-padding descriptor') + self.home(high_padding);self.home(reserve) + need(self.read(high_padding)==1,'Gaussian-modulus extra sign bit');self.step(high_padding,1) + while self.read(reserve)!=self.blank: + need(self.read(reserve)==1 and self.read(high_padding)==1,'enough inherited high headroom') + self.step(reserve,1);self.step(high_padding,1) + while self.read(high_padding)!=self.blank: + need(self.read(high_padding)==1,'unary high descriptor');self.step(high_padding,1) + self.home(reserve);self.home(high_padding) + self._unary(reserve,LOW);self._unary(coarse_width,COPY) + if high_padding is None: + self._unary(reserve,HIGH);self.append(self.pattern,HIGH) + else:self._unary(high_padding,HIGH) + self.home(self.pattern);self.ready=True + def prepare(self,coarse_width,reserve,high_padding=None): + need(not self.ready and not self.returned,'closed pattern setup') + ports=[coarse_width,reserve]+([] if high_padding is None else [high_padding]) + need(len({id(t) for t in ports+[self.pattern,self.output]})==len(ports)+2,'distinct borrowed setup ports') + try:self._prepare(coarse_width,reserve,high_padding) + except BaseException: + for t in ports:self.home(t) + self.erase(self.pattern);self.ready=False;raise + def _run(self,source,project): + need(self.ready and not self.returned,'consume preceding protected bridge output') + need(source not in (self.pattern,self.output),'separate borrowed source') + self.home(source);self.home(self.pattern);need(self.read(self.output)==self.blank,'blank bridge output') + parity=False + try: + while self.read(source)!=self.blank: + sign=None + while self.read(self.pattern)!=self.blank: + op=self.read(self.pattern) + if project: + bit=self.read(source);need(bit in (0,1),'complete wide component');self.step(source,1) + if op==LOW:need(bit==0,'nonzero discarded fractional bit') + elif op==COPY:self.append(self.output,bit);sign=bit + else:need(op==HIGH and sign is not None and bit==sign,'incompatible return sign extension') + else: + if op==LOW:self.append(self.output,0) + elif op==COPY: + bit=self.read(source);need(bit in (0,1),'complete coarse component');self.step(source,1) + self.append(self.output,bit);sign=bit + else:need(op==HIGH and sign is not None,'valid immutable pattern');self.append(self.output,sign) + self.step(self.pattern,1) + self.home(self.pattern);parity=not parity + need(not parity,'complete Gaussian real/imaginary pair') + self.home(source);self.home(self.output);self.returned=True;return self.output + except BaseException: + self.home(source);self.home(self.pattern);self.erase(self.output);raise + def promote(self,source):return self._run(source,False) + def project(self,source):return self._run(source,True) + def consume(self): + need(self.returned,'protected output exists');self.erase(self.output);self.returned=False + def close(self): + need(not self.returned,'consume before closing');self.erase(self.pattern);self.ready=False + def cost(self):return dict(self.counts) + +def unary_from_count(count,Tape,Counter): + """Paid encoded-binary to unary setup via the actual amortized ripple counter. + + Setup descriptors are borrowed; the returned unary tape is owned and must be + erased after the immutable conversion pattern is prepared. Counter work and + output tape meters supply its complete cell invoice in the fixtures. + """ + out=Tape();remaining=Counter(count) + while not remaining.finished: + out.append(1);remaining.decrement() + remaining.close();out.rewind() + return out,remaining.tape.meter.record() diff --git a/research/qq16-caller-install/inputs/PR4129-construction.py b/research/qq16-caller-install/inputs/PR4129-construction.py new file mode 100644 index 0000000000..79573076c5 --- /dev/null +++ b/research/qq16-caller-install/inputs/PR4129-construction.py @@ -0,0 +1,224 @@ +"""QQ16 rank-one capsules in the retained physical recursive machine. + +New source inspection and descriptor arithmetic; no retained executable imports. +The caller authenticates word and source bytes before invoking audit(). +This verifies an ABI construction, not execution of the enormous selected cover. +Apache-2.0; substantial OpenAI Codex assistance. +""" +import ast +from collections import Counter +from hashlib import sha256 +import json + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def digest(value): + return sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + + +def coarse_depth(e): + need(type(e) is int and e >= 0, "nonnegative integer active width") + n = 0 + while e >= 73: + e = 48 * (e // 73) + n += 1 + return n + + +def signed_recipe(q, sign, dimension=73): + """Actual MonomialPackets literal inputs around a positive rank-one child. + + This is finite source geometry, independent of numerical values/depth. + Row convention: output address bit i is parity(matrix_rows[i] & input). + The same map is repeated at every tensor-factor position by the backend. + """ + need(type(dimension) is int and 1 <= dimension <= 73, "native literal dimension") + need(type(q) is int and 0 < q < (1 << dimension), "nonzero source line") + need(type(sign) is int and sign in (-1, 1), "literal signed line") + pivot = (q & -q).bit_length() - 1 + columns = (q,) + tuple(1 << i for i in range(dimension) if i != pivot) + rows = [sum(((v >> i) & 1) << j for j, v in enumerate(columns)) for i in range(dimension)] + left, inv = rows[:], [1 << i for i in range(dimension)] + for col in range(dimension): + at = next((j for j in range(col, dimension) if (left[j] >> col) & 1), None) + need(at is not None, "invertible line wrapper") + left[col], left[at] = left[at], left[col] + inv[col], inv[at] = inv[at], inv[col] + for j in range(dimension): + if j != col and ((left[j] >> col) & 1): + left[j] ^= left[col] + inv[j] ^= inv[col] + need(left == [1 << i for i in range(dimension)], "wrapper inverse elimination") + def literal(matrix, offset): + return {"matrix_rows": matrix, "offset": offset, "phase": 0, + "linear_Z4": [0] * dimension, "quadratic_rows": [0] * dimension} + result = {"rank": 1, "right": literal(inv, 0), + "left": literal(rows, q if sign == -1 else 0)} + # Algebraic checks on all generator columns establish the full linear maps. + def act(matrix, value): + return sum(((r & value).bit_count() & 1) << i for i, r in enumerate(matrix)) + for i in range(dimension): + need(act(rows, act(inv, 1 << i)) == 1 << i and + act(inv, act(rows, 1 << i)) == 1 << i, "two exact wrapper inverse orders") + need(act(rows, 1) == q, "positive native direction maps to caller q") + return result + + +def capsule(lam, spacing, before=0, after=0, root_width=None): + """The source prepare_child rank-one descriptor, at parent width 73*lam. + + The rows exponent is a sufficient divisibility promise, not a decoded + actual row allocation. Source prefixes/compact fields/r/global grid remain + untouched, so volume equality only needs this active/after calculation. + """ + need(all(type(x) is int and x >= 0 for x in (before, after)), "spectator widths") + need(type(lam) is int and lam >= 1 and type(spacing) is int and spacing >= 1, + "positive tensor depth and source spacing") + parent = 73 * lam + if root_width is None: + root_width = parent + need(type(root_width) is int and root_width >= parent, "parent within global root width") + child_after = after + 72 * lam * spacing + need(before + parent * spacing + after == before + lam * spacing + child_after, + "same complete packet volume") + available = coarse_depth(parent) - 1 + required = coarse_depth(lam) + need(required <= available, "rank-one child inherits sufficient row stock") + return {"lambda": lam, "parent_width": parent, "child_width": lam, + "global_root_width": root_width, "spacing": spacing, + "before": before, "parent_after": after, "child_after": child_after, + "parent_stock_exponent": coarse_depth(parent), + "inherited_stock_exponent": available, "required_stock_exponent": required, + "packet_address_bits": before + parent * spacing + after, + "child_leaf": lam < 73 or pow(lam, 1000) < root_width} + + +def function(tree, cls, name): + container = next((n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == cls), None) + need(container is not None, "source class " + cls) + node = next((n for n in container.body if isinstance(n, ast.FunctionDef) and n.name == name), None) + need(node is not None, "source method " + cls + "." + name) + return node + + +def source_contract(sources): + """Pin actual source mechanisms without treating their text as execution.""" + need(set(sources) >= {"machine", "root_plan", "selected_binding", "bank_packets", "physical_proof"}, + "complete actual-machine documentary inputs") + trees = {key: ast.parse(sources[key]) for key in + ("machine", "root_plan", "selected_binding", "bank_packets")} + methods = {} + for key, cls, names in ( + ("machine", "Machine", ("prepare_child", "enter_child", "return_node", "primitive_boundary", "node", "run")), + ("bank_packets", "BankPackets", ("gather", "scatter", "commit")), + ("selected_binding", "SelectedBinding", ("group",)), + ): + for name in names: + node = function(trees[key], cls, name) + methods[key + "." + name] = sha256(ast.dump(node, include_attributes=False).encode()).hexdigest() + selected = next(n for n in trees["selected_binding"].body + if isinstance(n, ast.ClassDef) and n.name == "SelectedBinding") + constants = {} + for node in selected.body: + if isinstance(node, ast.Assign) and len(node.targets) == 1 and isinstance(node.targets[0], ast.Name): + try: + constants[node.targets[0].id] = ast.literal_eval(node.value) + except (ValueError, TypeError): + pass + need({k: constants[k] for k in ("dimension", "maximum_rank", "families", "slots", "private")} == + {"dimension": 73, "maximum_rank": 48, "families": 14336, "slots": 704, "private": 8}, + "actual selected machine dimensions and inventory") + # These are source-binding guards; the capsule induction is in NATIVE.md. + required = { + "machine": [ + 'width = Count(self.c("columns"))', + 'tail.multiply_small(self.binding.dimension - rank)', + 'after = Count.product(tail, self.c("spacing"))', + 'value = self.c("unused") if name == "rows" else width if name == "width" else after if name == "after" else self.c(name)', + 'self.parking.park()', 'self.parking.restore()', + 'self.group.code[self.pc - 1][2:] == (target, rank)', + 'need(remainder.zero() and not unused.zero(), "complete fresh row divisor at node")', + ], + "root_plan": ['self.fast = compare(selected, Q0) > 0', + 'stock.multiply_small(self.level_divisor)', + 'save("padded_rows", times(multiples, stock))'], + "bank_packets": ['Layout: prefix, family, cover, unused row, complete within-row packet.', + 'copy_bits(source, self.packets[slot], extent)'], + "selected_binding": ['code.extend(self.codes[call["orientation"]])', + 'keys = tuple((o.family, self.cover.rank(multiply(g, o.sigma_columns))) for o in owners)'], + "physical_proof": ['D0(e)=0 for e<73, otherwise 1+D0(48 floor(e/73))', + 'I keep d,K,G,H and the coefficient grid global.'], + } + for key, needles in required.items(): + for needle in needles: + need(needle in sources[key], "actual physical source anchor: " + key + ": " + needle) + return {"class_constants": {k: constants[k] for k in + ("dimension", "maximum_rank", "families", "slots", "private")}, + "method_ast_sha256": methods, + "source_sha256": {k: sha256(sources[k].encode()).hexdigest() for k in sorted(required)}, + "retained_execution_rerun": False} + + +def events(word): + need(type(word) is list and all(type(e) is list and e for e in word), "literal event word") + lines = [(i, e) for i, e in enumerate(word) if e[0] == "line"] + need(lines and lines[0] == (4, ["line", "W0", 0, 1]), "actual first H1 event") + need(word[2:4] == [["clear", "W0", "hole0"], ["add", "W0", "Y0", "1"]], + "first child reads owned current-Y copy") + inventory = Counter() + scope = [] + covered = [] + for i, e in enumerate(word): + if e[0] == "begin": + scope.append(e[1]) + elif e[0] == "end": + need(scope and scope.pop() == e[1], "balanced caller private lifetime") + elif e[0] == "line": + need(not scope and len(e) == 4 and type(e[2]) is int and 0 <= e[2] < 112 + and type(e[3]) is int and e[3] in (-1, 1), "isolated rank-one native call") + typ = "initial_positive" if e[1].startswith("W") and e[3] == 1 else \ + "query_negative" if e[1] in ("Z10", "Z11") and e[3] == -1 else \ + "response_positive" if e[1] == "Z10" and e[3] == 1 else None + need(typ is not None, "known actual event variant") + inventory[typ] += 1 + covered.append({"event": i, "target": e[1], "port": e[2], "sign": e[3], "variant": typ, + "child_rank": 1, "wrapper_count": 2}) + need(not scope, "closed caller lifetimes") + need(inventory == {"initial_positive": 112, "query_negative": 104, "response_positive": 8}, + "all 224 actual signed variants") + need({e["port"] for e in covered[:112]} == set(range(112)), "all initial ports") + return {"count": len(covered), "inventory": dict(sorted(inventory.items())), + "events": covered, "events_sha256": digest(covered), "first_event": covered[0], + "native_inside_scalar_private_scope": False} + + +def audit(word, source_texts): + bound = source_contract(source_texts) + covered = events(word) + fixtures = [capsule(lam, spacing, 3, 5, 73 * lam + 19) + for lam, spacing in ((1, 1), (2, 2), (72, 73), (73, 100000), + (74, 19), (1000, 4096), (1000000, 200000))] + need(all(x["child_width"] < x["parent_width"] for x in fixtures), "strict source descent") + controls = {} + for name, fn in ( + ("first_child_borrowed_target", lambda: events(word[:4] + [["line", "Y0", 0, 1]] + word[5:])), + ("missing_line", lambda: events(word[:4] + word[5:])), + ("parent_too_narrow", lambda: capsule(73, 1, root_width=73)), + ("zero_spacing", lambda: capsule(73, 0)), + ("source_row_contract_changed", lambda: source_contract({**source_texts, "machine": source_texts["machine"].replace( + 'value = self.c("unused") if name == "rows"', 'value = self.c("rows") if name == "rows"')})), + ): + try: + fn() + except ValueError: + controls[name] = "rejected" + else: + raise ValueError("ineffective control " + name) + return {"schema": "qq16-physical-recursive-capsule-v1", "source_binding": bound, + "literal_coverage": covered, "descriptor_fixtures": fixtures, "controls": controls, + "quantified_claim": "For every admitted physical parent e=73*lambda, R divisible by L^D0(e), and positive lambda: each of the 224 rank-one events can use the existing prepare_child descriptor with width lambda, rows R/L and after increased by 72*lambda*K; its required recursive stock divides R/L and its complete packet volume is unchanged.", + "scope": "Descriptor and source-contract composition. The retained selected program does not contain the new recovery word. Output allocation, chronological caller connection, new program registration, precision and complete tariff are separate integration obligations."} diff --git a/research/qq16-caller-install/installer.py b/research/qq16-caller-install/installer.py new file mode 100644 index 0000000000..fdb932baa0 --- /dev/null +++ b/research/qq16-caller-install/installer.py @@ -0,0 +1,186 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Install a completed whole-cover recovery service in the actual parent. + +Only encoded Counts and source Tape operations inspect input-sized quantities. +Finite source bindings and the three exclusive engines are compiled first. +Chris R / Clear1nsight, substantial OpenAI Codex assistance. +""" + +def need(ok,why): + if not ok:raise ValueError(why) + + +def owned_tapes(owner): + """Compile-time census of fixed physical roles, excluding control bindings. + + No Tape body or input-sized descriptor is traversed. The separately shared + original child is inventoried once, rather than mistaken for an alias. + """ + import types + from records import Tape + seen=set();tapes={} + skip={'binding','catalogue','group','data','source','native_child','at_fence', + 'observe','codes','recipes','template','packet','core','events','word'} + def visit(v): + if id(v) in seen:return + seen.add(id(v)) + if isinstance(v,Tape):tapes[id(v)]=v;return + if isinstance(v,dict): + for item in v.values():visit(item) + elif isinstance(v,(tuple,list)): + for item in v:visit(item) + elif not isinstance(v,(type,types.ModuleType,types.FunctionType,types.MethodType)) and hasattr(v,'__dict__'): + for k,item in vars(v).items(): + if k not in skip:visit(item) + visit(owner) + return tuple(tapes.values()) + + +class Installation: + def __init__(self, parent_binding, service_machine, native_child, + PacketCompiler, CallerStorage, ServiceBank, fields=224, adopt=True): + from bank_packets import BankPackets + from cardinal_counts import Count + from machine import transfer + from records import Tape + from scalar_words import require_zero + from scratch_pool import ScratchPool + from session import OuterScope + from stream import Counter + from words import BLANK + need(service_machine is not native_child and service_machine.native_child is native_child, + 'one exclusive original C backend for the sequential service') + self.binding=parent_binding + self.service,self.native_child=service_machine,native_child + self.fields=fields + need(type(adopt) is bool,'compiled publication choice') + self.adopt=adopt + self.acquisition=BankPackets(parent_binding.families,1,fields) + self.compiler=PacketCompiler() + self.bundle=ServiceBank(Tape,Counter,BLANK,fields) + self.pool=ScratchPool(256);self.scope=OuterScope(self.pool) + self.engine_roles=(owned_tapes(service_machine),owned_tapes(native_child)) + need(not ({id(t) for t in self.engine_roles[0]} & {id(t) for t in self.engine_roles[1]}), + 'separate complete native and service Ordinary/Compact inventories') + auxiliary=(*self.compiler.roles.values(),*self.compiler.snapshots,*self.compiler.pool.tapes, + self.bundle.bank,*self.pool.tapes) + self.storage=CallerStorage(Tape,Count,Counter,BLANK,transfer,require_zero, + outputs=fields,private=16,expected_event=parent_binding.global_fence, + engines=(service_machine,native_child), + external_roles=(*self.engine_roles[0],*self.engine_roles[1],*auxiliary)) + self.calls=0 + self.completed=False + + def discard(self): + """Retire owned partial service backing after a controlled rejection. + + The enclosing source Machine owns its current bank and performs its + own discard. Borrowed original root input and descriptors are untouched. + Arbitrary asynchronous interruption recovery is not asserted. + """ + from session import erase_marker + from words import LEFT,BLANK + def retire(tape): + # Successful/controlled-return contracts place these fixed roles + # at their canonical origins, sometimes with the marker erased. + tape.step(-1) + marker=tape.read() + need(marker in (LEFT,BLANK),'controlled discard at canonical role origin') + if marker==BLANK:tape.write(LEFT) + tape.step(1) + tape.clear() + if marker==BLANK:erase_marker(tape) + for engine in (self.service,self.native_child):engine.discard() + for roles in self.engine_roles: + for tape in roles:retire(tape) + for tape in (*self.storage.roles,*self.acquisition.packets, + self.acquisition.output,*self.acquisition.pool.tapes, + self.bundle.bank,*self.compiler.roles.values(),*self.compiler.snapshots, + *self.compiler.pool.tapes,*self.pool.tapes): + retire(tape) + self.acquisition.source=self.acquisition.selection=None + self.acquisition.state='closed' + self.bundle.state='closed';self.compiler.closed=True + self.storage.stage='closed' + self.storage.parent=self.storage.cut=self.storage.targets=self.storage.acquisition=None + self.completed=False + + def __call__(self,parent): + from cardinal_counts import Count + from session import borrowed_count,sealed_constructors + from words import BLANK + from qq16_decoder import service_descriptors + need(parent.binding is self.binding and parent is not self.service + and parent is not self.native_child,'literal caller and separate engines') + need(parent.fence_calls==1 and self.storage.stage=='closed' + and self.bundle.state=='closed','one closed caller installation per root invocation') + parent_roles={id(t) for t in owned_tapes(parent)} + need(not parent_roles.intersection(id(t) for roles in self.engine_roles for t in roles), + 'active producer and original/service engines have distinct fixed inventories') + self.calls+=1 + self.completed=False + owned=[] + def keep(v):owned.append(v);return v + try: + with sealed_constructors(),self.scope.installed(): + full_row=keep(Count(parent.c('row_bits'))) + full_row.multiply_small(parent.binding.cover.size) + prefix_extent=keep(Count.product(parent.c('unused'),full_row)) + full_extent=keep(Count.product(parent.c('prefixes'),prefix_extent)) + self.acquisition.select(tuple((i,0) for i in range(self.fields))) + with self.scope.suspended(): + fields=self.acquisition.gather(parent.roles['current'], + *(borrowed_count(v) for v in + (parent.c('prefixes'),parent.c('unused'),full_row))) + self.compiler.compile_global(parent,fields[0],self.binding.global_fence) + self.storage.begin(parent,self.acquisition,tuple(range(self.fields))) + payload=self.bundle.assemble(fields,parent.c('prefixes'),prefix_extent) + descriptors=service_descriptors(parent,Count,self.service.binding.families) + try: + with self.scope.suspended():returned=self.service.run(payload,descriptors) + self.bundle.extract(returned,fields,self.storage.outputs, + parent.c('prefixes'),prefix_extent) + finally: + for value in descriptors.values():value.close() + self.storage.decoded(full_extent) + self.storage.ready(full_extent,True) + with self.scope.suspended(): + self.storage.commit(*(borrowed_count(v) for v in + (parent.c('prefixes'),parent.c('unused'),full_row)),adopt=self.adopt) + self.compiler.close() + need(self.service.closed and self.native_child.closed and + self.service.output.read()==BLANK and self.native_child.output.read()==BLANK, + 'completed engines and consumed protected outputs') + need(self.bundle.state=='closed' and self.storage.stage=='closed', + 'service banks and caller output generation retired') + self.completed=True + except BaseException: + self.discard() + raise + finally: + for value in reversed(owned):value.close() + self.pool.empty() + + +def attach_root(root_layer, producer_machine): + """Compile-time replacement of the actual RootLayer.fast_core Machine. + + Retain its former original Machine as the producer's separate child engine. + No payload, fixed public input/output port or root-plan field is rebound. + """ + from words import BLANK + need(root_layer.closed and producer_machine.closed and + root_layer.current.read()==BLANK and root_layer.output.read()==BLANK, + 'closed root construction before numerical input') + need(producer_machine.native_child is root_layer.machine, + 'retain the root original C engine rather than an endpoint double') + need(root_layer.machine.closed and root_layer.machine.output.read()==BLANK, + 'closed inherited exact C endpoint') + original=root_layer.machine.binding + replacement=producer_machine.binding + need(all(getattr(original,k)==getattr(replacement,k) + for k in ('dimension','maximum_rank','families')) and + original.cover.size==replacement.cover.size, + 'unchanged root-plan dimension rank family and cover geometry') + root_layer.machine=producer_machine + return root_layer diff --git a/research/qq16-caller-install/integrated-fixture.py b/research/qq16-caller-install/integrated-fixture.py new file mode 100644 index 0000000000..871a21846e --- /dev/null +++ b/research/qq16-caller-install/integrated-fixture.py @@ -0,0 +1,286 @@ +# SPDX-License-Identifier: Apache-2.0 +"""One continuous reduced physical caller/recovery/current-return/bridge run. + +Authenticated actual primitive implementations are used at every arithmetic +endpoint. The two-dimensional finite control and initial/expected arrays are +explicit test fixtures, not a selected O73 execution or production loader. +""" +from pathlib import Path +import sys,json +from hashlib import sha256 +from types import SimpleNamespace +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +import runtime +runtime.cold() +P=runtime.module('qq16_producer',HERE/'producer.py') +D=runtime.module('qq16_decoder',HERE/'decoder.py') +K=runtime.module('qq16_packet',HERE/'packet.py') +L=runtime.module('qq16_lifecycle',HERE/'lifecycle.py') +J=runtime.module('qq16_installer',HERE/'installer.py') +C=runtime.module('qq16_connection',HERE/'connection.py') +from machine import Machine,transfer +from cardinal_counts import Count +from records import Tape +from ordinary import Ordinary +from macro_code import Code +from session import erase_marker +from selected_binding import Group,literal +from fixture_binding import FixtureBinding +from cover import OrthogonalCover +from scalar_program import ScalarProgram +from words import BLANK +from stream import Counter +from root_layer import RootLayer + + +def native(): + return Ordinary(2,SimpleNamespace(codes=SimpleNamespace(q=2)),SimpleNamespace(families=0), + (Code((('unreachable',),),0),),capacity=64) + + +def raw(t):return bytes(t.cells[1:]).rstrip(bytes([BLANK])) +def encode(values,h):return bytes((x>>b)&1 for pair in values for x in pair for b in range(h)) +def recipe(q,sign,dimension): + P.need(q==1 and dimension==2 and sign in (-1,1),'reduced actual signed line') + return {'right':literal((1,2)),'left':literal((1,2),0 if sign==1 else 1)} + + +class CallerBinding: + dimension=2;maximum_rank=1;families=4;slots=4;private=1 + events=('Q_signed_pair','intervening_dirty_helper','idle_pair1','both_bridge_legs') + global_fence=1 + def __init__(self,wrong_sign=False): + self.cover=OrthogonalCover(2);self.wrong_sign=wrong_sign + self.catalogue={k:ScalarProgram(*k) for k in [('add',1,1),('add',-1,1),('scale',-1,1)]} + def group_count(self,event):return 1 + def group(self,event,subgroup,owner): + P.need(subgroup==0 and 0<=event<4,'literal reduced parent control') + if event==0: + keys=((0,owner),(1,owner));code=[];recipes={} + for target,sign in ((0,1),(1,1 if self.wrong_sign else -1)): + for name,record in [('g',literal(self.cover.unrank(owner))), + ('right',recipe(1,sign,2)['right']), + ('left',recipe(1,sign,2)['left'])]: + recipes[str(target)+name]=record + code.extend((('monomial',-1,target,str(target)+'g',True), + ('monomial',-1,target,str(target)+'right',False), + ('child',-1,target,1), + ('monomial',-1,target,str(target)+'left',False), + ('monomial',-1,target,str(target)+'g',False))) + return Group(keys,tuple(code),recipes) + if event==1: + # Nonconstant dirty helper receives two real translation operations. + return Group(((3,owner),),(('monomial',-1,0,'shift',False), + ('monomial',-1,0,'shift',False)),{'shift':literal((1,2),1)}) + if event==2: + return Group(((2,owner),),(('child',-1,0,1),),{}) + return Group(((0,owner),(2,owner),(3,owner),(1,owner)), + (('scalar',-1,0,1,('add',1,1)), + ('scalar',-1,2,3,('add',-1,1))),{}) + +class OriginalBinding(FixtureBinding): + """Direct sum of two disjoint source complete-C fixture groups. + + This preserves the original source instructions and matches the caller's + four-family row-stock geometry; it is still explicitly reduced geometry. + """ + families=4 + def group_count(self,event): + P.need(event==0,'original reduced C event') + return 2 + def group(self,event,subgroup,owner): + P.need(subgroup in (0,1),'original disjoint complete-C group') + source=super().group(event,0,owner) + return Group(tuple((family+2*subgroup,d) for family,d in source.keys), + source.code,source.recipes) + + +def line(values,mask,sign): + """Independent exact Gaussian 2x2 tensor on one physical address bit.""" + result=list(values) + for a in range(4): + if a&mask:continue + b=a^mask;x,y=values[a];u,v=values[b] + plus=((x-y+u+v)//2,(x+y-u+v)//2) + other=((x+y+u-v)//2,(-x+y+u+v)//2) + P.need(all(z%2==0 for z in (x-y+u+v,x+y-u+v,x+y+u-v,-x+y+u+v)), + 'exact reduced input grid') + result[a],result[b]=(plus,other) if sign==1 else (other,plus) + return result + + +def expected(values,binding): + result=list(values) + for prefix in range(2): + for owner in range(2): + start=prefix*32+owner*4 + x=values[start:start+4];y=values[start+8:start+12] + u=values[start+16:start+20];v=values[start+24:start+28] + direction=P.act(binding.cover.unrank(owner),1) + mask=((direction&1)<<1)|((direction>>1)&1) + # Q is H+ on X and H- on Y. D recovers both. The reduced current + # return then applies W+=Z, Z-=W, W=H-(W), exactly its literal word. + z=[(-a,-b) for a,b in y] + w=line([(a+c,b+d) for (a,b),(c,d) in zip(x,y)],mask,-1) + idle=line(u,2,1) # source prepare_child selects the leading column + result[start:start+4]=[(a+c,b+d) for (a,b),(c,d) in zip(z,idle)] + result[start+8:start+12]=w + result[start+16:start+20]=idle + result[start+24:start+28]=[(a-c,b-d) for (a,b),(c,d) in zip(v,w)] + return result + + +def run_case(mutation=None): + binding=CallerBinding(mutation=='wrong_producer_sign') + word=[['clear','Z0','current'],['add','Z0','X0','1'],['line','Z0',0,-1], + ['clear','W0','current'],['add','W0','Y0','1'],['line','W0',0,1]] + decoder=D.DecoderBinding(word,{'recipes':[{'q':1}]},{},binding.cover,Group,literal, + ScalarProgram,recipe,P.map_group,P.order,ports=1,dimension=2,continuation=True) + original=OriginalBinding() + root=RootLayer(original,native(),original.catalogue) + child=root.machine + public_root=(root.current,root.output,root.plan) + inherited_native=child.monomial.compact.binary.native + try: + C.install(root,binding,decoder,lambda:inherited_native) + except ValueError as exc: + P.need('three distinct admitted Ordinary inventories' in str(exc), + 'factory rejects shared ordinary backend') + else:raise ValueError('factory accepted shared ordinary backend') + P.need(root.machine is child,'rejected factory preserves original root') + installation=C.install(root,binding,decoder,native) + parent=root.machine + service=installation.service + P.need(parent.at_fence is installation and parent.native_child is child and + public_root==(root.current,root.output,root.plan), + 'actual connection factory installs root and exact original child') + seen=[] + def fence(parent): + seen.append((parent.event,parent.cover_index,parent.pc,parent.bank.state)) + if mutation=='early_fence': + parent.cover_index-=1 + if mutation=='output_alias': + installation.storage.outputs=(installation.acquisition.packets[0],installation.storage.outputs[1]) + installation(parent) + parent.at_fence=fence + # Attachment rejection controls inspect the same closed objects before + # numerical input, temporarily exposing the retained original endpoint. + # The successful execution below uses the factory-created attachment. + root.machine=child + root.closed=False + try: + J.attach_root(root,parent) + except ValueError as exc: + P.need('closed root construction' in str(exc),'active RootLayer attachment rejected') + else:raise ValueError('active RootLayer attachment accepted') + finally:root.closed=True + parent.native_child=service + try: + J.attach_root(root,parent) + except ValueError as exc: + P.need('retain the root original C engine' in str(exc),'wrong inherited endpoint rejected') + else:raise ValueError('wrong original RootLayer child accepted') + finally:parent.native_child=child + for attribute in ('dimension','maximum_rank','families','cover'): + original_value=getattr(binding,attribute) + setattr(binding,attribute,SimpleNamespace(size=3) if attribute=='cover' else original_value+1) + try: + J.attach_root(root,parent) + except ValueError as exc: + P.need('unchanged root-plan dimension rank family and cover geometry' in str(exc), + 'changed root-plan geometry rejected: '+attribute) + else:raise ValueError('changed root-plan geometry accepted: '+attribute) + finally:setattr(binding,attribute,original_value) + root.machine=parent + P.need(root.machine is parent and public_root==(root.current,root.output,root.plan), + 'actual RootLayer compile-time attachment preserves public roles and plan') + values=[(256*((i*7)%19-9),256*((i*11)%23-11)) for i in range(64)] + source=Tape();data=encode(values,32) + for bit in data:source.append(bit) + source.rewind() + descriptors={k:Count.literal(v) for k,v in dict(prefixes=2,rows=8,front=0,compact_bits=0, + before=0,width=2,after=0,back=0,spacing=1,guard=1,residue=0,component_bits=32, + coefficients=1,root_width=2).items()} + descriptor_images={k:bytes(v.tape.cells) for k,v in descriptors.items()} + for tape in (*installation.storage.roles,*parent.private): + for bit in (1,0,1,1):tape.append(bit) + tape.rewind() + try: + result=parent.run(source,descriptors);actual=raw(result) + P.need(actual==encode(expected(values,binding),32),'composed producer recovery current-return and both bridge outputs') + P.need(raw(source)==data and all(bytes(v.tape.cells)==descriptor_images[k] for k,v in descriptors.items()), + 'complete borrowed entry and descriptors preserved') + P.need(seen==[(1,2,0,'closed')] and installation.calls==1 and installation.completed, + 'one exact completed producer fence installed') + P.need(parent.closed and service.closed and child.closed and installation.storage.stage=='closed' + and installation.bundle.state=='closed' and installation.compiler.closed, + 'all caller/service/native/compiler lifetimes retired') + P.need(all(t.read()==BLANK for t in (*installation.storage.roles,*parent.parked)), + 'dirty owned helpers and output generations retired') + answer={'status':'PASS_CONTINUOUS_PHYSICAL_CALLER_INSTALLATION','sha256':sha256(actual).hexdigest(), + 'outer_prefixes':2,'families':4,'owners':2,'complex_values':64,'physical_component_bits':32, + 'all_entry_exit_outputs_checked':True,'actual_signed_original_C_calls':True, + 'borrowed_preserved':True,'dirty_owned_scratch_retired':True,'both_bridge_legs':True, + 'actual_root_layer_attachment_checked':True,'root_attachment_negative_controls':6, + 'actual_connection_factory_checked':True,'factory_inventory_rejection_checked':True, + 'source_preparation':'test oracle only','scope':'Reduced physical composition; selected O73 proof and production cost remain separate.'} + result.clear() + if mutation is None: + # A different nonconstant input exercises fresh generations on the + # same three engines and the same Installation after adoption. + second_values=[(-b,a) for a,b in reversed(values)] + second_data=encode(second_values,32) + source.clear() + for bit in second_data:source.append(bit) + source.rewind() + result=parent.run(source,descriptors) + second_actual=raw(result) + P.need(second_actual==encode(expected(second_values,binding),32) and + raw(source)==second_data and installation.calls==2 and installation.completed, + 'same physical engines accept a fresh full generation') + P.need(seen==[(1,2,0,'closed')]*2 and installation.storage.stage=='closed' and + all(bytes(v.tape.cells)==descriptor_images[k] for k,v in descriptors.items()), + 'second generation preserves descriptors and closes at exact fence') + answer['same_engine_second_generation_sha256']=sha256(second_actual).hexdigest() + answer['completed_generations']=2 + result.clear() + return answer + except ValueError: + if mutation in ('early_fence','output_alias'): + P.need(raw(source)==data and source.head==1 and + all(bytes(v.tape.cells)==descriptor_images[k] and v.tape.head==1 + for k,v in descriptors.items()), + 'internal rejection preserves borrowed bytes and heads before fixture cleanup') + P.need(installation.storage.stage=='closed' and installation.bundle.state=='closed' + and installation.compiler.closed and service.closed and child.closed + and all(t.read()==BLANK for t in J.owned_tapes(installation)), + 'Installation.discard closes all owned backing before fixture cleanup') + raise + finally: + source.clear() + for v in descriptors.values():v.close() + # Rejection cleanup belongs to the fixture, with no postfailure result + # admitted. Successful cleanup above is checked before this recovery. + for m in (parent,service,child):m.discard() + for t in (*installation.storage.roles,installation.bundle.bank):t.clear() + installation.compiler.close() + + +def main(): + good=run_case();rejects={} + for mutation,reason in [('wrong_producer_sign','composed producer recovery'), + ('early_fence','whole-cover producer fence'), + ('output_alias','exclusive physical caller/native/wrapper inventory')]: + try:run_case(mutation) + except ValueError as exc: + P.need(reason in str(exc),'targeted integrated rejection '+mutation+': '+str(exc)) + rejects[mutation]=str(exc) + else:raise ValueError('accepted integrated mutation '+mutation) + return {'continuous':good,'rejections':rejects, + 'internal_rejection_cleanup_checked_before_fixture_recovery':True} + + +if __name__=='__main__': + try:print(json.dumps(main(),sort_keys=True)) + finally:runtime.cleanup() diff --git a/research/qq16-caller-install/lifecycle.py b/research/qq16-caller-install/lifecycle.py new file mode 100644 index 0000000000..56c1636801 --- /dev/null +++ b/research/qq16-caller-install/lifecycle.py @@ -0,0 +1,537 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Dedicated finite caller storage and paid immutable-port return. + +Chris R / Clear1nsight, OpenAI Codex assistance. The Tape, Count, Counter, +copy/transfer and primitive-boundary bodies are inherited, injected sources. +No numerical address or packet length is decoded into Python control. +""" + +def need(ok, reason): + if not ok: + raise ValueError(reason) + + +class CallerStorage: + """One exclusive 224-output / 16-private inventory outside active Machine. + +Only the fixed role alphabet and finite stage enter control. A suspended +caller's primitive pools are never used as recovery storage. This class +implements storage ownership, not the arithmetic meaning of outputs. +""" + def __init__(self, Tape, Count, Counter, blank, transfer, require_zero, + external_roles=(), outputs=224, private=16, expected_event=4, engines=()): + need(type(outputs) is int and outputs > 0 and type(private) is int and private > 0, + 'fixed positive caller role alphabet') + self.outputs = tuple(Tape() for _ in range(outputs)) + self.private = tuple(Tape() for _ in range(private)) + self.Count, self.Counter = Count, Counter + self.blank, self.transfer, self.require_zero = blank, transfer, require_zero + self.external_roles = tuple(external_roles) + need(type(expected_event) is int and expected_event >= 0, 'fixed producer fence event') + self.expected_event = expected_event + self.engines = tuple(engines) + self.stage = 'closed' + self.parent = self.cut = self.targets = self.acquisition = None + self._distinct() + + @property + def roles(self): + return (*self.outputs, *self.private) + + def _distinct(self): + acquired = () if getattr(self, 'acquisition', None) is None else ( + *self.acquisition.packets, self.acquisition.output, *self.acquisition.pool.tapes) + all_roles = (*self.roles, *acquired, *self.external_roles) + need(len({id(t) for t in all_roles}) == len(all_roles), + 'exclusive physical caller/native/wrapper inventory') + + def _parent_cut(self): + p = self.parent + need(p is not None and not p.closed and p.mode == 'group' and p.group is None + and p.bank.state == 'closed' and p.event == self.expected_event + and p.subgroup == 0 and p.pc == 0 + and p.cover_index == p.binding.cover.size, + 'completed whole-cover parent fence') + need((p.event, p.subgroup, p.cover_index, p.pc, id(p.roles['current'])) == self.cut, + 'same immutable parent continuation and bank binding') + p.primitive_boundary() + self._distinct() + service_roles = (*self.roles, *self.acquisition.packets, self.acquisition.output, + *self.acquisition.pool.tapes) + need(not any(t is x for t in service_roles for x in + (*p.parked, *p.capsule.values(), p.output, p.bank.output, + p.parking.stack, p.parking.reverse)), + 'dedicated recovery roles disjoint from all live parent roles') + need(self.acquisition.state == 'gathered' + and self.acquisition.source is p.roles['current'] + and self.acquisition.selection == {(family, 0): i + for i, family in enumerate(self.targets)}, + 'actual whole-family acquired source and owner binding') + need(not any(t is x for t in self.roles for x in + (*self.acquisition.packets, self.acquisition.output, + *self.acquisition.pool.tapes)), 'outputs separate from borrowed acquired fields') + + def begin(self, parent, acquisition, targets): + need(self.stage == 'closed', 'previous output generation retired') + need(type(targets) is tuple and len(targets) == len(self.outputs) + and len(set(targets)) == len(targets) + and all(type(i) is int and 0 <= i < parent.binding.families for i in targets), + 'distinct finite persistent destination families') + need(acquisition.families == parent.binding.families and acquisition.covers == 1 + and acquisition.slots == len(targets), 'whole-cover family acquisition layout') + self.parent, self.acquisition, self.targets = parent, acquisition, targets + self.cut = (parent.event, parent.subgroup, parent.cover_index, parent.pc, + id(parent.roles['current'])) + self._parent_cut() + # The service owns these tapes exclusively. Arbitrary old contents are + # disposable, but erasure is an actual paid tape operation. + for tape in self.roles: + tape.clear() + self.stage = 'decode' + + def output(self, index): + need(self.stage in ('decode', 'reconnect') and type(index) is int + and 0 <= index < len(self.outputs), 'live output role') + return self.outputs[index] + + def temporary(self, index): + need(self.stage in ('decode', 'reconnect') and type(index) is int + and 0 <= index < len(self.private), 'live private role') + return self.private[index] + + def _close_private(self, extent): + for tape in self.private: + tape.rewind() + if tape.read() != self.blank: + self.require_zero(tape, extent) + tape.clear() + + def decoded(self, extent): + need(self.stage == 'decode', 'completed decoder before reconnection') + self._parent_cut() + self._close_private(extent) + self.stage = 'reconnect' + + def ready(self, extent, engines_closed): + need(self.stage == 'reconnect', 'completed reconnection before publication') + need(engines_closed, 'native and wrapper completed outputs consumed') + for engine in self.engines: + need(engine is not self.parent and engine.closed + and engine.output.read() == self.blank, 'separate closed engine and consumed output') + engine.pool.empty() + if hasattr(engine, 'compact'): + need(engine.compact.closed and engine.compact.binary.native.closed, + 'closed wrapper Compact and ordinary engine') + if hasattr(engine, 'primitive_boundary'): + engine.primitive_boundary() + engine.parking.empty() + self._parent_cut() + self._close_private(extent) + # Preflight every output before the first destructive parent write. + # The Count remains encoded and borrowed; countdown owns its copy. + for tape in self.outputs: + tape.rewind() + counter = self.Counter(extent) + try: + while not counter.finished: + need(tape.read() in (0, 1), 'complete returned binary output') + tape.step(1) + counter.decrement() + need(tape.read() == self.blank, 'exact returned output extent') + finally: + tape.rewind() + counter.close() + self.stage = 'ready' + + def commit(self, prefixes, unused_rows, full_cover_row_bits, adopt=False): + need(self.stage == 'ready', 'all decoder and continuation reads completed') + self._parent_cut() + # D and reconnection have completed every borrowed acquired-field read. + # Each source transfer clears that old field, consumes its owned result, + # and returns heads. The immutable parent current bank is still untouched. + for tape, target in zip(self.outputs, self.acquisition.packets): + self.transfer(tape, target) + # Source BankPackets copies every unselected family unchanged, replaces + # all selected fields, then performs its paid fixed-current-bank commit. + self.acquisition.scatter(self.parent.roles['current'], prefixes, + unused_rows, full_cover_row_bits) + if adopt: + adopt_bank(self.parent, self.acquisition, self.blank, self.external_roles) + else: + self.acquisition.commit(self.parent.roles['current']) + self.stage = 'closed' + self.parent = self.cut = self.targets = self.acquisition = None + need(all(t.read() == self.blank for t in self.roles), 'all caller work retired') + + +def current_bindings(parent): + """Finite source role tables must agree; no body/head observations.""" + expected = (*parent.roles.values(), *parent.bank.packets, *parent.private) + need(tuple(parent.parked) == expected and tuple(parent.parking.roles) == expected, + 'complete current-role/parked/parking binding correspondence') + need(len({id(t) for t in expected}) == len(expected), 'distinct parent role table') + return expected + + +def adopt_bank(parent, acquisition, blank, external_roles=()): + """Opt-in finite role exchange at a completed, closed-bank caller fence. + + Public parent.output and the borrowed run input retain their physical + identities. No current/output aliases may escape this compiled boundary. + Replaces only the final BankPackets.commit interval, after scatter. + """ + from words import LEFT + from session import erase_marker + old = parent.roles['current'] + new = acquisition.output + previous = current_bindings(parent) + need(not parent.closed and parent.group is None and parent.mode == 'group' + and parent.bank.state == 'closed' and parent.bank.source is None, + 'closed parent bank before internal role adoption') + need(acquisition.state == 'returned' and acquisition.source is old + and not acquisition.pool.live, 'completed owned replacement bank') + need(old is not new and new not in previous + and new not in (*parent.capsule.values(), parent.output, + parent.bank.output, parent.parking.stack, parent.parking.reverse), + 'replacement disjoint from all parent roles') + need(old not in external_roles and new not in external_roles, + 'no cached external binding to exchanged current/output roles') + need(new.read() in (0, 1), 'complete nonempty replacement bank') + # These are actual head-relative origin checks, not numeric head resets. + for tape in (old, new): + tape.step(-1) + try: need(tape.read() == LEFT, 'canonical exchange origin') + finally: tape.step(1) + new.rewind() + try: + while True: + symbol = new.read() + if symbol == blank: break + need(symbol in (0, 1), 'opaque binary replacement alphabet') + new.step(1) + finally: + new.rewind() + # A single finite-control transposition updates every source role table. + # Ancestor frames contain encoded bodies in logical-role order, not aliases. + replacement = tuple(new if tape is old else tape for tape in previous) + parent.roles['current'] = new + parent.parked = replacement + parent.parking.roles = replacement + acquisition.output = old + acquisition.source = None # All reads of this borrowed source have ended. + current_bindings(parent) + old.clear() # Discarding the old current bank is still paid. + erase_marker(old) + acquisition.release() + + +def parent_source_audit(sources, original_sources): + """Byte-level compatibility with Sagar Thakrar's #3464 source boundary.""" + import hashlib + names = ('machine.py', 'parking.py', 'bank_packets.py', 'selected_binding.py') + need(all(sources[n] == original_sources[n] for n in names), + 'exact #3464 principal source compatibility') + return {n: hashlib.sha256(sources[n]).hexdigest() for n in names} + + +def fixture(families=224, adopt=False): + """Actual Tape/BankPackets/Machine execution of the whole-cover fence. + + The service's payload transformation is an identity storage witness, not + QQ16 arithmetic. The integrated continuation checker must separately bind + D/G and the current-value endpoint. All 224 destination families and 16 + private roles are exercised; geometry and native backend remain reduced. + """ + width = 2 + from types import SimpleNamespace + from cardinal_counts import Count + from fixture_binding import FixtureBinding + from selected_binding import Group + from machine import Machine, copy_symbols, transfer + from bank_packets import BankPackets + from macro_code import Code + from ordinary import Ordinary + from records import Tape + from stream import Counter + from scratch_pool import ScratchPool + from session import OuterScope, sealed_constructors + from scalar_words import require_zero + from words import BLANK + from hashlib import sha256 + + need(families >= 4, 'bounded lifecycle fixture domain') + family_count = families + class Binding(FixtureBinding): + families, slots, private = family_count, 4, 1 + events = ('complete_tensor', 'both_bridge_legs') + def group_count(self, event): + need(event in (0, 1), 'fixture event') + return 1 + def group(self, event, subgroup, cover): + if event == 0: + old = super().group(0, subgroup, cover) + code = [] + for operation in old.code: + op = list(operation) + positions = (2, 3) if op[0] in ('scalar', 'copy', 'exchange') else (2,) + for i in positions: + if op[i] == 2: op[i] = 4 + code.append(tuple(op)) + return Group(old.keys, tuple(code), old.recipes) + need(event == 1 and subgroup == 0, 'fixture bridge event') + return Group(tuple((i, cover) for i in range(4)), + (('scalar', -1, 0, 1, ('add', 1, 1)), + ('scalar', -1, 2, 3, ('add', -1, 1))), {}) + + def body(t): return bytes(t.cells[1:]).rstrip(bytes([BLANK])) + def native(): + return Ordinary(2, SimpleNamespace(codes=SimpleNamespace(q=2)), + SimpleNamespace(families=0), (Code((('unreachable',),), 0),), capacity=64) + transfer_controls = [] + for old_length, new_length in ((0, 0), (1, 1), (5, 5), (17, 17), (3, 11)): + source_tape, target_tape = Tape(), Tape() + for i in range(new_length): source_tape.append(i & 1) + for i in range(old_length): target_tape.append((i + 1) & 1) + source_tape.rewind(); target_tape.rewind() + before_pair = [t.meter.record() for t in (source_tape, target_tape)] + transfer(source_tape, target_tape) + paid = {k: sum(t.meter.record()[k]-old[k] for t, old in + zip((source_tape, target_tape), before_pair)) + for k in ('reads', 'writes', 'moves')} + expected_cost = dict(reads=2*old_length+5*new_length+7, + writes=old_length+2*new_length, + moves=2*old_length+4*new_length+10) + need(paid == expected_cost, 'literal immutable-transfer tariff') + transfer_controls.append(dict(old_bits=old_length, new_bits=new_length, actions=paid)) + source_tape.clear(); target_tape.clear() + binding = Binding() + acquisition = BankPackets(binding.families, 1, families) + service = CallerStorage(Tape, Count, Counter, BLANK, transfer, require_zero, outputs=families, expected_event=0) + pool = ScratchPool(64) + scope = OuterScope(pool) + observations, rejections, meters = [], [], [] + def reject(name, operation): + try: operation() + except ValueError: rejections.append(name) + else: raise ValueError('accepted lifecycle mutation: ' + name) + + class Installed(Machine): + def finish_group(self): + super().finish_group() + if self.event != 0 or self.cover_index != binding.cover.size: + return + # The original outer allocation scope is suspended; the external + # service has its own fixed64 descriptor pool. Native engines, if + # called by the integrated service, must suspend this scope too. + with self.scope.suspended(): + with sealed_constructors(), scope.installed(): + rowbits = Count(self.c('row_bits')) + rowbits.multiply_small(binding.cover.size) + extent = Count.product(self.c('prefixes'), self.c('unused')) + extent2 = Count.product(extent, rowbits) + extent.close() + try: + protected = tuple(t for t in (*self.parked, *self.capsule.values(), + self.output, self.bank.output, self.parking.stack, self.parking.reverse) + if t is not self.roles['current']) + image = [(body(t), t.head) for t in protected] + bank_image = body(self.roles['current']) + all_tapes = tuple(dict.fromkeys((*service.roles, *acquisition.packets, + acquisition.output, *acquisition.pool.tapes, *pool.tapes, + self.roles['current'], rowbits.tape, extent2.tape))) + before = [t.meter.record() for t in all_tapes] + acquisition.select(tuple((i, 0) for i in range(families))) + with scope.suspended(): + acquisition.gather(self.roles['current'], self.c('prefixes'), + self.c('unused'), rowbits) + # Own dirty state is discardable; borrowed source is not. + for i, tape in enumerate(service.roles): + tape.append(i & 1); tape.rewind() + service.begin(self, acquisition, tuple(range(families))) + reject('premature fixed-bank commit', lambda: service.commit( + self.c('prefixes'), self.c('unused'), rowbits)) + saved = service.outputs + service.outputs = (self.roles['current'], *saved[1:]) + reject('parent/output alias', service._parent_cut) + service.outputs = saved + for i in range(families): + copy_symbols(acquisition.packets[i], service.output(i)) + # Nonzero private state must be restored by the decoder. + service.private[0].append(1); service.private[0].rewind() + reject('unrestored private dirt', lambda: service.decoded(extent2)) + service.private[0].clear() + service.decoded(extent2) + reject('unclosed native output', lambda: service.ready(extent2, False)) + # Exact extent rejects before any source-bank mutation. + service.outputs[-1].clear() + reject('short final output', lambda: service.ready(extent2, True)) + need(body(self.roles['current']) == bank_image, + 'all output preflight precedes destructive parent writes') + copy_symbols(acquisition.packets[-1], service.outputs[-1]) + service.ready(extent2, True) + with scope.suspended(): + service.commit(self.c('prefixes'), self.c('unused'), rowbits, adopt=adopt) + need(body(self.roles['current']) == bank_image, + 'whole-bank identity storage publication') + need([(body(t), t.head) for t in protected] == image, + 'all parent roles and suspended ancestor stack preserved') + reject('retired output access', lambda: service.output(0)) + reject('double commit', lambda: service.commit( + self.c('prefixes'), self.c('unused'), rowbits)) + meters.append({k: sum(t.meter.record()[k]-old[k] for t, old in + zip(all_tapes, before)) for k in ('reads', 'writes', 'moves')}) + observations.append(dict(ancestor=not self.root, event=self.event)) + finally: + rowbits.close(); extent2.close() + pool.empty() + + rows = 2*families + compact = width//2-1 + desc_values = dict(prefixes=2, rows=rows, front=0, compact_bits=compact, before=0, + width=width, after=0, back=0, spacing=1, guard=1, residue=0, + component_bits=12, coefficients=1, root_width=width) + descriptors = {n: Count.literal(v) for n, v in desc_values.items()} + values = [(16*((7*i)%11-5), 16*((3*i)%7-3)) for i in range(2*rows*(1<<(width+3*compact)))] + raw = bytes((x >> bit) & 1 for pair in values for x in pair for bit in range(12)) + source = Tape() + for bit in raw: source.append(bit) + source.rewind() + source_image = body(source) + desc_images = {n: body(v.tape) for n, v in descriptors.items()} + baseline = Machine(binding, native(), binding.catalogue) + expected = baseline.run(source, descriptors) + expected_raw = body(expected); expected.clear() + boundary_counts = {'enter': 0, 'return': 0} + def observe(machine, event): + boundary_counts[event] += 1 + current_bindings(machine) + installed = Installed(binding, native(), binding.catalogue, observe) + result = installed.run(source, descriptors) + need(body(result) == expected_raw, 'actual two bridge legs and root return unchanged') + if adopt: + result.clear() + result = installed.run(source, descriptors) + need(body(result) == expected_raw, 'second root and original recursive returns after adoption') + need(len(observations) == (2 if adopt else 1), 'one chosen full-cover fence per root generation') + need(body(source) == source_image and all(body(v.tape) == desc_images[n] + for n, v in descriptors.items()), 'borrowed root payload and encoded descriptors preserved') + need(service.stage == 'closed' and acquisition.state == 'closed' + and all(t.read() == BLANK for t in (*service.roles, *acquisition.packets, + acquisition.output)), 'all full-output backing retired') + receipt = dict(status='PASS_ACTUAL_FULL_BANK_LIFECYCLE_AND_BRIDGE', outputs=families, private=16, + geometry_dimension=2, whole_cover_families=families, covers=2, outer_prefixes=2, + producer_width=width, reached_fences=len(observations), + root_invocations=2 if adopt else 1, actual_recursive_boundaries=boundary_counts, + ancestor_frames_preserved_at_fences=sum(int(r['ancestor']) for r in observations), + complex_values=len(values), actual_bridge_legs_per_cover=2, + internal_bank_adoption=adopt, + endpoint_sha256=sha256(expected_raw).hexdigest(), mutation_rejections=rejections, + exact_transfer_tariff_checks=transfer_controls, + control_inclusive_service_cell_actions={k: sum(m[k] for m in meters) for k in ('reads','writes','moves')}, + fixed_service_tapes=2*families+97, + all_parent_roles_preserved=True, cleanup=True, + scope='Actual source Machine, BankPackets, Tape/Count and both bridge scalar legs; identity service tests storage only, not QQ16 arithmetic, selected O73 execution or complete supplier.') + result.clear(); source.clear() + for value in descriptors.values(): value.close() + return receipt + + +def adoption_fixture(): + """Exact paired commit meters and source Parking's nonempty-frame codec. + + Boundary payloads/ancestor frames are fixture oracles. The full fixture() + separately reaches the fence through actual Machine execution. + """ + from types import SimpleNamespace + from fixture_binding import FixtureBinding + from machine import Machine, origin + from bank_packets import BankPackets, arm_empty + from macro_code import Code + from ordinary import Ordinary + from words import BLANK + def body(t): return bytes(t.cells[1:]).rstrip(bytes([BLANK])) + def make(size, ancestor): + binding = FixtureBinding() + native = Ordinary(2, SimpleNamespace(codes=SimpleNamespace(q=2)), + SimpleNamespace(families=0), (Code((('unreachable',),), 0),), capacity=64) + parent = Machine(binding, native, binding.catalogue) + parent.closed = False; parent.mode = 'group'; parent.group = None + original_ancestor = None + if ancestor: + for i, tape in enumerate(parent.parked): + origin(tape) + for digit in (i & 1, 12, 13): tape.append(digit) + tape.rewind() + original_ancestor = tuple(body(t) for t in parent.parked) + parent.parking.park() + for i in range(size): parent.roles['current'].append(i & 1) + parent.roles['current'].rewind() + acquired = BankPackets(2, 1, 1) + for tape in (acquired.output, *acquired.packets): arm_empty(tape) + for i in range(size): acquired.output.append((i+1) & 1) + acquired.output.rewind() + for i in range(size//2): acquired.packets[0].append(i & 1) + acquired.packets[0].rewind() + acquired.source = parent.roles['current']; acquired.state = 'returned' + return parent, acquired, original_ancestor + cases = [] + mutations = [] + def reject(name, action): + try: action() + except ValueError: mutations.append(name) + else: raise ValueError('accepted adoption mutation: ' + name) + for size in (2, 6, 18, 66): + costs = [] + for adopt in (False, True): + parent, acquired, ancestor = make(size, adopt) + old = parent.roles['current']; new = acquired.output + public = parent.output + stack_image = (body(parent.parking.stack), parent.parking.stack.head) + expected = body(new) + tapes = (old, new, *acquired.packets) + before = [t.meter.record() for t in tapes] + if adopt: adopt_bank(parent, acquired, BLANK) + else: acquired.commit(old) + costs.append({k: sum(t.meter.record()[k]-b[k] for t,b in zip(tapes,before)) + for k in ('reads','writes','moves')}) + need(body(parent.roles['current']) == expected and parent.output is public, + 'adoption completed value and immutable public output') + need((body(parent.parking.stack), parent.parking.stack.head) == stack_image, + 'encoded ancestor frame untouched by adoption') + if adopt: + good = parent.parked + parent.parked = tuple(old if t is new else t for t in good) + reject('omitted parked binding', lambda: current_bindings(parent)) + parent.parked = good + parent.parking.roles = tuple(old if t is new else t for t in good) + reject('omitted parking binding', lambda: current_bindings(parent)) + parent.parking.roles = good + for tape in parent.parked: origin(tape); tape.clear() + parent.parking.restore() + need(tuple(body(t) for t in parent.parked) == ancestor, + 'actual Parking restores ancestor bodies into rebound logical roles') + parent.parking.empty() + for tape in (*parent.parked, acquired.output): origin(tape); tape.clear() + saving = {k: costs[0][k]-costs[1][k] for k in ('reads','writes','moves')} + need(saving == dict(reads=5*size+2, writes=2*size, moves=4*size+2), + 'exact current-bank adoption action difference') + need(sum(saving.values()) == 11*size+4, 'exact whole-bank adoption saving') + cases.append(dict(bank_bits=size, baseline=costs[0], adopted=costs[1], saved=saving)) + for mutation in ('cached external current alias', 'invalid returned binary symbol'): + parent, acquired, _ = make(6, False) + old = parent.roles['current']; new = acquired.output + old_image, old_binding = body(old), parent.parked + if mutation == 'cached external current alias': + reject(mutation, lambda: adopt_bank(parent, acquired, BLANK, (old,))) + else: + new.write(3) + reject(mutation, lambda: adopt_bank(parent, acquired, BLANK)) + need(parent.roles['current'] is old and parent.parked == old_binding + and parent.parking.roles == old_binding and body(old) == old_image + and old.head == new.head == 1, 'rejected adoption preserves source and bindings') + for tape in (*parent.parked, acquired.output, *acquired.packets): + origin(tape); tape.clear() + return dict(status='PASS_EXACT_BANK_ADOPTION_AND_REBOUND_PARKING', cases=cases, + mutations=mutations, nonempty_ancestor_codec_cases=4, + saving='11*B+4 tape cell actions; plus separately charged finite role-control cost', + scope='Actual source commit, Tape and Parking at synthetic admitted body boundaries; full actual controller adoption/continuation is fixture(adopt=True).') diff --git a/research/qq16-caller-install/packet.py b/research/qq16-caller-install/packet.py new file mode 100644 index 0000000000..9b965f8f63 --- /dev/null +++ b/research/qq16-caller-install/packet.py @@ -0,0 +1,420 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Encoded acquisition from an actual gathered complex caller. + +Chris R, substantial OpenAI Codex assistance. Retained Count, tape, scope, +stock and capsule routines are Jose Manuel's physical-controller lineage. +Caller selection and source authentication must precede this module's use. +No values, widths, row counts or packet lengths are decoded in this adapter. +""" + +class PacketCompiler: + """Fixed-owned descriptor block and optional entry snapshots. + + A snapshot is a charged original-data lifetime, never an implicit recovery + input. This module does not establish the semantic reconnection theorem. + """ + def __init__(self, snapshot_slots=0): + from records import Tape + from scratch_pool import ScratchPool + from session import OuterScope + from machine import INPUTS + if type(snapshot_slots) is not int or snapshot_slots < 0: + raise ValueError('fixed nonnegative snapshot slot count') + self.roles = {name: Tape() for name in INPUTS} + self.snapshots = tuple(Tape() for _ in range(snapshot_slots)) + self.pool = ScratchPool(64) + self.scope = OuterScope(self.pool) + self.closed = True + self.captured = () + + def descriptors(self): + from cardinal_counts import Count + if self.closed: + raise ValueError('live encoded packet descriptor lease') + result = {} + for name, tape in self.roles.items(): + value = object.__new__(Count) + value.tape = tape + result[name] = value + return result + + def compile(self, caller): + return self._compile(caller) + + def compile_global(self, caller, field, expected_event): + """Compile one acquired whole-family operand at a completed cover sweep. + + expected_event is a fixed program-fence constant, not a decoded count. + field has order prefix, cover, unused row, complete within-row record. + """ + from words import need + need(type(expected_event) is int and expected_event >= 0, + 'fixed whole-cover producer fence') + need(not caller.closed and caller.mode == 'group' and caller.group is None and + caller.bank.state == 'closed' and caller.event == expected_event and + caller.subgroup == caller.pc == 0 and + caller.cover_index == caller.binding.cover.size, + 'actual completed whole-cover producer fence') + return self._compile(caller, field) + + def _compile(self, caller, field=None): + from cardinal_counts import Count, positive + from encoded import compare, divide, fixed_power + from machine import INPUTS, copy_symbols + from session import sealed_constructors + from words import BLANK, need + need(self.closed and not self.pool.live and + all(t.read() == BLANK for t in (*self.roles.values(), *self.snapshots)), + 'closed encoded compiler') + if field is None: + need(not caller.closed and caller.mode == 'group' and caller.group is not None and + caller.bank.state == 'gathered', 'actual gathered caller cut') + caller.primitive_boundary() + dimension = caller.binding.dimension + rank = caller.binding.maximum_rank + divisor_constant = caller.binding.families * caller.binding.cover.size + need(type(dimension) is int and dimension >= 2 and + type(rank) is int and 0 < rank < dimension, 'fixed source recursion constants') + need(all(t not in caller.parked for t in (*self.roles.values(), *self.snapshots, *self.pool.tapes)), + 'exclusive compiler inventory') + owned = [] + def keep(v): + owned.append(v) + return v + try: + with sealed_constructors(), self.scope.installed(): + for name in ('columns', 'prefixes', 'unused', 'spacing', 'guard', + 'component_bits', 'coefficients', 'root_width'): + positive(caller.c(name)) + width = keep(Count(caller.c('columns'))) + parent_width = keep(Count(width)); parent_width.multiply_small(dimension) + need(compare(parent_width, caller.c('width')) == 0, + 'post-remainder parent width is dimension times columns') + need(compare(caller.c('width'), caller.c('root_width')) <= 0, + 'actual global root width') + if field is not None: + # The source node tests its old width before peeling a + # remainder. The service needs its own post-peel test. + nonleaf = keep(fixed_power(caller.c('width'), 1000, caller.c('root_width'))) + need(compare(nonleaf, caller.c('root_width')) >= 0, + 'post-remainder service nonleaf admission') + need(compare(caller.c('residue'), caller.c('spacing')) < 0, + 'actual spacing residue') + divisor = keep(Count.literal(divisor_constant)) + rows, rem = divide(caller.c('rows'), divisor) + keep(rows); keep(rem) + need(rem.zero() and compare(rows, caller.c('unused')) == 0, + 'actual owner rows are exact parent quotient') + # Prove the requested child's own conservative stock directly. + current = keep(Count(width)); threshold = keep(Count.literal(dimension)) + stock = keep(Count.literal(1)) + while compare(current, threshold) >= 0: + current.divide_small(dimension) + if rank > 1: current.multiply_small(rank) + stock.multiply_small(divisor_constant) + stock_multiple, stock_rem = divide(rows, stock) + keep(stock_multiple); keep(stock_rem) + need(stock_rem.zero() and not stock_multiple.zero(), 'actual child row stock') + tail = keep(Count(width)) + if dimension > 2: tail.multiply_small(dimension - 1) + after = keep(Count.product(tail, caller.c('spacing'))) + after.add(caller.c('after')) + prefixes = keep(Count(caller.c('prefixes'))) + if field is not None: + from compact_counts import power_two + from stream import Counter + need(field not in (*self.roles.values(), *self.snapshots, *self.pool.tapes), + 'borrowed whole-family field separate from compiler') + gamma = caller.binding.cover.size + need(type(gamma) is int and gamma > 0, 'fixed actual cover cardinality') + if gamma > 1: prefixes.multiply_small(gamma) + # Recompute the actual whole row, instead of trusting a + # convenient logical payload or a stale derived row_bits. + active = keep(Count.product(caller.c('width'), caller.c('spacing'))) + address = keep(Count(caller.c('compact_bits'))); address.multiply_small(3) + for name in ('front', 'before', 'after', 'back'): address.add(caller.c(name)) + address.add(active) + records = keep(power_two(address)) + row_fields = keep(Count.product(records, caller.c('coefficients'))) + row_bits = keep(Count.product(row_fields, caller.c('component_bits'))) + row_bits.multiply_small(2) + need(compare(row_bits, caller.c('row_bits')) == 0, 'actual complete source row extent') + prefix_rows = keep(Count.product(prefixes, rows)) + extent = keep(Count.product(prefix_rows, row_bits)) + remaining = keep(Counter(extent)) + field.rewind() + try: + while not remaining.finished: + need(field.read() in (0, 1), 'complete whole-family field bits') + field.step(1); remaining.decrement() + need(field.read() == BLANK, 'exact whole-family field extent') + finally: + field.rewind() + for name in INPUTS: + source = prefixes if name == 'prefixes' else rows if name == 'rows' else width if name == 'width' else after if name == 'after' else caller.c(name) + copy_symbols(source.tape, self.roles[name]) + self.closed = False + return self.descriptors() + except BaseException: + for tape in self.roles.values(): tape.clear() + raise + finally: + for value in reversed(owned): value.close() + self.pool.empty() + + def capture(self, caller, source_roles): + from machine import copy_symbols + from words import need + need(not self.closed and not self.captured, 'one snapshot per descriptor lease') + need(type(source_roles) is tuple and len(source_roles) == len(self.snapshots) and + len(set(source_roles)) == len(source_roles), 'complete distinct snapshot roles') + need(caller.mode == 'group' and caller.bank.state == 'gathered', 'live gathered snapshot source') + caller.primitive_boundary() + try: + for target, role in zip(self.snapshots, source_roles): + source = caller.packet(role) + need(source not in self.snapshots, 'snapshot source and target disjoint') + copy_symbols(source, target) + self.captured = source_roles + return self.snapshots + except BaseException: + for tape in self.snapshots: tape.clear() + raise + + def close(self): + if self.pool.live: + raise ValueError('compiler scratch closes before retirement') + for tape in (*self.roles.values(), *self.snapshots): tape.clear() + self.closed = True + self.captured = () + + +def fixture(): + """Reduced actual controller exercise, called only after authentication. + + Fixture setup uses host integers and loads a dense tape, as an oracle. + PacketCompiler itself uses only encoded source operations. This is a + dimension-two physical fixture, not selected O73 execution. + """ + from types import SimpleNamespace + from cardinal_counts import Count + from fixture_binding import FixtureBinding + from machine import Machine, copy_symbols + from macro_code import Code + from ordinary import Ordinary + from records import Tape + from words import BLANK, need + binding = FixtureBinding() + native = Ordinary(2, SimpleNamespace(codes=SimpleNamespace(q=2)), + SimpleNamespace(families=0), (Code((('unreachable',),), 0),), capacity=64) + compiler = PacketCompiler(2) + observed = [] + controls = [] + compiled = [] + invoice = [] + mutation_counts = [(name, Count.literal(bad), Count.literal(good), reason) for name,bad,good,reason in + (('unused',2,1,'actual owner rows'), ('width',1,2,'post-remainder'), + ('residue',1,0,'actual spacing'))] + def body(t): return bytes(t.cells[1:]).rstrip(bytes([BLANK])) + def observe(machine, event): + if event == 'enter' and compiled and not observed: + need(all(body(machine.c(name).tape) == raw for name, raw in compiled[0].items()), + 'compiled descriptors equal actual source child capsule') + observed.append(event) + class Caller(Machine): + def next_group(self): + super().next_group() + if self.group is None or compiled: return + original = {name: body(self.c(name).tape) for name in self.roles if name != 'current' and name != 'header'} + # Source-bound rejecting mutations, restoring the original Count. + for name, invalid, saved, reason in mutation_counts: + try: + copy_symbols(invalid.tape, self.c(name).tape) + try: + with self.scope.suspended(): compiler.compile(self) + except ValueError as error: + need(reason in str(error), 'precise compiler mutation rejection') + controls.append(reason) + else: raise ValueError('compiler accepted descriptor mutation') + finally: + copy_symbols(saved.tape, self.c(name).tape) + paid_tapes = tuple(dict.fromkeys((*compiler.roles.values(), *compiler.snapshots, *compiler.pool.tapes, *self.roles.values(), *self.bank.packets))) + paid_before = [t.meter.record() for t in paid_tapes] + with self.scope.suspended(): result = compiler.compile(self) + compiled.append({name: body(value.tape) for name, value in result.items()}) + originals = [body(self.packet(i)) for i in range(2)] + with self.scope.suspended(): snapshots = compiler.capture(self, (0, 1)) + need([body(t) for t in snapshots] == originals, 'complete actual gathered owner copies') + need([body(self.packet(i)) for i in range(2)] == originals, 'borrowed owner values preserved') + need(all(body(self.c(name).tape) == raw for name, raw in original.items()), + 'parent descriptors preserved by compile and acquisition') + compiler.close() + invoice.append({key: sum(t.meter.record()[key]-old[key] for t,old in zip(paid_tapes,paid_before)) for key in ('reads','writes','moves')}) + engine = Caller(binding, native, binding.catalogue, observe) + # Two prefixes, two coefficients and nonconstant complex payload: every + # spectator/outer record must survive actual gather/child/scatter/return. + descriptors = {name: Count.literal(value) for name, value in dict( + prefixes=2, rows=4, front=0, compact_bits=0, before=0, width=2, + after=0, back=0, spacing=1, guard=1, residue=0, component_bits=20, + coefficients=2, root_width=2).items()} + values = [(16 * ((7 * i) % 11 - 5), 16 * ((3 * i) % 7 - 3)) for i in range(64)] + raw = bytes((x >> bit) & 1 for pair in values for x in pair for bit in range(20)) + source = Tape() + for bit in raw: source.append(bit) + source.rewind(); image = body(source) + before = {name: body(value.tape) for name, value in descriptors.items()} + result = engine.run(source, descriptors) + need(observed == ['enter'] and engine.closed, 'actual child and complete parent continuation executed') + need(body(source) == image and all(body(value.tape) == before[name] for name, value in descriptors.items()), + 'complete caller borrowed input and descriptors preserved') + need(compiler.closed and all(t.read() == BLANK for t in (*compiler.roles.values(), *compiler.snapshots)), + 'compiler descriptors and optional snapshots retired') + import hashlib + digest = hashlib.sha256(body(result)).hexdigest() + result.clear(); source.clear() + for value in descriptors.values(): value.close() + for _, invalid, saved, _ in mutation_counts: invalid.close(); saved.close() + return dict(status='PASS_ACTUAL_ENCODED_CALLER_PACKET_COMPILER', geometry_dimension=2, + prefixes=2, rows=4, coefficients=2, complex_values=64, + actual_child_descriptor_match=True, mutation_rejections=controls, + endpoint_sha256=digest, source_and_descriptors_preserved=True, + compiler_retired=True, paid_compiler_snapshot_retirement=invoice[0], + fixed_compiler_tapes=78, optional_fixture_snapshot_tapes=2, + scope='Actual retained Machine/gather/prepare_child/return/scatter and new encoded compiler; reduced geometry, no selected O73 native fixture or reconnection theorem.') + + +def global_fixture(): + """Actual complete-cover acquisition, compiler and child; reduced geometry.""" + from types import SimpleNamespace + from cardinal_counts import Count + from fixture_binding import FixtureBinding + from machine import Machine, copy_symbols + from bank_packets import BankPackets + from macro_code import Code + from ordinary import Ordinary + from records import Tape + from words import BLANK, need + from fractions import Fraction as Q + import hashlib + binding = FixtureBinding() + def native(): + return Ordinary(2, SimpleNamespace(codes=SimpleNamespace(q=2)), + SimpleNamespace(families=0), (Code((('unreachable',),), 0),), capacity=64) + compiler = PacketCompiler() + acquisition = BankPackets(binding.families, 1, 1) + child = Machine(binding, native(), binding.catalogue) + # These fixed small fixture Counts are loaders, not compiler implementation. + rowbits_gamma = Count.literal(640) + bad_counts = {n: Count.literal(v) for n,v in [('width',4),('columns',2),('root_width',4)]} + restored_counts = {n: Count.literal(v) for n,v in [('width',2),('columns',1),('root_width',2)]} + nonleaf_boundary = Count.literal(3 ** 1000) + expected_counts = {name:Count.literal(value) for name,value in [('prefixes',4),('rows',1),('width',1),('after',1)]} + truncated = Tape(); truncated.append(0); truncated.rewind() + records = [] + def body(t): return bytes(t.cells[1:]).rstrip(bytes([BLANK])) + def decode(raw): + numbers=[] + for start in range(0,len(raw),20): + x=sum(bit<>i)&1 for z in values for x in z for i in range(20)) + def c_axis(values, bit, rows): + out=[tuple(map(Q,z)) for z in values] + # Four addresses times two coefficients in each row. + for row in range(rows): + for address in range(4): + if address&bit: continue + for coefficient in range(2): + i=(row*4+address)*2+coefficient + j=(row*4+address+bit)*2+coefficient + a,b=out[i];c,d=out[j] + out[i]=((a-b+c+d)/2,(a+b-c+d)/2) + out[j]=((a+b+c-d)/2,(-a+b+c+d)/2) + need(all(x.denominator==1 for z in out for x in z),'finite fixture exact grid') + return out + class Caller(Machine): + def finish_group(self): + super().finish_group() + if self.cover_index != binding.cover.size or records: return + with self.scope.suspended(): + acquisition.select(((0,0),)) + acquisition.gather(self.roles['current'],self.c('prefixes'),self.c('unused'),rowbits_gamma) + field=acquisition.packets[0]; original=body(field) + parent_image={name:body(tape) for name,tape in self.roles.items()} + rejections=[] + def reject(label, operation, substring): + try: operation() + except ValueError as error: + need(substring in str(error),'precise global compiler rejection '+label) + rejections.append(label) + else: raise ValueError('accepted global compiler control '+label) + reject('wrong producer fence',lambda:compiler.compile_global(self,field,1),'whole-cover producer fence') + reject('short whole-family field',lambda:compiler.compile_global(self,truncated,0),'whole-family field bits') + try: + copy_symbols(nonleaf_boundary.tape,self.c('root_width').tape) + rejection_state={name:(body(tape),tape.head) for name,tape in self.roles.items()} + field_state=(body(field),field.head) + reject('pre-remainder nonleaf does not admit service', + lambda:compiler.compile_global(self,field,0), + 'post-remainder service nonleaf admission') + need(all((body(tape),tape.head)==rejection_state[name] for name,tape in self.roles.items()) + and (body(field),field.head)==field_state, + 'nonleaf rejection preserves caller descriptors and borrowed field') + need(compiler.closed and not compiler.pool.live and + all(t.read()==BLANK for t in compiler.roles.values()), + 'nonleaf rejection retires all compiler temporaries') + finally: + copy_symbols(restored_counts['root_width'].tape,self.c('root_width').tape) + try: + for name,value in bad_counts.items():copy_symbols(value.tape,self.c(name).tape) + reject('insufficient actual child stock',lambda:compiler.compile_global(self,field,0),'actual child row stock') + finally: + for name,value in restored_counts.items():copy_symbols(value.tape,self.c(name).tape) + paid_tapes=tuple(dict.fromkeys((*compiler.roles.values(),*compiler.pool.tapes,*self.roles.values(),field))) + before=[t.meter.record() for t in paid_tapes] + descriptors=compiler.compile_global(self,field,0) + setup_invoice={key:sum(t.meter.record()[key]-old[key] for t,old in zip(paid_tapes,before)) for key in ('reads','writes','moves')} + # Bytes are interpreted only in this independent fixture oracle. + expected={name:body(self.c(name).tape) for name in descriptors} + for name,probe in expected_counts.items(): expected[name]=body(probe.tape) + need({name:body(v.tape) for name,v in descriptors.items()}==expected, + 'global cover folds into encoded prefixes and exact child fields') + # Actual closed recursive endpoint on all covers of one family. + returned=child.run(field,descriptors) + expected_values=c_axis(decode(original),2,4) + need(body(returned)==encode(expected_values),'actual whole-family child matches address oracle') + returned.clear() + retirement_before=[t.meter.record() for t in paid_tapes] + compiler.close() + retirement_invoice={key:sum(t.meter.record()[key]-old[key] for t,old in zip(paid_tapes,retirement_before)) for key in ('reads','writes','moves')} + need(body(field)==original and all(body(tape)==parent_image[name] for name,tape in self.roles.items()), + 'global compiler and native preserve producer bank and descriptors') + acquisition.release() + need(compiler.closed and child.closed,'whole-family descriptors and child retired') + records.append(dict(prefixes=2,covers=2,native_prefixes=4,rows=1,coefficients=2, + field_complex_values=32,controls=rejections, + endpoint_sha256=hashlib.sha256(encode(expected_values)).hexdigest(), + compiler_setup_validation_actions=setup_invoice, + compiler_retirement_actions=retirement_invoice)) + engine=Caller(binding,native(),binding.catalogue) + descriptors={n:Count.literal(v) for n,v in dict(prefixes=2,rows=4,front=0,compact_bits=0, + before=0,width=2,after=0,back=0,spacing=1,guard=1,residue=0,component_bits=20, + coefficients=2,root_width=2).items()} + values=[(16*((7*i)%11-5),16*((3*i)%7-3)) for i in range(64)] + source=Tape() + for bit in encode(values):source.append(bit) + source.rewind(); original=body(source) + try: + returned=engine.run(source,descriptors) + need(len(records)==1 and body(source)==original,'actual global fence and borrowed source preservation') + need(body(returned)==encode(c_axis(c_axis(values,1,8),2,8)), + 'entire actual parent continuation unchanged by global service') + returned.clear() + return dict(status='PASS_ACTUAL_GLOBAL_FAMILY_PACKET_COMPILER',fixture=records[0], + fixed_compiler_tapes=78,source_and_descriptors_preserved=True, + scope='Actual cover2 parent, whole-family BankPackets acquisition, encoded compiler, actual rank-one C child and completed parent; reduced geometry, not full QQ16 semantic installation.') + finally: + source.clear();truncated.clear();rowbits_gamma.close();nonleaf_boundary.close() + for value in (*descriptors.values(),*bad_counts.values(),*restored_counts.values(),*expected_counts.values()):value.close() + compiler.close() diff --git a/research/qq16-caller-install/physical.py b/research/qq16-caller-install/physical.py new file mode 100644 index 0000000000..79a8a5b82e --- /dev/null +++ b/research/qq16-caller-install/physical.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python3 +"""Isolated physical evidence after complete source authentication.""" +from pathlib import Path +import sys,json +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +import runtime +runtime.cold() +try: + if len(sys.argv)!=2:raise ValueError('literal physical suite required') + mode=sys.argv[1] + if mode=='packet': + p=runtime.module('qq16_packet',HERE/'packet.py') + out={'group':p.fixture(),'global':p.global_fixture()} + elif mode=='lifecycle': + p=runtime.module('qq16_lifecycle',HERE/'lifecycle.py') + out={'full224':p.fixture(adopt=True),'adoption':p.adoption_fixture()} + else:raise ValueError('unknown physical suite') + print(json.dumps(out,sort_keys=True)) +finally:runtime.cleanup() diff --git a/research/qq16-caller-install/producer-fixture.py b/research/qq16-caller-install/producer-fixture.py new file mode 100644 index 0000000000..84e4552c75 --- /dev/null +++ b/research/qq16-caller-install/producer-fixture.py @@ -0,0 +1,240 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Reduced physical producer routing and original-child return controls. + +Authenticate source closure before launching this fixture. Payload construction +and expected values are test oracles only, not production entry compilers. +""" +from pathlib import Path +import sys,json +from hashlib import sha256 +from types import SimpleNamespace +ROOT=Path(__file__).resolve().parents[2] +sys.path.insert(0,str(Path(__file__).resolve().parent)) +import runtime +runtime.cold() +runtime.module('producer',Path(__file__).resolve().parent/'producer.py') +import cohort +from cardinal_counts import Count +from records import Tape +from ordinary import Ordinary +from macro_code import Code +from machine import Machine,transfer +from session import erase_marker +from selected_binding import Group,literal +from fixture_binding import FixtureBinding +from cover import OrthogonalCover +from scalar_program import ScalarProgram +from words import BLANK +from producer import map_group,machine_class,act,multiply,need + + +def native(): + return Ordinary(2,SimpleNamespace(codes=SimpleNamespace(q=2)), + SimpleNamespace(families=0),(Code((('unreachable',),),0),),capacity=64) + + +def raw(t): + return bytes(t.cells[1:]).rstrip(bytes([BLANK])) + + +def encode(values,h): + return bytes((x>>b)&1 for pair in values for x in pair for b in range(h)) + + +def execute(binding,expected,external=False): + child=Machine(FixtureBinding(),native(),FixtureBinding().catalogue) + fences=[] + def at_fence(parent): + need(parent.scope.manager is None and parent.group is None and + parent.bank.state=='closed' and parent.cover_index==binding.cover.size and + parent.pc==0 and parent.subgroup==0, 'actual suspended global fence') + parent.primitive_boundary() + fences.append(parent.event) + engine=(machine_class(Machine,Count,transfer,erase_marker)(binding,native(),binding.catalogue,child,at_fence) + if external else Machine(binding,native(),binding.catalogue)) + # These owned private tapes are discardable scratch, not borrowed inputs. + for tape in engine.private: + for bit in (1,0,1):tape.append(bit) + tape.rewind() + descriptors={k:Count.literal(v) for k,v in dict(prefixes=2,rows=binding.families*binding.cover.size,front=0,compact_bits=0, + before=0,width=binding.dimension,after=0,back=0,spacing=1,guard=1,residue=0, + component_bits=16,coefficients=1,root_width=binding.dimension).items()} + count=2*binding.families*binding.cover.size*(1<>1)&1) + for z in range(4):out[prefix*16+d*4+z]=values[prefix*16+source*4+(z^address_shift)] + return out + + +def child_expected(values,binding): + out=values[:] + for prefix in range(2): + for owner in range(2): + start=prefix*16+owner*4 + for z in (0,1): + a,b=values[start+z];c,d=values[start+z+2] + out[start+z]=((a-b+c+d)//2,(a+b-c+d)//2) + out[start+z+2]=((a+b+c-d)//2,(-a+b+c+d)//2) + return out + + +class ChildBinding(MapBinding): + def group(self,i,j,k):return Group(((0,k),), (('child',-1,0,1),),{}) + +class Map3Binding(MapBinding): + dimension=3;slots=3 + def __init__(self,mutation=None): + self.cover=OrthogonalCover(3);self.mutation=mutation + self.record={'owner_right_matrix_columns':[2,4,1], + 'payload_translation_at_identity_owner':1} + if mutation=='transpose_record':self.record['owner_right_matrix_columns']=[4,1,2] + self.catalogue={('scale',-1,1):ScalarProgram('scale',-1,1)} + def group(self,i,j,k): + group=map_group(self.cover,k,0,self.record,Group,literal) + if self.mutation=='transpose_owner_translation': + recipes=dict(group.recipes) + for op in group.code: + if op[0]=='monomial': + owner=self.cover.unrank(group.keys[op[2]][1]) + recipes[op[3]]=literal((1,2,4),act(owner,1)) + return Group(group.keys,group.code,recipes) + return group + +def map3_expected(values,binding): + result=values[:];gamma=6;addresses=8 + # Independent dense row-matrix multiplication, with the fixture map + # columns (2,4,1), hence mathematical rows (4,1,2). + right_rows=(4,1,2) + for prefix in range(2): + for d in range(gamma): + left=binding.cover.unrank(d) + product_rows=tuple(sum((sum(((left[i]>>k)&1)*((right_rows[k]>>j)&1) + for k in range(3))%2)<>j)&1)*(1 if j==0 else 0) + for j in range(3))%2 for i in range(3)) + mask=sum(bit<<(2-i) for i,bit in enumerate(direction)) + need(mask in (1,2,4),'O3 permutation owner image of q') + start=prefix*96+family*48+owner*8 + for address in range(8): + if address&mask:continue + a,b=values[start+address];c,d=values[start+(address^mask)] + numerators=(a-b+c+d,a+b-c+d,a+b+c-d,-a+b+c+d) + need(all(x%2==0 for x in numerators),'exact signed-line fixture grid') + plus=tuple(x//2 for x in numerators[:2]) + minus=tuple(x//2 for x in numerators[2:]) + result[start+address],result[start+(address^mask)]=( + (plus,minus) if family==0 else (minus,plus)) + return result + + +def run(): + results={'cycle':execute(MapBinding(),map_expected), + 'nonsymmetric_row_column_cycle':execute(Map3Binding(),map3_expected), + 'nonsymmetric_signed_native_conjugation':execute(Signed3Binding(),signed3_expected,True), + 'external_original_child':execute(ChildBinding(),child_expected,True)} + rejected=[] + for name in ('omit_exchange','omit_translation','omit_sign'): + try:execute(MapBinding(name),map_expected) + except ValueError as exc: + need('literal nonconstant physical producer endpoint' in str(exc), 'targeted mutation failure') + rejected.append(name) + else:raise ValueError('mutation accepted: '+name) + for name in ('transpose_record','transpose_owner_translation'): + try:execute(Map3Binding(name),map3_expected) + except ValueError as exc: + need('literal nonconstant physical producer endpoint' in str(exc), 'targeted convention failure') + rejected.append(name) + else:raise ValueError('matrix convention mutation accepted: '+name) + try:execute(Signed3Binding('reverse_owner_conjugation'),signed3_expected,True) + except ValueError as exc: + need('literal nonconstant physical producer endpoint' in str(exc), + 'targeted nonsymmetric native conjugation failure') + rejected.append('reverse_owner_conjugation') + else:raise ValueError('reversed native owner conjugation accepted') + results['rejected']=rejected + results['scope']='Reduced actual Tape/BankPackets/MonomialPackets/Ordinary/Machine execution; no selected O73 payload or supplier theorem.' + return results + + +if __name__=='__main__': + try:print(json.dumps(run(),sort_keys=True)) + finally:runtime.cleanup() diff --git a/research/qq16-caller-install/producer.py b/research/qq16-caller-install/producer.py new file mode 100644 index 0000000000..7abf64aba3 --- /dev/null +++ b/research/qq16-caller-install/producer.py @@ -0,0 +1,478 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Source-bound QQ16 F0/B1 full-cover producer for the physical C dispatcher. + +Inputs are authenticated decoded source objects. Control uses only the fixed +supplier alphabet, never numerical payloads or decoded input-sized descriptors. +Chris R with OpenAI Codex assistance; retained physical compiler: Jose Manuel. +""" +from collections import Counter +from copy import copy +from fractions import Fraction +from functools import lru_cache +from hashlib import sha256 +import json + + +def need(ok, reason): + if not ok: + raise ValueError(reason) + + +def act(columns, value): + result = 0 + for i, column in enumerate(columns): + if value >> i & 1: + result ^= column + return result + + +def multiply(left, right): + return tuple(act(left, x) for x in right) + +def transpose(matrix): + return tuple(sum(((matrix[i]>>j)&1)<=self.slots,'private producer CLEAR');code.append(('zero',macro_index,target)) + elif op[0]=='copy': + need(target>=self.slots,'private producer COPY');code.append(('copy',macro_index,target,role(op[2]))) + else: + need(op[0] in ('add','scale'),'producer scalar opcode') + j=3 if op[0]=='add' else 2;c=Fraction(op[j],op[j+1]); key=(op[0],c.numerator,c.denominator) + need(key in self.catalogue,'paid producer scalar catalogue') + code.append(('scalar',macro_index,target,role(op[2]) if op[0]=='add' else None,key)) + else: + need(event[0]=='native_line','complete producer macro alphabet') + target=role(event[1]);native=self.packet['native_line_recipes'][event[2]] + need(native['rank']==1,'literal producer rank-one call') + mono(target,self.literal(g),True) + mono(target,self.embed(native['recipe']['right'],self.dimension)) + code.append(('child',macro_index,target,1)) + mono(target,self.embed(native['recipe']['left'],self.dimension)) + mono(target,self.literal(g)) + need(len(code)<65536,'source finite PC width') + return self.Group(keys,tuple(code),recipes) + + def height_programs(self): + """One body per touched family/owner path; permutations have height zero. + + Distinct-family selected owner charts make each core group partition + its touched fields, so looping Gamma does not multiply the height. + Include all three unchanged intervening source cores conservatively. + Omit only outer owner-view monomials, whose height and debt are zero; + their physical actions remain in the separate full-group invoice. + """ + result=[] + for i,event in enumerate(self.events): + if event[0]=='source': + if event[1] in (1,2,3): + call=self.source.calls[self.source.events[event[1]]['time']] + result.append(self.source.codes[call['orientation']]) + elif event[4][0]=='retained_core': + result.append(self.core.codes[event[4][1]]) + elif event[4][0]!='cover_map': + result.append(self.group(i,0,0).code) + need(len(result)==46, 'complete aggregate producer interval height bodies') + return tuple(result) + + def root_child_census(self): + """Count every root child instruction, including the unmodified suffix. + + Local owner views contain no child instruction, so their cached compiled + bodies give the exact multiplicity. Idle groups have one child iff their + literal remainder exists; reconstruct its checked active suffix for + every finite subgroup. Counts do not depend on the cover owner. + """ + source=self.source + local={direction:Counter(op[3] for op in code if op[0]=='child') + for direction,code in source.codes.items()} + core={direction:Counter(op[3] for op in code if op[0]=='child') + for direction,code in self.core.codes.items()} + per_event=[];idle_samples={};kinds=Counter() + no_children={'bridge','terminal','terminal_Y_translations', + 'bank_padding_cover_sweep','translate_every_live_family'} + for index,event in enumerate(source.events): + kind=event['kind'];kinds[kind]+=1;hist=Counter() + if kind=='local_cover_sweep': + need(source.group_count(index)==1,'one local core per cover owner') + hist.update(local[source.calls[event['time']]['orientation']]) + elif kind=='idle_cover_sweep': + need(source.group_count(index)==224,'complete two-side idle port census') + for subgroup in range(224): + side,port=divmod(subgroup,112) + child=event['child_indices'][side] + remainder=source.remainders.get((event['replica'],child,port)) + if remainder: + family=896*event['replica']+(2*event['pair']+side)*112+port + axes=source.data['phases']['recipes'][port]['idle_children'][child]['orthogonal_axes'] + active=tuple(axes[remainder['pending_offset']:]) + need(remainder['family']==family and len(active)==remainder['rank'], + 'actual idle child family and pending suffix') + hist[len(active)]+=1 + idle_samples.setdefault(len(active),(index,subgroup)) + else: + need(kind in no_children,'complete source child-emitting event alphabet') + per_event.append(hist) + # Check the exact dispatcher instructions for each admitted idle rank; + # the full finite subgroup census above checks every remainder instance. + sampled=copy(source);sampled.cover=copy(source.cover) + sampled.cover.unrank=lru_cache(maxsize=1)(source.cover.unrank) + for rank,(index,subgroup) in idle_samples.items(): + actual=Counter(op[3] for op in sampled.group(index,subgroup,0).code if op[0]=='child') + need(actual==Counter({rank:1}),'actual idle dispatcher rank witness') + def total(indices): + answer=Counter() + for index in indices:answer.update(per_event[index]) + return answer + original_pair=total((0,4));retained_core=core['forward']+core['backward'] + outer=Counter() + for event in self.events: + if event[0]!='qq16':continue + macro=event[4] + if macro[0] in ('cover_map','retained_core'):continue + body=macro[2] if macro[0] in ('cover_sweep','private_sweep') else [macro] + for op in body: + if op[0]=='native_line': + outer[self.packet['native_line_recipes'][op[2]]['rank']]+=1 + removed=original_pair-retained_core + need(removed==Counter({8:16}) and retained_core-original_pair==Counter() + and outer==Counter({1:32}),'exact replaced centres and new producer lines') + intervening=total((1,2,3));idle=per_event[5];bridge=per_event[6] + baseline_prefix=total(range(7)) + installed_prefix=retained_core+outer+intervening+idle+bridge + suffix=total(range(7,len(per_event))) + baseline=baseline_prefix+suffix;installed=installed_prefix+suffix + need(baseline-removed+outer==installed,'whole-root native count conservation') + def record(hist): + return {'rank_counts':dict(sorted(hist.items())), + 'calls':sum(hist.values()), + 'rank_mass':sum(rank*count for rank,count in hist.items())} + return {'units':'root child invocations per Gamma; service children separate', + 'baseline_events':len(source.events),'installed_events':len(self.events), + 'source_event_kinds':dict(sorted(kinds.items())), + 'original_pair_0_4':record(original_pair), + 'clean_retained_pair_cores':record(retained_core), + 'qq16_added_lines':record(outer), + 'intervening_source_1_3':record(intervening), + 'idle_source_5':record(idle),'bridge_source_6':record(bridge), + 'baseline_entry_through_bridge':record(baseline_prefix), + 'installed_entry_through_bridge':record(installed_prefix), + 'retained_later_source_7_481':record(suffix), + 'baseline_whole_root':record(baseline), + 'installed_whole_root':record(installed), + 'removed_centres':record(removed), + 'idle_rank_dispatch_witnesses':len(idle_samples), + 'protocol_scope':'Every installed root child uses external-child transfer; same rank does not cancel differing parent protocols or packet contexts.'} + + def audit(self): + # Checker-only memoization of the exact fixed cover value. It changes + # neither the runtime binding nor the source finite-control answers. + audit_source=copy(self.source) + audit_source.cover=copy(self.source.cover) + audit_source.cover.unrank=lru_cache(maxsize=1)(self.source.cover.unrank) + overlap={} + for source_index in (1,2,3): + event=self.source.events[source_index] + owner_families={o.family for o in self.source.owner_specs[event['time']]} + overlap[source_index]=sorted(owner_families & set(range(224))) + need(not overlap[source_index], 'intervening source event touches changed pair0 data') + for port in range(112): + g=audit_source.group(6,port,0) + need(g.keys==((port,0),(224+port,0),(336+port,0),(112+port,0)), + 'both literal bridge legs use immutable original ports') + need(g.code==(('scalar',-1,0,1,('add',1,1)), + ('scalar',-1,2,3,('add',-1,1))), 'both signed bridge instructions') + for side in range(2): + g=audit_source.group(5,112*side+port,0) + need(all(family>=224 for family,_ in g.keys), 'idle pair1 excludes changed pair0') + orders=Counter(); outer=Counter(); nonmap=0; translated=0 + for event in self.events: + if event[0]=='qq16' and event[4][0]!='cover_map': + nonmap+=1 + macro=event[4] + if macro[0]!='retained_core': + for x in macro[2] if macro[0] in ('cover_sweep','private_sweep') else [macro]: + outer[x[0]+(':'+x[1][0] if x[0]=='scalar' else '')]+=1 + if event[0]=='qq16' and event[4][0]=='cover_map': + record=self.packet['map_registry'][event[4][2]] + orders[order(tuple(record['owner_right_matrix_columns']))]+=1 + translated+=bool(record['payload_translation_at_identity_owner']) + need(orders==Counter({2:464,5:24,12:20,6:12,20:4,17:4}), 'complete literal 528 map orders') + need(nonmap==43 and translated==528 and outer==Counter({'scalar:add':2200,'scalar:clear':32,'scalar:scale':16,'native_line':32}), 'complete literal producer outer invoice') + need(self.source_events[5]==self.global_fence+1 and self.source_events[6]==self.global_fence+2, + 'idle and bridge immediately follow global acquisition fence') + return {'status':'PASS_SOURCE_BOUND_PRODUCER_PLAN','expanded_events':len(self.events), + 'global_fence_last_event':self.global_fence,'source_events_retained':len(self.source_events), + 'helper_endpoint_common_label_checks':self.helper_evidence, + 'root_child_census':self.root_child_census(), + 'outer_macro_counts':dict(sorted(outer.items())), + 'nonmap_groups_per_cover':nonmap,'translated_map_calls_per_cover':translated, + 'map_groups_per_cover':str(sum(Fraction(c,k) for k,c in orders.items())), + 'plain_swaps_per_cover':str(sum(Fraction(c*(k-1),k) for k,c in orders.items())), + 'map_owner_control_visits_per_cover':sum(orders.values()), + 'intervening_pair0_owner_intersections':overlap, + 'both_bridge_legs_bound':112,'idle_groups_exclude_pair0':224, + 'map_orders':dict(sorted(orders.items())), 'maximum_map_packet_slots':max(orders), + 'scope':'Finite control and operator lowering; separate original recursive native endpoint required. No production payload execution.'} + + +def machine_class(Machine, Count, transfer, erase_marker): + """Adapt only the child boundary and the one completed global fence. + + `native_child` is a distinct, original-binding closed Machine. Its output + is consumed before the next call. The parent's packet groups are never + passed to this child; only prepare_child's owned capsule is borrowed. + `at_fence` is an optional installed continuation, called once at the bank- + closed global fence, with the parent scratch scope suspended. + """ + class ProducerMachine(Machine): + def __init__(self, binding, native, catalogue, native_child, at_fence=None, observe=None): + super().__init__(binding,native,catalogue,observe) + need(native_child is not self and native_child.closed, + 'separate closed original native child engine') + need(native_child.binding is not binding and + not isinstance(native_child.binding,ProducerBinding), + 'retain original recursive endpoint rather than reentering QQ16 producer') + self.native_child=native_child + self.at_fence=at_fence + self.fence_calls=0 + + def run(self, payload, descriptors): + need(self.closed and self.native_child.closed, 'closed producer and native engines') + self.fence_calls=0 + return super().run(payload,descriptors) + + def enter_child(self): + need(self.scope.manager is None, 'source run exits parent allocation scope before child entry') + self.primitive_boundary() + root,event,subgroup,cover_index,next_pc,target,rank=self.header.read(self.roles['header']) + need((bool(root),event,subgroup,cover_index,next_pc)== + (self.root,self.event,self.subgroup,self.cover_index,self.pc+1), + 'prepared child belongs to exact current producer instruction') + need(self.group.code[self.pc][0]=='child' and self.group.code[self.pc][2:]==(target,rank), + 'literal prepared child target and rank') + descriptors={} + for name in self.capsule: + if name!='current': + c=object.__new__(Count);c.tape=self.capsule[name];descriptors[name]=c + result=self.native_child.run(self.capsule['current'],descriptors) + transfer(result,self.packet(target));erase_marker(result) + for tape in self.capsule.values(): + tape.clear() + self.roles['header'].clear() + self.pc=next_pc + if self.observe: + self.observe(self,'external-child-return') + + def finish_group(self): + super().finish_group() + if (self.root and self.event==self.binding.global_fence and + self.subgroup==0 and self.cover_index==self.binding.cover.size): + need(self.group is None and self.pc==0 and self.bank.state=='closed', + 'completed global producer fence') + self.primitive_boundary() + need(self.fence_calls==0,'single producer continuation fence') + self.fence_calls+=1 + if self.at_fence is not None: + with self.scope.suspended(): + self.at_fence(self) + self.primitive_boundary() + return ProducerMachine diff --git a/research/qq16-caller-install/runtime.py b/research/qq16-caller-install/runtime.py new file mode 100644 index 0000000000..c037424904 --- /dev/null +++ b/research/qq16-caller-install/runtime.py @@ -0,0 +1,42 @@ +"""One authenticated physical cohort; raw canonical modules, no timestamp pyc. + +All source execution follows auth.authenticate. Compile-time geometry and test +oracles are separate from encoded runtime descriptors and payload instructions. +""" +import importlib.abc,importlib.util,sys,types +from pathlib import Path +HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1] +def module(name,path): + result=types.ModuleType(name);result.__file__=str(path) + sys.modules[name]=result + exec(compile(path.read_bytes(),str(path),'exec'),result.__dict__) + return result +def cold(): + auth=module('qq16_auth',HERE/'auth.py');auth.authenticate() + rows=auth.parse((HERE/'SOURCES.json').read_bytes())['files'] + entries={Path(r['path']).stem:(ROOT/r['path'],r['sha256']) for r in rows + if r['usage']=='input' and r['path'].startswith('research/physical-complex-controller/') and r['path'].endswith('.py')} + class RawLoader(importlib.abc.Loader): + def __init__(self,path,digest):self.path,self.digest=path,digest + def create_module(self,spec):return None + def exec_module(self,m): + raw=self.path.read_bytes();auth.need(auth.sha(raw)==self.digest,'canonical executable integrity') + m.__file__=str(self.path);exec(compile(raw,str(self.path),'exec'),m.__dict__) + class Finder(importlib.abc.MetaPathFinder): + def find_spec(self,name,path=None,target=None): + if name in entries: + p,d=entries[name];return importlib.util.spec_from_file_location(name,p,loader=RawLoader(p,d)) + return None + sys.meta_path.insert(0,Finder()) + sys.path.insert(0,str(ROOT/'research/physical-complex-controller')) + import cohort + cohort.activate() + return cohort +def cleanup(): + import tempfile + seen=set() + for m in list(sys.modules.values()): + if m is None:continue + for v in list(vars(m).values()): + if isinstance(v,tempfile.TemporaryDirectory) and id(v) not in seen: + seen.add(id(v));v.cleanup() diff --git a/research/qq16-caller-install/test_verify.py b/research/qq16-caller-install/test_verify.py new file mode 100644 index 0000000000..6a00d4d611 --- /dev/null +++ b/research/qq16-caller-install/test_verify.py @@ -0,0 +1,73 @@ +"""Whole export replay and semantic authentication/receipt boundary controls. +Chris R, substantial OpenAI Codex assistance. Apache-2.0. +""" +import hashlib,importlib.util,json,os,shutil,subprocess,sys,tempfile,unittest +from pathlib import Path +HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1] +def snapshot(root): + return {str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() + for p in root.rglob('*') if p.is_file()} +class Boundary(unittest.TestCase): + def setUp(self): + self.tmp=tempfile.TemporaryDirectory(prefix='qq16-caller-export-');self.addCleanup(self.tmp.cleanup) + self.root=Path(self.tmp.name)/'checkout';self.package=self.root/'research'/HERE.name + shutil.copytree(HERE,self.package,ignore=shutil.ignore_patterns('__pycache__')) + for r in json.loads((HERE/'SOURCES.json').read_text())['files']: + if r['usage']=='input': + target=self.root/r['path'];target.parent.mkdir(parents=True,exist_ok=True) + shutil.copyfile(ROOT/r['path'],target) + def replay(self,*args,optimized=True,ok=True,needle='PASS_QQ16_ACTUAL_CALLER_INSTALLATION_CONTRACT'): + env=dict(os.environ,PATH='/nonexistent-qq16-git-free') + r=subprocess.run([sys.executable,'-I','-Werror','-B',*(['-O'] if optimized else []), + str(self.package/'verify.py'),*args],cwd=self.root,env=env,capture_output=True,text=True,timeout=240) + out=r.stdout+r.stderr;self.assertEqual(r.returncode==0,ok,out) + if needle:self.assertIn(needle,out) + if ok:self.assertFalse(r.stderr,out) + return out + def test_normal_optimized_readonly_export(self): + for p in self.root.rglob('*'): + if p.is_file():p.chmod(0o444) + before=snapshot(self.root);self.replay(optimized=False);self.replay() + self.assertFalse((self.root/'.git').exists());self.assertEqual(before,snapshot(self.root)) + def test_source_before_inherited_execution(self): + source=self.root/'research/physical-complex-controller/machine.py';raw=source.read_bytes() + source.write_bytes(b"raise RuntimeError('UNAUTHENTICATED_MACHINE_EXECUTED')\n"+raw) + (self.package/'connection.py').write_text("raise RuntimeError('CONNECTION_EXECUTED')\n") + out=self.replay(ok=False,needle='source integrity:') + self.assertNotIn('UNAUTHENTICATED_MACHINE_EXECUTED',out) + self.assertNotIn('CONNECTION_EXECUTED',out) + source.write_bytes(raw) + p=self.package/'inputs/PR4129-construction.py' + p.write_bytes(b"raise RuntimeError('SIGNED_EXECUTED')\n"+p.read_bytes()) + out=self.replay(ok=False,needle='source integrity:');self.assertNotIn('SIGNED_EXECUTED',out) + def test_manifest_word_and_exclusive_generation(self): + for name,needle in [('SOURCES.json','manifest integrity:SOURCES.json'), + ('PREDECESSORS.json','manifest integrity:PREDECESSORS.json'), + ('inputs/PR4106-WORD.json','source integrity:')]: + p=self.package/name;raw=p.read_bytes();p.write_bytes(raw+b' ') + self.replay(ok=False,needle=needle);p.write_bytes(raw) + before=snapshot(self.root) + self.replay('--write',ok=False,needle='refuse receipt overwrite') + self.assertEqual(before,snapshot(self.root)) + def test_whole_typed_receipt_validation(self): + # Exercise the actual comparison used after fresh computation, using + # complete expected objects. This avoids rerunning physical arithmetic + # for mutations of transport metadata; full exports above recompute it. + sys.path.insert(0,str(self.package)) + spec=importlib.util.spec_from_file_location('qq16_boundary_verifier',self.package/'verify.py') + m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m) + for name in m.NAMES: + p=self.package/name;raw=p.read_bytes();expected=json.loads(raw) + m.check_receipt(name,expected,self.package) + changed=json.loads(raw) + key=next(iter(changed));changed[key]=False + p.write_text(json.dumps(changed)) + with self.assertRaisesRegex(ValueError,'whole typed receipt mismatch:'): + m.check_receipt(name,expected,self.package) + p.write_bytes(raw) + self.assertNotEqual(m.A.typed(1),m.A.typed(True)) + p=self.package/'RESULT.json';raw=p.read_bytes() + p.write_bytes(b'{"status":false,'+raw.lstrip()[1:]) + with self.assertRaisesRegex(ValueError,'duplicate JSON key:status'): + m.check_receipt('RESULT.json',json.loads(raw),self.package) +if __name__=='__main__':unittest.main() diff --git a/research/qq16-caller-install/verify.py b/research/qq16-caller-install/verify.py new file mode 100644 index 0000000000..7639dca029 --- /dev/null +++ b/research/qq16-caller-install/verify.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +"""Whole source-bound caller composition and typed read-only receipts. +Chris R / Clear1nsight, substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse,json,subprocess,sys,types +from pathlib import Path +HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1] +sys.path.insert(0,str(HERE)) +import runtime +A=runtime.module('qq16_auth',HERE/'auth.py');need=A.need +STATUS='PASS_QQ16_ACTUAL_CALLER_INSTALLATION_CONTRACT' +NAMES=('RESULT.json','COMPILATION.json','BILL.json','EXECUTION.json') + +def physical(name,mode=None): + cmd=[sys.executable,'-I'] + if sys.flags.optimize:cmd+=['-O'] + cmd+=['-Werror','-B',str(HERE/name)] + if mode:cmd+=[mode] + p=subprocess.run(cmd,cwd=ROOT,capture_output=True,text=True,timeout=180) + need(p.returncode==0 and not p.stderr,'physical replay:'+name+':'+p.stdout+p.stderr) + return A.parse(p.stdout) + +def compute(): + pins=A.authenticate() + runtime.cold() + try: + C=runtime.module('qq16_connection',HERE/'connection.py') + data,packet,word,parent,service=C.bindings() + S=runtime.module('qq16_continuation',HERE/'continuation.py') + F=runtime.module('qq16_cost',HERE/'cost.py') + L=runtime.module('qq16_lifecycle',HERE/'lifecycle.py') + producer=parent.audit();decoder=service.audit() + semantic=S.audit(packet,data['phases'],data['programs'],data['template']) + logical=F.module_invoice(word);cost=F.physical_invoice(word) + cost['whole_root_child_protocol']=F.root_protocol_invoice(producer['root_child_census']) + actual=decoder['physical_per_cover'];expected=cost['decoder_service'] + for key in ('rank_one_children','physical_line_monomials','intrinsic_wrappers', + 'owner_basis_monomials','nonmap_groups','all_gather_scatter_commit_groups', + 'all_monomial_calls_including_map_translations', + 'scalar_engine_calls_including_map_sign_corrections','private_zero_calls'): + need(actual[key]==expected[key],'compiled decoder bill:'+key) + ep=cost['producer_outer'] + need(producer['nonmap_groups_per_cover']==ep['nonmap_groups'] and + producer['map_groups_per_cover']==ep['map_router']['gather_scatter_commit_groups_per_Gamma'] and + producer['translated_map_calls_per_cover']==528 and + producer['outer_macro_counts']=={'native_line':32,'scalar:add':2200,'scalar:clear':32,'scalar:scale':16}, + 'actual producer outer bill') + uniform=F.uniform_interval_domain(parent.height_programs()) + need(tuple(uniform[k] for k in ('programs','growth_constant','growth_lambda_slope','debt_constant','debt_lambda_slope','maximum_child_rank')) + ==(46,230124,27834,84422,27834,8),'complete literal interval height') + numeric=[] + for lam in (1,2,8,73): + numeric.append(F.fixed_grid_admission(lam,73*lam,230124+27834*lam,84422+27834*lam,8)) + need(all(r['admitted'] for r in numeric),'fixed admitted source width') + B=1041408*F.gamma()+(1<<100000) + need(4*B+(1<<24)<1<<210000,'all-parameter strict reserve inequality') + source=ROOT/'research/physical-complex-controller' + names=('machine.py','parking.py','bank_packets.py','selected_binding.py') + compatibility=L.parent_source_audit({n:(source/n).read_bytes() for n in names}, + {n:(HERE/'inputs'/('PR3464-'+n)).read_bytes() for n in names}) + native=A.parse((ROOT/'research/qq16-line-normalized-decoder/RESULT.json').read_bytes()) + dictionary={(r['port'],r['sign']):r for r in native['native']['signed_rank_one_recipes']} + generated=[] + from qq16_signed import signed_recipe + installed_lines=[(i,e) for i,e in enumerate(word) if e[0]=='line'] + installed_lines += [(len(word)+224+p,('line','W'+str(p),p,-1)) for p in range(112)] + for i,e in installed_lines: + r=dictionary[e[2],e[3]];recipe=signed_recipe(r['q'],r['sign'],73) + for side in ('right','left'): + rows=recipe[side]['matrix_rows'] + cols=[sum(((rows[j]>>k)&1)<