From 539d3613af45706182f9ecc0e5a77cd189314737 Mon Sep 17 00:00:00 2001 From: CubeJerry <80299683+CubeJerry@users.noreply.github.com> Date: Wed, 28 Oct 2026 23:00:35 +0800 Subject: [PATCH] Prove a rank-two partial-observation boundary saving Resolve PR5968's independent-output question with exact two/three adapter minima, complete local accounting and independent dirty-input checks. Prepared for @CubeJerry with substantial OpenAI Codex assistance. Credit Nick Petalas, commdata2338 and the retained restoration lineage. No new kappa. --- .../rank-two-observation-boundary/PROOF.md | 162 +++++++++++ .../rank-two-observation-boundary/README.md | 140 ++++++++++ .../rank-two-observation-boundary/RESULT.json | 257 ++++++++++++++++++ .../SOURCES.json | 30 ++ .../rank-two-observation-boundary/TASK.json | 168 ++++++++++++ .../rank-two-observation-boundary/VERIFY.json | 49 ++++ .../rank-two-observation-boundary/model.py | 82 ++++++ .../test_faults.py | 100 +++++++ .../rank-two-observation-boundary/verify.py | 236 ++++++++++++++++ 9 files changed, 1224 insertions(+) create mode 100644 research/rank-two-observation-boundary/PROOF.md create mode 100644 research/rank-two-observation-boundary/README.md create mode 100644 research/rank-two-observation-boundary/RESULT.json create mode 100644 research/rank-two-observation-boundary/SOURCES.json create mode 100644 research/rank-two-observation-boundary/TASK.json create mode 100644 research/rank-two-observation-boundary/VERIFY.json create mode 100644 research/rank-two-observation-boundary/model.py create mode 100644 research/rank-two-observation-boundary/test_faults.py create mode 100644 research/rank-two-observation-boundary/verify.py diff --git a/research/rank-two-observation-boundary/PROOF.md b/research/rank-two-observation-boundary/PROOF.md new file mode 100644 index 0000000000..723584e95a --- /dev/null +++ b/research/rank-two-observation-boundary/PROOF.md @@ -0,0 +1,162 @@ +# Independent output updates still permit a cheaper boundary + +Prepared by @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0. +The model is commdata2338's PR2020; Nick Petalas's PR5968 asks the rank-two +question resolved here. This is a scoped written proof, with finite checks, +not a formal proof of integer multiplication. + +## Model and statement + +There are four arbitrary dirty coordinates `(d0,d1,w0,w1)=(x,y,a,b)` over +a nonzero vector space in characteristic two. Addition below denotes XOR for bits. +A compulsory, indivisible child `(o,s,t)` performs, in order, + +1. `d[o] += w[s]`; +2. `w[t] += w[1-t]`. + +An adapter is one of the two workspace additions or the four additions from +workspace to output. Each costs one. Finite adapter words are allowed before +the first child and after each child, never within a child. There are no free +gates, output feedback, output mixing, extra coordinates or clean-input premises. + +The eager reference undoes each child's workspace addition immediately. An +intermediate observation constrains the indicated output rows to equal that +reference; it does not read or alter workspace, feed back, or incur an operation +in this abstract gate model. At the final boundary all four coordinates must +equal the eager reference. Both comparators may retain noncanonical workspace. + +Fix children + +``` +(0,1,0), (0,0,0), (0,0,0), (1,0,1). +``` + +Observe both outputs after children 1 and 3, and only `d1` after child 2. +The complete final endpoint is + +``` +(x,y,a,b) -> (x+b,y+a,a,b). +``` + +The output-update matrix on `(a,b)` is `[[0,1],[1,0]]`, of rank two. For +q-bit coordinatewise streams with q>=1 it has rank `2q`. Neither output is redundant. + +**Theorem.** This partially observed fixed-child contract has exact adapter +minimum **2**. Observing both outputs after every child has exact minimum **3**. +Including all eight compulsory child gates, the minima are **10** and **11**. + +## Explicit attaining words + +Write `U: w0 += w1`, `L: w1 += w0`, and `D: d0 += w1`. +For partial observation, apply U after child 2 and L after child 3. + +| Boundary, including adapters | Actual state | Required eager outputs | +| --- | --- | --- | +| Child 1 | `(x+b,y,a+b,b)` | `(x+b,y)` | +| Child 2, U | `(x+a,y,a+b,b)` | only `d1=y` | +| Child 3, L | `(x+b,y,a,a+b)` | `(x+b,y)` | +| Child 4 | `(x+b,y+a,a,b)` | complete final state | + +The only discrepancy at any observed-output boundary would be b in d0 after +child 2; that output alone is hidden there. Both incoming dirty workspace +values are returned exactly, with no copy or erasure. + +For full observation, apply U at entry, L after child 1, and D after child 3. +The entry changes workspace to `(a+b,b)` and is charged. + +| Boundary, including adapters | Actual state | +| --- | --- | +| Child 1, L | `(x+b,y,a,a+b)` | +| Child 2 | `(x+a+b,y,b,a+b)` | +| Child 3, D | `(x+b,y,a,a+b)` | +| Child 4 | `(x+b,y+a,a,b)` | + +All four rows are checked at return. The full comparator is optimized over +the same alphabet, rather than restricted to eager workspace restoration. + +## Lower bounds without a search assumption + +Both workspace generators U and L are odd permutations of the three nonzero +vectors of `F2^2`. Data adapters leave workspace unchanged. Four compulsory +workspace shears have even parity. Therefore a restoring schedule uses an +even number of workspace adapters. With none, its workspace word is U,U,U,L, +which is nonidentity: `(a,b)` goes to `(a+b,a)`. Consequently any correct +schedule needs at least two workspace adapters. The partial word attains two. + +Suppose full observation were possible with at most two total adapters. The +preceding argument forces exactly two workspace adapters and no data adapters. +Subtracting consecutive fully observed output rows shows that children 2, 3 +and 4 must each read the incoming a from w0. After child 2, its U changes this +row to `a+w1`. The current workspace matrix is invertible, so its w1 row is +nonzero. At least one workspace adapter is required in the gap between children +2 and 3. The same argument requires one between children 3 and 4. + +Both adapters are thus spent in those two disjoint gaps. None is available +at entry or between children 1 and 2. But then child 1 leaves workspace +`(a+b,b)`, and child 2 reads `a+b`, not the required a. This is a contradiction. +Full observation needs at least three adapters; its displayed word attains three. + +The argument is about independent formal coefficient rows. Special values +such as b=0 do not invalidate it or establish arbitrary-input correctness. +It also proves the conclusion for nonzero characteristic-two vector spaces: the +allowed coefficients remain in F2 and the same formal identities apply. + +## Complete local bill and composition recurrence + +The displayed words have the following **complete** gate histograms. Entry, +correction and dirty restoration are included; the four children are retained. + +| Gate | Partial word | Full word | +| --- | ---: | ---: | +| `w0 += w1` | 4 | 4 | +| `w1 += w0` | 2 | 2 | +| `d0 += w0` | 2 | 2 | +| `d0 += w1` | 1 | 2 | +| `d1 += w0` | 1 | 1 | +| **Total** | **10** | **11** | + +Thus the difference between these two words is one output correction, with +both workspace restoration counts equal. For assigned gate prices u,l,r00, +r01,r10, their exact bills are `4u+2l+2r00+r01+r10` and that expression plus +r01. Optimality is claimed for unit prices only, not for arbitrary weights. + +For a literal q-bit stream XOR, define `X(0)=0`, `X(1)=1`, and +`X(q)=X(floor(q/2))+X(ceil(q/2))` for q>=2. There is no cross-bit mixing or +charged tape transport in this model, so `X(q)=q`. The complete fixed-child +bills are `P(q)=8X(q)+2X(q)=10q` and `F(q)=8X(q)+3X(q)=11q`. +Each XOR reads its two operands and writes its destination, giving 20q/22q +scalar reads and 10q/11q writes. Four dirty q-bit banks are occupied; additional +scratch, helper initialization, copying and erasure counts are zero. + +For m invocations with this same observation pattern and a complete four-bank +return required at each block boundary, the exact sequential recurrence is +`P_0(q)=F_0(q)=0`, +`P_(m+1)(q)=P_m(q)+10q`, and `F_(m+1)(q)=F_m(q)+11q`. +The all-dirty endpoint makes each invocation legal after the previous one. +This recurrence fixes each block boundary and forbids cross-block resynthesis; +it is not a lower bound when those boundaries or children may be removed. + +These are complete local scalar bills, **not** a recursive supplier tariff. +A physical integration must provide child implementations, observations, +native frame alignment, storage ownership, movement, precision and a full +caller invoice. None of those unknown costs is set to zero for the selected +multiplier. The result removes the rank-one limitation of a toy boundary; +it does not discharge a selected framework assumption. **No new kappa.** + +## Finite corroboration and search scope + +All words with zero, one or two adapters are enumerated, including entry, +repetitions and multiple ordered gates in one gap: counts are 1, 30 and 540. +Nondecreasing gap choices and every ordered gate tuple cover every shorter +schedule exactly once. Coefficient and separately written literal Boolean +engines agree on every boundary of every word for all 16 dirty inputs. +There are 9,136 executions and 18,272 observation-contract checks, plus 48 +positive-word executions. This finite replay corroborates the written proof; +it is not a formal proof of the full multiplication theorem. + +Discovery used CPython 3.12 `random.Random(57).shuffle` on the lexicographic +list of all 8^4 child chains, filtered for rank-two eager update. It completed +the first three qualifying chains and stopped at the first strict saving +through two adapters with only one hidden output at one cut. RESULT.json +records the exact inspected count and the first witness. This is not a census +of four-call chains, nor a claim of maximum possible saving in that domain. diff --git a/research/rank-two-observation-boundary/README.md b/research/rank-two-observation-boundary/README.md new file mode 100644 index 0000000000..b2237e02bb --- /dev/null +++ b/research/rank-two-observation-boundary/README.md @@ -0,0 +1,140 @@ +# A four-call saving with independent output updates + +**Scoped proof with exact finite corroboration. No new κ.** +Four fixed two-XOR children can return two independent output updates with +**two adapters instead of three** when one output at one intermediate cut +need not yet be correct. All arbitrary dirty workspace inputs are restored. +The complete local bills are **10 versus 11 XORs**, including entry work, +all children, correction and restoration. + +The endpoint is `(x,y,a,b) -> (x+b,y+a,a,b)`: the update matrix has rank two. +This answers the first **Open next question** in Nick Petalas's +[PR5968](https://github.com/CrocSwap/integer-mult-bounds/pull/5968), whose +example updates both outputs by the same input and has rank one. It uses +commdata2338's unchanged [PR2020](https://github.com/CrocSwap/integer-mult-bounds/pull/2020) +model. The predecessors' shorter-chain census and rank-one result are cited, +not claimed as new replays. No error in either predecessor is alleged. + +## Exact result and review path + +[PROOF.md](PROOF.md) gives the complete model, attaining words, short lower +bounds, dirty-input traces, gate histogram and composition recurrence. +Both optimizers may carry noncanonical workspace and use any of the six +adapters before or between the mandatory children. Thus 11 is the optimized +full-observation bill, rather than the eager bill of 12. + +The children are `(0,1,0), (0,0,0), (0,0,0), (1,0,1)` in PR2020 notation. +Only d0 after child 2 is hidden. The partial word adds `w1` into `w0` after +child 2 and `w0` into `w1` after child 3. The full word has a charged entry +adapter, a workspace adapter after child 1 and an output correction after +child 3. The difference in their complete gate histograms is exactly one +`d0 += w1`. Both original workspace values return without copying or erasure. + +[model.py](model.py) evaluates formal coefficient rows. [verify.py](verify.py) +also uses a separately written literal bit interpreter that does not call +those child semantics. It enumerates all **571** schedules of adapter costs +0, 1 and 2. Exactly two cost-two schedules satisfy the partial contract; +none satisfy full observation. The literal interpreter checks every boundary +on all 16 dirty inputs: **9,136 executions / 18,272 contract checks**, plus +48 executions of the three positive words. The written argument establishes +the nonzero characteristic-two vector-space statement; this finite replay is not +formal verification of the multiplication theorem. + +[RESULT.json](RESULT.json) is generated, not handwritten. It binds the exact +traces, counts, discovery coverage, predecessor inputs and implementation +hashes. Twelve semantic controls include a newly visible output, omitted +restoration, delayed correction, rank-one substitution, a clean-input false +positive and forbidden feedback. [test_faults.py](test_faults.py) injects +nine real faults per mode into private package/source copies and requires +the expected rejection in normal and optimized Python. + +## Reproduce + +Python 3.12, standard library only, from the repository root: + +```sh +python3 -B scripts/research_package.py --package research/rank-two-observation-boundary +``` + +Expected: `PASS_RANK_TWO_OBSERVATION_BOUNDARY rank=2 partial=2 full=3 xor=10/11 no_new_kappa` +in normal and optimized modes; `PASS_RANK_TWO_BOUNDARY_FAULTS rejected=18 modes=normal,optimized`; +then `PASS_REGISTERED_RESEARCH_PACKAGE`. + +Direct Git-free scientific replay is +`python3 -I -W error -B research/rank-two-observation-boundary/verify.py`. +It is read-only. To regenerate, pass `--write-result NEW_PATH` and compare +that new file with RESULT.json. An existing output path is refused. + +## Provenance and bounded selection + +Base: `721c03822c421b7f7fcbb2598993b947c4d88419`; priority revision 8. +[SOURCES.json](SOURCES.json) pins both predecessor contracts by Git blob and +SHA256 at this base, as well as the historical selected record and catalogue. +PR5968's publication head is `8a3fcbcbc6dd83f3f1af3e34df700847f35c9645`; +PR2020's is `f4f8d2afdd3fec60c7739dcd826497e9738f80c1`. Execution uses the +exact base-pinned contract files, not a moving PR head. No predecessor code +is imported. PR2020 is incorporated in the ledger; PR5968 is partially reviewed. + +Fresh OS randomness selected **57**, the recursive-interfaces track. The +catalogue's `joint-query-controller` card is marked **changed** in +[TASK.json](TASK.json): this is a historical abstract boundary side result, +not an active-mode injection or a changed supplier on the selected P104 word. +Three candidates and the local advance claim are recorded there. No pinned +sprint issue was found; the connector has no Discussion-writing operation. +The claim is local, with no separate reservation issue. + +Seed 57 shuffles all 4,096 four-child lists in the specified lexicographic +order. Rank-two filtering leaves three fully checked candidates among the +first eleven inspected lists before the first witness is found. Each of the +three completes all 571 shorter schedules; search then stops. The seed changes +ordering; the independent-output requirement is what distinguishes this work. +No complete four-call census or maximum saving claim is made. + +Open PR bodies, exact overlap searches, the ledger, relevant negative results +and visible Discussion1166 handoffs were checked before selection. The local +overlap helper reports sparse coverage and unavailable CLI remote refresh; +the GitHub connector supplies the separate live checks. Neither search +coverage nor the absence of a match excludes unpublished work. Freshness and +the final compatibility decision are recorded in TASK.json. + +## Limits + +If the mandatory children can be replaced, two direct XORs implement the +endpoint. Ten is therefore not an unrestricted circuit minimum. Observations +are read-only correctness constraints in this model, not a physical consumer. +The exact 10q/11q bit bill and returned-block recurrence in PROOF.md assume +coordinatewise XORs without cross-bit mixing or tape transport. They must not +be substituted for a native recursive-child tariff. + +No actual recursive caller, physical observation service, native alignment, +stock allocation, tape movement, finite precision or complete outer invoice +is supplied. All five selected framework assumptions remain. The selected +κ=781451/250000000 is unchanged. Source-binding orientation is distinct from +the selected scientific cold replay, which was not run. No hosted CI, +independent human acceptance or proof-kernel verification is claimed. + +## Open next questions + +Does a named mandatory child chain in an actual caller +permit this exact missing observation? First extract its input/output maps, +all later reads and dirty returns, then compare the complete physical bill. +Without those contracts, further abstract enumeration would not establish +a useful supplier improvement. This package stops at the rank-two witness. + +Power of Ten scope: managed Python allocates bounded tuples, lists and integers. +The finite verifier uses four rows, five gaps, 571 shorter schedules streamed +one at a time, 16 inputs and a 4,096-chain ordering. The fault harness alone +uses bounded subprocesses and private temporary copies. No scientific +network access or dynamic predecessor import occurs. + +## Credit + +Prepared for **@CubeJerry** with substantial **OpenAI Codex** assistance. +Credit Nick Petalas's PR5968 for the explicit rank-two handoff and its +rank-one witness; commdata2338's PR2020 for the model and earlier census; +Aaron Wang / navinor's PR1155, Adam Gall's observer-safe restoration and +Sagar Thakrar's restored-cut planner for the retained lineage. The classical +linear-circuit and permutation-parity arguments are not claimed as new. +This contribution supplies one independent-update witness, its sharp minima, +full local accounting and reproducible checks. New files are Apache-2.0; +predecessor files, licenses and attribution remain unchanged. diff --git a/research/rank-two-observation-boundary/RESULT.json b/research/rank-two-observation-boundary/RESULT.json new file mode 100644 index 0000000000..3b80826969 --- /dev/null +++ b/research/rank-two-observation-boundary/RESULT.json @@ -0,0 +1,257 @@ +{ + "children": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 0 + ], + [ + 0, + 0, + 0 + ], + [ + 1, + 0, + 1 + ] + ], + "claim_type": "scoped written proof with exact finite corroboration", + "complete_gate_histograms": { + "full": { + "0<-2": 2, + "0<-3": 2, + "1<-2": 1, + "2<-3": 4, + "3<-2": 2 + }, + "partial": { + "0<-2": 2, + "0<-3": 1, + "1<-2": 1, + "2<-3": 4, + "3<-2": 2 + } + }, + "complete_xor_bills": { + "eager": 12, + "full": 11, + "partial": 10 + }, + "discovery": { + "chain_domain": 4096, + "completed_rank_two_chains": 3, + "hidden_error_masks": [ + 0, + 1, + 0 + ], + "inspected_chains": 11, + "seed": 57, + "shorter_schedules_per_chain": 571, + "stopping_rule": "first strict one-hidden-cut witness through two adapters" + }, + "enumeration": { + "full_hits": [ + 0, + 0, + 0 + ], + "literal_contract_checks": 18272, + "literal_executions": 9136, + "partial_hits": [ + 0, + 0, + 2 + ], + "schedules_by_cost": [ + 1, + 30, + 540 + ] + }, + "final_rows": [ + 9, + 6, + 4, + 8 + ], + "implementation_sha256": { + "model.py": "adbe7d32b433fd5e8372f7b64f701cc6764cdd99764b9ddbd74a00dabea8e2d5", + "verify.py": "7324a4b738e7b77550c8bc3de9d1f7b509d0c1770272bf0f37d26b25633691e5" + }, + "no_new_kappa": true, + "partial_masks": [ + 3, + 2, + 3, + 3 + ], + "schema": "rank-two-observation-boundary/1", + "semantic_controls": 12, + "source_sha256": { + "research/four-call-productive-observations/README.md": "c6d2bbf3a0497855e779a4fead13e5fd0d83d01a2ded7f083bd5e69a6da577a0", + "research/partial-observation-boundaries/README.md": "72ddf7a70241b4b02749361149287772dc39def8d86ec6ffd5eddeaf2470609c" + }, + "update_rank": 2, + "words": { + "eager": { + "adapters": 4, + "trace": [ + [ + 9, + 2, + 4, + 8 + ], + [ + 13, + 2, + 4, + 8 + ], + [ + 9, + 2, + 4, + 8 + ], + [ + 9, + 6, + 4, + 8 + ] + ], + "word": [ + [], + [ + [ + 2, + 3 + ] + ], + [ + [ + 2, + 3 + ] + ], + [ + [ + 2, + 3 + ] + ], + [ + [ + 3, + 2 + ] + ] + ] + }, + "full": { + "adapters": 3, + "trace": [ + [ + 9, + 2, + 4, + 12 + ], + [ + 13, + 2, + 8, + 12 + ], + [ + 9, + 2, + 4, + 12 + ], + [ + 9, + 6, + 4, + 8 + ] + ], + "word": [ + [ + [ + 2, + 3 + ] + ], + [ + [ + 3, + 2 + ] + ], + [], + [ + [ + 0, + 3 + ] + ], + [] + ] + }, + "partial": { + "adapters": 2, + "trace": [ + [ + 9, + 2, + 12, + 8 + ], + [ + 5, + 2, + 12, + 8 + ], + [ + 9, + 2, + 4, + 12 + ], + [ + 9, + 6, + 4, + 8 + ] + ], + "word": [ + [], + [], + [ + [ + 2, + 3 + ] + ], + [ + [ + 3, + 2 + ] + ], + [] + ] + } + } +} diff --git a/research/rank-two-observation-boundary/SOURCES.json b/research/rank-two-observation-boundary/SOURCES.json new file mode 100644 index 0000000000..ef1218b0c8 --- /dev/null +++ b/research/rank-two-observation-boundary/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "721c03822c421b7f7fcbb2598993b947c4d88419", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/four-call-productive-observations/README.md", + "usage": "input", + "git_blob": "1109df11eb1d56fe23d19bcfc9dbb929252a8418", + "sha256": "c6d2bbf3a0497855e779a4fead13e5fd0d83d01a2ded7f083bd5e69a6da577a0" + }, + { + "path": "research/partial-observation-boundaries/README.md", + "usage": "input", + "git_blob": "06692e56721422d797f0f8f7d2be5a29428d2ae7", + "sha256": "72ddf7a70241b4b02749361149287772dc39def8d86ec6ffd5eddeaf2470609c" + } + ] +} diff --git a/research/rank-two-observation-boundary/TASK.json b/research/rank-two-observation-boundary/TASK.json new file mode 100644 index 0000000000..980ac2671b --- /dev/null +++ b/research/rank-two-observation-boundary/TASK.json @@ -0,0 +1,168 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 8, + "base_commit": "721c03822c421b7f7fcbb2598993b947c4d88419", + "original_card": { + "id": "joint-query-controller", + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Resolve PR5968 Open next question 1: a four-call partial-observation saving with linearly independent final output updates in the unchanged PR2020 model.", + "scope_change_reason": "The live explicit unclaimed handoff is a bounded historical interface side result. It changes the catalogue current-supplier assignment; it is not active-mode delivery, a selected P104 edit, or a new target credit.", + "bottleneck_link": "Shows that avoiding an output correction need not rely on redundant output updates. Actual recursive caller applicability and its complete physical invoice remain open.", + "budget_minutes": 120, + "stop_rule": "Stop at the first seed-57 rank-two chain admitting a strict saving through two adapters with exactly one hidden output/cut; prove both minima and finish one package. No four-call census or wider construction round.", + "outcome": "completed", + "evidence": "PROOF.md and generated RESULT.json: rank-two endpoint, exact two/three adapter minima, all 571 shorter schedules, independent literal checks on all 16 dirty inputs and complete 10/11 gate histograms.", + "author": "@CubeJerry", + "ai_assistance": "Substantial OpenAI Codex assistance for task selection, mathematics, implementation, checks, documentation and publication; prepared for @CubeJerry.", + "open_questions": [ + { + "question": "Does one named actual mandatory child chain permit the exact missing d0 observation after child 2?", + "why_it_matters": "Only a legal caller binding and favorable complete bill could turn this local interface saving into a supplier improvement.", + "first_step": "Extract its child maps, all later readers, native interfaces and dirty-return obligations, then price the literal changed word including observation and movement.", + "blocked_by": "No qualifying recursive/native caller or physical cost/precision/ownership contract has been provided." + } + ], + "random_assignment": { + "source": "OS randomness via secrets.randbelow(100)", + "integer": 57, + "track": "recursive-interfaces", + "picker_seed": "00000000000000000000000000000039" + }, + "candidates": [ + { + "object": "PR6127 counterless DDG binary lowering", + "decision": "not selected; wider physical controller and tape closure" + }, + { + "object": "PR6024 reversal-free convolution in a Gaussian caller", + "decision": "not selected; wider rounded layout and native closure" + }, + { + "object": "PR5968 independent-output four-call observation boundary", + "decision": "selected; explicit open question, different rank condition, complete small interface" + } + ], + "coordination": { + "claim_time_utc": "2026-10-28T14:28:00Z", + "claim_location": "local TASK.json; original advance note outside the checkout", + "publication_access": "No pinned sprint issue found; only issue913 open. Connected GitHub tools provide no Discussion-writing operation. No separate reservation issue opened.", + "expected_finish_utc": "2026-10-28T16:15:30Z", + "claim_scope": "PR5968 rank-two open question, six adapters, four mandatory children; exact witness/minima or complete bounded obstruction." + }, + "freshness": [ + { + "checked_at_utc": "2026-10-28T14:15:30Z", + "upstream_commit": "721c03822c421b7f7fcbb2598993b947c4d88419", + "priority_revision": 8, + "decision": "Fresh canonical-main branch, selected certificate PR6030 traced through construction and review. Historical PR5599 prose not treated as current." + }, + { + "checked_at_utc": "2026-10-28T14:49:11.774364+00:00", + "upstream_commit": "721c03822c421b7f7fcbb2598993b947c4d88419", + "priority_revision": 8, + "decision": "Canonical fetch and connected upstream/fork main agree. No guidance, selected-record or predecessor changes; retain frozen scientific inputs. Focused overlap refresh found no competing rank-two observation-boundary result." + } + ], + "overlap": { + "live_queries": [ + "5968", + "rank-two observation", + "independent four-call" + ], + "review_ledger": { + "2020": "incorporated", + "5968": "partially reviewed" + }, + "live_coverage": "Latest 100 open PR bodies and focused all-state searches; visible Discussion1166 handoffs; no exact competing claim found.", + "limitations": "Local helper coverage sparse; gh remote refresh unavailable. Separate GitHub connector queries do not exclude unpublished work or unpaginated Discussion comments.", + "selected_baseline": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY after materializing the complete selected source closure; no scientific cold replay." + }, + "search": { + "chain_domain": 4096, + "completed_rank_two_chains": 3, + "hidden_error_masks": [ + 0, + 1, + 0 + ], + "inspected_chains": 11, + "seed": 57, + "shorter_schedules_per_chain": 571, + "stopping_rule": "first strict one-hidden-cut witness through two adapters" + }, + "selected_kappa": "781451/250000000", + "kappa_change": "No new κ", + "validation": { + "python": "CPython 3.12.14", + "dependencies": "standard library only", + "registered": "Normal and optimized scientific verification plus all 18 private-copy fault rejections passed.", + "selected_orientation": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "not_run": [ + "selected scientific cold replay", + "predecessor scientific suites", + "Lean", + "Docker", + "hosted CI" + ], + "publication_branch": "research/rank-two-boundary-seed57-20261028" + } +} diff --git a/research/rank-two-observation-boundary/VERIFY.json b/research/rank-two-observation-boundary/VERIFY.json new file mode 100644 index 0000000000..f8c96573aa --- /dev/null +++ b/research/rank-two-observation-boundary/VERIFY.json @@ -0,0 +1,49 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/four-call-productive-observations/README.md", + "research/partial-observation-boundaries/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Exact positive words, full coefficient/literal agreement for 571 shorter schedules and all dirty inputs, rank-two endpoint, discovery coverage, source pins and generated receipt." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Same scientific obligations with assertions disabled." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/test_faults.py" + ], + "timeout_seconds": 120, + "checks": "Eighteen real private-copy fault rejections in normal/optimized modes, read-only positives and overwrite refusal." + } + ] +} diff --git a/research/rank-two-observation-boundary/model.py b/research/rank-two-observation-boundary/model.py new file mode 100644 index 0000000000..d741765a4e --- /dev/null +++ b/research/rank-two-observation-boundary/model.py @@ -0,0 +1,82 @@ +"""Exact coefficient semantics. @CubeJerry with OpenAI Codex. Apache-2.0. + +Model: commdata2338 PR2020; open question: Nick Petalas PR5968. +""" +from itertools import combinations_with_replacement, product + +ADAPTERS = ((2, 3), (3, 2), (0, 2), (0, 3), (1, 2), (1, 3)) +CHILDREN = ((0, 1, 0), (0, 0, 0), (0, 0, 0), (1, 0, 1)) +PARTIAL_MASKS = (3, 2, 3, 3) +FULL_MASKS = (3, 3, 3, 3) +PARTIAL_WORD = ((), (), ((2, 3),), ((3, 2),), ()) +FULL_WORD = (((2, 3),), ((3, 2),), (), ((0, 3),), ()) +EAGER_WORD = ((), ((2, 3),), ((2, 3),), ((2, 3),), ((3, 2),)) +IDENTITY = (1, 2, 4, 8) +FINAL = (9, 6, 4, 8) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def validate(children, schedule): + require(len(children) == 4, "four compulsory children") + require(all(len(c) == 3 and all(type(v) is int and v in (0, 1) + for v in c) for c in children), "child alphabet") + require(len(schedule) == 5, "five adapter gaps") + require(sum(map(len, schedule)) <= 4, "bounded certificate word") + require(all(g in ADAPTERS for gap in schedule for g in gap), + "six-adapter alphabet; no output feedback") + + +def reference(children=CHILDREN): + state = list(IDENTITY) + rows = [] + for output, source, _target in children: + state[output] ^= 1 << (2 + source) + rows.append(tuple(state)) + return tuple(rows) + + +def coefficient_trace(schedule, children=CHILDREN): + validate(children, schedule) + state = list(IDENTITY) + for destination, source in schedule[0]: + state[destination] ^= state[source] + trace = [] + for i, (output, source, target) in enumerate(children): + state[output] ^= state[2 + source] + state[2 + target] ^= state[3 - target] + for destination, source in schedule[i + 1]: + state[destination] ^= state[source] + trace.append(tuple(state)) + return tuple(trace) + + +def accepts(trace, masks, children=CHILDREN): + require(len(trace) == len(masks) == 4 and masks[-1] == 3, + "four observations with both final outputs") + require(all(type(m) is int and m in (1, 2, 3) for m in masks), + "nonempty observation masks") + wanted = reference(children) + return trace[-1] == wanted[-1] and all( + not (mask & (1 << out)) or row[out] == goal[out] + for row, goal, mask in zip(trace, wanted, masks, strict=True) + for out in (0, 1)) + + +def schedules(count): + require(type(count) is int and 0 <= count <= 3, "enumeration count 0..3") + for gaps in combinations_with_replacement(range(5), count): + for gates in product(ADAPTERS, repeat=count): + word = [[] for _ in range(5)] + for gap, gate in zip(gaps, gates, strict=True): + word[gap].append(gate) + yield tuple(tuple(gap) for gap in word) + + +def update_rank(children=CHILDREN): + rows = reference(children)[-1] + a, b = (rows[0] ^ 1) >> 2, (rows[1] ^ 2) >> 2 + return 0 if not (a or b) else 1 + int(bool(a and b and a != b)) diff --git a/research/rank-two-observation-boundary/test_faults.py b/research/rank-two-observation-boundary/test_faults.py new file mode 100644 index 0000000000..eb059c0640 --- /dev/null +++ b/research/rank-two-observation-boundary/test_faults.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +"""Reject real faults in private package copies; never mutate the checkout. + +@CubeJerry with OpenAI Codex assistance. Apache-2.0. +""" +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def snapshot(root): + return {str(p.relative_to(root)): hashlib.sha256(p.read_bytes()).hexdigest() + for p in sorted(root.rglob("*")) if p.is_file()} + + +def faults(): + return ( + ("RESULT.json", '"update_rank": 2', '"update_rank": 1', "committed RESULT"), + ("RESULT.json", '"partial": 10', '"partial": 9', "committed RESULT"), + ("RESULT.json", '"completed_rank_two_chains": 3', + '"completed_rank_two_chains": 4', "committed RESULT"), + ("model.py", "PARTIAL_WORD = ((), (), ((2, 3),), ((3, 2),), ())", + "PARTIAL_WORD = ((), (), ((2, 3),), (), ())", "positive coefficient word"), + ("model.py", "PARTIAL_MASKS = (3, 2, 3, 3)", + "PARTIAL_MASKS = (3, 3, 3, 3)", "positive coefficient word"), + ("model.py", "CHILDREN = ((0, 1, 0), (0, 0, 0), (0, 0, 0), (1, 0, 1))", + "CHILDREN = ((0, 1, 0), (0, 0, 0), (0, 0, 0), (1, 1, 1))", + "independent final updates"), + ("model.py", "PARTIAL_WORD = ((), (), ((2, 3),), ((3, 2),), ())", + "PARTIAL_WORD = (((2, 0),), (), ((2, 3),), ((3, 2),), ())", "alphabet"), + ) + + +def run(copy, optimized, expected=None, extra=()): + args = [sys.executable, "-I", "-W", "error", "-B"] + if optimized: + args.append("-O") + result = subprocess.run([*args, str(copy / "verify.py"), *extra], + cwd=copy.parent.parent.parent, capture_output=True, + text=True, timeout=30, check=False) + if expected is None: + require(result.returncode == 0 and "PASS_RANK_TWO" in result.stdout, + "private-copy positive control") + else: + require(result.returncode != 0 and expected in result.stderr, + "fault not rejected for the expected reason: " + expected) + + +def main(): + require(not sys.argv[1:], "no fault-test arguments") + sources = json.loads((HERE / "SOURCES.json").read_text()) + original = snapshot(HERE) + cases = 0 + with tempfile.TemporaryDirectory(prefix="rank-two-boundary-faults-") as temp: + root = Path(temp) + copy = root / "research" / HERE.name + shutil.copytree(HERE, copy) + for row in sources["files"]: + if row["usage"] == "input": + dest = root / row["path"] + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT / row["path"], dest) + for optimized in (False, True): + before = snapshot(root) + run(copy, optimized) + require(snapshot(root) == before, "verification must be read-only") + for filename, old, new, expected in faults(): + target = copy / filename + saved = target.read_text() + require(saved.count(old) == 1, "unique fault injection") + target.write_text(saved.replace(old, new), encoding="utf-8") + run(copy, optimized, expected) + target.write_text(saved, encoding="utf-8") + cases += 1 + source = root / "research/four-call-productive-observations/README.md" + saved = source.read_bytes() + source.write_bytes(saved + b"\ncorrupted source\n") + run(copy, optimized, "source pin") + source.write_bytes(saved) + run(copy, optimized, "FileExistsError", ("--write-result", str(copy / "RESULT.json"))) + require(snapshot(root) == before, "controls must restore private copies") + cases += 2 + require(snapshot(HERE) == original, "original package changed") + print(f"PASS_RANK_TWO_BOUNDARY_FAULTS rejected={cases} modes=normal,optimized") + + +if __name__ == "__main__": + main() diff --git a/research/rank-two-observation-boundary/verify.py b/research/rank-two-observation-boundary/verify.py new file mode 100644 index 0000000000..ffbb2aff23 --- /dev/null +++ b/research/rank-two-observation-boundary/verify.py @@ -0,0 +1,236 @@ +#!/usr/bin/env python3 +"""Read-only verification; --write-result creates a new receipt exclusively. + +Prepared by @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0. +No predecessor scientific implementation is imported. +""" +import argparse +from collections import Counter +import hashlib +import itertools +import json +from pathlib import Path +import random +import runpy + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +M = runpy.run_path(str(HERE / "model.py")) +need = M["require"] + + +def authenticate(): + sources = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + checked = {} + for row in sources["files"]: + if row["usage"] == "input": + path = ROOT / row["path"] + need(path.is_file() and not path.is_symlink(), "regular pinned input") + data = path.read_bytes() + need(len(data) <= 32768, "bounded source contract") + digest = hashlib.sha256(data).hexdigest() + need(digest == row["sha256"], "source pin: " + row["path"]) + checked[row["path"]] = digest + need(len(checked) == 2, "two predecessor contracts") + return checked + + +def literal_trace(word, initial): + """Independent bit execution with literal, fixed child bodies.""" + registers = list(initial) + trace = [] + for cut in range(5): + if cut == 1: + registers[0] = (registers[0] + registers[3]) % 2 + registers[2] = (registers[2] + registers[3]) % 2 + elif cut in (2, 3): + registers[0] = (registers[0] + registers[2]) % 2 + registers[2] = (registers[2] + registers[3]) % 2 + elif cut == 4: + registers[1] = (registers[1] + registers[2]) % 2 + registers[3] = (registers[3] + registers[2]) % 2 + for destination, source in word[cut]: + registers[destination] = (registers[destination] + registers[source]) % 2 + if cut: + trace.append(tuple(registers)) + return tuple(trace) + + +def literal_accepts(trace, initial, full): + x, y, a, b = initial + wanted = ((x ^ b, y), (x ^ a ^ b, y), (x ^ b, y), (x ^ b, y ^ a)) + good = trace[-1] == (*wanted[-1], a, b) + for cut in range(4): + good &= trace[cut][1] == wanted[cut][1] + if full or cut != 1: + good &= trace[cut][0] == wanted[cut][0] + return good + + +def enumerate_shorter(): + counts, partial_hits, full_hits = [], [], [] + executions = 0 + for count in range(3): + seen = partial = full = 0 + for word in M["schedules"](count): + rows = M["coefficient_trace"](word) + p = M["accepts"](rows, M["PARTIAL_MASKS"]) + f = M["accepts"](rows, M["FULL_MASKS"]) + lp = lf = True + for initial in itertools.product((0, 1), repeat=4): + bits = literal_trace(word, initial) + packed = sum(v << i for i, v in enumerate(initial)) + expected = tuple(tuple((row & packed).bit_count() % 2 for row in state) + for state in rows) + need(bits == expected, "coefficient/literal trace disagreement") + lp &= literal_accepts(bits, initial, False) + lf &= literal_accepts(bits, initial, True) + executions += 1 + need((p, f) == (lp, lf), "independent observation disagreement") + partial += p + full += f + seen += 1 + counts.append(seen) + partial_hits.append(partial) + full_hits.append(full) + need(counts == [1, 30, 540], "complete shorter-word domain") + need(partial_hits[:2] == [0, 0] and partial_hits[2] > 0, "partial minimum two") + need(full_hits == [0, 0, 0], "full minimum at least three") + return dict(schedules_by_cost=counts, partial_hits=partial_hits, + full_hits=full_hits, literal_executions=executions, + literal_contract_checks=2 * executions) + + +def positive_words(): + need(M["reference"]()[-1] == M["FINAL"], "independent final updates") + need(M["update_rank"]() == 2, "rank-two endpoint") + traces = {} + for name, key, masks, full in ( + ("partial", "PARTIAL_WORD", "PARTIAL_MASKS", False), + ("full", "FULL_WORD", "FULL_MASKS", True), + ("eager", "EAGER_WORD", "FULL_MASKS", True)): + word = M[key] + rows = M["coefficient_trace"](word) + need(M["accepts"](rows, M[masks]), "positive coefficient word") + for initial in itertools.product((0, 1), repeat=4): + need(literal_accepts(literal_trace(word, initial), initial, full), + "positive arbitrary dirty input") + traces[name] = dict(word=word, trace=rows, adapters=sum(map(len, word))) + return traces + + +def rejects(call, phrase): + try: + call() + except ValueError as error: + need(phrase in str(error), "rejection reason") + return + raise ValueError("invalid domain accepted") + + +def controls(): + p = M["PARTIAL_WORD"] + trace = M["coefficient_trace"](p) + need(not M["accepts"](trace, M["FULL_MASKS"]), "newly visible output") + need(trace[1][0] ^ M["reference"]()[1][0] == 8, "hidden defect is incoming b") + missing_u = ((), (), (), p[3], ()) + missing_l = ((), (), p[2], (), ()) + moved_u = ((), (), (), p[2] + p[3], ()) + for word in (missing_u, missing_l, moved_u): + need(not M["accepts"](M["coefficient_trace"](word), M["PARTIAL_MASKS"]), + "omitted or delayed adapter") + bad_return = M["coefficient_trace"](missing_l)[-1] + need(bad_return[:2] == M["FINAL"][:2] and bad_return[2:] != (4, 8), + "retained outputs alone miss failed dirty return") + for initial, expected in (((0, 0, 0, 0), True), ((0, 0, 0, 1), False)): + need(literal_accepts(literal_trace(p, initial), initial, True) == expected, + "clean-only false positive and dirty counterexample") + rank_one = (*M["CHILDREN"][:-1], (1, 1, 1)) + need(M["update_rank"](rank_one) == 1, "duplicate nonzero updates are not independent") + rejects(lambda: M["coefficient_trace"]((((2, 0),), (), (), (), ())), "alphabet") + rejects(lambda: M["coefficient_trace"](p[:-1]), "gaps") + rejects(lambda: M["accepts"](trace, (3, 0, 3, 3)), "masks") + return 12 + + +def discovery(): + """Replay the declared first-witness search, not a four-call census.""" + chains = list(itertools.product(tuple(itertools.product((0, 1), repeat=3)), repeat=4)) + random.Random(57).shuffle(chains) + tested = inspected = 0 + for chain in chains: + inspected += 1 + if M["update_rank"](chain) != 2: + continue + tested += 1 + full_min = 3 + candidates = [] + for count in range(3): + for word in M["schedules"](count): + rows = M["coefficient_trace"](word, chain) + ref = M["reference"](chain) + if rows[-1] != ref[-1]: + continue + errors = tuple(sum((rows[i][o] != ref[i][o]) << o for o in (0, 1)) + for i in range(3)) + if not any(errors): + full_min = min(full_min, count) + elif sum(e.bit_count() for e in errors) == 1: + candidates.append((count, word, errors)) + for count, word, errors in candidates: + if count < full_min: + need(chain == M["CHILDREN"] and word == M["PARTIAL_WORD"], + "first seed-57 witness changed") + return dict(seed=57, chain_domain=4096, inspected_chains=inspected, + completed_rank_two_chains=tested, shorter_schedules_per_chain=571, + stopping_rule="first strict one-hidden-cut witness through two adapters", + hidden_error_masks=errors) + raise ValueError("the declared first witness was not found") + + +def invoices(): + bills = {} + for name, key in (("partial", "PARTIAL_WORD"), ("full", "FULL_WORD")): + gates = Counter(g for gap in M[key] for g in gap) + for output, source, target in M["CHILDREN"]: + gates[(output, 2 + source)] += 1 + gates[(2 + target, 3 - target)] += 1 + bills[name] = gates + need(bills["full"] == bills["partial"] + Counter({(0, 3): 1}), + "complete histograms differ by one output correction") + need(sum(bills["partial"].values()) == 10 and sum(bills["full"].values()) == 11, + "all child and adapter gates charged") + return {name: {f"{d}<-{s}": count for (d, s), count in sorted(gates.items())} + for name, gates in bills.items()} + + +def result(): + pins = authenticate() + return dict(schema="rank-two-observation-boundary/1", no_new_kappa=True, + claim_type="scoped written proof with exact finite corroboration", + children=M["CHILDREN"], partial_masks=M["PARTIAL_MASKS"], + final_rows=M["FINAL"], update_rank=2, words=positive_words(), + enumeration=enumerate_shorter(), semantic_controls=controls(), + discovery=discovery(), complete_gate_histograms=invoices(), + complete_xor_bills=dict(partial=10, full=11, eager=12), + source_sha256=pins, implementation_sha256={ + name: hashlib.sha256((HERE / name).read_bytes()).hexdigest() + for name in ("model.py", "verify.py")}) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", type=Path) + args = parser.parse_args() + data = json.dumps(result(), sort_keys=True, indent=2) + "\n" + if args.write_result is not None: + with args.write_result.open("x", encoding="utf-8", newline="\n") as stream: + stream.write(data) + else: + need((HERE / "RESULT.json").read_text(encoding="utf-8") == data, + "committed RESULT differs from recomputed mathematics") + print("PASS_RANK_TWO_OBSERVATION_BOUNDARY rank=2 partial=2 full=3 xor=10/11 no_new_kappa") + + +if __name__ == "__main__": + main()