From 0e8a13c251a9be1029114cda8b4194f05f3a23ec Mon Sep 17 00:00:00 2001 From: Dillon Amburgey Date: Fri, 23 Oct 2026 05:56:13 -0400 Subject: [PATCH] Prove sharp active query cost for the physical eight-mode code --- .../coded-active-query-bound/ATTRIBUTION.md | 13 + .../EXTENSION-REVIEW.md | 95 +++++ .../INDEPENDENT-REVIEW.md | 93 +++++ .../coded-active-query-bound/INDEPENDENT.json | 14 + research/coded-active-query-bound/PROOF.md | 394 ++++++++++++++++++ research/coded-active-query-bound/README.md | 60 +++ research/coded-active-query-bound/RESULT.json | 43 ++ .../coded-active-query-bound/SOURCES.json | 66 +++ research/coded-active-query-bound/TASK.json | 118 ++++++ .../coded-active-query-bound/VALIDATION.md | 29 ++ research/coded-active-query-bound/VERIFY.json | 52 +++ .../coded-active-query-bound/independent.py | 81 ++++ research/coded-active-query-bound/verify.py | 236 +++++++++++ 13 files changed, 1294 insertions(+) create mode 100644 research/coded-active-query-bound/ATTRIBUTION.md create mode 100644 research/coded-active-query-bound/EXTENSION-REVIEW.md create mode 100644 research/coded-active-query-bound/INDEPENDENT-REVIEW.md create mode 100644 research/coded-active-query-bound/INDEPENDENT.json create mode 100644 research/coded-active-query-bound/PROOF.md create mode 100644 research/coded-active-query-bound/README.md create mode 100644 research/coded-active-query-bound/RESULT.json create mode 100644 research/coded-active-query-bound/SOURCES.json create mode 100644 research/coded-active-query-bound/TASK.json create mode 100644 research/coded-active-query-bound/VALIDATION.md create mode 100644 research/coded-active-query-bound/VERIFY.json create mode 100644 research/coded-active-query-bound/independent.py create mode 100644 research/coded-active-query-bound/verify.py diff --git a/research/coded-active-query-bound/ATTRIBUTION.md b/research/coded-active-query-bound/ATTRIBUTION.md new file mode 100644 index 0000000000..9b20852dc6 --- /dev/null +++ b/research/coded-active-query-bound/ATTRIBUTION.md @@ -0,0 +1,13 @@ +# Attribution and inherited scope + +Prepared for Dillon with substantial OpenAI Codex assistance. The source-specific coset theorem, its application to chronological input/output cuts, sharp one-sided and rectangular mode bounds, finite-H extension and direct-sum corollary are the additions from this session. General causal/image/row-space rank-cut methods are standard and retain the earlier repository method credit to eumemic's PR288 and Ali Romman's PR468, summarized in `fixed-support-unary-query-bounds/README.md`. That related fixed-carrier theorem is not a dependency or a proof of this physical-code result. Distinct agents derived the proof, audited its mathematical scope, checked an independent binary formula and prepared the portable package. Their agreement is agent corroboration, not independent human or proof-kernel acceptance. + +- Dugongue's PR4929 supplies the native center-free code A, its all-input producer contract and 408 independent helper endpoints. +- PR4933, prepared for Dillon, supplies the actual real signed orthogonal normalizers K_i, physical code C, exact phase conventions and fixed owner recoding. +- Chris R/Clear1nsight's PR4932 `coded-port-adapter-ceiling` supplies the finite-phase group-algebra formulation, tensor faithfulness theorem, physical adapter interface and the distinct one-parallel-bank grade-two result. The present theorem changes chronology and method; it does not relabel that predecessor result. +- The retained `passive-saved-query-ceiling` package supplies the explicit uniform finite-alphabet clarification and its separate passive-controller scope. Its owned-reset clarification is respected: no inverse-uncompute or reset-cost lower bound is used here. +- Cinna Davis/1337isnot1337's PR4694/4698, Cao Yifan/intqwq's PR4610 and round-three native source, zxv's exact Clifford work, and the retained helper, compiler and outer contributors remain credited through the cited packages and source notices. + +No predecessor implementation is vendored. The main verifier executes authenticated existing `coded-native-caller/clifford_exact.py` bytes and reads the retained code/normalizer receipts. Its byte origin and Apache-2.0 obligations remain in `coded-native-caller/NOTICE` and `ORIGINS.json`, pinned as provenance in SOURCES.json. The independent binary checker does not import that implementation. All new files are under the repository's Apache-2.0 license. + +The native all-input theorem and its physical recoding are inherited premises. This package does not rerun the full source producer, provide a numerical compiler/outer admission, or promote either historical or current source claims to formal theorem acceptance. diff --git a/research/coded-active-query-bound/EXTENSION-REVIEW.md b/research/coded-active-query-bound/EXTENSION-REVIEW.md new file mode 100644 index 0000000000..c7feabd98c --- /dev/null +++ b/research/coded-active-query-bound/EXTENSION-REVIEW.md @@ -0,0 +1,95 @@ +# Independent mathematical review of the active local-query obstruction + +Review by a separate OpenAI Codex agent, 2026-10-23. This is AI-assisted mathematical review and executable corroboration, not independent human acceptance or proof-kernel verification. Repository and GitHub state were not changed by this reviewer. + +## Result + +I found no remaining mathematical blocker in the fresh-input active-query argument, including the finite-monomial-alphabet strengthening, homogeneous direct sums, canonical rectangular mode maps, and free retraction basis changes described below. The restrictions in this report are essential. In particular this is not a lower bound on the complete p2/p16 caller or an arbitrary multiplication implementation. + +The first draft was read with its finite Clifford ambient algebra. I independently proposed the explicit small-width caveat, reviewed the author's stronger finite-H formulation, and checked each extension algebraically. The draft snapshot initially replayed had PROOF.md SHA256 `bdc4e345c2a52bdc1dc4a6caff61ecb5eb84e9909cf8d16515b93ac322f33889` and verifier SHA256 `d21ffd6282cd226080db0fabde57a5e2b96623633d503769a49c6b3f0b85efde`. The extensions below were reviewed from the stated formulas and messages; their final integration may change those hashes. This report does not pretend the final package bytes were already replayed at that point. + +## 1. Algebra and tensor faithfulness + +Only the free monomial group H needs to be fixed and finite up to its stated finite scalar phases. It may be the full group of one-column coordinate permutations and phases in a fixed root-of-unity group; it need not consist only of Clifford monomials. The group generated by H and Q need not be finite. + +Take k=C, quotient the finite H group algebra by each scalar relation [z]=zeta^f, and call the result B_f. It has finite dimension |H/Z|. Every free coefficient belongs to this algebra, and products of free coefficients stay in it. For the endpoint proof, only a finite union of projective cosets is needed: H together with the finitely many g_ij H, or H together with the relevant H g_ij. It is unnecessary to close this support under arbitrary paid products. + +The tensor-power Gram argument is valid on this finite set of projectively distinct unitary representatives. Distinct projective unitaries have normalized inner product of magnitude strictly below one, so diagonal dominance establishes injectivity at every sufficiently large f. Products of free coefficients and the target by a free kernel vector stay inside that finite support. This is sufficient for the contradiction even if a paid query is an arbitrary one-field linear operator outside the finite support. + +The theorem must be phrased as a uniform/all-width obstruction, or pointwise for every sufficiently large width. It is false as a 112-query assertion at every individual width: at f=1 the central Gaussian Q=((1+i)/2)I+((1−i)/2)X already lies in the free monomial algebra. Width-dependent scalar coefficients are permitted because the proof works separately at each sufficiently large width. A width-dependent alphabet or arbitrary noncolumnwise address maps are not permitted by this argument. + +## 2. Actual source cosets and the eight-mode issue + +For g_ij=Q^−1 K_i^−1 K_j Q, the ratio g_ij^−1 g_ik is Q^−1 K_j^−1 K_k Q. With the signed orthogonal binary normalizers, its Z-to-X block is G e e^T+e e^T G. It has rank zero precisely when G e=e and rank two otherwise. Distinct source central vectors therefore give distinct right monomial cosets, including after enlarging H to all monomials: a genuinely nonmonomial unitary cannot become monomial by changing its allowed phase alphabet. + +The source's zero diagonal and nonempty off-diagonal support in every column imply that (J−F)w=0, w in B_f^112, forces w=0 for every free F. The module convention is consistent: matrix coefficients act on the left, and the column domain is a right B_f-module. The kernel argument uses only finite-dimensional k-linear algebra, so zero divisors or noncommutativity in B_f cause no difficulty. + +The eight-mode factorization is not a contradiction. It gives low rank over the larger operator algebra containing the conjugated Gaussian maps. It does not supply a nonzero kernel column over the smaller free algebra B_f. The separated-coset proof establishes exactly that distinction. + +## 3. Chronological feedback and bypasses + +The normal form y_t=T_t(b_t x+sum_(s A_f^r. Since dim_C(A_f)=|H|, if r<112 this map has a nonzero kernel column w. On inputs x_j=w_j z, the first call input is zero and therefore y_1=0. Inductively every paid response vanishes. Correctness would then give (J-F0)w z=0 for every field vector z, contradicting the no-free-column-kernel statement once the group-algebra representation is faithful. + +Independent dirty auxiliaries can be set to zero. Fixed affine constants can be removed by differencing executions; equivalently apply the argument to the homogeneous input dependence. Correlated inputs x_j=w_j z are a valid test of an identity required for all input tuples. They do not assume that the original independent jobs are allowed to share their arbitrary inputs in the claimed implementation. + +## 4. Tensor lift and phase audit + +Choose unitary representatives U_g of the projective group. For distinct projective classes, rho_gk=|tr(U_g^* U_k)/d|<1. Let rho be the maximum over the finite group. The normalized Gram matrix of U_g^{tensor f} has diagonal 1 and off-diagonal magnitude at most rho^f. Once (|G|-1)rho^f<1 it is positive definite. Thus the map R_f -> End(V_f), g -> U_g^{tensor f}, is injective for every sufficiently large f. Its multiplication uses the cocycle alpha^f, so no phase-divisibility restriction on f is necessary. + +This threshold is uniform over all allowed scalar coefficients, control choices and free circuit lengths. A nonzero abstract (J-F0)w therefore supplies an actual vector z on which it is nonzero. No tensor power of an owner sum is replaced by a sum of tensor powers. + +## Scope boundaries that must accompany the claim + +- The result does not apply at every small width. At width one, linear dependence among Clifford matrices can make Gaussian maps free in the scalar span of monomials. +- It assumes the fixed finite columnwise Clifford alphabet. Arbitrary noncolumnwise or width-dependent address permutations are not covered by the finite-dimensional algebra argument. +- One paid call has one input field and one output field of the same address dimension. Wider calls, owner-to-address packing, or a simultaneous multi-field native primitive are not one unary call in this theorem. +- Preexisting saved nonmonomial functions of x must either be excluded or have their producing paid calls included. Hence the theorem is not a claim of 112 additional calls after arbitrary global-caller history. +- The result counts total unary calls, not Gaussian grade or a weighted moment. It does not itself exclude a global three-bank-query p2 construction. +- Data-dependent branching, data-dependent scalar coefficients, or nonlinear free arithmetic are outside the fixed linear-circuit contract. + +## Evidence + +Command: + + python3 -I -B research/coded-active-query-bound/independent.py + +Result: PASS_INDEPENDENT_RIGHT_COSET_CENSUS; 112 self pairs grade 0; 12,432 distinct pairs grade 2; 5,824 supported off-diagonal code blocks. + +Source SHA-256: + +- CODE.json: 8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0 +- NORMALIZERS.json: ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da + +Prepared with substantial OpenAI Codex assistance. The packaged independent.py preserves the separately derived binary formulas, with portable paths, hash authentication, explicit checks that survive -O, and frozen receipt comparison. It imports no Clifford implementation. This review and the proof remain agent work, not independent human or formal-kernel acceptance. + +## Addendum: sharp bounds for QP and PQ + +Let P=(I-C)/14, so P_ij=b_ij K_i^-1 K_j with b_ij=(delta_ij-a_ij)/14. In particular b_ii=1/14 for the actual code. + +For QP, define h_ij=Q K_i^-1 K_j. Every h_ij has grade one, hence lies outside H. For a fixed column j, + + h_ij h_kj^-1 = Q K_i^-1 K_k Q^-1, + +which has grade two when i != k by the same orthogonal binary calculation. Thus the left cosets H h_ij are distinct. For any free F0, a left row v over A_f satisfying v(QP-F0)=0 must vanish: columnwise left-coset separation isolates each supported v_i, and b_ii != 0 ensures each row is supported. + +At the final output cut, every circuit has the form output=F0 x+F y, where y collects its r paid unary responses and F belongs to A_f^{112-by-r}. If r<112, finite complex dimension gives a nonzero left kernel row vF=0. Correctness gives v(QP-F0)=0, a contradiction. This argument allows all chronological feedback because it uses only the final free decoder. Computing P freely and applying Q separately to its 112 resulting fields attains the bound. + +For PQ, use k_ij=K_i^-1 K_j Q. These grade-one operators avoid H, and for fixed row i, + + k_ij^-1 k_ik = Q^-1 K_j^-1 K_k Q. + +Their right cosets are distinct. This supplies the no-right-kernel property modulo free F0 and the earlier chronological input-cut lower bound of 112. Applying Q separately to all 112 input fields and then applying P freely attains it. + +Therefore QP and PQ each have exact unary paid-field-call complexity 112 for every sufficiently large width under the same finite-alphabet/same-field/local-input contract. No new checker was required: the independently checked distinct-port grade-two assertion is precisely the shared combinatorial condition. The fact that P has ordinary owner-mode rank eight does not contradict these bounds; the free input/output cuts are over the monomial algebra, where the stated one-sided kernel obstruction is stronger than ordinary physical matrix rank. diff --git a/research/coded-active-query-bound/INDEPENDENT.json b/research/coded-active-query-bound/INDEPENDENT.json new file mode 100644 index 0000000000..f1a6eecdac --- /dev/null +++ b/research/coded-active-query-bound/INDEPENDENT.json @@ -0,0 +1,14 @@ +{ + "pair_grade_census": { + "0": 112, + "2": 12432 + }, + "ports": 112, + "scope": "Binary monomial/coset conditions only; no numerical group-algebra enumeration or circuit search.", + "source_sha256": { + "CODE.json": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0", + "NORMALIZERS.json": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + "status": "PASS_INDEPENDENT_RIGHT_COSET_CENSUS", + "supported_offdiagonal_blocks": 5824 +} diff --git a/research/coded-active-query-bound/PROOF.md b/research/coded-active-query-bound/PROOF.md new file mode 100644 index 0000000000..1ebf18af5b --- /dev/null +++ b/research/coded-active-query-bound/PROOF.md @@ -0,0 +1,394 @@ +# An active local-query obstruction for the actual 112-port code + +Prepared for Dillon, 2026-10-23, with substantial OpenAI Codex assistance. +This is a scoped exact local theorem with finite source checks, not a +complete-controller lower bound, a multiplication algorithm or an admission +claim. Apache-2.0. + +## Statement + +Use the actual physical native code from `research/coded-native-caller`: + +\[ + C_{ij}=a_{ij}K_i^{-1}K_j,\qquad J=Q^{-1}CQ, +\] + +where there are 112 owners, Q is the one-central-axis Gaussian, each K_i is +the retained signed orthogonal permutation normalizer, and the scalar matrix +a has zero diagonal and 52 nonzero off-diagonal entries in every column. +The 112 vectors q_i=G_i e_0 are distinct. The source factorization +C=I-14P has an eight-mode projector P. + +Fix any finite projective group H of invertible one-column monomial maps on the +declared fixed ambient address space, containing the source normalizers and +all admitted free address maps. For example, H may be the full group of +one-column permutations with phases in a fixed finite root-of-unity group; +the free permutations need not be Clifford. Every address map is lifted as +the SAME one-column map h on all f columns, h^tensor(f). Independent choices +on individual columns are outside this grammar. Free operations are +arbitrary linear owner programs over the +monomial subgroup algebra, including scalar operations, every +actual C or C inverse, owned COPY/CLEAR, arbitrary clean buffers, saved +banks, and fanout. These are charged as ordinary finite work; "free" here +means no recursive Gaussian call. Allow every paid unary call to apply an +arbitrary fixed one-field linear operator, with chronological linear +feedback from all available fields. In particular its input may use all +earlier paid responses. All coefficients are data-independent, although +they may depend on width. Every counted field has the same address width as +one source owner; a wider packed channel is not counted as one field. + +**Theorem.** A standalone exact implementation of J, or of J-I, on 112 +arbitrary fresh owner fields requires at least 112 paid unary field calls. +The statement is valid for an identity at all positive tensor widths, and +allows the scalar owner coefficients to depend on width. The same conclusion +holds after adding any free owner operator to J. +More precisely, the bound holds at every sufficiently large tensor width, +so no all-width implementation uses fewer than 112 calls. It is not a bound +at every small width: at width one, +Q=((1+i)/2)I+((1-i)/2)X is in the scalar span of free monomials. + +**Sharp one-sided corollary.** Put P=(I-C)/14. Each of QP and PQ, as a +112-input/112-output owner operator, requires at least 112 paid unary field +calls. Exactly 112 H1 calls suffice: apply P for free and then Q to every +output, or apply Q to every input and then P. Thus the eight scalar code +modes do not yield an eight-call one-sided Q repair. The statement also +holds with Q replaced by Q inverse. + +**Canonical eight-mode corollary.** For the actual source mode matrix M, +let U_mode=diag(K_i^-1)M and V_mode=M^T diag(K_i)/56. Then +P=U_mode V_mode and V_mode U_mode=I_8. Each of Q U_mode (eight fresh inputs, +112 outputs) and V_mode Q (112 fresh inputs, eight outputs) also has exact +paid-field-call complexity 112, attained by 112 H1 calls. Thus the canonical +rectangular mode ABI does not avoid the one-sided obstruction. + +It does not cover receiving Gaussian-dependent saved data, absorbing the +correction into the paid native FULLs or their prefixes, recycling an existing +paid IDLE, or a direct coded consumer with a different endpoint. Nonlinear +controls, noncolumnwise address operations, approximate endpoints, and +unequal-width packing are outside the stated model. + +## 1. Phase-correct finite algebra and all-width evaluation + +This uses the finite-phase algebra and sufficiently-large-width tensor +faithfulness already proved in `coded-port-adapter-ceiling/PROOF.md`, section +3, and clarified by the passive saved-query package's uniform-alphabet +addendum. Here only the FREE group H must be finite projectively. An ambient +group generated by H and Q need not be finite or Clifford. + +Choose one invertible matrix representative for every projective element +of H. At width f its nonzero scalar multiplication cocycle is raised to +the f-th power; the scalar factors need not have modulus one. +Let B_f be the resulting finite-dimensional twisted group algebra over +k=C, with one basis element per projective element of H. Its evaluation +is the span of the literal tensor lifts h^tensor(f). Scalar factors are +retained through the cocycle; owner coefficients are applied only once. + +Besides H itself, we will need only a fixed finite union of its projective +cosets: the sets g_ij H used for J, the analogous right cosets for PQ and +V_mode Q, and the analogous left cosets for QP and Q U_mode. Take S to be +their union with H, with repeated projective elements identified. This set +is finite because H and the source owner/mode sets are finite. Closure of +S under multiplication is not needed: all free products remain in H, and +every target-times-free expression used below stays in its declared coset +set. A different fixed finite number of source stages merely enlarges S. + +For projectively distinct nonzero representatives v_1,...,v_N, individually +normalize each by its Hilbert-Schmidt norm. Their tensor-power +Gram matrix has diagonal one and off-diagonal entries +^f, whose magnitudes are at most rho^f for some rho<1. For +(N-1)rho^f<1 the Gram matrix is strictly diagonally dominant and positive +definite. Apply this to the projective representatives in S. Their literal +tensor lifts are linearly independent for every sufficiently large f. +Thus B_f and all the required coset subspaces evaluate faithfully, with +distinct cosets in direct sum, at those widths. Scalar factors remain raised +to the f-th power; owner coefficients are never raised to that power. + +We work at any one such width. The threshold is uniform over all free +coefficients, control choices, and control lengths because H and S are +fixed. Width-dependent scalar coefficients are allowed. A width-dependent +or noncolumnwise group of arbitrary payload maps is not allowed; neither +is an infinite projective phase grammar. No assumption that arbitrary +permutations together with Q generate a finite group is made. + +## 2. Actual-source right-coset separation + +Write g_ij=Q^-1 K_i^-1 K_j Q. For a fixed i, + +\[ + g_{ij}^{-1}g_{ik}=Q^{-1}K_j^{-1}K_kQ. (1) +\] + +For the signed orthogonal permutation M=K_j^-1 K_k, let G=G_j^-1 G_k be +its binary orthogonal coordinate matrix and e=e_0. Pauli signs affect only +tableau phases. The Z-to-X block of Q^-1 M Q is + +\[ + B=G e e^T+e e^T G. (2) +\] + +If G e=e, orthogonality gives e^T G=e^T, and B=0. If G e differs from e, +then both pairs (G e,e) and (e,G^T e) are independent; the two outer products +in (2) have rank two. Thus Q^-1 M Q is monomial exactly when G e=e. +Equivalently, G_j e=G_k e, or q_j=q_k. The actual 112 source vectors are +distinct, so (1) belongs to H exactly when j=k. + +Therefore the 112 g_ij lie in distinct right H-cosets for each fixed i. +The j=i coset is H itself, since g_ii=I. The scalar phase quotient does not +alter this test: multiplying by a scalar never changes monomiality. +The companion checker verifies all 112^2 ordered pairs by both formula +(2) and the retained exact tableau implementation. It separately checks +the actual code's zero diagonal and nonempty column supports. + +## 3. No nonzero free input survives modulo a free output + +Let F_0 be ANY 112-by-112 matrix over B_f. Suppose w in B_f^112 obeys + +\[ + (J-F_0)w=0. (3) +\] + +Row i of Jw is sum_j a_ij g_ij w_j. Each summand lies in the right-coset +subspace g_ij B_f. These subspaces are in direct sum. Every component of +F_0 w lies in B_f, the H coset. The diagonal source coefficient is zero. +For each off-diagonal supported pair (i,j), projecting (3) onto g_ij B_f +therefore gives a_ij g_ij w_j=0. A nonzero scalar and a group unit are +invertible, so w_j=0. Each column j has a supported off-diagonal entry, +and hence w=0. + +This is stronger than an eigenvector statement: J-F_0 has zero kernel on +B_f^112 for every free F_0. In particular the Q-conjugated eigenspaces of +C contain no nonzero free input embedding, despite the eight-mode +factorization of C-I. A cheap compression of J-F_0 through fewer than 112 +owner fields is impossible. + +### One-sided projector operators + +Write p=(I-a)/14, so P_ij=p_ij K_i^-1 K_j and p_ii=1/14. For PQ, fix row +i. Its blocks are p_ij h_ij with h_ij=K_i^-1 K_j Q. Every h_ij has Fourier +grade one and lies outside H. Further, + + h_ij^-1 h_ik = Q^-1 K_j^-1 K_k Q. + +Thus the h_ij occupy distinct right H-cosets as j varies. The same argument +proves ker_{B_f}(PQ-F_0)=0 for every free F_0; the nonzero diagonal of p +already supplies a supported entry in each column. + +For QP fix column j instead, and put t_ij=Q K_i^-1 K_j. These grade-one +words lie in distinct LEFT H-cosets as i varies, because + + t_ij t_kj^-1 = Q K_i^-1 K_k Q^-1 + +is nonmonomial for i different from k. Consequently a free row w satisfying +w(QP-F_0)=0 must vanish: project each fixed output column onto the distinct +left-coset subspaces B_f t_ij, and use p_ii different from zero. This is the +left-kernel version of the same source-specific separation. + +### Canonical rectangular eight-mode maps and free rebasing + +The retained 112-by-8 scalar mode matrix M obeys M^T M=56I_8 and +a=I-MM^T/4; each row has four nonzero entries. The checker verifies every +entry of these identities from the pinned source receipt. Define + + U_mode = diag(K_i^-1) M, shape 112 by 8, + V_mode = M^T diag(K_i)/56, shape 8 by 112. + +These maps are free, with P=U_mode V_mode and V_mode U_mode=I_8. +For Q U_mode the fixed mode-column a has entries M_ia Q K_i^-1. The words +t_i=Q K_i^-1 lie in distinct left H-cosets, since +t_i t_k^-1=Q K_i^-1 K_k Q^-1 is nonmonomial when i differs from k. +Each t_i itself is nonmonomial. Every row of M has a nonzero entry, so +the same columnwise projection proves that + + w (Q U_mode-F_0)=0, w in B_f^(1 by 112), + +forces w=0 for every free 112-by-8 F_0. Thus the no-left-kernel conclusion +holds even though there are only eight fresh inputs. + +Dually, V_mode Q has entries M_ja K_j Q/56. The words K_j Q lie in +distinct right H-cosets because their pairwise relative transports are +Q^-1 K_j^-1 K_k Q. Every source column is represented in at least one mode +row. Hence (V_mode Q-F_0)w=0, with w in B_f^112, forces w=0 for every free +8-by-112 F_0, even though there are only eight outputs. + +These conclusions cover all free changes of retraction basis. If another +free pair U',V' has P=U'V' and V'U'=I_8, then + + W=V_mode U', W^-1=V' U_mode, + U'=U_mode W, V'=W^-1 V_mode. + +The two inverse identities follow by substituting U'V'=P and +U_mode V_mode=P. Thus Q U' and V'Q differ from the canonical operators by +invertible free input or output boundaries. No cheaper implementation is +obtained by any such free eight-mode basis choice. + +## 4. Arbitrary chronological paid calls + +Normalize any finite acyclic linear implementation by retaining all paid +responses y_1,...,y_r. COPY, saves, fanout, overwrite and CLEAR are included +in this normalization: enlarging owned storage can preserve the history +without introducing another recursive call. At paid call t its input is + +\[ + b_t x+\sum_{s B_f^r. As a k-linear map its +domain has dimension 112 dim_k B_f and its codomain has dimension +r dim_k B_f. If r<112, choose a nonzero w in its kernel. Substitute the +formal input x=w z, with z one arbitrary field. Every direct term b_t w is +zero. Induction on t in (4) gives every paid response y_t=0, regardless of +T_t and regardless of the active feedback coefficients. Thus the claimed +endpoint J must satisfy Jw=F_0w. Section 3 contradicts this. + +This proves r>=112. Replacing J by J-I or J+F_free merely changes the free +matrix F_0 and gives the same result. + +The input-kernel proof applies verbatim to PQ. For QP use the dual output +cut: concatenate the free output columns in (5) into L in B_f^(112 by r). +If r<112, the k-linear map w -> wL from B_f^(1 by 112) to B_f^(1 by r) +has a nonzero kernel row w. Multiplying the endpoint by that row annihilates +every paid-response term, so w(QP-F_0)=0, contrary to the left-kernel result. +No assumption about the paid calls' chronology is needed beyond the +existence of the finite linear circuit normal form. + +For Q U_mode the same output cut has 112 rows and r paid-response columns, +although F_0 has only eight input columns. It again gives r>=112. For +V_mode Q the same input cut has 112 input columns, although F_0 has only +eight output rows, and also gives r>=112. Both bounds are attained by +112 H1 calls: expand eight fields through U_mode for free and apply Q to +all 112 results; or apply Q to the 112 inputs and contract through V_mode +for free. Invertible free retraction basis changes preserve these counts. +The same arguments apply with Q inverse throughout. + +## 5. Direct sums and local amortization + +For any fixed positive m, consider m fresh physical code blocks, embedded +in one fixed ambient address space. Each block may use its own eight fresh +axes and physical normalizers, with the same 112 distinct-direction +property. Let N=112m. The same proof gives + +* diag(J_1,...,J_m), or its free perturbation: at least N paid field calls; +* diag(P_1 Q,...,P_m Q): exactly N H1 calls are necessary and sufficient; +* diag(QP_1,...,QP_m): exactly N H1 calls are necessary and sufficient. +* diag(Q U_mode,1,...,Q U_mode,m), and its free retraction rebases: + exactly N H1 calls are necessary and sufficient; +* diag(V_mode,1 Q,...,V_mode,m Q), and its free retraction rebases: + exactly N H1 calls are necessary and sufficient. + +Free controls may mix different blocks arbitrarily. To see why this does +not change the proof, write a candidate free kernel column or row in m +blocks. Project each target block's rows or columns onto its nontrivial +cosets. The free comparison operator still contributes only the H coset, +even when it mixes all N owners. The corresponding single-block argument +forces every block of the candidate kernel to vanish. Apply the input or +output dimension cut with B_f^N and r=1 and price at least one, so the local correction costs at least 112. +Its added recursive price exceeds the removed-center saving by at least +48 per FULL. The direct-sum theorem gives a gap of at least 48m for m such +standalone local repairs, even when their free controls mix all inputs. + +Thus this isolated interface-restoration strategy cannot turn the removed +eight H8 calls into a recursive saving anywhere in 0<=c<1. Extra ordinary +work can only increase the cost. The conclusion does not price or rule out +absorption into correlated FULL, IDLE, or saved-query data in a complete +caller, nor a different direct coded endpoint. + +### Relationship to predecessor and active caller work + +The predecessor `coded-port-adapter-ceiling` (#4932) proves that one parallel +bank needs 112 grade-2 channels for its physical recovery adapter, using a +grade projection of full rank. It expressly excludes multiple chronological +banks. The argument here uses source-specific distinct right cosets and an +input-kernel cut to cover arbitrary chronological paid unary calls and +active feedback. Its conclusion is 112 calls of any grade; it does not +claim 112 grade-2 calls in this enlarged model. + +The conclusion excludes an independently implemented 16-, 32-, or 42-H1 +fresh-input correction of J, J-I, QP, or PQ through the native code's eight +modes. For J and J-I this is a lower bound, with the elementary 224-H1 +conjugation implementation as an upper bound; 112-call attainability is +not asserted. For QP and PQ the 112-H1 bound is attained. +It does not prove that p2 needs four thin banks, nor that a complete active +three-bank caller is impossible. Such a caller can already hold nonfree +data from its FULLs, queries, and IDLE. A useful construction must exploit +that shared paid access, change the endpoint, or leave this local grammar. +The particular eight-mode ABIs Q U_mode and V_mode Q, including their free +retraction rebases, are covered above. An arbitrary different eight-mode +endpoint, the middle compression V_mode Q U_mode, and the two-sided +compression PQP remain outside the claims. + +The actual #4932 entrance adapter is also covered by free equivalence. Its +physical monomial X wrapper is M_i=U_i K_i Q^-1. Therefore +U a U*=M (Q C Q^-1) M*, and Q C Q^-1=Q^2 J Q^-2. Since Q^2 and M are free, +and a^-1=(a+12I)/13, the physical U a^-1 U* differs from J by invertible +free boundaries, a nonzero scalar, and a free bypass. These operations +preserve the local paid-call lower bound. This correspondence uses the +retained exact physical wrapper identities; it does not replace U_i with +a bare Fourier along q_i. + +## Source and predecessor credit + +The source code and native producer are Dugongue's #4929. The actual signed +orthogonal normalizers and physical C formulation come from the retained +`coded-native-caller` package. The finite-phase group algebra, tensor +faithfulness, adapter scope and warning that rank-eight scalar modes are not +eight query heads come from #4932. The uniform finite-alphabet clarification +and related passive-controller limitations come from the retained passive +saved-query package. Credit also Cinna Davis/1337isnot1337's #4694/#4698, +Cao Yifan/intqwq's #4610 source, zxv's retained exact Clifford/compiler work, +and all source notices. This active local input-kernel argument was derived +in the current research session with substantial OpenAI Codex assistance. + +No independent human or formal-kernel acceptance is claimed. The source +native all-input theorem, numerical outer admission, and complete caller +endpoint are inherited or open, not replayed by this scratch result. diff --git a/research/coded-active-query-bound/README.md b/research/coded-active-query-bound/README.md new file mode 100644 index 0000000000..f8858cea6b --- /dev/null +++ b/research/coded-active-query-bound/README.md @@ -0,0 +1,60 @@ +# Sharp active local query cost for the physical eight-mode code + +**The physical code's one-sided correction and eight-mode extraction/expansion each require exactly 112 unary field calls in the stated local model, attained by 112 H1 calls.** The conjugated adapter `J=Q^-1 C Q` and `J-I` each require at least 112 unary paid calls. The proof permits arbitrary chronological linear feedback, saved inputs, copies, owned resets, fanout and free mixing across any fixed number of independent blocks. No new κ or complete-caller lower bound is claimed. + +Here `C_ij=a_ij K_i^-1 K_j` is the actual 112-port code from [#4933](https://github.com/CrocSwap/integer-mult-bounds/pull/4933), `P=(I-C)/14`, and Q is the central rank-one Gaussian. A field call operates on one owner-width field. Free operations are finite linear owner programs over a fixed finite projective group of one-column invertible monomial maps; they have ordinary scalar/routing/precision cost but no recursive Gaussian call. Paid unary maps may be arbitrary zero-preserving linear maps, so the lower bound also applies when those maps are Gaussian calls of any rank. + +The free permutations may be non-Clifford; no finite ambient Clifford group is assumed. The theorem concerns identities required at every positive tensor width; its obstruction holds at every sufficiently large width. Each admitted one-column map h acts by the same tensor lift `h^⊗f` in every column; independent per-column choices are not admitted. Scalar coefficients and finite control choices may depend on width. At width one, Gaussian operators can lie in the scalar span of monomials, so the lower bound is deliberately not asserted for every small width. It excludes wider packed channels, arbitrary noncolumnwise address maps, nonlinear or data-dependent controls, approximate endpoints and preexisting nonfree observations of the fresh inputs. A running native caller may already possess such observations, so this result does not exclude an active three-query p2 construction. + +Write `U=diag(K_i^-1) M` and `V=M^T diag(K_i)/56` for the actual source mode maps. Then `P=UV` and `VU=I_8`. The local endpoints have the following exact call bounds at sufficiently large width: + +| Endpoint | Fresh input fields | Output fields | Paid unary calls | +|---|---:|---:|---:| +| QP or PQ | 112 | 112 | Exactly 112 | +| QU, mode expansion followed by Q | 8 | 112 | Exactly 112 | +| VQ, Q followed by mode extraction | 112 | 8 | Exactly 112 | +| J or J-I | 112 | 112 | At least 112; 224 H1 suffice | + +The mode bounds also cover every free eight-mode retraction basis `P=U'V'`, `V'U'=I_8`, since these differ from U,V by invertible free boundaries. They do not classify arbitrary unrelated eight-output operators. + +## What changes relative to the predecessors + +[#4932](https://github.com/CrocSwap/integer-mult-bounds/pull/4932)'s [coded-port adapter ceiling](../coded-port-adapter-ceiling/README.md) treats one parallel query bank and forces 112 grade-two channels. The [passive saved-query ceiling](../passive-saved-query-ceiling/README.md) keeps its later paid inputs fixed. This package uses a different invariant: the physical port transports occupy distinct monomial cosets. An input or output kernel cut then covers **arbitrary chronological paid calls and active linear feedback** for the standalone local endpoint. Its 112-call result counts calls of any grade; it does not extend the predecessor's grade-two conclusion to the larger model. + +The core source fact is that the 112 vectors `G_i e0` are distinct. For each fixed output i, the words `Q^-1 K_i^-1 K_j Q` lie in distinct right monomial cosets. Each source column has 52 nonzero off-diagonal entries. Consequently `J-F` has no nonzero free input column for any free bypass F. A circuit with fewer than 112 unary calls has a nonzero free input direction that vanishes at every paid input, even when later calls use previous responses. These statements contradict each other. The output-cut version proves the QP bound; the input-cut version proves PQ. Applying Q to all 112 fields before or after the free P realizes each one-sided upper bound. + +For m independent copies, arbitrary cross-copy free mixing still requires 112m calls. The one-sided 112m-H1 upper constructions attain those bounds. This is a direct-sum statement about the declared local endpoints, not about amortization into already-paid FULLs, IDLEs or native internal prefixes. For J/J-I, 112-call attainability remains open; the elementary conjugation uses 224 H1 calls. + +An isolated repair that restores one backward coded FULL to the ordinary uncoded FULL is also priced sharply. Since `C=I−14P`, the exact entry patch is `X ← X−14QP Y`; it needs 112 H1 calls in the enlarged local model. The inherited producer removes only 8 H8 calls, worth at most 64 in every moment with exponent `1−c`, `0≤c<1`. Thus such an independently implemented repair increases the recursive paid bill by at least 48 per FULL, or 48m for a direct sum. The eight-H8 removal is an inherited source invoice, not replayed by this checker. Absorbing the patch into already-paid native operations is outside the corollary. + +The mathematical argument, finite phase treatment and all-width scope are in [PROOF.md](PROOF.md). [INDEPENDENT-REVIEW.md](INDEPENDENT-REVIEW.md) records a separately derived proof audit and binary census. [EXTENSION-REVIEW.md](EXTENSION-REVIEW.md) audits the finite-H extension, rectangular modes, rebasing, direct sums and isolated-patch tariff. Neither is independent human or proof-kernel acceptance. + +## Evidence and reproduction + +Python 3.12 for the registered runner, standard library only, from the repository root: + +```sh +python3 -B scripts/research_package.py --package research/coded-active-query-bound +``` + +Direct replay, including after an official package export with its declared inputs: + +```sh +python3 -I -W error -B research/coded-active-query-bound/verify.py +python3 -I -O -W error -B research/coded-active-query-bound/verify.py +python3 -I -O -W error -B research/coded-active-query-bound/independent.py +``` + +The main verifier authenticates the code, normalizers and exact Clifford implementation before executing the latter's source bytes. It checks all 12,544 ordered port pairs by both a separately written binary formula and source tableaus: 112 self pairs have grade 0; 12,432 distinct pairs have grade 2; all 5,824 supported off-diagonal code terms are grade 2. It also checks 12,544 left-coset conjugates, 12,544 one-sided grade-one transports, the 52-entry column supports, all 12,544 entries of `a=I-MM^T/4`, all 64 entries of `M^T M=56I`, and four mode contacts per owner. Four rejection controls alter a direction, a source column, the diagonal or a mode factor. The independent checker imports no Clifford implementation. Both compare exact finite receipts; checks remain active under `-O`. + +[RESULT.json](RESULT.json) and [INDEPENDENT.json](INDEPENDENT.json) are finite source receipts. They do not enumerate the monomial group algebra, test every circuit, or mechanically prove the tensor/kernel argument. [SOURCES.json](SOURCES.json) pins frozen main `4c0a359d88f22f05189d51f48387750b801a45d4`, live inputs and proof provenance. [VERIFY.json](VERIFY.json) declares every live input. The submission base is refreshed canonical main `20a1e31bc6009b9b3f4d084bbaadc6350e34fcba`; the earlier scientific pins remain unchanged. No predecessor package is copied or altered; provenance-only proof references resolve through the pinned Git history. [VALIDATION.md](VALIDATION.md) states executed checks and unrun obligations. + +## Open next questions + +Can a complete coded caller use nonfree observations that its FULLs and IDLEs already produced to recover all prescribed independent Gaussian outputs? This is the meaningful route left by the local result. The first step is one explicit changed paid input with its retained observations, followed by all terminal operator identities and a complete invoice. The current package supplies no such global endpoint. The final checkpoint also reviewed Cinna Davis's [common-code moving-stage interface](../common-code-moving-stages/README.md), whose transported Gaussian stages fail the inherited commutation relation, and JoyboyBrian's [fresh-D coherent-pair countermodel](../two-full-fresh-d-coherent-pair/README.md). Their changed interfaces and endpoint obligations remain distinct from this local query theorem. + +What is the exact complexity of J or J-I between 112 and 224 calls? A smaller explicit chronological circuit or stronger cut invariant would resolve the gap. The sharp 112 result for QP/PQ does not settle it. Structured first steps and blockers are in [TASK.json](TASK.json). + +## Credit + +Prepared for Dillon with substantial OpenAI Codex assistance from separate proof, independent-review, construction and packaging agents. Credit Dugongue's center-free producer [#4929](https://github.com/CrocSwap/integer-mult-bounds/pull/4929), the real signed normalizers/physical C in #4933, Chris R/Clear1nsight's #4932 finite phase algebra and one-bank theorem, the passive package's uniform-alphabet clarification, Cinna Davis/1337isnot1337's #4694/#4698, Cao Yifan/intqwq's #4610 native source, zxv and the retained Clifford/helper/compiler lineage. See [ATTRIBUTION.md](ATTRIBUTION.md). Standard causal/image/row-space rank cuts retain earlier method credit to eumemic's PR288 and Ali Romman's PR468, as summarized in [fixed-support unary-query bounds](../fixed-support-unary-query-bounds/README.md); that different carrier theorem does not imply the physical-code result here. New work is Apache-2.0. The selected frontier remains unchanged. diff --git a/research/coded-active-query-bound/RESULT.json b/research/coded-active-query-bound/RESULT.json new file mode 100644 index 0000000000..c1b59eb73e --- /dev/null +++ b/research/coded-active-query-bound/RESULT.json @@ -0,0 +1,43 @@ +{ + "all_ordered_pair_fourier_grade": { + "0": 112, + "2": 12432 + }, + "canonical_mode_expansion_and_extraction_H1_optimum": 112, + "column_nonzero_support": { + "52": 112 + }, + "complete_controller_lower_bound": false, + "conjugated_J_112_call_attainability_claimed": false, + "distinct_central_vectors": 112, + "free_alphabet": "Any fixed finite projective monomial group H; each map is the same one-column h tensor-lifted on all columns. Independent per-column controls are excluded. No finite ambient Clifford-group premise is required.", + "independent_formula_and_exact_tableau_checks": 12544, + "left_coset_tableau_checks": 12544, + "minimum_paid_unary_same_width_field_calls": 112, + "mode_contacts_per_owner": 4, + "mode_factor_entries_checked": 12544, + "mode_gram_entries_checked": 64, + "mutation_controls_rejected": [ + "duplicate physical direction", + "empty code column", + "nonzero source diagonal", + "changed source mode factor" + ], + "one_sided_QP_and_PQ_H1_optimum": 112, + "one_sided_transport_fourier_grade": { + "1": 12544 + }, + "owner_count": 112, + "proof_kernel_checked": false, + "schema": "actual-coded-active-local-query-obstruction/1", + "source_sha256": { + "CODE.json": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0", + "NORMALIZERS.json": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da", + "clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + "status": "PASS_ACTUAL_SOURCE_COSET_SEPARATION", + "supported_pair_fourier_grade": { + "2": 5824 + }, + "theorem_scope": "Standalone J=Q^-1 C Q, J-I, QP, PQ, canonical Q U_mode and V_mode Q, their free retraction rebases, and homogeneous direct sums; fresh inputs; arbitrary chronological unary same-width paid calls with data-independent linear feedback." +} diff --git a/research/coded-active-query-bound/SOURCES.json b/research/coded-active-query-bound/SOURCES.json new file mode 100644 index 0000000000..780cb3b01b --- /dev/null +++ b/research/coded-active-query-bound/SOURCES.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "base_commit": "4c0a359d88f22f05189d51f48387750b801a45d4", + "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" + }, + { + "path": "research/coded-native-caller/CODE.json", + "usage": "input", + "git_blob": "03170f4a31f7a8a3db7228f1cd5a6fdcb32720ae", + "sha256": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0" + }, + { + "path": "research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coded-native-caller/PHYSICAL.md", + "usage": "input", + "git_blob": "da8837ba67423ef08ef1afb8e8297a8032aafe9f", + "sha256": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078" + }, + { + "path": "research/coded-native-caller/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/coded-port-adapter-ceiling/PROOF.md", + "usage": "provenance", + "git_blob": "02876d6f7ad575a012ce29db41fb83e1cc23358d", + "sha256": "f7b86b69d60219b3b251d842694861d1fb6efff0e4c3c885d267468b29846c13" + }, + { + "path": "research/passive-saved-query-ceiling/evidence/frozen/pr4948-saved-query-macro-gate/UNIFORM-ALPHABET-ADDENDUM.md", + "usage": "provenance", + "git_blob": "d742381500d94759a3278050d86b7d1dcc726a7e", + "sha256": "f51448dc7551e8b61613c642d9487282f06e2ddc6274b1693276920688d5496f" + }, + { + "path": "research/coded-native-caller/NOTICE", + "usage": "provenance", + "git_blob": "985b6b1bc76dacd54a9cbe9897f3b659ae93c3a4", + "sha256": "317b1c5e040bab50ebfc3d0cdb3a47fc30e2f872a00895f563d7931749b1cc7b" + }, + { + "path": "research/coded-native-caller/ORIGINS.json", + "usage": "provenance", + "git_blob": "e18a033d4de1d997f55e84d1535fc6cde20424c4", + "sha256": "10cf47173ca238c32adb923daae7c1137c2e9c86c7066301d68fc74442b3f4d7" + } + ] +} diff --git a/research/coded-active-query-bound/TASK.json b/research/coded-active-query-bound/TASK.json new file mode 100644 index 0000000000..e17100892e --- /dev/null +++ b/research/coded-active-query-bound/TASK.json @@ -0,0 +1,118 @@ +{ + "schema_version": 1, + "task_id": "centre-path-sharing", + "priority_revision": 7, + "base_commit": "4c0a359d88f22f05189d51f48387750b801a45d4", + "original_card": { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). 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": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "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": [ + "Removing copies without a replacement contract for the decoder's copied totals.", + "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": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + "scope_status": "changed", + "actual_scope": "Sharp 112-call local complexity of QP, PQ, canonical Q U_mode and V_mode Q (including free retraction rebases), and a 112-call lower bound for J=Q^-1 C Q or J-I; arbitrary chronological unary calls, active data-independent linear feedback and homogeneous direct sums over a fixed finite projective monomial group.", + "scope_change_reason": "The native center-free producer replaces the center path with a physical code. The actionable question is whether its eight modes permit a compressed fresh-input decoder after earlier one-parallel-bank and passive-caller results. This changes the original sharing card to an active local interface theorem and does not claim a global caller obstruction.", + "bottleneck_link": "A 16-, 32- or 42-call fresh-input correction would fit attractive coded-caller budgets. The sharp 112-call theorem excludes that standalone route and directs construction toward reusing nonfree FULL/IDLE history.", + "budget_minutes": null, + "stop_rule": "Stop this package after the all-width active local theorem, exact actual-source coset census, semantic controls and independent binary corroboration. Do not turn bounded caller searches into a universal caller lower bound.", + "outcome": "completed", + "evidence": "Written finite-coset tensor-faithfulness and input/output kernel-cut proof; all 12,544 actual port pairs by binary formula and exact source tableaus; all 5,824 supported terms; 12,544 code-factor and 64 mode-Gram equalities; four source-condition rejection controls; separate binary census; normal and optimized replay.", + "author": "Dillon", + "ai_assistance": "Substantial OpenAI Codex assistance from distinct proof, independent-review, construction and packaging agents; no independent human or proof-kernel acceptance is claimed.", + "open_questions": [ + { + "question": "Can a complete coded caller exploit its already-paid FULL/IDLE responses to recover every prescribed independent Gaussian output?", + "why_it_matters": "The local theorem excludes preexisting nonfree observations; successful global sharing could still avoid paying a fresh 112-call repair.", + "first_step": "Specify one changed paid input and its retained responses, then bind every terminal main/helper operator and the complete paid inventory.", + "blocked_by": "No complete favorable global endpoint follows from this local theorem." + }, + { + "question": "What is the exact unary call complexity of J or J-I between the 112 lower bound and 224-H1 construction?", + "why_it_matters": "The sharp 112 result applies to QP/PQ; it does not assert attainability for the two-sided conjugated adapter.", + "first_step": "Produce a same-field finite-alphabet circuit with fewer than 224 calls or strengthen the chronological lower bound.", + "blocked_by": "The present input-kernel cut distinguishes call count but does not classify the remaining paid maps." + } + ], + "budget_note": "The donor explicitly removed the one-hour limit and asked for sustained ambitious research. This package is one independently reviewable result from that ongoing session.", + "session": { + "started_utc": "2026-10-23T07:55:06Z", + "selection_completed_utc": "2026-10-23T08:10:00Z", + "budget": "User removed the hour limit; no fixed session deadline." + }, + "checkpoints": [ + { + "utc": "2026-10-23T07:55:06Z", + "canonical_main": "4c0a359d88f22f05189d51f48387750b801a45d4", + "priority_revision": 7, + "selected_kappa": "0.00302015", + "decision": "New isolated worktree; previous sources and branch preserved." + }, + { + "utc": "2026-10-23T08:49:49Z", + "canonical_main": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "priority_revision": 7, + "selected_kappa": "0.00302015", + "decision": "Continue original frozen scientific inputs. Guidance, priorities and selection unchanged. PR5065/5069 merged at unchanged scientific heads. Active two-sided query and mixed-orientation construction remains open." + }, + { + "utc": "2026-10-23T09:27:05Z", + "canonical_main": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "priority_revision": 7, + "selected_kappa": "0.00302015", + "decision": "Continue original frozen physical inputs; derive independent active local-query lower bound and enlarge constructive search to actual port-dependent free intertwiners preserving common G17." + }, + { + "utc": "2026-10-23T09:54:17Z", + "canonical_main": "20a1e31bc6009b9b3f4d084bbaadc6350e34fcba", + "priority_revision": 7, + "selected_kappa": "0.00302015", + "decision": "Advance isolated publication branch to refreshed main. Guidance and all live inputs unchanged. Read newly archived common-code-moving-stages (Cinna Davis) and two-full-fresh-d-coherent-pair (JoyboyBrian); distinct constructive interfaces do not replace this fresh-input query theorem. Frozen scientific baseline remains4c0a359d8." + } + ], + "coordination": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19141406", + "overlap_checked_utc": "2026-10-23T09:47:52Z", + "open_prs": 307, + "discussion_records": 4262, + "local_note_records": 6764, + "complete_reported_remote_pagination": true, + "limits": "Titles/bodies and local README/TASK notes, not arbitrary diffs or unpublished work. Closest scoped predecessors #4932 and #4978 were read separately." + } +} diff --git a/research/coded-active-query-bound/VALIDATION.md b/research/coded-active-query-bound/VALIDATION.md new file mode 100644 index 0000000000..62c69983a0 --- /dev/null +++ b/research/coded-active-query-bound/VALIDATION.md @@ -0,0 +1,29 @@ +# Validation and evidence limits + +Executed on 2026-10-23, macOS 27.0.1 arm64, with CPython 3.12.15 for the final registered and portable replays. Standard library only. The separate initial binary audit also passed on CPython 3.14.7. No network service, native build, solver or historical full-source replay is required by these commands. + +## Completed checks + +The following registered replay passed with the final mathematical checker and its four source-condition mutations: + +```sh +python3.12 -B scripts/research_package.py --package research/coded-active-query-bound +``` + +It ran the source checker in isolated normal and optimized modes and the separately derived binary checker in isolated optimized mode. Every command used warnings-as-errors. Results were `PASS_CODED_ACTIVE_QUERY_BOUND`, `PASS_INDEPENDENT_RIGHT_COSET_CENSUS`, and `PASS_REGISTERED_RESEARCH_PACKAGE`. All mathematical checks use explicit exceptions; disabling assertions does not disable them. The retained exact Clifford implementation was executed from authenticated source bytes, bypassing any preexisting bytecode cache. + +The registered checker authenticates CODE.json, NORMALIZERS.json and clifford_exact.py; metadata also authenticates the declared PHYSICAL.md interface and frozen Git proof provenance. It verifies all 12,544 ordered right-coset tests by both a new binary formula and the retained Clifford tableaus, all 12,544 left-coset tests, all 12,544 one-sided grade-one tests, the 5,824 supported code terms, 52-entry column support, and 112 distinct source directions. It checks all 12,544 code-factor entries, all 64 mode-Gram entries and four mode contacts per owner. Four mutation controls reject a duplicate direction, empty source column, nonzero diagonal and altered mode factor. Coincident directions give the expected grade-zero positive exception. + +The independent binary checker authenticates its two inputs and reconstructs the complete right-coset census without importing the retained Clifford code. Its scope is that binary/source census; it does not independently replay the mode matrix or a native producer. + +A separate temporary directory received only this package and the four live inputs declared in VERIFY.json, with no Git directory. Both direct optimized checkers passed there. The main checker took approximately 2.46 seconds and the independent check 1.06 seconds on this machine. The source package bytes were unchanged by that read-only replay. The process made no network requests; operating-system network isolation was not imposed. This establishes portable direct replay of the declared executable inputs, not an official committed package export. + +## Mathematical review and remaining obligations + +[INDEPENDENT-REVIEW.md](INDEPENDENT-REVIEW.md) records a separate AI-agent derivation and binary audit. [EXTENSION-REVIEW.md](EXTENSION-REVIEW.md) audits finite projective H, nonunitary normalization, rectangular modes, free retraction rebasing, homogeneous direct sums and the isolated-patch tariff. It distinguishes its initial executable snapshot from later algebraic review. The final package replay above includes the subsequently added mode checks. These are AI-agent reviews, not independent human or formal-kernel acceptance. + +The all-width implications are written proofs using a finite-coset tensor Gram argument and input/output dimension cuts. The checker does not enumerate H, calculate a universal width threshold, search all circuits or verify those proofs in a kernel. It supplies the exact physical-source facts used in them. The eight rank-eight calls removed by the producer are inherited from the pinned source invoice; this package does not recount the native word. + +No complete coded caller endpoint, native internal-prefix schedule, changed compiler, finite-precision realization, stock protocol, full multiplication algorithm, selected cold replay or new κ is supplied. The nonfree-history, width-one, per-column-alphabet and same-field restrictions in PROOF.md remain material. + +The submitting agent repeated the registered normal/optimized/independent replay in an isolated publication worktree; it passed. The final upstream refresh advanced that worktree to `20a1e31bc6009b9b3f4d084bbaadc6350e34fcba`; all live scientific inputs and relevant guidance were byte-identical to the preceding checkpoint. Publication-byte/source-history preflight, official committed export and hosted CI results are recorded in the contribution PR against its publication commit. No selected record or predecessor file was changed. diff --git a/research/coded-active-query-bound/VERIFY.json b/research/coded-active-query-bound/VERIFY.json new file mode 100644 index 0000000000..2b71404883 --- /dev/null +++ b/research/coded-active-query-bound/VERIFY.json @@ -0,0 +1,52 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/coded-native-caller/CODE.json", + "research/coded-native-caller/NORMALIZERS.json", + "research/coded-native-caller/PHYSICAL.md", + "research/coded-native-caller/clifford_exact.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Authenticated actual code/normalizers, all 12544 right/left coset pair tests, 5824 supported blocks, exact eight-mode factor/Gram identities, one-sided grades, four semantic mutations and frozen receipt." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Same complete source and receipt checks with assertions disabled." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 30, + "checks": "Separately derived binary coset audit; no retained Clifford engine is imported; explicit source and receipt checks." + } + ] +} diff --git a/research/coded-active-query-bound/independent.py b/research/coded-active-query-bound/independent.py new file mode 100644 index 0000000000..a028b22e97 --- /dev/null +++ b/research/coded-active-query-bound/independent.py @@ -0,0 +1,81 @@ +"""Separately derived binary coset audit; Apache-2.0. +Prepared by the independent review agent for Dillon with OpenAI Codex assistance. +Packaging changes: portable root, authenticated inputs, explicit optimized-mode +checks and frozen receipt comparison. No Clifford engine is imported. +""" +import json, hashlib +from pathlib import Path +from fractions import Fraction +PACKAGE = Path(__file__).resolve().parent +root = PACKAGE.parent / 'coded-native-caller' +PINS = {'CODE.json': '8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0', 'NORMALIZERS.json': 'ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da'} +for name, digest in PINS.items(): + if hashlib.sha256((root / name).read_bytes()).hexdigest() != digest: + raise ValueError('Independent source hash: ' + name) +r = json.loads((root / 'NORMALIZERS.json').read_text()) +a = [[Fraction(x) for x in row] for row in json.loads((root / 'CODE.json').read_text())['A']] +p = r['ports'] +n = 9 +e = 1 + +def par(x): + return x.bit_count() & 1 + +def mv(g, x): + return sum((par(row & x) << i for i, row in enumerate(g))) + +def tr(g): + return [sum(((g[j] >> i & 1) << j for j in range(n))) for i in range(n)] + +def mul(g, h): + return [sum((par(g[i] & col) << j for j, col in enumerate(tr(h)))) for i in range(n)] + +def rank(rows): + piv = {} + for x in rows: + while x: + b = x.bit_length() - 1 + if b not in piv: + piv[b] = x + break + x ^= piv[b] + return len(piv) +if not (len(p) == 112 and len({x['q'] for x in p}) == 112): + raise ValueError("Independent condition failed: len(p) == 112 and len({x['q'] for x in p}) == 112") +if not all((len(row) == 112 for row in a)): + raise ValueError('Independent condition failed: all((len(row) == 112 for row in a))') +if not all((a[i][i] == 0 for i in range(112))): + raise ValueError('Independent condition failed: all((a[i][i] == 0 for i in range(112)))') +if not all((sum((a[i][j] != 0 for i in range(112))) == 52 for j in range(112))): + raise ValueError('Independent condition failed: all((sum((a[i][j] != 0 for i in range(112))) == 52 for j in range(112)))') +if not all((sum((a[i][j] != 0 for j in range(112))) == 52 for i in range(112))): + raise ValueError('Independent condition failed: all((sum((a[i][j] != 0 for j in range(112))) == 52 for i in range(112)))') +for x in p: + g = x['G_rows'] + if not mul(tr(g), g) == [1 << i for i in range(n)]: + raise ValueError('Independent condition failed: mul(tr(g), g) == [1 << i for i in range(n)]') + if not mv(g, e) == x['q']: + raise ValueError("Independent condition failed: mv(g, e) == x['q']") + if not x['K_word'][0] == ['P', g]: + raise ValueError("Independent condition failed: x['K_word'][0] == ['P', g]") + if not x['K_word'][1] == ['D', [0] * n, [2 * (x['Z_mask'] >> i & 1) for i in range(n)]]: + raise ValueError("Independent condition failed: x['K_word'][1] == ['D', [0] * n, [2 * (x['Z_mask'] >> i & 1) for i in range(n)]]") +census = {} +for j in range(112): + for k in range(112): + o = mul(tr(p[j]['G_rows']), p[k]['G_rows']) + u = mv(o, e) + v = mv(tr(o), e) + b = [(e if u >> i & 1 else 0) ^ (v if i == 0 else 0) for i in range(n)] + z = rank(b) + census[z] = census.get(z, 0) + 1 + if not z == (0 if j == k else 2): + raise ValueError((j, k, z)) +o = mul(tr(p[0]['G_rows']), p[0]['G_rows']) +if not mv(o, e) == e: + raise ValueError('Independent condition failed: mv(o, e) == e') +out = {'status': 'PASS_INDEPENDENT_RIGHT_COSET_CENSUS', 'ports': 112, 'pair_grade_census': census, 'supported_offdiagonal_blocks': sum((x != 0 for row in a for x in row)), 'source_sha256': {name: hashlib.sha256((root / name).read_bytes()).hexdigest() for name in ['NORMALIZERS.json', 'CODE.json']}, 'scope': 'Binary monomial/coset conditions only; no numerical group-algebra enumeration or circuit search.'} +expected = json.loads((PACKAGE / 'INDEPENDENT.json').read_text()) +if json.loads(json.dumps(out)) != expected: + raise ValueError('Independent finite receipt differs') +print('PASS_INDEPENDENT_RIGHT_COSET_CENSUS ports=112 distinct_grade2=12432 supported=5824') diff --git a/research/coded-active-query-bound/verify.py b/research/coded-active-query-bound/verify.py new file mode 100644 index 0000000000..ba49f91047 --- /dev/null +++ b/research/coded-active-query-bound/verify.py @@ -0,0 +1,236 @@ +"""Actual-source checks for the active local-query obstruction. + +Portable verifier; authenticates three retained source files and compares its +finite receipt. Standard library only. Apache-2.0; OpenAI Codex assistance. +""" +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from pathlib import Path +import argparse +import types +import json +import sys + +PACKAGE = Path(__file__).resolve().parent +DEFAULT_SOURCE = PACKAGE.parent / 'coded-native-caller' +EXPECTED = PACKAGE / 'RESULT.json' +PINS = { + 'CODE.json': '8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0', + 'NORMALIZERS.json': 'ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da', + 'clifford_exact.py': '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962', +} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def rank_binary(rows): + pivots = {} + for row in rows: + while row: + pivot = row.bit_length() - 1 + if pivot in pivots: + row ^= pivots[pivot] + else: + pivots[pivot] = row + break + return len(pivots) + + +def transpose(rows): + return [sum(((row >> j) & 1) << i for i, row in enumerate(rows)) + for j in range(len(rows))] + + +def multiply(left, right): + cols = transpose(right) + return [sum(((row & col).bit_count() & 1) << j + for j, col in enumerate(cols)) for row in left] + + +def central_image(rows): + return sum((row & 1) << i for i, row in enumerate(rows)) + + +def conjugated_b_rank(left, right): + # G_left is orthogonal, so inverse equals transpose. + relative = multiply(transpose(left), right) + central = central_image(relative) + block = [((central >> i) & 1) ^ (relative[0] if i == 0 else 0) + for i in range(len(relative))] + return rank_binary(block) + + +def validate_ports(ports): + need(len(ports) == 112, 'Exact owner count') + vectors = [port['q'] for port in ports] + need(len(set(vectors)) == 112, 'All 112 central vectors are distinct') + for port in ports: + rows = port['G_rows'] + need(len(rows) == 9, 'Native address dimension') + need(multiply(transpose(rows), rows) == [1 << i for i in range(9)], + 'Actual normalizer is binary orthogonal') + need(central_image(rows) == port['q'], 'Actual central vector binding') + + +def validate_code(code): + need(len(code) == 112 and all(len(row) == 112 for row in code), 'Code shape') + need(all(code[i][i] == 0 for i in range(112)), 'Zero source diagonal') + support = [sum(code[i][j] != 0 for i in range(112)) for j in range(112)] + need(support == [52] * 112, 'All columns have 52 nonzero off-diagonal entries') + need(all(code[i][j] == code[j][i] for i in range(112) for j in range(112)), + 'Actual symmetric source code') + return support + + +def validate_modes(columns, code): + need(len(columns) == 8 and all(len(column) == 112 for column in columns), + 'Eight source modes on 112 owners') + need(all(value in (-1, 0, 1) for column in columns for value in column), + 'Actual signed integral mode entries') + for a in range(8): + for b in range(8): + need(sum(x * y for x, y in zip(columns[a], columns[b])) == 56 * (a == b), + 'Exact mode Gram matrix M^T M=56I') + need(all(sum(column[i] != 0 for column in columns) == 4 for i in range(112)), + 'Every source owner has four mode contacts') + for i in range(112): + for j in range(112): + need(sum(column[i] * column[j] for column in columns) == 4 * ((i == j) - code[i][j]), + 'Actual code factorization A=I-MM^T/4') + + +def rejection(test, label): + try: + test() + except ValueError: + return label + raise ValueError('Mutation was not rejected: ' + label) + + +def run(source): + raw = {} + for name, digest in PINS.items(): + source_path = source / name + need(source_path.stat().st_size <= 1024 * 1024, 'Source exceeds fixed size bound: ' + name) + raw[name] = source_path.read_bytes() + need(sha256(raw[name]).hexdigest() == digest, 'Source hash: ' + name) + normalizer_receipt = json.loads(raw['NORMALIZERS.json']) + ports = normalizer_receipt['ports'] + mode_columns = normalizer_receipt['mode_columns'] + code = [[Fraction(x) for x in row] for row in json.loads(raw['CODE.json'])['A']] + validate_ports(ports) + support = validate_code(code) + validate_modes(mode_columns, code) + + # Execute the authenticated bytes directly: no stale .pyc can replace them. + ce = types.ModuleType('local_query_clifford') + ce.__file__ = str(source / 'clifford_exact.py') + sys.modules[ce.__name__] = ce + exec(compile(raw['clifford_exact.py'], ce.__file__, 'exec'), ce.__dict__) + q = ce.cgate(9, 1) + q_inverse = q.adjoint() + normalizers = [] + for port in ports: + phase = tuple(2 * ((port['Z_mask'] >> j) & 1) for j in range(9)) + normalizers.append(ce.perm(9, port['G_rows']).then(ce.diag(9, (0,) * 9, phase))) + inverses = [normalizer.adjoint() for normalizer in normalizers] + + pair_census = Counter() + supported_census = Counter() + one_sided_census = Counter() + for j in range(112): + for k in range(112): + formula = conjugated_b_rank(ports[j]['G_rows'], ports[k]['G_rows']) + # Literal composition is Q^-1 K_j^-1 K_k Q. Op.then is chronological. + exact = q.then(normalizers[k]).then(inverses[j]).then(q_inverse) + tableau = ce.rank([x for x, z, phase in exact.tab[9:]]) + expected = 0 if j == k else 2 + need(formula == tableau == expected, + 'Actual right-coset test for ordered pair %d,%d' % (j, k)) + left_conjugate = q_inverse.then(normalizers[k]).then(inverses[j]).then(q) + need(ce.rank([x for x, z, phase in left_conjugate.tab[9:]]) == expected, + 'Actual left-coset test for ordered pair %d,%d' % (j, k)) + one_sided = normalizers[k].then(inverses[j]).then(q) + one_grade = ce.rank([x for x, z, phase in one_sided.tab[9:]]) + need(one_grade == 1, 'One-sided transport is outside the monomial coset') + one_sided_census[one_grade] += 1 + pair_census[formula] += 1 + if code[j][k]: + supported_census[formula] += 1 + need(pair_census == {0: 112, 2: 12432}, 'Complete ordered-pair census') + need(supported_census == {2: 5824}, 'Actual supported source transports') + + duplicate = json.loads(json.dumps(ports)) + duplicate[1] = duplicate[0] + missing_column = [row[:] for row in code] + for row in missing_column: + row[0] = Fraction(0) + diagonal = [row[:] for row in code] + diagonal[0][0] = Fraction(1) + bad_modes = [column[:] for column in mode_columns] + bad_modes[0][0] += 1 + controls = [ + rejection(lambda: validate_ports(duplicate), 'duplicate physical direction'), + rejection(lambda: validate_code(missing_column), 'empty code column'), + rejection(lambda: validate_code(diagonal), 'nonzero source diagonal'), + rejection(lambda: validate_modes(bad_modes, code), 'changed source mode factor'), + ] + # A duplicated direction is genuinely an exception to the theorem's + # coset premise; do not merely reject it at the source-shape layer. + need(conjugated_b_rank(ports[0]['G_rows'], ports[0]['G_rows']) == 0, + 'Coincident-direction monomial positive control') + + return { + 'schema': 'actual-coded-active-local-query-obstruction/1', + 'status': 'PASS_ACTUAL_SOURCE_COSET_SEPARATION', + 'source_sha256': PINS, + 'owner_count': 112, + 'distinct_central_vectors': 112, + 'column_nonzero_support': dict(Counter(support)), + 'all_ordered_pair_fourier_grade': dict(sorted(pair_census.items())), + 'supported_pair_fourier_grade': dict(sorted(supported_census.items())), + 'independent_formula_and_exact_tableau_checks': 12544, + 'left_coset_tableau_checks': 12544, + 'one_sided_transport_fourier_grade': dict(sorted(one_sided_census.items())), + 'mode_factor_entries_checked': 12544, + 'mode_gram_entries_checked': 64, + 'mode_contacts_per_owner': 4, + 'mutation_controls_rejected': controls, + 'theorem_scope': 'Standalone J=Q^-1 C Q, J-I, QP, PQ, canonical Q U_mode and V_mode Q, their free retraction rebases, and homogeneous direct sums; fresh inputs; arbitrary chronological unary same-width paid calls with data-independent linear feedback.', + 'free_alphabet': 'Any fixed finite projective monomial group H; each map is the same one-column h tensor-lifted on all columns. Independent per-column controls are excluded. No finite ambient Clifford-group premise is required.', + 'minimum_paid_unary_same_width_field_calls': 112, + 'one_sided_QP_and_PQ_H1_optimum': 112, + 'canonical_mode_expansion_and_extraction_H1_optimum': 112, + 'conjugated_J_112_call_attainability_claimed': False, + 'complete_controller_lower_bound': False, + 'proof_kernel_checked': False, + } + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--source', type=Path, default=DEFAULT_SOURCE) + parser.add_argument('--write', action='store_true', help='Regenerate the package-local finite receipt.') + parser.add_argument('--json', action='store_true', help='Print the full finite receipt.') + args = parser.parse_args() + result = run(args.source) + if args.write: + EXPECTED.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + else: + need(EXPECTED.stat().st_size <= 65536, 'Receipt size bound') + need(json.loads(EXPECTED.read_text()) == json.loads(json.dumps(result)), + 'Frozen finite receipt differs') + if args.json: + print(json.dumps(result, indent=2, sort_keys=True)) + else: + print('PASS_CODED_ACTIVE_QUERY_BOUND owners=112 pair_checks=12544 ' + 'distinct_grade2=12432 supported=5824 local_unary_floor=112 ' + 'one_sided_optimum=112 mutation_controls=4 modes=8') + + +if __name__ == '__main__': + main()