diff --git a/research/joint-relations-independent-validation/CLAIMS.json b/research/joint-relations-independent-validation/CLAIMS.json new file mode 100644 index 0000000000..daa01b7985 --- /dev/null +++ b/research/joint-relations-independent-validation/CLAIMS.json @@ -0,0 +1,58 @@ +{ + "schema_version": 1, + "review_status": "READY_FOR_COLD_REPLAY", + "canonical_main": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "selected_baseline": ".0030217758", + "selected_metadata_role": "Frozen historical provenance; future selected-result updates do not invalidate this review.", + "candidates": [ + { + "pr": 5383, + "head": "4bd6efa51a495a7c7b7754915cf0244e7e60969e", + "author": "Ali Romman", + "kappa": "151333/50000000", + "decimal": ".00302666", + "package": "research/kappa-joint-relations-20261023", + "word_payload_sha256": "2aee5e997df99726fc763e510d9cb69fbe4f86114dc8d2cd33ad26c6c462a21d", + "last_pivot": 288 + }, + { + "pr": 5387, + "head": "b1ab650d36f59e5be682a813145b7c67e219e341", + "author": "Dugongue", + "kappa": "605334953/200000000000", + "decimal": ".003026674765", + "package": "research/eight-owned-relations", + "word_payload_sha256": "9aa0d7112b4e13f1aa13a93dab0af6f4435ffe99b842aad841685becdafee492", + "last_pivot": 261 + } + ], + "assumptions": [ + { + "id": "native_all_columns", + "statement": "Retained native operators, phase conventions, spectators and whole-job adapters work at every positive column multiplicity." + }, + { + "id": "owned_erasure", + "statement": "Owned streams and suspended centers obey the retained allocation, erasure and ownership contracts." + }, + { + "id": "compiler", + "statement": "The finite mixed-target compiler and chronological product, completion and splitting satisfy the retained uniform closure contract." + }, + { + "id": "precision_tape", + "statement": "Retained fixed-tape movement and precision/storage prescriptions apply to the new fixed finite template." + }, + { + "id": "analytic_recovery", + "statement": "Analytic decomposition, fine-prime avoidance and exact integer recovery follow the retained upstream/outer framework." + } + ], + "selection_authorized": false, + "construction_claim": "No new native construction is claimed by this independent review.", + "selected_kappa": "15108879/5000000000", + "same_selected_assumptions_required": true, + "new_unconditional_or_Lean_theorem": false, + "uniform_word_materialized": false, + "selected_record_changed": false +} diff --git a/research/joint-relations-independent-validation/COMMANDS.json b/research/joint-relations-independent-validation/COMMANDS.json new file mode 100644 index 0000000000..ddd38138d6 --- /dev/null +++ b/research/joint-relations-independent-validation/COMMANDS.json @@ -0,0 +1,95 @@ +{ + "schema_version": 1, + "commands": [ + { + "name": "algebra-5383", + "argv": [ + "agents/algebra/check_joint.py" + ], + "timeout_seconds": 120 + }, + { + "name": "algebra-5387", + "argv": [ + "agents/algebra/check_joint.py", + "--candidate", + "agents/sources/pr5387/research/eight-owned-relations/WORD.json.gz", + "--candidate-pr", + "5387", + "--candidate-head", + "b1ab650d36f59e5be682a813145b7c67e219e341", + "--out", + "agents/algebra/RESULT-5387.json" + ], + "timeout_seconds": 120 + }, + { + "name": "ownership-5383", + "argv": [ + "agents/ownership/check.py", + "--exact", + "--controls", + "--output", + "agents/ownership/RESULT.json" + ], + "timeout_seconds": 120 + }, + { + "name": "ownership-5387", + "argv": [ + "agents/ownership/check.py", + "--exact", + "--controls", + "--candidate", + "agents/sources/pr5387/research/eight-owned-relations/WORD.json.gz", + "--candidate-head", + "b1ab650d36f59e5be682a813145b7c67e219e341", + "--output", + "agents/ownership/RESULT-5387.json" + ], + "timeout_seconds": 120 + }, + { + "name": "event-invoice-and-prices-both", + "argv": [ + "agents/prices/check_prices.py" + ], + "timeout_seconds": 120 + }, + { + "name": "outer-BIT-compiler-both", + "argv": [ + "agents/outer/check_outer.py", + "--candidate", + "PR5383", + "repository/research/kappa-joint-relations-20261023/RESULT.json", + "--candidate", + "PR5387", + "agents/sources/pr5387/research/eight-owned-relations/RESULT.json", + "--bit-source", + "repository/research/query-thinned-controllers/RESULT.json", + "--out", + "agents/outer/RESULT.json" + ], + "timeout_seconds": 120 + }, + { + "name": "applicability-both", + "argv": [ + "agents/applicability/check_applicability.py" + ], + "timeout_seconds": 120 + }, + { + "name": "actual-word-semantic-mutants-5383", + "argv": [ + "agents/falsifier/check_mutants.py", + "--mode", + "full", + "--out", + "agents/falsifier/CONTROLS-FULL.json" + ], + "timeout_seconds": 300 + } + ] +} diff --git a/research/joint-relations-independent-validation/PROOF.md b/research/joint-relations-independent-validation/PROOF.md new file mode 100644 index 0000000000..96c22c58d4 --- /dev/null +++ b/research/joint-relations-independent-validation/PROOF.md @@ -0,0 +1,217 @@ +# Joint validation and exact dependency argument + +## Claim and five retained premises + +For each of the two exact literal words in CLAIMS.json, the new independent +engines establish the algebra, ownership, complete invoice and numerical +compiler/outer specialization described below. The implication remains +conditional on the **same five literal premises** in CLAIMS.json, which the +source guard compares with the authenticated selected PR5241 claim: + +1. Native operators, phase conventions, spectators and whole-job adapters work + at every positive column multiplicity. +2. Owned streams and suspended centers obey the retained allocation, erasure + and ownership contracts. +3. The finite mixed-target compiler and chronological product, completion and + splitting satisfy the retained uniform closure contract. +4. The retained fixed-tape movement and precision/storage prescriptions apply + to the new fixed finite template. +5. Analytic decomposition, fine-prime avoidance and exact integer recovery + follow the retained upstream/outer framework. + +The frozen selected record is 15108879/5000000000 = .0030217758 at canonical main +1ec1119972c9aefe42525172d07b332fcff81cb4. It is historical provenance, with an exact +vendored copy; no future live selected-file equality is a premise. No source +object is fetched or substituted for missing working input during replay. + +## Distinct literal words and algebraic domains + +| Item | Ali Romman PR5383 | Dugongue PR5387 | +| --- | --- | --- | +| Source head | 4bd6efa51a495a7c7b7754915cf0244e7e60969e | b1ab650d36f59e5be682a813145b7c67e219e341 | +| Conditional κ | 151333/50000000 = .00302666 | 605334953/200000000000 = .003026674765 | +| Last pivot | L288 | L261 | +| Eighth snapshot source event/role | 11306 / L288 | 11296 / L256 | +| Eighth zero source event/role | 17580 / L288 | 17233 / L256 | +| Backward scalar allowance | 158744 | 158776 | + +Both eighth substitutions use frame 281, but the unrestricted source relation +and the retained arbitrary input domain differ. Equal invoices cannot establish +their semantic equivalence. Each algebra invocation independently replays all +21,449 original backward events, derives eight source-center-minus-snapshot rows +and their eight matching later zero rows, reduces the simultaneous rank-eight +system, and checks the actual preparation. It then replays the entire respective +candidate on 624 independent retained inputs plus 17 arbitrary owned entry +inputs. The pivots are 225,227,229,230,241,245,257 and the candidate-specific last +pivot above. No relation basis, WITNESS, author evaluator or PASS receipt is the +source of those identities. See reports/algebra/REPORT.md. + +The independent dyadic row engine keeps integer numerators and a common power +of two denominator. Terms are independent inputs acted on by reduced free words. +Only adjacent generator/inverse pairs cancel; different generators do not +commute. For every positive width f, substitute the inherited actual f-column +operator for each generator and its inverse for the inverse symbol. Evaluation +is an algebra homomorphism, so the unrestricted formal identities hold on all +payload vectors, including nonseparable inputs. Rational coefficients stay +outside evaluation. No tensor power is distributed over a sum. + +All new preparation coefficients use the checked same-frame ADD/CLEAR grammar. +The emitted preparation equals the independent joint RREF assignments and has +no pivot on any pivot right-hand side. All eight snapshots coexist before the +first center substitution, each in a distinct cleared owned bank. Same-frame +COPY substitutes the exact source output with its physical gauge; identity at +a proved complete zero vector removes the later job. Identity does not transport +an arbitrary nonzero value between frames or erase approximate error. + +## Chronology, physical factors and owners + +The independent owner parser separately checks both whole backward words and +both unchanged forward words, all frame transitions, exact retained endpoints, +zero retags and owned returns. Each backward has 17 distinct complete owners +(eight pivots and C0..C8); each forward has one C0 owner. Arbitrary dirt is cleared +only in owned fields. Every removed pivot loses its productive target. No +snapshot, suspended center, query scratch or parked bank receives productive +credit. The raw p16 controller needs at least 16*17+2=274 separately tagged LOCAL +banks before its other controller/compiler storage. + +Every retained warp, phase marker and adapter has exact original chronology; +canonical operators and frames are unchanged. Source signed native and paid +phase facts are **authenticated historical reuse** from the selected PR5241 +foundation, whose full 31-file proof/checker/receipt closure is retained under +capsule/agents/sources/pr5241. The receipt binds the original source payload +cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd, +180 native classes, all 408 helpers in both orientations, and 5710 oriented paid +classes/6596 paid event instances. The historical first-cold wrapper differs +from canonical verify.py; its mathematical phase/native/helper checkers and +regeneration code retain the recorded hashes. No new phase lowering is claimed. +The canonical maintainer PROOF-REVIEW authorizes this unchanged foundation reuse. +New scalar chronology, joint identities and owner domains are checked afresh. +PR5384's single-relation review supplies generic COPY/zero/all-f interpretation, +not the simultaneous joint proof or new inventory. + +## Whole-controller invoice, directed prices and outer point + +The event census computes paid ranks from actual endpoint frame dimensions, +checks physical scalar tariffs and reads the literal p16 controller. It obtains +64,148 paid jobs and 10,800 productive fields for each word. Relative to the +source controller it removes 128 H1 and 128 H8 paid calls and surrenders all +128 H9 productive targets; the rank surplus remains 752. This is a complete +controller invoice, not eight added local savings. It includes main, idle, +query and completion terms. See reports/prices/REPORT.md. + +A fresh independent fixed-point rational interval engine uses directed rounding +at 10^-65, an atanh logarithm series and exponential Taylor remainder. It checks +the actual signed moments, unique fixed-profile crossing, both completion tails, +strict alpha reserve, eta/complement capacity and splitting. It independently +recomputes both candidate parameter choices; source-identical profile reuse is +justified by the separate literal event censuses. The raw crossing is strictly +between .00302667476807 and .00302667476808. This is a ceiling for this exact +invoice, not an optimum over native constructions or relation systems. + +| Quantity | PR5383 | PR5387 | +| --- | --- | --- | +| Tested complex saving | .00302667 | .003026674766 | +| Reserved alpha slack | 1e-9 | 1e-12 | +| Tensor exponent / cutoff / floor | 1024 / 20 / 21 | 1024 / 20 / 21 | +| Outer gap | 1/700000000 | 1/7000000000000 | +| Least winning j on stated sufficient grid | 44836 | 58507 | +| Compiler H, N=2^H | 31385200000000 | 409549000000000000 | + +The new rational outer engine derives all 54 strict and four functional rows +from its own exact parameter family, checks all positive, and independently +finds the winning compiler integer and failure at the preceding sufficient-grid +index. It compares author parameter records only after fresh computation. +Ordinary BIT is source-bound to 17/5000=.0034 with the exact unchanged ABI; +its native/interface admission is retained, not replayed. The compiler threshold +is an algorithmic finite specification. The enormous expanded word is not +materialized. See reports/outer/REPORT.md and reports/applicability/REPORT.md. + +The author engines' separate normal/optimized cold replay evidence is an +external execution gate. This review's own replay independently recomputes the +invoice, directed moments and outer predicates; it does not promote author +RESULT status labels into a premise. + +## Effective expanded bounds and exact physical domain + +The detailed construction and strong-induction proof are retained in +reports/applicability/REPORT.md, with exact canonical FINITE-PRECOMPILATION and +FINITE-TEMPLATE-CLOSURE notes under capsule/repository. For the explicitly chosen +integer batch clearing, sequential base kernels, full routes and separately +tagged owned banks, define + +``` +D = 2^262144 +F(0) = D +X_n = (n+1)*(D+1)*(F(n-1)+1) (n>=1) +F(n) = X_n^(16*(n+1)^2) (n>=1) +N = 2^H, M = F(N) +Wbar = Pbar = Obar = Rbar = Gbar = M +Zbar = 2*M +Ebar = 64*(Zbar+N+Pbar+Gbar+1)^3 +Bbar = Pbar+Ebar +C0bar = 32*N*Bbar^2 +``` + +These are terminating integer recursions and fixed finite constants, with +candidate-specific H. D pays the squared complete role inventory and rank-router +factors of the strictified 1024-fold unit. For top rank n, there are at most +(D+1)^(2n+2) mixed-unit instances; product clearing over distinct smaller widths +is at most F(n-1)^(n-1). Expanded incidence fits X_n^(3n+5); routing and coefficient +height fit X_n^(9n+20). For every n>=1, +16(n+1)^2-(9n+20)=16n^2+23n-4>=35, proving the strong induction. The finite probe +of this inequality corroborates the algebraic proof; it does not replace it. +The raw 181098496 bound is never reused as the expanded cap. + +The actual W/P still determines efficiency; enlarged envelopes create no +productive outputs. The fresh semantic recurrence is +A(e)<=A(floor(e/N))+Pbar*floor(e/N)+Ebar, with elementary leaves <=8e. +It gives A(e)<=2*Bbar*e and complete-layer height below C0bar*d. The actual +identity at zero retags propagates residual error through this changed program; +there is no artificial numerical reset at a symbolic zero. + +For d<=c*p^(a/b), choose +Lprec=bit_length(4*C0bar*ceil(c)), +tprec=max(4,ceil(b*Lprec/(b-a))) and p_prec=2^tprec. +For p>=p_prec the retained fine-grid prescription uses at most 2p bits per signed +component. Fixed-tape class restrictions remain f<=p, A=O(p), +K/log(p)->infinity, complete compact/control fields, restored dirty temporaries +and the source superpolynomial record fiber. Their asymptotic domain-entry +threshold remains the retained premise where no numerical growth rate is given. + +With Dord(e)=0 below N and 1+Dord(floor(e/N)) otherwise, reserve complex stock +[Wbar*(Obar+1)]^Dord(d), **multiply** it by simultaneous BIT stock, and pad once +to the full product. For retained BIT coefficient L_BIT, define +Lstock=ceil(log2 Wbar)+ceil(log2(Obar+1))+L_BIT+2. +Above d>=2^(2*(Lstock+2)), the combined reserve uses fewer than d/4 complete +chunks; padding costs a factor below 2. Include stopping, precision, movement +and descriptor cutoffs in the final maximum. This pays all suspended banks and +preserves the retained movement exponent and spectator restoration. + +## Independence, controls and invalidation + +No new engine imports an author native, price, interval or endpoint evaluator. +The only cross-engine import is the independent algebra implementation used by +the actual-word semantic falsifier. The wrapper runs both exact words separately, +then checks fresh coverage fields and source/K/payload identities. Fresh result +files do not enter the frozen input inventory and cannot form a hash cycle. +The normal/-O schedule is identical, with explicit optimization propagated to +every scientific subprocess and fresh bytecode caches before scientific imports. + +Independent controls cover preparation sign/coefficient/pivot, wrong saved row, +wrong COPY gauge, omitted relation, arbitrary owned dirt, missing owner returns, +source chronology, borrowed erasure, storage alias, productive credit, extra H1, +reserve, compiler grid and outer boundary failures. Six actual-word mutants +recompute their payload digests and reach the mathematical parser directly; +rejection is not an old-digest comparison. Source and headline mutation controls +separately exercise the working-input guard and offline Git membership binding. + +An early algebra parser rejected legal signed-denominator SCALE [2,-1]; sign +normalization corrected that checker defect before the frozen successful runs. +Early applicability/falsifier resource failures and the wrong-marker parser +attempt remain reported as implementation failures, never candidate evidence. +Source phase, ordinary BIT native construction, physical precision/tape execution, +analytic decomposition, prime avoidance and integer recovery are reused in +explicit quantified domains. This is not an unconditional theorem, Lean/kernel +verification, independent human acceptance, selected promotion or practical +speedup. Any relevant word, native factor, ownership, invoice, parameter, +scientific engine, source pin or premise edit invalidates its dependent replay. diff --git a/research/joint-relations-independent-validation/README.md b/research/joint-relations-independent-validation/README.md new file mode 100644 index 0000000000..a0c5845494 --- /dev/null +++ b/research/joint-relations-independent-validation/README.md @@ -0,0 +1,101 @@ +# Independent validation of the joint eight-relation words + +This package is being assembled for the exact Ali Romman PR5383 head +`4bd6efa51a495a7c7b7754915cf0244e7e60969e` at conditional κ `.00302666` +and Dugongue PR5387 head `b1ab650d36f59e5be682a813145b7c67e219e341` +at conditional κ `.003026674765`. The separate independent algebra, exact owner, invoice, directed-price, +applicability and outer checks passed for both words. The first full package +cold replay passed all eight fresh commands; final committed-byte/export +transport and acceptance remain separate root gates. + +The contribution is an independent validation, with newly implemented algebra, +owner/frame parsing, event invoice, rational prices and outer predicates. Ali +Romman retains the public eight-relation construction credit. Dugongue retains +the separately ordered literal word and tighter completion/compiler reserve +application. Equal 64,148-paid / 10,800-productive histograms do not establish +equal word semantics: the eighth pivot is 288 in PR5383 and 261 in PR5387. +Both exact words require separate source identities and ownership specialization. + +The selected baseline is the frozen canonical-main `.0030217758` record at +`1ec1119972c9aefe42525172d07b332fcff81cb4`. This package changes no selected +record. It claims no unconditional multiplication theorem, new native mechanism, +human acceptance or practical speedup. + +## Reproduction + +Run from the repository root with standard-library Python 3.12: + +```sh +python3 -B scripts/research_package.py --package research/joint-relations-independent-validation +``` + +The registered manifest runs normal and optimized replays. Direct commands for +explicit receipt destinations are: + +```sh +python3 -B research/joint-relations-independent-validation/verify.py --output /tmp/joint-normal.json +python3 -O -B research/joint-relations-independent-validation/verify.py --output /tmp/joint-optimized.json +``` + +The standalone verifier authenticates both helper modules before import, rejects +missing/symlinked/mutated working inputs and wrong claim/head/payload/premises, +then copies the minimal capsule into a private scratch tree. It creates fresh +bytecode caches, propagates explicit optimization to every child and runs the +eight scientific commands serially. After copying a read-only export, it sets +only the new private scratch directories to mode 0700 so caches and regenerated +outputs can be created; frozen/exported source bytes and permissions stay +unchanged. Fresh outputs are parsed for exact source bindings and complete +scientific coverage; a child exit code alone is insufficient. It uses no runtime Git reader or Git-blob fallback. Normal and +optimized executions remain separate recorded runs. Receipt destinations must +be outside the package and free of symlink/hardlink aliases. Cold receipts stay +outside frozen inputs, avoiding a source-hash cycle. + +`SOURCE-BINDINGS.json` declares every package-local input with raw digest, +compressed-payload digest where applicable, original head/path/blob and offline +commit/tree membership proofs. `VERIFY.json.inputs` is empty because no runtime +input lies outside this package; its package-local inventory is explicit and +all package changes already trigger registered replay. The full capsule is +about 2.3 MB and retains the selected 31-file phase proof/reuse closure rather +than the historical research archive. + +The first normal package replay completed all eight fresh commands in 23.47 s +under the root 1 GiB serial guard. That receipt predates the final bootstrap +helper hash check and is evidence for its exact pre-bootstrap wrapper only. +Final registered normal/optimized and committed/exported-byte receipts are +external publication gates. Engine bytes and mathematical input payloads are +unchanged. See the source/verification limits in `PROOF.md`. + +## Same premises and proof scope + +The five literal retained premises are in `CLAIMS.json`: native all-column +operators and phase conventions; owned allocation/erasure; uniform finite +mixed-target compiler closure; precision and fixed-tape storage/movement; +analytic, prime and exact-recovery transfer. `PROOF.md` maps their exact +applicability to the new fixed templates and include computable expanded +majorants. The enormous compiled word is specified algorithmically and is not +materialized. + +Source-identical phase factors and previously admitted framework propositions +are reused with exact hashes and domains. This does not rerun absolute-phase +lowering, ordinary BIT construction or analytic integer recovery. PR5384's +single-relation proof cannot establish this package's joint rank, simultaneous +preparation, 17-bank local ownership, endpoint or complete invoice. + +## Open next questions + +Structured questions, relevance, first steps and blockers are in `TASK.json`. +The principal open task is independent closure of the five retained premises. +Any further relation search must supply a changed complete bill and its full +physical/compiler applicability rather than add local savings. + +## Credit and license + +Prepared for Chris R / Clear1nsight with substantial OpenAI Codex assistance. +Ali Romman supplied PR5377/PR5383's public helper-relation mechanism; Dugongue +supplied PR5387's separately priced compiler-margin refinement. Retained credit: +Cao Yifan (PR4610); Chris R (PR5241/PR5384 independent review); Cinna Davis +(PR4470 p16 controller); zxv (completion/compiler); Jacob Alan Sussman +(mixed-target recursion); Dugongue (transported frames); ToikY and the retained +native, Clifford, BIT, precision and analytic contributors. Source-specific +credits and notices remain in the exact vendored files. Apache-2.0 under the +repository LICENSE. diff --git a/research/joint-relations-independent-validation/SOURCE-BINDINGS.json b/research/joint-relations-independent-validation/SOURCE-BINDINGS.json new file mode 100644 index 0000000000..e590a363e9 --- /dev/null +++ b/research/joint-relations-independent-validation/SOURCE-BINDINGS.json @@ -0,0 +1,1292 @@ +{ + "candidate_claim_records": { + "5383": "capsule/repository/research/kappa-joint-relations-20261023/RESULT.json", + "5387": "capsule/agents/sources/pr5387/research/eight-owned-relations/RESULT.json" + }, + "candidate_words": { + "5383": "capsule/repository/research/kappa-joint-relations-20261023/WORD.json.gz", + "5387": "capsule/agents/sources/pr5387/research/eight-owned-relations/WORD.json.gz" + }, + "canonical_main": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "files": [ + { + "bytes": 2301, + "path": "CLAIMS.json", + "role": "bootstrap_helper_or_claim_and_command_contract", + "sha256": "def444a7c84d8d3da1d43117a351eba4ebcffcbf9be01f804a089c16d6b90fea" + }, + { + "bytes": 2354, + "path": "COMMANDS.json", + "role": "bootstrap_helper_or_claim_and_command_contract", + "sha256": "a1137cf53296d6b56db2a785a1e923e4b807e799e1de41a911353ed5e7aa0433" + }, + { + "bytes": 17804, + "path": "capsule/agents/algebra/check_joint.py", + "role": "new_independent_scientific_engine", + "sha256": "3ee4ae79a55188d5abf2306f678179f4aafb799602ffb970fc1bc8f76cb061d9" + }, + { + "bytes": 9747, + "path": "capsule/agents/applicability/check_applicability.py", + "role": "new_independent_scientific_engine", + "sha256": "07d09997ad1e0cf3b16a7a0dc152dcd4305c91b6c5fa8e9a5985f69f44277873" + }, + { + "bytes": 4781, + "path": "capsule/agents/falsifier/check_mutants.py", + "role": "new_independent_scientific_engine", + "sha256": "326a813b2373502cfaf179de89a9a2736a82413e40b26b52f8681495e5fd4359" + }, + { + "bytes": 9832, + "path": "capsule/agents/outer/check_outer.py", + "role": "new_independent_scientific_engine", + "sha256": "6338e7c30403f2077ec1c3397db05707c26fa0dd811c7863b6d84b288fb484ac" + }, + { + "bytes": 16997, + "path": "capsule/agents/ownership/check.py", + "role": "new_independent_scientific_engine", + "sha256": "69ab58e41ccf548d68d24c45b673ed9918e22845d5d819588d431eb7807eff24" + }, + { + "bytes": 16122, + "path": "capsule/agents/prices/check_prices.py", + "role": "new_independent_scientific_engine", + "sha256": "e5f828e06b896723da4b58ca8c780609b8b94bde374a2ffeda1cab143323a335" + }, + { + "bytes": 1894, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "49b35d3fec3960c29b88f974b19e29b2bf487355", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/CLAIM.json", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/CLAIM.json", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "4f0f13fb4cd2b30fb52716df3e7299846dc6d11bbd207f2107bc6b06a9b18b61", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 282091, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "7b46f38ceee3152f753a13157852fdaaf60c31aa", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/FIRST-COLD-REPLAY.json", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/FIRST-COLD-REPLAY.json", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "0b37e1741af786144e1eb78a752bee65424437107c5065181d8a28e05ec30122", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 488, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "ab99b0d3c93b512ca5add19712d2c541e1abf90c", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/LOCAL-INPUTS.json", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/LOCAL-INPUTS.json", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "d3d5d8dd4037112c5952dc91e5d1287a13cf7c26927cd37fd446785e3a07a749", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 125818, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "73fa3ced93981949ad8f2432af840b787d9182c0", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/PAID-CATALOG.jsonl.gz", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/PAID-CATALOG.jsonl.gz", + "payload_sha256": "dc47d96b5b651ba3446d73ac0710152f7de88547a0cb2bbd75706e691b6f0bd6", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "964aa2e28057936825a67872ebe5c6b0abc3228e71a545dda6c1fc11adb983d5", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 14291, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "cc71e69b34835eff261b6073606dd585355e442c", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/PROOF.md", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/PROOF.md", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "e573cbbe6fa5481c0533e773de404e10f4dc7907b5ebfe404bdcd02dcf9844d8", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 8212, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "c70c1b436bbd1130332f737c2efab193674e8672", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/README.md", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/README.md", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "df5a03f28c64e2de5d0b0000d1fe93ced20d99b9e99bbc1fa97432f783848f13", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 13513, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "cf40c4d94f11f1058cfd2d04388dbba72051c1fe", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/SOURCES.json", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/SOURCES.json", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "25fed1fae88cffefc64cdecf8114718f4f4bcff1ef11e69e7556b8f40110e9a6", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 19802, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "7ee84b30892f7354e1c36611f1a5e9b082dc6147", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/SPECIALIZATION.md", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/SPECIALIZATION.md", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 6649, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "761b7c6ba0684f62bc92a2106515ac24ac61fea9", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/TASK.json", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/TASK.json", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "0697507662d6f33633bff5a509122b2c977a82644d758f8282f139e3e24bc8d2", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 1633, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "dfb812803040ae38aafb0c32a522161b6e1414e2", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/VALIDATION.json", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/VALIDATION.json", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "e596d5cbe89e5688b16e0a3dd3b9f2dbe867d5e1be67f0186b2afb6a9d0b234e", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 3583, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "8f4e95ea81bfd210d79ef2312247e92d0ecc7837", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/VERIFY.json", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/VERIFY.json", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "3beda8479a0db2a01732a860b7299e05aecc35235943eacd494f179270f3cfc0", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 142, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "b8e75050ef87853ca5950ff8a9ff9b6b36d4cc3c", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/__init__.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/__init__.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "0af9ca16983533aa5fcb9dbcfbbd6f91c6200c93f69515703c9d340f24fed748", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 9219, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "04d5a7427a55761a25a915d38b3e92e6ba9a14cc", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/all_helpers.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/all_helpers.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "7bc813bbd400f851dcb0137ad31d53e7044f33d3a6cb729c60b070fddab0d1ef", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 3109, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "407d9389ff973ff3900dea8b8ed3439cc8630edc", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/arithmetic.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/arithmetic.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "d67b2f665d4cc9ee49ca20af88a06ac2c971923b6a3a7d2b22bfc19c296ca8b5", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 1371, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "dc76e295f2504df68d26428b3aee2af0527c3302", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/census_controls.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/census_controls.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "35fb546ef060a56539be3ac0eaba9d36405bd10803a7829933bd45699c2873ea", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 3509, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "43daf7c305f1fe62ef99f3920b2cb7ed1d83aac6", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/claim.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/claim.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "86bf973f21b6bb1fe54b5dc83b89264e0b406d0ff1a6f686133c055a9752f39a", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 10669, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "6a6f9373fe33d20e6aa7588ddcf86dde6a33a26a", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/compiler.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/compiler.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "4ec862afb1b0c18cecebec9b04d692be37083da64814da79ad692da96fd62bb5", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 2019, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "80a91d0a31bb64f662a7bed1eca90096e3b2cd69", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/frame.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/frame.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "0ef2fa6794ccdc5895a7b72ff318b1f0b56da933ef829705f98ac6d35ee17bcf", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 11245, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "57e54de4a09f6d4e7aba96856a6c29c4b131a13d", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/helpers.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/helpers.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "a6516b310c41a07db9a83f1444c9ae63295286acdb5a5e3eb561bef46cdb22ce", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 3946, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "f33ac0d326d20b8b8422ded0fdae49acff16fbe9", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/independent_clifford.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/independent_clifford.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "4953e06bd3837fa414372a62f2de57711854353e3a6ac6cea94e4c18ae42ea87", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 9584, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "142f3db7796f9be8d58a0c14db747614f8b8b4ff", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/invoice.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/invoice.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "c0a9f90dfbbacec2d6d065986fad3c2b985361b9601d941ceb8296361311a60a", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 4513, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "ebe89f02c41853dd695d84629954d699f97b0cc9", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/lift.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/lift.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "5ca85c008be87d6b49ba24f7928f3f6cc9558d5342119a5e715abf28326ac9fa", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 3561, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "9ad2be9453dda7cb1f4cb2483a17c190272a9ec8", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/lineage.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/lineage.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "7eb01f6125dd65fad0aa404055b0ed3f0609cce01e3d407f5089e4d5f0ac9dbb", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 6502, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "21abd93594516dad073e40b658c6c37084db2c5f", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/moments.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/moments.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "4de41cb8cff88de815f47b634709ef819f822544a03a66ae35c0bea76e5d94c9", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 10090, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "0545a57fc35f6109cbb3bc06e0934d40777c2890", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/native.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/native.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "49b3560fd1baefd3ac986854844d399f1d180f8fd96724b0c3b2065e98a44523", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 3468, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "39e62cac780b662903582cb5f8684990fa779bb3", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/outer.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/outer.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "196be1bc2329500f2c7c995deaf5a82aecc5e27f0fef7805470cb65d187bb1c0", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 9184, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "b9740fa217e545f67e289ae89c75a2a6b492692e", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/paid.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/paid.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "4c6ff3312440ec3ef0c3e2649a1d2dae0f81ef09a8c65b46866775b56be79907", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 4545, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "d17583cd64d9e8c4d1ab2e61cd557bd0bd5037c9", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/source.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/source.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "7b519f0d9326b630c142630fec55a6a8b03a7b2dee7f4fcb2ca68564c4e04e53", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 13855, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "4fe827ec0ea0b30c8749e8e476b5257fd292c1b1", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/checks/specialization.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/specialization.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "a4baf55b462bff8a1f4b9d49d928ff88018792710a1c36b87f859093969921d6", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree" + ] + }, + { + "bytes": 1133, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "39eaf03f00c5d7e02795112afbd3364386564fca", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/regenerate_paid.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/regenerate_paid.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "3ccd4bc6022f96b863c4611907640a04cecdb0f69ea6c1e9b23c8c88c9eea7e4", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 3687, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "1879aeffa158e5efa74e920fb3d326eb573b1f4e", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/final4610-independent-admission/verify.py", + "path": "capsule/agents/sources/pr5241/research/final4610-independent-admission/verify.py", + "role": "authenticated_historical_phase_reuse_closure", + "sha256": "94ae718a0b5db7f91550c352a4b573edbf62d16aaa925cf250f01b4b8c15edeb", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree" + ] + }, + { + "bytes": 9358, + "commit_object": "custody/git-objects/b1ab650d36f59e5be682a813145b7c67e219e341.commit", + "git_blob": "17901a8af82a17135f8414fa592c63c65d85a785", + "git_mode": "100644", + "origin_commit": "b1ab650d36f59e5be682a813145b7c67e219e341", + "origin_path": "research/eight-owned-relations/README.md", + "path": "capsule/agents/sources/pr5387/research/eight-owned-relations/README.md", + "role": "literal_word_or_author_claim_provenance", + "sha256": "5d5f033c82a8ed8b7e9c3fe3d3f18f559f4f651bb11d0e6a2c916e244777fb99", + "tree_objects": [ + "custody/git-objects/6d2b3a87d39cf33569d1b1f8a7d6177af59bd524.tree", + "custody/git-objects/46dca2d79105e0d899594be581275b404bc812cd.tree", + "custody/git-objects/87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6.tree" + ] + }, + { + "bytes": 14772, + "commit_object": "custody/git-objects/b1ab650d36f59e5be682a813145b7c67e219e341.commit", + "git_blob": "2e13818df03e9fd93b9e13ada8663646ec948572", + "git_mode": "100644", + "origin_commit": "b1ab650d36f59e5be682a813145b7c67e219e341", + "origin_path": "research/eight-owned-relations/RESULT.json", + "path": "capsule/agents/sources/pr5387/research/eight-owned-relations/RESULT.json", + "role": "literal_word_or_author_claim_provenance", + "sha256": "34ad456c1f98f7f8c361d63539ef26d75dad8ffb3444edf29652372acabf1aaf", + "tree_objects": [ + "custody/git-objects/6d2b3a87d39cf33569d1b1f8a7d6177af59bd524.tree", + "custody/git-objects/46dca2d79105e0d899594be581275b404bc812cd.tree", + "custody/git-objects/87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6.tree" + ] + }, + { + "bytes": 3665, + "commit_object": "custody/git-objects/b1ab650d36f59e5be682a813145b7c67e219e341.commit", + "git_blob": "71c57c8a90585da602b8df163d582e7c77949c00", + "git_mode": "100644", + "origin_commit": "b1ab650d36f59e5be682a813145b7c67e219e341", + "origin_path": "research/eight-owned-relations/SOURCES.json", + "path": "capsule/agents/sources/pr5387/research/eight-owned-relations/SOURCES.json", + "role": "literal_word_or_author_claim_provenance", + "sha256": "3b1536861c5b6990966ad5107f3a619f5d9da548f3c4eaa454ec32341e640dd3", + "tree_objects": [ + "custody/git-objects/6d2b3a87d39cf33569d1b1f8a7d6177af59bd524.tree", + "custody/git-objects/46dca2d79105e0d899594be581275b404bc812cd.tree", + "custody/git-objects/87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6.tree" + ] + }, + { + "bytes": 5444, + "commit_object": "custody/git-objects/b1ab650d36f59e5be682a813145b7c67e219e341.commit", + "git_blob": "8b9df431cc81487d1993dc1babb39dd466abfd59", + "git_mode": "100644", + "origin_commit": "b1ab650d36f59e5be682a813145b7c67e219e341", + "origin_path": "research/eight-owned-relations/TASK.json", + "path": "capsule/agents/sources/pr5387/research/eight-owned-relations/TASK.json", + "role": "literal_word_or_author_claim_provenance", + "sha256": "e3d0ee26c8b6a409be30b83aada3a2c3d1b332408a59307733f4299c940ff8b8", + "tree_objects": [ + "custody/git-objects/6d2b3a87d39cf33569d1b1f8a7d6177af59bd524.tree", + "custody/git-objects/46dca2d79105e0d899594be581275b404bc812cd.tree", + "custody/git-objects/87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6.tree" + ] + }, + { + "bytes": 1298, + "commit_object": "custody/git-objects/b1ab650d36f59e5be682a813145b7c67e219e341.commit", + "git_blob": "8098df4c806a6c6e9e2be7253ba4101744dab08d", + "git_mode": "100644", + "origin_commit": "b1ab650d36f59e5be682a813145b7c67e219e341", + "origin_path": "research/eight-owned-relations/VERIFY.json", + "path": "capsule/agents/sources/pr5387/research/eight-owned-relations/VERIFY.json", + "role": "literal_word_or_author_claim_provenance", + "sha256": "1fc62a3afd087aa63f8d993beb1cba944b9b441824cd14e9135e792fcd45bab8", + "tree_objects": [ + "custody/git-objects/6d2b3a87d39cf33569d1b1f8a7d6177af59bd524.tree", + "custody/git-objects/46dca2d79105e0d899594be581275b404bc812cd.tree", + "custody/git-objects/87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6.tree" + ] + }, + { + "bytes": 207423, + "commit_object": "custody/git-objects/b1ab650d36f59e5be682a813145b7c67e219e341.commit", + "git_blob": "c62fcb59643f87919208100517a2fbc4b57cb7d7", + "git_mode": "100644", + "origin_commit": "b1ab650d36f59e5be682a813145b7c67e219e341", + "origin_path": "research/eight-owned-relations/WORD.json.gz", + "path": "capsule/agents/sources/pr5387/research/eight-owned-relations/WORD.json.gz", + "payload_sha256": "9aa0d7112b4e13f1aa13a93dab0af6f4435ffe99b842aad841685becdafee492", + "role": "literal_word_or_author_claim_provenance", + "sha256": "6412632c28e265597fb088087048091d81c19500fb28a0c9c9d2a48f61b8665b", + "tree_objects": [ + "custody/git-objects/6d2b3a87d39cf33569d1b1f8a7d6177af59bd524.tree", + "custody/git-objects/46dca2d79105e0d899594be581275b404bc812cd.tree", + "custody/git-objects/87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6.tree" + ] + }, + { + "bytes": 5495, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "b288ae44032fd84dd5564243422836cbcd29835e", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "certificates/selected-result.json", + "path": "capsule/repository/certificates/selected-result.json", + "role": "runtime_input", + "sha256": "f9ed52bb642cd1e1486cf2743557ac5fa23cf1514a3277d786a644e39a565038", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/92bd281a274191242f183544f5ebab24b7f61127.tree" + ] + }, + { + "bytes": 8277, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "bf5ff049da5fa07f9bf71176dfafe3343b7ac93d", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md", + "path": "capsule/repository/docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md", + "role": "runtime_input", + "sha256": "b84f833e3072cbab372fbda2ece98fbc031c15e590cf73003ddea35a5222e148", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/258aaa876ecb530c4c173c8e3ef93ccf87c81673.tree", + "custody/git-objects/e9c70b9927d6e9233633e4e88108f831e7c5c5d9.tree", + "custody/git-objects/02fdbbad293e674b3e2300ee89b37ed4dc623f6f.tree", + "custody/git-objects/ca6f51bb3b6474cfa4111ebafa02b1913a807446.tree" + ] + }, + { + "bytes": 9907, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "69c337a7704ce589798269ab4b8606189c070c4e", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/free-word-tensor-lift-audit/PROOF.md", + "path": "capsule/repository/research/free-word-tensor-lift-audit/PROOF.md", + "role": "runtime_input", + "sha256": "cc8ad3698a673fb225419a3636a39aa99a66c7a0676f12e329b1e76564fa1459", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/8bed1ecc75af648c4b5fbf888b902e89ea94de00.tree" + ] + }, + { + "bytes": 57924, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "49a2f0675819f9deeea27ed77be2c2b6ff2e87e5", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/joint-helper-lattice/CONTROLLER.json", + "path": "capsule/repository/research/joint-helper-lattice/CONTROLLER.json", + "role": "runtime_input", + "sha256": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/93c3da5da0a527baf42dbbe76e7af010384def87.tree" + ] + }, + { + "bytes": 16479, + "commit_object": "custody/git-objects/4bd6efa51a495a7c7b7754915cf0244e7e60969e.commit", + "git_blob": "d0593a46e89eb63a533968cd6bc1d2a129f3c22e", + "git_mode": "100644", + "origin_commit": "4bd6efa51a495a7c7b7754915cf0244e7e60969e", + "origin_path": "research/kappa-joint-relations-20261023/README.md", + "path": "capsule/repository/research/kappa-joint-relations-20261023/README.md", + "role": "literal_word_or_author_claim_provenance", + "sha256": "899027b74219ece1832d711e27def50eb49994cd28ede4fedcdd0bd0f2574c64", + "tree_objects": [ + "custody/git-objects/7c8818178b05733b5d09a6decc34d53b84fdc213.tree", + "custody/git-objects/b3abe1a63f80b453a11823d70c836b9199e7c556.tree", + "custody/git-objects/0994002341ec20dbea467f4c19fb8d4300cb88cc.tree" + ] + }, + { + "bytes": 22334, + "commit_object": "custody/git-objects/4bd6efa51a495a7c7b7754915cf0244e7e60969e.commit", + "git_blob": "b6c9cd0da1889ed92f3f1066127a203246f303d8", + "git_mode": "100644", + "origin_commit": "4bd6efa51a495a7c7b7754915cf0244e7e60969e", + "origin_path": "research/kappa-joint-relations-20261023/RESULT.json", + "path": "capsule/repository/research/kappa-joint-relations-20261023/RESULT.json", + "role": "literal_word_or_author_claim_provenance", + "sha256": "d6a99bd75c6b7a2146b0fc4cfa038890aaf1d4adcdef42d767fdb40b687e61aa", + "tree_objects": [ + "custody/git-objects/7c8818178b05733b5d09a6decc34d53b84fdc213.tree", + "custody/git-objects/b3abe1a63f80b453a11823d70c836b9199e7c556.tree", + "custody/git-objects/0994002341ec20dbea467f4c19fb8d4300cb88cc.tree" + ] + }, + { + "bytes": 3665, + "commit_object": "custody/git-objects/4bd6efa51a495a7c7b7754915cf0244e7e60969e.commit", + "git_blob": "71c57c8a90585da602b8df163d582e7c77949c00", + "git_mode": "100644", + "origin_commit": "4bd6efa51a495a7c7b7754915cf0244e7e60969e", + "origin_path": "research/kappa-joint-relations-20261023/SOURCES.json", + "path": "capsule/repository/research/kappa-joint-relations-20261023/SOURCES.json", + "role": "literal_word_or_author_claim_provenance", + "sha256": "3b1536861c5b6990966ad5107f3a619f5d9da548f3c4eaa454ec32341e640dd3", + "tree_objects": [ + "custody/git-objects/7c8818178b05733b5d09a6decc34d53b84fdc213.tree", + "custody/git-objects/b3abe1a63f80b453a11823d70c836b9199e7c556.tree", + "custody/git-objects/0994002341ec20dbea467f4c19fb8d4300cb88cc.tree" + ] + }, + { + "bytes": 5801, + "commit_object": "custody/git-objects/4bd6efa51a495a7c7b7754915cf0244e7e60969e.commit", + "git_blob": "5b57a9e8233575c97042b774a8ee3881e6ece6f7", + "git_mode": "100644", + "origin_commit": "4bd6efa51a495a7c7b7754915cf0244e7e60969e", + "origin_path": "research/kappa-joint-relations-20261023/TASK.json", + "path": "capsule/repository/research/kappa-joint-relations-20261023/TASK.json", + "role": "literal_word_or_author_claim_provenance", + "sha256": "4d536a9bd6162b64ecf7bba20bec35fa0ca8fe61abf8e1404cd010b58de07a3d", + "tree_objects": [ + "custody/git-objects/7c8818178b05733b5d09a6decc34d53b84fdc213.tree", + "custody/git-objects/b3abe1a63f80b453a11823d70c836b9199e7c556.tree", + "custody/git-objects/0994002341ec20dbea467f4c19fb8d4300cb88cc.tree" + ] + }, + { + "bytes": 1298, + "commit_object": "custody/git-objects/4bd6efa51a495a7c7b7754915cf0244e7e60969e.commit", + "git_blob": "8098df4c806a6c6e9e2be7253ba4101744dab08d", + "git_mode": "100644", + "origin_commit": "4bd6efa51a495a7c7b7754915cf0244e7e60969e", + "origin_path": "research/kappa-joint-relations-20261023/VERIFY.json", + "path": "capsule/repository/research/kappa-joint-relations-20261023/VERIFY.json", + "role": "literal_word_or_author_claim_provenance", + "sha256": "1fc62a3afd087aa63f8d993beb1cba944b9b441824cd14e9135e792fcd45bab8", + "tree_objects": [ + "custody/git-objects/7c8818178b05733b5d09a6decc34d53b84fdc213.tree", + "custody/git-objects/b3abe1a63f80b453a11823d70c836b9199e7c556.tree", + "custody/git-objects/0994002341ec20dbea467f4c19fb8d4300cb88cc.tree" + ] + }, + { + "bytes": 207650, + "commit_object": "custody/git-objects/4bd6efa51a495a7c7b7754915cf0244e7e60969e.commit", + "git_blob": "a4a58afce144541603385e9bf4e0695c54eade7c", + "git_mode": "100644", + "origin_commit": "4bd6efa51a495a7c7b7754915cf0244e7e60969e", + "origin_path": "research/kappa-joint-relations-20261023/WORD.json.gz", + "path": "capsule/repository/research/kappa-joint-relations-20261023/WORD.json.gz", + "payload_sha256": "2aee5e997df99726fc763e510d9cb69fbe4f86114dc8d2cd33ad26c6c462a21d", + "role": "literal_word_or_author_claim_provenance", + "sha256": "7883ba0faefc96505bb61ca7312d588fa22dfe2164050c817c1718b8fa28693a", + "tree_objects": [ + "custody/git-objects/7c8818178b05733b5d09a6decc34d53b84fdc213.tree", + "custody/git-objects/b3abe1a63f80b453a11823d70c836b9199e7c556.tree", + "custody/git-objects/0994002341ec20dbea467f4c19fb8d4300cb88cc.tree" + ] + }, + { + "bytes": 207673, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "path": "capsule/repository/research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "payload_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd", + "role": "runtime_input", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/db06c76a46083783b675e5a5ce418c52a400d350.tree" + ] + }, + { + "bytes": 23356, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "ac77b78547d6dbf2e6bd102e1047c5b16c1bca88", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "path": "capsule/repository/research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "payload_sha256": "bc9de6d11fc3d5fb2141a1658785f2093ea1b735d34414ed15749df7d731b34e", + "role": "runtime_input", + "sha256": "6eae66ed3cfa8a1533e89b9660a57276908e6646640a12f8b1e3489f4ea1354b", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/db06c76a46083783b675e5a5ce418c52a400d350.tree" + ] + }, + { + "bytes": 15898, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md", + "path": "capsule/repository/research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md", + "role": "runtime_input", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/3e58974508669b0b52f53c56371b5f9c253ece4b.tree", + "custody/git-objects/74e7c585a7f3c853a2927a5028db379ac86b4a34.tree", + "custody/git-objects/df0da6ab4433542c03f089e50eeaabacb89fa6a4.tree", + "custody/git-objects/2f0243de4ff0d29f087894edbf247327c5bae8e9.tree", + "custody/git-objects/d520959c0a8af33980dff881ed2cf6c4703bb338.tree" + ] + }, + { + "bytes": 15369, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "9917ac5543608047fd368e5e75f0851310f53584", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md", + "path": "capsule/repository/research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md", + "role": "runtime_input", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/3e58974508669b0b52f53c56371b5f9c253ece4b.tree", + "custody/git-objects/74e7c585a7f3c853a2927a5028db379ac86b4a34.tree", + "custody/git-objects/df0da6ab4433542c03f089e50eeaabacb89fa6a4.tree", + "custody/git-objects/2f0243de4ff0d29f087894edbf247327c5bae8e9.tree", + "custody/git-objects/308866b397e4296d95f7a55ad38313ec11c69f3b.tree" + ] + }, + { + "bytes": 10237, + "commit_object": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "git_blob": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "git_mode": "100644", + "origin_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "origin_path": "research/query-thinned-controllers/RESULT.json", + "path": "capsule/repository/research/query-thinned-controllers/RESULT.json", + "role": "runtime_input", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "tree_objects": [ + "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "custody/git-objects/368780035287bad0b8e9cd1a9f7da73223dfa456.tree" + ] + }, + { + "bytes": 341, + "path": "custody/CANDIDATE-COMMIT.raw", + "role": "source_custody_observation", + "sha256": "d1a49634694ac9f77010440e9da8bbcaec5abfac9c7c2e7ec142b93008b27039" + }, + { + "bytes": 2411, + "path": "custody/CANDIDATE-FILES.json", + "role": "source_custody_observation", + "sha256": "e70ed297be022d50471506049c3db674c2d539712f8327b76f3096cd0097f758" + }, + { + "bytes": 317, + "path": "custody/CANONICAL-COMMIT.raw", + "role": "source_custody_observation", + "sha256": "8fc74b8fe0be2ef8075db0f654579721bcaf73fa7f1744cb23fe086edc553716" + }, + { + "bytes": 7977, + "path": "custody/PR5241-INVENTORY.json", + "role": "source_custody_observation", + "sha256": "82656ff69e81a0e466d4f4bd65c5dfe74b061a63b3a51d8927e5fbc20eab6350" + }, + { + "bytes": 7613, + "path": "custody/PR5241-PHASE-REUSE.json", + "role": "source_custody_observation", + "sha256": "98a5fa3cee0aeea101676f0a05d045b8c4f7a953273456b798fd9495c24cd51b" + }, + { + "bytes": 313, + "path": "custody/PR5387-COMMIT.raw", + "role": "source_custody_observation", + "sha256": "73c5b337305a1122b7d474f5ec1b74205bc169f51e34868b5cb40706a5263e00" + }, + { + "bytes": 2981, + "path": "custody/PR5387-INVENTORY.json", + "role": "source_custody_observation", + "sha256": "52bff5a1fe9d1bd8b1621b8441da4ad91c768d2b753c581301ac9cb799e94c37" + }, + { + "bytes": 4651, + "path": "custody/SOURCE-HISTORY.json", + "role": "source_custody_observation", + "sha256": "8b1fa9c7328e0e510f945b5f59a1d98fdab5e9645e634eab01d358af9569744d" + }, + { + "bytes": 9907, + "git_object_sha1": "02fdbbad293e674b3e2300ee89b37ed4dc623f6f", + "git_object_type": "tree", + "path": "custody/git-objects/02fdbbad293e674b3e2300ee89b37ed4dc623f6f.tree", + "role": "offline_git_membership_proof", + "sha256": "9f5e14586bed06cd212709f9c6152e61417f4607a8905c941637fc68a79e857f" + }, + { + "bytes": 382, + "git_object_sha1": "0994002341ec20dbea467f4c19fb8d4300cb88cc", + "git_object_type": "tree", + "path": "custody/git-objects/0994002341ec20dbea467f4c19fb8d4300cb88cc.tree", + "role": "offline_git_membership_proof", + "sha256": "81ca588d7a603cc9845120e32ca2906322c8fda59335c4085b605b397e687c2f" + }, + { + "bytes": 575, + "git_object_sha1": "19b1abce68e32239bd8ad6abf979584eb93ad269", + "git_object_type": "tree", + "path": "custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "role": "offline_git_membership_proof", + "sha256": "b86777926b23d06339e922e520bb9d2aaa7eed869025b290ce7d8c046e013979" + }, + { + "bytes": 317, + "git_object_sha1": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "git_object_type": "commit", + "path": "custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "role": "offline_git_membership_proof", + "sha256": "8fc74b8fe0be2ef8075db0f654579721bcaf73fa7f1744cb23fe086edc553716" + }, + { + "bytes": 639, + "git_object_sha1": "258aaa876ecb530c4c173c8e3ef93ccf87c81673", + "git_object_type": "tree", + "path": "custody/git-objects/258aaa876ecb530c4c173c8e3ef93ccf87c81673.tree", + "role": "offline_git_membership_proof", + "sha256": "32b88db989aaae9adf124ed59a8f391b8c7cc55175b3f191937c6d422b1e036a" + }, + { + "bytes": 181, + "git_object_sha1": "2f0243de4ff0d29f087894edbf247327c5bae8e9", + "git_object_type": "tree", + "path": "custody/git-objects/2f0243de4ff0d29f087894edbf247327c5bae8e9.tree", + "role": "offline_git_membership_proof", + "sha256": "2ea587bae76140099f73e6042d0b4cc524ccebf5f87acb1d63efeb2a937912ce" + }, + { + "bytes": 707, + "git_object_sha1": "2f781f177482200db6432209f21d8e7d662fbba3", + "git_object_type": "tree", + "path": "custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree", + "role": "offline_git_membership_proof", + "sha256": "9bb093aa1ad199128bce47b6f958cd19db7df0b8fce36070b184d4e9eeff2341" + }, + { + "bytes": 196, + "git_object_sha1": "308866b397e4296d95f7a55ad38313ec11c69f3b", + "git_object_type": "tree", + "path": "custody/git-objects/308866b397e4296d95f7a55ad38313ec11c69f3b.tree", + "role": "offline_git_membership_proof", + "sha256": "26330485f86d462abe32df5b51f7db47ae295dfba576da7e1b5d85345f4f9b49" + }, + { + "bytes": 445, + "git_object_sha1": "368780035287bad0b8e9cd1a9f7da73223dfa456", + "git_object_type": "tree", + "path": "custody/git-objects/368780035287bad0b8e9cd1a9f7da73223dfa456.tree", + "role": "offline_git_membership_proof", + "sha256": "ab3e8e7e9ac2eb4668ad34f9b2f31cec0303f2de62162728128be1cb02c4f78a" + }, + { + "bytes": 797, + "git_object_sha1": "3e58974508669b0b52f53c56371b5f9c253ece4b", + "git_object_type": "tree", + "path": "custody/git-objects/3e58974508669b0b52f53c56371b5f9c253ece4b.tree", + "role": "offline_git_membership_proof", + "sha256": "4785a00e3abd23489c2368faf23ff1a6d16a9713b8e08bd36c47e5af99022645" + }, + { + "bytes": 219666, + "git_object_sha1": "46dca2d79105e0d899594be581275b404bc812cd", + "git_object_type": "tree", + "path": "custody/git-objects/46dca2d79105e0d899594be581275b404bc812cd.tree", + "role": "offline_git_membership_proof", + "sha256": "a2da6776db02103b2b825d10c1d2ccb47f17589f1f44975d8770c1942442d354" + }, + { + "bytes": 341, + "git_object_sha1": "4bd6efa51a495a7c7b7754915cf0244e7e60969e", + "git_object_type": "commit", + "path": "custody/git-objects/4bd6efa51a495a7c7b7754915cf0244e7e60969e.commit", + "role": "offline_git_membership_proof", + "sha256": "d1a49634694ac9f77010440e9da8bbcaec5abfac9c7c2e7ec142b93008b27039" + }, + { + "bytes": 969, + "git_object_sha1": "6d2b3a87d39cf33569d1b1f8a7d6177af59bd524", + "git_object_type": "tree", + "path": "custody/git-objects/6d2b3a87d39cf33569d1b1f8a7d6177af59bd524.tree", + "role": "offline_git_membership_proof", + "sha256": "e4410ed702d2606f40d86389d7639f20ace1dbae3a8b66ea8eb0f1b04a85c473" + }, + { + "bytes": 35, + "git_object_sha1": "74e7c585a7f3c853a2927a5028db379ac86b4a34", + "git_object_type": "tree", + "path": "custody/git-objects/74e7c585a7f3c853a2927a5028db379ac86b4a34.tree", + "role": "offline_git_membership_proof", + "sha256": "ca82587f0e0a51caaf7a942cda7448f75e339bd39571f256f14d24a0f76458f1" + }, + { + "bytes": 969, + "git_object_sha1": "7c8818178b05733b5d09a6decc34d53b84fdc213", + "git_object_type": "tree", + "path": "custody/git-objects/7c8818178b05733b5d09a6decc34d53b84fdc213.tree", + "role": "offline_git_membership_proof", + "sha256": "8c929ae6900a027b095d7446ea2813f8f5eff20706966d211a6cabd104b793d7" + }, + { + "bytes": 477, + "git_object_sha1": "87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6", + "git_object_type": "tree", + "path": "custody/git-objects/87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6.tree", + "role": "offline_git_membership_proof", + "sha256": "b2751ffc200196951f304e4fb45f000d68f922a353931925abebecc15e4cdf0b" + }, + { + "bytes": 663, + "git_object_sha1": "8bed1ecc75af648c4b5fbf888b902e89ea94de00", + "git_object_type": "tree", + "path": "custody/git-objects/8bed1ecc75af648c4b5fbf888b902e89ea94de00.tree", + "role": "offline_git_membership_proof", + "sha256": "29c18dc1e2792ca110b97790a9153826994ab4e2af59cf9f2e8e1ec8dd04bb86" + }, + { + "bytes": 6799, + "git_object_sha1": "92bd281a274191242f183544f5ebab24b7f61127", + "git_object_type": "tree", + "path": "custody/git-objects/92bd281a274191242f183544f5ebab24b7f61127.tree", + "role": "offline_git_membership_proof", + "sha256": "9925ce9ff27d85508b1493dad6f33b38a03350bb6985f17b55f58ecf0966313b" + }, + { + "bytes": 599, + "git_object_sha1": "93c3da5da0a527baf42dbbe76e7af010384def87", + "git_object_type": "tree", + "path": "custody/git-objects/93c3da5da0a527baf42dbbe76e7af010384def87.tree", + "role": "offline_git_membership_proof", + "sha256": "3764da0e59c2829d0e8b560feac19e71051d92411598a8abd46fa95b6f8fd7b9" + }, + { + "bytes": 313, + "git_object_sha1": "b1ab650d36f59e5be682a813145b7c67e219e341", + "git_object_type": "commit", + "path": "custody/git-objects/b1ab650d36f59e5be682a813145b7c67e219e341.commit", + "role": "offline_git_membership_proof", + "sha256": "73c5b337305a1122b7d474f5ec1b74205bc169f51e34868b5cb40706a5263e00" + }, + { + "bytes": 219675, + "git_object_sha1": "b3abe1a63f80b453a11823d70c836b9199e7c556", + "git_object_type": "tree", + "path": "custody/git-objects/b3abe1a63f80b453a11823d70c836b9199e7c556.tree", + "role": "offline_git_membership_proof", + "sha256": "0df25acffcf38c7c6690547dc0ab38c2cdc15d6593046ffdca8b575484c13531" + }, + { + "bytes": 969, + "git_object_sha1": "bfb420045d2bc04dd026b5020aea84d547873ef4", + "git_object_type": "tree", + "path": "custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "role": "offline_git_membership_proof", + "sha256": "aee24b16e5fb24053b230ed4a9b375251da522404f93402e7deacceeb9289b4c" + }, + { + "bytes": 219618, + "git_object_sha1": "c211d4eb07730865bffd69a35a85a0642acc333d", + "git_object_type": "tree", + "path": "custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "role": "offline_git_membership_proof", + "sha256": "dbfd9e35527f18d2342c82bccd407d99d7222e6ebd8f0db4cdb469b05b745d49" + }, + { + "bytes": 526, + "git_object_sha1": "ca6f51bb3b6474cfa4111ebafa02b1913a807446", + "git_object_type": "tree", + "path": "custody/git-objects/ca6f51bb3b6474cfa4111ebafa02b1913a807446.tree", + "role": "offline_git_membership_proof", + "sha256": "10d55a065b955681775731817a9619242ea69137125b88be1be2fd8b130e005d" + }, + { + "bytes": 208, + "git_object_sha1": "d520959c0a8af33980dff881ed2cf6c4703bb338", + "git_object_type": "tree", + "path": "custody/git-objects/d520959c0a8af33980dff881ed2cf6c4703bb338.tree", + "role": "offline_git_membership_proof", + "sha256": "be37540cce0416977753211ea760091f909b5300d7d7f8172ebfdb2905396416" + }, + { + "bytes": 1307, + "git_object_sha1": "db06c76a46083783b675e5a5ce418c52a400d350", + "git_object_type": "tree", + "path": "custody/git-objects/db06c76a46083783b675e5a5ce418c52a400d350.tree", + "role": "offline_git_membership_proof", + "sha256": "727b0999f3afd17b8756efdc2eec96e5d76f9fcab111db9031814b7fbfbd0d54" + }, + { + "bytes": 93, + "git_object_sha1": "df0da6ab4433542c03f089e50eeaabacb89fa6a4", + "git_object_type": "tree", + "path": "custody/git-objects/df0da6ab4433542c03f089e50eeaabacb89fa6a4.tree", + "role": "offline_git_membership_proof", + "sha256": "bbdcd341a480357712d3b4e4187a861c76a680be7334bdb80c4895f959806b62" + }, + { + "bytes": 14144, + "git_object_sha1": "e9c70b9927d6e9233633e4e88108f831e7c5c5d9", + "git_object_type": "tree", + "path": "custody/git-objects/e9c70b9927d6e9233633e4e88108f831e7c5c5d9.tree", + "role": "offline_git_membership_proof", + "sha256": "22369b51a2b61cb47fb424394c7a9fac4f8ef81a1e29f4e9a6805892dbbba7e9" + }, + { + "bytes": 5586, + "path": "receipt_guard.py", + "role": "bootstrap_helper_or_claim_and_command_contract", + "sha256": "67336a39205247ca3ad1639e29f2dfcdc334f8e8f68cc173e87cd58f80d6adda" + }, + { + "bytes": 11581, + "path": "reports/algebra/REPORT.md", + "role": "independent_proof_and_limits", + "sha256": "4a56a57c6ef5191c57b82c145fc253661cf26fb2555325b414fca6a954df3df2" + }, + { + "bytes": 2297, + "path": "reports/algebra/RUN-REQUEST.json", + "role": "independent_proof_and_limits", + "sha256": "81e5dfaf34f43e4509ce094ca2f31bfaf575b75af419c11e50e157da109e20d8" + }, + { + "bytes": 711, + "path": "reports/applicability/FOUNDATION-SOURCES.json", + "role": "independent_proof_and_limits", + "sha256": "217e64f025f1c4d2a985703eace4ac60bb8f9951453b5e613ba41cc0790945bf" + }, + { + "bytes": 17224, + "path": "reports/applicability/REPORT.md", + "role": "independent_proof_and_limits", + "sha256": "500080de09e17619d7e9b34ca910fc242fa6691d377d5af9f7fa3de8b529832b" + }, + { + "bytes": 8546, + "path": "reports/falsifier/CODE-AUDIT.md", + "role": "independent_proof_and_limits", + "sha256": "6ab315f9ac420aa23cc36c1eca30efdc74e5362ab232ff5b78d84ede89b3c209" + }, + { + "bytes": 2274, + "path": "reports/falsifier/EARLY-FINDINGS.md", + "role": "independent_proof_and_limits", + "sha256": "97712b703aec926caac82351047a7b64656df6d8fc2a30cc8cf023a1d034ae7c" + }, + { + "bytes": 960, + "path": "reports/falsifier/RUN-REQUEST.json", + "role": "independent_proof_and_limits", + "sha256": "e691a9a645b2f1c07e8c874ece22673c8405d184dd61ee62729e0500ddeb56b9" + }, + { + "bytes": 533, + "path": "reports/falsifier/SAME-FRAME-CONTROL.json", + "role": "independent_proof_and_limits", + "sha256": "ade262c1506f55baf9221112788e430a3058b0d5ecb35e2cc91113f1c03a238a" + }, + { + "bytes": 8620, + "path": "reports/outer/REPORT.md", + "role": "independent_proof_and_limits", + "sha256": "5131afd92d8feb8e3578d724cb7f45a7deea9ef327465af741e02ee00c0f0045" + }, + { + "bytes": 5593, + "path": "reports/outer/SOURCES.json", + "role": "independent_proof_and_limits", + "sha256": "3de5130c6494cf0c644ec7cc06fec8255ffd6a7d2f7049a1ad758d81bbfe1503" + }, + { + "bytes": 14887, + "path": "reports/ownership/REPORT.md", + "role": "independent_proof_and_limits", + "sha256": "80bb8d3a6e7fbc224049baa95b38a49f8fb31aa2e6b320326a965efb53a848fc" + }, + { + "bytes": 1839, + "path": "reports/ownership/RUN-REQUEST.json", + "role": "independent_proof_and_limits", + "sha256": "15208fac92c19b734b04e2f54b5dfd4bc39e72447a804a5ec30543095974d85f" + }, + { + "bytes": 8838, + "path": "reports/prices/REPORT.md", + "role": "independent_proof_and_limits", + "sha256": "17e2097d2ebe908700e7d4677733755e4002dc05570f0584f45184456628b165" + }, + { + "bytes": 8408, + "path": "source_guard.py", + "role": "bootstrap_helper_or_claim_and_command_contract", + "sha256": "9ef48a8b1fad7e391c8b585691d741c3c4642745aed36e00b5b65b0cf4cdac12" + } + ], + "schema_version": 1, + "selected_phase_receipt": "capsule/agents/sources/pr5241/research/final4610-independent-admission/FIRST-COLD-REPLAY.json", + "selected_record": "capsule/repository/certificates/selected-result.json", + "source_word": "capsule/repository/research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "working_source_policy": "No runtime Git reader or object fallback; source custody occurs once during preparation and all replay data are actual authenticated working-file bytes." +} diff --git a/research/joint-relations-independent-validation/SOURCES.json b/research/joint-relations-independent-validation/SOURCES.json new file mode 100644 index 0000000000..5559e48849 --- /dev/null +++ b/research/joint-relations-independent-validation/SOURCES.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "base_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b288ae44032fd84dd5564243422836cbcd29835e", + "sha256": "f9ed52bb642cd1e1486cf2743557ac5fa23cf1514a3277d786a644e39a565038" + } + ], + "vendored_source_bindings": "SOURCE-BINDINGS.json", + "source_binding_policy": "Every actual runtime input is read from working bytes. Git provenance authenticates history; it never supplies a replacement for missing or mutated working inputs." +} diff --git a/research/joint-relations-independent-validation/TASK.json b/research/joint-relations-independent-validation/TASK.json new file mode 100644 index 0000000000..2427c5c9e4 --- /dev/null +++ b/research/joint-relations-independent-validation/TASK.json @@ -0,0 +1,73 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. 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", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "refined", + "actual_scope": "Independent complete same-premise validation of the two literal eight-relation words in PR5383 and PR5387; preserve separate algebra, ownership and compiler bindings.", + "scope_change_reason": "The construction authors requested independent review. A matched economic profile does not identify the changed eighth relation or its retained-domain proof.", + "bottleneck_link": "https://github.com/CrocSwap/integer-mult-bounds/pull/5383", + "budget_minutes": 240, + "stop_rule": "Freeze complete evidence and package only after the root scientific and acceptance gates pass; otherwise publish an explicit unresolved scope.", + "outcome": "completed", + "evidence": "PROOF.md; byte-identical six independent scientific engines; 111 offline-bound working-input files; root first normal cold replay passed all eight fresh commands. Final normal/optimized registered replay, committed-byte/export transport and acceptance remain root gates.", + "author": "Chris R / Clear1nsight", + "ai_assistance": "Substantial OpenAI Codex assistance in independent code, mathematical review, source custody, verification and packaging.", + "open_questions": [ + { + "question": "Can the five retained transfer premises be replaced by independently checked all-size physical and analytic proofs?", + "why_it_matters": "This package is a same-premise conditional validation; finite source identities do not close the full multiplication theorem.", + "first_step": "Follow each premise and exact retained proposition in PROOF.md and the source-pinned applicability audit.", + "blocked_by": "The retained framework includes unrestricted native, compiler, precision/tape and analytic contracts." + }, + { + "question": "Can a changed relation system improve this complete paid/productive profile?", + "why_it_matters": "The fixed-profile ceiling does not establish a global optimum or a new native construction.", + "first_step": "Refresh live claims, derive literal source identities and price every surrendered target and owned bank.", + "blocked_by": "All eight backward center jobs are already removed in this profile." + } + ], + "publication_transport_status": "Pending final registered normal/optimized, committed-byte/source-history/export and root acceptance gates." +} diff --git a/research/joint-relations-independent-validation/VERIFY.json b/research/joint-relations-independent-validation/VERIFY.json new file mode 100644 index 0000000000..32866f81c3 --- /dev/null +++ b/research/joint-relations-independent-validation/VERIFY.json @@ -0,0 +1,142 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Fresh independent word identities, ownership, event invoice, directed prices, applicability and outer arithmetic, conditional on five explicit retained premises." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Same replay with assertion optimization explicitly propagated to child engines; all scientific guards remain active." + } + ], + "input_inventory": "SOURCE-BINDINGS.json binds all package-local working inputs. The registered runner triggers on any package change; no runtime input lies outside this self-contained package.", + "package_local_inputs": [ + "research/joint-relations-independent-validation/CLAIMS.json", + "research/joint-relations-independent-validation/COMMANDS.json", + "research/joint-relations-independent-validation/capsule/agents/algebra/check_joint.py", + "research/joint-relations-independent-validation/capsule/agents/applicability/check_applicability.py", + "research/joint-relations-independent-validation/capsule/agents/falsifier/check_mutants.py", + "research/joint-relations-independent-validation/capsule/agents/outer/check_outer.py", + "research/joint-relations-independent-validation/capsule/agents/ownership/check.py", + "research/joint-relations-independent-validation/capsule/agents/prices/check_prices.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/CLAIM.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/FIRST-COLD-REPLAY.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/LOCAL-INPUTS.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/PAID-CATALOG.jsonl.gz", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/PROOF.md", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/README.md", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/SOURCES.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/SPECIALIZATION.md", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/TASK.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/VALIDATION.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/VERIFY.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/__init__.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/all_helpers.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/arithmetic.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/census_controls.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/claim.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/compiler.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/frame.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/helpers.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/independent_clifford.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/invoice.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/lift.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/lineage.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/moments.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/native.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/outer.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/paid.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/source.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/checks/specialization.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/regenerate_paid.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5241/research/final4610-independent-admission/verify.py", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5387/research/eight-owned-relations/README.md", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5387/research/eight-owned-relations/RESULT.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5387/research/eight-owned-relations/SOURCES.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5387/research/eight-owned-relations/TASK.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5387/research/eight-owned-relations/VERIFY.json", + "research/joint-relations-independent-validation/capsule/agents/sources/pr5387/research/eight-owned-relations/WORD.json.gz", + "research/joint-relations-independent-validation/capsule/repository/certificates/selected-result.json", + "research/joint-relations-independent-validation/capsule/repository/docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md", + "research/joint-relations-independent-validation/capsule/repository/research/free-word-tensor-lift-audit/PROOF.md", + "research/joint-relations-independent-validation/capsule/repository/research/joint-helper-lattice/CONTROLLER.json", + "research/joint-relations-independent-validation/capsule/repository/research/kappa-joint-relations-20261023/README.md", + "research/joint-relations-independent-validation/capsule/repository/research/kappa-joint-relations-20261023/RESULT.json", + "research/joint-relations-independent-validation/capsule/repository/research/kappa-joint-relations-20261023/SOURCES.json", + "research/joint-relations-independent-validation/capsule/repository/research/kappa-joint-relations-20261023/TASK.json", + "research/joint-relations-independent-validation/capsule/repository/research/kappa-joint-relations-20261023/VERIFY.json", + "research/joint-relations-independent-validation/capsule/repository/research/kappa-joint-relations-20261023/WORD.json.gz", + "research/joint-relations-independent-validation/capsule/repository/research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "research/joint-relations-independent-validation/capsule/repository/research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "research/joint-relations-independent-validation/capsule/repository/research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md", + "research/joint-relations-independent-validation/capsule/repository/research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md", + "research/joint-relations-independent-validation/capsule/repository/research/query-thinned-controllers/RESULT.json", + "research/joint-relations-independent-validation/custody/CANDIDATE-COMMIT.raw", + "research/joint-relations-independent-validation/custody/CANDIDATE-FILES.json", + "research/joint-relations-independent-validation/custody/CANONICAL-COMMIT.raw", + "research/joint-relations-independent-validation/custody/PR5241-INVENTORY.json", + "research/joint-relations-independent-validation/custody/PR5241-PHASE-REUSE.json", + "research/joint-relations-independent-validation/custody/PR5387-COMMIT.raw", + "research/joint-relations-independent-validation/custody/PR5387-INVENTORY.json", + "research/joint-relations-independent-validation/custody/SOURCE-HISTORY.json", + "research/joint-relations-independent-validation/custody/git-objects/02fdbbad293e674b3e2300ee89b37ed4dc623f6f.tree", + "research/joint-relations-independent-validation/custody/git-objects/0994002341ec20dbea467f4c19fb8d4300cb88cc.tree", + "research/joint-relations-independent-validation/custody/git-objects/19b1abce68e32239bd8ad6abf979584eb93ad269.tree", + "research/joint-relations-independent-validation/custody/git-objects/1ec1119972c9aefe42525172d07b332fcff81cb4.commit", + "research/joint-relations-independent-validation/custody/git-objects/258aaa876ecb530c4c173c8e3ef93ccf87c81673.tree", + "research/joint-relations-independent-validation/custody/git-objects/2f0243de4ff0d29f087894edbf247327c5bae8e9.tree", + "research/joint-relations-independent-validation/custody/git-objects/2f781f177482200db6432209f21d8e7d662fbba3.tree", + "research/joint-relations-independent-validation/custody/git-objects/308866b397e4296d95f7a55ad38313ec11c69f3b.tree", + "research/joint-relations-independent-validation/custody/git-objects/368780035287bad0b8e9cd1a9f7da73223dfa456.tree", + "research/joint-relations-independent-validation/custody/git-objects/3e58974508669b0b52f53c56371b5f9c253ece4b.tree", + "research/joint-relations-independent-validation/custody/git-objects/46dca2d79105e0d899594be581275b404bc812cd.tree", + "research/joint-relations-independent-validation/custody/git-objects/4bd6efa51a495a7c7b7754915cf0244e7e60969e.commit", + "research/joint-relations-independent-validation/custody/git-objects/6d2b3a87d39cf33569d1b1f8a7d6177af59bd524.tree", + "research/joint-relations-independent-validation/custody/git-objects/74e7c585a7f3c853a2927a5028db379ac86b4a34.tree", + "research/joint-relations-independent-validation/custody/git-objects/7c8818178b05733b5d09a6decc34d53b84fdc213.tree", + "research/joint-relations-independent-validation/custody/git-objects/87cbbbc8ccf824c7a3ceadac4f7ca3b041fb8ab6.tree", + "research/joint-relations-independent-validation/custody/git-objects/8bed1ecc75af648c4b5fbf888b902e89ea94de00.tree", + "research/joint-relations-independent-validation/custody/git-objects/92bd281a274191242f183544f5ebab24b7f61127.tree", + "research/joint-relations-independent-validation/custody/git-objects/93c3da5da0a527baf42dbbe76e7af010384def87.tree", + "research/joint-relations-independent-validation/custody/git-objects/b1ab650d36f59e5be682a813145b7c67e219e341.commit", + "research/joint-relations-independent-validation/custody/git-objects/b3abe1a63f80b453a11823d70c836b9199e7c556.tree", + "research/joint-relations-independent-validation/custody/git-objects/bfb420045d2bc04dd026b5020aea84d547873ef4.tree", + "research/joint-relations-independent-validation/custody/git-objects/c211d4eb07730865bffd69a35a85a0642acc333d.tree", + "research/joint-relations-independent-validation/custody/git-objects/ca6f51bb3b6474cfa4111ebafa02b1913a807446.tree", + "research/joint-relations-independent-validation/custody/git-objects/d520959c0a8af33980dff881ed2cf6c4703bb338.tree", + "research/joint-relations-independent-validation/custody/git-objects/db06c76a46083783b675e5a5ce418c52a400d350.tree", + "research/joint-relations-independent-validation/custody/git-objects/df0da6ab4433542c03f089e50eeaabacb89fa6a4.tree", + "research/joint-relations-independent-validation/custody/git-objects/e9c70b9927d6e9233633e4e88108f831e7c5c5d9.tree", + "research/joint-relations-independent-validation/receipt_guard.py", + "research/joint-relations-independent-validation/reports/algebra/REPORT.md", + "research/joint-relations-independent-validation/reports/algebra/RUN-REQUEST.json", + "research/joint-relations-independent-validation/reports/applicability/FOUNDATION-SOURCES.json", + "research/joint-relations-independent-validation/reports/applicability/REPORT.md", + "research/joint-relations-independent-validation/reports/falsifier/CODE-AUDIT.md", + "research/joint-relations-independent-validation/reports/falsifier/EARLY-FINDINGS.md", + "research/joint-relations-independent-validation/reports/falsifier/RUN-REQUEST.json", + "research/joint-relations-independent-validation/reports/falsifier/SAME-FRAME-CONTROL.json", + "research/joint-relations-independent-validation/reports/outer/REPORT.md", + "research/joint-relations-independent-validation/reports/outer/SOURCES.json", + "research/joint-relations-independent-validation/reports/ownership/REPORT.md", + "research/joint-relations-independent-validation/reports/ownership/RUN-REQUEST.json", + "research/joint-relations-independent-validation/reports/prices/REPORT.md", + "research/joint-relations-independent-validation/source_guard.py" + ] +} diff --git a/research/joint-relations-independent-validation/capsule/agents/algebra/check_joint.py b/research/joint-relations-independent-validation/capsule/agents/algebra/check_joint.py new file mode 100644 index 0000000000..f546c04c16 --- /dev/null +++ b/research/joint-relations-independent-validation/capsule/agents/algebra/check_joint.py @@ -0,0 +1,310 @@ +#!/usr/bin/env python3 +"""Independent joint algebra audit. Standard library only; imports no author code. + +Chris R / OpenAI Codex independent checking of Ali Romman's construction, +using Cao Yifan's source word. Rational rows use normalized dyadic integer +numerators, not the author's per-coefficient Fraction implementation. +""" +import argparse +import gzip +import hashlib +import json +from fractions import Fraction +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] / 'repository' +SOURCE = 'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz' +CANDIDATE = 'research/kappa-joint-relations-20261023/WORD.json.gz' + +def require(ok, message): + if not ok: + raise ValueError(message) + +def norm(d, exponent): + d = {k: v for k, v in d.items() if v} + if not d: + return ({}, 0) + shift = min((abs(v) & -abs(v)).bit_length() - 1 for v in d.values()) + shift = min(shift, exponent) + if shift: + d = {k: v >> shift for k, v in d.items()} + return d, exponent - shift + +def linear(a, b, numerator=1, denominator=1): + # Source rationals may carry the sign on either integer, including + # SCALE [2,-1]. Normalize the rational sign before dyadic validation. + if denominator < 0: + numerator, denominator = -numerator, -denominator + require(denominator > 0 and denominator & (denominator - 1) == 0, 'non-dyadic scalar') + exp_b = b[1] + denominator.bit_length() - 1 + exp = max(a[1], exp_b) + d = {k: v << (exp - a[1]) for k, v in a[0].items()} + for k, v in b[0].items(): + d[k] = d.get(k, 0) + numerator * (v << (exp - exp_b)) + return norm(d, exp) + +def scaled(a, numerator, denominator): + return linear(({}, 0), a, numerator, denominator) + +def initial(role): + return ({(role, ()): 1}, 0) + +def warped(a, symbol): + # Left action: cancel only an adjacent inverse. Distinct symbols never + # commute and the scalar coefficient is kept outside the word. + d = {} + for (role, word), v in a[0].items(): + key = (role, word[1:] if word and word[0] == -symbol else (symbol,) + word) + d[key] = d.get(key, 0) + v + return norm(d, a[1]) + +def rational_row(row): + return {k: Fraction(v, 1 << row[1]) for k, v in row[0].items()} + +def rref(relations, preferred_pivots=()): + """Conventional matrix elimination, with fixed increasing column order.""" + all_columns = {h for d in relations for h in d} + require(set(preferred_pivots) <= all_columns, 'prepared pivot absent from derived relation system') + columns = list(preferred_pivots) + sorted(all_columns - set(preferred_pivots)) + matrix = [[Fraction(d.get(h, 0)) for h in columns] for d in relations] + rank, pivots = 0, [] + for j, h in enumerate(columns): + k = next((k for k in range(rank, len(matrix)) if matrix[k][j]), None) + if k is None: + continue + matrix[rank], matrix[k] = matrix[k], matrix[rank] + q = matrix[rank][j] + matrix[rank] = [v / q for v in matrix[rank]] + for i in range(len(matrix)): + if i != rank and matrix[i][j]: + q = matrix[i][j] + matrix[i] = [a - q * b for a, b in zip(matrix[i], matrix[rank])] + pivots.append(h) + rank += 1 + if rank == len(matrix): + break + return {p: {h: q for h, q in zip(columns, matrix[i]) if q} for i, p in enumerate(pivots)} + +def decode_edits(source, candidate): + """Read the literal word delta without WITNESS.json or expected outputs.""" + old, new = source['programs']['backward'], candidate['programs']['backward'] + j = next(i for i, e in enumerate(new) if e == old[0]) + preparation = new[:j] + snapshots, centers, zeros = {}, {}, {} + for i, event in enumerate(old): + if new[j] == event: + j += 1 + elif event[0] == 'center': + a, b, c = new[j:j + 3] + frame = event[3] + require(a == ['scalar', ['clear', ['C', 0]], frame], 'center clear') + require(b[0] == 'scalar' and b[1][:2] == ['copy', ['C', 0]] and b[2] == frame, 'center COPY gauge') + slot = tuple(b[1][2]) + require(c == ['scalar', ['clear', list(slot)], frame], 'snapshot consumption') + centers[i] = {'slot': slot, 'frame': frame} + j += 3 + else: + require(event[0] == 'climb', 'unexpected source edit') + role, oldframe, newframe = ('L', event[2]), event[3], event[4] + require(new[j] == ['zero_retag', list(role), oldframe, newframe], 'zero edit exact frames') + zeros[i] = {'role': role, 'frame': oldframe, 'rank': event[5]} + j += 1 + if j + 1 < len(new) and new[j][0] == 'scalar' and new[j][1][0] == 'clear' and new[j][1][1][0] == 'C' and new[j][1][1][1] > 0: + a, b = new[j:j + 2] + slot, frame = tuple(a[1][1]), a[2] + require(b[0] == 'scalar' and b[1][:2] == ['copy', list(slot)] and b[2] == frame, 'snapshot COPY') + require(slot not in [x['slot'] for x in snapshots.values()], 'snapshot slot reused') + snapshots[i] = {'slot': slot, 'role': tuple(b[1][2]), 'frame': frame} + j += 2 + trailing = new[j:] + require(len(snapshots) == len(centers) == len(zeros) == 8, 'eight of each edit') + require(len({x['slot'] for x in centers.values()}) == 8, 'eight independent snapshot slots') + require(max(snapshots) < min(centers), 'all eight snapshots simultaneously live') + for i, x in centers.items(): + match = [k for k, s in snapshots.items() if s['slot'] == x['slot']] + require(len(match) == 1 and match[0] < i and snapshots[match[0]]['frame'] == x['frame'], 'chronological same-frame snapshot') + x['snapshot'] = match[0] + require(candidate['programs']['forward'] == source['programs']['forward'], 'unchanged entire forward word') + canonical = dict(source['canonical']); canonical.pop('local_profile') + require(candidate['canonical'] == canonical, 'unchanged actual native operators and frames') + return preparation, snapshots, centers, zeros, trailing + +def replay(canonical, program, owned, source_sites=None): + roles = {('L', i) for i in range(632)} | set(owned) + rows = {r: initial(r) for r in roles} + frames = {('L', i): f for i, f in enumerate(canonical['start'])} + frames.update({r: None for r in owned if r[0] == 'C'}) + observed, spaces = {}, {} + paid = {} + max_terms = 1 + def space(frame): + if frame not in spaces: + s = {0} + for v in canonical['frames'][frame]: + s |= {u ^ v for u in tuple(s)} + require(len(s) == 1 << len(canonical['frames'][frame]), 'independent binary frame') + spaces[frame] = s + return spaces[frame] + for i, event in enumerate(program): + tag = event[0] + touched = None + if tag == 'scalar': + op, f = event[1:] + action, dst = op[0], tuple(op[1]); touched = dst + require(dst in roles and 0 <= f < len(canonical['frames']), 'scalar declaration') + if action == 'clear': + require(dst in owned, 'borrowed erasure') + rows[dst] = ({}, 0); frames[dst] = f + else: + require(frames[dst] == f, 'destination gauge') + if action in ('add', 'copy'): + src = tuple(op[2]) + require(src in roles and dst != src and frames[src] == f, 'source gauge') + if action == 'copy': + require(dst in owned and not rows[dst][0], 'COPY requires clean owned destination') + rows[dst] = (dict(rows[src][0]), rows[src][1]) + else: + rows[dst] = linear(rows[dst], rows[src], op[3], op[4]) + else: + require(action == 'scale', 'unknown scalar') + rows[dst] = scaled(rows[dst], op[2], op[3]) + elif tag == 'warp': + _, role, symbol, old, new = event + dst = tuple(role); touched = dst + require(frames[dst] == old and 1 <= abs(symbol) <= len(canonical['warps']), 'warp source gauge') + rows[dst] = warped(rows[dst], symbol); frames[dst] = new + elif tag in ('center', 'climb'): + if tag == 'center': + _, idx, old, new, rank = event; dst = ('C', idx) + require(space(old) < space(new) or space(new) < space(old), 'center nested spaces') + else: + _, _, idx, old, new, rank = event; dst = ('L', idx) + require(space(old) < space(new), 'climb nested spaces') + require(frames[dst] == old and rank == abs(len(canonical['frames'][old]) - len(canonical['frames'][new])), 'paid exact frame and rank') + frames[dst] = new; paid[rank] = paid.get(rank, 0) + 1 + elif tag == 'zero_retag': + _, role, old, new = event; dst = tuple(role) + require(frames[dst] == old and not rows[dst][0], 'physical identity requires complete zero row') + frames[dst] = new + else: + require(tag in ('phase', 'adapter'), 'unrecognized native event') + if touched is not None: + max_terms = max(max_terms, len(rows[touched][0])) + if source_sites and i in source_sites: + observed[i] = {r: (dict(rows[r][0]), rows[r][1]) for r in source_sites[i]} + for i in range(632): + r = ('L', i) + require(frames[r] == canonical['final'][i], 'retained final frame') + if r not in owned: + want = initial(r) + if i < 112: + want = linear(want, initial(('L', i + 112)), -1) + require(rows[r] == want, 'retained exact endpoint L' + str(i)) + require(all(not rows[r][0] for r in owned), 'arbitrary owned entry must erase and return zero') + return observed, {'events': len(program), 'paid': paid, 'max_live_row_terms': max_terms, + 'independent_retained_inputs': 632 - sum(r[0] == 'L' for r in owned), + 'arbitrary_owned_entry_inputs': len(owned)} + +def serialize(d): + return {str(k): str(v) for k, v in sorted(d.items())} + +def verify_preparation(prep, basis): + pivots = set(basis) + expected = [] + for pivot, row in sorted(basis.items()): + expected.append(['scalar', ['clear', ['L', pivot]], 0]) + for h, q in sorted(row.items()): + if h != pivot: + require(h not in pivots and q.denominator & (q.denominator - 1) == 0, 'independent dyadic preparation') + expected.append(['scalar', ['add', ['L', pivot], ['L', h], -q.numerator, q.denominator], 0]) + require(prep == expected, 'actual simultaneous pivot preparation differs from independently derived RREF') + +def main(): + ap = argparse.ArgumentParser(); ap.add_argument('--out', type=Path, default=HERE / 'RESULT.json') + ap.add_argument('--candidate', type=Path, default=ROOT / CANDIDATE) + ap.add_argument('--candidate-pr', type=int, default=5383) + ap.add_argument('--candidate-head', default='4bd6efa51a495a7c7b7754915cf0244e7e60969e') + args = ap.parse_args() + source_raw = (ROOT / SOURCE).read_bytes() + candidate_raw = args.candidate.read_bytes() + source_payload, candidate_payload = map(gzip.decompress, (source_raw, candidate_raw)) + source, candidate = map(json.loads, (source_payload, candidate_payload)) + prep, snapshots, centers, zeros, trailing = decode_edits(source, candidate) + sites = {} + for i, s in snapshots.items(): sites.setdefault(i, set()).add(s['role']) + for i in centers: sites.setdefault(i, set()).add(('C', 0)) + for i, z in zeros.items(): sites.setdefault(i, set()).add(z['role']) + observed, before = replay(source['canonical'], source['programs']['backward'], {('C', 0)}, sites) + relations, identities, by_frame = [], [], {} + for i, x in sorted(centers.items()): + s = snapshots[x['snapshot']] + diff = linear(observed[i][('C', 0)], observed[x['snapshot']][s['role']], -1) + qrow = rational_row(diff) + require(qrow and all(r[0] == 'L' and 224 <= r[1] < 632 and not word for (r, word) in qrow), 'derived relation must contain only scalar helper inputs') + relation = {r[1]: q for (r, _), q in qrow.items()} + require(all(source['canonical']['start'][h] == 0 and source['canonical']['final'][h] == 1 for h in relation), 'cold full-ended relation domain') + relations.append(relation); by_frame[x['frame']] = diff + identities.append({'center_event': i, 'snapshot_event': x['snapshot'], 'snapshot_role': s['role'], 'frame': x['frame'], 'center_minus_snapshot': serialize(relation)}) + require(len(by_frame) == 8, 'distinct center frames') + for i, z in sorted(zeros.items()): + require(z['frame'] in by_frame and z['rank'] == 1, 'zero site belongs to named rank-one center frame') + require(observed[i][z['role']] == scaled(by_frame[z['frame']], -1, 1), 'unrestricted later row equals negative center-minus-snapshot') + identities.append({'zero_event': i, 'role': z['role'], 'frame': z['frame'], 'unrestricted_row_is_negative_center_delta': True}) + canonical_basis = rref(relations) + require(len(canonical_basis) == 8, 'joint relation rank eight') + prepared_pivots = [e[1][1][1] for e in prep if e[0] == 'scalar' and e[1][0] == 'clear' and e[1][1][0] == 'L'] + require(len(prepared_pivots) == len(set(prepared_pivots)) == 8, 'eight distinct actual prepared pivots') + basis = rref(relations, sorted(prepared_pivots)) + require(set(basis) == set(prepared_pivots), 'actual chosen pivots not independent in joint relation system') + verify_preparation(prep, basis) + require(trailing == [['scalar', ['clear', ['L', h]], 1] for h in sorted(basis)], 'all pivot outputs returned zero') + owned = {('L', h) for h in basis} | {('C', i) for i in range(9)} + require({tuple(r) for r in candidate['owned']['backward']} == owned, 'actual owned declarations') + _, after = replay(candidate['canonical'], candidate['programs']['backward'], owned) + # Controls are exact local propositions applied to independently derived + # rows, rather than rerunning or relying on author's rejection controls. + controls = {} + def rejects(name, fn): + try: fn() + except ValueError as e: controls[name] = str(e) + else: raise ValueError('accepted negative control ' + name) + mutant = json.loads(json.dumps(prep)); mutant[1][1][3] += 1 + rejects('wrong_preparation_coefficient', lambda: verify_preparation(mutant, basis)) + mutant2 = json.loads(json.dumps(prep)); mutant2[1][1][3] *= -1 + rejects('wrong_preparation_sign', lambda: verify_preparation(mutant2, basis)) + mutant3 = json.loads(json.dumps(prep)); mutant3[0][1][1][1] = 226 + rejects('wrong_pivot', lambda: verify_preparation(mutant3, basis)) + # Swapping distinct saved values must change the unrestricted center delta. + cs = list(sorted(centers)); x, y = centers[cs[0]], centers[cs[1]] + sx, sy = snapshots[x['snapshot']], snapshots[y['snapshot']] + wrong_delta = linear(observed[cs[0]][('C', 0)], observed[y['snapshot']][sy['role']], -1) + rejects('wrong_snapshot', lambda: require(wrong_delta == by_frame[x['frame']], 'snapshot changes unrestricted identity')) + wrong_gauge = json.loads(json.dumps(candidate)); ci = next(i for i,e in enumerate(wrong_gauge['programs']['backward']) if e[0]=='scalar' and e[1][:2]==['copy',['C',0]]) + wrong_gauge['programs']['backward'][ci][2] = 0 + rejects('wrong_copy_gauge', lambda: decode_edits(source, wrong_gauge)) + zi = min(zeros); z = zeros[zi] + wrong_zero = linear(observed[zi][z['role']], initial(('L', 224))) + rejects('wrong_zero_row', lambda: require(wrong_zero == scaled(by_frame[z['frame']], -1, 1), 'nonzero retained column at zero site')) + fake_rank = dict(basis); fake_rank.pop(min(fake_rank)) + rejects('drop_independent_relation', lambda: require(len(fake_rank)==8, 'rank seven cannot fund eight pivots')) + result = {'status': 'PASS_INDEPENDENT_JOINT_ALGEBRA', 'author_credit': 'Ali Romman; source word Cao Yifan', + 'candidate_pr': args.candidate_pr, 'candidate_head': args.candidate_head, + 'source_file': str(ROOT / SOURCE), 'candidate_file': str(args.candidate.resolve()), + 'source_raw_sha256': hashlib.sha256(source_raw).hexdigest(), + 'source_payload_sha256': hashlib.sha256(source_payload).hexdigest(), + 'candidate_raw_sha256': hashlib.sha256(candidate_raw).hexdigest(), + 'candidate_payload_sha256': hashlib.sha256(candidate_payload).hexdigest(), + 'checker_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'relation_rank': 8, 'independently_derived_pivots': list(sorted(basis)), + 'independently_derived_rref': {str(p): serialize(d) for p,d in sorted(basis.items())}, + 'unconstrained_canonical_rref': {str(p): serialize(d) for p,d in sorted(canonical_basis.items())}, + 'source_identities': identities, 'source_replay': before, 'candidate_replay': after, + 'simultaneous_snapshot_count': 8, 'all_16_unrestricted_identities_checked': True, + 'forward_entire_word_unchanged': True, 'canonical_operators_frames_unchanged': True, + 'negative_controls': controls, + 'limitations': ['No new absolute-phase lowering or physical all-size proof.', 'Forward replay unchanged and reused; this checker independently replays backward words only.', 'Cost, compiler, outer inequalities are separate review responsibilities.']} + args.out.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print(json.dumps({'status': result['status'], 'pivots': sorted(basis), 'controls': list(controls)})) + +if __name__ == '__main__': main() diff --git a/research/joint-relations-independent-validation/capsule/agents/applicability/check_applicability.py b/research/joint-relations-independent-validation/capsule/agents/applicability/check_applicability.py new file mode 100644 index 0000000000..3186aca892 --- /dev/null +++ b/research/joint-relations-independent-validation/capsule/agents/applicability/check_applicability.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python3 +"""Independent small grammar/count/guard check. No candidate evaluator imports. + +This checks finite applicability conditions, not unrestricted source identities, +Clifford factors, directed moments, or complete conditional admission. +Substantial OpenAI assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import gzip +import json +import resource +import sys +import time + +HERE = Path(__file__).resolve().parent +BASE = HERE.parents[1] +REPO = BASE / 'repository' + +def require(ok, message): + if not ok: + raise ValueError(message) + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + +def allowance(g): + if g[0] in ('clear', 'copy'): + return 2 + q = Q(*g[3:]) if g[0] == 'add' else Q(*g[2:]) + a, b = abs(q.numerator), q.denominator + require(a and not b & (b-1), 'Dyadic finite scalar grammar') + if g[0] == 'scale': + require(not a & (a-1), 'Dyadic unit SCALE') + return 2*(abs(a.bit_length()-b.bit_length()) + int(q < 0)) + require(g[0] == 'add', 'Scalar opcode') + return 2*(2+a.bit_length()+a.bit_count()+b.bit_length()-1) + +def inspect(word, old, label): + pivots = {225,227,229,230,241,245,257,288 if label == '5383' else 261} + require(word['programs']['forward'] == old['programs']['forward'], 'Unchanged forward word') + require(word['canonical'] == {k:v for k,v in old['canonical'].items() if k != 'local_profile'}, 'Unchanged canonical geometry') + expected = {('C', j) for j in range(9)} | {('L', j) for j in pivots} + require({tuple(r) for r in word['owned']['backward']} == expected, 'Seventeen distinct backward owners') + stats = {} + for direction in ('forward','backward'): + program = word['programs'][direction] + require([e for e in program if e[0] in ('warp','adapter','phase')] == + [e for e in old['programs'][direction] if e[0] in ('warp','adapter','phase')], + 'Exact retained phase/warp/adapter itinerary') + owned = {tuple(r) for r in word['owned'][direction]} + frames = {('L', i):f for i,f in enumerate(word['canonical']['start'])} + cleared = set(); live = set(); peak = 0; scalar = 0; paid = Counter(); zeros = [] + first_native = next(i for i,e in enumerate(program) if e[0] != 'scalar') + prepared = set() + for i,e in enumerate(program): + kind = e[0] + if kind == 'scalar': + g, f = e[1:]; dst = tuple(g[1]); op = g[0] + scalar += allowance(g) + if op == 'clear': + require(dst in owned, 'Borrowed erase prohibited') + cleared.add(dst); frames[dst] = f + if dst[0] == 'C' and dst[1]: live.discard(dst) + else: + require(frames.get(dst) == f, 'Scalar destination exact frame') + if op in ('add','copy'): + src = tuple(g[2]); require(src != dst and frames.get(src) == f, 'Distinct same-frame scalar source') + if op == 'copy' and dst[0] == 'C' and dst[1]: + require(dst in cleared and src[0] == 'L', 'Initialized owned snapshot') + live.add(dst); peak=max(peak,len(live)) + if i < first_native: + require(direction == 'backward' and dst == ('L',dst[1]) and dst[1] in pivots and dst in cleared, 'Owned cold pivot preparation') + require(op == 'add' and src[0] == 'L' and src[1] not in pivots and f == 0, 'No pivot dependency or extra preparation oracle') + prepared.add(dst[1]) + elif kind == 'climb': + r=('L',e[2]); require(frames[r] == e[3], 'Paid current frame');frames[r]=e[4];paid[e[5]]+=1 + elif kind == 'center': + r=('C',e[1]); frames[r]=e[3];paid[e[4]]+=1 + elif kind == 'zero_retag': + r=tuple(e[1]);require(frames[r] == e[2] and e[3] == 1, 'Zero site exact source/target frames');frames[r]=e[3];zeros.append(r) + elif kind == 'warp': + r=tuple(e[1]); require(frames[r] == e[3], 'Warp current exact frame');frames[r]=e[4] + else: + require(kind in ('phase','adapter'), 'Known unchanged event species') + require(not live, 'All snapshots erased at return') + if direction == 'backward': + require(prepared == pivots and peak == 8 and len(zeros) == 8, 'Joint preparation, eight simultaneous snapshots, eight zero sites') + require(paid == {1:2193,2:412,3:510,4:127,5:40}, 'Complete backward paid census') + stats[direction] = dict(scalar_allowance=scalar, owned=len(owned), simultaneous_snapshots=peak, paid=dict(paid), zero_sites=len(zeros)) + require(stats['backward']['scalar_allowance'] == {'5383':158744,'5387':158776}[label], 'Candidate-specific fresh scalar allowance') + return stats + +def main(): + start=time.monotonic() + resource.setrlimit(resource.RLIMIT_CPU,(15,15)) + resource.setrlimit(resource.RLIMIT_AS,(128*1024**2,128*1024**2)) + old=read(REPO/'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz') + packages={'5383':REPO/'research/kappa-joint-relations-20261023', + '5387':BASE/'agents/sources/pr5387/research/eight-owned-relations'} + out={'status':'PASS_SCOPED_APPLICABILITY_COUNTS_AND_GUARDS','candidates':{},'full_uniform_word_materialized':False} + for label,path in packages.items(): + word=read(path/'WORD.json.gz'); result=read(path/'RESULT.json') + stats=inspect(word,old,label); price=result['bound'] if 'bound' in result else result.get('price',result) + # Receipt keys are discovered explicitly, never evaluated as code. + if 'compiler' not in price: + price=next(v for v in result.values() if isinstance(v,dict) and 'compiler' in v) + c=price['compiler'];s=price['strictification'];gap=Q(c['gap']);h=c['H'];j=c['integer_test_exponent'] + require(gap.numerator == 1 and h == j*gap.denominator, 'Exact integer compiler grid') + require((h+1)**1000 < 2**j and (gap.denominator*(j-1)+1)**1000 >= 2**(j-1), 'Candidate threshold and preceding sufficient grid') + rho=Q(s['reserve']); normalized=1/(1+1024*rho)+Q(4,2**32) + require(normalized < 1 and Q(s['normalized_paid_upper']) == normalized, 'Funded paid-completion rounding budget') + require(20**64 < 21**63 and Q(97,100)**128 < Q(1,16), 'Splitting separation and two charged tail-block guard') + require(h > 8192 and 1000*gap > Q(1,h+1), 'Threshold covers product rank and eventual logarithmic derivative') + out['candidates'][label]=dict(word_sha256=sha256((path/'WORD.json.gz').read_bytes()).hexdigest(), + result_sha256=sha256((path/'RESULT.json').read_bytes()).hexdigest(),local=stats, + raw_controller_owned_LOCAL_banks=16*17+2,compiler_H=h,compiler_j=j,gap=str(gap), + reserve=str(rho),paid_completion_slack=str(1-normalized), + expanded_count_majorant='D=2^262144; F(0)=D; F(n)=((n+1)*(D+1)*(F(n-1)+1))^(16*(n+1)^2); M=F(2^H)', + expanded_bounds={name:'M' for name in ['W','P','O','R','G']}, + semantic={'Z':'2*M','E':'64*(2*M+2^H+2*M+1)^3','B':'M+E','C0':'32*2^H*B^2'}, + endpoint_scope='Fixed finite template and eventual thresholds under the five selected assumptions; semantic source identities and interval moment premises are separate review obligations') + # Symbolic induction exponents behind F(n), with concrete arbitrary n controls. + require(all(9*n+20 <=16*(n+1)**2 for n in range(1,1000)), 'Router/denominator-clearing majorant exponent') + require(2*(82*1024+10+2*8192)+6+3*8193 < 262144, 'Strictified-unit D exponent including squared complete role inventory') + controls={} + del word + original=read(packages['5383']/'WORD.json.gz') + def bad_warp(w): + i=next(i for i,e in enumerate(w['programs']['backward']) if e[0]=='warp') + w['programs']['backward'][i]=list(w['programs']['backward'][i]) + w['programs']['backward'][i][2]=0 + for name,edit in [ + ('borrowed_erase',lambda w:w['programs']['backward'].insert(0,['scalar',['clear',['L',324]],0])), + ('snapshot_owner_alias',lambda w:w['owned']['backward'].pop(8)), + ('phase_itinerary',bad_warp), + ]: + bad=dict(original);bad['programs']=dict(original['programs']) + bad['programs']['backward']=list(original['programs']['backward']) + bad['owned']=dict(original['owned']);bad['owned']['backward']=list(original['owned']['backward']) + edit(bad) + try: inspect(bad,old,'5383') + except ValueError as error: controls[name+'_rejected']=str(error) + else: raise ValueError('Accepted mutation '+name) + controls.update({'old_1e9_as_expanded_cap_rejected':2**262144>10**9, + 'one_bank_per_depth_rejected':out['candidates']['5383']['local']['backward']['simultaneous_snapshots']>1, + '5387_reserve_1e_minus13_rounding_rejected':1/(1+Q(1024,10**13))+Q(4,2**32)>=1}) + require(all(controls.values()),'Meaningful stock/reserve controls') + out.update(controls=controls,seconds=time.monotonic()-start, + limitations=['No candidate evaluator imported','No free-word identity or Clifford phase replay','Moment alpha/gamma/delta interval hypotheses supplied by independent pricing review','Expanded count bound is a terminating integer recursion; its astronomical value was not numerically expanded','No independent human or formal proof; no unconditional physical theorem']) + print(json.dumps(out,indent=2)) + +if __name__=='__main__': + main() diff --git a/research/joint-relations-independent-validation/capsule/agents/falsifier/check_mutants.py b/research/joint-relations-independent-validation/capsule/agents/falsifier/check_mutants.py new file mode 100644 index 0000000000..a85fb7db3e --- /dev/null +++ b/research/joint-relations-independent-validation/capsule/agents/falsifier/check_mutants.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +"""Semantic mutations of actual PR5383 WORD; no old digest comparison in math path. + +Chris R with OpenAI Codex. Inputs read only; imports only independent worker's +algebra module. Coordinator must serialize the full replay modes. +""" +import argparse, copy, gzip, hashlib, importlib.util, json, sys, time +from pathlib import Path +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +EXEC = HERE.parents[1] +CHECKER = EXEC / 'agents/algebra/check_joint.py' +REPO = EXEC / 'repository' +PACKAGE = REPO / 'research/kappa-joint-relations-20261023' + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + +def digest(value): + return hashlib.sha256((json.dumps(value,sort_keys=True,separators=(',',':'))+'\n').encode()).hexdigest() + +def load_checker(): + spec=importlib.util.spec_from_file_location('independent_joint_algebra_for_mutation',CHECKER) + module=importlib.util.module_from_spec(spec); spec.loader.exec_module(module) + return module + +def mutations(candidate): + program=candidate['programs']['backward'] + def fork(): + m=dict(candidate); m['programs']=dict(candidate['programs']) + m['programs']['backward']=list(program); m['owned']=copy.deepcopy(candidate['owned']) + return m + m=fork(); del m['programs']['backward'][0] + yield 'arbitrary_owned_input_clear_removed',m,'replay',None + m=fork(); m['programs']['backward'][1]=copy.deepcopy(program[1]); m['programs']['backward'][1][1][3]*=-1 + yield 'preparation_sign_reversed',m,'replay',None + m=fork(); idx=next(i for i,e in enumerate(program) if e[0]=='scalar' and e[1][:2]==['copy',['C',1]]) + m['programs']['backward'][idx]=copy.deepcopy(program[idx]); m['programs']['backward'][idx][1][2]=['L',63] + yield 'wrong_same_frame_snapshot_source',m,'replay',None + m=fork(); m['programs']['backward'].pop() + yield 'arbitrary_owned_output_not_returned_zero',m,'replay',None + # Preserve every source marker and per-kind subsequence but exchange two + # adjacent differently tagged events. Source chronology must reject. + m=fork(); p=m['programs']['backward'] + idx=next(i for i,e in enumerate(p[:-1]) if e[0] in ('phase','adapter') and p[i+1][0]!=e[0]) + p[idx],p[idx+1]=p[idx+1],p[idx] + yield 'phase_marker_displaced_across_adjacent_event',m,'decode_edits',{'swapped_indices':[idx,idx+1]} + m=fork(); m['owned']['backward'].remove(['L',225]) + yield 'pivot_laundered_as_borrowed_productive_input',m,'replay',None + +def main(): + ap=argparse.ArgumentParser(); ap.add_argument('--mode',choices=['manifest','full'],default='manifest'); ap.add_argument('--out',type=Path,default=HERE/'CONTROLS.json'); ap.add_argument('--only',action='append') + args=ap.parse_args(); candidate=read(PACKAGE/'WORD.json.gz'); source=read(REPO/'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz'); checker=load_checker() + original_hash=digest(candidate); results={}; start=time.monotonic() + for name,mutant,engine,extra in mutations(candidate): + if args.only and name not in args.only: continue + row={'mutant_payload_sha256_recomputed':digest(mutant),'original_payload_sha256':original_hash,'hash_changed':digest(mutant)!=original_hash,'engine':engine,'old_digest_comparison_used_for_rejection':False,'detail':extra} + if args.mode=='manifest': row['status']='NOT_RUN_MANIFEST_ONLY' + else: + began=time.monotonic() + try: + if engine=='decode_edits': checker.decode_edits(source,mutant) + else: checker.replay(mutant['canonical'],mutant['programs']['backward'],{tuple(r) for r in mutant['owned']['backward']}) + except (ValueError,IndexError,KeyError) as exc: + row.update(status='REJECTED',reason=str(exc),exception_type=type(exc).__name__) + else: row.update(status='ACCEPTED_UNEXPECTEDLY') + row['seconds']=time.monotonic()-began + results[name]=row + output={'status':'MANIFEST_ONLY' if args.mode=='manifest' else ('PASS_SEMANTIC_MUTANTS_REJECTED' if all(r['status']=='REJECTED' for r in results.values()) else 'FAIL_SEMANTIC_MUTANT_ACCEPTED'),'candidate_head':'4bd6efa51a495a7c7b7754915cf0244e7e60969e','mutations_of_actual_literal_word':True,'checker_sha256':hashlib.sha256(CHECKER.read_bytes()).hexdigest(),'harness_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),'elapsed_seconds':time.monotonic()-start,'controls':results} + args.out.write_text(json.dumps(output,indent=2,sort_keys=True)+'\n'); print(json.dumps({'status':output['status'],'controls':{k:v['status'] for k,v in results.items()}})) + if output['status']=='FAIL_SEMANTIC_MUTANT_ACCEPTED': raise SystemExit(1) +if __name__=='__main__': main() diff --git a/research/joint-relations-independent-validation/capsule/agents/outer/check_outer.py b/research/joint-relations-independent-validation/capsule/agents/outer/check_outer.py new file mode 100644 index 0000000000..44ce83d7a6 --- /dev/null +++ b/research/joint-relations-independent-validation/capsule/agents/outer/check_outer.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python3 +"""Independent rational review of mixed-target outer allocations and compiler grid. +No candidate Python code is imported or executed. Standard library only. +Predecessors for exponent contracts: Jacob Alan Sussman, zxv, Cao Yifan, +Cinna Davis, and Chris R / Clear1nsight's independently transcribed PR5241 +ledger preserved by PR5384. Substantial OpenAI Codex assistance. +""" +from fractions import Fraction as Q +from pathlib import Path +import argparse, hashlib, json, platform, resource, time + +def need(ok, msg): + if not ok: raise AssertionError(msg) +def encode(x): + if isinstance(x,Q): return str(x) + if isinstance(x,dict): return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)): return [encode(v) for v in x] + return x + +def family(k,s,bit=Q('.0034')): + g=(s-k)/7 + return dict(kappa=k,tested_saving=s,complex_uniform_saving=k+6*g, + b=k+5*g,a=k+4*g,q=k+3*g,bit_saving=bit,epsilon=1-g, + beta=1-3*g,r0=g/10,stop=g,layout=g,d=g) + +def outer(p,atom=Q('.004')): + # Exponents are calculated from the stopping, grouping and routing rules. + k,b,a,q,ep,be,r,stop,layout=(p[n] for n in + ('kappa','b','a','q','epsilon','beta','r0','stop','layout')) + sigma,tau=1-b,1-a + internal=tau+(1-stop)*max(sigma-tau,Q(0)) + leaf=sigma+stop*(1-sigma) + lam=1-(q+a)/2 + xi=ep*(1+q)-Q(3,32)+layout + key=be+1-ep + m=dict(main_transform=ep*q,global_coordinate_router=a, + fused_gaussian=1-ep+q*be,group_bit_router=1-ep+a*be, + group_scans=1-ep+be,boundary_algebraic_matrix=Q(3,32)+xi-ep, + sparse_union_movement=xi+Q(1,2)-ep,polynomial_products=ep, + microbox_face_corrections=79-ep-be) + c=dict(actual_bit_above_effective=p['bit_saving']-a, + complex_above_effective=b-a,q_positive=q,complex_endpoint=b-q, + q_below_effective=a-q,stop_positive=stop,stop_below_one=1-stop, + leaf_saving_above_effective=(1-stop)*b-a, + q_below_internal=1-internal-q,q_below_leaf=1-leaf-q, + lambda_above_tau=lam-tau,lambda_above_sigma=lam-sigma, + lambda_above_internal=lam-internal,lambda_prime_above_lambda=1-q-lam, + lambda_prime_above_leaf=1-q-leaf,epsilon_positive=ep, + epsilon_below_one=1-ep,cap_above_band=xi-Q(1,2),cap_below_cell=ep-xi, + group_positive=be,group_below_dimension=ep-be,support_router_span=1-be, + group_gauge_power_slack=3-2*xi-r-be, + actual_logarithmic_group_guard=3-2*xi-be, + global_gamma_power_slack=1-ep-r,actual_logarithmic_gamma_guard=1-ep, + alpha_logarithm_absorption=r,group_key_fits_record=1-key, + membership_arithmetic_fits_record=1-be-2*(1-ep), + microbox_halo_volume=80-be,positive_layout_slack=layout, + short_record_fallback=ep-a,complex_below_one_over_32=Q(1,32)-b, + strassen_integer_power_gap=Q(2**45-7**16), + theta_positive_polynomial_power=Q(2),cap_below_phase_cell_power=2-xi, + halo_covers_generic_inverse_radius=Q(5),union_tag_work_per_visit_fits_record=1-be, + union_header_fits_record=1-be,source_axis_superpolynomial=1-ep, + gaussian_above_main=m['fused_gaussian']-m['main_transform'], + new_complex_uniform_saving_above_b=p['complex_uniform_saving']-b, + improvement_over_user_baseline=k-Q('.001730970419199163702738'), + new_semantic_guard_with_C1_one=1-ep,fine_prime_halo_umbrella=Q(7,2)) + c.update({n+'_above_kappa':v-k for n,v in m.items()}) + f=dict(new_semantic_group_guard=1-be, + new_BIT_row_stock_sublinear_in_active_group=be*Q(997,1000), + fixed_halo_explicit_metadata_branch=79-ep-be, + actual_new_BIT_stock_sublinear=be*(1-atom)) + return dict(parameters=dict(p,cap_xi=xi,lambda_=lam,lambda_prime=1-q), + margins=m,strict_checks=c,functional_checks=f) + +def compiler(k,s,reserve,record=None): + gap=(s-k)/7 + need(gap>0 and gap.numerator==1,'positive unit-fraction compiler grid') + step=gap.denominator + power,v=1000,1024 + def wins(j):return (step*j+1)**power<2**j + left,right=1,2 + while not wins(right): left,right=right,2*right + while right-left>1: + mid=(left+right)//2 + if wins(mid):right=mid + else:left=mid + H=step*right + normalized=1/(1+v*reserve)+Q(4,2**32) + checks=dict(height_above_8v=H>8*v,integer_success=wins(right), + preceding_integer_grid_fails=not wins(right-1), + rounding_and_completion_funded=normalized<1, + strict_uniform_below_tested=k+6*gap0. A success and previous failure + # prove the least winning positive integer grid index, not least arbitrary H. + return dict(gap=gap,step=step,j=right,H=H,N_encoding='2^'+str(H), + checks=checks,normalized_paid_upper=normalized,rounding_reserve=1-normalized, + reserve_must_exceed=Q(4,2**32)/(v*(1-Q(4,2**32))), + word_materialized=False,threshold_scope='Least winning integer j on H=step*j for this sufficient inequality; no globally optimal compiler claim.') + +def run(name,path,bit_source): + raw=path.read_bytes(); rec=json.loads(raw); ar=rec.get('arithmetic',rec) + k,s=Q(ar['kappa']),Q(ar['strictification']['tested']) + reserve=Q(ar['strictification']['reserve']) + p=family(k,s); out=outer(p) + need(len(out['strict_checks'])==54 and len(out['functional_checks'])==4,'54+4 inventory') + need(all(v>0 for g in ('strict_checks','functional_checks') for v in out[g].values()),'strict outer funding') + for g in ('margins','strict_checks','functional_checks'): + need(out[g]=={n:Q(v) for n,v in ar['outer'][g].items()},'record equality '+g) + need(all(Q(ar['outer']['parameters'][n])==v for n,v in p.items()),'recorded parameter family') + comp=compiler(k,s,reserve,ar['compiler']) + controls={} + for label,patch in [('insufficient_BIT',{'bit_saving':Q('.0027')}), + ('closed_BIT',{'bit_saving':p['a']}),('closed_uniform',{'complex_uniform_saving':p['b']}), + ('unfunded_endpoint',{'kappa':s}),('closed_epsilon',{'epsilon':Q(1)}), + ('missing_layout',{'layout':Q(0)})]: + bad=outer(dict(p,**patch)) + failures={n:v for n,v in bad['strict_checks'].items() if v<=0} + need(failures,'reject '+label);controls[label]=failures + try:compiler(k,s,Q(1,10**13)) + except AssertionError:controls['unfunded_rounding']='rejected by normalized paid bound' + else:raise AssertionError('unfunded rounding accepted') + controls['lower_compiler_integer_grid']='rejected by independently evaluated strict integer inequality at j-1' + try:compiler(s,s,reserve) + except AssertionError:controls['closed_compiler_gap']='rejected by positive gap requirement' + else:raise AssertionError('closed compiler gap accepted') + bit=ar['ordinary_BIT']; need(bit==bit_source,'retained source BIT record unchanged'); atom=Q(bit['atom']) + ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + need(ordinary==Q(bit['ordinary_saving']),'ordinary BIT interpolation') + need(atom==Q('.004') and atom>ordinary>Q(bit['admitted'])>s and atom<1-ordinary,'BIT chain and active stock') + need(Q(bit['admitted'])==p['bit_saving'],'same retained BIT admission') + margins=out['margins']; limiter=min(margins,key=margins.get) + return dict(status='PASS_INDEPENDENT_OUTER_AND_FINITE_COMPILER_ARITHMETIC',candidate=name, + source_path=str(path.resolve()),source_sha256=hashlib.sha256(raw).hexdigest(), + kappa=k,tested=s,reserve=reserve,outer=out,compiler=comp,controls=controls, + limiting_outer_row=limiter,limiting_outer_headroom=margins[limiter]-k, + minimum_strict_slack=min(out['strict_checks'].values()), + BIT=dict(atom=atom,ordinary=ordinary,admitted=Q(bit['admitted']), + effective_required=p['a'],headroom=Q(bit['admitted'])-p['a'], + positive_sublinear_active_stock=0p['complex_uniform_saving'], + uniform_above_b=p['complex_uniform_saving']>p['b'],b_above_a=p['b']>p['a'], + a_above_q=p['a']>p['q'],q_above_kappa=p['q']>k), + unexecuted=['Independent invoice and alpha/gamma/delta/eta intervals delegated to pricing lane', + 'Physical/native/all-size applicability delegated to other review lanes', + 'No global optimum or selected-frontier promotion; no expanded word materialized']) + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--candidate',action='append',nargs=2,required=True) + ap.add_argument('--out',type=Path,required=True);ap.add_argument('--bit-source',type=Path,required=True) + args=ap.parse_args();t=time.monotonic();bit_source=json.loads(args.bit_source.read_bytes())['ordinary_BIT'] + result=dict(status='PASS_SCOPED_ARITHMETIC',candidates=[run(n,Path(p),bit_source) for n,p in args.candidate], + python=platform.python_version(),seconds=time.monotonic()-t, + retained_BIT_source=str(args.bit_source.resolve()), + retained_BIT_source_sha256=hashlib.sha256(args.bit_source.read_bytes()).hexdigest(), + maxrss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss, + checker_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest()) + args.out.write_text(json.dumps(encode(result),indent=2,sort_keys=True)+'\n') + print(json.dumps(encode({k:v for k,v in result.items() if k!='candidates'}))) +if __name__=='__main__':main() diff --git a/research/joint-relations-independent-validation/capsule/agents/ownership/check.py b/research/joint-relations-independent-validation/capsule/agents/ownership/check.py new file mode 100644 index 0000000000..f03bc1d68a --- /dev/null +++ b/research/joint-relations-independent-validation/capsule/agents/ownership/check.py @@ -0,0 +1,281 @@ +#!/usr/bin/env python3 +"""Independent event owner/frame/def-use audit; never imports candidate Python. + +--structure is a cheap contract probe. --exact is a coordinator-only full row +replay on arbitrary retained and owned entries. Mathematical scalar rows use +rational coefficients and reduced free words, not binary tableaux. +""" +import argparse +import copy +import gzip +import hashlib +import json +from collections import Counter, defaultdict +from fractions import Fraction +from pathlib import Path + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] / 'repository' +SOURCE = 'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz' +CANDIDATE = 'research/kappa-joint-relations-20261023/WORD.json.gz' +PHASE = 'research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz' +HEAD = '4bd6efa51a495a7c7b7754915cf0244e7e60969e' +MAIN = '1ec1119972c9aefe42525172d07b332fcff81cb4' + + +def require(p, text): + if not p: + raise ValueError(text) + + +def read(p): + data = p.read_bytes() + return json.loads(gzip.decompress(data) if p.suffix == '.gz' else data) + + +def role(x): + require(isinstance(x, list) and len(x) == 2 and x[0] in ('L','C') and isinstance(x[1],int), 'Malformed role') + return tuple(x) + + +def label(r): + return '%s%d' % r + + +def relation_structure(source, candidate): + """Align literal events, discovering edits instead of using WITNESS.json.""" + c = candidate['canonical'] + expected = dict(source['canonical']); expected.pop('local_profile') + require(c == expected, 'Changed canonical frames/maps/adapters') + require(candidate['programs']['forward'] == source['programs']['forward'], 'Changed forward program') + owned_list = [role(x) for x in candidate['owned']['backward']] + owned = set(owned_list) + require(len(owned) == len(owned_list) == 17, '17 distinct owned roles required') + require({r for r in owned if r[0]=='C'} == {('C',i) for i in range(9)}, 'Distinct C0..C8 required') + pivots = sorted(r[1] for r in owned if r[0]=='L') + require(len(pivots) == 8 and all(224 <= i < 632 and c['start'][i]==0 and c['final'][i]==1 for i in pivots), '8 owned cold full-ended helpers') + require(len(c['frames'][1])-len(c['frames'][0]) == 9, 'Lost owned helpers must have rank nine') + old = source['programs']['backward']; new = candidate['programs']['backward'] + k = 0; prepared={}; prep_ops=[] + while k < len(new) and new[k][0]=='scalar': + e=new[k]; g=e[1]; dst=role(g[1]) + require(e[2]==0 and dst in owned and dst[0]=='L', 'Preparation owner/frame') + if g[0]=='clear': + require(dst[1] not in prepared, 'Repeated pivot initial clear') + prepared[dst[1]]=[] + else: + require(g[0]=='add' and dst[1] in prepared, 'Pivot read before initial clear') + src=role(g[2]); require(src[0]=='L' and 224<=src[1]<632 and src not in owned and c['start'][src[1]]==0, 'Preparation must use independent common-frame helpers') + q=Fraction(g[3],g[4]); require(q and q.denominator & (q.denominator-1)==0, 'Preparation dyadic coefficient') + prepared[dst[1]].append([src[1],str(q)]) + prep_ops.append(k);k+=1 + require(set(prepared)==set(pivots) and all(prepared.values()), 'Every owned pivot prepared from retained helpers') + require(k0: + slot=role(new[k][1][1]);frame=new[k][2] + require(j>0 and slot not in snapshots and k+1>p&1:n^=row[p] + require(n,'Dependent frame basis') + row[n.bit_length()-1]=n + return row + + +def subset(a,b): + for n in a: + for p in sorted(b,reverse=True): + if n>>p&1:n^=b[p] + if n:return False + return True + + +def run_frames(c,program,owned,exact=False,backward=True): + """Frame and syntactic owner check; exact=True proves complete row returns.""" + roles={('L',i) for i in range(632)}|owned + frames={('L',i):f for i,f in enumerate(c['start'])} + frames.update({r:None for r in owned if r[0]=='C'}) + initialized=set(roles)-owned + # Each role, including every owner, starts with its own independent symbol. + rows={r:{(r,()):Fraction(1)} for r in roles} if exact else None + ever_cleared=set(); last_reads={}; last_writes={}; first_clear={}; last_clear={}; paid=Counter(); zero_sites=[] + bases=[span_rank(x) for x in c['frames']] + frame_cache={} + def read_at(r,i): + require(r in roles,'Undeclared/aliased source role') + require(r in initialized,'Owned dirt read before legal erase') + last_reads[r]=i + def add(dst,src,q): + for key,value in list(src.items()): + new=dst.get(key,Fraction(0))+q*value + if new:dst[key]=new + else:dst.pop(key,None) + for i,e in enumerate(program): + kind=e[0] + if kind=='scalar': + g,f=e[1:];dst=role(g[1]); require(dst in roles and isinstance(f,int) and 0<=f0 else -1000000) if backward else op + rows[dst]={(r,word[1:] if word and word[0]==-symbol else (symbol,)+word):q for (r,word),q in rows[dst].items()} + frames[dst]=new;last_writes[dst]=i + elif kind in ('climb','center'): + if kind=='climb':_,_,n,old,new,rank=e;dst=('L',n) + else:_,n,old,new,rank=e;dst=('C',n) + read_at(dst,i);require(frames[dst]==old,'Paid input frame') + require(rank==abs(len(c['frames'][new])-len(c['frames'][old])),'Paid rank mismatch') + key=(kind,old,new) + if key not in frame_cache: + frame_cache[key]=subset(c['frames'][old],bases[new]) or (kind=='center' and subset(c['frames'][new],bases[old])) + require(frame_cache[key],'Paid frame inclusion') + frames[dst]=new;last_writes[dst]=i;paid[rank]+=1 + elif kind=='zero_retag': + _,r,old,new=e;dst=role(r);read_at(dst,i) + require(frames[dst]==old,'Zero identity input frame') + if exact:require(not rows[dst],'Zero identity has nonzero input row') + frames[dst]=new;last_writes[dst]=i;zero_sites.append(i) + else:require(kind in ('phase','adapter'),'Unknown opcode') + require([frames[('L',i)] for i in range(632)]==c['final'],'Final borrowed/owned native frame mismatch') + require(owned<=ever_cleared,'Owned entry dirt not legally erased') + for r in owned: + require(last_clear[r]==last_writes[r],'Owned output not zero at return') + if exact: + for r in sorted(roles): + expected={} + if r not in owned: + expected[(r,())]=Fraction(1) + if r[0]=='L' and ((backward and r[1]<112) or (not backward and 112<=r[1]<224)): + src=('L',r[1]+112 if backward else r[1]-112) + expected[(src,())]=Fraction(-1 if backward else 1) + require(rows[r]==expected,'Wrong arbitrary-column endpoint '+label(r)) + return {'paid':dict(sorted(paid.items())),'zero_sites':zero_sites, + 'initial_columns':len(roles),'retained_arbitrary_columns':len(roles-owned),'owned_arbitrary_columns':len(owned), + 'all_exact_endpoints_checked':exact,'all_owned_last_writes_are_clears':True, + 'owned_def_use':[{'role':label(r),'first_clear':first_clear[r],'last_read':last_reads.get(r),'last_clear':last_clear[r],'return_frame':frames[r]} for r in sorted(owned)]} + + +def phase_binding(repo,source,candidate): + receipt=read(repo/PHASE) + payload=hashlib.sha256(gzip.decompress((repo/SOURCE).read_bytes())).hexdigest() + require(receipt['actual_word_canonical_sha256']==payload and receipt['status']=='PASS_JOINT_HELPER_MAPS_ALL_ACTUAL_ABSOLUTE_PHASES','Absolute phase receipt/source binding') + for d in ('forward','backward'): + for kind in ('warp','phase','adapter'): + require([e for e in source['programs'][d] if e[0]==kind]==[e for e in candidate['programs'][d] if e[0]==kind],'Changed phase/native/adapter sequence') + return {'source_payload_sha256':payload,'receipt':PHASE,'source_absolute_phase_lowering_replayed':False,'exact_native_phase_adapter_order_preserved':True} + + +def check(repo,candidate,exact=False): + source=read(repo/SOURCE) + contract=relation_structure(source,candidate) + run=run_frames(candidate['canonical'],candidate['programs']['backward'],contract['owned'],exact) + forward=run_frames(candidate['canonical'],candidate['programs']['forward'],{('C',0)},exact,False) + public={k:v for k,v in contract.items() if k not in ('owned','source_map','snapshots')} + public['snapshots']={label(k):v for k,v in contract['snapshots'].items()} + return {'contract':public,'backward':run,'forward':forward,'phase':phase_binding(repo,source,candidate)} + + +def mutations(repo,candidate): + checks={} + def reject(name,mutate): + bad=copy.deepcopy(candidate);mutate(bad) + try:check(repo,bad,False) + except (ValueError,IndexError,KeyError) as err:checks[name]=str(err) + else:raise ValueError('Mutation escaped: '+name) + def program(x):return x['programs']['backward'] + def first_snapshot(x):return next(i for i,e in enumerate(program(x)) if e[0]=='scalar' and e[1][:2]==['copy',['C',1]]) + reject('borrowed_clear',lambda x: program(x)[0][1].__setitem__(1,['L',0])) + reject('missing_initial_pivot_clear',lambda x: program(x).pop(0)) + reject('alias_owned_snapshot_bank',lambda x:x['owned']['backward'].__setitem__(2,['C',1])) + def reuse(x): + j=next(i for i,e in enumerate(program(x)) if e[0]=='scalar' and e[1][:2]==['copy',['C',2]]) + program(x)[j-1][1][1]=['C',1];program(x)[j][1][1]=['C',1] + reject('reused_live_snapshot_bank',reuse) + reject('wrong_snapshot_frame',lambda x:program(x)[first_snapshot(x)].__setitem__(2,0)) + reject('wrong_snapshot_source',lambda x:program(x)[first_snapshot(x)][1].__setitem__(2,['C',0])) + reject('missing_owner_return',lambda x:program(x).pop()) + reject('missing_retained_output_operation',lambda x:program(x).pop(next(i for i,e in enumerate(program(x)) if e[0]=='scalar' and e[1][0]=='add' and e[1][1][0]=='L' and e[1][1][1]<224))) + reject('undeclared_storage_alias',lambda x:program(x)[first_snapshot(x)][1].__setitem__(1,['C',9])) + reject('changed_phase_marker',lambda x:program(x).pop(next(i for i,e in enumerate(program(x)) if e[0]=='phase'))) + reject('wrong_final_owned_frame',lambda x:program(x)[-1].__setitem__(2,0)) + reject('wrong_center_copy_gauge',lambda x:next(e for e in program(x) if e[0]=='scalar' and e[1][:2]==['copy',['C',0]]).__setitem__(2,0)) + return checks + + +def main(): + parser=argparse.ArgumentParser();parser.add_argument('--repo',type=Path,default=REPO);parser.add_argument('--exact',action='store_true');parser.add_argument('--structure',action='store_true');parser.add_argument('--controls',action='store_true');parser.add_argument('--output',type=Path);parser.add_argument('--candidate',type=Path);parser.add_argument('--candidate-head',default=HEAD) + a=parser.parse_args();candidate_path=a.candidate or a.repo/CANDIDATE;candidate=read(candidate_path) + result={'status':'PASS_EXACT_RUNTIME_OWNERSHIP' if a.exact else 'PASS_STRUCTURAL_RUNTIME_OWNERSHIP','candidate_head':a.candidate_head,'candidate_word':str(candidate_path.resolve()),'candidate_word_sha256':hashlib.sha256(candidate_path.read_bytes()).hexdigest(),'canonical_main':MAIN,'scope':'Independent event parser; no author Python imports or WITNESS/RESULT counters used','result':check(a.repo,candidate,a.exact)} + if a.controls:result['mutation_controls']=mutations(a.repo,candidate) + data=json.dumps(result,indent=2,sort_keys=True)+'\n' + if a.output:a.output.write_text(data) + print(data) + + +if __name__=='__main__':main() diff --git a/research/joint-relations-independent-validation/capsule/agents/prices/check_prices.py b/research/joint-relations-independent-validation/capsule/agents/prices/check_prices.py new file mode 100644 index 0000000000..c8b7284f75 --- /dev/null +++ b/research/joint-relations-independent-validation/capsule/agents/prices/check_prices.py @@ -0,0 +1,264 @@ +#!/usr/bin/env python3 +"""Independent event invoice and rational outward-rounded prices. No candidate imports. + +New audit code by the execution pricing lane with substantial OpenAI Codex help. +Construction credit: Ali Romman; retained source Cao Yifan, Cinna Davis, zxv, +Jacob Alan Sussman. This verifies prices conditional on separately checked semantics. +""" +import argparse, collections, functools, gzip, hashlib, json +from fractions import Fraction as F +from pathlib import Path + +HERE=Path(__file__).resolve().parent +REPO=HERE.parents[1]/'repository' +S=10**65 + +def ceildiv(a,b): return -((-a)//b) +def need(p,s): + if not p: raise ValueError(s) +def read(p): + b=p.read_bytes(); return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def digest(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def encode(v): + if isinstance(v,F): return str(v) + if isinstance(v,dict): return {str(k):encode(x) for k,x in v.items()} + if isinstance(v,(list,tuple)): return [encode(x) for x in v] + return v + +def census(w): + c=w['canonical']; frames=c['frames']; dims=list(map(len,frames)); v=c['v'] + need(len(c['start'])==len(c['final'])==2*v+408 and v==len(c['ports']), 'Main/helper ABI') + def reduce_vector(x,basis): + for pivot,row in basis: + if x & (1<0,'Independent binary frame') + basis.append((row.bit_length()-1,row));basis.sort(reverse=True) + bases.append(basis) + def subset(a,b): return all(reduce_vector(x,bases[b])==0 for x in frames[a]) + all_profiles={} + for direction,events in w['programs'].items(): + owned={tuple(x) for x in w.get('owned',{}).get(direction,[['C',0]])} + current={('L',i):f for i,f in enumerate(c['start'])} + current.update({r:None for r in owned if r[0]=='C'}) + paid=collections.Counter(); types=collections.Counter(); scalar_types=collections.Counter(); tariff=0 + for e in events: + kind=e[0]; types[kind]+=1 + if kind=='scalar': + g,frame=e[1:]; dst=tuple(g[1]);scalar_types[g[0]]+=1 + if g[0] in ('clear','copy'): tariff+=2 + else: + q=F(*(g[3:] if g[0]=='add' else g[2:]));n,d=abs(q.numerator),q.denominator + need(n>0 and d&(d-1)==0,'Dyadic scalar tariff') + if g[0]=='scale': + need(n&(n-1)==0,'Unit dyadic scale');tariff+=2*(abs(n.bit_length()-d.bit_length())+int(q<0)) + else: + need(g[0]=='add','Tariff opcode');tariff+=2*(3+n.bit_length()-1+n.bit_count()+d.bit_length()-1) + if g[0]=='clear': current[dst]=frame + else: + need(current[dst]==frame,'Scalar destination frame') + if g[0] in ('add','copy'): need(current[tuple(g[2])]==frame,'Scalar source frame') + elif kind=='warp': + _,dst,op,a,b=e;dst=tuple(dst) + need(current[dst]==a,'Warp input frame'); current[dst]=b + elif kind in ('climb','center'): + if kind=='climb': _,tag,i,a,b,claimed=e; dst=('L',i) + else: _,i,a,b,claimed=e; dst=('C',i) + need(current[dst]==a,'Paid input frame') + # The price is computed from endpoint dimensions, never its JSON rank. + rank=abs(dims[b]-dims[a]);need(rank==claimed and rank>0,'Paid rank witness') + need(subset(a,b) if kind=='climb' else subset(a,b) or subset(b,a),'Nested paid frame') + paid[rank]+=1;current[dst]=b + elif kind=='zero_retag': + _,dst,a,b=e;dst=tuple(dst) + need(current[dst]==a,'Retag frame');current[dst]=b + else: need(kind in ('phase','adapter'),'Known event kind') + need([current['L',i] for i in range(2*v+408)]==c['final'],'Final frame census') + targets=collections.Counter() + lost=[] + for i in range(2*v,2*v+408): + a,b=c['start'][i],current['L',i] + rank=dims[b]-dims[a];need(rank>0 and subset(a,b),'Productive rank') + if ('L',i) in owned: lost.append([i,rank]) + else: targets[rank]+=1 + all_profiles[direction]={'paid':paid,'helpers':targets,'event_types':types,'scalar_types':scalar_types,'real_scalar_allowance':tariff,'surrendered_helpers':lost} + return all_profiles + +def invoice(): + wp=REPO/'research/kappa-joint-relations-20261023/WORD.json.gz' + sp=REPO/'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz' + cp=REPO/'research/joint-helper-lattice/CONTROLLER.json' + w=read(wp);source=read(sp);controller=read(cp) + successor_path=HERE.parent/'sources/pr5387/research/eight-owned-relations/WORD.json.gz' + successor=census(read(successor_path)) + new=census(w);old=census(source) + for direction in new: + need(successor[direction]['paid']==new[direction]['paid'] and successor[direction]['helpers']==new[direction]['helpers'],'Actual PR5387 same profile') + def whole(local): + T=collections.Counter();P=collections.Counter();counts=collections.Counter();parts={} + v=w['canonical']['v']; h=w['canonical']['h']; step=h-1 + for e in controller['physical_events']: + counts[e[0]]+=1 + if e[0]=='LOCAL': + direction='backward' if e[3] else 'forward' + counts[direction]+=1;T.update(local[direction]['helpers']);P.update(local[direction]['paid']) + elif e[0]=='QUERY_SHEAR': P[1]+=v + elif e[0]=='IDLE': P[step*len(e[2])]+=2*v + main=collections.Counter() + for exponents in controller['diagonal']: + need(abs(exponents[0])==1 and set(exponents[1:])<= {0,1},'Whole completed main target') + main[1+step*sum(exponents[1:])]+=v + T.update(main) + return {'targets':dict(sorted(T.items())),'paid':dict(sorted(P.items())), + 'productive_fields':sum(T.values()),'paid_calls':sum(P.values()), + 'target_rank_mass':sum(r*n for r,n in T.items()),'paid_rank_mass':sum(r*n for r,n in P.items()), + 'controller_event_types':counts,'main_targets':main} + candidate,baseline=whole(new),whole(old) + delta={k:{r:candidate[k].get(r,0)-baseline[k].get(r,0) for r in set(candidate[k])|set(baseline[k]) if candidate[k].get(r,0)!=baseline[k].get(r,0)} for k in ('targets','paid')} + need(delta=={'targets':{9:-128},'paid':{1:-128,8:-128}},'Actual whole delta') + need(candidate['paid_calls']==64148 and candidate['productive_fields']==10800,'Whole counts') + need(candidate['target_rank_mass']-candidate['paid_rank_mass']==752,'Conserved mass surplus') + inputs={str(p.relative_to(REPO)):digest(p) for p in (wp,sp,cp)} + inputs[str(successor_path.relative_to(HERE.parents[1]))]=digest(successor_path) + return {'candidate_head':'4bd6efa51a495a7c7b7754915cf0244e7e60969e','canonical_main':'1ec1119972c9aefe42525172d07b332fcff81cb4', + 'inputs_sha256':inputs,'local_candidate':new,'local_successor':successor,'successor_head':'b1ab650d36f59e5be682a813145b7c67e219e341','local_baseline':old,'candidate':candidate,'baseline':baseline,'delta':delta, + 'semantic_dependency':'Each retained endpoint must independently satisfy ordinary completed-helper ABI; zero_retag validity and owned lifetimes checked by other lanes.'} + +# Each pair is [lower,upper] in units 1/S. All interval operations round out. +def mul(a,b): + q=[x*y for x in a for y in b]; return min(q)//S,ceildiv(max(q),S) +def add(a,b): return a[0]+b[0],a[1]+b[1] +def scale(a,q): + q=F(q); x=[n*q.numerator for n in a] + return min(x)//q.denominator,ceildiv(max(x),q.denominator) +def div(a,b): + need(b[0]>0,'Positive denominator');q=[F(x*S,y) for x in a for y in b] + return min(q).__floor__(),max(q).__ceil__() +def constant(q): + q=F(q)*S;return q.__floor__(),q.__ceil__() +def interval(a): return [F(a[0],S),F(a[1],S)] +def decimal(a,digits=30): + # Display rounding outward as well; exact bounds are always retained. + factor=10**digits;return [f'{a[0]*factor//S/ factor:.{digits}f}',f'{ceildiv(a[1]*factor,S)/ factor:.{digits}f}'] +@functools.lru_cache(None) +def log(rank): + need(rank>=1,'Positive integer log') + if rank==1:return (0,0) + k=rank.bit_length()-1;x=F(rank,2**k);z=(x-1)/(x+1) + def atanh(q): + total=F(0);term=q + for j in range(90):total+=term/F(2*j+1);term*=q*q + tail=2*term/(181*(1-q*q)) + return constant(2*total)[0],constant(2*total+tail)[1] + a=atanh(z);b=atanh(F(1,3));return add(a,scale(b,k)) +def exp_positive(a): + need(a[0]>=0 and a[1]< 16*S,'Exp convergence range') + term=(S,S);total=term + for n in range(1,1000): + term=scale(mul(term,a),F(1,n));total=add(total,term) + # All subsequent exact terms have ratio <= upper(x)/(n+1). + if term[1]<=2 and a[1] < (n+1)*S: + tail=ceildiv(term[1]*a[1],(n+1)*S-a[1]) + return total[0],total[1]+tail + raise ValueError('Exp iteration limit') +@functools.lru_cache(None) +def power(rank,exponent): + exponent=F(exponent) + if exponent==0:return(S,S) + a=scale(log(rank),abs(exponent));result=exp_positive(a) + return result if exponent>0 else div((S,S),result) +def moment(hist,exponent): + result=(0,0) + for r,n in hist.items():result=add(result,scale(power(int(r),exponent),n)) + return result + +def validate_invoice_claim(proposed,derived): + for kind in ('targets','paid'): + need(proposed[kind]==derived[kind], 'Proposed '+kind+' disagrees with literal event-derived census') + return True + +def prices(data): + T=data['candidate']['targets'];P=data['candidate']['paid'];tcount=data['candidate']['productive_fields'] + validate_invoice_claim({'targets':dict(T),'paid':dict(P)},data['candidate']) + def margin(c): + a,b=moment(T,1-c),moment(P,1-c);return a[0]-b[1],a[1]-b[0] + low,high=F('.00302667476807'),F('.00302667476808') + need(margin(low)[0]>0 and margin(high)[1]<0,'Exact fixed-profile root bracket') + # Independently certify strictly decreasing M(C) on [0,.05]. Since + # M'(C)=-sum signed n*r^(1-C)*ln(r), bound that sum from below. + signed={r:T.get(r,0)-P.get(r,0) for r in set(T)|set(P)} + derivative_bounds=[] + for j in range(16): + l,r=F(j,320),F(j+1,320);lower=0 + for rank,n in signed.items(): + b=mul(power(int(rank),1-r if n>0 else 1-l),log(int(rank))) + lower+=n*b[0 if n>0 else 1] + need(lower>0,'Strict decreasing raw moment');derivative_bounds.append(F(lower,S)) + rest=[] + for j in range(128): + l,r=F(1,20)+F(19*j,2560),F(1,20)+F(19*(j+1),2560) + upper=sum(n*power(int(rank),1-l if n>0 else 1-r)[1 if n>0 else 0] for rank,n in signed.items()) + need(upper<0,'Negative moment above .05');rest.append(F(upper,S)) + variants={} + for label,K,C,rho in [('PR5383',F('.00302666'),F('.00302667'),F(1,10**9)),('PR5387',F('.003026674765'),F('.003026674766'),F(1,10**12))]: + a,b=moment(T,1-C),moment(P,1-C) + alpha=div(b,a);gamma=div(moment(P,1-C+F(1,5)),mul(power(20,F(1,5)),a)) + delta=div(constant(21*tcount),mul(power(20,C),a)) + alpha_budget=(scale(a,1-rho)[0]-b[1],scale(a,1-rho)[1]-b[0]) + need(alpha[1]F(63,64)**1000,'Complement capacity') + need(F(power(145,1024*C)[1],S)<2**1000,'Initial range') + rounding_fail=1/(1+1024*F(1,10**13))+F(4,2**32)>=1 + predecessor_reserve_rejected=alpha[0]>constant(1-F(1,10**9))[1] + if label=='PR5387': need(predecessor_reserve_rejected,'Reject old reserve at stronger C') + variants[label]={'kappa':K,'tested':C,'reserve':rho,'raw_margin':interval(margin(C)),'target_moment':interval(a),'paid_moment':interval(b), + 'alpha':interval(alpha),'gamma':interval(gamma),'delta':interval(delta),'alpha_budget':interval(alpha_budget), + 'coarse_completed_upper':bound,'coarse_completion_slack':1-bound,'actual_completed_upper':exact_tail_bound, + 'eta':interval(eta),'raw_headroom_over_claim':[low-K,high-K],'raw_headroom_over_tested':[low-C,high-C], + 'coarse_rounding_reserve_1e-13_fails':rounding_fail,'predecessor_reserve_1e-9_rejected':predecessor_reserve_rejected, + 'extra_H1_affordable':int(F(alpha_budget[0],S).__ceil__()-1), + 'tail_offset':F(1,5),'power':1024,'cutoff':20,'floor':21} + next_tested_grid={} + for C in [F('.003026674767'),F('.003026674768')]: + a,b=moment(T,1-C),moment(P,1-C);alpha=div(b,a) + reserved=constant(1-F(1,10**12));budget=(scale(a,1-F(1,10**12))[0]-b[1],scale(a,1-F(1,10**12))[1]-b[0]) + next_tested_grid[str(C)]={'tested':C,'alpha':interval(alpha),'alpha_budget':interval(budget),'strict_alpha_pass':alpha[1]=reserved[1]} + need(next_tested_grid[str(F('.003026674767'))]['strict_alpha_pass'],'Next C grid still passes alpha') + need(next_tested_grid[str(F('.003026674768'))]['strict_alpha_fail'],'Following C grid fails reserved alpha') + controls={} + for name,patch in [('unearned_128_H9',{9:128}),('extra_H1',{1:1})]: + if name.startswith('unearned'): + bad={'targets':dict(T),'paid':dict(P)};bad['targets'][9]+=128 + mutant_hash=hashlib.sha256(json.dumps(encode(bad),sort_keys=True,separators=(',',':')).encode()).hexdigest() + try: validate_invoice_claim(bad,data['candidate']) + except ValueError as error: controls[name]={'status':'invoice_mutant_rejected','reason':str(error),'added_target_count':128,'recomputed_proposed_invoice_sha256':mutant_hash} + else: raise ValueError('Unearned productive outputs escaped invoice validator') + else: + bad=dict(P);bad[1]+=1 + controls[name]={'margin_upper_at_5383':F(moment(T,1-F('.00302667'))[1]-moment(bad,1-F('.00302667'))[0],S)} + need(controls[name]['margin_upper_at_5383']<0,'Reject unpriced H1') + return {'status':'PASS_INDEPENDENT_EVENT_INVOICE_AND_EXACT_PRICES','method':'Integer fixed-point outward rounding 10^-65; rational atanh log series and exp Taylor geometric remainder; no author code imports', + 'raw_root_bracket':[low,high],'min_derivative_negation_lower':min(derivative_bounds),'remaining_moment_upper':max(rest),'variants':variants,'next_tested_1e-12_grid':next_tested_grid,'controls':controls, + 'independence_scope':'Fresh implementation of count/parser and interval arithmetic; no PR5377/5383/5387 or PR5384 arithmetic engine reused. Literal word and controller are common primary evidence.', + 'ceiling_scope':'Unique raw crossing of this exact signed profile for 0