diff --git a/docs/ci-verification.md b/docs/ci-verification.md index f700630922..006bf5a3d5 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -3,7 +3,9 @@ ## Current selected-family replay: #5599 The [selected record](../certificates/selected-result.json) binds conditional -κ = 0.00310045. `make frontier5599-verify` authenticates the complete source +κ = 0.00310045 to the [proof review](research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md) +and [explicit source closure](../certificates/frontier5599-source.json). +`make frontier5599-verify` authenticates the complete source closure and claim derivation, then executes primary, independent caller positive-control, adapted caller and optimized primary checks serially. The Linux [audit run](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/40253906841) diff --git a/research/p104-temporal-fixed-independent-audit/ADAPTATION.json b/research/p104-temporal-fixed-independent-audit/ADAPTATION.json new file mode 100644 index 0000000000..2c8326152d --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/ADAPTATION.json @@ -0,0 +1,97 @@ +{ + "schema": "exact-local-to-portable-core-preservation/v1", + "historical_registered_checker_sha256": "e2c42f6f5db304067661ec3d54e6c94ebf7bc2fa82d4c8ded7f714cdcb461aa3", + "portable_checker_sha256": "bce6cdf82cb1492d209c241670df894548a485b89622a39851f26352f61e999b", + "portable_checker_execution": "QUALIFIED_DIRECT_NORMAL_AND_EXPLICIT_O", + "scientific_core_definition": "Exact source bytes of the named constants/classes/functions, including Audit and coefficient/JSON parser helpers", + "scientific_core_node_sha256": { + "LIMITS": "bcfad909c83eb410476072c9603a9dd09b475a64a5c52f7c12f77ee511d80710", + "BOUNDS": "5d57aa29f09f22d8f20fdb0d9f1fb7b5c0e3db209d24a337fdbed726d9980039", + "SUBJECT": "e03093b733eb5aea089cd2c0539c93c6be995c877e27ae949857d083a8eada73", + "REQUIRED": "ef1bbcee82770d60886fd7afaef5447e34b3b70996565aa67b6830b9f499e6f2", + "OPTIONAL": "04a77362c62652828182c249b89993fce620827e18a813a15d5960f4354cb709", + "ARITY": "a6456e1cce32a4d8382c0dfaa52be889c7d2cf029b097cb2d0145e59700eb971", + "Unresolved": "63f794cb96bb4a058687543f49f1d50e9d6daf19eff16da580be86679ca09ea6", + "Falsified": "9cd780b5a3be594f0be172e08634d9fc50114ad32aec494fbee170d535122ab6", + "Incomplete": "7043898ab5f5bf04fed7a5e2750313b15e13939d6e173ceb90dba85e306ce350", + "need": "97df2cebe9713e585cee46378f33de80ff329ee94ec4e3b1e77f6e86230f2285", + "fixed": "4ddbcfdf99302de9b8daeef4abc615b810d1ce8c6ad4c52523eb17977abc3a4b", + "deadline": "732e0fdd5efa3e2b5bfb58b8f1a48127fe6b8d4b9873680b2c694080d47ebec5", + "integer": "8fa81b024aa379054abee9fd13dfff378c259b53707d25bec1faa058d251699d", + "canonical": "223f52f64a8c81054b8d5b33d27c7a9ab7819039b9e8b10ca3120bd39d06a8ca", + "sha": "2f1541faf4c4ebe2f74c17d4b666982327a0f1e144708a531c92f08669705d57", + "bounded_read": "674a57f3d7df19d24af518fb218e98d1905200eb39d2b6d72d5dacdba5be60da", + "preflight": "cb296c8a20adcbb887ffd552a14303d5cf867965a3fdc88dcc4e431422d27bb9", + "unique_pairs": "9622d3e0f3c2d2a29295a9f86276d2c54612945736ace45131c447132b601aeb", + "reject_number": "9d23ed500af8c95662864cacbfd92c9c70e25a89bd03a62d848d4098b0065cba", + "decode": "4e3b649c43b401f906ed3724dcb53da4213fbdb5595217171da62c693762c425", + "coefficient": "1215015eeb9b01adccb8c81044b97ee4c378a0a9e6846fcd5c7b91a4ea19a39d", + "Audit": "c49d10a692198ffeb18b67079db5743fc33a5a775f447ed8e39f969b3ed43162" + }, + "scientific_core_manifest_sha256": "6c2de9fa2d5714e7501c308d06492e5bf251c6e9bd341efff0e4f6629c0d2974", + "all_named_nodes_byte_identical": true, + "private_exact_diff_sha256": "4b01e71fad5593ae1bedbbb5a7e2f55325d86a8c51ce96322f5289499d0fe712", + "private_diff_not_public_payload": true, + "wrapper_changes": [ + "One explicit data-file path replaces workspace-specific source path and private review/registration/acquisition wrapper", + "Pinned LICENSE/NOTICE companions verified as data; immutable WORD hash/blob/length checks remain before decode", + "Only basename/public source pins and current code hash enter new output; private I/O paths are omitted", + "Unexpected exception messages suppress local paths; scientific statuses/causal predicates/typed trajectory unchanged" + ], + "historical_receipt_does_not_validate_portable_wrapper": true, + "root_qualification_request": "The completed private V2 request/registration are retained outside this public package; this evidence revision grants no further run.", + "historical_full_scientific_projection": { + "excluded_top_level_fields": [ + "binding", + "elapsed_seconds_internal", + "runtime_memory_and_termination_evidence", + "source" + ], + "exclusion_reason": "Private source/binding wrapper and explicit runtime/elapsed fields only; public immutable source pins are retained separately.", + "included_top_level_fields": [ + "340_stronger_provenance_observation", + "747_read_lifetimes", + "anchors", + "assumptions", + "coverage", + "credited_causal_identity", + "cuts", + "decoded_word_sha256_recorded_after_authorized_decode", + "ledgers", + "new_kappa", + "no_fallback", + "not_proved", + "object_id", + "predicates", + "source_head", + "status", + "write_census" + ], + "sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "exact_equality_to_distributed_scientific_data": true, + "historical_stdout_sha256": "ef45148b8ee100c237432d730c6384e74f436c4e99ccf0195dbd177af50cb02e" + }, + "v2_controls": { + "status": "QUALIFIED_ALL_12_EXPLICIT_SYNTHETIC_CONTROLS", + "portable_verify_unchanged_from_v1": true, + "controls_sha256": "9e9e14f995b47afb13d48a21cdd4c68750ef121a91b00298dd1e5de7a9df697c", + "fixtures_sha256": "494736481a4722b76ca94584df74fec1f58d54d62abe86a4b11ec89da5421c5b", + "raw_verifier_compile_instead_of_pyc_import": true, + "original_authenticated_before_in_memory_derivatives": true, + "assert_acceptance_used": false, + "normal_or_control_phase_executed": true + }, + "qualification": { + "status": "PASS_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "postrun_review_sha256": "5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce", + "root_acceptance_metadata_sha256": "84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666", + "normal_and_explicit_O_passed": true, + "synthetic_controls_passed": 12, + "full_scientific_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "generic_metadata_validation": "NOT_RUN", + "export": "NOT_RUN", + "hosted_replay": "NOT_RUN" + }, + "postrun_revision": "Documentation/evidence/metadata only. verify.py, controls.py, fixtures, scientific-core nodes, historical reference and all retained input pins are unchanged." +} diff --git a/research/p104-temporal-fixed-independent-audit/ADAPTATION.md b/research/p104-temporal-fixed-independent-audit/ADAPTATION.md new file mode 100644 index 0000000000..886459bd5e --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/ADAPTATION.md @@ -0,0 +1,17 @@ +# Exact adaptation and postrun boundary + +Historical local checker SHA256: `e2c42f6f5db304067661ec3d54e6c94ebf7bc2fa82d4c8ded7f714cdcb461aa3`. + +Qualified portable verifier: `bce6cdf82cb1492d209c241670df894548a485b89622a39851f26352f61e999b`. + +Qualified controls: `9e9e14f995b47afb13d48a21cdd4c68750ef121a91b00298dd1e5de7a9df697c`; fixtures: `494736481a4722b76ca94584df74fec1f58d54d62abe86a4b11ec89da5421c5b`. + +The named scientific constants/classes/functions in ADAPTATION.json, including Audit and the input/coefficient parser, retain their exact source bytes from the local checker. Their scientific-core manifest hash is `6c2de9fa2d5714e7501c308d06492e5bf251c6e9bd341efff0e4f6629c0d2974`. The local-to-portable wrapper replaced workspace-specific custody/registration paths with one explicit data argument and active WORD/LICENSE/NOTICE authentication, and removed private paths from output. Its exact private diff was sealed; the private removed lines are not distributed publicly. + +V2 added a separate control harness without changing that verifier. It authenticates and compiles raw verifier bytes, avoiding cached verifier bytecode; authenticates the original before in-memory derivatives; compares the full scientific projection; and requires exact intended predicates/sites. All 12 controls have now passed their registered phase. The prospective-only fixture has original 715/747 in 598 and prospective 715 in 3. The coefficient-only 11202 positive fixture is distinct from the unmodified historical-projection comparison. The minimal 340 fixture tests its precise later stability boundary. No assert-only acceptance or source-file mutation is used. + +Normal and explicit `-O` direct runs reproduce all 17 historical scientific fields, SHA256 `8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c`. Agreement is reproduction, not a new independent checking method. Root's recorded outcome and separate static AI postrun review support only the fixed causal/typed scope; that reviewer did not execute a further replay or reread WORD. + +This final-publication revision changes documentation, evidence and metadata only. The verifier, controls, fixtures, historical reference, scientific core and retained input pins remain byte-for-byte unchanged from qualified V2. Frozen preparation-time UNRUN notices in hash-bound code/fixtures are retained as historical input labels; current execution evidence is stored separately. V1 and V2 local artifacts remain preserved. No new scientific run, source decode, export, Git or upstream action occurred during this revision. + +The implementation/publication identity and final byte/history/generic/CI/render checks remain root-owned and pending. Generic/export/hosted passes are not inferred from direct qualification. No new kappa or broader native/caller/price admission follows. diff --git a/research/p104-temporal-fixed-independent-audit/CONTROL-CONTRACTS.json b/research/p104-temporal-fixed-independent-audit/CONTROL-CONTRACTS.json new file mode 100644 index 0000000000..1cfdb11ad5 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/CONTROL-CONTRACTS.json @@ -0,0 +1,73 @@ +{ + "schema": "portable-fixed5713-control-contracts/v2", + "status": "QUALIFIED_12_EXPLICIT_SYNTHETIC_BOUNDARY_CONTROLS", + "harness_implemented": true, + "automatic_execution_authorized": false, + "immutable_source_rule": "Never modify the original retained WORD. A future separately reviewed harness may authenticate it and construct explicitly synthetic in-memory derivatives with unique synthetic labels; no derivative is source evidence.", + "default_pinned_wrapper": "Every changed compressed input fails custody before decode. Semantic controls therefore require an explicitly labeled synthetic Audit-level harness, not a bypass presented as original data.", + "designs": [ + { + "id": "SOURCE_BYTES", + "operation": "Change one compressed byte in an isolated synthetic copy named WORD.json.gz", + "expected": "BINDING_UNRESOLVED before gzip/JSON decoding", + "exercises": "Custody fail-closed path" + }, + { + "id": "HIDDEN715_READ", + "operation": "Synthetic replacement of original event823 by ADD207,715,1@3; label derivative and retain original unchanged", + "expected": "FIXED_SUFFICIENT_PREMISE_NOT_ESTABLISHED:715_NO_OUTWARD_OBSERVER_OR_FORBIDDEN_CHANGE at823", + "exercises": "Causal source-observer gate, not an identity counterexample" + }, + { + "id": "CHANGED747_WRITE", + "operation": "Synthetic replacement of known source-read13574 by ADD747,713,1@598", + "expected": "Fixed747 sufficient continuity premise not established at13574", + "exercises": "Known active owned destination write, without claiming actual nonzero defect" + }, + { + "id": "CHANGED747_LIFETIME", + "operation": "Synthetic replacement of13574 by CLEAR747@598", + "expected": "Fixed747 continuity/lifecycle premise not established at13574", + "exercises": "Owned lifetime continuity; no original source mutated" + }, + { + "id": "RETAINED715_WRONG_FRAME", + "operation": "Synthetic replacement of nonanchor13579 (original CLEAR747@598) by ADD715,747,1@598; old715/747 are598, prospective715 is3.", + "expected": "PROSPECTIVE715_RETAINED_SCALAR_CONTACT at13579; original tracked common frame passes.", + "exercises": "Destination-only ADD passes the causal barrier and original typing but fails prospective typing. Synthetic branch test only; no actual source mutation/result." + }, + { + "id": "UNKNOWN_SEMANTICS", + "operation": "Synthetic replacement at823 by an unknown QUERY event", + "expected": "BINDING_UNRESOLVED, never a scientific falsifier", + "exercises": "Closed grammar/observer ambiguity" + } + ], + "qualification": { + "status": "PASS_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "postrun_review_sha256": "5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce", + "root_acceptance_metadata_sha256": "84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666", + "normal_and_explicit_O_passed": true, + "synthetic_controls_passed": 12, + "full_scientific_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "generic_metadata_validation": "NOT_RUN", + "export": "NOT_RUN", + "hosted_replay": "NOT_RUN" + }, + "harness": "controls.py authenticates raw portable verifier and compiles the authenticated bytes; no stale verify.pyc or author import.", + "fixtures": "CONTROL-FIXTURES.json; fixed SHA256 bound by controls.py", + "original_authentication": "Actual normal wrapper baseline authenticates all original inputs and compares complete scientific projection before any derivative; source bytes are authenticated again for byte-mismatch test.", + "acceptance": "Explicit require/exception checks, no assert-only acceptance. Exact intended predicate/site required for every negative semantic fixture.", + "synthetic_label": "Every emitted test record is SYNTHETIC_CONTROL_ONLY, including envelope probes and original-baseline reference inside the harness.", + "other_implemented_checks": [ + "Original normal status/envelope/body hash and complete historical scientific projection", + "Corrupted receipt digest rejected", + "Unscoped PASS status rejected even with a matching digest", + "Missing cuts rejected even with a matching digest", + "Coefficient-only11202 write remains nonblocking", + "Required minimal340 interval write rejected at its exact intended predicate" + ], + "execution": "One registered synthetic-control phase completed all12 cases with exact intended outcomes and labels. No actual source counterexample is proved, and no automatic rerun/export or source repair is authorized.", + "frozen_fixture_status_note": "CONTROL-FIXTURES.json and source headers retain preparation-time UNRUN notices to preserve qualified hashes. Their execution status is recorded separately here and in qualification evidence." +} diff --git a/research/p104-temporal-fixed-independent-audit/CONTROL-FIXTURES.json b/research/p104-temporal-fixed-independent-audit/CONTROL-FIXTURES.json new file mode 100644 index 0000000000..9344bf26cf --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/CONTROL-FIXTURES.json @@ -0,0 +1,159 @@ +{ + "schema": "portable5713-explicit-synthetic-control-fixtures/v2", + "label": "SYNTHETIC_CONTROL_ONLY", + "status": "IMPLEMENTED_UNRUN", + "original_file_mutation": false, + "verifier_sha256": "bce6cdf82cb1492d209c241670df894548a485b89622a39851f26352f61e999b", + "event_mutants": [ + { + "id": "HIDDEN715_READ", + "index": 823, + "original_expected": [ + "ADD", + 207, + 720, + "-2", + 3 + ], + "replacement": [ + "ADD", + 207, + 715, + "1", + 3 + ], + "expected_kind": "fixed_premise", + "expected_predicate": "715_NO_OUTWARD_OBSERVER_OR_FORBIDDEN_CHANGE", + "prerequisite": "CUT823_715_FRAME3" + }, + { + "id": "CHANGED747_VALUE_WRITE", + "index": 13574, + "original_expected": [ + "ADD", + 713, + 747, + "1", + 598 + ], + "replacement": [ + "ADD", + 747, + 713, + "1", + 598 + ], + "expected_kind": "fixed_premise", + "expected_predicate": "747_NO_INTERVENING_WRITE_OR_LIFECYCLE", + "prerequisite": "747_LIVE_598" + }, + { + "id": "CHANGED747_LIFETIME", + "index": 13574, + "original_expected": [ + "ADD", + 713, + 747, + "1", + 598 + ], + "replacement": [ + "CLEAR", + 747, + 598 + ], + "expected_kind": "fixed_premise", + "expected_predicate": "747_NO_INTERVENING_WRITE_OR_LIFECYCLE", + "prerequisite": "747_LIVE_598" + }, + { + "id": "PROSPECTIVE_ONLY_715_CONTACT", + "index": 13579, + "original_expected": [ + "CLEAR", + 747, + 598 + ], + "replacement": [ + "ADD", + 715, + 747, + "1", + 598 + ], + "expected_kind": "fixed_premise", + "expected_predicate": "PROSPECTIVE715_RETAINED_SCALAR_CONTACT", + "expected_frame": 598, + "expected_actual": 3, + "prerequisite": "715_AND747_LIVE_598_AFTER13578" + }, + { + "id": "UNKNOWN_SEMANTICS", + "index": 823, + "original_expected": [ + "ADD", + 207, + 720, + "-2", + 3 + ], + "replacement": [ + "QUERY", + 715 + ], + "expected_kind": "unresolved", + "expected_reason": "Unknown opcode/arity", + "prerequisite": "CUT823_715_FRAME3" + }, + { + "id": "NONBLOCKING11202_WRITE", + "index": 11202, + "original_expected": [ + "ADD", + 340, + 337, + "1", + 396 + ], + "replacement": [ + "ADD", + 340, + 337, + "2", + 396 + ], + "expected_kind": "pass", + "prerequisite": "340_FRAME396_AT11202" + }, + { + "id": "MINIMAL340_INTERVAL_WRITE", + "index": 14655, + "original_expected": [ + "MOVE", + 712, + 598, + 397, + false + ], + "replacement": [ + "ADD", + 340, + 525, + "1", + 396 + ], + "expected_kind": "fixed_premise", + "expected_predicate": "340_MINIMAL_READ_TO_CUT_STABILITY", + "prerequisite": "340_AND525_FRAME396_AFTER14654" + } + ], + "other_controls": [ + "ORIGINAL_BASELINE_ENVELOPE_AND_FULL_PROJECTION", + "SOURCE_BYTE_MISMATCH_PREDECODE", + "BAD_ENVELOPE_HASH", + "UNSCOPED_PASS_STATUS", + "MISSING_SCIENTIFIC_PROJECTION_FIELD" + ], + "meaning": "Every derivative is synthetic. A rejected sufficient premise is not an identity counterexample or author defect. No fixture is source evidence.", + "execution": "Future separately registered controls only; no automatic invocation, retries, source writes or unregistered grant." +} diff --git a/research/p104-temporal-fixed-independent-audit/LICENSE b/research/p104-temporal-fixed-independent-audit/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/p104-temporal-fixed-independent-audit/NOTICE b/research/p104-temporal-fixed-independent-audit/NOTICE new file mode 100644 index 0000000000..f1ac6b121d --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/NOTICE @@ -0,0 +1,50 @@ +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + + +Independent fixed temporal-audit addendum (Apache-2.0). +PR5684 reorder/reframe work: Joel Pulikkan (GamingPuzzled), with Claude assistance. +PR5713 temporal identity, construction and author checks: Ali Romman, with substantial OpenAI Codex assistance. +This independent audit and portable preparation were produced with substantial OpenAI Codex assistance, including multiple agents for static contracts and separate local AI review. +The historical No subagents statements above describe their original source contributions, not this independent audit. +Local accepted source-premise evidence, unrun portable code, full scientific admission, human acceptance and selected-frontier status are distinct. diff --git a/research/p104-temporal-fixed-independent-audit/PROOF.md b/research/p104-temporal-fixed-independent-audit/PROOF.md new file mode 100644 index 0000000000..f7d00e46e5 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/PROOF.md @@ -0,0 +1,29 @@ +# Scope of the independent causal and contact certificate + +The temporal construction and direct identity belong to Ali Romman's PR5713. This note explains the fixed premises independently checked by the scanner. Portable normal, explicit `-O` and all 12 synthetic controls have completed their qualified direct runs; no new construction, mathematical identity or kappa is supplied. + +All indices are zero-based in original PR5684. Cut $c$ is immediately before original event $c$. Let $A$ be field 525 at cut 823, $B$ field 712 there, $V$ field 747 immediately before 13578, $C$ field 340 at cut 14983 and $D$ field 525 there. These are arbitrary actual decoded causal values and may depend on all public or dirty-owned inputs. No zero-input or 105-coordinate spanning assumption is imposed. + +The complete causal ledger establishes these sufficient premises under straight-line positional scalar semantics and the retained value-preserving decoded native-MOVE contract: + +- Field 712 has only write 13572 in `[823,14983)`, adding 747. Its source reads at 13572 and 13578 use the same live birth token 1 from 13565 in chart 598, with no intervening 747 write or lifecycle change. Thus 712 is $B+V$ at its later use. +- Field 525 has exactly two writes: subtract $4\cdot712$ at 13737, then add 340 at 14654. No 340 write occurs in `[14654,14983)`, so the latter added value is $C$. +- Field 715 has no outward observer or forbidden SCALE/COPY/lifetime change in `[823,14983)`. Destination-only accumulation and decoded value-preserving transport are distinguished from source observations. + +The author's relation follows for those arbitrary causal values: + +$$ +D=A-4(B+V)+C,\qquad V=\frac{A}{4}-B-\frac{D}{4}+\frac{C}{4}. +$$ + +The four prescribed updates read 525/712 at cut 823 in chart 3 and 525/340 at cut 14983 in chart 396. Their combined contribution equals the removed update from 747 into 715. Other fields follow their original logical trajectories because they cannot observe 715's transient difference. That difference is zero before original event 14983 reads 715. This conditional temporal argument is not an independently computed complete endpoint matrix. + +The prospective native typing timeline is checked separately across the whole program. It skips old 715 MOVE 13577 and ADD 13578, interprets 14982 as 715:3→396, and checks every retained 715 scalar/MOVE contact plus all four insertion contacts. The real ledger covers 16 original contacts, 14 retained, including destination ADD 17439 in chart 127. A no-read argument alone would miss a retained destination contact requiring a deleted chart. The scanner emits no changed WORD. + +Actual event 11202 is `ADD 340,337,1@396`. This earlier write is nonblocking provenance. Required equality of the later source value is the read-to-cut condition `[14654,14983)`, chosen before the original execution. Clarifying the stronger inclusive wording does not infer an identity defect. + +The binary-space path 3⊊598⊊396 and dimensions 0,1,3 are source-type premises checked by the parser. Exact canonical transports telescope after decoding. Neither fact supplies the direct 3→396 provider, its scalar/global phase, monomial normalizers or all-width theorem; nor can transport composition erase an intervening ADD without the temporal argument. + +The portable normal and optimized receipts reproduce the full historical scientific projection. The executed synthetic controls test their exact intended sufficient-test boundaries: predecode custody, observation, owned continuity, prospective typing, unknown semantics, minimal stability and envelope/projection validation. Their results are explicitly synthetic. Extra writes could cancel and actual defects could vanish, so a failed sufficient predicate is not an identity counterexample. The positive coefficient-only 11202 fixture confirms nonblocking provenance while preserving the required later stability. + +The accepted result remains `PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY`. Complete emitted5713 equality, scalar/owned-zero endpoints, exact native provider/absolute phase/all widths, caller, invoice and compiler/outer acceptance remain separate. All five framework assumptions remain. No full multiplication theorem, Lean theorem, native/full-price admission, new saving or `.00311` result follows. diff --git a/research/p104-temporal-fixed-independent-audit/PUBLICATION-STATE.json b/research/p104-temporal-fixed-independent-audit/PUBLICATION-STATE.json new file mode 100644 index 0000000000..a961cfe6ad --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/PUBLICATION-STATE.json @@ -0,0 +1,41 @@ +{ + "schema": "fixed5713-final-publication-state/v1", + "status": "FINAL_TEXT_AND_EVIDENCE_REVISION_READY_FOR_ROOT_REVIEW", + "documentation_revision_only": true, + "qualified_verifier_sha256": "bce6cdf82cb1492d209c241670df894548a485b89622a39851f26352f61e999b", + "qualified_controls_sha256": "9e9e14f995b47afb13d48a21cdd4c68750ef121a91b00298dd1e5de7a9df697c", + "qualified_fixtures_sha256": "494736481a4722b76ca94584df74fec1f58d54d62abe86a4b11ec89da5421c5b", + "scientific_core_sha256": "6c2de9fa2d5714e7501c308d06492e5bf251c6e9bd341efff0e4f6629c0d2974", + "full_scientific_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "qualification_outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "qualification_postrun_review_sha256": "5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce", + "root_acceptance_metadata_sha256": "84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666", + "root_acceptance_is_additional_source_science": false, + "source_retention_commit": "e8567c39feda6412a1e5a54e10aeb0a6d4d1e80c", + "source_retention_tree": "7f4c2d03f0b44dfe7da32aaeffaf59f30d780582", + "implementation_commit": null, + "implementation_tree": null, + "pull_request": null, + "CI_identity": null, + "generic_metadata_validation": "NOT_RUN", + "source_export": "NOT_RUN", + "hosted_replay": "NOT_RUN", + "postrun_scientific_rerun_during_final_preparation": false, + "external_complementary_PR5717": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5717", + "role": "External complementary caller/owned-lifetime evidence identified by root; not this package replay or native/full-price result; no source-input pin invented.", + "head": "41fda9302e5de79911b0c91c6161beaf386798b3" + }, + "new_kappa": null, + "author_PR5713_kappa_unchanged": ".00310915222", + "selected_record_unchanged": ".00310045", + "goal_at_least_00311_fulfilled": false, + "identity_tracking": "Qualification-stage snapshot only; later implementation/PR/export/CI identities are recorded in Git history, the upstream PR and export manifest.", + "external_later_PR5718": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5718", + "head": "a1534ac45401c9a9c80c07aa65c89e00e33594f8", + "author_reported_conditional_kappa": ".00311024570", + "not_this_package_validation": true, + "fixed_certificate_transfer_established": false + } +} diff --git a/research/p104-temporal-fixed-independent-audit/README.md b/research/p104-temporal-fixed-independent-audit/README.md new file mode 100644 index 0000000000..5ed759e99f --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/README.md @@ -0,0 +1,77 @@ +# Independent fixed source and typed-contact audit for PR5713 + +This package independently checks the fixed original-source premises behind [Ali Romman's PR5713](https://github.com/CrocSwap/integer-mult-bounds/pull/5713), head `a5348f7143f95fe0046b92b96172e30763c7d731`. It verifies the credited temporal identity's causal write, observer and owned-lifetime premises, together with every prescribed prospective contact of field 715. It does not independently admit the complete successor, its native provider or its price. + +**Direct qualification completed:** the portable normal verifier, explicit `-O` verifier and all 12 synthetic controls passed their registered phases. Both positive runs reproduce the complete 17-field historical scientific projection, SHA256 `8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c`. A separate local AI postrun review accepted this exact limited result. Final publication, generic metadata validation, export and hosted replay are separate: none is claimed as completed here. + +## Result and scope + +The original independent local checker completed 25,451 PR5684 events and returned the real 23-entry scoped ledger. Portable normal and optimized runs reproduce all ten named predicates, the complete cuts/anchors/ledgers and the prescribed contact trace. The certificate checks: + +- field 712's sole relevant write at 13572 and field 525's writes at 13737 and 14654; +- field 747's same live owned birth from 13565 at both reads; +- the protected field-715 interval and the actual common charts at cuts 823 and 14983; +- all 14 retained original field-715 contacts and four insertion contacts, including the retained destination ADD at 17439. + +The actual event 11202 is `ADD 340,337,1@396`. It is nonblocking provenance. The needed condition is no write to 340 in `[14654,14983)`, fixed before the original execution and satisfied by the source. This clarifies a stronger earlier no-write wording; it is not an identity bug or a post-run boundary repair. + +The author's relation is + +$$ +D=A-4(B+V)+C,\qquad V=A/4-B-D/4+C/4. +$$ + +[PROOF.md](PROOF.md) explains the conditional arbitrary-value transfer and its limits. No prefix matrix, 105-coordinate spanning assertion, author constructor or new mathematical identity is used by this checker. This is independent implementation evidence for the fixed causal and typing premises. + +## Reproduction and exact sources + +Python 3.12 and its standard library suffice. From the repository root: + +```sh +python3 -B research/p104-temporal-fixed-independent-audit/verify.py research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz +python3 -O -B research/p104-temporal-fixed-independent-audit/verify.py research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz +python3 -B research/p104-temporal-fixed-independent-audit/controls.py research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz +``` + +The two verifier commands return `PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY`. The control command returns `PASS_EXPLICIT_PORTABLE_CONTROL_SET_ONLY`; every test record is labeled `SYNTHETIC_CONTROL_ONLY`. Controls authenticate and compile raw verifier bytes rather than import cached `verify.pyc`. The original fixed input is authenticated before any in-memory derivative. No original file is written, and there is no assert-only acceptance. + +The original source is [PR5684](https://github.com/CrocSwap/integer-mult-bounds/pull/5684) at `d0f6fa2555410a1e23fe4191424c2097ab3d5d97`, path `research/p104-reframe-r22/WORD.json.gz`: 106613 compressed bytes, Git blob `f3fb0e2144ec8a5c3407e4eaa6528bb3436ba573`, SHA256 `d6db1d0d97b13ea483a462c65437664d15d34dec56c3682cf6e1de31266ec6c2`. + +The three live inputs are retained in `Clear1nsight/integer-mult-bounds` at real commit `e8567c39feda6412a1e5a54e10aeb0a6d4d1e80c`, tree `7f4c2d03f0b44dfe7da32aaeffaf59f30d780582`: `inputs/WORD.json.gz`, [LICENSE](inputs/LICENSE) and [NOTICE](inputs/NOTICE). All are actively checked by length, SHA256 and Git blob; WORD is authenticated before decoding. The retention parent is PR5703's shared fix `475cfff509e3369926c5b2ee258fc8f1f9c3c6a1` over canonical base `df0137efd35e11b4445734bf612bdd4c7ebc330c`. Original PR5684 is descriptive source credit rather than an assumed reachable foreign dependency. No Git, network, author import or archive is needed by the standalone verifier. + +## Qualification evidence + +[PORTABLE-V2-OUTCOME.json](evidence/PORTABLE-V2-OUTCOME.json), SHA256 `7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8`, records the three real runs. [The static postrun review](evidence/PORTABLE-V2-POSTRUN-REVIEW.json), SHA256 `5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce`, accepts their limited scope. Root's acceptance hash `84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666` identifies coordination metadata, not additional source science. + +| Recorded phase | Child elapsed seconds | Sampled descendant RSS maximum, bytes | Result | +| --- | ---: | ---: | --- | +| Normal | 0.503533 | 26210304 | Narrow source/contact PASS | +| Explicit `-O` | 0.705401 | 29077504 | Same full scientific projection | +| Synthetic controls | 1.107103 | 27848704 | All 12 controls PASS | + +All three children exited zero without termination. The recorded related child time is **2.8210496769752353 seconds**, including the original local run of 0.5050126829883084 seconds. This is child-time accounting, not complete orchestration wall time. RSS values are sampled maxima, not exact peaks or future performance guarantees. Root used phase caps of 45/45/60 seconds, 512 MiB limits and a shared 150-second budget, with serial execution and no retries. + +The controls exercise predecode source rejection with zero gzip/decode calls; hidden 715 observation; 747 write/lifetime changes; a prospective-only retained contact; unknown semantics; nonblocking 11202 versus minimal 340 stability; and digest, status and full-projection validators. Each negative reaches its exact intended predicate/site. Synthetic rejection establishes no actual source counterexample or identity defect. Normal/optimized agreement is reproduction by the same scientific method, not a second independent method. + +[The runtime summary](evidence/PORTABLE-V2-RUNTIME-SUMMARY.json) is explicitly **derived and privacy-filtered**, not an original raw guard or stdout. It retains actual original hashes. Private command/cwd/request/registration wrappers and raw guards are excluded. [The scientific extract](evidence/SCIENTIFIC-RECEIPT-EXTRACT.json) preserves all 17 historical scientific fields, excluding only explicit private source/binding and elapsed/runtime wrapper fields. Its own file hash is distinct from original stdout/body hashes. The postrun reviewer checked recorded evidence; it did not reread WORD or independently rehash the checkout. + +`verify.py`, `controls.py`, fixtures and all retained input pins are byte-for-byte unchanged from qualified V2. [ADAPTATION.json](ADAPTATION.json) seals their identities and the scientific-core manifest. Their frozen preparation-time `UNRUN` headers and fixture status remain as historical input notices; actual execution status is recorded separately here and in qualification evidence. This final revision changes documentation/evidence/metadata only and performs no scientific rerun. + +## Remaining boundaries + +All five inherited assumptions remain: native all-column extension; owned allocation/erasure; uniform compiler/completion/splitting; precision/storage/fixed tape; and analytic decomposition/fine-prime/exact recovery. + +This certificate does not establish emitted5713 equality, exact 3→396 native provider/absolute phase/all widths, a complete scalar endpoint matrix, owned-zero erasures, the physical caller, full invoice, both moment engines, ordinary/stock/precision/tape/BIT/compiler or 54+4 outer predicates. All eight owned H7 centre queries remain paid. PR5713's author-reported `.00310915222` and its raw invoice are unchanged. This certificate supplies no new saving or `.00311` admission. The selected record at the stated canonical main remains `.00310045`. + +Root identifies [PR5717](https://github.com/CrocSwap/integer-mult-bounds/pull/5717) as external complementary caller/owned-lifetime evidence. Its externally reviewed head is `41fda9302e5de79911b0c91c6161beaf386798b3`. It is not a pinned input or replay by this package, and its scope must not be conflated with this fixed-715 audit or credited here as native/full-price admission. + +A later construction, [PR5718](https://github.com/CrocSwap/integer-mult-bounds/pull/5718), flyingviper head `a1534ac45401c9a9c80c07aa65c89e00e33594f8`, reports conditional kappa `.00311024570` using distinct input/output helper bases. This is external author evidence, not this package's validation or gain. Its inserted events, new public helper and shifted owned labels mean the fixed event/field certificate here does not automatically transfer to that successor. The present package remains bound to PR5713 and its original PR5684 input. + +`VERIFY.json` is ready/runnable metadata for the qualified commands. At the qualification snapshot, generic metadata, export and hosted checks were **NOT RUN**. This declaration claims no such pass; later publication evidence belongs to the PR and export records. The implementation commit, PR and CI identities remain pending until real values are supplied by root. Final byte/history/guidance/render/publication decisions remain separate. + +## Open next questions + +1. Does the emitted5713 artifact implement exactly the credited edit under complete native and caller contracts? A distinct scope must bind the emitted word, exact provider/phase/all-width and endpoint/erasure evidence before broader admission. +2. Are the final committed source/history metadata, replay selection and public rendering correct? Root must bind the actual implementation identity and choose applicable metadata/CI/render checks. Direct qualification does not answer these publication questions or grant an export/rerun. + +These questions and the unchanged full original `p104-side-correction` card are in [TASK.json](TASK.json), with refined audit scope. No picker/reroll, Lean theorem or broad novelty claim is involved. Credit Ali Romman's temporal construction; Joel Pulikkan/GamingPuzzled with Claude assistance for R22; and the complete retained PR5678/5660/P104/native/helper/caller/compiler lineage. [NOTICE](NOTICE) preserves the original notice verbatim and appends the R22 and multi-agent OpenAI disclosures. Separate local AI reviews are not independent human or proof-kernel acceptance. Apache-2.0 applies. diff --git a/research/p104-temporal-fixed-independent-audit/SOURCES.json b/research/p104-temporal-fixed-independent-audit/SOURCES.json new file mode 100644 index 0000000000..d545b65fca --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/SOURCES.json @@ -0,0 +1,80 @@ +{ + "schema_version": 1, + "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c", + "status": "REAL_RETAINED_INPUTS_AND_DIRECT_PORTABLE_QUALIFICATION_BOUND", + "files": [ + { + "path": "research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz", + "usage": "input", + "git_blob": "f3fb0e2144ec8a5c3407e4eaa6528bb3436ba573", + "sha256": "d6db1d0d97b13ea483a462c65437664d15d34dec56c3682cf6e1de31266ec6c2", + "bytes": 106613, + "pin": "head:e8567c39feda6412a1e5a54e10aeb0a6d4d1e80c:research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz", + "pin_status": "REAL_RETENTION_COMMIT_ROOT_REMOTE_READBACK" + }, + { + "path": "research/p104-temporal-fixed-independent-audit/inputs/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "bytes": 11357, + "pin": "head:e8567c39feda6412a1e5a54e10aeb0a6d4d1e80c:research/p104-temporal-fixed-independent-audit/inputs/LICENSE", + "pin_status": "REAL_RETENTION_COMMIT_ROOT_REMOTE_READBACK" + }, + { + "path": "research/p104-temporal-fixed-independent-audit/inputs/NOTICE", + "usage": "input", + "git_blob": "fa0bd1401f5775f4351cfa23b08f3998dba6129e", + "sha256": "e8e0cabef6cf40d63f3cea3b6403dfd1af8727e40df03f09b2932718bcddc1b0", + "bytes": 2179, + "pin": "head:e8567c39feda6412a1e5a54e10aeb0a6d4d1e80c:research/p104-temporal-fixed-independent-audit/inputs/NOTICE", + "pin_status": "REAL_RETENTION_COMMIT_ROOT_REMOTE_READBACK" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ], + "retention_commit": "e8567c39feda6412a1e5a54e10aeb0a6d4d1e80c", + "word_custody": "Root staged/remote-readback retained inputs and guarded portable phases authenticated exact bytes before decode. Final publication preparer did not read, copy or hash WORD.", + "input_verification": "Portable verifier actively checks exact bytes/SHA256/Git blob for WORD and retained LICENSE/NOTICE, rather than treating source rows as decorative.", + "original_source": { + "repository": "GamingPuzzled/integer-mult-bounds", + "head": "d0f6fa2555410a1e23fe4191424c2097ab3d5d97", + "committed_path": "research/p104-reframe-r22/WORD.json.gz" + }, + "credited_construction": { + "repository": "aliromman/integer-mult-bounds", + "head": "a5348f7143f95fe0046b92b96172e30763c7d731", + "package": "research/p104-temporal-updates", + "proof_sha256": "24a9d3d0abded70d995f4bf944048c60fab972d1badb17335460b54a117e626e", + "readme_sha256": "506d585cf6b6018917f15a31de6e288c301221d367d2f60afe977a810d328439", + "role": "Public reference/credit; no author executable imported" + }, + "pending_rule": "Implementation/publication identity, final byte/history review, generic metadata/export/hosted/CI/render evidence remain root-owned and pending; no invented commit or pass.", + "retention_repository": "Clear1nsight/integer-mult-bounds", + "retention_tree": "7f4c2d03f0b44dfe7da32aaeffaf59f30d780582", + "retention_parent": "475cfff509e3369926c5b2ee258fc8f1f9c3c6a1", + "retention_shared_fix_pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/5703", + "retention_evidence": "Root reports exact three-file retention commit and remote byte readback; preparation did not read WORD.", + "qualification_evidence": { + "status": "PASS_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "postrun_review_sha256": "5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce", + "root_acceptance_metadata_sha256": "84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666", + "normal_and_explicit_O_passed": true, + "synthetic_controls_passed": 12, + "full_scientific_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "generic_metadata_validation": "NOT_RUN", + "export": "NOT_RUN", + "hosted_replay": "NOT_RUN" + } +} diff --git a/research/p104-temporal-fixed-independent-audit/TASK.json b/research/p104-temporal-fixed-independent-audit/TASK.json new file mode 100644 index 0000000000..665f78eba2 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/TASK.json @@ -0,0 +1,157 @@ +{ + "schema_version": 1, + "task": "p104-side-correction", + "original_card": { + "id": "p104-side-correction", + "question": "Can a changed P104 producer/consumer contract escape the scoped slot, chart and completion obstructions with a favorable full bill?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/p104-literal-slot-defect/README.md", + "research/p104-uniform-commutation-gap/README.md", + "research/p104-uniform-encoding-gap/README.md", + "research/p104-source-chart-shortcut/README.md", + "research/p104-fiber-tag-seam/README.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. 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 named successor obstructions before extending #2981 static flags. Distinguish literal-slot action, commutation, uniform encoding, source-chart shortcut and fiber-tag seam scopes; none excludes all P104 mechanisms.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Name one hypothesis changed from these exact interfaces. Write a literal producer-to-consumer timeline and an arbitrary-dirty-input positive/control pair, then charge acquisition, coefficients, completion, hosting and restoration. Stop if the same slot/fiber mismatch persists or the favorable full budget already fails. A scoped independent audit remains useful; another static count is not a new completion.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier.", + "Repeating a correction or physical conversion already supplied by a pending follow-up without adding independent coverage or a different unresolved obligation.", + "Repeating the 208-flag static matching or calling a static nested cover a chronological correction program. Independent audit of that certificate is distinct and remains useful.", + "Repeating a static cover, source-chart shortcut or fiber-tag seam without changing the hypothesis responsible for its obstruction." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991", + "2586", + "endpoint transport", + "physical dual", + "relay composition", + "2981", + "joint unit flags", + "acquisition delivery", + "static nesting", + "4133", + "4136", + "4140", + "4153", + "4154", + "p104-literal-slot-defect", + "p104-uniform-commutation-gap", + "p104-uniform-encoding-gap", + "p104-source-chart-shortcut", + "p104-fiber-tag-seam" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "scope_change_reason": "Independent fixed causal and typed715 audit of the credited PR5713 temporal rewrite; no new correction mechanism, producer/caller change or kappa claim.", + "scope_key": "pr5713/original5684/fixed715/causal-ledger-and-all-prospective-contacts", + "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c", + "selected_record_decimal": "0.00310045", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "assignment": "Explicit portable-verification preparation; no picker/reroll", + "milestone": "Qualified independent fixed causal/typed-contact certificate with direct normal, explicit-O and12 synthetic controls; final publication evidence revision only.", + "formal_Lean": false, + "outcome": "partial", + "qualification": { + "status": "PASS_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "postrun_review_sha256": "5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce", + "root_acceptance_metadata_sha256": "84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666", + "normal_and_explicit_O_passed": true, + "synthetic_controls_passed": 12, + "full_scientific_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "generic_metadata_validation": "NOT_RUN", + "export": "NOT_RUN", + "hosted_replay": "NOT_RUN" + }, + "task_id": "p104-side-correction", + "actual_scope": "Independently verify the fixed original PR5684 causal ledger and every prescribed prospective field715 contact supporting the PR5713 temporal rewrite.", + "bottleneck_link": "https://github.com/CrocSwap/integer-mult-bounds/pull/5713", + "stop_rule": "Stop on source/grammar mismatch, an unmet fixed causal or typed premise, incomplete receipt or resource limit. No automatic retry, new candidate or full supplier claim.", + "evidence": "evidence/SCIENTIFIC-RECEIPT-EXTRACT.json, evidence/PORTABLE-V2-OUTCOME.json and evidence/PORTABLE-V2-POSTRUN-REVIEW.json record the fixed results, exact controls and limited review.", + "author": "Clear1nsight", + "ai_assistance": "Prepared with substantial OpenAI Codex assistance, including separate preparation and static review agents. AI checks are not independent human or formal acceptance.", + "outcome_detail": "Historical local fixed audit plus direct portable normal/explicit-O and all12 synthetic controls passed, with limited static postrun review. No new kappa or full native/caller/price acceptance.", + "open_questions": [ + { + "question": "Does the emitted5713 artifact implement exactly the credited edit under complete native/caller contracts?", + "why_it_matters": "This package certifies fixed original-source and prescribed715 contact premises, not successor equality or full admission.", + "first_step": "In a separate scope, bind exact emitted-word and native/caller receipts before any broader acceptance claim.", + "blocked_by": "Outside this focused audit; exact provider/phase/all-width, endpoint/erasure and full caller evidence remain distinct." + }, + { + "question": "Are the final committed source/history metadata, generic replay selection and public rendering correct?", + "why_it_matters": "Direct qualification does not establish publication/CI/export custody.", + "first_step": "Root reviews final bytes and real publication identity, then chooses applicable bounded metadata/CI/render checks.", + "blocked_by": "Implementation commit and PR/CI identities have not yet been supplied; no automated action is granted by this note." + } + ] +} diff --git a/research/p104-temporal-fixed-independent-audit/VERIFY.json b/research/p104-temporal-fixed-independent-audit/VERIFY.json new file mode 100644 index 0000000000..cd7aa0ffaf --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/VERIFY.json @@ -0,0 +1,85 @@ +{ + "schema_version": 1, + "status": "ready", + "commands": [ + { + "name": "fixed-normal", + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "{package}/inputs/WORD.json.gz" + ], + "timeout_seconds": 45, + "expected": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "checks": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY; fixed causal and typed-contact scope only, with explicit source custody and normal result envelope." + }, + { + "name": "fixed-explicit-optimized", + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py", + "{package}/inputs/WORD.json.gz" + ], + "timeout_seconds": 45, + "expected": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "checks": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY; fixed causal and typed-contact scope only, with explicit source custody and normal result envelope." + }, + { + "name": "explicit-synthetic-controls", + "argv": [ + "{python}", + "-B", + "{package}/controls.py", + "{package}/inputs/WORD.json.gz" + ], + "timeout_seconds": 60, + "expected": "PASS_EXPLICIT_PORTABLE_CONTROL_SET_ONLY with SYNTHETIC_CONTROL_ONLY labels", + "checks": "PASS_EXPLICIT_PORTABLE_CONTROL_SET_ONLY with SYNTHETIC_CONTROL_ONLY labels; fixed causal and typed-contact scope only, with explicit source custody and normal result envelope." + } + ], + "inputs": [ + "research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz", + "research/p104-temporal-fixed-independent-audit/inputs/LICENSE", + "research/p104-temporal-fixed-independent-audit/inputs/NOTICE", + "research/p104-temporal-fixed-independent-audit/verify.py", + "research/p104-temporal-fixed-independent-audit/CONTROL-FIXTURES.json", + "research/p104-temporal-fixed-independent-audit/evidence/SCIENTIFIC-RECEIPT-EXTRACT.json" + ], + "requirements": [], + "expected_status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "controls": "All12 explicit synthetic controls passed in the recorded normal controls phase. Controls under-O were not separately executed; no assert-only acceptance is used.", + "root_resource_ceiling": { + "child_seconds": 60, + "memory_mib": 512, + "shared_aggregate_seconds": 150, + "proposed_phase_caps_seconds": [ + 45, + 45, + 60 + ], + "phase_cap_sum_seconds": 150, + "root_caps_remaining_actual_budget": true, + "stop_on_failure": true, + "automatic_retries": 0 + }, + "scientific_scope": "Narrow source-premise/contact certificate, not emitted5713/native/full-price acceptance", + "implementation_state": "QUALIFIED_DIRECT_NORMAL_EXPLICIT_O_AND_12_CONTROLS", + "local_qualification": "Recorded direct phases passed. This ready declaration is not a generic launcher/export/hosted pass; those remain NOT RUN.", + "export_qualification": "NOT RUN; no fourth phase occurred. Any export/replay needs a separate applicable root decision.", + "qualification": { + "status": "PASS_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "postrun_review_sha256": "5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce", + "root_acceptance_metadata_sha256": "84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666", + "normal_and_explicit_O_passed": true, + "synthetic_controls_passed": 12, + "full_scientific_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "generic_metadata_validation": "NOT_RUN", + "export": "NOT_RUN", + "hosted_replay": "NOT_RUN" + }, + "python": "3.12" +} diff --git a/research/p104-temporal-fixed-independent-audit/controls.py b/research/p104-temporal-fixed-independent-audit/controls.py new file mode 100644 index 0000000000..31cc4246c5 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/controls.py @@ -0,0 +1,462 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""IMPLEMENTED, UNRUN: explicit in-memory controls for the fixed portable audit. + +Every control result is SYNTHETIC_CONTROL_ONLY. Original source files are never +written. The original fixed input must pass authenticated normal verification +before any derivative is made. Raw verifier bytes are authenticated and compiled; +no import of verify.py or its cached bytecode occurs. No assert-based acceptance. +""" +import contextlib +import copy +import hashlib +import io +import json +import math +from pathlib import Path +import re +import sys +import time +import types + +HERE = Path(__file__).resolve().parent +LABEL = 'SYNTHETIC_CONTROL_ONLY' +VERIFY_SHA256 = 'bce6cdf82cb1492d209c241670df894548a485b89622a39851f26352f61e999b' +FIXTURES_SHA256 = '494736481a4722b76ca94584df74fec1f58d54d62abe86a4b11ec89da5421c5b' +REFERENCE_SHA256 = '1fe52b928ebd27e61aad9384785d163abe765a98aa6e84b4f6901a0384141e35' +PROJECTION_SHA256 = '8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c' +PASS_STATUS = 'PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY' +EXCLUDED_PROJECTION_FIELDS = {'binding', 'source', 'elapsed_seconds_internal', + 'runtime_memory_and_termination_evidence'} +MAX_FILE_BYTES = 1048576 +MAX_METADATA_TOTAL = 8388608 +CHILD_SECONDS = 60 +START = time.monotonic() +METADATA_BYTES = 0 +EXPECTED_MUTANT_IDS = ['HIDDEN715_READ', 'CHANGED747_VALUE_WRITE', 'CHANGED747_LIFETIME', + 'PROSPECTIVE_ONLY_715_CONTACT', 'UNKNOWN_SEMANTICS', + 'NONBLOCKING11202_WRITE', 'MINIMAL340_INTERVAL_WRITE'] + + +class ControlFailure(Exception): + def __init__(self, check, detail=None): + self.check, self.detail = check, detail + + +class ControlsIncomplete(Exception): + pass + + +def require(ok, check, detail=None): + if not ok: + raise ControlFailure(check, detail) + + +def deadline(): + if time.monotonic() - START >= CHILD_SECONDS: + raise ControlsIncomplete('Control phase deadline; no retries or incomplete pass') + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True).encode('ascii') + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def read_pinned(path, expected): + global METADATA_BYTES + with path.open('rb') as stream: + raw = stream.read(MAX_FILE_BYTES + 1) + require(len(raw) <= MAX_FILE_BYTES, 'CONTROL_METADATA_FILE_CAP', path.name) + METADATA_BYTES += len(raw) + require(METADATA_BYTES <= MAX_METADATA_TOTAL, 'CONTROL_METADATA_TOTAL_CAP') + require(sha(raw) == expected, 'CONTROL_METADATA_SHA256', path.name) + return raw + + +def unique_pairs(items): + out = {} + for key, value in items: + require(key not in out, 'ENVELOPE_DUPLICATE_KEY') + out[key] = value + return out + + +def output_preflight(text): + """Before JSON allocation: source-sized caps, permitting finite elapsed floats. + + The scientific verifier's integer-only input preflight is unchanged. This + separate envelope lexer handles its bounded runtime presentation fields. + """ + require(type(text) is str and len(text.encode('utf-8')) <= MAX_FILE_BYTES, + 'ENVELOPE_BYTE_CAP') + n, i, depth, nodes = len(text), 0, 0, 0 + while i < n: + if i % 16384 == 0: + deadline() + ch = text[i] + if ch.isspace() or ch in ',:': + i += 1 + continue + if ch in ']}': + depth -= 1 + require(depth >= 0, 'ENVELOPE_UNBALANCED_JSON') + i += 1 + continue + nodes += 1 + require(nodes <= 500000, 'ENVELOPE_NODE_CAP') + if ch in '[{': + depth += 1 + require(depth <= 16, 'ENVELOPE_DEPTH_CAP') + i += 1 + elif ch == '"': + i += 1 + length = 0 + while i < n and text[i] != '"': + require(ord(text[i]) >= 32, 'ENVELOPE_STRING_CONTROL') + if text[i] == '\\': + i += 1 + require(i < n, 'ENVELOPE_INCOMPLETE_ESCAPE') + if text[i] == 'u': + require(i+4 < n and all(c in '0123456789abcdefABCDEF' for c in text[i+1:i+5]), + 'ENVELOPE_UNICODE_ESCAPE') + i += 4 + else: + require(text[i] in '"\\/bfnrt', 'ENVELOPE_ESCAPE') + length += 1 + require(length <= 256, 'ENVELOPE_STRING_CAP') + i += 1 + require(i < n, 'ENVELOPE_UNTERMINATED_STRING') + i += 1 + elif ch in '-0123456789': + start = i + while i < n and text[i] not in ' \t\r\n,]}:': + i += 1 + require(i-start <= 64, 'ENVELOPE_NUMBER_CAP') + token = text[start:i] + require(re.fullmatch(r'-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?', token) is not None, + 'ENVELOPE_NUMBER_GRAMMAR') + elif text.startswith('true', i): + i += 4 + elif text.startswith('false', i): + i += 5 + elif text.startswith('null', i): + i += 4 + else: + raise ControlFailure('ENVELOPE_UNKNOWN_TOKEN') + require(depth == 0, 'ENVELOPE_UNBALANCED_JSON') + + +def finite_float(token): + require(len(token) <= 64, 'ENVELOPE_FLOAT_CAP') + value = float(token) + require(math.isfinite(value), 'ENVELOPE_NONFINITE_FLOAT') + return value + + +def bounded_integer(token): + require(len(token.lstrip('-')) <= 24, 'ENVELOPE_INTEGER_CAP') + return int(token) + + +def reject_constant(token): + raise ControlFailure('ENVELOPE_NONFINITE_CONSTANT', token) + + +def decode_output(text): + output_preflight(text) + return json.loads(text, object_pairs_hook=unique_pairs, parse_float=finite_float, + parse_int=bounded_integer, parse_constant=reject_constant) + + +def projection(receipt): + return {key: value for key, value in receipt.items() if key not in EXCLUDED_PROJECTION_FIELDS} + + +def validate_envelope(text, exit_code, expected_status, expected_projection=None): + envelope = decode_output(text) + require(type(envelope) is dict and set(envelope) == {'receipt', 'receipt_sha256'}, 'ENVELOPE_SHAPE') + receipt = envelope['receipt'] + require(type(receipt) is dict and sha(canonical(receipt)) == envelope['receipt_sha256'], + 'RECEIPT_DIGEST_MISMATCH') + if receipt.get('status') == 'INCOMPLETE' or exit_code == 4: + raise ControlsIncomplete('Verifier returned incomplete; no control acceptance') + require(receipt.get('status') == expected_status, 'UNEXPECTED_VERIFIER_STATUS', receipt.get('status')) + expected_exit = 0 if expected_status == PASS_STATUS else 3 + require(exit_code == expected_exit, 'UNEXPECTED_VERIFIER_EXIT', exit_code) + if expected_projection is not None: + require(projection(receipt) == expected_projection, 'FULL_SCIENTIFIC_PROJECTION_MISMATCH') + return envelope + + +class CappedCapture(io.StringIO): + def write(self, text): + require(self.tell() + len(text) <= MAX_FILE_BYTES, 'CAPTURE_BYTE_CAP') + return super().write(text) + + +def invoke_main(module, source_path): + prior = sys.argv + buffer = CappedCapture() + try: + sys.argv = ['verify.py', str(source_path)] + with contextlib.redirect_stdout(buffer): + exit_code = module.main() + finally: + sys.argv = prior + return buffer.getvalue(), exit_code + + +def load_verifier(): + raw = read_pinned(HERE/'verify.py', VERIFY_SHA256) + module = types.ModuleType('authenticated_fixed_verifier_under_controls') + module.__file__ = str(HERE/'verify.py') + module.__package__ = None + # Compile exactly authenticated source bytes; never import a cached verify.pyc. + code = compile(raw, 'authenticated-portable-verify.py', 'exec') + exec(code, module.__dict__) + return module + + +def labelled(test_id, **facts): + return {'label': LABEL, 'id': test_id, 'control_status': 'PASS', **facts} + + +def prerequisites(fixture, baseline): + kind = fixture['prerequisite'] + if kind == 'CUT823_715_FRAME3': + require(baseline['cuts']['823']['state']['715']['frame'] == 3, 'PREREQ_CUT823') + elif kind == '747_LIVE_598': + item = next(x for x in baseline['ledgers'] if x['index'] == 13574) + require(item['transition']['tracked_frames_before']['747'] == 598 + and baseline['747_read_lifetimes']['13572']['live'] is True, 'PREREQ747') + elif kind == '715_AND747_LIVE_598_AFTER13578': + state = baseline['anchors']['13578']['state_after'] + require(state['715']['frame'] == state['747']['frame'] == 598 and state['747']['live'] is True, + 'PREREQ_PROSPECTIVE_ONLY_CONTACT') + elif kind == '340_FRAME396_AT11202': + require(baseline['anchors']['11202']['state_before']['340']['frame'] == 396, + 'PREREQ_NONBLOCKING340') + elif kind == '340_AND525_FRAME396_AFTER14654': + state = baseline['anchors']['14654']['state_after'] + require(state['340']['frame'] == state['525']['frame'] == 396, 'PREREQ_MINIMAL340') + else: + raise ControlFailure('UNKNOWN_FIXTURE_PREREQUISITE') + + +def event_control(module, original, fixture, baseline): + deadline() + prerequisites(fixture, baseline) + index = fixture['index'] + require(original['program'][index] == fixture['original_expected'], 'FIXTURE_ORIGINAL_EVENT_MISMATCH', index) + derivative = dict(original) + derivative['program'] = list(original['program']) + derivative['program'][index] = list(fixture['replacement']) + try: + result = module.Audit(derivative).scan() + except module.Falsified as error: + require(fixture['expected_kind'] == 'fixed_premise', 'WRONG_CONTROL_EXCEPTION_KIND') + require(error.predicate == fixture['expected_predicate'] and error.index == index, + 'WRONG_FIXED_PREDICATE_OR_SITE', {'predicate':error.predicate,'index':error.index}) + if 'expected_frame' in fixture: + require(error.expected == fixture['expected_frame'] and error.actual == fixture['expected_actual'], + 'PROSPECTIVE_CONTROL_DID_NOT_REACH_EXPECTED_STATE') + return labelled(fixture['id'], data_derivative=True, event_index=index, + expected_predicate=error.predicate, actual_outcome='FIXED_SUFFICIENT_PREMISE_NOT_ESTABLISHED', + intended_gate_reached=True, no_identity_counterexample_claim=True) + except module.Unresolved as error: + require(fixture['expected_kind'] == 'unresolved', 'UNEXPECTED_BINDING_FAILURE', error.reason) + require(error.reason == fixture['expected_reason'] and error.index == index, + 'WRONG_UNRESOLVED_REASON_OR_SITE') + return labelled(fixture['id'], data_derivative=True, event_index=index, + actual_outcome='BINDING_UNRESOLVED', scientific_falsifier=False) + except module.Incomplete as error: + raise ControlsIncomplete(str(error)) + require(fixture['expected_kind'] == 'pass' and fixture['id'] == 'NONBLOCKING11202_WRITE', + 'UNEXPECTED_MUTANT_ACCEPTANCE') + require(result.get('status') == PASS_STATUS and result['coverage']['complete_program_scan'] is True, + 'NONBLOCKING_CONTROL_NOT_COMPLETE') + require(result['predicates'] == baseline['predicates'] and all(v == 'PASS' for v in result['predicates'].values()), + 'NONBLOCKING_CONTROL_CHANGED_REQUIRED_PREMISES') + require(result['anchors']['11202']['event'] == fixture['replacement'] + and result['write_census']['340'] == [11202] + and result['340_stronger_provenance_observation']['blocking'] is False, + 'NONBLOCKING_CONTROL_NOT_RECORDED_AS_PROVENANCE') + return labelled(fixture['id'], data_derivative=True, actual_outcome=PASS_STATUS, + required_minimal_interval='[14654,14983)', historical_projection_comparison='NOT_APPLICABLE_TO_MUTANT') + + +class MemoryInput: + name = 'WORD.json.gz' + + def __init__(self, raw): + self.raw = raw + + def open(self, mode): + require(mode == 'rb', 'SYNTHETIC_INPUT_OPEN_MODE') + return io.BytesIO(self.raw) + + +def source_mismatch_control(module, source_path, original_raw): + derivative = bytearray(original_raw) + derivative[0] ^= 1 + mutated = bytes(derivative) + authentic = module.authenticate_blob + decode, gzip_open = module.decode, module.gzip.GzipFile + counts = {'decode':0,'gzip':0} + + def substituted_input(path, pin): + if pin == module.SOURCE: + return authentic(MemoryInput(mutated), pin) + return authentic(path, pin) + + def forbidden_decode(*args, **kwargs): + counts['decode'] += 1 + raise ControlFailure('MISMATCH_REACHED_DECODE') + + def forbidden_gzip(*args, **kwargs): + counts['gzip'] += 1 + raise ControlFailure('MISMATCH_REACHED_GZIP') + + try: + module.authenticate_blob = substituted_input + module.decode = forbidden_decode + module.gzip.GzipFile = forbidden_gzip + text, exit_code = invoke_main(module, source_path) + finally: + module.authenticate_blob = authentic + module.decode = decode + module.gzip.GzipFile = gzip_open + envelope = validate_envelope(text, exit_code, 'BINDING_UNRESOLVED') + require(envelope['receipt'].get('reason') == 'Pinned input length/SHA256 mismatch: WORD.json.gz', + 'SOURCE_MISMATCH_WRONG_REJECTION') + require(counts == {'decode':0,'gzip':0}, 'SOURCE_MISMATCH_NOT_PREDECODE') + return labelled('SOURCE_BYTE_MISMATCH_PREDECODE', data_derivative=True, + actual_outcome='BINDING_UNRESOLVED', decoder_calls=counts, + synthetic_compressed_sha256=sha(mutated), original_file_written=False) + + +def envelope_controls(baseline_envelope, expected_projection): + cases = [] + bad_hash = copy.deepcopy(baseline_envelope) + bad_hash['receipt_sha256'] = '0'*64 + cases.append(('BAD_ENVELOPE_HASH',bad_hash,'RECEIPT_DIGEST_MISMATCH')) + bad_status = copy.deepcopy(baseline_envelope) + bad_status['receipt']['status'] = 'PASS_UNSCOPED' + bad_status['receipt_sha256'] = sha(canonical(bad_status['receipt'])) + cases.append(('UNSCOPED_PASS_STATUS',bad_status,'UNEXPECTED_VERIFIER_STATUS')) + missing = copy.deepcopy(baseline_envelope) + del missing['receipt']['cuts'] + missing['receipt_sha256'] = sha(canonical(missing['receipt'])) + cases.append(('MISSING_SCIENTIFIC_PROJECTION_FIELD',missing,'FULL_SCIENTIFIC_PROJECTION_MISMATCH')) + out = [] + for test_id, envelope, expected in cases: + try: + validate_envelope(canonical(envelope).decode('ascii'), 0, PASS_STATUS, expected_projection) + except ControlFailure as error: + require(error.check == expected, 'WRONG_ENVELOPE_CONTROL_REJECTION', error.check) + out.append(labelled(test_id, data_derivative=False, envelope_derivative=True, + intended_validator_rejection=expected)) + else: + raise ControlFailure('BAD_ENVELOPE_ACCEPTED', test_id) + return out + + +def run(): + require(len(sys.argv) == 2, 'EXACTLY_ONE_FIXED_SOURCE_DATA_PATH_REQUIRED') + source_path = Path(sys.argv[1]) + require(source_path.name == 'WORD.json.gz', 'EXACT_SOURCE_BASENAME_REQUIRED') + module = load_verifier() + fixture_raw = read_pinned(HERE/'CONTROL-FIXTURES.json', FIXTURES_SHA256) + reference_raw = read_pinned(HERE/'evidence/SCIENTIFIC-RECEIPT-EXTRACT.json', REFERENCE_SHA256) + fixtures, reference = module.decode(fixture_raw), module.decode(reference_raw) + require(fixtures['schema'] == 'portable5713-explicit-synthetic-control-fixtures/v2' + and fixtures['label'] == LABEL and fixtures['verifier_sha256'] == VERIFY_SHA256, + 'FIXTURE_HEADER_MISMATCH') + require([f['id'] for f in fixtures['event_mutants']] == EXPECTED_MUTANT_IDS, 'FIXTURE_SET_MISMATCH') + expected_projection = reference['scientific_data'] + require(sha(canonical(expected_projection)) == PROJECTION_SHA256, 'REFERENCE_FULL_PROJECTION_HASH') + captured = {} + authentic_decode = module.decode + + def capture_original(raw): + word = authentic_decode(raw) + require(not captured, 'MULTIPLE_ORIGINAL_WORD_DECODES') + captured['word'] = word + return word + + try: + module.decode = capture_original + text, exit_code = invoke_main(module, source_path) + finally: + module.decode = authentic_decode + baseline_envelope = validate_envelope(text, exit_code, PASS_STATUS, expected_projection) + baseline = baseline_envelope['receipt'] + require(baseline['binding']['checker_sha256'] == VERIFY_SHA256 and set(captured) == {'word'}, + 'BASELINE_AUTHENTICATED_CODE_OR_CAPTURE_MISSING') + # Normal run authenticated all original bytes before capture; no derivative + # was constructed earlier. Authenticate compressed bytes again for byte test. + original = captured['word'] + original_digest = sha(canonical(original)) + original_raw = module.authenticate_blob(source_path, module.SOURCE) + results = [labelled('ORIGINAL_BASELINE_ENVELOPE_AND_FULL_PROJECTION', data_derivative=False, + context='Original fixed input reference inside synthetic-control harness', + actual_outcome=PASS_STATUS, full_scientific_projection_sha256=PROJECTION_SHA256)] + results.append(source_mismatch_control(module, source_path, original_raw)) + for fixture in fixtures['event_mutants']: + deadline() + results.append(event_control(module, original, fixture, baseline)) + results.extend(envelope_controls(baseline_envelope, expected_projection)) + require(len(results) == 12, 'INCOMPLETE_CONTROL_SET') + require(sha(canonical(original)) == original_digest and sha(original_raw) == module.SOURCE['sha256'], + 'ORIGINAL_IN_MEMORY_INPUT_CHANGED') + deadline() + return {'status':'PASS_EXPLICIT_PORTABLE_CONTROL_SET_ONLY','label':LABEL, + 'controls':results,'control_count':len(results),'verifier_sha256':VERIFY_SHA256, + 'fixtures_sha256':FIXTURES_SHA256,'reference_sha256':REFERENCE_SHA256, + 'full_scientific_projection_sha256':PROJECTION_SHA256, + 'source':module.SOURCE,'original_source_authenticated_before_derivatives':True, + 'original_file_written':False,'original_in_memory_data_unchanged':True, + 'raw_verifier_compiled_without_cached_pyc':True,'assert_acceptance_used':False, + 'no_actual_source_counterexample_or_new_kappa':True} + + +def main(): + try: + result = run() + code = 0 + except (ControlsIncomplete, MemoryError, TimeoutError, KeyboardInterrupt) as error: + result = {'status':'INCOMPLETE','label':LABEL,'control_set_complete':False, + 'reason':type(error).__name__+': resource/interruption; no acceptance'} + code = 4 + except ControlFailure as error: + result = {'status':'CONTROL_FAILURE','label':LABEL,'control_set_complete':False, + 'check':error.check,'detail':error.detail} + code = 2 + except Exception as error: + result = {'status':'BINDING_UNRESOLVED','label':LABEL,'control_set_complete':False, + 'reason':type(error).__name__+': control input/runtime failure; private paths omitted'} + code = 3 + result['elapsed_seconds_internal'] = time.monotonic()-START + try: + body = canonical(result) + if len(body)+256 > MAX_FILE_BYTES: + result = {'status':'BINDING_UNRESOLVED','label':LABEL,'reason':'CONTROL_RECEIPT_CAP', + 'control_set_complete':False} + body = canonical(result) + code = 3 + envelope = canonical({'receipt':result,'receipt_sha256':sha(body)}) + except MemoryError: + result = {'status':'INCOMPLETE','label':LABEL,'reason':'Control receipt allocation failed', + 'control_set_complete':False} + body = canonical(result) + envelope = canonical({'receipt':result,'receipt_sha256':sha(body)}) + code = 4 + print(envelope.decode('ascii')) + return code + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-OUTCOME-REVIEW.json b/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-OUTCOME-REVIEW.json new file mode 100644 index 0000000000..db5d5c6a9a --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-OUTCOME-REVIEW.json @@ -0,0 +1,96 @@ +{ + "schema": "fixed5713-static-outcome-review/v1", + "decision": "ACCEPT_FIXED_CAUSAL_TYPED_SOURCE_RECEIPT_ONLY", + "object_id": "pr5713-fixed-causal-typed715-on-original5684-v1", + "recorded_status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "normal_valid_receipt": true, + "full_registered_binding_matches": true, + "receipt_body_sha256": "5a37ef6cc04271a370bd37c3a6719dedb049d2f570a51e699aa3025dbbd1def0", + "stdout_sha256": "ef45148b8ee100c237432d730c6384e74f436c4e99ccf0195dbd177af50cb02e", + "stdout_bytes": 25813, + "guard_receipt_sha256": "8d270f7750217975184c9b94b681acc181819ada301895f46f86c35db936ccf9", + "guard_receipt_bytes": 795, + "binding": { + "checker_sha256": "e2c42f6f5db304067661ec3d54e6c94ebf7bc2fa82d4c8ded7f714cdcb461aa3", + "request_core_sha256": "0af43504a8e2c8ca86d881750d3422c53c13effea7541cad87ecf941b3aae215", + "registered_request_sha256": "45f7240b402afee28b39e08ce08a08e72d8fd7e08aa607aa055e6dee3ea57881", + "independent_review_sha256": "bafbfccbc222ca8403dbcc1623d13f666c0fa22bc51938e62ccbcfbff9211f3e", + "root_registration_sha256": "764c707d877ea02b08a1aa10fe455136a24d4eb44327ff39d10ae7f8eb038f0a", + "source_head": "d0f6fa2555410a1e23fe4191424c2097ab3d5d97", + "source_sha256": "d6db1d0d97b13ea483a462c65437664d15d34dec56c3682cf6e1de31266ec6c2", + "source_git_blob": "f3fb0e2144ec8a5c3407e4eaa6528bb3436ba573", + "source_compressed_bytes": 106613, + "decoded_sha256_as_recorded_by_checker": "3ae490190103898b9a20d32a4be8865b1214dd9a84a154e509022dc698e3f8fc" + }, + "recorded_guard": { + "exit_code": 0, + "termination": null, + "elapsed_seconds": 0.5050126829883084, + "sampled_peak_descendant_rss_bytes": 26398720, + "rss_samples": 5, + "memory_limit_mib": 512, + "timeout_seconds": 60, + "sampled_rss_is_exact_peak": false, + "command_matches_registration": true, + "declared_request_environment_matches_registration": true, + "guard_receipt_separately_records_environment": false + }, + "accepted_scope": { + "complete_program_scan": true, + "event_count": 25451, + "scoped_ledger_entries": 23, + "named_predicates_pass": 10, + "causal_interval": "[823,14983)", + "cuts": "Immediately before original823 and14983", + "write712": [13572], + "write525": [13737,14654], + "write340_in_provenance_interval": [11202], + "required340_interval": "[14654,14983)", + "required340_interval_has_write": false, + "stronger11202_no_write_claim": false, + "stronger_claim_blocking": false, + "747_same_live_birth": true, + "747_birth_token": 1, + "747_birth_event": 13565, + "747_both_read_frames": 598, + "prospective715_all_original_contacts": 16, + "skipped715_contacts": [13577,13578], + "retained715_contacts_checked": 14, + "insertion_contacts_checked": 4, + "retarget14982": "715:3->396", + "retained_destination_ADD17439_checked": true + }, + "receipt_policy": { + "emergency_or_invalid_receipt_used": false, + "external_custody_repair_used": false, + "posthoc_patched_receipt_used": false + }, + "review_method": { + "static_record_and_metadata_only": true, + "canonical_body_hash_and_core_recomputed": true, + "word_read_or_decoded": false, + "checker_imported_or_executed": false, + "controls_executed": false, + "independent_second_scientific_replay": false, + "new_source_queries": false, + "frozen_run_and_binding_files_unchanged_before_after": true + }, + "public_verification_value": "Independent fixed-source event, observer, owned-lifetime and prospective715 contact receipt for the credited temporal identity", + "portable_publication_gaps": [ + "Portable source-relative registered harness and reproducible custody", + "Separately authorized meaningful negative fixture controls; all existing designs UNRUN", + "Explicit native and complete-price limitations in any later report" + ], + "no_automatic_pr_or_publication": true, + "not_established": [ + "Emitted5713 WORD or complete event-delta equality", + "Exact3-to396 native provider, absolute phase or all-width correctness", + "Full scalar endpoint validation or owned-zero erasure values", + "Physical caller, complete invoice and54+4 outer predicates", + "New identity, alleged105-coefficient bug, novelty clearance or new kappa", + ".00311 fulfillment" + ], + "framework_assumptions_remain": 5, + "credit": "Ali Romman PR5713 temporal identity and construction; inherited PR5684/native/helper/caller/compiler lineage retained", + "new_kappa": null +} diff --git a/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-OUTCOME-REVIEW.md b/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-OUTCOME-REVIEW.md new file mode 100644 index 0000000000..bb54b63ac7 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-OUTCOME-REVIEW.md @@ -0,0 +1,23 @@ +# Static outcome review: fixed PR5713 source audit + +**ACCEPT_FIXED_CAUSAL_TYPED_SOURCE_RECEIPT_ONLY.** The single registered run produced a normal valid receipt with status `PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY`. Its recorded source-event, owned-lifetime and prescribed715 contact certificate is accepted within the independently reviewed checker scope. This reviewer checked recorded output and metadata only; no WORD reread, decode, checker invocation, controls or second scientific replay occurred. + +The stdout SHA256 is ef45148b8ee100c237432d730c6384e74f436c4e99ccf0195dbd177af50cb02e, length25813. Its independently recomputed canonical receipt-body SHA256 is 5a37ef6cc04271a370bd37c3a6719dedb049d2f570a51e699aa3025dbbd1def0, matching the normal envelope. The guard RECEIPT.json SHA256 is 8d270f7750217975184c9b94b681acc181819ada301895f46f86c35db936ccf9, length795. These run files and the bound metadata were rechecked unchanged after writing this review. + +The complete binding matches the actual local metadata: checker e2c42f6f5db304067661ec3d54e6c94ebf7bc2fa82d4c8ded7f714cdcb461aa3; request core0af43504a8e2c8ca86d881750d3422c53c13effea7541cad87ecf941b3aae215; registered request45f7240b402afee28b39e08ce08a08e72d8fd7e08aa607aa055e6dee3ea57881; independent review bafbfccbc222ca8403dbcc1623d13f666c0fa22bc51938e62ccbcfbff9211f3e; root registration764c707d877ea02b08a1aa10fe455136a24d4eb44327ff39d10ae7f8eb038f0a. The copied review equals this reviewer's frozen preparation review. The registered request core was recomputed; registration added no core mutation. Source metadata consistently binds original PR5684 head d0f6fa2555410a1e23fe4191424c2097ab3d5d97, compressed SHA256 d6db1d0d97b13ea483a462c65437664d15d34dec56c3682cf6e1de31266ec6c2, Git blob f3fb0e2144ec8a5c3407e4eaa6528bb3436ba573 and106613 compressed bytes. The decoded SHA256 3ae490190103898b9a20d32a4be8865b1214dd9a84a154e509022dc698e3f8fc is recorded by the authorized checker; this reviewer did not independently decode or authenticate decoded bytes. + +The guard records the registered command, exit0, no termination, elapsed0.5050126829883084 seconds, five RSS samples with maximum26398720 bytes, timeout60seconds and memory limit512MiB. Sampled RSS is not an exact peak-memory measurement. Request and root registration agree on the declared environment; the guard receipt itself does not separately list the process environment. This is evidence for this fixed run only, not a performance guarantee or authorization to rerun. + +The receipt reports complete EOF grammar coverage of25451 events,23 entries in the exhaustive scoped ledger, and all ten named predicates PASS. The source causal interval is [823,14983), with cuts immediately before the original events. The recorded712 write census is [13572];525 is [13737,14654]. Anchors are consistent with ADD712←747 at13572 in598, ADD715←747 at13578 in598, ADD525←−4·712 at13737 in598, ADD525←340 at14654 in396, and the closing ADD340←−4·715 at14983 in396. The old715 MOVE anchors are3→598 at13577 and598→396 at14982. + +The340 provenance ledger reports the actual event11202 as `[ADD,340,337,"1",396]`; its recorded pre/post chart is396. Thus the stronger no-write assertion on [11202,14983) is false. This was explicitly nonblocking before registration. The necessary sufficient-test condition is no340 write in [14654,14983), and the receipt's complete write census establishes that condition under the reviewed adapter. The clarification is not an identity bug or a post-run boundary repair. + +Both747 reads report the same live birth token1 from event13565, chart598. The intervening scoped contacts13574 and13576 are source reads into713/714, with no747 write. The accepted checker also requires the full owned lifetime grammar to close, but proves no owned erasure value. Logical continuity through native transports remains conditional on the inherited decoded MOVE semantics. + +The original cut823 records715/525/712 all in chart3 and the two early inserted contacts in3. Cut14983 records715/525/340 in396 and the two late inserted contacts in396. The prospective715 frame remains3 through the skipped13577/13578 events, becomes396 at retargeted14982, then127 at retained14988. The ledger covers all16 original715 contacts: the two prescribed skipped records and14 retained contacts, including source reads before/after the interval and the retained destination ADD from role256 into715 with coefficient−1/4 at17439 in127. All four insertion contacts are separately recorded. This is the requested whole-program715 contact projection, not merely a no-observer screen. It neither emits a changed WORD nor independently compares the published successor's complete event sequence. + +There is narrow public verification value: a separately prepared, reviewed scanner has now produced an authenticated fixed-source premise and typed-contact receipt for Ali Romman's credited temporal identity. It adds explicit event indices,747 lifetime continuity, causal write/observer evidence and the prospective destination-contact check to the existing author's rational/dense endpoint claims. It is not a new identity or an alleged105-coefficient gap, and it is not stronger than a complete correct replay in those broader scopes. + +All designed negative controls remain UNRUN. Portable publication would still require a source-relative registered harness/artifact with reproducible custody and separately authorized meaningful fixture controls for changed747, extra712/525 writes, hidden715 reads, retained wrong-chart contacts, unknown semantics/caps and the nonblocking earlier340-write case. The naturally observed11202 write is useful boundary evidence, not an executed synthetic control. These are publication/validation gaps, not grounds to discard this normal positive receipt. No additional run, implementation, source query, PR or publication is authorized by this review. + +The certificate leaves emitted5713 equality, exact3→396 native provider/phase/all-width correctness, full scalar endpoints, owned-zero erasures, physical caller, complete prices and54+4 outer predicates unresolved. The five inherited framework assumptions remain. It establishes no new kappa or .00311 fulfillment and warrants no automatic standalone PR or novelty claim. diff --git a/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-RUN-SUMMARY.json b/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-RUN-SUMMARY.json new file mode 100644 index 0000000000..0f85846339 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/HISTORICAL-RUN-SUMMARY.json @@ -0,0 +1,26 @@ +{ + "schema": "derived-privacy-filtered-historical-run-summary/v1", + "derivation": "DERIVED SUMMARY, NOT ORIGINAL HASHED RAW GUARD. Private command/cwd and original request/registration are not distributed.", + "historical_checker_sha256": "e2c42f6f5db304067661ec3d54e6c94ebf7bc2fa82d4c8ded7f714cdcb461aa3", + "historical_stdout_sha256": "ef45148b8ee100c237432d730c6384e74f436c4e99ccf0195dbd177af50cb02e", + "historical_stdout_bytes": 25813, + "historical_body_sha256": "5a37ef6cc04271a370bd37c3a6719dedb049d2f570a51e699aa3025dbbd1def0", + "historical_raw_guard_sha256": "8d270f7750217975184c9b94b681acc181819ada301895f46f86c35db936ccf9", + "historical_raw_guard_bytes": 795, + "raw_guard_recomputable_from_summary": false, + "recorded_runtime": { + "exit_code": 0, + "termination": null, + "elapsed_seconds": 0.5050126829883084, + "sampled_peak_descendant_rss_bytes": 26398720, + "rss_samples": 5, + "memory_limit_mib": 512, + "timeout_seconds": 60.0, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "log_sha256": "ef45148b8ee100c237432d730c6384e74f436c4e99ccf0195dbd177af50cb02e" + }, + "environment_caveat": "Request/registration declared an environment; the original raw guard does not separately record process environment.", + "sampling_caveat": "Sampled RSS is not an exact peak; this historical run does not predict portable runtime.", + "portable_checker": "NOT_YET_RUN", + "controls": "UNRUN" +} diff --git a/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-OUTCOME.json b/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-OUTCOME.json new file mode 100644 index 0000000000..7f743e8d40 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-OUTCOME.json @@ -0,0 +1,66 @@ +{ + "schema": "root-portable5713-qualification-outcome/v2", + "status": "PASS_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "registration_sha256": "9f49e6ec1f9b5ac80a16e0a225ee469d430ea2082c1fde16e2ce06f8923984ae", + "request_sha256": "9c54d4221faeaee7ecfdb45a17f2b3d640967ffc83ce6a4560e2427af66e3a00", + "request_core_sha256": "f5052389ec648ea57c37f7157b2f9215c9d0cf9c7d312791fdf805915acfc73d", + "review_sha256": "f9577afbc978b09511c8d02f4f4c29bdb5f20604c16f755cc036b8c422af369d", + "prior_related_elapsed_seconds": 0.5050126829883084, + "phases": [ + { + "phase": "direct-normal", + "run_name": "pr5713-portable-v2-normal-20261026", + "actual_cap_seconds": 45, + "registration_commands_exact": true, + "guard_receipt_sha256": "dbf3542a5816661105176e990c86693725e4bd6b3d12f8ef6e1cdb3401fd85ca", + "elapsed_seconds": 0.5035334499843884, + "sampled_peak_descendant_rss_bytes": 26210304, + "scientific_status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "body_sha256": "9ddcd160873b25278be6b06d332af9e458d08a675e4f1384cbce51bc1cd22131", + "stdout_sha256": "3c337411e4f2480c052606e2161ee942b8fa6a7d7273b47563e06cbcc4f9b1a2", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": null, + "normal_envelope_valid": true, + "accepted": true + }, + { + "phase": "direct-explicit-optimized", + "run_name": "pr5713-portable-v2-optimized-20261026", + "actual_cap_seconds": 45, + "registration_commands_exact": true, + "guard_receipt_sha256": "29aa5437a46b98f66bb21599cd5b544e6c41766e7986accb32e4c8878d4824aa", + "elapsed_seconds": 0.7054007019905839, + "sampled_peak_descendant_rss_bytes": 29077504, + "scientific_status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "body_sha256": "c118e66a82d6c3f5ce86c6c5ae9c90af4ea4d36777797256cca7535f44ca1496", + "stdout_sha256": "7a7372bc51fee7f8964b329038c21a30e4cf28ef2dea0066c6ffb001ad5ec212", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": null, + "normal_envelope_valid": true, + "accepted": true + }, + { + "phase": "executable-synthetic-controls", + "run_name": "pr5713-portable-v2-controls-20261026", + "actual_cap_seconds": 60, + "registration_commands_exact": true, + "guard_receipt_sha256": "d030957f2af0c6ee4bee067e2b1258cf76b60c54dc173cd72fb20c879b05c0cf", + "elapsed_seconds": 1.1071028420119546, + "sampled_peak_descendant_rss_bytes": 27848704, + "scientific_status": "PASS_EXPLICIT_PORTABLE_CONTROL_SET_ONLY", + "body_sha256": "aa3564caf30d191833bee3c6a154f4842467844dad40884060259cfb9d2096a8", + "stdout_sha256": "e89281e210f5e62f93ac00024c29c8a3eb15dee72e91e1d210ab7096a2232152", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": 12, + "normal_envelope_valid": true, + "accepted": true + } + ], + "new_kappa": null, + "no_retry": true, + "export_run": false, + "hosted_replay_run": false, + "aggregate_elapsed_seconds": 2.8210496769752353, + "all_three_phases_accepted": true, + "public_claim": "Fixed causal and typed source/contact audit only; no full native/caller/price admission or new kappa" +} diff --git a/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-POSTRUN-REVIEW.json b/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-POSTRUN-REVIEW.json new file mode 100644 index 0000000000..50680ad4ae --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-POSTRUN-REVIEW.json @@ -0,0 +1,150 @@ +{ + "schema": "portable5713-v2-static-outcome-review/v1", + "decision": "ACCEPT_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "recorded_status": "PASS_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "registration_sha256": "9f49e6ec1f9b5ac80a16e0a225ee469d430ea2082c1fde16e2ce06f8923984ae", + "request_sha256": "9c54d4221faeaee7ecfdb45a17f2b3d640967ffc83ce6a4560e2427af66e3a00", + "request_core_sha256": "f5052389ec648ea57c37f7157b2f9215c9d0cf9c7d312791fdf805915acfc73d", + "independent_preparation_review_sha256": "f9577afbc978b09511c8d02f4f4c29bdb5f20604c16f755cc036b8c422af369d", + "orchestrator_sha256": "775033ad04800ff23a85f1fcb2687ee3b839d61d5e507d66b5922d3a04499261", + "checker_sha256": "bce6cdf82cb1492d209c241670df894548a485b89622a39851f26352f61e999b", + "controls_sha256": "9e9e14f995b47afb13d48a21cdd4c68750ef121a91b00298dd1e5de7a9df697c", + "fixtures_sha256": "494736481a4722b76ca94584df74fec1f58d54d62abe86a4b11ec89da5421c5b", + "full_scientific_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "phases": [ + { + "phase": "direct-normal", + "run_name": "pr5713-portable-v2-normal-20261026", + "actual_cap_seconds": 45, + "registration_commands_exact": true, + "guard_receipt_sha256": "dbf3542a5816661105176e990c86693725e4bd6b3d12f8ef6e1cdb3401fd85ca", + "elapsed_seconds": 0.5035334499843884, + "sampled_peak_descendant_rss_bytes": 26210304, + "scientific_status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "body_sha256": "9ddcd160873b25278be6b06d332af9e458d08a675e4f1384cbce51bc1cd22131", + "stdout_sha256": "3c337411e4f2480c052606e2161ee942b8fa6a7d7273b47563e06cbcc4f9b1a2", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": null, + "normal_envelope_valid": true, + "accepted": true + }, + { + "phase": "direct-explicit-optimized", + "run_name": "pr5713-portable-v2-optimized-20261026", + "actual_cap_seconds": 45, + "registration_commands_exact": true, + "guard_receipt_sha256": "29aa5437a46b98f66bb21599cd5b544e6c41766e7986accb32e4c8878d4824aa", + "elapsed_seconds": 0.7054007019905839, + "sampled_peak_descendant_rss_bytes": 29077504, + "scientific_status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "body_sha256": "c118e66a82d6c3f5ce86c6c5ae9c90af4ea4d36777797256cca7535f44ca1496", + "stdout_sha256": "7a7372bc51fee7f8964b329038c21a30e4cf28ef2dea0066c6ffb001ad5ec212", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": null, + "normal_envelope_valid": true, + "accepted": true + }, + { + "phase": "executable-synthetic-controls", + "run_name": "pr5713-portable-v2-controls-20261026", + "actual_cap_seconds": 60, + "registration_commands_exact": true, + "guard_receipt_sha256": "d030957f2af0c6ee4bee067e2b1258cf76b60c54dc173cd72fb20c879b05c0cf", + "elapsed_seconds": 1.1071028420119546, + "sampled_peak_descendant_rss_bytes": 27848704, + "scientific_status": "PASS_EXPLICIT_PORTABLE_CONTROL_SET_ONLY", + "body_sha256": "aa3564caf30d191833bee3c6a154f4842467844dad40884060259cfb9d2096a8", + "stdout_sha256": "e89281e210f5e62f93ac00024c29c8a3eb15dee72e91e1d210ab7096a2232152", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": 12, + "normal_envelope_valid": true, + "accepted": true + } + ], + "all_normal_envelopes_and_body_hashes_valid": true, + "all_guard_stdout_hashes_and_execution_tuples_match": true, + "all_children_exit_zero_no_termination": true, + "phase_order_matches_exact_registration": true, + "serial_no_retry_supported_by_registered_root_protocol": true, + "prior_related_elapsed_seconds": 0.5050126829883084, + "aggregate_recorded_child_elapsed_seconds_exact_decimal": "2.8210496769752353", + "aggregate_within_150_seconds": true, + "recorded_child_time_is_total_orchestration_walltime": false, + "sampled_rss_is_exact_peak": false, + "normal_optimized_full_projection_equals_all17_historical_fields": true, + "normal_optimized_equality_is_new_scientific_independence": false, + "normal_optimized_raw_stdout_equality_required": false, + "controls": { + "count": 12, + "all_exact_ids_order_and_synthetic_labels": true, + "all_control_statuses_pass": true, + "original_baseline_full_projection_matches": true, + "source_mismatch_decoder_and_gzip_calls_zero": true, + "hidden715_predicate_site": [ + 823, + "715_NO_OUTWARD_OBSERVER_OR_FORBIDDEN_CHANGE" + ], + "747_write_lifetime_predicate_site": [ + 13574, + "747_NO_INTERVENING_WRITE_OR_LIFECYCLE" + ], + "prospective_only_predicate_site": [ + 13579, + "PROSPECTIVE715_RETAINED_SCALAR_CONTACT" + ], + "prospective_expected598_actual3_enforced_by_frozen_harness": true, + "unknown_QUERY_unresolved_at": 823, + "nonblocking11202_coefficient_positive_control_pass": true, + "minimal340_predicate_site": [ + 14655, + "340_MINIMAL_READ_TO_CUT_STABILITY" + ], + "envelope_rejections": [ + "RECEIPT_DIGEST_MISMATCH", + "UNEXPECTED_VERIFIER_STATUS", + "FULL_SCIENTIFIC_PROJECTION_MISMATCH" + ], + "actual_source_counterexample_proved": false, + "original_source_authenticated_before_derivatives_reported": true, + "raw_authenticated_verifier_compile_reported": true, + "no_original_file_write_and_original_memory_unchanged_reported": true + }, + "immutability_evidence": { + "root_orchestrator_checks_all_payload_and_three_inputs_before_and_after_each_phase": true, + "final_accepted_outcome_follows_last_postrun_check": true, + "reviewer_independently_rehashed_checkout_or_WORD": false, + "root_evidence_only_for_target_source_bytes_and_ancestry": true + }, + "scientific_binding": { + "portable_stdout_binds_actual_checker_and_public_source_tuple": true, + "private_request_review_registration_are_separately_root_bound": true, + "emergency_or_repaired_envelope_used": false, + "source_head": "d0f6fa2555410a1e23fe4191424c2097ab3d5d97", + "source_sha256": "d6db1d0d97b13ea483a462c65437664d15d34dec56c3682cf6e1de31266ec6c2", + "source_git_blob": "f3fb0e2144ec8a5c3407e4eaa6528bb3436ba573", + "source_bytes": 106613 + }, + "public_usefulness": "Narrow public evidence update may report exact portable reproduction and meaningful fixed controls; credit and all scientific limits must remain", + "publication_grant": false, + "remaining_publication_gates": [ + "Postrun public evidence/draft revision and exact-byte review", + "Clean committed-head/source-history and portable source bindings", + "Generic metadata/CI and public rendering", + "Any export needs separate applicable authorization/evidence" + ], + "export_run": false, + "hosted_replay_run": false, + "broader_native_caller_price_or_theorem_admission": false, + "framework_assumptions_remain": 5, + "new_kappa": null, + "approximate_kappa_forecast_reviewed_or_admitted": false, + "review_method": { + "static_record_metadata_hash_checks_only": true, + "basic_recorded_elapsed_arithmetic_only": true, + "WORD_or_checkout_read": false, + "code_import_execution_rerun_controls": false, + "source_query_Git_API_export_scientific_engine": false, + "frozen_records_unchanged_before_after": true + } +} diff --git a/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-POSTRUN-REVIEW.md b/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-POSTRUN-REVIEW.md new file mode 100644 index 0000000000..056eeb6e9e --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-POSTRUN-REVIEW.md @@ -0,0 +1,38 @@ +# Static outcome review: portable PR5713 V2 qualification + +**ACCEPT_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY.** The recorded normal, explicit-O and synthetic-control phases meet the frozen V2 qualification contract. This is a static review of root's execution evidence, not a further replay, publication grant or broader scientific admission. The approximate-kappa task is outside this review and no forecast inputs were used. + +OUTCOME-V2.json independently hashes to7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8. Root registration hashes to9f49e6ec1f9b5ac80a16e0a225ee469d430ea2082c1fde16e2ce06f8923984ae and binds the accepted V2 review f9577afbc978b09511c8d02f4f4c29bdb5f20604c16f755cc036b8c422af369d, request9c54d4221faeaee7ecfdb45a17f2b3d640967ffc83ce6a4560e2427af66e3a00 and coref5052389ec648ea57c37f7157b2f9215c9d0cf9c7d312791fdf805915acfc73d. The canonical core, exact command/cwd arrays, review and root-static/orchestration hashes match the recorded metadata. Registration's source/code tuple remains verifybce6cdf8, controls9e9e14f9 and fixtures49473648, with complete hashes in REVIEW.json and the frozen preparation review. + +Each raw stdout is a normal two-field envelope with an independently recomputed canonical receipt-body SHA256. Raw stdout hashes match their guards and outcome entries; each guard hash matches the outcome. All three children exited0 without termination, and their actual commands/cwd/caps match the registration in the declared order: + +| Phase | Elapsed seconds | Sampled RSS bytes | Samples | Cap seconds | +| --- | ---: | ---: | ---: | ---: | +| Normal | 0.5035334499843884 | 26210304 | 5 | 45 | +| Explicit-O | 0.7054007019905839 | 29077504 | 7 | 45 | +| Synthetic controls | 1.1071028420119546 | 27848704 | 11 | 60 | + +All guards record512MiB limits. Exact decimal addition of these recorded child times and the earlier0.5050126829883084-second source run gives2.8210496769752353seconds, agreeing with root's aggregate and remaining below150seconds. This is recorded child-time accounting, not a measurement of the entire orchestration's wall time. Sampled RSS is not an exact peak-memory measurement or a future runtime guarantee. + +The root orchestration text hashes to775033ad04800ff23a85f1fcb2687ee3b839d61d5e507d66b5922d3a04499261, matching registration. It uses a blocking serial loop, checks the exact commands, caps each phase by the actual remaining shared budget and stops on any failure; its one-shot outcome guard forbids automatic retry. The guard-launch stdout reproduces each corresponding guard receipt and launch stderr is empty. The orchestration records hash/length checks of the entire declared public payload and all three immutable inputs before, between and after the phases. A final accepted outcome is reached only after the last postrun check. This supplies root's before/after immutability evidence. This reviewer did not reread or hash the checkout, input WORD or target code; no independent checkout/remote verification is implied. Actual environment setup is supported by root's registered orchestration, not a separately sampled environment field in the child guard receipts. + +Normal and explicit-O outputs each bind actual verify SHA256bce6cdf82cb1492d209c241670df894548a485b89622a39851f26352f61e999b and the exact public source tuple: original head d0f6fa2555410a1e23fe4191424c2097ab3d5d97, compressed SHA256d6db1d0d97b13ea483a462c65437664d15d34dec56c3682cf6e1de31266ec6c2,106613bytes and Git blob f3fb0e2144ec8a5c3407e4eaa6528bb3436ba573. The retained input ancestry/copy evidence is root metadata, not a new check here. Private request/review/registration hashes are correctly bound by root's custody layer and are not falsely described as fields of portable scientific stdout. + +Both direct outputs equal the full17-key historical scientific projection, SHA2568ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c. Equality was checked as complete parsed data, not selected counts or ledgers. Raw body/stdout hashes differ because runtime presentation differs; normal/O agreement is reproduction, not an independent new scientific method. Both preserve25451 events,23 scoped ledger entries, all ten PASS predicates, the actual11202 write as nonblocking provenance, clear required340 interval[14654,14983),747's same live birth13565, and every prescribed prospective715 contact including destination ADD17439. No emergency envelope or repaired scientific binding was used. + +The controls receipt has valid canonical body hash aa3564caf30d191833bee3c6a154f4842467844dad40884060259cfb9d2096a8 and exact status PASS_EXPLICIT_PORTABLE_CONTROL_SET_ONLY. All12 records have the required ids, order, PASS status and SYNTHETIC_CONTROL_ONLY label. It binds the frozen verifier, fixtures and reference hashes; reports authenticated original source before derivatives, raw verifier compilation without cached bytecode, unchanged in-memory original, no source-file writes and no assert-only acceptance. Specific results are: + +- The original baseline reproduces the full projection; changed compressed bytes return unresolved with zero gzip/decode calls. +- Hidden715 observation fails the intended observer predicate at823;747 write and lifetime fixtures fail the intended continuity predicate at13574. +- The13579 destination-contact fixture reaches PROSPECTIVE715_RETAINED_SCALAR_CONTACT. The frozen harness requires expected598/actual3; those states are enforced internally rather than separately printed in its compact control record. +- Unknown QUERY is unresolved at823, not a scientific falsifier. +- The coefficient-only11202 write completes the required PASS conditions as nonblocking provenance. The14655 write fails the required340 interval predicate at that exact site. +- Bad hash, unscoped PASS and missing cuts fail their respective digest, status and full-projection validators. + +These are meaningful executed boundary controls of the reviewed implementation. Synthetic rejection proves no actual source counterexample, identity bug or general impossibility. The positive11202 fixture does not claim equality with the unchanged historical projection. The control harness is one registered phase containing the disclosed original-data baseline and fixed fixtures, not hidden independent phases or a fourth export run. + +The portable qualification and meaningful-control gap identified in V1 is now closed for this exact fixed checkout/code/input version. A narrow public evidence update can report these three real runs, exact receipts, full-projection equality and intended control outcomes while retaining Ali Romman's temporal-identity/construction credit and R22/native/helper/caller/compiler lineage. The public drafts still require an explicit postrun revision and exact publication-byte review; no automatic edit, PR or publication follows. Clean committed-head/source-history checks, generic metadata/CI, public rendering and any Git-free export remain separate root gates. No export or hosted replay was performed by these phases. + +The accepted result remains the independent fixed causal/owned-lifetime/typed715 source certificate. Emitted5713 equality, exact3→396 native provider/absolute phase/all widths, complete scalar/owned-zero endpoints, physical caller, full invoice and54+4 outer predicates are not established. Five framework assumptions remain. This is neither a full theorem validation nor a new kappa or .00311 fulfillment. No approximate forecast or its admission is implied. + +Review operations were limited to text, JSON, canonical hashes, recorded metadata and basic elapsed-time arithmetic. No WORD/checkout read, code import/execution, rerun, controls, source query, API/Git/export, constructor or scientific engine occurred. Reviewed outcome/log/registration records were checked unchanged after writing this review. diff --git a/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-RUNTIME-SUMMARY.json b/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-RUNTIME-SUMMARY.json new file mode 100644 index 0000000000..3a280711c7 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/PORTABLE-V2-RUNTIME-SUMMARY.json @@ -0,0 +1,74 @@ +{ + "schema": "derived-privacy-filtered-portable5713-runtime-summary/v1", + "derivation": "DERIVED SUMMARY OF ROOT OUTCOME AND STATIC POSTRUN REVIEW, NOT ORIGINAL RAW GUARDS OR SCIENTIFIC STDOUT. Original hashes below identify those records; this summary has its own distinct hash.", + "outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "postrun_review_json_sha256": "5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce", + "postrun_review_markdown_sha256": "c7360ce9d1323fc5fa155090594ddeeeeaa01fde4d213289be6b4efe89a433e0", + "root_acceptance_metadata_sha256": "84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666", + "root_acceptance_is_source_science": false, + "status": "PASS_THREE_PHASE_PORTABLE_FIXED_AUDIT_QUALIFICATION_ONLY", + "phases": [ + { + "phase": "direct-normal", + "run_name": "pr5713-portable-v2-normal-20261026", + "actual_cap_seconds": 45, + "registration_commands_exact": true, + "guard_receipt_sha256": "dbf3542a5816661105176e990c86693725e4bd6b3d12f8ef6e1cdb3401fd85ca", + "elapsed_seconds": 0.5035334499843884, + "sampled_peak_descendant_rss_bytes": 26210304, + "scientific_status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "body_sha256": "9ddcd160873b25278be6b06d332af9e458d08a675e4f1384cbce51bc1cd22131", + "stdout_sha256": "3c337411e4f2480c052606e2161ee942b8fa6a7d7273b47563e06cbcc4f9b1a2", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": null, + "normal_envelope_valid": true, + "accepted": true + }, + { + "phase": "direct-explicit-optimized", + "run_name": "pr5713-portable-v2-optimized-20261026", + "actual_cap_seconds": 45, + "registration_commands_exact": true, + "guard_receipt_sha256": "29aa5437a46b98f66bb21599cd5b544e6c41766e7986accb32e4c8878d4824aa", + "elapsed_seconds": 0.7054007019905839, + "sampled_peak_descendant_rss_bytes": 29077504, + "scientific_status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "body_sha256": "c118e66a82d6c3f5ce86c6c5ae9c90af4ea4d36777797256cca7535f44ca1496", + "stdout_sha256": "7a7372bc51fee7f8964b329038c21a30e4cf28ef2dea0066c6ffb001ad5ec212", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": null, + "normal_envelope_valid": true, + "accepted": true + }, + { + "phase": "executable-synthetic-controls", + "run_name": "pr5713-portable-v2-controls-20261026", + "actual_cap_seconds": 60, + "registration_commands_exact": true, + "guard_receipt_sha256": "d030957f2af0c6ee4bee067e2b1258cf76b60c54dc173cd72fb20c879b05c0cf", + "elapsed_seconds": 1.1071028420119546, + "sampled_peak_descendant_rss_bytes": 27848704, + "scientific_status": "PASS_EXPLICIT_PORTABLE_CONTROL_SET_ONLY", + "body_sha256": "aa3564caf30d191833bee3c6a154f4842467844dad40884060259cfb9d2096a8", + "stdout_sha256": "e89281e210f5e62f93ac00024c29c8a3eb15dee72e91e1d210ab7096a2232152", + "full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "control_count": 12, + "normal_envelope_valid": true, + "accepted": true + } + ], + "historical_original_elapsed_seconds": 0.5050126829883084, + "related_recorded_child_elapsed_seconds": 2.8210496769752353, + "related_time_includes_historical_original": true, + "recorded_child_time_is_entire_orchestration_walltime": false, + "sampled_RSS_is_exact_peak": false, + "future_runtime_guaranteed": false, + "all_three_children_exit_zero_no_termination_as_reviewed": true, + "all_12_control_records_passed_as_reviewed": true, + "direct_normal_optimized_full_projection_sha256": "8ad201fe2ce3ebcbb0a081774790fd4511d3ecce1b5b5c1cee3dd9bde033895c", + "generic_metadata_validation": "NOT_RUN", + "export": "NOT_RUN", + "hosted_replay": "NOT_RUN", + "private_command_cwd_request_registration_raw_guard_distributed": false, + "new_kappa": null +} diff --git a/research/p104-temporal-fixed-independent-audit/evidence/ROOT-ACCEPTANCE-SUMMARY.json b/research/p104-temporal-fixed-independent-audit/evidence/ROOT-ACCEPTANCE-SUMMARY.json new file mode 100644 index 0000000000..1154016343 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/ROOT-ACCEPTANCE-SUMMARY.json @@ -0,0 +1,14 @@ +{ + "schema": "derived-root-portable5713-acceptance-metadata/v1", + "derivation": "Privacy-filtered root acceptance metadata; not scientific execution or a new source receipt.", + "original_metadata_sha256": "84d22f2e8f7c5bd3621064793de1dea4ce9a2363d8f1e7aad7a192cec4580666", + "decision": "ACCEPT_INDEPENDENT_STATIC_POSTRUN_REVIEW_LIMITED_SCOPE", + "review_public_file": "PORTABLE-V2-POSTRUN-REVIEW.json", + "review_sha256": "5162081de87c51ebb8dc3a8375513928ad1fb39226c60e7f9dfed78a4477f1ce", + "outcome_public_file": "PORTABLE-V2-OUTCOME.json", + "outcome_sha256": "7298b86c76e400876962c3daf8908a09694bee05501b8b0f62d2fd17d91c8fc8", + "phases_equal": true, + "scope": "Three portable fixed causal/typed qualification phases only; no export/hosted/full native/caller/price/theorem or new kappa", + "no_scientific_rerun": true, + "publication_commit_PR_and_CI": "PENDING_ROOT_DECISIONS" +} diff --git a/research/p104-temporal-fixed-independent-audit/evidence/SCIENTIFIC-RECEIPT-EXTRACT.json b/research/p104-temporal-fixed-independent-audit/evidence/SCIENTIFIC-RECEIPT-EXTRACT.json new file mode 100644 index 0000000000..f2e26c34b9 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/evidence/SCIENTIFIC-RECEIPT-EXTRACT.json @@ -0,0 +1,2413 @@ +{ + "schema": "derived-public-scientific-receipt-extract/v1", + "derivation": "Selected unchanged scientific subtrees of the accepted historical local receipt. Private binding/source-path/runtime wrapper omitted. This is not the original raw stdout/body.", + "original_stdout_sha256": "ef45148b8ee100c237432d730c6384e74f436c4e99ccf0195dbd177af50cb02e", + "original_receipt_body_sha256": "5a37ef6cc04271a370bd37c3a6719dedb049d2f570a51e699aa3025dbbd1def0", + "original_raw_hash_recomputable_from_extract": false, + "scientific_data": { + "status": "PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY", + "object_id": "pr5713-fixed-causal-typed715-on-original5684-v1", + "source_head": "d0f6fa2555410a1e23fe4191424c2097ab3d5d97", + "coverage": { + "340_nonblocking_provenance_interval": "[11202,14983)", + "340_required_interval": "[14654,14983)", + "747_no_write_interval": "[13572,13578)", + "complete_program_scan": true, + "events": 25451, + "interval": "[823,14983)", + "prospective715_contacts": "ALL_RETAINED_FULL_PROGRAM_PLUS_FOUR_INSERTIONS" + }, + "anchors": { + "11202": { + "event": [ + "ADD", + 340, + 337, + "1", + 396 + ], + "prospective715_before": 3, + "state_after": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": null + }, + "live": false, + "owned_birth": 0 + } + }, + "state_before": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": null + }, + "live": false, + "owned_birth": 0 + } + } + }, + "13572": { + "event": [ + "ADD", + 712, + 747, + "1", + 598 + ], + "prospective715_before": 3, + "state_after": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 747, + 518, + 598, + true + ], + "index": 13569 + }, + "live": true, + "owned_birth": 1 + } + }, + "state_before": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 747, + 518, + 598, + true + ], + "index": 13569 + }, + "live": true, + "owned_birth": 1 + } + } + }, + "13577": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "prospective715_before": 3, + "state_after": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 747, + 518, + 598, + true + ], + "index": 13569 + }, + "live": true, + "owned_birth": 1 + } + }, + "state_before": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 747, + 518, + 598, + true + ], + "index": 13569 + }, + "live": true, + "owned_birth": 1 + } + } + }, + "13578": { + "event": [ + "ADD", + 715, + 747, + "1", + 598 + ], + "prospective715_before": 3, + "state_after": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 747, + 518, + 598, + true + ], + "index": 13569 + }, + "live": true, + "owned_birth": 1 + } + }, + "state_before": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 747, + 518, + 598, + true + ], + "index": 13569 + }, + "live": true, + "owned_birth": 1 + } + } + }, + "13737": { + "event": [ + "ADD", + 525, + 712, + "-4", + 598 + ], + "prospective715_before": 3, + "state_after": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 3, + 598, + false + ], + "index": 13736 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + }, + "state_before": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 3, + 598, + false + ], + "index": 13736 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + } + }, + "14654": { + "event": [ + "ADD", + 525, + 340, + "1", + 396 + ], + "prospective715_before": 3, + "state_after": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 598, + 396, + false + ], + "index": 14653 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + }, + "state_before": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 598, + 396, + false + ], + "index": 14653 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 3, + 598, + false + ], + "index": 13571 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + } + }, + "14982": { + "event": [ + "MOVE", + 715, + 598, + 396, + false + ], + "prospective715_before": 3, + "state_after": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 598, + 396, + false + ], + "index": 14653 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 397, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 598, + 397, + false + ], + "index": 14655 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 598, + 396, + false + ], + "index": 14982 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + }, + "state_before": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 598, + 396, + false + ], + "index": 14653 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 397, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 598, + 397, + false + ], + "index": 14655 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 598, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + } + }, + "14983": { + "event": [ + "ADD", + 340, + 715, + "-4", + 396 + ], + "prospective715_before": 396, + "state_after": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 598, + 396, + false + ], + "index": 14653 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 397, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 598, + 397, + false + ], + "index": 14655 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 598, + 396, + false + ], + "index": 14982 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + }, + "state_before": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 598, + 396, + false + ], + "index": 14653 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 397, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 598, + 397, + false + ], + "index": 14655 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 598, + 396, + false + ], + "index": 14982 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + } + }, + "823": { + "event": [ + "ADD", + 207, + 720, + "-2", + 3 + ], + "prospective715_before": 3, + "state_after": { + "340": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": null + }, + "live": false, + "owned_birth": 0 + } + }, + "state_before": { + "340": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": null + }, + "live": false, + "owned_birth": 0 + } + } + } + }, + "cuts": { + "14983": { + "convention": "BEFORE_ORIGINAL_EVENT", + "insertions": [ + [ + 14983, + 715, + 525, + "-1/4", + 396 + ], + [ + 14983, + 715, + 340, + "1/4", + 396 + ] + ], + "prospective715_frame": 396, + "state": { + "340": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 340, + 70, + 396, + false + ], + "index": 11200 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 525, + 598, + 396, + false + ], + "index": 14653 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 397, + "last_frame_change": { + "event": [ + "MOVE", + 712, + 598, + 397, + false + ], + "index": 14655 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 396, + "last_frame_change": { + "event": [ + "MOVE", + 715, + 598, + 396, + false + ], + "index": 14982 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": [ + "CLEAR", + 747, + 598 + ], + "index": 13579 + }, + "live": false, + "owned_birth": 1 + } + } + }, + "823": { + "convention": "BEFORE_ORIGINAL_EVENT", + "insertions": [ + [ + 823, + 715, + 525, + "1/4", + 3 + ], + [ + 823, + 715, + 712, + "-1", + 3 + ] + ], + "prospective715_frame": 3, + "state": { + "340": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "525": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "712": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "715": { + "frame": 3, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": 3 + }, + "live": true, + "owned_birth": null + }, + "747": { + "frame": null, + "last_frame_change": { + "event": null, + "index": null, + "initial_frame": null + }, + "live": false, + "owned_birth": 0 + } + } + } + }, + "ledgers": [ + { + "classification": { + "local_accumulation": [ + 121 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 121 + ] + }, + "event": [ + "ADD", + 121, + 715, + "2", + 3 + ], + "index": 203, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "715": 3 + }, + "tracked_frames_before": { + "715": 3 + } + } + }, + { + "classification": { + "local_accumulation": [ + 137 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 137 + ] + }, + "event": [ + "ADD", + 137, + 715, + "-2", + 3 + ], + "index": 298, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "715": 3 + }, + "tracked_frames_before": { + "715": 3 + } + } + }, + { + "classification": { + "local_accumulation": [ + 184 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 184 + ] + }, + "event": [ + "ADD", + 184, + 715, + "-2", + 3 + ], + "index": 648, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "715": 3 + }, + "tracked_frames_before": { + "715": 3 + } + } + }, + { + "classification": { + "local_accumulation": [ + 206 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 206 + ] + }, + "event": [ + "ADD", + 206, + 715, + "2", + 3 + ], + "index": 822, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "715": 3 + }, + "tracked_frames_before": { + "715": 3 + } + } + }, + { + "classification": { + "local_accumulation": [ + 207 + ], + "native_transport": false, + "reads": [ + 720 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 207 + ] + }, + "event": [ + "ADD", + 207, + 720, + "-2", + 3 + ], + "index": 823, + "scopes": [ + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": {}, + "tracked_frames_before": {} + } + }, + { + "classification": { + "local_accumulation": [ + 340 + ], + "native_transport": false, + "reads": [ + 337 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 340 + ] + }, + "event": [ + "ADD", + 340, + 337, + "1", + 396 + ], + "index": 11202, + "scopes": [ + "340_nonblocking_11202_provenance_writes", + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "340": 396 + }, + "tracked_frames_before": { + "340": 396 + } + } + }, + { + "classification": { + "local_accumulation": [ + 712 + ], + "native_transport": false, + "reads": [ + 747 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 712 + ] + }, + "event": [ + "ADD", + 712, + 747, + "1", + 598 + ], + "index": 13572, + "scopes": [ + "712_interval_writes", + "747_two_read_continuity", + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "712": 598, + "747": 598 + }, + "tracked_frames_before": { + "712": 598, + "747": 598 + } + } + }, + { + "classification": { + "local_accumulation": [ + 713 + ], + "native_transport": false, + "reads": [ + 747 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 713 + ] + }, + "event": [ + "ADD", + 713, + 747, + "1", + 598 + ], + "index": 13574, + "scopes": [ + "747_two_read_continuity" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "747": 598 + }, + "tracked_frames_before": { + "747": 598 + } + } + }, + { + "classification": { + "local_accumulation": [ + 714 + ], + "native_transport": false, + "reads": [ + 747 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 714 + ] + }, + "event": [ + "ADD", + 714, + 747, + "1", + 598 + ], + "index": 13576, + "scopes": [ + "747_two_read_continuity" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "747": 598 + }, + "tracked_frames_before": { + "747": 598 + } + } + }, + { + "classification": { + "local_accumulation": [], + "native_transport": true, + "reads": [], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [] + }, + "event": [ + "MOVE", + 715, + 3, + 598, + false + ], + "index": 13577, + "scopes": [ + "715_all_interval_contacts", + "715_complete_prospective_contact_trace", + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "715": 598 + }, + "tracked_frames_before": { + "715": 3 + } + } + }, + { + "classification": { + "local_accumulation": [ + 715 + ], + "native_transport": false, + "reads": [ + 747 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 715 + ] + }, + "event": [ + "ADD", + 715, + 747, + "1", + 598 + ], + "index": 13578, + "scopes": [ + "715_all_interval_contacts", + "747_two_read_continuity", + "715_complete_prospective_contact_trace", + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "715": 598, + "747": 598 + }, + "tracked_frames_before": { + "715": 598, + "747": 598 + } + } + }, + { + "classification": { + "local_accumulation": [ + 525 + ], + "native_transport": false, + "reads": [ + 712 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 525 + ] + }, + "event": [ + "ADD", + 525, + 712, + "-4", + 598 + ], + "index": 13737, + "scopes": [ + "525_interval_writes", + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "525": 598, + "712": 598 + }, + "tracked_frames_before": { + "525": 598, + "712": 598 + } + } + }, + { + "classification": { + "local_accumulation": [ + 525 + ], + "native_transport": false, + "reads": [ + 340 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 525 + ] + }, + "event": [ + "ADD", + 525, + 340, + "1", + 396 + ], + "index": 14654, + "scopes": [ + "525_interval_writes", + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 3, + "prospective715_before": 3, + "tracked_frames_after": { + "340": 396, + "525": 396 + }, + "tracked_frames_before": { + "340": 396, + "525": 396 + } + } + }, + { + "classification": { + "local_accumulation": [], + "native_transport": true, + "reads": [], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [] + }, + "event": [ + "MOVE", + 715, + 598, + 396, + false + ], + "index": 14982, + "scopes": [ + "715_all_interval_contacts", + "715_complete_prospective_contact_trace", + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 396, + "prospective715_before": 3, + "tracked_frames_after": { + "715": 396 + }, + "tracked_frames_before": { + "715": 598 + } + } + }, + { + "classification": { + "local_accumulation": [ + 340 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 340 + ] + }, + "event": [ + "ADD", + 340, + 715, + "-4", + 396 + ], + "index": 14983, + "scopes": [ + "715_complete_prospective_contact_trace", + "fixed_anchor_or_boundary" + ], + "transition": { + "prospective715_after": 396, + "prospective715_before": 396, + "tracked_frames_after": { + "340": 396, + "715": 396 + }, + "tracked_frames_before": { + "340": 396, + "715": 396 + } + } + }, + { + "classification": { + "local_accumulation": [], + "native_transport": true, + "reads": [], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [] + }, + "event": [ + "MOVE", + 715, + 396, + 127, + false + ], + "index": 14988, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 127, + "prospective715_before": 396, + "tracked_frames_after": { + "715": 127 + }, + "tracked_frames_before": { + "715": 396 + } + } + }, + { + "classification": { + "local_accumulation": [ + 388 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 388 + ] + }, + "event": [ + "ADD", + 388, + 715, + "-4", + 127 + ], + "index": 14989, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 127, + "prospective715_before": 127, + "tracked_frames_after": { + "715": 127 + }, + "tracked_frames_before": { + "715": 127 + } + } + }, + { + "classification": { + "local_accumulation": [ + 276 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 276 + ] + }, + "event": [ + "ADD", + 276, + 715, + "4", + 127 + ], + "index": 17049, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 127, + "prospective715_before": 127, + "tracked_frames_after": { + "715": 127 + }, + "tracked_frames_before": { + "715": 127 + } + } + }, + { + "classification": { + "local_accumulation": [ + 340 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 340 + ] + }, + "event": [ + "ADD", + 340, + 715, + "2", + 127 + ], + "index": 17090, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 127, + "prospective715_before": 127, + "tracked_frames_after": { + "340": 127, + "715": 127 + }, + "tracked_frames_before": { + "340": 127, + "715": 127 + } + } + }, + { + "classification": { + "local_accumulation": [ + 388 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 388 + ] + }, + "event": [ + "ADD", + 388, + 715, + "4", + 127 + ], + "index": 17120, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 127, + "prospective715_before": 127, + "tracked_frames_after": { + "715": 127 + }, + "tracked_frames_before": { + "715": 127 + } + } + }, + { + "classification": { + "local_accumulation": [ + 607 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 607 + ] + }, + "event": [ + "ADD", + 607, + 715, + "4", + 127 + ], + "index": 17268, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 127, + "prospective715_before": 127, + "tracked_frames_after": { + "715": 127 + }, + "tracked_frames_before": { + "715": 127 + } + } + }, + { + "classification": { + "local_accumulation": [ + 614 + ], + "native_transport": false, + "reads": [ + 715 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 614 + ] + }, + "event": [ + "ADD", + 614, + 715, + "2", + 127 + ], + "index": 17274, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 127, + "prospective715_before": 127, + "tracked_frames_after": { + "715": 127 + }, + "tracked_frames_before": { + "715": 127 + } + } + }, + { + "classification": { + "local_accumulation": [ + 715 + ], + "native_transport": false, + "reads": [ + 256 + ], + "rule": "CLOSED_POSITIONAL_SIX_OP_GRAMMAR", + "writes": [ + 715 + ] + }, + "event": [ + "ADD", + 715, + 256, + "-1/4", + 127 + ], + "index": 17439, + "scopes": [ + "715_complete_prospective_contact_trace" + ], + "transition": { + "prospective715_after": 127, + "prospective715_before": 127, + "tracked_frames_after": { + "715": 127 + }, + "tracked_frames_before": { + "715": 127 + } + } + } + ], + "write_census": { + "340": [ + 11202 + ], + "525": [ + 13737, + 14654 + ], + "712": [ + 13572 + ] + }, + "747_read_lifetimes": { + "13572": { + "birth": 1, + "birth_event_index": 13565, + "frame": 598, + "live": true + }, + "13578": { + "birth": 1, + "birth_event_index": 13565, + "frame": 598, + "live": true + } + }, + "predicates": { + "340_stability": "PASS", + "525_writes": "PASS", + "712_writes": "PASS", + "715_observer_exclusion": "PASS", + "747_value_lifetime_continuity": "PASS", + "closed_full_grammar": "PASS", + "fixed_anchors": "PASS", + "original_cut_frames": "PASS", + "prospective715_all_contacts": "PASS", + "tracked_original_typing": "PASS" + }, + "340_stronger_provenance_observation": { + "blocking": false, + "meaning": "Provenance only; required C stability starts at14654 source read", + "no_write_stronger_claim_observed": false, + "writes_in_inclusive11202_to_cut14983": [ + 11202 + ] + }, + "credited_causal_identity": "Ali Romman PR5713: D=A-4*(B+V)+C; V=A/4-B-D/4+C/4", + "assumptions": [ + "Decoded native MOVEs preserve logical values", + "Straight-line positional field semantics; no unsupported channels", + "Baseline scalar/native and owned-erasure contracts remain conditional" + ], + "not_proved": [ + "Emitted5713 WORD/delta equality", + "Exact3-to396 provider/absolute phase/all widths", + "Full scalar endpoint matrix or owned-zero erasures", + "Physical caller/full invoice", + "Ordinary/stock/precision/tape/compiler/BIT/outer funding", + "New kappa or .00311" + ], + "new_kappa": null, + "no_fallback": true, + "decoded_word_sha256_recorded_after_authorized_decode": "3ae490190103898b9a20d32a4be8865b1214dd9a84a154e509022dc698e3f8fc" + } +} diff --git a/research/p104-temporal-fixed-independent-audit/inputs/LICENSE b/research/p104-temporal-fixed-independent-audit/inputs/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/inputs/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/p104-temporal-fixed-independent-audit/inputs/NOTICE b/research/p104-temporal-fixed-independent-audit/inputs/NOTICE new file mode 100644 index 0000000000..fa0bd1401f --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/inputs/NOTICE @@ -0,0 +1,42 @@ +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. diff --git a/research/p104-temporal-fixed-independent-audit/inputs/README.md b/research/p104-temporal-fixed-independent-audit/inputs/README.md new file mode 100644 index 0000000000..5f2f3c1f2e --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/inputs/README.md @@ -0,0 +1,7 @@ +# Retained immutable inputs + +The retained set is `WORD.json.gz`, `LICENSE` and `NOTICE`. Original filename, Git blob, byte length and SHA256 are exact in SOURCES.json and the verifier. LICENSE and NOTICE are unchanged source copies; top-level NOTICE appends further credit. + +All three inputs are retained at `e8567c39feda6412a1e5a54e10aeb0a6d4d1e80c`, tree `7f4c2d03f0b44dfe7da32aaeffaf59f30d780582`, in `Clear1nsight/integer-mult-bounds`. Root reports exact remote readback, and the qualified direct phases authenticated these inputs before source decoding. Generic live pins refer to that real retention head, not an assumed reachable foreign source commit. + +The final-publication preparer did not read, copy or hash the opaque compressed WORD, including in inventory loops. Root alone stages that file here from its retained source and owns later byte/history checks. This final documentation revision performs no scientific rerun. No source-code import or archive is required by the standalone data parser. diff --git a/research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz b/research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz new file mode 100644 index 0000000000..f3fb0e2144 Binary files /dev/null and b/research/p104-temporal-fixed-independent-audit/inputs/WORD.json.gz differ diff --git a/research/p104-temporal-fixed-independent-audit/verify.py b/research/p104-temporal-fixed-independent-audit/verify.py new file mode 100644 index 0000000000..a2111649f3 --- /dev/null +++ b/research/p104-temporal-fixed-independent-audit/verify.py @@ -0,0 +1,590 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Portable preparation, NOT YET RUN: fixed PR5713 causal/typed audit. + +Modified from the historically executed local checker e2c42f6f...61aa3. +Only the portable data/custody interface and privacy wrapper are adapted. +Audit/causal/typing/parser core is retained exactly; see ADAPTATION.json. +No author imports, native provider, full-price replay or emitted WORD. +""" +import gzip + + +import hashlib + + +import io + + +import json + + +from fractions import Fraction + + +from pathlib import Path + + +import re + + +import sys + + +import time + + +HERE = Path(__file__).resolve().parent + + +OBJECT = 'pr5713-fixed-causal-typed715-on-original5684-v1' + + +LIMITS = {'aggregate_seconds': 150, 'child_seconds': 60, 'memory_mib': 512, 'runs': 1, 'controls': 0} + + +BOUNDS = {'expanded_bytes': 16777216, 'json_nodes': 500000, 'json_depth': 16, + 'string_characters': 256, 'integer_digits': 24, 'frames': 4096, + 'basis_vectors': 9, 'events': 40000, 'roles': 752, 'ledger_entries': 1024, + 'ledger_bytes': 524288, 'entry_bytes': 4096, 'output_bytes': 1048576, + 'metadata_file_bytes': 1048576, 'metadata_total_bytes': 8388608, + 'coefficient_digits': 24} + + +SUBJECT = {'publication_head': 'a5348f7143f95fe0046b92b96172e30763c7d731', + 'recipient': 715, 'tracked': [340, 525, 712, 715, 747], + 'cuts_before_original_events': [823, 14983], + 'anchors': [823, 11202, 13572, 13577, 13578, 13737, 14654, 14982, 14983], + '340_no_write_interval': [14654, 14983], + '340_nonblocking_provenance_interval': [11202, 14983], + '747_no_write_interval': [13572, 13578], + 'causal_interval': [823, 14983], + 'skip_original_events': [13577, 13578], + 'retarget_original_MOVE': [14982, 715, 3, 396], + 'insertions': [[823, 715, 525, '1/4', 3], [823, 715, 712, '-1', 3], + [14983, 715, 525, '-1/4', 396], [14983, 715, 340, '1/4', 396]]} + + +REQUIRED = {'schema', 'public', 'initial', 'final', 'frames', 'program', 'live'} + + +OPTIONAL = {'ports', 'owned_fields'} + + +ARITY = {'MOVE': 5, 'INIT': 3, 'CLEAR': 3, 'SCALE': 4, 'ADD': 5, 'COPY': 5} + + +START = time.monotonic() + + +METADATA_BYTES = 0 + + +BINDING_CONTEXT = None + + +class Unresolved(Exception): + def __init__(self, reason, index=None, detail=None): + self.reason, self.index, self.detail = reason, index, detail + + +class Falsified(Exception): + def __init__(self, predicate, index, event, expected, actual): + self.predicate, self.index, self.event = predicate, index, event + self.expected, self.actual = expected, actual + + +class Incomplete(Exception): + pass + + +def need(ok, reason, index=None, detail=None): + if not ok: + raise Unresolved(reason, index, detail) + + +def fixed(ok, predicate, index, event, expected, actual): + if not ok: + raise Falsified(predicate, index, event, expected, actual) + + +def deadline(): + if time.monotonic() - START >= LIMITS['child_seconds']: + raise Incomplete('Internal elapsed limit; external root guard remains authoritative') + + +def integer(value): + return type(value) is int + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True).encode('ascii') + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def bounded_read(path, cap, metadata=False): + global METADATA_BYTES + with path.open('rb') as stream: + raw = stream.read(cap + 1) + need(len(raw) <= cap, 'Byte cap exceeded: ' + path.name) + if metadata: + METADATA_BYTES += len(raw) + need(METADATA_BYTES <= BOUNDS['metadata_total_bytes'], 'Aggregate metadata cap exceeded') + return raw + + +def preflight(raw): + """Lexical allocation guard BEFORE json.loads; constructs no JSON tree. + + Count every string/key, scalar and container, nesting and decoded-string + upper lengths. json.loads separately validates complete JSON syntax. + """ + text = raw.decode('utf-8') + n, i, nodes, depth = len(text), 0, 0, 0 + while i < n: + if i % 16384 == 0: + deadline() + ch = text[i] + if ch.isspace() or ch in ',:': + i += 1 + continue + if ch in ']}': + depth -= 1 + need(depth >= 0, 'Unbalanced JSON enclosure') + i += 1 + continue + nodes += 1 + need(nodes <= BOUNDS['json_nodes'], 'JSON node cap exceeded before allocation') + if ch in '[{': + depth += 1 + need(depth <= BOUNDS['json_depth'], 'JSON nesting cap exceeded before allocation') + i += 1 + elif ch == '"': + i += 1 + length = 0 + while i < n and text[i] != '"': + need(ord(text[i]) >= 32, 'Control byte in JSON string') + if text[i] == '\\': + i += 1 + need(i < n, 'Incomplete JSON escape') + if text[i] == 'u': + need(i + 4 < n and all(c in '0123456789abcdefABCDEF' for c in text[i+1:i+5]), + 'Malformed JSON unicode escape') + i += 4 + else: + need(text[i] in '"\\/bfnrt', 'Unknown JSON escape') + length += 1 + need(length <= BOUNDS['string_characters'], 'JSON string cap exceeded before allocation') + i += 1 + need(i < n, 'Unterminated JSON string') + i += 1 + elif ch in '-0123456789': + start = i + while i < n and text[i] not in ' \t\r\n,]}:': + i += 1 + need(i - start <= BOUNDS['integer_digits'] + 1, 'JSON integer token cap exceeded') + token = text[start:i] + need(re.fullmatch(r'-?(0|[1-9][0-9]*)', token) is not None, + 'Non-integer/unsupported JSON numeric token') + need(len(token.lstrip('-')) <= BOUNDS['integer_digits'], 'JSON integer digit cap exceeded') + elif text.startswith('true', i): + i += 4 + elif text.startswith('false', i): + i += 5 + elif text.startswith('null', i): + i += 4 + else: + raise Unresolved('Unsupported JSON token before allocation') + need(depth == 0, 'Unbalanced JSON nesting') + return text + + +def unique_pairs(items): + out = {} + for key, value in items: + need(key not in out, 'Duplicate JSON key') + out[key] = value + return out + + +def reject_number(value): + raise Unresolved('Nonfinite or floating JSON number is unsupported') + + +def decode(raw): + text = preflight(raw) + return json.loads(text, object_pairs_hook=unique_pairs, + parse_float=reject_number, parse_constant=reject_number) + + +def coefficient(value, index): + if integer(value): + need(len(str(abs(value))) <= BOUNDS['coefficient_digits'], 'Coefficient token cap', index) + q = Fraction(value) + else: + need(type(value) is str, 'Unsupported scalar representation', index) + match = re.fullmatch(r'([+-]?[0-9]{1,24})(?:/([0-9]{1,24}))?', value) + need(match is not None, 'Unsupported scalar grammar', index) + d = int(match.group(2)) if match.group(2) else 1 + need(d > 0, 'Zero/nonpositive scalar denominator', index) + q = Fraction(int(match.group(1)), d) + need(q != 0 and q.denominator & (q.denominator - 1) == 0, 'Nonzero dyadic scalar required', index) + return q + + +class Audit: + def __init__(self, word): + need(type(word) is dict and REQUIRED <= set(word) and set(word) <= REQUIRED | OPTIONAL, + 'Unknown WORD attribute/semantic channel') + need(word['schema'] == SOURCE['schema'] and word['public'] == 743, + 'Exact schema/public inventory mismatch') + need('owned_fields' not in word or word['owned_fields'] == 9, 'Optional owned inventory mismatch') + if 'ports' in word: + need(type(word['ports']) is list and len(word['ports']) == 104 + and all(integer(q) and 0 < q < 512 for q in word['ports']), 'Unsupported optional port schema') + self.frames, self.program = word['frames'], word['program'] + need(type(self.frames) is list and 599 <= len(self.frames) <= BOUNDS['frames'], 'Frame inventory cap/shape') + need(type(self.program) is list and 14983 < len(self.program) <= BOUNDS['events'], 'Program inventory cap/shape') + self.initial, self.final = word['initial'], word['final'] + need(type(self.initial) is list and type(self.final) is list + and len(self.initial) == len(self.final) == 743, 'Endpoint inventory mismatch') + for f in self.initial + self.final: + self.frame_id(f) + live = word['live'] + need(type(live) is list and len(live) == 104 and all(integer(r) and 0 <= r < 631 for r in live) + and len(set(live)) == 104 and len(set(live) | {r+112 for r in live}) == 208, 'Live/main schema') + # Nine-bit binary basis validation is not a Clifford or scalar matrix. + for basis in self.frames: + need(type(basis) is list and len(basis) <= BOUNDS['basis_vectors'], 'Frame basis cap/shape') + pivots = {} + for v in basis: + need(integer(v) and 0 < v < 512, 'Frame basis vector shape') + x = v + while x: + p = x.bit_length()-1 + if p not in pivots: + pivots[p] = x + break + x ^= pivots[p] + need(x != 0, 'Dependent binary frame basis') + self.masks = {} + fixed([len(self.frames[f]) for f in (3,598,396)] == [0,1,3] + and self.nested(3,598) and self.nested(598,396), + 'OLD715_STRICT_0_1_3_CHAIN', None, None, '3 strict 598 strict 396, dims0/1/3', + {'dimensions': [len(self.frames[f]) for f in (3,598,396)]}) + self.current = {r: self.initial[r] if r < 743 else None for r in SUBJECT['tracked']} + self.last = {r: {'index': None, 'event': None, 'initial_frame': self.current[r]} for r in self.current} + self.alive = set() + self.birth = {r: 0 for r in range(743,752)} + self.birth_site = {r: None for r in range(743,752)} + self.prospective = self.current[715] + self.ledgers, self.ledger_bytes = [], 0 + self.anchors, self.cuts, self.samples = {}, {}, {} + self.write712, self.write525, self.write340 = [], [], [] + self.scanned = 0 + + def frame_id(self, frame, index=None): + need(integer(frame) and 0 <= frame < len(self.frames), 'Invalid frame index', index) + + def mask(self, frame): + if frame not in self.masks: + values = [0] + for v in self.frames[frame]: + values += [x ^ v for x in values] + mask = 0 + for x in values: + mask |= 1 << x + self.masks[frame] = mask + return self.masks[frame] + + def nested(self, a, b): + return len(self.frames[a]) < len(self.frames[b]) and self.mask(a) & self.mask(b) == self.mask(a) + + def state(self): + return {str(r): {'frame': self.current[r], 'live': r < 743 or r in self.alive, + 'owned_birth': self.birth.get(r), 'last_frame_change': self.last[r]} + for r in self.current} + + def append(self, entry): + raw = canonical(entry) + need(len(raw) <= BOUNDS['entry_bytes'], 'Ledger entry byte cap') + need(len(self.ledgers) < BOUNDS['ledger_entries'] + and self.ledger_bytes + len(raw) <= BOUNDS['ledger_bytes'], 'Complete ledger cap; no truncation') + self.ledger_bytes += len(raw) + self.ledgers.append(entry) + + def insertion_cut(self, index): + if index not in (823,14983): + return + wanted = 3 if index == 823 else 396 + roles = (715,525,712) if index == 823 else (715,525,340) + fixed(all(self.current[r] == wanted for r in roles), 'ORIGINAL_CUT_COMMON_CHART', index, + self.program[index], {'roles': list(roles), 'frame': wanted}, self.state()) + fixed(self.prospective == wanted, 'PROSPECTIVE715_INSERTION_CHART', index, + self.program[index], wanted, self.prospective) + self.cuts[str(index)] = {'convention': 'BEFORE_ORIGINAL_EVENT', 'state': self.state(), + 'prospective715_frame': self.prospective, + 'insertions': [x for x in SUBJECT['insertions'] if x[0] == index]} + + def parse_event(self, event, index): + need(type(event) is list and len(event) >= 2, 'Malformed event', index) + op, r = event[:2] + need(type(op) is str and op in ARITY and len(event) == ARITY[op], 'Unknown opcode/arity', index) + need(integer(r) and 0 <= r < 752, 'Invalid positional destination', index) + reads, writes, accum, touched, q = [], [], [], [r], None + if op == 'MOVE': + a,b,private = event[2:] + self.frame_id(a,index); self.frame_id(b,index) + need((r < 743 or r in self.alive) and type(private) is bool + and private == (r in self.alive), 'MOVE ownership/lifetime ambiguity', index) + elif op in ('INIT','CLEAR'): + need(r >= 743 and ((r not in self.alive) if op == 'INIT' else (r in self.alive)), + 'Owned lifetime grammar invalid', index) + self.frame_id(event[2],index) + writes = [r] + else: + self.frame_id(event[-1],index) + q = coefficient(event[-2],index) + writes = [r] + if op in ('ADD','COPY'): + s = event[2] + need(integer(s) and 0 <= s < 752 and s != r, 'Invalid positional source', index) + need(op != 'COPY' or r >= 743, 'COPY destination not owned', index) + reads, touched = [s], [r,s] + if op == 'ADD': + accum = [r] + else: + reads = [r] + need(all(v < 743 or v in self.alive for v in touched), 'Inactive owned scalar access', index) + return op,r,q,reads,writes,accum,touched + + def anchor(self, index, event, op, r, q): + if index not in SUBJECT['anchors']: + return + self.anchors[str(index)] = {'event': event, 'state_before': self.state(), + 'prospective715_before': self.prospective} + add = {13572:(712,747,1,None),13578:(715,747,1,598),13737:(525,712,-4,None), + 14654:(525,340,1,None),14983:(340,715,-4,None)} + if index in add: + dest,src,c,frame = add[index] + ok = op == 'ADD' and r == dest and event[2] == src and q == c + if frame is not None: + ok = ok and event[-1] == frame + fixed(ok, 'FIXED_ADD_ANCHOR', index, event, list(add[index]), event) + if index in (13577,14982): + expected = ['MOVE',715,3,598,False] if index == 13577 else ['MOVE',715,598,396,False] + fixed(event == expected, 'FIXED_MOVE_ANCHOR', index, event, expected, event) + + def check_causal(self, index, event, reads, writes, accum, touched): + scopes = [] + if 823 <= index < 14983: + if 712 in writes: + self.write712.append(index); scopes.append('712_interval_writes') + fixed(index == 13572, '712_SOLE_INTERVAL_WRITE', index, event, [13572], self.write712) + if 525 in writes: + self.write525.append(index); scopes.append('525_interval_writes') + fixed(index in (13737,14654), '525_TWO_INTERVAL_WRITES', index, event, [13737,14654], self.write525) + if 715 in touched: + scopes.append('715_all_interval_contacts') + fixed(event[0] == 'MOVE' or (event[0] == 'ADD' and event[1] == 715 and 715 not in reads), + '715_NO_OUTWARD_OBSERVER_OR_FORBIDDEN_CHANGE', index, event, + 'MOVE or destination-only ADD', {'reads':reads,'writes':writes}) + if 11202 <= index < 14983 and 340 in writes: + self.write340.append(index) + scopes.append('340_nonblocking_11202_provenance_writes') + if index >= 14654: + fixed(False, '340_MINIMAL_READ_TO_CUT_STABILITY', index, event, + 'No340write in [14654,14983)', self.write340) + if 13572 <= index <= 13578 and 747 in touched: + scopes.append('747_two_read_continuity') + if index < 13578: + fixed(747 not in writes, '747_NO_INTERVENING_WRITE_OR_LIFECYCLE', index, event, 'No747write', writes) + if index in (13572,13578): + self.samples[str(index)] = {'birth': self.birth[747], 'live': 747 in self.alive, + 'frame': self.current[747], + 'birth_event_index':self.birth_site[747]} + if 715 in touched: + scopes.append('715_complete_prospective_contact_trace') + if index in SUBJECT['anchors']: + scopes.append('fixed_anchor_or_boundary') + return scopes + + def apply(self, index, event, op, r, touched): + before = {str(v): self.current[v] for v in touched if v in self.current} + prospective_before = self.prospective + if op == 'MOVE': + a,b,private = event[2:] + if r in self.current: + fixed(self.current[r] == a, 'ORIGINAL_TRACKED_MOVE_SOURCE', index,event,a,self.current[r]) + fixed(self.nested(b,a) if private else self.nested(a,b), 'ORIGINAL_TRACKED_MOVE_NESTING', + index,event,'Strict owned reverse/public forward inclusion', [a,b]) + if r == 715 and index != 13577: + source = 3 if index == 14982 else a + fixed(self.prospective == source and self.nested(source,b), 'PROSPECTIVE715_MOVE_CONTACT', + index,event,{'source':source,'target':b},self.prospective) + self.prospective = b + if r in self.current: + self.current[r] = b + self.last[r] = {'index':index,'event':event} + elif op in ('INIT','CLEAR'): + if op == 'INIT': + self.alive.add(r); self.birth[r] += 1 + self.birth_site[r] = index + else: + self.alive.remove(r) + if r in self.current: + if op == 'CLEAR': + fixed(self.current[r] == event[2], 'TRACKED_CLEAR_CHART', index,event,event[2],self.current[r]) + self.current[r] = event[2] if op == 'INIT' else None + self.last[r] = {'index':index,'event':event} + else: + for v in touched: + if v in self.current: + fixed(self.current[v] == event[-1], 'ORIGINAL_TRACKED_SCALAR_COMMON_CHART', + index,event,event[-1],{'role':v,'actual':self.current[v]}) + if 715 in touched and index != 13578: + fixed(self.prospective == event[-1], 'PROSPECTIVE715_RETAINED_SCALAR_CONTACT', + index,event,event[-1],self.prospective) + return {'tracked_frames_before':before, + 'tracked_frames_after':{str(v):self.current[v] for v in touched if v in self.current}, + 'prospective715_before':prospective_before,'prospective715_after':self.prospective} + + def scan(self): + for index,event in enumerate(self.program): + if index % 256 == 0: + deadline() + self.insertion_cut(index) + op,r,q,reads,writes,accum,touched = self.parse_event(event,index) + self.anchor(index,event,op,r,q) + scopes = self.check_causal(index,event,reads,writes,accum,touched) + transition = self.apply(index,event,op,r,touched) + if scopes: + self.append({'index':index,'event':event,'scopes':scopes, + 'classification':{'reads':reads,'writes':writes,'local_accumulation':accum, + 'native_transport':op == 'MOVE', + 'rule':'CLOSED_POSITIONAL_SIX_OP_GRAMMAR'}, + 'transition':transition}) + if str(index) in self.anchors: + self.anchors[str(index)]['state_after'] = self.state() + self.scanned = index + 1 + fixed(self.write712 == [13572], 'COMPLETE712_WRITE_CENSUS', len(self.program),None,[13572],self.write712) + fixed(self.write525 == [13737,14654], 'COMPLETE525_WRITE_CENSUS',len(self.program),None,[13737,14654],self.write525) + fixed(set(self.samples) == {'13572','13578'} and self.samples['13572']['live'] + and self.samples['13578']['live'] + and self.samples['13572']['birth'] == self.samples['13578']['birth'], + '747_SAME_OWNED_LIFETIME_AT_TWO_READS',len(self.program),None,'Same live owned lifetime',self.samples) + for r in (340,525,712,715): + fixed(self.current[r] == self.final[r], 'TRACKED_PUBLIC_FINAL_CHART',len(self.program),None, + {'role':r,'frame':self.final[r]},self.current[r]) + fixed(self.prospective == self.final[715], 'PROSPECTIVE715_FINAL_CHART',len(self.program),None, + self.final[715],self.prospective) + need(not self.alive, 'Owned lifetime grammar has live exits') + return {'status':'PASS_FIXED_CAUSAL_LEDGER_AND_TYPED_CONTACTS_ONLY', + 'coverage':{'complete_program_scan':True,'events':self.scanned, + 'interval':'[823,14983)','340_required_interval':'[14654,14983)', + '340_nonblocking_provenance_interval':'[11202,14983)', + '747_no_write_interval':'[13572,13578)', + 'prospective715_contacts':'ALL_RETAINED_FULL_PROGRAM_PLUS_FOUR_INSERTIONS'}, + 'anchors':self.anchors,'cuts':self.cuts,'ledgers':self.ledgers, + 'write_census':{'712':self.write712,'525':self.write525,'340':self.write340}, + '340_stronger_provenance_observation':{ + 'blocking':False,'writes_in_inclusive11202_to_cut14983':self.write340, + 'no_write_stronger_claim_observed':not self.write340, + 'meaning':'Provenance only; required C stability starts at14654 source read'}, + '747_read_lifetimes':self.samples, + 'predicates':{p:'PASS' for p in ['fixed_anchors','712_writes','525_writes','340_stability', + '747_value_lifetime_continuity','715_observer_exclusion', + 'original_cut_frames','tracked_original_typing', + 'prospective715_all_contacts','closed_full_grammar']}, + 'credited_causal_identity':'Ali Romman PR5713: D=A-4*(B+V)+C; V=A/4-B-D/4+C/4', + 'assumptions':['Decoded native MOVEs preserve logical values', + 'Straight-line positional field semantics; no unsupported channels', + 'Baseline scalar/native and owned-erasure contracts remain conditional'], + 'not_proved':['Emitted5713 WORD/delta equality','Exact3-to396 provider/absolute phase/all widths', + 'Full scalar endpoint matrix or owned-zero erasures','Physical caller/full invoice', + 'Ordinary/stock/precision/tape/compiler/BIT/outer funding','New kappa or .00311']} + + +SOURCE = {'repository': 'GamingPuzzled/integer-mult-bounds', 'head': 'd0f6fa2555410a1e23fe4191424c2097ab3d5d97', 'committed_path': 'research/p104-reframe-r22/WORD.json.gz', 'file_name': 'WORD.json.gz', 'bytes': 106613, 'git_blob': 'f3fb0e2144ec8a5c3407e4eaa6528bb3436ba573', 'sha256': 'd6db1d0d97b13ea483a462c65437664d15d34dec56c3682cf6e1de31266ec6c2', 'schema': 'p104-r22-reframe/1', 'embedded_frames': 'BOUND_BY_COMPLETE_AUTHENTICATED_WORD'} + +INPUT_TEXT_PINS = {'LICENSE': {'bytes': 11357, 'sha256': 'c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4', 'git_blob': '261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64'}, 'NOTICE': {'bytes': 2179, 'sha256': 'e8e0cabef6cf40d63f3cea3b6403dfd1af8727e40df03f09b2932718bcddc1b0', 'git_blob': 'fa0bd1401f5775f4351cfa23b08f3998dba6129e'}} + + +def authenticate_blob(path, pin): + raw = bounded_read(path, pin['bytes'], metadata=True) + need(len(raw) == pin['bytes'] and sha(raw) == pin['sha256'], 'Pinned input length/SHA256 mismatch: ' + path.name) + need(hashlib.sha1(('blob '+str(len(raw))+'\0').encode('ascii')+raw).hexdigest() == pin['git_blob'], + 'Pinned input Git blob mismatch: ' + path.name) + return raw + + +def run(): + global BINDING_CONTEXT + need(len(sys.argv) == 2, 'Expected exactly one data path: WORD.json.gz; no control/source/window options') + input_path = Path(sys.argv[1]) + need(input_path.name == SOURCE['file_name'], 'Input basename must be the exact source filename WORD.json.gz') + checker_raw = bounded_read(Path(__file__).resolve(), BOUNDS['metadata_file_bytes'], metadata=True) + binding = {'checker_sha256':sha(checker_raw), 'source':SOURCE, + 'variant':'PORTABLE_DATA_ONLY_ADAPTATION', + 'historical_local_checker_sha256':'e2c42f6f5db304067661ec3d54e6c94ebf7bc2fa82d4c8ded7f714cdcb461aa3', + 'historical_local_run_is_not_a_portable_run':True} + BINDING_CONTEXT = binding + for name,pin in INPUT_TEXT_PINS.items(): + authenticate_blob(HERE/'inputs'/name, pin) + raw = authenticate_blob(input_path, SOURCE) + with gzip.GzipFile(fileobj=io.BytesIO(raw)) as stream: + expanded = stream.read(BOUNDS['expanded_bytes'] + 1) + need(len(expanded) <= BOUNDS['expanded_bytes'], 'Expanded JSON byte cap') + decoded_sha = sha(expanded) + word = decode(expanded) + del expanded, raw + audit = Audit(word) + result = audit.scan() + result['binding'] = binding + result['decoded_word_sha256_recorded_after_authorized_decode'] = decoded_sha + return result + + +def main(): + try: + result = run() + code = 0 + except Falsified as e: + result = {'status':'FIXED_SUFFICIENT_PREMISE_NOT_ESTABLISHED','predicate':e.predicate,'event_index':e.index, + 'event':e.event,'expected':e.expected,'actual':e.actual, + 'coverage_complete':False, + 'meaning':'Fixed sufficient causal or prescribed typing premise not established; no identity counterexample or author defect proved'} + code = 2 + except (Incomplete, MemoryError, TimeoutError, KeyboardInterrupt) as e: + result = {'status':'INCOMPLETE','coverage_complete':False,'reason':type(e).__name__+': interrupted or allocation failure'} + code = 4 + except Exception as e: + result = {'status':'BINDING_UNRESOLVED','coverage_complete':False,'scientific_falsifier':False, + 'reason':e.reason if isinstance(e,Unresolved) else type(e).__name__+': input/runtime failure; local paths omitted', + 'event_index':getattr(e,'index',None),'detail':getattr(e,'detail',None)} + code = 3 + result.update({'object_id':OBJECT,'source_head':SOURCE['head'],'no_fallback':True,'new_kappa':None, + 'binding':BINDING_CONTEXT,'source':SOURCE, + 'elapsed_seconds_internal':time.monotonic()-START, + 'runtime_memory_and_termination_evidence':'EXTERNAL_GUARD_EVIDENCE_IS_SEPARATE'}) + try: + body = canonical(result) + need(len(body) + 256 <= BOUNDS['output_bytes'], 'Receipt output cap; no truncation') + envelope = canonical({'receipt':result,'receipt_sha256':sha(body)}) + except MemoryError: + envelope = canonical({'receipt':{'status':'INCOMPLETE','reason':'Receipt serialization memory failure', + 'coverage_complete':False,'object_id':OBJECT}}) + code = 4 + except Exception: + envelope = canonical({'receipt':{'status':'BINDING_UNRESOLVED','reason':'Receipt output cap', + 'coverage_complete':False,'object_id':OBJECT}}) + code = 3 + print(envelope.decode('ascii')) + return code + + +if __name__ == '__main__': + sys.exit(main())