From 890fadd4683ac206fa0c39ad58ff80932bdba26b Mon Sep 17 00:00:00 2001 From: d3lerium Date: Fri, 23 Oct 2026 08:46:35 +1100 Subject: [PATCH 1/2] Screen the complete complementary serial consumer bill --- .../.gitattributes | 1 + .../OVERLAP.json | 27 +++ .../PROOF.md | 94 +++++++++++ .../README.md | 21 +++ .../RESULT.json | 88 ++++++++++ .../SNAPSHOTS.json | 37 +++++ .../SOURCES.json | 18 ++ .../TASK.json | 66 ++++++++ .../VALIDATION.json | 22 +++ .../VERIFY.json | 20 +++ .../inputs/AUDIT.md | 142 ++++++++++++++++ .../inputs/B.json | 35 ++++ .../inputs/C.json | 60 +++++++ .../inputs/INTERFACE.md | 61 +++++++ .../inputs/PREDECESSOR.md | 156 ++++++++++++++++++ .../verify.py | 97 +++++++++++ 16 files changed, 945 insertions(+) create mode 100644 research/complementary-consumer-feasibility/.gitattributes create mode 100644 research/complementary-consumer-feasibility/OVERLAP.json create mode 100644 research/complementary-consumer-feasibility/PROOF.md create mode 100644 research/complementary-consumer-feasibility/README.md create mode 100644 research/complementary-consumer-feasibility/RESULT.json create mode 100644 research/complementary-consumer-feasibility/SNAPSHOTS.json create mode 100644 research/complementary-consumer-feasibility/SOURCES.json create mode 100644 research/complementary-consumer-feasibility/TASK.json create mode 100644 research/complementary-consumer-feasibility/VALIDATION.json create mode 100644 research/complementary-consumer-feasibility/VERIFY.json create mode 100644 research/complementary-consumer-feasibility/inputs/AUDIT.md create mode 100644 research/complementary-consumer-feasibility/inputs/B.json create mode 100644 research/complementary-consumer-feasibility/inputs/C.json create mode 100644 research/complementary-consumer-feasibility/inputs/INTERFACE.md create mode 100644 research/complementary-consumer-feasibility/inputs/PREDECESSOR.md create mode 100644 research/complementary-consumer-feasibility/verify.py diff --git a/research/complementary-consumer-feasibility/.gitattributes b/research/complementary-consumer-feasibility/.gitattributes new file mode 100644 index 0000000000..b7823e3f34 --- /dev/null +++ b/research/complementary-consumer-feasibility/.gitattributes @@ -0,0 +1 @@ +inputs/* -text diff --git a/research/complementary-consumer-feasibility/OVERLAP.json b/research/complementary-consumer-feasibility/OVERLAP.json new file mode 100644 index 0000000000..40e8e31162 --- /dev/null +++ b/research/complementary-consumer-feasibility/OVERLAP.json @@ -0,0 +1,27 @@ +{ + "base": "624de9dc66858af0945e5f8a0942488d62280d43", + "pr_searches": [ + "4703", + "complementary OR mixed controller OR endpoint gauge" + ], + "related": [ + 4703, + 4712, + 4674, + 4660, + 4839 + ], + "discussion_pages": [ + 1163, + 1166, + 1167 + ], + "discussion_coverage": "Bounded rendered first-page read and term search; pagination not exhaustive.", + "local_helper": "find_overlap complementary --refresh failed remote gh unavailable; local3614/6319 note paths searched,2705 absent.", + "novelty": "No exhaustive novelty claim. Direct-price method credited4674; paired serial contract and refreshedC profiles are distinct scope.", + "source_heads": { + "4703": "4cc96829fad977aecf0018b26beb067cfd2689a5", + "4712": "b75a27bf07f1584b20babfddf887493981cd5949", + "4674": "84cf25a580db9ed2b4b1371c40689a035711364e" + } +} diff --git a/research/complementary-consumer-feasibility/PROOF.md b/research/complementary-consumer-feasibility/PROOF.md new file mode 100644 index 0000000000..836439b3fe --- /dev/null +++ b/research/complementary-consumer-feasibility/PROOF.md @@ -0,0 +1,94 @@ +# Complementary cancellation and its complete serial budget + +Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0. + +## Sources and obligation + +PR4703 at 4cc96829fad977aecf0018b26beb067cfd2689a5 supplies actual complementary B/C native interfaces. PR4712 at b75a27bf07f1584b20babfddf887493981cd5949 independently audits the endpoints, frames, phases, helper ownership and refreshed local profiles. The unchanged audit and relevant inputs are retained byte for byte from canonical main 624de9dc66858af0945e5f8a0942488d62280d43. This package consumes those conditional interface facts; it does not replay the native scientific suite. + +The older PR4674 at 84cf25a580db9ed2b4b1371c40689a035711364e supplies the direct-price normalization method for the earlier B supplier. Its method is credited, not claimed as new. The new scope is an explicit complementary two-call cancellation on the refreshed B/C suppliers, and a screen of their serial fixed-owner consumers. PR4712's 120-head query and dirty-helper failures are different models and are not repeated. + +## Actual two-call word + +Use a shared central Gaussian Q and two disjoint seven-axis Gaussian blocks D1,D2. They commute because they act on disjoint address axes; the field matrices below are not tensor-powered. Let L(c)=[[1,0],[c,1]]. At stage s: + + A_s = D_s [[1,0],[Q^-1,1]], + B_s = D_s [[1,0],[1,Q]], + C_s = D_s [[Q,0],[1,1]]. + +The whole first invocation is the C provider and the whole second is the B provider. Use the same 56 exceptional ports in both. Each call has its own 408 independent helper inputs. Every main input remains arbitrary. On exceptional pairs the actual chronological word C1, B2, L(-2) gives + + L(-2) B2 C1 = diag(D2 D1 Q,D2 D1 Q). + +On the 56 ordinary pairs the chronological word A1,A2,L(-2Q^-1) gives + + L(-2Q^-1) A2 A1 = diag(D2 D1,D2 D1). + +The second terminal is a genuine rank-one query on each pair, implemented with the source contract's owned temporary, Q^-1 child, scalar multiply/add and owned clear. It cannot be replaced by L(-2). All monomial source wrappers and actual inverse-Gaussian normalizers are inherited. The helper fields are untouched by these main-only terminals and each returns its original independent Gaussian job exactly once. No helper is credited as a recovered main job. + +For any matrix W=T B2 C1, the actual raw dual is + + W^-T=T^-T B2^-T C1^-T. + +The execution order is C1^-T, B2^-T, T^-T, the same chronological order with every gate replaced by its inverse transpose. Explicitly + + B_s^-T=D_s^-1 [[1,-Q^-1],[0,Q^-1]], + C_s^-T=D_s^-1 [[Q^-1,-Q^-1],[0,1]], + A_s^-T=D_s^-1 [[1,-Q^-1],[0,1]], + L(c)^-T=[[1,-c],[0,1]]. + +These expressions use symmetric canonical D_s,Q and retain their inverse powers; they do not identify Q with Q^-1. The verifier computes the inverse transpose algebraically and checks both complete endpoints over rational Laurent polynomials in D1,D2,Q without finite-order assumptions. + +This is a fully specified typed consumer with paid query children. It is not a newly emitted 1040-field native trace. Physical validity remains conditional on the audited supplier/normalizer/owned-temporary interface; no claim of new absolute-phase native replay or compiler admission follows. + +## Complete recursive bill and finite work + +The audited net local rank masses are B=1688 and C=1680. Add 56 rank-one terminal jobs. The new main jobs are 112 rank14 and112 rank15, rank mass3248. All816 helpers occur once in both the moment and ownership census. Thus the complete rank-mass deficit is + + 1688+1680+56-3248=176. + +The full paid and target histograms appear in RESULT.json. There are1040 independent persistent inputs:224 main and816 helpers. One owned query temporary can be reused serially; its clean entry/exit is not productive credit. The whole word inherits two local finite allowances each less than10^8 V under PR4703's native model, plus112 terminal additions,56 owned query COPY/clear sequences, their coefficient work and monomial normalization. Address permutations, storage, precision and the outer compiler remain separate finite obligations. Those costs are granted free only in the optimistic rejection screen below; their exact finite native constants are not needed to reject a negative recursive moment. No recursive price is invented for finite scalar work. + +## Refreshed direct-price lemma + +Let t=1-C and P_B,H_B,P_C,H_C be the authenticated current profiles. Define + + g_J(C)=P_J(t)-H_J(t)-224*7^t-112. + +The direct primitives of either actual A/B or A/C interface cost224 rank-seven jobs and112 rank-one jobs, with helper jobs paid separately. B's exceptional output scalar shear and C's exceptional input scalar shear give their direct implementations. This is the existing PR4674 comparison extended to the current C profile. + +At C=0, g_B=8 and g_C=0. Normalize g_J/7^t. In its derivative, every signed-rank term is nonnegative except the negative rank-six helper term. The rank-seven term is constant. The rank-one term alone contributes at least (P_J[1]-112)/7 * log7; the rank-six term has magnitude at most H_J[6]*log(7/6). Since log7>1 and log(7/6)<1, the derivative is strictly greater than + + B: (1956-112)/7-7 =1795/7 >0, + C: (2011-112)/7-6 =1857/7 >0. + +All other signs are checked against the authenticated profiles. Therefore for0<=C<1: + + g_B(C)>=8*7^-C, + g_C(C)>=0, + +and both are strict relative to their starting normalized value for C>0. This proves the domain, not a numerical sample or monotonicity extrapolation. It also explains why the C local improvement does not supply a positive primitive discount at positive saving. + +## Scoped serial ceiling + +Fix n>=2 whole invocations on the same224 main owners, one shared Q, and n fresh disjoint seven-axis blocks. The only other productive fields are the independent408 helpers per invocation, preserved as their audited outputs. Require every completed main Gaussian job to act within these7n+1 axes. Allow arbitrary main permutations and scalar boundary programs, but no extra productive inputs, helper repurposing or uncharged rank outside that domain. Any additional recursive cleanup is charged; grant all cleanup and finite work free for this upper bound. + +Each main target has rank at most7n+1. Thus with n_B B invocations and n_C C invocations, n_B+n_C=n, the complete target-minus-paid moment has upper bound + + M(C)<=224*(7n+1)^t -n*(224*7^t+112)-8*n_B*7^-C. + +For0=2 whole-call consumer on the same224 main owners, shared Q and n disjoint seven-axis blocks, with main target ranks at most7n+1 and only the source helpers as additional productive fields, has nonpositive moment at C=0 and strictly negative moment throughout0=2 complete whole calls; same224 main owners; independent408 helpers per call; one shared Q; n disjoint seven-axis transverse blocks; each main target rank<=7n+1; no extra productive inputs or ranks", + "status": "PASS_SCOPED_COMPLEMENTARY_SERIAL_SCREEN", + "two_call_screens": { + "0B+2C": { + "maximum_main_count": 224, + "maximum_main_rank": 15, + "optimistic_mass_deficit": 0 + }, + "1B+1C": { + "maximum_main_count": 224, + "maximum_main_rank": 15, + "optimistic_mass_deficit": 8 + }, + "2B+0C": { + "maximum_main_count": 224, + "maximum_main_rank": 15, + "optimistic_mass_deficit": 16 + } + }, + "uniform_optimistic_moment_bound": "M(C)<=224*(7n+1)^(1-C)-n*(224*7^(1-C)+112)-8*n_B*7^(-C); strict negative for0=2", + "verification_scope": "typed-interface Laurent identities and source receipt arithmetic only; source native/phase audit inherited from4712, not freshly replayed" +} diff --git a/research/complementary-consumer-feasibility/SNAPSHOTS.json b/research/complementary-consumer-feasibility/SNAPSHOTS.json new file mode 100644 index 0000000000..b8a7d2d666 --- /dev/null +++ b/research/complementary-consumer-feasibility/SNAPSHOTS.json @@ -0,0 +1,37 @@ +[ + { + "snapshot": "inputs/B.json", + "path": "research/kappa-round8-complement-audit-20261023/upstream/QUOTIENT153-ROUND3-ACTUAL-PROFILE.json", + "commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "git_blob": "0f04f7f6904a6fbd8ba5b4637babd1fb70766a1a", + "sha256": "c0ff4ea6bd3b8510f109203a90efba5d924edd9902641a96330f3bd1a7c2a571" + }, + { + "snapshot": "inputs/C.json", + "path": "research/kappa-round8-complement-audit-20261023/upstream/INTERSECTION153-ROUND3-ACTUAL-PROFILE.json", + "commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "git_blob": "d01460798ff331e702e873957b4a7799345690b0", + "sha256": "0820837a5ddd25d81596eb3fb1f0a18d173f0958aa6ceab651fc71d64d24325c" + }, + { + "snapshot": "inputs/AUDIT.md", + "path": "research/kappa-round8-complement-audit-20261023/README.md", + "commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "git_blob": "e92aa3b5a831611c9aca7935752cea91e1bf1e22", + "sha256": "4a5a37fadb83dd291b9d977a84693423ba4b1107c261dbbb5ec35730e67ff625" + }, + { + "snapshot": "inputs/INTERFACE.md", + "path": "research/kappa-round8-complement-audit-20261023/upstream/HETEROGENEOUS-CONTROLLER.md", + "commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "git_blob": "13713545701f29d5f4743a3602538cad982ac476", + "sha256": "c6231bd89629e6356d576d9e8c81f7b42a0b79ab66b0b4c95b8d94520016f011" + }, + { + "snapshot": "inputs/PREDECESSOR.md", + "path": "research/typed-primitive-price/PROOF.md", + "commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "git_blob": "86b640dd4e743e850d03aca03555379d98df1207", + "sha256": "94ff4bbcd2050cea2ef4d833fa5bbbd31ae63a6a128b09bb599f139f5dea1b06" + } +] diff --git a/research/complementary-consumer-feasibility/SOURCES.json b/research/complementary-consumer-feasibility/SOURCES.json new file mode 100644 index 0000000000..80f74a60e2 --- /dev/null +++ b/research/complementary-consumer-feasibility/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + } + ] +} diff --git a/research/complementary-consumer-feasibility/TASK.json b/research/complementary-consumer-feasibility/TASK.json new file mode 100644 index 0000000000..c2793697e1 --- /dev/null +++ b/research/complementary-consumer-feasibility/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "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": "changed", + "actual_scope": "An exact complementary B/C pair consumer and all-exponent optimistic screen of serial whole-call fixed224-owner consumers.", + "scope_change_reason": "Explicit donor request to test actual PR4703 complementary consumers using PR4712 prior audit, stop before expanding a losing complete bill.", + "bottleneck_link": "The typed local word must offer a real moment discount over direct main jobs and direct helper normalization to justify controller exploration.", + "budget_minutes": 60, + "stop_rule": "Reject serial construction expansion if a proved optimistic complete moment is nonpositive throughout the declared saving interval.", + "outcome": "negative-result", + "evidence": "PROOF.md, RESULT.json, authenticated audit/profile snapshots and verify.py", + "author": "Chris R / Clear1nsight", + "ai_assistance": "Substantial OpenAI Codex assistance; delegated construction worker, no independent human review.", + "open_questions": [ + { + "question": "Can a changed shared producer or target ownership exceed the serial bound without repayment?", + "why_it_matters": "All scoped serial consumers have a nonpositive complete optimistic moment.", + "first_step": "Emit one actual cross-contact operation with a disjoint target census and a favorable complete optimistic bill.", + "blocked_by": "No such changed paid profile or owned-input interface established." + } + ] +} diff --git a/research/complementary-consumer-feasibility/VALIDATION.json b/research/complementary-consumer-feasibility/VALIDATION.json new file mode 100644 index 0000000000..5afbd3c7d3 --- /dev/null +++ b/research/complementary-consumer-feasibility/VALIDATION.json @@ -0,0 +1,22 @@ +{ + "git_free_cold": { + "exit_code": 0, + "stdout": "PASS_SCOPED_COMPLEMENTARY_SERIAL_SCREEN", + "last_stderr": "" + }, + "receipt_boolean_to_integer": { + "exit_code": 1, + "stdout": "", + "last_stderr": "ValueError: type-sensitive canonical receipt" + }, + "source_bytes": { + "exit_code": 1, + "stdout": "", + "last_stderr": "ValueError: source SHA256" + }, + "restored_cold": { + "exit_code": 0, + "stdout": "PASS_SCOPED_COMPLEMENTARY_SERIAL_SCREEN", + "last_stderr": "" + } +} diff --git a/research/complementary-consumer-feasibility/VERIFY.json b/research/complementary-consumer-feasibility/VERIFY.json new file mode 100644 index 0000000000..b3c1f4c640 --- /dev/null +++ b/research/complementary-consumer-feasibility/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Authenticate snapshot bytes; exact arbitrary-input Laurent pair and actual raw-dual identities; full profile accounting; all-exponent derivative sign premises and scoped serial bound; algebraic rejecting controls." + } + ] +} diff --git a/research/complementary-consumer-feasibility/inputs/AUDIT.md b/research/complementary-consumer-feasibility/inputs/AUDIT.md new file mode 100644 index 0000000000..e92aa3b5a8 --- /dev/null +++ b/research/complementary-consumer-feasibility/inputs/AUDIT.md @@ -0,0 +1,142 @@ +# Independent admission audit of PR4703's complementary native suppliers + +Status: independent scalar/frame/ownership checks and the full exact phase replay +passed. This package claims no new multiplication bound or profitable controller. +Prepared by intqwq with substantial OpenAI Codex assistance; Apache-2.0. + +The audited source is [PR4703](https://github.com/CrocSwap/integer-mult-bounds/pull/4703), +exact head `4cc96829fad977aecf0018b26beb067cfd2689a5`, by Dugongue. +All 54 package files, including its 13 retained interpreter/Clifford files, are copied +byte-for-byte under `upstream/`. `SOURCES.json` pins every original Git blob, SHA-256 +and byte count. Upstream notices and attribution remain intact. This audit adds an +independent evaluator and receipt; it does not claim authorship of the suppliers. + +## What is admitted + +Both words implement a valid local supplier on 632 arbitrary independent persistent +inputs: 224 main fields and 408 helper fields. The owned temporary's entry is also +treated as arbitrary and must be cleared at return. `independent.py` imports no +upstream evaluator or Clifford implementation. It executes the exact rational scalar +word over the free group algebra, checks every chronological frame contact, each +paid width and all 72 shared native maps on every occurrence, and compares every +final input coefficient in both orientations. The result has 632 rows, 744 terms +and no nonempty operator words. The retained scalar records match the original +word exactly. Both meaningful mathematical corruption controls are rejected. + +For each helper, the entrance is a proper subspace of its exit. Its output depends +only on its own arbitrary input after the physical endpoint transforms. Its rank +is computed from that actual nested pair. No helper input is initialized or +identified with another provider call's helper. + +The exact phase-aware upstream replay is separate evidence: `replay.py` invokes +the original verifier with `-I -O -B` in its authenticated source directory, +places its temporary regeneration copies under `.scratch/`, and checks that the +original source bytes remain unchanged. The original wrapper launches assertion- +enabled child evaluators for both orientations. Its success requires regenerated +word, warp-phase, main-normalizer and paid/helper-phase mathematical payloads to +match exactly, including absolute phases. `REPLAY.json` and the two log files +record the successful result. This package adds no Lean formalization. + +## Complete local profiles and changed interface + +| Provider | Paid jobs | Independent helper jobs | Paid minus helper rank mass | +| --- | --- | --- | --- | +| B quotient | 1:1956, 2:450, 3:403, 4:127, 5:28, 8:8 | 3:2, 4:26, 6:7, 7:47, 8:326 | 1688 | +| C restriction | 1:2011, 2:445, 3:427, 4:112, 5:12, 7:8 | 3:26, 4:2, 6:6, 7:48, 8:326 | 1680 | + +All owned centers are included. The C supplier includes its four required rank-one +warp repairs at operators 2, 3, 4 and 29. The special ports agree exactly: each +provider has 56 ordinary A ports and the same 56 exceptional B or C ports. + +Writing D for a seven-axis Gaussian and Q for an independent central one-axis +Gaussian, the forward interfaces are + + A = diag(D,D) Sy(Q^-1), + B = diag(1,Q) A, + C = A diag(Q,1). + +Backward interfaces are inverse transposes, with the explicitly described even +Gaussian powers and signs normalized by monomial operations. They cannot be +substituted for the previous common eight-axis main contract. The strict local +C improvement compares with the older C restriction, whose productive profile +and typed contract agree; it does not establish an improvement over the enclosing +controller of PR4610. + +For completeness, the local difference claimed upstream is + + -36 + 28*2^t + 4*3^t - 8*4^t < 0, 0 <= t < 1. + +Its supplied calculus proof is valid: for x=2^t and a=log_2(3), one has +1<=x<2 and 12, and its value at 2 is zero. +Thus it is increasing on [1,2] and negative below 2. This is a local cost lemma. + +## Admission and recurrence boundaries + +The finite free-group identity implies an all-width identity upon evaluating +its consistently shared generators at the lifted native operators. Each address- +operator block identity tensors separately. Tensor powers of field-level sums +are not assumed. The separate exact Clifford lowering checks the actual +normalizers and gives standard Gaussian whole jobs. + +The written native construction has an eventual fixed O(V) allowance. Our +independent event meter finds 17,453 scalar events and 240 native warps per +orientation, with scalar numerators/denominators at most 8. Counting two monomial +normalizers per paid child, all warp/main/backward/helper wrappers gives fewer +than 9,000 fixed nine-axis monomial operations. The stated local 10^8 V allowance +therefore has a concrete finite-operation basis, including bank permutations. +The detailed fixed-width arithmetic, parity tables, precision and guard handling +still rely on the retained Word RAM/complex-Gaussian model and written native +implementation argument. This audit does not produce a new finite-state +compiler or outer transfer theorem, or import the older smaller scalar allowance. + +For a heterogeneous retained p-controller, let n_B+n_C=p+2. Its local contribution +is precisely + + P_local(t) = n_B sum_r P_B[r] r^t + n_C sum_r P_C[r] r^t, + T_helpers(t) = n_B sum_r H_B[r] r^t + n_C sum_r H_C[r] r^t. + +Each invocation owns a distinct set of all 408 helper channels. Additional paid +terms include every actual rank-seven IDLE job, crossed-gauge scalar ADD, query +and retag call, and any other explicitly emitted Gaussian. The old thin-query +bill is replaced when queries change; it must not be counted twice. A choice +of provider is a whole-call choice. Its exceptional 56-port subset may be moved +by actual input/output bank permutations with finite native cost. + +The complete main targets must come from the diagonalized chronological word +RIGHT, physical events, LEFT, including both scalar boundary programs. For an +actual diagonal row with fresh-block exponents e_s and central exponent m, its +changed productive rank is + + 7 sum_s e_s + ((m + a_out - a_in) mod 2). + +This is valid only after all physical gauge corrections and signed swaps are +emitted and the resulting matrix is diagonal on the same independent channels. +The initial gauge theorem changes the productive request honestly; it does not +make a Gaussian input adapter free for an unchanged request. These conditional +formulae do not supply a profitable mixed recurrence, spectral-radius estimate, +or positive whole target-minus-paid moment. The present suppliers consequently +cannot yet fund a new recursive phase adapter or a larger kappa. + +## Reproduction and dependencies + +From this directory using standard-library Python 3.12 or later: + + python -I -B independent.py + python -I -B replay.py + python -I -B check_bundle.py + +The independent check takes a few seconds. The exact phase regeneration takes +several minutes. Replay needs writable `.scratch/` and no network, Git object, +solver, Lean installation or external repository path. `capture.py` is only a +source-import aid and requires Git plus the pinned commit object; it is not +needed for a clean-checkout audit replay. Original compressed bytes are pinned, +while regeneration compares decompressed mathematical payloads. + +## Open next questions + +The missing construction is a profitable complete consumer of the actual B/C +ports. Such a consumer must provide its chronological arbitrary-input operator, +all independent helper channels and whole physical invoice. It must then satisfy +the mirror/critical majorant, finite compiler reserve, precision and native outer +assembly requirements. No further phase enumeration is part of this audit. diff --git a/research/complementary-consumer-feasibility/inputs/B.json b/research/complementary-consumer-feasibility/inputs/B.json new file mode 100644 index 0000000000..0f04f7f690 --- /dev/null +++ b/research/complementary-consumer-feasibility/inputs/B.json @@ -0,0 +1,35 @@ +{ + "status": "PASS_Q153_SHARED_MAPS_FORMAL_ENDPOINTS_ALL_WARP_PHASES", + "paid": { + "1": 1956, + "2": 450, + "3": 403, + "4": 127, + "5": 28, + "8": 8 + }, + "helpers": { + "8": 326, + "4": 26, + "7": 47, + "6": 7, + "3": 2 + }, + "local_deficit": 1688, + "new_warp_outputs": [], + "formal": { + "backward": { + "rows": 632, + "terms": 744, + "nonempty_words": 0 + }, + "forward": { + "rows": 632, + "terms": 744, + "nonempty_words": 0 + } + }, + "payload_sha256": "aac6822eeb412a8690791d0755d2a7d2ff4da3198260e199b75499c8d9924f39", + "warp_classes": 180, + "warp_phase_seconds": 8.98399999999674 +} \ No newline at end of file diff --git a/research/complementary-consumer-feasibility/inputs/C.json b/research/complementary-consumer-feasibility/inputs/C.json new file mode 100644 index 0000000000..d01460798f --- /dev/null +++ b/research/complementary-consumer-feasibility/inputs/C.json @@ -0,0 +1,60 @@ +{ + "status": "PASS_H153_SHARED_MAPS_FORMAL_ENDPOINTS_ALL_WARP_PHASES", + "paid": { + "1": 2011, + "2": 445, + "3": 427, + "4": 112, + "5": 12, + "7": 8 + }, + "helpers": { + "8": 326, + "3": 26, + "7": 48, + "6": 6, + "4": 2 + }, + "local_deficit": 1680, + "new_warp_outputs": [ + { + "operator": 2, + "input": 189, + "old_output": 1087, + "new_output": 1943 + }, + { + "operator": 3, + "input": 192, + "old_output": 1087, + "new_output": 1943 + }, + { + "operator": 4, + "input": 192, + "old_output": 1087, + "new_output": 1943 + }, + { + "operator": 29, + "input": 192, + "old_output": 1087, + "new_output": 1943 + } + ], + "formal": { + "backward": { + "rows": 632, + "terms": 744, + "nonempty_words": 0 + }, + "forward": { + "rows": 632, + "terms": 744, + "nonempty_words": 0 + } + }, + "payload_sha256": "7f137c4b95db519d04ad2336ef1a146fbc953124e95940d10b572a63ab958c87", + "warp_classes": 180, + "warp_phase_seconds": 14.297000000020489 +} \ No newline at end of file diff --git a/research/complementary-consumer-feasibility/inputs/INTERFACE.md b/research/complementary-consumer-feasibility/inputs/INTERFACE.md new file mode 100644 index 0000000000..1371354570 --- /dev/null +++ b/research/complementary-consumer-feasibility/inputs/INTERFACE.md @@ -0,0 +1,61 @@ +# Heterogeneous seven-axis suppliers with exact port transport + +Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0. + +## Physical interface + +Consider two independently admitted local words with 112 independent main pairs and 408 independent helper fields. Their main endpoints, after explicit monomial wrappers, are direct sums of seven-axis primitives with a common central Q: + + A = diag(D,D) S_y(Q^-1), + B = diag(1,Q) A, + C = A diag(Q,1). + +Here D acts on seven fresh coordinate axes, Q on a separate central axis, and Q² is an explicit monomial. Each B-provider call has 56 A and 56 B ports. Each C-provider call has 56 A and 56 C ports. Their logical words, paid profiles and helper profiles remain separately authenticated; equal counts of main types do not identify the underlying helper inputs. + +Backward interfaces are the actual inverse transposes. To compare them with the retained source controller, explicitly apply input-Y Q², output-Y Q^-2 and output D² on both fields. The resulting source-convention backward A is diag(D,D) S_x(-Q), backward B has its extra Q^-1 on output Y, and backward C has its extra Q^-1 on input X. The extra phases and even powers are retained as monomial wrappers. These corrections do not add recursive Gaussian calls. + +## Arbitrary placement of the 56 exceptional ports + +Let sigma be any permutation of the 112 main pairs. Apply the corresponding permutation to both input banks X_i,Y_i, execute the local word, then apply the inverse permutation to both main output banks. Leave helper banks untouched. The main endpoint is the conjugate direct sum, so any chosen 56 ports can carry the exceptional B or C type. The paid profile and all 408 independent helper endpoint operators are unchanged. + +This conclusion uses the admitted direct-sum endpoint: each helper output depends only on its own arbitrary input, and no helper input contributes to a main output. Therefore main-only pair permutations introduce no disguised helper identification, sharing, loss of arbitrariness or changed input ABI. These zero cross-block facts are verified by the free-group-algebra endpoint certificate. No per-occurrence inconsistent warp map is chosen. + +The pair permutation is an actual native operation. Decompose the permutation of 224 banks into at most 223 transpositions. Each transposition is the literal reversible scalar sequence x+=y; y-=x; x+=y; y=-y. It swaps the two fields exactly, preserves every independent input and uses no overwrite/CLEAR on borrowed data. One constant guard bit covers intermediate sums. Input plus inverse output use at most 446 transpositions, hence at most 1,784 scalar bank passes. At at most 16 native operations per complex-record scalar pass this is 28,544 V, leaving an additional allowance of 30,000 V including loop/index bookkeeping. Pointer relabeling may be cheaper but is not required. An owned-temporary cycle-copy implementation is also possible on ordinary RAM, but is unnecessary for the stricter reversible-scalar protocol. + +In particular one may use two fixed groups of 56 global ports and independently choose at each LOCAL which group receives the exceptional type. This is a genuine new degree of freedom beyond keeping the same exceptional port class at every stage. A computed assignment still needs its complete chronological incidence check. + +## Exact row-gauge consumption + +At each controller row use a central gauge Q^a, retaining the full integer exponent and accounting for parity only when pricing Gaussian rank. For a logical ADD with coefficient epsilon Q^k, the physical coefficient is epsilon Q^(k+a_target-a_source). An odd exponent requires one rank-one Gaussian call; an even exponent is an explicit monomial. A temporary COPY/transform/ADD/CLEAR implementation preserves the source and pays that Gaussian exactly once. It uses only owned temporary erasure. + +For an A-type LOCAL, input row parities must agree; the two outputs keep that common parity. For B, input parities agree and physical Y flips at the output. For C, input parities are opposite and both output parities equal the input Y parity; equivalently C has an input-X flip followed by A. The same parity rules hold in the backward source convention after the stated monomial wrappers. The X/Y identities refer to physical banks, not to whichever row is the shear source in that orientation. + +The controller's scalar RIGHT boundary program runs first, then its physical events, then its scalar LEFT boundary program. Carry the gauges through both boundary programs and price every crossed-parity ADD. Signed swaps carry their gauges with the swapped rows. An optimizer that ignores these boundary programs does not establish a usable diagonal target. + +## Exact whole invoice + +Let n_B and n_C be the numbers of the two provider calls, with n_B+n_C=p+2 in the retained p-pair controller. The helper targets are the multiset sum n_B H_B+n_C H_C, with a fresh independent copy of every helper at every call. The local Gaussian paid jobs are n_B P_B+n_C P_C. Add each actual seven-axis IDLE job, each actual rank-one query/ADD/gauge-correction job, and every additional explicitly emitted recursive child. Do not also include the old thin-query bill if those queries were replaced by the actual gauged jobs; that would double-count. + +For a final diagonal row with retained Laurent monomial Q^m product_s D_s^(e_s), its actual central rank is (m+a_final) modulo two, not a_final by itself. Its total target rank is + + 7 sum_s e_s + ((m+a_final) mod 2), + +for the retained 0/1 fresh-slot exponents. Initial gauges are frozen. All even powers, signs and inverse D orientations belong to explicit monomial normalizers. The complete formal Laurent identity must be replayed using the emitted gauged controller, not merely priced from a mask. + +The exact whole rank-mass surplus is sum(rank*target_count)-sum(rank*paid_count) for this rebuilt invoice. A positive rank-mass surplus is only an initial screen. A strictly positive complete moment at a specified exponent, the mirror/critical majorant, finite uniform compiler, precision and native outer assembly are required before claiming a new kappa. + +## Spectator and coordinate embedding + +A B-provider's ninth local coordinate is a spectator on the main typed endpoint but may be active in independent rank-nine helper jobs. It must be embedded as a genuine extra coordinate chosen outside the central axis and current seven-axis block; another stage's fresh coordinate suffices because p>=2. The complete global address space has rank 1+7(p+2), so this extra coordinate exists. Main output identity on that coordinate is an actual typed-interface fact, not a reason to discard its helper action. The borrowed coordinate labels addresses; it is not borrowed storage and does not identify two independent helper fields. + +A C-provider whose complete admitted word lives in an eight-plane may use only central plus seven local coordinates; its ninth identity spectator remains explicit. Every whole-job normalizer is formed on its actual active coordinates. No block-eight diagonal credit is inferred from a helper-only padded spectator. + +## Local native allowance + +For the frozen source words, each orientation contains 17,453 scalar events, 240 native warp events, 448 inherited adapter markers and at most 3,195 paid Gaussian jobs. All scalar numerator/denominator magnitudes are at most 8. Allow two exact nine-axis monomial normalizers per paid child, the native warp monomials, all explicit main wrappers, the backward-convention corrections and both helper whole-job normalizers. Fewer than 9,000 nine-axis lifted monomial operations suffice per local call. This is a conservative count, not a practical runtime estimate. + +A lifted fixed nine-axis monomial is a binary 9×9 block map and a Z4 quadratic phase on nine f-bit blocks, with arbitrary identity spectators. Its address is formed with at most 81 block XORs and fixed shifts/masks. Compute each phase using at most 45 block parity/Hamming-weight-mod-4 functions; a parity chunk table on max(1,floor(f/16)) bits gives at most 31 chunks per f-bit block. Including the table setup, scatter/gather, phase multiplication, loop/index operations and fixed metadata, 10,000 V native operations per such map is a deliberately loose eventual bound. Tables are prepared by explicit recurrences and cost O(V), not an oracle. Thus fewer than 9e7 V operations cover these monomials; 64 operations per scalar event, the bank permutations and a further million-operation metadata reserve leave the nonrecursive LOCAL allowance below 10^8 V. Gaussian child work is charged separately in the paid profile. This bound concerns the local primitive, not the entire p-stage controller or its larger main whole-job normalizers. + +All statements hold at each digit-column width f by the retained exact free-group-algebra evaluation theorem and blockwise tensorization of address-operator identities. They do not tensor the field-level 2×2 matrices. The full native construction remains source-bound in its inherited Gaussian, compiler and analytic premises. This note establishes a sufficient heterogeneous-consumer and exact accounting framework; it does not assert an unobserved profitable provider/gauge schedule. + +Credit the actual B/C supplier constructions and source owners; DaysSky, Cinna Davis, Cao Yifan, the retained controller authors, Dugongue's native Word RAM and frame-interface work, zxv, Jacob Alan Sussman and all original notices. The useful new mechanism is per-call physical port transport together with an honest heterogeneous profile, rather than repricing a changed endpoint as the old common supplier. diff --git a/research/complementary-consumer-feasibility/inputs/PREDECESSOR.md b/research/complementary-consumer-feasibility/inputs/PREDECESSOR.md new file mode 100644 index 0000000000..86b640dd4e --- /dev/null +++ b/research/complementary-consumer-feasibility/inputs/PREDECESSOR.md @@ -0,0 +1,156 @@ +# The typed quotient has no recursive primitive discount + +Prepared for Cinna Davis with substantial OpenAI Codex assistance. Apache-2.0. + +## 1. Exact direct implementations of the supplied interface + +Assume the exact typed ABI of PR4654 at +`dca175fed8ebde8980635fd3b4508b8cba89a1b0`. Its 112 main pairs consist +of 56 type A and 56 type B. On each pair, Q is a symmetric rank-one +Gaussian and D a symmetric rank-seven Gaussian on disjoint axes: + +``` +A = diag(D,D) S_y(Q^-1), +B = diag(D,QD) S_y(Q^-1) = S_y(1) diag(D,QD). +``` + +The second identity is exact: both B expressions send (X,Y) to +`(DX, DX+QD Y)`. There is no order-two relation for Q in this proof. + +A direct A implementation uses two rank-seven D jobs and one rank-one +query shear. The query copies X into an owned zero temporary, applies +Q^-1 with its actual monomial normalizer, adds into Y and clears the +temporary. This retains the predecessor's owned-erasure hypothesis; it +does not erase a dirty borrowed field. A direct B uses two D jobs, one +Q job on Y and one ordinary output addition. Thus each type costs exactly +`2*7^t+1` in recursive paid moment, t=1-C. + +The raw inverse transposes have equally explicit implementations: + +``` +A^-T = diag(D^-1,D^-1) S_x(-Q^-1), +B^-T = S_x(-1) diag(D^-1,Q^-1 D^-1). +``` + +The B scalar addition is on the left and acts last. Gaussian inverses +retain their actual monomial normalizers; rank does not change. The +verifier checks all four Laurent matrix identities, with independent D +and Q symbols and every sign and inverse exponent intact. + +Across all 112 pairs, direct main execution costs **224 rank-seven jobs +and 112 rank-one jobs**, in either orientation. It uses at most one owned +query temporary at a time. The source's 408 helpers remain independent +arbitrary inputs; implementing each source-normalized helper job directly +adds its complete actual target moment H_t to the paid list. All helper +monomial normalizers are retained. No helper target is counted twice. + +Some direct helper jobs have rank nine. The fallback therefore does not +preserve the native word's rank-eight local child cap. The price comparison +is not drop-in compiler admission: any replacement must recheck child ranks, +strictification tails and allocation. If a consumer introduces these helpers +only as fresh independent bystanders, its direct main implementation can +instead omit both their inputs/targets and their matching direct paid jobs; +that cancellation preserves the surplus, but changes the caller's inventory. + +This is an operator-level fallback and a comparison of recursive paid +moments. ADDs, copies, clear/erase, monomial wrappers, fixed routing and +helper normalizers have finite volume-linear work. We do not assert +identical machine costs, construct a practical multiplier, or independently +reprove the typed source's native/all-width/phase theorem. + +## 2. Strict dominance at every concave exponent + +Recounting both emitted source words and their helper endpoints gives + +``` +P = {1:2177,2:424,3:389,4:147,5:50,8:8}, +H = {3:2,6:7,7:47,8:139,9:213}. +``` + +The native minus direct recursive paid moment is + +``` +G(C) = P_t - H_t -224*7^t -112, t=1-C. +``` + +It has G(0)=8. Normalize K(C)=G(C)/7^t. The constant -224 +has derivative zero. In `(P_t-H_t-112)/7^t` the rank coefficients are + +``` +{1:2065,2:424,3:387,4:147,5:50,6:-7,7:-47,8:-131,9:-213}. +``` + +For 0<=C<1, all derivative contributions are nonnegative except the +rank-six term. The rank-one term alone contributes at least +`2065/7 * log(7)`; the rank-six negative contribution has magnitude at +most `7 log(7/6)`. Since log(7)>1 and log(7/6)<1, + +``` +K'(C) > 2065/7 -7 = 288 > 0. +``` + +The elementary log inequalities are also enclosed by the pinned exact +rational interval engine. Therefore + +``` +G(C) >= 8 * 7^(-C) > 0, 0<=C<1. +``` + +The typed native word is strictly more expensive in recursive paid moment +than the direct implementation of the *same* main ABI and helper targets, +for every exponent in the range, including rank mass at C=0. + +This is stronger than a failed controller search and different from the +A-only-path obstruction of PR4660. It applies to the local offer before +any controller is chosen. A profitable consumer using this offer could +instead use the cheaper direct implementation, with the same operator +and independent helper targets. It does **not** prove that every such +consumer or every Gaussian algorithm is impossible. + +## 3. Comparison with the actual round-three native discount + +Freeze PR4610 at `1eb8da6cfb35512c0cc2533413e5ca42f48e13c6`: + +``` +H0 = {4:28,7:7,8:47,9:326}, +P0 = {1:2201,2:412,3:510,4:127,5:40,8:8}. +``` + +Its ordinary all-A, block-eight main interface has direct paid cost +`H0_t+224*8^t+112`. Put G0=P0_t-H0_t-224*8^t-112. +Its normalized rank-eight gap G0/8^t starts at -6. The corresponding +rank-one coefficient is 2089; the only negative derivative contribution +below rank eight is -7 at rank seven. Hence + +``` +(G0/8^t)' > 2089/8 -7 = 2033/8 > 0. +``` + +Exact outward enclosures give G0<0 at C=0.0062073960 and G0>0 at +C=0.0062073961. Thus the original supplier's unique direct-price crossing +is in that interval. Above it the original offer, too, has no recursive +discount over direct main jobs and direct helpers. This is a **local price +crossing**, not an integer-multiplication exponent or a universal ceiling. + +At C=.004, the original offer still discounts the direct price by about +16.9818753 per full invocation. This is useful controller budget; the +typed quotient instead has a positive surcharge. Complete controller, +strictification, compiler, BIT, precision and outer conditions remain +necessary for any actual K claim. + +## 4. Source and verification boundary + +The source word, typed interface and round-three arithmetic are retained +byte for byte, with Git blob and SHA256 authentication. Both paid censuses +and every helper rank are recomputed from the emitted word. The source's +Clifford and free-group proofs are premises here, not newly audited. + +The registered Python replay uses exact Laurent arithmetic and outward +rational power/log enclosures. It rejects an unpaid B query, a wrong Q +inverse, missing owned charges and source/profile drift. Passing it does +not establish a new native construction, selected frontier or theorem. + +Credit Dugongue and PR4654, DaysSky's quotient source, Cao Yifan and PR4610, +Cinna Davis and the PR4440/PR4470/native lineage, zxv, Jacob Alan Sussman, +the PR4660 B-autonomy observation and all retained predecessor authors. +The direct factorization of B is credited, not rediscovered here. diff --git a/research/complementary-consumer-feasibility/verify.py b/research/complementary-consumer-feasibility/verify.py new file mode 100644 index 0000000000..8950810214 --- /dev/null +++ b/research/complementary-consumer-feasibility/verify.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +"""Exact typed complementary-consumer screen. Apache-2.0; OpenAI Codex assistance.""" +from collections import Counter +from fractions import Fraction as F +from hashlib import sha1, sha256 +from pathlib import Path +import argparse, json +HERE=Path(__file__).resolve().parent + +def need(ok,msg): + if not ok: raise ValueError(msg) + +def add(a,b): + c=dict(a) + for k,v in b.items(): c[k]=c.get(k,0)+v + return {k:v for k,v in c.items() if v} + +def mul(a,b): + c={} + for k,v in a.items(): + for l,w in b.items(): + e=tuple(x+y for x,y in zip(k,l));c[e]=c.get(e,0)+v*w + return {k:v for k,v in c.items() if v} + +def mon(a=0,b=0,q=0,c=1): return {(a,b,q):F(c)} if c else {} +I=[[mon(),{}],[{},mon()]] +def mm(a,b): return [[add(mul(a[i][0],b[0][j]),mul(a[i][1],b[1][j])) for j in range(2)] for i in range(2)] +def tr(a): return [[a[j][i] for j in range(2)] for i in range(2)] +def sh(c): return [[mon(),{}],[c,mon()]] +def diag(x,y): return [[x,{}],[{},y]] +def gaussian(stage,q=0,sign=1): return mon(sign if stage==1 else 0,sign if stage==2 else 0,q) +def minus(a): return {k:-v for k,v in a.items()} +def inverse_monomial(a): + need(len(a)==1,'monomial diagonal') + (k,v),=a.items();return {tuple(-x for x in k):1/v} +def rawdual(a): + need(not a[0][1],'lower triangular source') + x,z=inverse_monomial(a[0][0]),inverse_monomial(a[1][1]) + return [[x,minus(mul(mul(x,a[1][0]),z))],[{},z]] +def source(stage,kind): + d=gaussian(stage) + if kind=='A':return mm(diag(d,d),sh(mon(q=-1))) + if kind=='B':return mm(diag(d,mul(d,mon(q=1))),sh(mon(q=-1))) + if kind=='C':return mm(diag(d,d),mm(sh(mon(q=-1)),diag(mon(q=1),mon()))) + raise ValueError(kind) + +def certify(): + for r in json.loads((HERE/'SNAPSHOTS.json').read_text()): + data=(HERE/r['snapshot']).read_bytes() + need(sha256(data).hexdigest()==r['sha256'],'source SHA256') + need(sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==r['git_blob'],'source Git blob') + profiles={}; lower={} + for name in 'BC': + x=json.loads((HERE/'inputs'/f'{name}.json').read_text());p={int(k):v for k,v in x['paid'].items()};h={int(k):v for k,v in x['helpers'].items()} + need(sum(h.values())==408,'independent helper census') + net={r:p.get(r,0)-h.get(r,0) for r in p.keys()|h.keys()} + mass=sum(r*v for r,v in net.items()); need(mass==x['local_deficit'],'source mass') + # d/dC [(P-H-112)/7^(1-C)] : all terms nonnegative + # except rank6; rank7 is constant. log7>1, log(7/6)<1. + c=dict(net);c[1]-=112 + need(all(v>=0 for r,v in c.items() if r<7 and r!=6),'derivative signs below separator') + need(all(v<=0 for r,v in c.items() if r>7),'derivative signs above separator') + need(c.get(6,0)<=0,'only negative derivative term') + L=F(c[1],7)+c.get(6,0);need(L>0,'strict all-domain derivative lower bound') + lower[name]=str(L) + profiles[name]={'paid':p,'helpers':h,'net_mass':mass,'direct_gap_mass':mass-1680} + need(profiles['B']['direct_gap_mass']==8 and profiles['C']['direct_gap_mass']==0,'actual source gaps') + D=mon(1,1);Q=mon(q=1) + # Execute C on fresh block1, then B on fresh block2, then Y-=2X. + cb=[source(1,'C'),source(2,'B'),sh(mon(c=-2))] + aa=[source(1,'A'),source(2,'A'),sh(mon(q=-1,c=-2))] + for name,word,target in [('exceptional',cb,diag(mul(D,Q),mul(D,Q))),('ordinary',aa,diag(D,D))]: + f=I;dual=I + for op in word:f=mm(op,f);dual=mm(rawdual(op),dual) + need(f==target,name+' arbitrary-input Laurent endpoint') + need(mm(tr(f),dual)==I,name+' actual raw inverse transpose') + need(mm(sh(mon(c=-1)),mm(cb[1],cb[0]))!=diag(mul(D,Q),mul(D,Q)),'wrong cancellation coefficient rejected') + need(mm(sh(mon(c=-2)),mm(aa[1],aa[0]))!=diag(D,D),'ordinary Q inverse cannot be dropped') + need(mm(tr(mm(cb[1],cb[0])),mm(cb[1],cb[0]))!=I,'forward word is not raw dual') + paid=Counter();helpers=Counter() + for v in profiles.values():paid.update(v['paid']);helpers.update(v['helpers']) + paid[1]+=56 # the retained ordinary A/A contamination is charged once per pair + targets=dict(helpers);targets[14]=112;targets[15]=112 + mass=lambda c:sum(r*n for r,n in c.items()) + need(mass(paid)-mass(targets)==176,'complete pair deficit') + need(sum(targets.values())==1040,'224 main plus two disjoint408 helper banks') + # Explicit n=2 extremal cap; universal-n result is algebraic in PROOF.md. + screens={} + for b in range(3):screens[f'{b}B+{2-b}C']={'maximum_main_rank':15,'maximum_main_count':224,'optimistic_mass_deficit':8*b} + return {'status':'PASS_SCOPED_COMPLEMENTARY_SERIAL_SCREEN','new_kappa':False,'profiles':profiles,'normalized_direct_gap_derivative_lower_bounds':lower,'complete_pair_paid':dict(sorted(paid.items())),'complete_pair_targets':dict(sorted(targets.items())),'complete_pair_rank_deficit':176,'persistent_independent_inputs':1040,'two_call_screens':screens,'serial_domain':'n>=2 complete whole calls; same224 main owners; independent408 helpers per call; one shared Q; n disjoint seven-axis transverse blocks; each main target rank<=7n+1; no extra productive inputs or ranks','uniform_optimistic_moment_bound':'M(C)<=224*(7n+1)^(1-C)-n*(224*7^(1-C)+112)-8*n_B*7^(-C); strict negative for0=2','verification_scope':'typed-interface Laurent identities and source receipt arithmetic only; source native/phase audit inherited from4712, not freshly replayed'} + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');a=ap.parse_args();r=certify();s=json.dumps(r,sort_keys=True,indent=2)+'\n' + if a.write:(HERE/'RESULT.json').write_text(s) + else:need(json.dumps(json.loads((HERE/'RESULT.json').read_text()),sort_keys=True)==json.dumps(json.loads(json.dumps(r)),sort_keys=True),'type-sensitive canonical receipt') + print(r['status']) +if __name__=='__main__':main() From d5772576a9f260768d39eea0adde36e08602e889 Mon Sep 17 00:00:00 2001 From: d3lerium Date: Fri, 23 Oct 2026 09:08:15 +1100 Subject: [PATCH 2/2] Prevent detached maintenance in sparse baseline test fixtures Disable command-scoped auto maintenance and GC on disposable fixture commits. Add a real-Git Trace2 regression with forced automatic work and an unguarded foreground positive control. Fixes the cleanup failure observed in registered-package run 39860907480 for PR #4848. Developed with substantial OpenAI Codex assistance. --- tests/test_research_baseline_sparse.py | 33 ++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/tests/test_research_baseline_sparse.py b/tests/test_research_baseline_sparse.py index 7c5e5df9ad..319f7ff8f8 100644 --- a/tests/test_research_baseline_sparse.py +++ b/tests/test_research_baseline_sparse.py @@ -2,11 +2,13 @@ import contextlib import io import json +import os from pathlib import Path import subprocess import sys import tempfile import unittest +from unittest import mock ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / "scripts")) @@ -50,7 +52,9 @@ def git(self, *args): text=True, encoding="utf-8").stdout def commit(self, message, *extra): + # Detached maintenance can recreate .git/objects during temp cleanup. self.git("-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid", + "-c", "maintenance.auto=false", "-c", "gc.auto=0", "-c", "core.hooksPath=/dev/null", "commit", "-q", *extra, "-m", message) def run_main(self): @@ -82,6 +86,35 @@ def test_full_checkout_reports_nothing(self): self.assertEqual((code, result["status"]), (0, "NO_SPARSE_SELECTED_OMISSIONS")) self.assertEqual(result["next"], ["python3", "-B", "scripts/research_baseline.py"]) + def test_fixture_commit_never_starts_background_maintenance(self): + # Force automatic work even in this tiny repo. Keep the positive + # control synchronous so its own maintenance cannot race cleanup. + for key, value in { + "maintenance.auto": "true", "maintenance.autoDetach": "false", + "gc.autoDetach": "false", "maintenance.commit-graph.enabled": "true", + "maintenance.commit-graph.auto": "-1", "gc.auto": "1", + }.items(): + self.git("config", key, value) + with tempfile.TemporaryDirectory() as directory: + trace = Path(directory) / "git-trace.jsonl" + + def maintenance_children(): + return [event for line in trace.read_text(encoding="utf-8").splitlines() + if (event := json.loads(line)).get("event") == "child_start" + and any(arg in {"maintenance", "gc"} + for arg in event.get("argv", []))] + + with mock.patch.dict(os.environ, {"GIT_TRACE2_EVENT": str(trace)}): + self.commit("guarded fixture", "--allow-empty") + self.assertEqual(maintenance_children(), []) + + trace.unlink() + with mock.patch.dict(os.environ, {"GIT_TRACE2_EVENT": str(trace)}): + self.git("-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid", + "-c", "core.hooksPath=/dev/null", "commit", "-q", "--allow-empty", + "-m", "unguarded positive control") + self.assertTrue(maintenance_children(), "positive control must start maintenance") + def test_full_explicit_inventory_keeps_repository_relative_paths(self): self.explicit_manifest() code, result = self.run_main()