From 7e1ddb459728f4f2998e0b75c6a6a6aee7687481 Mon Sep 17 00:00:00 2001 From: Dugongue <49054532+Dugongue@users.noreply.github.com> Date: Sun, 25 Oct 2026 19:36:48 +0000 Subject: [PATCH] Extend fine-grid Gaussian inversion and batch coded boundary queries --- .../fine-gap-gaussian-boundaries/README.md | 69 ++++++ .../fine-gap-gaussian-boundaries/assembly.md | 154 +++++++++++++ .../fine-gap-gaussian-boundaries/boundary.md | 131 +++++++++++ .../fine-gap-gaussian-boundaries/consumer.md | 183 +++++++++++++++ .../fine-gap-gaussian-boundaries/inverse.md | 213 ++++++++++++++++++ .../precedents/gaussian-convolution.md | 167 ++++++++++++++ 6 files changed, 917 insertions(+) create mode 100644 research/fine-gap-gaussian-boundaries/README.md create mode 100644 research/fine-gap-gaussian-boundaries/assembly.md create mode 100644 research/fine-gap-gaussian-boundaries/boundary.md create mode 100644 research/fine-gap-gaussian-boundaries/consumer.md create mode 100644 research/fine-gap-gaussian-boundaries/inverse.md create mode 100644 research/fine-gap-gaussian-boundaries/precedents/gaussian-convolution.md diff --git a/research/fine-gap-gaussian-boundaries/README.md b/research/fine-gap-gaussian-boundaries/README.md new file mode 100644 index 0000000000..ae0bdaf03a --- /dev/null +++ b/research/fine-gap-gaussian-boundaries/README.md @@ -0,0 +1,69 @@ +# Fine-grid inversion and rank-batched coded boundaries + +Dugongue, with substantial OpenAI Codex assistance from four workers. This is a collection of informal mathematical proofs, constructions and precisely stated research directions, using only local DAG and linked proof-tree sources. No numerical experiment, solver, web search or Lean check was used. + +**No higher complete multiplication κ is proved in this release.** The previous inverse-adapter improvement cannot by itself raise a provider-limited full bound. The positive contributions below widen the actual inverse algorithm and construct new ways to implement coded boundaries and consumers. An uncompleted stronger provider is not assumed as an input to a claimed new best exponent. + +## 1. A completed fine-grid inverse without the huge gauge + +Let ρ=T/S, θ=ρ−1, q_i=floor(ρi+1/2), β_i=ρi−q_i, and + + G_ij=exp(−a[(ρj−q_i)^2−β_j^2]), + N_ij=sum_(k in Z) G_(i,j+kS). + +For θ=Θ(p^(−2)), a=Θ(log p) with a sufficiently large fixed lower coefficient, log(S+1)=O(p), target precision O(p) and input magnitude exp(O(p)), the exact periodic N inverse has a constructive O(S log p) application algorithm, after charged polynomial(S,p) input-independent preparation, using O(p)-bit words in the stated extended Word RAM. + +The key exact identity is + + (1+qz) H(z)=H(q²z), + H(z)=sum_(r≥0) (−q)^r z^r / product_(j=1)^r(1−q^(2j)). + +After the actual run similarity, the first factor is a stable bidiagonal recurrence. The remaining kernel decays rapidly, so it is evaluated in short locally recentered convolution blocks. This avoids ever applying the huge full-run diagonal exp(aβ_i²/θ). A physical boundary Schur complement, with its diagonal-dominance margin proved, completes the periodic inverse. + +`inverse.md` proves the local identities, finite tails, recurrence stability, boundary solve, precision and actual inverse theorem. This extends the previous construction beyond its d≤O(p^(1/4)) precision restriction. It uses ordinary complete line solves, and does not assume that a low-rank tensor description is already a cheap contraction. + +The native model explicitly includes bounded-word multiplication/division, fixed-point rescaling shifts and indexed memory. Parameters have effective certified descriptions. The mathematical statements do not claim an instruction-level implementation in a smaller ISA. + +## 2. A completed rank-based boundary construction + +Let M be an invertible scalar matrix between independent role fields. Let a,b be binary input/output gauge labels for a central Gaussian Q. The actual boundary is G_b M G_a^(-1). Its only nonordinary blocks are + + M_01 Q^(-1) and M_10 Q. + +Rank-factor those two scalar blocks, compute their linear combinations on one immutable input snapshot, query each rank component once, and distribute the results. The complete boundary therefore has the sufficient Gaussian tariff + + rank(M_01)+rank(M_10). + +Owned buffers, all-input correctness, coefficient generation and cleanup are explicit. The reciprocal-dual boundary has the same total tariff, proved by an inverse-block nullity identity. When a completed provider's literal boundary uses more queries than this, replacing it preserves the exact independent endpoint and strictly reduces the paid rank-one count. The paper does not assert that such a strict reduction has already been found in the selected provider. + +`boundary.md` gives the construction and its eight proofs, including a dense rank-one sharing example and a safe multiaxis extension. This is whole-matrix sharing, so it never reuses a query after its source snapshot has changed. + +## 3. New positive coded-consumer interfaces + +`consumer.md` proves how a paid Gaussian correction at an ADD can be redirected onto the target without increasing its Gaussian rank, including the correct restricted multiaxis version. It constructs exact B/C gauge incidences and a completely priced alternating schedule. That simple schedule does not fund a higher κ. + +A separate dense consumer computes a common-frame orthogonal-code invariant in an XOR-convolution algebra, with reciprocal Gaussian filters cancelled inside the product. Its actual output is one sum of products; it is not credited as many independent Gaussian transforms. The note supplies the ordinary Walsh algorithm and states exactly why a changing code itinerary or a cyclic-convolution caller needs an additional proved interface. + +## 4. Exact implications for a full κ + +`assembly.md` reconstructs the complete native cost rows and proves their sufficient transfers. For an actually admitted provider saving q_C, the inherited fused route already gives every strict κ 0 be a genuinely admitted uniform native Gaussian provider saving: for every growing selected width e, the actual independent Gaussian job has cost O(V e^(1−q) polylog p) for every fixed q < q_C, with the source's exact endpoint, owned-state, all-input and semantic-depth contracts. In the source-bound native route this premise is furnished by the specified finite productive word and its strict majorant, not an optimal-circuit oracle. + +Retain the complete fine-padding, gauge-free circuit, selected-coordinate, batched boundary, polynomial-record and recovery proofs listed above. Put c = 3/32, the explicit conservative native boundary saving inherited from the stated Strassen construction. For parameters ε, β, ξ the paid native savings are + + main εq, + fused Gaussian 1−ε+qβ, + group scans 1−ε+β, + boundary c+ξ−ε, + sparse visits 1/2+ξ−ε, + record products ε, + fixed additional passes 1. + +The retained core-face row has a much larger fixed margin in the parameter family below. The source also requires + + 0 < β < ε < 1, 1/2 < ξ < ε, + ε+r < 1, β+2ξ−2+r < 1, + β+1−ε < 1, β+2(1−ε) < 1, + +where r is a freely chosen positive spare exponent for logarithmic Gaussian parameters. These are hypotheses of the written source constructions, not merely preferences of a numerical optimizer. + +**Theorem 2 (source-bound provider-to-multiplier transfer).** For every + + 0 < κ < min(q_C, 3/32), + +the retained fused native construction gives complete packed multiplication cost O(n/(log n)^κ), conditional only on the explicitly retained algebraic and analytic source proofs. + +**Proof.** Choose q with κ < q < min(q_C,c). For a positive δ to be chosen sufficiently small, set + + ε = 1−δ, β = 1−3δ, + ξ = ε(1+q)−c+ℓ, + +where ℓ is a small fixed positive number. At δ = ℓ = 0 the cap ξ equals 1+q−c, which lies strictly between 1/2 and 1 because 0 < q < c < 1/2. Choose ℓ and then δ small enough to keep 1/2 < ξ < ε and εq > κ. Also choose 0 < r < δ sufficiently small. + +The fused Gaussian saving is q+δ(1−3q), while the main saving is q−δq. Their difference is δ(1−2q) > 0. The boundary saving is exactly εq+ℓ. The sparse-visit saving is εq+ℓ+1/2−c. The group-scan saving is 1−2δ, and the record saving is 1−δ. These all strictly exceed κ after reducing δ if needed; fixed passes have saving 1. + +The thin-table constraint is β+1−ε = 1−2δ < 1, and membership is β+2(1−ε) = 1−δ < 1. The remaining chirp exponent is + + β+2ξ−2+r = 1+2q−2c−δ(5+2q)+2ℓ+r. + +Its strict margin at ℓ = r = δ = 0 is 2(c−q) > 0. Select ℓ and r small enough that it remains below 1. All other strict source inequalities persist in a sufficiently small positive parameter neighborhood. The core-face term has exponent ε+β+48−128+2, which stays negative. The complete source algorithms therefore meet every row with a strict κ margin. Apply Theorem 1. ∎ + +This general parameter argument is the inherited fine-padding lifting principle, made explicit in native notation. It is not a new paid provider. In particular, choosing ε closer to 1 only approaches q_C; it is not a new mechanism for surpassing that supplier saving. + +## 3. The strengthened line-inverse route and a different full transfer + +The companion inverse note supplies a direct fine-gap inverse algorithm. Together with the inherited direct native forward Gaussian map, its intended completed per-line contract is O(S log p) work, exp(o(p)) shared preparation and O(p)-bit precision for the actual source matrices. Unlike the fused route, this uses ordinary line applications and does not require an assumed fast tensor fusion of every Gaussian adapter. + +**Theorem 3 (unfused complete assembly).** Suppose the actual forward and inverse maps on each source axis have this completed per-line contract, and retain the exact cyclic embedding, pointwise/record multiplication, original-label twiddles, arbitrary-input native Gaussian provider and integer recovery proofs. For d = Θ(p^ε), 0 < ε < 1, the complete native cost is + + O(V[p^(1−εq) + p^ε + p^(1−ε)] polylog p) + exp(o(p)). + +Consequently every fixed + + κ < q/(1+q) + +is obtained by choosing ε = 1/(1+q), provided those line contracts apply uniformly at that ε. + +**Proof.** The main common-level transform has Θ(p/d) levels. Its actual selected-width-d provider call costs O(V d^(1−q) polylog p), so their sum is O(V p d^(−q) polylog p) = O(V p^(1−εq) polylog p). There are V/S_i independent fibers on axis i. The completed O(S_i log p) line routine therefore costs O(V log p) per axis; summing d axes gives O(V p^ε polylog p). The retained global-precision record products cost O(V p/d polylog p), and fixed twiddle/address/recovery passes fit the displayed rows. Shared preparations sum to exp(o(p)) because the source axes have log length Θ(p/d) and the number of axes is polynomial in p. + +The three native savings are εq, 1−ε, and ε. If q < 1, setting ε = 1/(1+q) makes the first two equal q/(1+q), while ε is larger. Any strict smaller κ absorbs every fixed logarithmic factor by Theorem 1. The exactness and whole-tensor precision premises remain actual line/outer theorems, as required in the statement. ∎ + +This is a positive complete transfer for the new line algorithm. With the same q it is weaker than the already available fused supremum q; its significance is a simpler sufficient Gaussian-adapter contract and possible applicability to providers whose full fused interface has not yet been established. It does not silently grant that broader provider interface. + +For the earlier production-scale Beatty-run specialization a = Θ(d sqrt p), the proved local guard a/θ = Θ(d² sqrt p) restricts d to O(p^(1/4)) when θ = Θ(1/d). Its direct use in Theorem 3 gives a main saving only q/4 at d = Θ(p^(1/4)). The improved inverse bound is real, but this substitution alone is not a larger complete κ. The stronger fine-gap construction is needed even to apply the unfused lifting near ε = 1/(1+q). + +## 4. A positive normal form for genuinely independent changed Gaussian targets + +The following theorem isolates what endpoint charts can be normalized cheaply. It does not assume that a coupled local word has already been diagonalized into independent targets. + +Let X and Z be the coordinate and momentum subspaces of the standard binary symplectic space of dimension 2m. Let P be the subgroup stabilizing the computational Z Lagrangian. Its quantum lifts are computational-basis monomial operators: an invertible affine permutation of labels followed by a quadratic root-of-unity phase. Keep absolute phase as part of the specified lift. + +**Theorem 4 (monomial–Gaussian–monomial normal form).** Let U be an explicitly specified Clifford operator with symplectic matrix S, and let r be the rank of the X-from-Z block of S. There are explicitly constructible computational monomial operators M_L,M_R and a scalar phase ζ such that + + U = ζ M_L (H_r tensor I) M_R, + +where H_r is the normalized Hadamard transform on r selected address bits. The number r is invariant under left and right computational monomial multiplication. + +**Proof.** The dimension of Z intersect S(Z) is m−r because r is the rank of the projection of S(Z) to X. The group P acts transitively on Lagrangians L having a given intersection dimension with Z. Here is a constructive proof of that fact. First choose a basis of I = L intersect Z and extend it to a basis of Z. An invertible coordinate change in P sends I to the last m−r coordinate momenta. Pass to the symplectic quotient I-perp/I. There L/I and Z/I are transverse r-dimensional Lagrangians. Transversality writes L/I as a graph over the coordinate-position subspace. The Lagrangian identity says its graph matrix is symmetric. A symmetric shear belonging to P removes that graph matrix, sending L/I to the standard position subspace. Lift this shear and retain I pointwise. Thus a constructed P_L sends S(Z) to the Lagrangian obtained by swapping the first r position/momentum pairs of Z. + +Let w_r perform those r swaps. Then w_r^(-1)P_L S stabilizes Z, so it belongs to P. Rearranging expresses S as P_L^(-1)w_r P_R for an explicitly constructed P_R in P. Lift P_L and P_R to computational monomial Clifford operators and w_r to H_r. Two lifts of the same binary symplectic action differ by the explicitly retained Pauli/phase data; those data are absorbed into the monomial factors and ζ. Hence the displayed exact operator equality holds with its absolute phase. Every operation used is a finite basis extension, symmetric shear, or phase normalization, not a tensor-isomorphism decision oracle. + +Finally, left/right multiplication by matrices in P preserves dim(Z intersect S(Z)), because P fixes Z. Therefore r is invariant. ∎ + +**Corollary 5 (independent heterogeneous Gaussian outputs).** If a complete word has an exact all-input endpoint + + direct_sum_i U_i + +on arbitrary mutually independent fields, and each U_i is supplied with the normal form in Theorem 4, then computational monomial wrappers turn it into independent canonical Gaussian targets of ranks r_i. Different output charts need not be forced into one common chart. Their actual ranks and normalizers must be used by the subsequent finite productive compiler. + +**Proof.** Apply the specified right normalizer separately to each input field, execute the complete word, and apply the specified left normalizer and phase correction separately to each output field. The direct-sum endpoint prevents any cross-field term. Theorem 4 proves the resulting target on every independent input. The heterogeneous ranks are the actual r_i; no rank-eight target can be credited merely because another job occupies a rank-eight ambient space. ∎ + +**Native scope.** For a fixed finite template lifted over f digit columns, its finite binary basis maps and quadratic phases have bounded descriptions. With selected width o(p), their complete address/phase tables are generated in exp(o(p)) preparation. Direct indexed visits and the stated word masks/shifts implement each monomial field pass with polylog(p) native overhead. The factors are unitary, so they add no operator-norm amplification. The total finite wrapper allowance is included in the provider's nonrecursive work. An arbitrary width-dependent dense basis is not declared free by this fixed-template statement. + +## 5. Why the available quotient profile is not yet such an input + +The cached PR4629 description reports a large complex-only number. Its actual repaired local descendants supply two typed alternatives, with 56 ordinary and 56 exceptional main pairs. Writing D for a seven-axis Gaussian and Q for a disjoint central-axis Gaussian, + + A = diag(D,D) S_y(Q^(-1)), + B = diag(1,Q) A, + C = A diag(Q,1). + +The source `HETEROGENEOUS-CONTROLLER.md` constructs physical port permutations and the exact backward-convention wrappers. `FREE-ENDPOINT-GAUGES.md` proves that a complete diagonal controller may have honest changed initial and final central gauges. Both are positive sufficient local/interface constructions. Neither states that the particular changed B/C chronological word already has a profitable complete diagonal endpoint. + +**Theorem 6 (whole-word gauge telescoping with exact independent targets).** Suppose a complete chronological word M_s ... M_1 has an exactly proved diagonal endpoint T = direct_sum_i T_i, including its scalar boundary programs. For boundary gauges G_0,...,G_s, physically implement each event as M'_j = G_j M_j G_(j−1)^(-1). Then the raw-input endpoint is + + M'_s ... M'_1 = G_s T G_0^(-1). + +If G_0 and G_s are fieldwise diagonal gauges, the output remains a direct sum of honest changed independent targets. Every nonmonomial event correction must be counted among the paid calls. + +**Proof.** Multiply the displayed event operators in chronological order. Every adjacent G_(j−1)^(-1)G_(j−1) cancels. The surviving two endpoint gauges surround the originally proved T. Because both are block diagonal by field, the resulting map has no cross-field dependence. It is the actual operator on raw inputs; no input gauge is physically applied unless it occurs in the emitted word. This proves the identity but does not alter the cost of implementing any M'_j. ∎ + +This is the scope in which free initial/final gauges are legitimate. Theorem 4 cannot be applied to a diagonal block that has not been shown to exist. The full local A primitive is a Gaussian diagonal times a coefficient-field shear, which is generally nonunitary; it is not itself a single address-space Clifford merely because its Gaussian entries are Clifford operators. Applying a symplectic double-coset theorem to that whole role-mixing matrix would therefore use the wrong category. In particular, replacing A by B or C inside a controller is not justified by the observation that the pricing code does not read the local frames: the source's symbolic factorization explicitly assumes the A operator identity. Its correctness is an operator statement, not a syntactic condition on which JSON fields the code reads. + +The actual external bridge operations in the inspected controller are scalar ADDs. Odd central Gaussian shears occur inside the local A primitive and are already included in its provider profile. Turning an external scalar ADD into a crossed-gauge operation can introduce a paid Gaussian bridge; it is not automatically a query saving. The complete left/right scalar boundary programs and the resulting target central parities remain part of any constructive new controller proof. + +## 6. Precise consequence for the next κ improvement + +Theorems 1–3 give complete positive native lifting constructions on their displayed actual inputs. Theorems 4–6 give constructive chart and gauge interfaces for a new heterogeneous provider. Thus a genuine new complete κ can follow from either of two concrete positive developments: + +1. An actually admitted stronger independent Gaussian provider, with its complete paid moment, finite uniform compiler, owned/phase/precision contracts and heterogeneous normalizers. Theorem 2 transfers its saving cofinally up to the explicit boundary limit; Theorem 3 supplies a simpler alternative once the fine-gap line routines apply. +2. A new complete main-transform service whose actual moment is better than the inherited selected-width provider recurrence. Its algorithms and independent outputs must be supplied, rather than inferred from a cheaper adapter. + +No such stronger independent provider is proved in this note. In particular, the complex-only headline from PR4629 is not substituted for q_C. The positive results here preserve and precisely widen usable interfaces, but do not turn an unproved B/C controller into a new numerical κ. + diff --git a/research/fine-gap-gaussian-boundaries/boundary.md b/research/fine-gap-gaussian-boundaries/boundary.md new file mode 100644 index 0000000000..478a8980fc --- /dev/null +++ b/research/fine-gap-gaussian-boundaries/boundary.md @@ -0,0 +1,131 @@ +# Rank-batched Gaussian boundaries with exact dual tariffs + +Dugongue, with substantial OpenAI Codex assistance. Informal mathematics only. The purpose is to apply a whole ordinary boundary matrix at its actual Gaussian correction rank, instead of paying independently for every crossed ADD in one scalar program. No numerical search, executable proof check, web search or Lean verification is used. + +## Source context and scope + +The local `HETEROGENEOUS-CONTROLLER.md` and `FREE-ENDPOINT-GAUGES.md` distinguish an actually diagonalized supplier from a coupled local B/C port. They give the exact physical boundary G_out M G_in^(-1), where M is an ordinary scalar program and G consists of central Gaussian row gauges. The present note constructs that complete boundary directly. It applies to those scalar boundaries, not to an arbitrary Clifford word whose coefficients are themselves address operators. + +The shared library's fixed-circuit and support principles motivate preserving one actual all-input map. `Mathproof/SymplecticTITOCIBalancedCoevaluation20260901.lean` supplies the primal/reciprocal-dual viewpoint, and `Mathproof/LinearAlgebra/SchurBlockElimination.lean` records exact elimination rather than an assumed inverse. The rank factorizations and nullity identity proved below are classical finite-dimensional linear algebra. No historical or exhaustive project novelty is claimed. + +Credit the retained native controller, quotient and restriction work of Cinna Davis, DaysSky, Cao Yifan, Dugongue, Nick Petalas, Ryanson Jonathan, zxv, Jacob Alan Sussman and their compiler predecessors. The new contribution here is the explicit boundary construction, owned storage, dual-price equality and profile substitution interface. + +## Definitions + +Let K be a field and V a finite-dimensional K-vector space. A role field is an arbitrary vector of V. Fix an invertible Gaussian operator Q on V. Ordinary operations in this note are K-linear combinations between role fields and explicitly supplied ordinary address monomials. Scalar role matrices commute with Q. A Q or Q^(-1) application to one arbitrary role field is one charged rank-one Gaussian job. In the actual lifted setting Q is the central-axis Gaussian over all its digit columns; its inverse differs by its known even-power monomial and has the same Gaussian rank. + +There are n independent input fields. Let M be an invertible n by n scalar matrix over K. Give each input role j a gauge bit a_j and each output role i a gauge bit b_i. Put + + G_a = diag_j(Q^(a_j)), G_b = diag_i(Q^(b_i)), + F = G_b M G_a^(-1). + +Define input groups A_0,A_1 and output groups B_0,B_1 by their gauge bits. Write M_uv for the block with rows B_u and columns A_v. Empty blocks have rank zero. Let m_0=|A_0| and n_0=|B_0|. All ranks below are over K. + +## B1. Exact whole-boundary decomposition + +**Theorem.** The physical boundary F has the block form + + [ M_00 M_01 Q^(-1) ] + [ M_10 Q M_11 ]. + +It can be applied using exactly + + r = rank(M_01) + rank(M_10) + +charged Gaussian jobs in the construction below, plus ordinary linear work. This is a sufficient tariff, not a lower-bound assertion against all possible uses of the concrete Q. + +**Proof.** A block with output gauge u and input gauge v has coefficient Q^u M_uv Q^(-v). Scalars commute with Q, giving the displayed form. + +Choose rank factorizations M_01=U_01 V_01 and M_10=U_10 V_10, where the inner dimensions equal their respective ranks. Such factorizations exist constructively: choose independent columns as U, express every column in that basis, and place the coordinates into V. Form V_01 x_1 in r_01 temporary fields and apply Q^(-1) separately to each. Ordinary multiplication by U_01 then produces M_01 Q^(-1)x_1. Independently form V_10 x_0, apply Q separately to its r_10 fields, and spread by U_10. Add the ordinary direct terms M_00 x_0 and M_11 x_1. This gives every physical output exactly, on arbitrary mutually independent inputs. No Q is declared free and no temporary linear combination is mistaken for an independent productive target. ∎ + +For a fixed finite boundary template this uses O(n²) ordinary scalar operations per address, plus its explicitly counted Gaussian jobs. A low-rank boundary may have a substantially smaller Gaussian tariff than a long sequence of individually priced ADDs. + +## B2. A complete owned-buffer realization + +**Theorem.** B1 can be realized with O(n) owned field buffers, all zero on exit, without overwriting a source before its last read. It preserves every unrelated main or helper field. The net map on the n main fields is exactly the invertible boundary F. + +**Proof.** Clear n owned output buffers and at most r temporary buffers. Read the immutable main input bank to accumulate both direct output blocks and the rank-factor combinations. Once a combination is complete, apply its charged Q or Q^(-1) job and accumulate its U multiple into the output bank. A temporary is cleared after its last use and may be reused. No further input source is read after the two output blocks are complete. Swap the main and owned output banks, then clear the old input bank, which now occupies the owned bank. The operation is the same all-input invertible main map F; no independent input is lost from that main endpoint. Every other field was untouched. ∎ + +The model here permits clearing owned buffers, as in the retained native recoders. This theorem does not claim a reversible computation with no erasure, nor does it borrow an uninitialized helper as though it were a zero input. Gaussian-child workspace and cleanup retain the child service's own charged contract. + +## B3. A strict sharing example for a dense boundary + +**Theorem.** Let u and v be nonzero scalar vectors and take + + M = [ I u v^T ] + [ 0 I ], + +with the first output/input group carrying gauge 0 and the second group gauge 1. The complete physical boundary needs one charged Q^(-1) job in B1. If all entries of u and v are nonzero, the literal coordinate-ADD expansion of the upper-right block contains |u||v| crossed terms; implementing each as a separate fresh query uses that many jobs. + +**Proof.** The upper-right block has rank one. Its action is u times Q^(-1)(v^T x_1). Compute the scalar combination v^T x_1 once in one owned temporary, query Q^(-1) once, and add its u multiples to the first group. The literal expansion has one nonzero coefficient u_i v_j for each pair (i,j); its stated separate-query implementation therefore makes one query per pair. The theorem compares these two explicit constructions, not every possible caching strategy. ∎ + +The sharing is across one fixed input snapshot. There is no reuse of a stale query after one of its source fields has changed. This is why the matrix-level construction is safe even when a chronological ADD program would change its intermediate inputs repeatedly. + +## B4. An elementary inverse-block nullity identity + +**Theorem.** Let M:U→W be an isomorphism of n-dimensional spaces with coordinate bases. For any row-index subset I and column-index subset J of M^(-1), + + rank((M^(-1))_(J,I)) + = rank(M_(I^c,J^c)) + |I| + |J| − n. + +Here I refers to coordinates of W and J to coordinates of U; the subscripts keep those two spaces distinct. + +**Proof.** Restrict M^(-1) to the coordinate space W_I and then project to U_J. Its kernel consists exactly of y in W_I with M^(-1)y in U_(J^c). Thus its kernel is W_I intersect M(U_(J^c)). The map obtained by applying M to U_(J^c) and projecting to W_(I^c) has rank rank(M_(I^c,J^c)) and domain dimension n−|J|. Its kernel has dimension n−|J|−rank(M_(I^c,J^c)); this equals the intersection dimension just identified. Subtract that dimension from |I| to obtain the claimed rank. ∎ + +The formula also covers empty groups. Its right side is nonnegative because it equals an actual rank. + +## B5. Forward and reciprocal-dual boundaries have equal tariffs + +**Theorem.** Use the reciprocal-dual Gaussian Q_d=Q^(-T) for the inverse-transpose boundary. Its two crossed-block ranks satisfy + + rank((M^(-T))_01) = rank(M_10)+n_0−m_0, + rank((M^(-T))_10) = rank(M_01)+m_0−n_0. + +Consequently the B1 tariff for the forward boundary and for its actual inverse transpose is identical: + + rank((M^(-T))_01)+rank((M^(-T))_10) + = rank(M_01)+rank(M_10). + +**Proof.** Transposing the inverse changes its block 01 into the inverse block with rows A_1 and columns B_0. Apply B4 with I=B_0 and J=A_1; their complementary M block is M_10, and |B_0|+|A_1|−n=n_0−m_0. The other equality follows with I=B_1,J=A_0. Sum them. + +For the actual operator, direct inversion and transposition gives + + F^(-T) = G_b^(-T) M^(-T) G_a^T. + +This has the same binary in/out gauge partitions with Q replaced by Q_d, since G_b^(-T)=diag(Q_d^(b_i)) and G_a^T=diag(Q_d^(-a_j)). Apply B1. The actual symmetric central Gaussian has Q_d=Q^(-1), whose charged rank is the same; all even-power monomials remain explicit. ∎ + +This is a useful compatibility statement for mirrored suppliers: the cost improvement is not obtained by silently ignoring the backward orientation. + +## B6. Coefficients, guards and preparation are finite mathematical data + +**Theorem.** Suppose M has rational entries, and a common scaling makes their integer numerators have magnitude at most 2^H, with the scaling denominator explicitly supplied. The rank factorizations in B1 can be chosen with coefficient numerator and denominator bit lengths O(n(H+log(n+1))) plus the supplied common denominator length. They can therefore be prepared by exact finite elimination, independently of data. + +**Proof.** Choose independent columns and an invertible square minor of their full rank r. The coordinates of any other column in that basis are given by solving the r by r minor system. Cramer's rule expresses each coordinate as a ratio of r by r determinants. The determinant expansion has at most r! terms and each product has magnitude at most 2^(rH). Thus the determinant numerators have at most rH+log2(r!)+O(1) bits, bounded by O(r(H+log(r+1))). Common denominator factors cancel or contribute their explicitly supplied lengths. The independent columns give U and these coordinates give V. This is a finite construction, not an oracle for a smallest circuit. ∎ + +For a fixed finite provider template, n and these coefficient sizes are fixed before the external input length grows. Their ordinary work is an actual finite multiple of the field volume, and their coefficient/partial-sum bounds give a fixed extra guard. If the template itself grows, these costs and guards must be charged as functions of n and H; the theorem does not turn growing matrices into constant-time instructions. + +## B7. Safe substitution into an already completed provider + +**Theorem.** Consider a completed all-input independent-output supplier, with both orientations supplied, whose chronological word includes an ordinary scalar boundary M implemented under the stated in/out gauges. Replace that boundary by B1–B2 and perform the corresponding B5 replacement in the inverse transpose. Then the exact endpoints, independent main/helper inputs and Gaussian target ranks are unchanged. If the replaced implementation used c charged rank-one jobs and B1 uses rr, nor that a changed B/C local word has already been completed. Its additional finite ordinary work and finite guard belong to the subsequent uniform-compiler cost bound. An exact positive moment is one input to that compiler, not by itself a proof of an improved multiplication exponent. + +## B8. Multi-axis boundary blocks and complete rank tariffs + +**Theorem.** Let Q_1,...,Q_s be commuting invertible Gaussians on disjoint address axes. Give each input and output a binary gauge vector. Partition input roles by a in {0,1}^s and output roles by b. For each scalar block M_ba choose a rank factorization of inner dimension r_ba. Then the whole boundary can be applied with, for each a≠b, + + r_ba jobs of the explicit product Q^(b−a), + +plus ordinary work. Each such product has charged Gaussian rank |supp(b−a)|, with inverse orientations normalized by their actual even-power monomials. + +**Proof.** The physical block is Q^b M_ba Q^(−a)=M_ba Q^(b−a). Apply the rank-factor construction of B1 to that whole block. The commuting product is a tensor Gaussian on precisely the axes whose gauge entries differ; inverse factors differ from forward ones by the supplied even-power monomials. Treat the a=b blocks ordinarily. Distribute and sum the explicitly specified output blocks. ∎ + +Here the safe tariff is the sum over displayed blocks. No equality of forward/backward weighted tariffs is inferred for arbitrary multi-axis rank weights; B5 proved that equality only for the single-axis count. Nor is a whole rank-r product replaced by r separate rank-one jobs when its actual service permits one rank-r call. + +## Mathematical contribution and remaining κ task + +These results construct a cheaper boundary whenever its crossed scalar blocks have low rank relative to the literal query expansion. They include arbitrary independent fields, cleanup, both orientations and actual coefficient data. They are applicable to a complete already proved caller and do not use an unproved Gaussian gadget. + +To obtain a higher κ one must instantiate B7 in a specific complete profitable provider, or complete a new provider whose actual boundaries satisfy this tariff and whose whole paid moment is stronger. The present note supplies neither that missing particular instance nor a numerical κ. The companion inverse and consumer notes develop independent positive mechanisms that can be joined only through their exact stated interfaces. diff --git a/research/fine-gap-gaussian-boundaries/consumer.md b/research/fine-gap-gaussian-boundaries/consumer.md new file mode 100644 index 0000000000..4449c1bc28 --- /dev/null +++ b/research/fine-gap-gaussian-boundaries/consumer.md @@ -0,0 +1,183 @@ +# Constructive gauge transport and a dense paired consumer + +Dugongue, with substantial OpenAI Codex assistance. Informal mathematics only. No numerical experiments, executable mathematical checks, Lean runs or external searches were used for this note. + +The main construction is an event-by-event Gaussian gauge compiler that can change a row's gauge at an ADD without paying twice. Its multivariate form groups a correction on several independent Gaussian axes into one whole Gaussian request. This supplies explicit additional choices for the actual complementary B/C providers. A second, independent construction consumes a common-frame coded pair through a complete dense XOR-convolution algorithm. Neither construction is asserted to furnish an unproved profitable whole supplier or a larger multiplication κ. + +## Predecessors and exact scope + +The source contracts are the actual complementary quotient and restriction providers in `research/native-dual-suppliers/HETEROGENEOUS-CONTROLLER.md`, its full endpoint identity in `FREE-ENDPOINT-GAUGES.md`, and the Laurent controller construction in `research/kappa-rebuild/bit/complex_controller_factor.py`. Only the mathematical definitions in that source were read; nothing was executed. The local main interfaces have 112 independent pairs, with 56 ordinary A ports and 56 exceptional B or C ports; helper inputs remain independent at every call. The complete native profiles and notices belong to their retained source authors. + +The linked `Mathproof/SymplecticTITOCIBalancedCoevaluation20260901.lean` supplies the reciprocal primal/dual cancellation precedent. The previous `algebra.md` supplies the exact two-state carry tensor and common-gauge algebra. The actual whole-K normalizers have the documented form `L_i = Z_z P_Gi`, with an invertible binary linear map and a real linear character. This is stronger than merely being an arbitrary signed permutation and is the hypothesis needed by the XOR-algebra construction below. The retained central-Q decoder proves a fully paid repair of the actual opposite endpoint; its positive Gaussian cost is not erased by this note. + +Credit Cao Yifan, DaysSky, Cinna Davis, Nick Petalas, Ryanson Jonathan, Rohan Arun, Dugongue, zxv, Jacob Alan Sussman, the retained provider/controller authors and the Gaussian/Clifford/source08 lineage. The whole-K discussion also retains THU New Media Research Center and Ali Romman's geometry and the native-interface contributors named in the preceding deliverable. The constructions here do not establish world novelty or an exhaustive historical comparison. + +## 1. A precise row-gauge ADD construction + +Let Q be an explicitly available invertible Gaussian on a selected coordinate block, with every even power of Q an explicitly available ordinary monomial. A field is an arbitrary vector; a row gauge a means that its physical value is Q^a times its logical value. Integer exponents, rather than only parity bits, are retained in all operator identities. Their parity is used only to count Gaussian calls. + +Consider the logical ADD + + x_t ← x_t + ε Q^k x_s, + +where s and t are distinct fields and ε is an explicitly available scalar. Suppose the source and target enter in gauges b and a. Keep the source in gauge b, and choose the target's outgoing gauge c. The physical update must be + + z_t ← Q^(c−a) z_t + ε Q^(k+c−b) z_s. (1) + +**Theorem C1 (one-axis ADD with a changing target gauge).** The update (1) has an explicit implementation with at most one Q call, fixed ordinary monomial/scalar operations and at most one owned temporary field. It uses no Q call exactly when both displayed exponents are even in this construction. The source is preserved, and the temporary is cleared. + +**Proof.** Put α = c−a and β = k+c−b. If both are even, both factors are ordinary monomials: apply the first to the target, copy the source to owned storage if a nontrivial source monomial is needed, add its scaled image, and clear the temporary. If only α is odd, execute Q on the target, with its remaining even power as an ordinary monomial, and add the ordinary source image. If only β is odd, form the source image in owned storage, apply its single Q and even monomial there, and add it to the ordinary target image. If both are odd, rewrite (1) as + + Q[Q^(α−1) z_t + ε Q^(β−1) z_s]. + +The two inner powers are even. Form the bracket by ordinary operations and then execute Q once on the target. Each case implements the exact integer-exponent identity and preserves the source. An inverse odd Gaussian can equally be written as one Q followed by an even monomial. ∎ + +The assertion describes an emitted tariff, not a lower bound against every conceivable algorithm for Q. A literal width-dependent butterfly algorithm remains possible and has its own nonrecursive cost. + +**Corollary C2 (redirect an already paid correction).** If k is even and a and b have opposite parity, either of the choices c=a and c=b costs one Gaussian in C1. The former transforms a source copy; the latter transforms the target and aligns its output gauge with the source. The alignment costs no additional Gaussian beyond the correction already paid for that crossed ADD. + +**Proof.** For c=a the first exponent is even and the second odd. For c=b the first is odd and the second even. Apply C1. ∎ + +This is a new scheduling choice relative to pricing every crossed ADD while forcing its target gauge to stay fixed. It can affect later queries and scalar boundaries; it does not automatically make their full costs vanish. + +## 2. Several commuting Gaussian axes + +Let Q_0,...,Q_(r−1) act on explicitly specified mutually independent coordinate axes. They commute, and each Q_j squared is a known monomial. For an integer vector v write Q^v for their product and let supp₂(v) be its odd-coordinate set. The operator Q^v is an ordinary monomial times a whole Gaussian on |supp₂(v)| axes. An actual Gaussian job on this support is one rank-|supp₂(v)| request, with the usual explicit normalizers; it is not a collection of productive outputs on different input fields. + +**Theorem C3 (multivariate one-job redirection).** In (1), replace a,b,c,k by integer vectors. Let + + v = k+a−b. + +The outgoing target gauge can be chosen as either c=a or c=b−k. In the first case only the source requires the correction Q^v; in the second only the target requires Q^(−v). Both implementations use one whole Gaussian of the same rank |supp₂(v)|, plus ordinary monomials. All input fields remain independent. + +**Proof.** Substitute the two choices in (1). For c=a its target exponent is zero and its source exponent is v. For c=b−k its source exponent is zero and its target exponent is −v. The two odd supports agree. Strip the even powers to ordinary monomials and execute the remaining whole Gaussian. ∎ + +For arbitrary c in several axes, two Gaussian requests may be needed. C1's one-axis conclusion must not be extended to arbitrary vector output gauges. C3 is the constructive alternative that retains one request and equal cost. + +For a rank moment t in (0,1), a correction of rank h≥1 has price h^t, rather than h separately priced rank-one calls. The strict inequality h^t1 follows from h^(t−1)<1. Grouping is legal only when those axes act on the same arbitrary field in one actual whole request. Independent fields may not be grouped by this argument. + +## 3. Exact multivariate incidences for B and C + +Let Q_0 be the logical controller's central Gaussian. Let a local physical provider instead use Q_s, and let D be its seven-axis block Gaussian, commuting with the displayed gauges. Its physical types are + + A_s = diag(D,D) S_y(Q_s^(−1)), + B_s = diag(D,Q_sD) S_y(Q_s^(−1)), + C_s = diag(Q_sD,D) S_y(1). + +More uniformly, set b,c in {0,1} with (b,c) respectively (0,0),(1,0),(0,1). The type is diag(1,Q_s^b) A_s diag(Q_s^c,1). Write e_j for the jth exponent vector. + +**Theorem C4 (typed incidences without a hidden adapter).** The physical type equals the gauge-conjugate of the logical A_0 whenever the following integer equalities hold: + + g_X,out − g_X,in = c e_s, + g_Y,out − g_Y,in = b e_s, + g_Y,in − g_X,in = e_0 + (c−1)e_s. (2) + +Its outgoing row difference is then + + g_Y,out − g_X,out = e_0 + (b−1)e_s. (3) + +**Proof.** Gauge-conjugating logical A_0 gives diagonal entries Q^(g_X,out−g_X,in)D and Q^(g_Y,out−g_Y,in)D, and lower off-diagonal entry Q^(−e_0+g_Y,out−g_X,in)D. The first two equations give the physical diagonal entries. Substituting the third into the off-diagonal exponent yields (b+c−1)e_s, which is exactly the displayed typed provider's off-diagonal entry. Subtracting the first two gauge updates gives (3). ∎ + +Thus B_s takes row difference e_0−e_s to e_0, while C_s takes e_0 to e_0−e_s. In particular B_s can be followed by C_t at their common intermediate difference e_0; C_t can be followed by B_t. These are operator identities, not free changes of chart. Ordinary A ports, all other incident operations and both global boundaries must satisfy their own equalities. If central coordinates overlap other Gaussian factors, the final rank is the odd support of the full combined exponent vector, not the sum of nominal ranks. + +## 4. Complete-program telescoping and scalar boundaries + +Fix an actually supplied reference controller whose complete identity is + + L M R = diag(T_i). + +The scalar RIGHT program R acts first, then M, then the scalar LEFT program L. Choose a row gauge G_j at every chronological field boundary. Implement each event E_j as G_j E_j G_(j−1)^(−1), using C1–C4 where applicable and actual monomial swaps/scales elsewhere. + +**Theorem C5 (constructive whole changed request).** The resulting program acts on arbitrary raw inputs by + + G_out diag(T_i) G_in^(−1). + +If every T_i is a monomial in the same commuting Gaussians, the result is diagonal, and its exact exponent vector on channel i is the original exponent plus a_out,i−a_in,i. Its productive rank is the odd support of that full vector. Helpers remain separate independent channels when the admitted local endpoints and physical port permutations preserve their original helper ABI. + +**Proof.** Multiplying consecutive implemented events cancels each interior G_j^(−1)G_j. What remains is G_out(LMR)G_in^(−1). The assumed reference diagonal identity gives the result, and commuting endpoint factors gives the exponent formula. No Gaussian is executed merely to reinterpret the input logically as G_in^(−1)x: the implemented physical events act directly on raw x. The exact operator on the admitted original fields is diagonal with invertible factors. The only erasures in C1 affect owned temporary copies, so no original arbitrary field is identified or erased. No input fields are merged by a chart choice. ∎ + +**Theorem C6 (a complete scalar-boundary tariff).** Let B be any fixed scalar row matrix on n fields. Let its prescribed input and output gauges be integer vectors a_i and b_i in a single central Q direction. For either s=0 or s=1, its gauge-conjugate can be implemented with at most + + number{i : a_i differs from s modulo 2} + + number{i : b_i differs from s modulo 2} + +rank-one Gaussian requests, followed or preceded by the actual scalar program and ordinary even-power monomials. Choosing s optimally bounds the total by n. + +**Proof.** First change each input field from its physical input gauge to uniform gauge s. This uses one Q exactly for each odd difference s−a_i, together with the actual even monomial. Execute B. A scalar matrix commutes with the same Q^s on every row, so its outputs remain in uniform gauge s. Finally change row i to b_i. The Gaussian count is the displayed sum. The sums for s=0 and s=1 add to 2n, so their smaller value is at most n. ∎ + +For the two complete boundaries together, one may choose the SAME common outside gauge Q^s on every input and every output channel. Then this common gauge commutes with the diagonal target and changes no productive target. The actual RIGHT boundary can be executed followed by the needed changes to the prescribed interior entrance gauges; the LEFT boundary can be preceded by changes from its prescribed interior exit gauges. Choosing s by the combined majority gives at most n total rank-one requests across both boundaries, since there are 2n interior gauge bits. This proves an honest finite boundary allowance even when the scalar matrices are dense. It does not price the allowance as zero. + +## 5. A fully specified alternating schedule, with its actual tariff + +This construction applies to the retained p-pair event pattern, for any fixed p≥2 for which the reference complete Laurent factorization is supplied. There are p+2 thick LOCALs: stage 0, every odd stage, and stage 2p. The even stages 2,...,2p−2 are thin Q^(−1) shear queries. Do not alternate provider types over those thin queries as if they were full provider calls. + +Use the same 56 exceptional ports throughout. Choose thick provider types alternately B,C,B,C,..., starting with B at stage 0. At the exceptional ports give pair 0 initial gauges (0,0). Stage 0 B changes them to (0,1), so odd stage 1 C is admissible and leaves (1,1). For pair j≥1 choose its entrance gauges equal to the previous pair's post-odd gauges. Those post-odd states cycle as + + s_0=(1,1), s_1=(1,0), s_2=(0,0), s_3=(0,1), s_(j+4)=s_j. + +**Theorem C7 (an emitted typed schedule with complete middle pricing).** This gauge assignment admits every typed thick LOCAL. Every forward bridge is ordinary. Exactly ceil((p−1)/2) of the thin queries use a rank-one Gaussian in C1's fixed-gauge construction. The backward terminal bridges use p rank-one requests. Signed swaps transport their row gauges without further Gaussian work. A complete unchanged-target endpoint can be supplied using C6 with at most 2p additional rank-one requests at the two scalar boundaries. + +**Proof.** Stage 0 and stage 1 were checked above. A B input pair has equal gauges and its output Y flips, producing an opposite pair; the following C accepts that pair and returns an equal pair with the opposite common bit. Repeating gives the displayed four-state cycle. Before pair j+1's first LOCAL its entrance gauges equal pair j's post-odd gauges. Both forward bridges connect those same row gauges: the intervening thin query does not change a chosen gauge. Their coefficients therefore remain even powers of Q, so they are ordinary. + +The thin query is a forward Q^(−1) ADD. Its physical coefficient is odd exactly when the two current row gauges agree. Those are the C outputs, indexed by even j among 0,...,p−2. There are ceil((p−1)/2) of them. Neighboring states s_j,s_(j+1) differ in exactly one bit, so each usual backward bridge has exactly one crossed ADD. The final pair receives one additional thick LOCAL after its odd stage; its final state is s_p rather than s_(p−1). Since s_p and s_(p−2) differ in both bits, the last backward bridge has two crossed ADDs. Thus the p−2 ordinary adjacent bridges cost one each and the last costs two, totaling p. A signed swap moves the attached gauge with the row and introduces only its known scalar sign. There are n=2p rows in the scalar boundaries; apply the common-outside-gauge consequence of C6 to obtain at most 2p additional calls without changing the diagonal target. ∎ + +At the 56 ordinary ports use the original zero-gauge A incidences and their unchanged thin-query tariff. Every local helper is fresh and retains its own endpoint. The number of B calls is ceil((p+2)/2), and C calls floor((p+2)/2), so their helper and paid profiles are summed with exactly those multiplicities. Every seven-axis IDLE is charged on its actual selected stage set. + +C7 is a complete sufficient construction, not a claim that naive alternation funds a larger exponent. In particular, the middle count p+ceil((p−1)/2) is greater than the old p−1 thin-query count. The additional redirection choices in C2–C3 can alter this schedule and its future boundary cost, but a lower complete moment must be proved for an actual resulting word before it is promoted. C7 prevents a local B→C match from being mistaken for a free entire controller. + +## 6. A separate dense consumer from the convolution algebra + +Let Γ be a finite abelian group and let A be its complex group algebra, represented as coefficient arrays with convolution *. If α is a group automorphism and χ a character, define + + Lx(g) = χ(g) x(α^(−1)g). + +**Theorem C8 (explicit algebraic normalizers).** L is an invertible algebra automorphism of A. If Γ=(Z/2)^f, these are exactly the form of binary-linear index permutations followed by real linear characters used by the documented whole-K normalizers. + +**Proof.** Reindexing a convolution by the additive bijection α preserves the equation a+b=g. Character multiplicativity gives χ(a)χ(b)=χ(g) in each summand. Hence (Lx)*(Ly)=L(x*y). Both factors are invertible and preserve the convolution identity. In the binary case a real linear character is (−1) raised to a binary linear form, which is exactly the stated sign multiplier. ∎ + +The theorem concerns linear coordinate permutations and character signs. An arbitrary affine translation or arbitrary signed permutation does not satisfy the same automorphism identity and is not silently included. + +Let L=diag(L_1,...,L_R), let K be a scalar R by R matrix with K^T K=I, and set C=L^(−1)(K⊗I)L. Define the A-valued bilinear output + + Ψ_L(x,y) = sum_(u=1)^R (L_u x_u)*(L_u y_u) + = sum_u L_u(x_u*y_u). + +**Theorem C9 (a complete paired coded consumer).** For all arbitrary dense x,y, + + Ψ_L(Cx,Cy)=Ψ_L(x,y). + +The same holds for a product of such codes sharing the same L. If a convolution filter F is invertible, then also + + Ψ_L(F^(−1) Cx, F Cy)=Ψ_L(x,y), (4) + +where F acts on every owner field by the same convolution. More generally x,y may be replaced by any explicitly supplied operator images D x and E y, without a commutation assumption on C with D or E. + +**Proof.** Put a=Lx and b=Ly. Then L(Cx)=Ka and L(Cy)=Kb. Expand the output: + + sum_u (sum_v K_uv a_v)*(sum_w K_uw b_w) + = sum_(v,w) (sum_u K_uv K_uw) (a_v*b_w) + = sum_v a_v*b_v. + +This uses K^T K=I and bilinearity over the commutative coefficient algebra. Products of orthogonal K matrices remain orthogonal, proving the common-frame assertion. If F is convolution by h, its inverse is convolution by a convolution inverse of h. Associativity and commutativity give (F^(−1)z)*(Fw)=z*w for every pair of fields. Apply this cancellation before applying L_u and summing. Substitution of D x,E y proves the last statement. ∎ + +A varying normalizer itinerary is NOT automatically a common L. One sufficient case is L_(j,u)=A_j L_u for an owner-independent algebra automorphism A_j: then that A_j commutes with every scalar owner matrix and cancels in each code, leaving exactly L^(−1)(K_j⊗I)L. This gives an actual nontrivial family of admissible changing descriptions while preserving the common-frame theorem. + +For binary Γ, the documented central Q_f has one-bit coefficients a=(1+i)/2 and b=(1−i)/2, so it is convolution by the tensor product of the two-point vector (a,b). Its Fourier eigenvalues are products of a+b=1 and a−b=i and are therefore nonzero. It is an invertible convolution filter, and (4) applies with F=Q_f. + +However, the actual source positive terminal P E Q is not automatically the companion Q P E required in (4). They agree only under an established commutation relation. Nor does XOR convolution equal cyclic convolution on integer digit indices. Those actual interface conditions are retained explicitly. + +## 7. An explicit dense algorithm and its output contract + +**Theorem C10 (dense XOR contraction without decoding the codes).** For Γ=(Z/2)^f, N=2^f, and the C9 normalizers, Ψ_L(z,w) is computed on arbitrary dense arrays by 2R forward Walsh transforms, one inverse Walsh transform, and O(RN) ordinary pointwise products, additions and frequency permutations. Using the ordinary butterfly recursion gives O((R+1)Nf) field work. If an actually supplied all-input Walsh procedure has complete cost W(N,f), the same construction has cost at most (2R+1)W(N,f)+O(RN), with its actual coefficient/precision costs included. + +**Proof.** Let Hx(ξ)=sum_g (−1)^(ξ·g)x(g), so H^(−1)=H/N. Direct character orthogonality proves H(x*y)=Hx·Hy. Also + + H(L_u x)(ξ) = Hx(α_u^T(ξ+z_u)) + +when χ_u(g)=(−1)^(z_u·g). Thus compute Hz_u,Hw_u once each, permute their frequency coordinates by the known affine bijection, multiply and sum the R pairs, and apply H^(−1) once. The convolution theorem gives exactly Ψ_L(z,w). Splitting a Walsh transform by its final bit yields two half-size transforms and N scalar additions/subtractions, hence O(Nf) operations by induction. This is an explicit dense algorithm, rather than an inference from tensor bond dimension. ∎ + +The output here is one A-valued sum of R products, not R independent Gaussian outputs. The theorem therefore gives no license to retain R old productive-target credits. It is a useful changed consumer when the surrounding multiplication formula already requires that sum. Mapping it to a full integer-multiplication caller still requires an exact carry-aware/cyclic interface and a compatible companion producer; no such missing map is assumed in these proofs. + +The main actionable positive result for the actual B/C route is C1–C6: full chronological gauge changes, one-job target redirection and a complete finite boundary tariff. The dense consumer C8–C10 is a distinct exact service that can be considered by a multitype assembly theorem only at its true input/output dimensions and its displayed paid cost. No larger κ has been inferred from an unpaid local match or a changed output sum. + + diff --git a/research/fine-gap-gaussian-boundaries/inverse.md b/research/fine-gap-gaussian-boundaries/inverse.md new file mode 100644 index 0000000000..b10271349a --- /dev/null +++ b/research/fine-gap-gaussian-boundaries/inverse.md @@ -0,0 +1,213 @@ +# Fine-gap Gaussian inversion without the large run gauge + +Dugongue, with substantial OpenAI Codex assistance. This note contains informal mathematics only. It uses local proof-tree and DAG precedents; no numerical experiment, external search, solver or Lean run establishes any statement here. + +The completed result is a constructive inverse for the actual periodic rounded Gaussian in the fine-gap regime. It removes the exp(a/θ) intermediate range of the preceding whole-run construction. This substantially enlarges that construction's parameter domain. It does not manufacture a stronger Gaussian provider or claim that a complex-only quotient word has already satisfied a different native caller contract. + +## Source precedents and scope + +The preceding Beatty-run note, `research/beatty-run-gaussian-inverse/analysis.md`, gives the exact Gaussian q-LDU and the periodic run/boundary decomposition. Its Theorem A11 used aρ θ bounded below and paid the full run similarity range a/θ. + +The retained `research/native-kappa-30201655/modern-sources/BILATERAL-LDU.md` gives the same actual Gaussian kernel and finite/bilateral inverse formulas. `LOG-A-PHASE-SCHUR-AUDIT.md` records the sharper nearest-neighbor diagonal-dominance bound and the physical phase-cell Schur geometry. `research/native-word-fft/NATIVE-BANDED-INVERSE.md` supplies the constructive elimination/residual argument. `NATIVE-ASSEMBLY.md` already reaches every saving strictly below its admitted provider saving, subject to its retained source contracts. Consequently a new inverse algorithm must not be counted as a new numerical κ merely because its individual cost is lower. + +Classical Gaussian elimination, q-binomial identities, geometric recurrences, FFT convolution and Schur complements retain their classical status. The new application here is to factor the exact finite-run inverse so that its long-range part is a stable first-order recurrence and its remaining convolution is short and locally well scaled. + +## 1. Actual matrix and fine-gap regime + +Let S0 define + + G_ij = exp(−a[(ρj−q_i)^2−β_j^2]), + N_ij = sum_(k in Z) G_(i,j+kS). + +Thus β_i belongs to [−1/2,1/2), β_(i+S)=β_i, and N is the actual periodic Gaussian inverse matrix from the retained reduction. + +For the asymptotic corollary use a master parameter p tending to infinity, constants c_1,c_2,A_1,A_2>0, and + + c_1 p^(−2) ≤ θ ≤ c_2 p^(−2), + A_1 log p ≤ a ≤ A_2 log p, + +where A_1≥4. Requested accuracy is 2^(−P), with P=O(p), and the input magnitude is at most exp(O(p)). Parameters have explicit polynomial-time certified approximations, as for the production choice a=π α² with prescribed integer α. The native model is the same explicit extended Word RAM as the preceding note: O(p)-bit words, bounded-word arithmetic, multiplication/division, indexed memory and fixed-point rescaling shifts. Raw products fit before rescaling. This does not claim an implementation in the smaller tcslib ISA. + +## 2. Exact run blocks and their q-LDU + +The sets I_c={i:q_i−i=c} are integer intervals of length floor(1/θ) or ceil(1/θ). A cyclic relabeling gives S consecutive indices partitioned into g=T−S=Sθ complete runs. The proof is the interval identity + + I_c = Z intersect [(c−1/2)/θ,(c+1/2)/θ), + I_(c+g)=I_c+S. + +Within one run define D_i=exp(aβ_i²/θ). Its full, unperiodized principal block is + + B = D A D^(−1), A_ij=q^((i−j)^2), + q=exp(−aρ). + +Expanding both exponents proves the equality; on the run β_i−β_j=θ(i−j). + +Set F_0=1 and F_r=product_(k=1)^r(1−q^(2k)), and let F denote the diagonal matrix with entries F_i after translating the run origin to zero. Define the lower Toeplitz matrix H with coefficients + + h_r=(−q)^r/F_r, r≥0. + +The exact finite q-LDU identity from the preceding note gives + + A^(−1)=F^(−1) H^T F H F^(−1). + +Since D commutes with F, the actual run inverse is therefore + + B^(−1)=F^(−1) J_+ F J_- F^(−1), + J_-=D H D^(−1), J_+=D H^T D^(−1). (1) + +The former algorithm formed D and D^(−1) separately. The construction below never does so. + +## 3. A generating-function identity removes the slow tail + +**Theorem 1.** In formal power series, and hence for every finite nilpotent shift Z, + + H(z) = (1+qz)^(−1) H(q²z). + +**Proof.** The coefficient of z^r in (1+qz)H(z), for r≥1, is + + (−q)^r[1/F_r−1/F_(r−1)] + = (−q)^r q^(2r)/F_r, + +because F_r=F_(r−1)(1−q^(2r)). This equals the coefficient in H(q²z). The constant coefficients are both 1. At a finite shift the same coefficient identity holds after all powers at or above the run length vanish. ∎ + +Let Z be the lower coordinate shift on the run and M_-=q D Z D^(−1). Conjugating Theorem 1 gives + + J_-=(I+M_-)^(−1) R_-, + R_-=D H(q²Z)D^(−1). (2) + +For the upper orientation use the upper shift Z^T, producing J_+=(I+M_+)^(−1)R_+. These are exact finite identities, not asymptotic expansions. + +## 4. The first factor is a stable scalar recurrence + +**Theorem 2.** Every nonzero entry of M_- or M_+ has absolute value at most exp(−aθ). Applying (I+M_±)^(−1) is an explicit first-order forward or backward recurrence with O(length of the run) arithmetic work and + + ||(I+M_±)^(−1)||_∞ ≤ 1/[1−exp(−aθ)]. (3) + +Its rounding and coefficient perturbations have only polynomial amplification in θ^(−1) in the fine-gap regime. + +**Proof.** For adjacent positions in the same run, + + D_i/D_j = exp(a(i−j)(β_i+β_j)) ≤ exp(a). + +Since q=exp(−aρ), multiplying by q gives exp(−aθ). The lower solve is y_i+μ_i y_(i−1)=z_i; compute in increasing order, with the analogous decreasing order for the upper solve. Expanding the recurrence gives a finite geometric majorant with ratio exp(−aθ), proving (3). With a local additive residual at most η in every recurrence equation, the same expansion bounds the output error by η/[1−exp(−aθ)]. An error in μ_i contributes at most its size times the current solution bound. Hence choosing coefficient and arithmetic errors smaller by a further polynomial in [1−exp(−aθ)]^(−1) proves the stated stability. In the fine-gap regime this quantity is polynomial in p. ∎ + +This step is not a dense triangular inverse and does not multiply the input by an exponentially large diagonal. + +## 5. The residual has a short, uniformly summable tail + +For r=|i−j| on a run, the residual coefficients in the relevant triangular orientation are + + (R_±)_ij = (−q³)^r D_i/[F_r D_j]. + +**Theorem 3.** If a≥1, then + + |(R_±)_ij| ≤ (3/2) exp(−a(3ρ−1)r). + +Consequently truncating each residual to r≤L has row-sum error at most + + (3/2) exp(−a(3ρ−1)(L+1)) / + [1−exp(−a(3ρ−1))]. (4) + +In the fine-gap regime, errors of size exp(−O(p)) times any prescribed inverse polynomial in p are obtained with L=O(p/log p). + +**Proof.** Since q≤exp(−1)<1/2, the finite product estimate F_r≥2/3 applies. The run identity gives D_i/D_j≤exp(a r). Multiply that estimate by q^(3r) and sum the resulting geometric tail. Its exponent has a(3ρ−1)≥2a, which is Θ(log p) in the stated regime. Taking logarithms of (4) gives the length claim. ∎ + +## 6. Local recentering makes the residual an ordinary bounded convolution + +**Theorem 4.** A length-L truncation of R_± can be applied with O(S log(L+2)) native work over all runs, after input-independent preparation, using additional magnitude and accuracy reserve + + O(aθL² + log p + log(S+1)) + +beyond the target precision and the input magnitude. In the fine-gap regime with L=O(p/log p), the term aθL² is O(1/log p). + +**Proof.** Partition each run into consecutive blocks of length at most L. An output block of a triangular bandwidth-L operator meets at most two input blocks. For any such input/output rectangle, choose an anchor u in their common run, with every participating index within 2L of u. Write + + D_i = const × exp(2aβ_u(i−u)) × exp(aθ(i−u)²), + +where β_u=θu−c lies in [−1/2,1/2]. The constant cancels from every ratio. Absorb the linear factor into the Toeplitz kernel. Its new rth coefficient is + + (−q³ exp(±2aβ_u))^r/F_r, + +whose magnitude is at most (3/2)exp(−a(3ρ−1)r). The remaining diagonal values are between 1 and exp(4aθL²). Thus the rectangle is two bounded diagonal maps around one explicitly specified linear convolution. Zero padding and the radix-two FFT compute it in O(L log(L+2)) operations; the ordinary butterfly norm/error argument requires only O(log L) guard bits beyond the logarithms of the displayed magnitudes. No coordinate is padded in the final array: padding belongs only to a temporary one-dimensional convolution. + +There are O(S/L) such rectangles, plus a bounded number of shorter endpoint rectangles per run. A shorter run may instead use one such rectangle; in the fine-gap regime full runs have length Θ(p²)≫L. Summing gives O(S log(L+2)). Every anchor, kernel transform and diagonal table is input independent and belongs to preparation. The identity uses local differences and β_u; it never evaluates the global exponent aβ_i²/θ. Finally aθL²=O((log p)p^(−2)(p/log p)²)=O(1/log p). ∎ + +The same proof covers both orientations. It uses the explicit convolution theorem of the preceding note, including twiddle preparation and fixed-point rescaling, not an assumed fast multiplication oracle. + +## 7. A complete stable fine-gap run inverse + +**Theorem 5.** In the fine-gap regime, the full block-diagonal inverse B^(−1) on all complete runs admits application cost O(S log p), after polynomial(S,p) input-independent preparation. It needs O(p) working bits when log(S+1)=O(p), target precision and input magnitude logarithms are O(p). + +**Proof.** Apply (1), replacing each J_± by (2). Each orientation consists of one residual convolution from Theorems 3–4 and one first-order recurrence from Theorem 2. The three F diagonal maps have bounded norm because 2/3≤F_i≤1. The recurrence norms are polynomial in p, and the residual maps have constant row-sum bounds. Therefore all completed factors and their partial direct recurrence sums have polynomial range and error amplification. Allocate each truncation, coefficient and arithmetic error at the target tolerance divided by a sufficiently large polynomial in p and S. Its logarithmic cost is O(log p+log S), while the residual's local gauges have constant logarithmic range by Theorem 4. This proves the precision statement and the cost O(S log p). All raw products fit a sufficiently enlarged constant multiple of p bits before rescaling. ∎ + +This theorem removes the preceding sufficient requirement a/θ=O(p). Here a/θ is Θ(p² log p), yet it is never formed as a data multiplier. + +## 8. The physical matrix remains diagonally dominant + +**Theorem 6.** For the actual periodic matrix, + + ||N−I||_∞ ≤ exp(−2aθ)+5exp(−2a). (5) + +In the fine-gap regime there is a constant c>0 such that, eventually, N and every principal/truncated matrix obtained by deleting its positive off-diagonal kernel terms have row diagonal-dominance margin at least + + δ=c aθ. + +All their inverse norms are at most δ^(−1). + +**Proof.** Put n_(i,h)=G_(i,i+h). For h=−1,+1, the exact nearest-integer gaps q_i−q_(i−1),q_(i+1)−q_i belong to {1,2}. Expanding the two exponent differences gives the upper bounds exp(−a(1+2θ−2β_i)) and exp(−a(1+2θ+2β_i)); if a gap is 2, its allowed β_i interval only strengthens that bound. Their sum is a convex function of β_i, so its maximum on [−1/2,1/2] is exp(−2aθ)+exp(−2a(1+θ)). For |h|≥2, the exponent difference is at least h²−|h|. Summing that Gaussian tail gives at most 4exp(−2a) when a≥1. This proves (5), including periodic diagonal aliases. + +For large p, aθ≤1/2, so 1−exp(−2aθ)≥aθ. Also 5exp(−2a)≤(aθ)/2 because a≥4log p and θ≥c_1p^(−2). Thus the gap is at least aθ/2. Removing positive off-diagonal terms cannot decrease it. Principal restrictions have the same property. A matrix with row diagonal-dominance margin δ has inverse norm at most δ^(−1): at a coordinate where |x_i| is maximal, |(Ax)_i|≥δ||x||_∞. ∎ + +## 9. A boundary-only correction with a physical Schur system + +Choose w≥1 with w=O(sqrt(p/a)) large enough to make + + 4exp(−a w(w+1)) ≤ ε δ²/[4(X+1)], + +where ε is the desired final inverse error and X bounds the input. Every run has length Θ(p²), so its first and last w coordinates are disjoint eventually. Keep the full within-run blocks and only cross-run kernel entries with displacement at most w; call the result A=B+E. Let J consist of those boundary coordinates, let V select them, and put K=VEV^T. Then E=V^T K V, and K couples only neighboring runs, cyclically. + +**Theorem 7.** Define the block-diagonal matrix + + S_B=(V B^(−1) V^T)^(−1), + +and the cyclic block-tridiagonal matrix S_A=S_B+K. The following is an exact A-solve: + + y=B^(−1)b, + S_A z=S_B V y, + x=B^(−1)(b−V^T K z). (6) + +Both S_B and S_A are physical Schur complements and have row diagonal-dominance margin at least δ and bounded row sums. The inverse residual caused by replacing N by A is at most ε/2 under the displayed tail choice. + +**Proof.** Eliminating all nonboundary coordinates inside each full run produces S_B, by the block-inverse identity. Because E is supported on J×J, exactly the same elimination on A adds K to that Schur complement. A scalar elimination step cannot decrease a strict row gap: the new gap is at least the old gap plus |a_ik| times the pivot row gap divided by |a_kk|. Its absolute row sum cannot increase. Thus the stated Schur properties follow from Theorem 6, with no near-identity assumption on the Woodbury matrix. + +Multiplying the middle equation in (6) by V B^(−1)V^T gives (I+VB^(−1)V^T K)z=Vy. The last equation therefore has Vx=z. Multiplying it by A gives Ax=b−V^TKz+V^TKVx=b. The omitted Gaussian row tail is at most 4exp(−aw(w+1)). Since ||N^(−1)|| and ||A^(−1)|| are at most δ^(−1), the resolvent identity bounds their action difference by δ^(−2)||N−A||X, giving the stated allowance. ∎ + +## 10. Complete boundary solve and precision + +**Theorem 8.** Preparing a bordered band elimination of S_A costs O(g w³) scalar work; applying its factors costs O(g w²) per right-hand side. Its rounding can be controlled with P+O(log(S+1)+log p+log(X+1)) bits. + +**Proof.** Group the boundary coordinates by runs, each group having 2w coordinates. Retain the first group as a border and eliminate the other groups in cyclic order. At every step a pivot group is joined only to the next uneliminated group and the retained border. Its update frontier has O(w) coordinates, so each group costs O(w³) to prepare and writes O(w²) factor coefficients. A solve visits these coefficients once, including all border contributions, proving the work counts. + +Simultaneous row/column reordering preserves strict row diagonal dominance. During elimination pivots remain at least δ and absolute row sums remain bounded by the original row sum. Thus every upper-factor entry is bounded, every multiplier is bounded by a polynomial in δ^(−1), and the total lower-factor row sum is at worst a polynomial in S and p. The inverse bounds for every relevant principal problem are at most δ^(−1). Consequently ||L^(−1)||≤||U||||S_A^(−1)|| and ||U^(−1)||≤||S_A^(−1)||||L|| are polynomial in S,p. The same statements hold on elimination prefixes. Expanding each computed row update literally expresses its factor residual as a sum of polynomially many local rounding errors, rather than a product of successive condition numbers. Solving with the computed factors adds another such residual. Choosing every local error at most the target tolerance divided by a sufficiently large polynomial in S,p,X therefore gives the asserted logarithmic reserve. + +All coefficients are prepared from explicit finite matrices. To form S_B, one can apply the stable run inverse to its boundary basis vectors and invert the resulting 2w by 2w blocks; their inverse is the physical Schur block, whose norm is already bounded. Dense QR or exact finite elimination with sufficient rational precision supplies this input-independent finite operation. Its polynomial cost belongs to preparation, not to an unpriced oracle. ∎ + +## 11. Fine-gap inverse theorem + +**Theorem 9.** Under the parameters of Section 1, the actual periodic N inverse can be applied to accuracy 2^(−P) with + + O(S log p + Sθ w²) = O(S log p) + +native operations per right-hand side, after input-independent polynomial(S,p) preparation. It uses O(p)-bit words if log(S+1), P and log(X+1) are O(p). + +**Proof.** Use Theorem 5 for both block-inverse applications in (6). The boundary product and solve cost O(gw²)=O(Sθw²), by Theorem 8. Gathering, scattering and S_B multiplication fit this count. Here w²=O(p/a), so θw²=O(1/(p log p)) in the fine-gap regime. Theorem 7 pays the truncation, and Theorems 5 and 8 pay all remaining local arithmetic and coefficient errors. Their range/precision reserves are O(p). ∎ + +If D=p^ε axes have log S_i=O(p^(1−ε)), for any fixed 0<ε<1, one preparation per axis is exp(o(p)). The full inverse tensor costs O(V D log p). The completed physical inverse norms are polynomial in p, so their product over D axes has logarithm O(D log p)=o(p); allocating these extra guard bits still uses O(p)-bit words. This is a sufficient constructive extension to near-linear axis counts. It does not require a simultaneous tensor fusion of the local solvers. + +## 12. What this does and does not establish about κ + +The new mechanisms are the exact recurrence/residual factorization of q-LDU and the physical boundary Schur recovery. They eliminate the large whole-run similarity and extend the actual inverse algorithm to fine prime gaps at logarithmic Gaussian width. + +Combining this with an actual unfused forward adapter of O(S log p) gives total Gaussian adapter work O(V d log p). An actual native provider saving q, inserted into the existing main transform, gives main work O(V p d^(−q)). With d=p^ε and V=Θ(n/p), these two terms admit every κ below min(εq,1−ε), maximized symbolically at ε=1/(1+q), giving every κ i. + +**Theorem.** A = L D L^T. + +**Proof.** The (i,j) entry on the right is the sum over k ≤ min(i,j) of + + q^((i−k)^2+(j−k)^2) F_i F_j/[F_k F_(i−k) F_(j−k)]. + +Subtracting (i−j)^2 from the exponent leaves 2(i−k)(j−k). Therefore that sum is q^((i−j)^2) times the left side of (4), which is 1. This proves every entry equality. Since each F_k is positive and L is unit triangular, this also proves positive definiteness and invertibility, independent of A1. ∎ + +The determinant is product_(k=0)^(n−1) F_k. Although that determinant can decrease with n, it does not imply an unbounded inverse norm; A6 gives a uniform norm bound. + +## A5. Exact inverse as two convolutions + +Let H be lower triangular Toeplitz with + + H_ik = (−q)^(i−k)/F_(i−k) for i ≥ k, + H_ik = 0 for i < k. + +**Theorem.** + + L^−1 = D H D^−1, + A^−1 = D^−1 H^T D H D^−1. (5) + +Thus A^−1 b is obtained by applying, in order, D^−1, H, D, H^T and D^−1. + +**Proof.** Put T_ik = q^((i−k)^2)/F_(i−k) for i ≥ k and zero otherwise. The definition of L gives L = D T D^−1. Products of finite lower triangular Toeplitz matrices multiply their coefficient sequences by truncated convolution. The coefficient of degree m in T H is + + sum_(r=0)^m q^(r²) (−q)^(m−r)/[F_r F_(m−r)] + = (−q)^m/F_m * sum_(r=0)^m (−1)^r Q^(r(r−1)/2) B(m,r). + +By (3) with z = −1, the last sum is product_(j=0)^(m−1)(1−Q^j). It is 1 for m = 0 and zero for m ≥ 1, since then its j = 0 factor is zero. Hence T H = H T = I. It follows that L^−1 = D H D^−1. Inverting A = L D L^T gives + + A^−1 = L^−T D^−1 L^−1 + = D^−1 H^T D D^−1 D H D^−1 + = D^−1 H^T D H D^−1. + +This is (5). H b is a truncated linear convolution with h_r = (−q)^r/F_r. H^T b is the reversal of such a convolution on the reversed input. Both are explicit finite sums; no inverse oracle occurs. ∎ + +## A6. Dimension-independent conditioning and intermediate magnitudes + +All vector and matrix norms in this section are maximum-coordinate and maximum absolute-row-sum norms. + +**Theorem.** For 0 < q ≤ 1/2 and all n, + + ||D|| ≤ 1, ||D^−1|| ≤ 3/2, + ||H|| ≤ 3, ||H^T|| ≤ 3, + ||A^−1|| ≤ 81/4. + +For ||b|| ≤ B, the five intermediate vectors in (5) have norms at most respectively + + (3/2) B, (9/2) B, (9/2) B, (27/2) B, (81/4) B. + +**Proof.** A2 gives the first two estimates. Every absolute row sum of H or H^T is bounded by sum_(r≥0) q^r/F_r ≤ (3/2)/(1−q) ≤ 3. Multiplying the five operator-norm estimates yields the displayed bound (3/2)·3·1·3·(3/2) = 81/4, and multiplying the prefix estimates gives each intermediate-vector bound. Every partial dot product is bounded by the corresponding sum of absolute values, so the same argument controls partial sums in a direct convolution implementation. ∎ + +This is the positive conditioning result missing from a naive global Vandermonde factorization. The inverse is recovered without factors of size exp(constant times n²). An implementation of the convolutions may have its own intermediate growth; for an FFT or polynomial multiplication implementation, that separate arithmetic analysis must be included. A6 does not declare a free stable FFT. + +## A7. A fully specified perturbation theorem for the five-factor inverse + +**Theorem.** Let F_1,...,F_5 denote the five exact factors in their order of application in (5), each of norm at most 3. Suppose approximate factors satisfy ||Fhat_j−F_j|| ≤ ε ≤ 1, and the five evaluated maps introduce additive vector errors of norm at most δ at their outputs. Then the final vector differs from A^−1 b by at most + + 1280 ε ||b|| + 341 δ. + +**Proof.** Each approximate factor has norm at most 4. The difference between the approximate and exact fivefold products is a telescoping sum of five terms. Every term has one factor difference with norm at most ε and at most four remaining factors, each bounded by 4; its norm is at most 4^4 ε. Thus the product perturbation is at most 5·4^4 ε ||b|| = 1280 ε ||b||. An additive error injected after one factor passes through at most four later approximate factors, so all five errors contribute at most δ sum_(j=0)^4 4^j = 341 δ. Add the bounds. ∎ + +In particular, choose ε ≤ 2^(−P)/(2560(B+1)) and δ ≤ 2^(−P)/682 to obtain absolute error at most 2^(−P) for every ||b|| ≤ B. If each retained convolution coefficient is formed with absolute error at most ε/n, its matrix row-sum error is at most ε; the required coefficient precision is P + log2(B+1) + log2 n + O(1). This is a sufficient precision schedule, not an experimental extrapolation. + +## A8. The q-parameter itself has a dimension-independent error budget + +**Lemma.** On 0 < q ≤ 1/2, uniformly in k, + + |F_k'(q)| ≤ 64/27, + |(1/F_k)'(q)| ≤ 16/3. + +Furthermore the sum of absolute derivatives of h_r(q) = (−q)^r/F_r(q), over any finite prefix, is less than 17. + +**Proof.** Logarithmic differentiation gives + + |F_k'| = F_k sum_(r=1)^k [2r q^(2r−1)/(1−q^(2r))] + ≤ [2/(1−q²)] sum_(r≥1) r q^(2r−1) + = 2q/(1−q²)^3 ≤ 64/27. + +Here F_k ≤ 1 was used. Dividing by F_k² ≥ (2/3)² gives the second bound. For h_r, + + |h_r'| ≤ r q^(r−1)/F_r + q^r |(1/F_r)'|. + +Summing the first majorant gives at most (3/2)/(1−q)² ≤ 6; summing the second gives at most (16/3)/(1−q) ≤ 32/3. Their sum is 50/3 < 17. The r = 0 derivative is zero, so its harmless inclusion in the second majorant preserves the inequality. ∎ + +**Corollary.** If q and qhat lie in (0,1/2], the row-sum norm errors in D, D^−1 and H or H^T caused only by substituting qhat for q are at most respectively (64/27)|qhat−q|, (16/3)|qhat−q| and 17|qhat−q|. Apply the scalar mean-value theorem to every coefficient and the preceding derivative sums. Consequently an O(2^(−P)/(B+1)) enclosure of q suffices for the parameter component of A7's final error, with an absolute constant independent of n. ∎ + + + +### A11.9. Explicit convolution and native arithmetic model + +For the native corollary, also impose an effective input condition: a is an explicitly specified positive rational, π times an explicitly specified positive rational (including the actual a = πα²), or a real with a charged polynomial-time certified approximation procedure to the working precision. The integers S,T are explicitly supplied, and b is supplied as fixed-point data or certified enclosures at the stated working precision, with a supplied magnitude bound whose logarithm is O(p). The exact real identities in A11.1–A11.6 do not require this computability restriction. For the native corollary, fix the following model. A word contains W bits, with W a sufficiently large constant times the requested precision plus the displayed magnitude and guard bounds. Unit-cost operations include bounded-word addition, subtraction, multiplication, comparison, memory access, integer division, and a shift that divides by a power of two with a specified rounding convention. The word width is large enough to contain raw products before fixed-point rescaling. Complex numbers use two such fixed-point values. Thus one real or complex fixed-point addition, product, or division by a pivot bounded away from zero costs O(1) of these native operations and has a chosen O(2^(−B)) local error. This is an explicit extended Word RAM; no instruction-level realization in the more restrictive tcslib ISA is claimed. The exact field-operation count (10) and the precision requirement (12) are mathematical statements independent of that implementation choice. + +**Convolution lemma.** Two length-L complex arrays with coordinate bounds X,Y can be convolved, to absolute output error 2^(−P), using O(L log(L+2)) operations in this model and P + O(log(L+2) + log(X+1) + log(Y+1)) fractional bits, with sufficient integral bits for polynomial-in-L intermediate growth. Input-independent twiddle preparation is charged separately and has a polynomial precision-dependent cost. + +**Proof.** Pad both arrays with zeros to a power-of-two length M satisfying 2L ≤ M < 4L. Choose ζ = exp(2πi/M). The geometric-series identity sum_(j=0)^(M−1) ζ^(kj) = 0 for nonmultiples k of M and M otherwise proves the DFT inverse formula. Splitting a DFT into its even and odd indices gives the radix-two butterfly recursion. There are log2 M levels, M/2 butterflies at each level and O(M log M) operations overall. Pointwise multiplication of the two DFTs followed by the normalized inverse gives their cyclic convolution; zero padding makes all its nonzero output coefficients equal the ordinary linear convolution. + +Each exact butterfly has maximum-row-sum norm at most 2; each twiddle has modulus 1. At any stage exact intermediate magnitudes are at most M times the input bound. Suppose every twiddle has absolute error at most δ and each completed butterfly coordinate incurs additive arithmetic error at most 4δ. A perturbed butterfly has norm at most 2+δ. For δ ≤ 1, the forward error after r levels is at most + + δ r 3^(r−1) (X+4) ≤ δ M³ (X+4). + +This follows by telescoping the stage products and summing the additive errors; r ≤ M and 3^r ≤ M². If δ ≤ M^(−3), each approximate forward transform is bounded by 2M(X+4), or 2M(Y+4). Subtracting the two pointwise products and using these forward-error bounds gives error at most + + 10 δ M⁴ (X+4)(Y+4) + +including one rounded pointwise product. More precisely, each forward bound is (M+1)(X+4) or (M+1)(Y+4). Since M is at least 2, their product and the pointwise rounding fit below 4M²(X+4)(Y+4). This is the input bound of the approximate inverse transform. Applying the same stage bound and then the exact 1/M normalization bounds the additional inverse-transform error by at most 5δ M⁴(X+4)(Y+4); the final fixed-point normalization adds at most δ. Therefore the complete convolution error is at most + + 512 δ M⁴ (X+1)(Y+1). + +Choosing δ at most both M^(−3) and 2^(−P)/[512 M⁴(X+1)(Y+1)] proves the stated fractional-bit bound. Every intermediate magnitude in the argument is polynomial in M times (X+1)(Y+1); its logarithm supplies the asserted integral bits. + +The complex twiddles are not exact machine oracles. They are input-independent constants whose bounded arguments can be approximated by elementary Taylor series after range reduction, with polynomial cost in the desired precision. A sufficiently accurate π value may be supplied by the elementary arctangent identities and series already used in the inherited exponential/root preparation notes. Preparing all M twiddles to the chosen precision costs polynomial(M,P,log(X+1),log(Y+1)) work and is charged to preparation. In A11.8, M = O(1/θ) is polynomial in p; neither this preparation nor coefficient setup alters its subexponential-in-p setup classification. ∎ + +Apply this convolution lemma to the two Toeplitz maps in A5 and their reversals, at the extra precision required by the D_c similarity. It supplies the explicit C(L) = O(L log(L+2)) used in A11.7. The actual run solve is consequently a sufficient algorithm on the stated extended native machine, with all intermediate growth, rescaling, truncation and boundary costs paid. This is a mathematical construction, not an experimentally verified or Lean-verified program. + +