From 03444336c7b327e12ab3b69dde4def7b8dfae27c Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Sun, 18 Oct 2026 21:23:15 -0500 Subject: [PATCH] research: audit minimal joint-output connector charge --- .../README.md | 131 ++++++++++++++++++ .../SOURCES.json | 42 ++++++ .../TASK.json | 67 +++++++++ .../VERIFY.json | 23 +++ .../verify.py | 125 +++++++++++++++++ 5 files changed, 388 insertions(+) create mode 100644 research/joint-output-connector-minimal-charge-247794/README.md create mode 100644 research/joint-output-connector-minimal-charge-247794/SOURCES.json create mode 100644 research/joint-output-connector-minimal-charge-247794/TASK.json create mode 100644 research/joint-output-connector-minimal-charge-247794/VERIFY.json create mode 100644 research/joint-output-connector-minimal-charge-247794/verify.py diff --git a/research/joint-output-connector-minimal-charge-247794/README.md b/research/joint-output-connector-minimal-charge-247794/README.md new file mode 100644 index 0000000000..ee89b0a401 --- /dev/null +++ b/research/joint-output-connector-minimal-charge-247794/README.md @@ -0,0 +1,131 @@ +# Minimal joint-output connector charge + +**Scoped connector-alphabet experiment; no new κ or supplier claim.** This +refines `connector-alphabet-change` to the smallest nonzero instance of one +output-side operation: two distinct output maps are applied to the same +connector in one joint readout record. The existing pair-source operation is +already treated in [PR #2056](../connector-pair-source-path-seed2cdb/README.md), +so this package checks the complementary output direction. + +## Exact interface change + +The fixed alphabet permits a single-target readout +`A_i: y_i += A_i z`. This experiment adds exactly one family + +```text +J_ik: (y_i, y_k) += (A_i z, A_k z), i != k +``` + +`J_ik` reads the one connector `z`, adds into two distinct output rows, leaves +`z` and all sources unchanged, restores its private scratch and tape heads, and +does not inspect either old target. Both maps are arbitrary fixed +`F_2`-linear maps. The operation is a **one-record premise change**: it must +account for both coefficient/map evaluations, both target updates, connector +routing, scratch restoration and head returns. Nothing in this package claims +that a real supplier currently implements that fused record. + +## Smallest dirty-state construction + +Use one source `x`, one arbitrarily dirty connector `z`, and two arbitrarily +dirty targets `y_i,y_k`. Let `B` be the source map and let the requested outputs +be `A_i Bx` and `A_k Bx`. Compare these schedules: + +```text +single-target alphabet: B, A_i, A_k, B, A_i, A_k +joint-output alphabet: J_ik, B, J_ik, B +``` + +Write `s = Bx` and let the initial connector be any `z0`. In the first +schedule, each target receives `A_r(z0+s) + A_r(z0) = A_r(s)`. In the second, +each receives `A_r(z0) + A_r(z0+s) = A_r(s)`. Both schedules leave `z=z0`; +neither changes `x`. This uses only additivity over `F_2`; no invertibility, +commutation, clean-row assumption or observation of intermediate outputs is +needed. The instance is minimal for this operation: one source gives a +nonzero requested term, and two distinct targets are required to exercise +`J_ik`. + +## Complete cost + +Let `c_B`, `c_i`, and `c_k` be the complete map-evaluation costs per additive +call, excluding root dispatch. They include the source/coefficient access, +arithmetic, target update, scratch restoration and head return. Let `D` be the +cost of one root record. Charge a joint readout as + +```text +cost(J_ik) = c_i + c_k + D + phi, +``` + +where `phi >= 0` is any extra shared-routing, fusion, storage or restoration +overhead not already counted in those two complete map costs or the one root +record. This explicitly pays for both `A` maps and targets. + +| Schedule | Map evaluations | Root records | Complete bill | +|---|---|---:|---| +| Original alphabet | `2 c_B + 2 c_i + 2 c_k` | 6 | `2 c_B + 2 c_i + 2 c_k + 6D` | +| With `J_ik` | `2 c_B + 2 c_i + 2 c_k` | 4 | `2 c_B + 2 c_i + 2 c_k + 4D + 2phi` | + +Therefore `C_joint - C_single = 2(phi-D)`. The joint operation is favorable +exactly when `phi < D`; at `phi = D` it ties, and above that it loses. If `J` +is implemented by invoking two ordinary root-level `A` calls, that pays the +second dispatch (`phi = D`) and yields no saving. A true one-record +implementation with no extra fusion surcharge would save `2D`, but remains an +unproved implementation obligation. No leaf-map work is removed in this +minimal instance. + +## Verification + +```sh +python3 -I -B research/joint-output-connector-minimal-charge-247794/verify.py +``` + +The standard-library checker enumerates all `16^3 * 4^4 = 1,048,576` +combinations of two-dimensional `F_2` maps `B,A_i,A_k` and arbitrary data +`x,z,y_i,y_k`. It checks both the output identity and connector restoration. +Three faulty schedules (missing one output update, missing the first dirty +cancellation readout, or missing final connector restoration) must fail. It +also checks the exact symbolic cost delta at `phi/D` values 0, 1 and 2. The +finite enumeration is a verifier check; the dimension-independent claim above +follows from the displayed linear identity. + +Registered replay and source pins: + +```sh +python3 scripts/research_package.py --package research/joint-output-connector-minimal-charge-247794 --check-only +python3.12 scripts/research_package.py --package research/joint-output-connector-minimal-charge-247794 +``` + +The package is pinned to base `20ecf2891d80b5acf18d980b2164fb44ea7faa90`, +priority revision 6. The selected record remains +`κ = 836330098538459/500000000000000000`; this experiment changes no selected +source, supplier, or frontier. It does not establish a real `J_ik` compiler, +an optimized caller, a reduced recursive interface tariff, or a new +multiplication bound. + +## Overlap and credit + +The current five-source scope map distinguishes fixed single-output calls, +pair-source calls and connector frames. Its pair-source predecessor already +accounts for two source accesses and arbitrary dirty replay. The live PR #3779 +at intake concerns overlapping six-window gate counts and source restoration; +it does not change this one-source/two-target alphabet definition. The offline +overlap search found no direct joint-output match, and current handoff comments +were checked for the same operation. Open PR #3604 (head +`7156bb98f78b7492002010e8729d59fe38b92e60`) is adjacent: it co-delivers +specialized P112 tetrad products to a fused port and a source-side dirty +correction, and leaves the native schedule and full scalar tariff open. This +package does not re-audit that factorization; `J_ik` is the generic operation +that applies two arbitrary `A` maps to two targets from the same connector, and +the cost calculation deliberately grants no shared-product leaf discount. +These checks are not proof of novelty. + +Credit Adam Gall and the contributors to the fixed-alphabet tariff and +pair-source connector results; this note does not supersede or restate their +theorems. Prepared by OpenAI Codex with substantial assistance. Apache-2.0. + +## Open next questions + +Can a caller-bound stacked map realize `J_ik` with all common-label, input +routing, output ownership, scratch and head costs included, at an overhead +`phi < D`? The next step is to instantiate one real supplier port and compare +its measured complete bill with the threshold above. Without such a caller and +tariff, do not extend this construction or infer a supplier improvement. diff --git a/research/joint-output-connector-minimal-charge-247794/SOURCES.json b/research/joint-output-connector-minimal-charge-247794/SOURCES.json new file mode 100644 index 0000000000..89334c8b0d --- /dev/null +++ b/research/joint-output-connector-minimal-charge-247794/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "docs/research/five-source-connector-scope-map.md", + "usage": "input", + "git_blob": "c4b56250e35eb52f07987f7e96c7dba18fac75d1", + "sha256": "5b541588a5ddb38b4dbbf5dca91cc9e6684f67462d515e25f838d833ec30f62f" + }, + { + "path": "research/connector-pair-source-path-seed2cdb/README.md", + "usage": "input", + "git_blob": "22aade420aef3f395792cac576a41a98d8c986f5", + "sha256": "ec2be09ba0ef27862ce880ae7bf2e0b6be3dd32fccaed70e0b6fd4e96d19e8d3" + }, + { + "path": "research/universal-connector-boundary/README.md", + "usage": "input", + "git_blob": "d277f7c5830b1f2bc42e1ff41ab86e7d7564929f", + "sha256": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476" + }, + { + "path": "research/universal-connector-boundary/verify.py", + "usage": "input", + "git_blob": "de6483bb7ff51940dbbb76c18f91af4c907e07da", + "sha256": "e4fa4700f9e1ae6ca09c3c76ebc569e8361b89b699425a67839d999d8812e42d" + } + ] +} diff --git a/research/joint-output-connector-minimal-charge-247794/TASK.json b/research/joint-output-connector-minimal-charge-247794/TASK.json new file mode 100644 index 0000000000..3bd5c74c81 --- /dev/null +++ b/research/joint-output-connector-minimal-charge-247794/TASK.json @@ -0,0 +1,67 @@ +{ + "schema_version": 1, + "task_id": "connector-alphabet-change", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "assignment": { + "seed": "2477945717b9b6d6cc55a36835a0d5aa", + "track": "recursive-interfaces", + "scope_key": "ff4f5113ed2256ab19ed" + }, + "original_card": { + "id": "connector-alphabet-change", + "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/universal-connector-boundary/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct and charge a legal extra operation on a minimal instance.", + "Prove a target-specific bound after adding one specified operation family." + ], + "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free. 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/universal-connector-boundary/verify.py" + ], + "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY", + "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.", + "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.", + "allowed_variations": [ + "Choose one additional operation and a small source count for its first counterexample." + ], + "scope_change_triggers": [ + "Keeping the alphabet and only increasing the source count; record this as a changed assignment.", + "Extending a source-count census without naming a supplier/interface decision it could change; audit #2973 pruning concerns before relying on the affected predecessor exclusions." + ], + "overlap_terms": [ + "universal connector", + "source-toggle", + "connector alphabet" + ] + }, + "scope_status": "refined", + "actual_scope": "On the smallest nonzero one-source, two-output instance, audit one extra joint-readout operation J_ik:(y_i,y_k)+=(A_i z,A_k z), including arbitrary dirty connector and target rows, and derive the exact fusion-overhead threshold for a complete-cost saving.", + "scope_change_reason": "The source-side pair operation B_jk already has a five-source construction, dirty replay and charged-access analysis in PR #2056; the current scope map records it. Refine the card to the distinct output-side joint-readout operation and the minimal instance, rather than repeating the pair-source word or the live six-window bill in PR #3779.", + "bottleneck_link": "Root dispatch savings from a multi-output connector readout count only if its real implementation overhead stays below the dispatch records it removes.", + "budget_minutes": 60, + "stop_rule": "Stop after the exact one-source/two-output dirty-state identity and full symbolic invoice. Do not expand the output alphabet or claim supplier benefit unless a concrete caller realizes J_ik with fusion overhead below one saved dispatch per use.", + "outcome": "completed", + "evidence": "A general F2-linear identity proves the four-record J_ik,B,J_ik,B schedule implements both outputs and restores arbitrary connector dirt. A stdlib verifier exhausts all 1,048,576 combinations of 2x2 linear maps and dirty data. Leaf map calls match the original six-record schedule; the complete delta is exactly 2(phi-D), so the extension wins only for fusion overhead phi < D.", + "ai_assistance": "Substantial OpenAI Codex assistance; the verifier and proof note were produced by this agent.", + "author": "OpenAI Codex (GPT-6 Luna xhigh; homelab-09)", + "open_questions": [ + { + "question": "Can a real selected-supplier caller implement a joint readout J_ik with total shared-routing and fusion overhead phi < D while preserving both dirty targets, connector frames, scratch and tape heads?", + "why_it_matters": "The minimal schedule's leaf work is unchanged; only an implementation below this exact threshold reduces the completed invoice.", + "first_step": "At one concrete caller port, write the stacked map's common-label/tape realization, account for both A_i and A_k coefficients and all routing/restoration, then compare its extra cost phi with one root dispatch D.", + "blocked_by": "No caller-bound fused output module or measured complete dispatch tariff is pinned in the current connector sources." + } + ] +} diff --git a/research/joint-output-connector-minimal-charge-247794/VERIFY.json b/research/joint-output-connector-minimal-charge-247794/VERIFY.json new file mode 100644 index 0000000000..d3a83b82a2 --- /dev/null +++ b/research/joint-output-connector-minimal-charge-247794/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "docs/research/five-source-connector-scope-map.md", + "research/connector-pair-source-path-seed2cdb/README.md", + "research/universal-connector-boundary/README.md", + "research/universal-connector-boundary/verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exhaust all 1,048,576 combinations of 2x2 F2 maps and arbitrary source/connector/two-target states; reject three dirty/output/restoration faults; verify exact cost break-even at phi/D = 0,1,2." + } + ] +} diff --git a/research/joint-output-connector-minimal-charge-247794/verify.py b/research/joint-output-connector-minimal-charge-247794/verify.py new file mode 100644 index 0000000000..8df565f8c3 --- /dev/null +++ b/research/joint-output-connector-minimal-charge-247794/verify.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +"""Exhaustively check the minimal joint-output dirty-state schedule. + +The proof in README.md is dimension-independent. This checker independently +enumerates every F2-linear map on F2^2 and every source, connector, and target +state, then rejects three deliberately faulty schedules and checks the exact +symbolic break-even formula. +""" + +from fractions import Fraction +from itertools import product + + +def require(condition, message): + if not condition: + raise AssertionError(message) + + +def parity(value): + return value.bit_count() & 1 + + +def apply(matrix, vector): + """Apply a 2x2 F2 matrix encoded as two row masks.""" + row0, row1 = matrix + return parity(row0 & vector) | (parity(row1 & vector) << 1) + + +def all_matrices(): + return tuple(product(range(4), repeat=2)) + + +def joint_readout(z, yi, yk, ai, ak, *, omit_ak=False): + yi ^= apply(ai, z) + if not omit_ak: + yk ^= apply(ak, z) + return yi, yk + + +def replay(ai, ak, b, x, z, yi, yk, *, omit_first=False, + omit_ak=False, omit_second=False, omit_final_b=False): + """Run J, B, J, B with optional faults used by negative controls.""" + if not omit_first: + yi, yk = joint_readout(z, yi, yk, ai, ak, omit_ak=omit_ak) + z ^= apply(b, x) + if not omit_second: + yi, yk = joint_readout(z, yi, yk, ai, ak, omit_ak=omit_ak) + if not omit_final_b: + z ^= apply(b, x) + return x, z, yi, yk + + +def expected(ai, ak, b, x, z0, yi0, yk0): + signal = apply(b, x) + return (x, z0, + yi0 ^ apply(ai, signal), + yk0 ^ apply(ak, signal)) + + +def check_positive_cases(): + matrices = all_matrices() + cases = 0 + for ai, ak, b in product(matrices, repeat=3): + for x, z, yi, yk in product(range(4), repeat=4): + got = replay(ai, ak, b, x, z, yi, yk) + want = expected(ai, ak, b, x, z, yi, yk) + require(got == want, + "joint-readout mismatch at case %d: %r != %r" % + (cases, got, want)) + cases += 1 + require(cases == 1_048_576, "unexpected exhaustive case count") + return cases + + +def check_negative_controls(): + identity = (1, 2) + zero = (0, 0) + controls = 0 + + # Omitting A_k from both joint records loses the second requested output. + args = (identity, identity, identity, 1, 0, 0, 0) + require(replay(*args, omit_ak=True) != expected(*args), + "control failed to expose a missing output update") + controls += 1 + + # With dirty z and Bx=0, the first J is needed to cancel A_r z0. + args = (identity, identity, zero, 0, 1, 0, 0) + require(replay(*args, omit_first=True) != expected(*args), + "control failed to expose missing dirty-state cancellation") + controls += 1 + + # The last B call is required to return the connector to its dirty entry. + args = (identity, identity, identity, 1, 0, 0, 0) + require(replay(*args, omit_final_b=True) != expected(*args), + "control failed to expose missing connector restoration") + controls += 1 + + return controls + + +def check_cost_threshold(): + # C_joint - C_single = 2(phi - D); report the ratio when D is normalized + # to one. Exact rationals avoid a floating-point break-even check. + def delta_over_d(phi_over_d): + return 2 * (phi_over_d - 1) + + require(delta_over_d(Fraction(0)) == -2, + "zero fusion overhead should save two dispatches") + require(delta_over_d(Fraction(1)) == 0, + "one dispatch of fusion overhead should tie") + require(delta_over_d(Fraction(2)) == 2, + "two dispatches of fusion overhead should lose by two dispatches") + return True + + +def main(): + cases = check_positive_cases() + controls = check_negative_controls() + check_cost_threshold() + print("PASS_JOINT_OUTPUT_CONNECTOR_MINIMAL cases=%d controls=%d " + "records=6_to_4 leaves_equal delta=2*(phi-D)" % (cases, controls)) + + +if __name__ == "__main__": + main()