From 326844a3e0c570fdafa4f3737095cd37154743a6 Mon Sep 17 00:00:00 2001 From: Jerry Jiaheng Chen <80299683+CubeJerry@users.noreply.github.com> Date: Sat, 14 Nov 2026 14:05:21 +1100 Subject: [PATCH] Prove exact displacement and Toeplitz generator counts for tensor Gaussian sections --- .../PR-DESCRIPTION.md | 96 +++++ .../PROOF.md | 293 +++++++++++++++ .../README.md | 156 ++++++++ .../REVIEW.md | 74 ++++ .../SOURCES.json | 54 +++ .../TASK.json | 95 +++++ .../VALIDATION.json | 25 ++ .../VERIFY.json | 34 ++ .../verify.py | 343 ++++++++++++++++++ 9 files changed, 1170 insertions(+) create mode 100644 research/tensor-gaussian-displacement-rank/PR-DESCRIPTION.md create mode 100644 research/tensor-gaussian-displacement-rank/PROOF.md create mode 100644 research/tensor-gaussian-displacement-rank/README.md create mode 100644 research/tensor-gaussian-displacement-rank/REVIEW.md create mode 100644 research/tensor-gaussian-displacement-rank/SOURCES.json create mode 100644 research/tensor-gaussian-displacement-rank/TASK.json create mode 100644 research/tensor-gaussian-displacement-rank/VALIDATION.json create mode 100644 research/tensor-gaussian-displacement-rank/VERIFY.json create mode 100644 research/tensor-gaussian-displacement-rank/verify.py diff --git a/research/tensor-gaussian-displacement-rank/PR-DESCRIPTION.md b/research/tensor-gaussian-displacement-rank/PR-DESCRIPTION.md new file mode 100644 index 0000000000..451393a88e --- /dev/null +++ b/research/tensor-gaussian-displacement-rank/PR-DESCRIPTION.md @@ -0,0 +1,96 @@ +## What changed and why it matters + +This package proves an exact representation obstruction for a proposed +grouped Gaussian inverse: flattening a separable tensor does not preserve +small ordinary Toeplitz displacement rank. The retained shallow inverse uses +short lower-times-upper Toeplitz generator sums, so the required generator +count is an explicit obligation when that formula is transferred to a +grouped block. + +For normalized shifted Gaussian sections of dimensions `n_i >= 2`, total +dimension `T`, and fastest axis `f`, the ordinary Sylvester and Stein +displacements of both the tensor and its inverse have exact rank `2T/n_f`. +This is also the exact minimum number of ordinary `L(u) U(v)` generator terms. +The best lexicographic axis ordering gives `2T/max_i n_i`; two-point factors +have full displacement rank in every such ordering. + +The underlying proof is stronger: for any invertible `m x m` outer matrix A +and any Toeplitz fastest factor B, explicit boundary minors have determinants +`(-b_-1^2)^m det(A)^2` and `(-b_-1 b_1)^m det(A)^2`. The forward ranks follow +from these minors and the matching support upper bounds. The inverse +Sylvester identity and a Schur-complement/persymmetry argument supply the +inverse claims. A Vandermonde factorization establishes Gaussian +invertibility uniformly. + +## Scope, dependencies and predecessor credit + +Exact base: `e54523517d0f03e58352e647c403a5af3e525a57`. The selected record, +review, task card and source sections have Git-blob/SHA256 pins in +`SOURCES.json`. They are historical provenance; the verifier has no external +runtime inputs or dependencies. + +The normalized kernel comes from `GAUGEFREE-INTERIORS.md`, while the ordinary +generator mechanism comes from `SHALLOW-TOEPLITZ.md`. Preserve Vlado +Vojdanovski's capped-phase-fusion credit and the cited source authors' work. +The one-axis application/error contracts in #5566, #5571 and #6905 remain +their own results. This package adds the exact flattened representation +calculation and its matching scope controls, without repeating the familiar +serial factor-of-axes budget as a new contribution. Bounded overlap searches +found no matching exact project theorem; no literature-wide priority claim +is made. The proof cites Olshevsky, Oseledets and Tyrtyshnikov's classical +multilevel Toeplitz/tensor work as background. + +## Reproduction and executed checks + +```sh +python3 -I -W error -B research/tensor-gaussian-displacement-rank/verify.py +python3 -I -O -W error -B research/tensor-gaussian-displacement-rank/verify.py +python3 scripts/research_package.py --package research/tensor-gaussian-displacement-rank --check-only +python3 scripts/research_package.py --package research/tensor-gaussian-displacement-rank +``` + +The two standalone commands were executed with Python 3.12.14 and returned +identical `PASS` JSON. They cover 48 generic forward cases, 47 invertible +generic inverse cases, 11 Gaussian tensors, 22 exact minimum-generator +reconstructions, all six distinct-axis orders of a `(2,3,2)` tensor, and six +negative/scope controls. Ranks use exact rational elimination; selected +minor determinants use independent denominator-cleared Bareiss elimination. +Literal shift products are compared with indexed entry formulas. Explicit +failure checks remain active under optimized Python. The package hook also +registers both commands. The universal proof is written in `PROOF.md`; these +finite fixtures are failure controls, not the proof of all sizes. + +## Limitations and open obligations + +- This is a lower bound on the length of one exact ordinary generator + representation, not on runtime, the recursive Full compiler or general + grouped circuits. A direct local-axis circuit is an explicit control. +- The minimum is over lexicographic axis orderings, not arbitrary coordinate + permutations. A checked Gray ordering reduces the rank in dimension four. +- Exact rank alone does not establish approximate rank or a useful rounding + threshold. A structure-preserving rounded Toeplitz table is covered only + after its invertibility and nonzero adjacent coefficients are established. +- Paid gauges, the full periodic Reference, holes, source generation, + restoration, movement, precision and the complete three-transform budget + are not replaced by the normalized-core calculation. + +Open next questions give concrete first steps for quantitative minor +stability and a source-faithful grouped inverse that uses multilevel +structure with its complete physical budget. + +## Kappa status and assistance + +**No new kappa.** The selected conditional value remains +`363005817/100000000000` (#7000), with all five inherited assumptions retained. +This is a scoped analytic-recovery representation audit, not an unconditional +integer multiplication theorem or admission of a new recovery service. + +Prepared for @CubeJerry with substantial OpenAI ChatGPT assistance. The +orchestrator and research worker independently derived and checked the +boundary-minor proof; the orchestrator extended the initial two-point result +to arbitrary Toeplitz sections. Predecessor credit is retained. New files +are Apache-2.0. + +## Independent review and provenance boundary + +A separate worker independently derived the complete proof (REVIEW.md). Registered normal/optimized replay, metadata/pins, committed bytes/modes and direct base ancestry pass. Generic full-history preflight refuses the intentionally shallow checkout; every provenance row was instead verified at its exact canonical base. No success is claimed for the refused gate. See VALIDATION.json. diff --git a/research/tensor-gaussian-displacement-rank/PROOF.md b/research/tensor-gaussian-displacement-rank/PROOF.md new file mode 100644 index 0000000000..7301e963f2 --- /dev/null +++ b/research/tensor-gaussian-displacement-rank/PROOF.md @@ -0,0 +1,293 @@ +# Exact displacement rank of a flattened Gaussian tensor + +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. + +This is an all-size algebraic result about a specified exact representation. +It does not prove a multiplication runtime lower bound, discharge a retained +foundational assumption, or improve the selected conditional kappa. + +## 1. Question and conventions + +The one-dimensional inverse argument in +`research/capped-phase-fusion/SHALLOW-TOEPLITZ.md`, section 5, uses small ordinary +Toeplitz displacement rank to write an inverse as a short sum of products of +lower and upper triangular Toeplitz matrices. The Gaussian core in +`research/capped-fusion-t74-k554/outer/GAUGEFREE-INTERIORS.md`, section 2, is +Toeplitz after the specified normalization. A tempting grouped replacement is +to flatten a tensor of these cores into one ordinary Toeplitz-generator +representation. The theorem below gives the exact number of terms that this +particular replacement needs. + +Indices start at zero. Let `Z_k` be the k-by-k strict lower shift, so +`(Z_k)_(i,j)=1` exactly when `i=j+1`. For a square matrix X define + +\[ + D(X)=XZ-ZX,\qquad E(X)=X-ZXZ^{\mathsf T}, +\] + +using the shift of the same size. These are respectively the ordinary +Sylvester and Stein displacements; they are not tensor displacement operators. +Flatten `A tensor B` with the B index varying fastest. Every rank below is an +exact algebraic rank, not a numerical or approximate rank. + +## 2. A general Kronecker--Toeplitz theorem + +**Theorem 1.** Let A be an invertible m-by-m matrix over a field, m at least 1. +Let B be an n-by-n Toeplitz matrix, n at least 2, with +`B_(i,j)=b_(i-j)`. Put H=`A tensor B` and N=mn. + +1. If `b_-1` is nonzero, then `rank D(H)=2m`. +2. If both `b_-1` and `b_1` are nonzero, then `rank E(H)=2m`. + +No symmetry or invertibility assumption on B is required for these two +forward conclusions. + +### 2.1 Sylvester displacement + +If a row has fastest index greater than zero and a column has fastest index +less than n-1, the two entries of `HZ_N-Z_NH` agree by the Toeplitz identity. +Thus every nonzero entry lies in one of the m fastest-index-zero rows or one +of the m fastest-index-(n-1) columns. A matrix supported on r rows and s +columns has rank at most r+s, by splitting it into a matrix supported on those +rows and a matrix supported on those columns. Hence `rank D(H)<=2m`. + +Select the rows and columns with fastest indices 0 and n-1, ordering all +index-zero rows/columns first. Set + +\[ + R=b_{-1}I_m-b_{n-1}Z_m. +\] + +The selected square minor is + +\[ + \begin{pmatrix} + RA&b_0(AZ_m-Z_mA)\\ + 0&-AR + \end{pmatrix}. +\] + +Since R is lower triangular with diagonal `b_-1`, the determinant of this +2m-by-2m minor is + +\[ + (-b_{-1}^2)^m\det(A)^2\ne0. +\] + +This proves the first conclusion, including the boundary case n=2. + +### 2.2 Stein displacement + +An entry of `H-Z_NHZ_N^T` vanishes whenever both fastest indices are positive. +Its support is therefore contained in the union of the m fastest-index-zero +rows and columns, giving rank at most 2m. Select the rows and columns with +fastest indices 0 and 1. In the same grouped ordering the minor is + +\[ + \begin{pmatrix} + b_0(A-Z_mAZ_m^{\mathsf T})&RA\\ + AS&0 + \end{pmatrix},\quad + S=b_1I_m-b_{-(n-1)}Z_m^{\mathsf T}. +\] + +Exchanging the two block columns makes this block triangular, so its +determinant is + +\[ + (-1)^m\det(RA)\det(AS) + =(-b_{-1}b_1)^m\det(A)^2\ne0. +\] + +This proves the second conclusion. The argument uses exact boundary entries, +not a genericity assertion. + +## 3. Inverses and the role of persymmetry + +If H is invertible, direct multiplication gives + +\[ + D(H^{-1})=-H^{-1}D(H)H^{-1}, +\] + +so the Sylvester rank is unchanged without further assumptions. + +For the Stein displacement one must first distinguish the shift orientation. +The two Schur complements of the block matrix + +\[ + \begin{pmatrix}H&Z_N\\Z_N^{\mathsf T}&H^{-1}\end{pmatrix} +\] + +show that + +\[ + \operatorname{rank}(H-Z_NHZ_N^{\mathsf T}) + =\operatorname{rank}(H^{-1}-Z_N^{\mathsf T}H^{-1}Z_N). +\] + +The right side has the reverse shift. For a tensor of Toeplitz factors let J +be full coordinate reversal. Each Toeplitz factor satisfies `J B J=B^T`, +and full reversal is the tensor of the individual reversals. Consequently +`J H J=H^T`, and also `J H^-1 J=(H^-1)^T`. Since `J Z_N J=Z_N^T`, conjugating +`E(H^-1)` by J and transposing gives the reverse-shift displacement above. +These operations preserve rank. We have proved: + +**Corollary 2.** If H is a tensor of invertible Toeplitz factors and its fastest +factor has nonzero adjacent offdiagonals, then the four ranks +`rank D(H)`, `rank E(H)`, `rank D(H^-1)`, and `rank E(H^-1)` all equal twice +the product of the other factor dimensions. + +The same-shift inverse Stein conclusion here uses persymmetry. The arbitrary +A hypothesis of Theorem 1 is not, by itself, the proof of that conclusion. +Nor does this argument assert that an inverse Toeplitz matrix is Toeplitz. + +## 4. Normalized shifted Gaussian sections + +Write a normalized contiguous Gaussian section as + +\[ + B_{ij}=q^{(i-j)^2}v^{i-j},\qquad 00. +\] + +This is the retained normalized kernel `exp(-gamma h^2+2 gamma s h)` with +`q=exp(-gamma)` and `v=exp(2 gamma s)`, up to transposition if the source uses +the opposite difference convention. The adjacent coefficients are `q/v` +and `qv`, both nonzero. This algebraic lemma allows every real shift s; +the caller's stricter shift, conditioning and precision premises remain +unchanged. + +For completeness, this matrix is invertible without appealing to a finite +conditioning experiment. Factor it as left and right diagonal matrices +around the Vandermonde matrix `V_(i,j)=(q^(-2i))^j`, for +`0<=i,j0. +\] + +Indeed, each Vandermonde factor for i=2`, and let `T=product n_i`. In a lexicographic ordering with +factor f fastest, all four displacement ranks from Corollary 2 equal + +\[ + \frac{2T}{n_f}. +\] + +The minimum over permutations of the tensor axes is therefore +`2T/max_i n_i`. Equal factor dimensions B give `2 B^(g-1)`. For two-point +factors the rank is the full dimension `2^g` in every axis ordering. +Size-one factors can simply be removed. Nonzero scalar normalization of a +factor does not change any of these ranks. + +This applies to the exact normalized Toeplitz cores. Diagonal gauges, +permutations, periodic tails, holes and rounded coefficient tables can change +ordinary displacement rank. No identification with the complete physical +Reference or a finite fixed-point source is being assumed. + +There is also a direct conditional application to structure-preserving +rounding. If a truncated or rounded factor remains Toeplitz, is invertible, +and retains nonzero adjacent coefficients, Corollary 2 applies to that exact +table without any Gaussian formula. One sufficient admission test is an ideal +factor whose Hermitian part is at least `mu I`, a Toeplitz perturbation of +operator norm strictly below mu, and adjacent-coefficient errors strictly +below `min(q/v,qv)`. The perturbed Hermitian part remains positive definite, +and neither adjacent coefficient vanishes. A band truncation must retain +distance one. The retained source supplies a one-factor conditioning contract, +but this package does not silently certify its full precision choice or paid +diagonal conversion. Arbitrary perturbations need not preserve the rank +equality or the Toeplitz structure. + +## 5. Exact minimum number of ordinary Toeplitz-generator terms + +For vectors u,v of length T, let L(u) be lower triangular Toeplitz with first +column u, and U(v) upper triangular Toeplitz with first row v. Directly, + +\[ + L(u)U(v)=\sum_{k=0}^{T-1}Z_T^k u v^{\mathsf T}(Z_T^{\mathsf T})^k, + \qquad E(L(u)U(v))=uv^{\mathsf T}. +\] + +Thus an exact representation of X as a sum of r products `L(u_l)U(v_l)` +implies `rank E(X)<=r`. Conversely, factor `E(X)` as a sum of exactly +`rank E(X)` rank-one matrices and apply the displayed finite sum. Telescoping, +using the fact that the T-th power of `Z_T` is zero, recovers X. + +**Corollary 4.** The minimum number of ordinary lower-times-upper Toeplitz +generator terms for either the exact H or its inverse in Corollary 3 is +exactly `2T/n_f`. It is not merely an upper bound or a failure of one generator +construction. + +This gives the precise missing representation obligation in a proposed +grouped use of the one-dimensional shallow Toeplitz inverse: rank one as a +tensor does not imply bounded ordinary shift-displacement rank after flattening. + +## 6. Cost interpretation and exclusions + +The exact term count prevents a direct constant-term transplant of that +ordinary generator formula to these grouped matrices. It does not turn an +upper bound on generator application cost into a lower bound on runtime. +Shared work, different generators, a tensor circuit, or another controller may +still exploit separability. Source generation, frame changes, gauges, movement, +precision, restoration and the other two transforms still need their full +cost accounts in any constructive replacement. No new complete kappa follows. + +In particular, for two-point factors +`H=[[A,bA],[cA,A]]` has scalar-identity block shears bI and cI and middle +diagonal blocks A and `(1-bc)A`. A direct tensor circuit applies one local +factor per axis. This simple circuit coexists with full ordinary displacement +rank. The theorem is not a lower bound for the repository's recursive Full +compiler or for all grouped/separable circuits. + +## 7. Failure controls and open next questions + +The verifier deliberately checks these boundaries: + +- With a zero adjacent offdiagonal, the formula can fail: an identity matrix + has Sylvester rank zero and Stein rank one. +- Singular A need not give the asserted full minor rank. +- An axis shift such as `Z_m tensor I_n` is not the full lexicographic shift; + for `A=I_m` its commutator is zero. +- Axis reorderings are not arbitrary coordinate permutations. For two equal + symmetric two-point factors with q=1/2, Gray order `[0,1,3,2]` makes the + matrix ordinary Toeplitz and reduces both ranks from four to two. +- A direct local-factor tensor circuit reproduces the matrix despite the + large global rank. + +Three concrete remaining questions are quantitative stability of these rank +minors under the retained rounding errors; source-faithful grouped algorithms +using multilevel structure instead of one ordinary displacement; and the effect +of the paid gauges, actual Reference and hole completion on that algorithm. +The first requires singular-value or inverse-minor bounds, not just nonzero +determinants. The latter two require the actual inherited source and complete +movement/precision budget. None is settled by this package. + +## 8. Source context, novelty scope and credit + +The source manifests pin the source sections and selected record. Relevant +predecessors include the Beatty-run inverse in +[CrocSwap/integer-mult-bounds#5566](https://github.com/CrocSwap/integer-mult-bounds/pull/5566), +the fine-grid Toeplitz inverse in +[CrocSwap/integer-mult-bounds#5571](https://github.com/CrocSwap/integer-mult-bounds/pull/5571), +the complete physical periodic inverse in +[CrocSwap/integer-mult-bounds#6905](https://github.com/CrocSwap/integer-mult-bounds/pull/6905), +and the retained shallow Toeplitz construction. Their cost and error results +remain their own; this package supplies the exact flattened representation +calculation and its limitations. The overlap search was bounded and does not +prove literature-wide novelty. + +Classical background is Vadim Olshevsky, Ivan Oseledets and Eugene Tyrtyshnikov, +[*Tensor properties of multilevel Toeplitz and related matrices*](https://www2.math.uconn.edu/~olshevsky/papers/tenprop_revision2.pdf). +That work distinguishes tensor properties from one-dimensional displacement +structure. This package does not claim to introduce either concept. + +Prepared for @CubeJerry with substantial OpenAI ChatGPT assistance. Two +independent derivations supplied the boundary-minor argument and its extension +from two-point factors to arbitrary Toeplitz sections. Exact finite checks are +failure controls for the written all-size proof, not a substitute for it. +Apache-2.0, retaining predecessor attribution. diff --git a/research/tensor-gaussian-displacement-rank/README.md b/research/tensor-gaussian-displacement-rank/README.md new file mode 100644 index 0000000000..bf12f30f33 --- /dev/null +++ b/research/tensor-gaussian-displacement-rank/README.md @@ -0,0 +1,156 @@ +# Exact generator count for lexicographically flattened Gaussian tensors + +**No new kappa. A scoped all-size representation theorem; no runtime lower +bound or foundational assumption discharge.** + +For a tensor of invertible Toeplitz factors, ordinary displacement rank can +grow with all the nonfastest dimensions even though the tensor is separable. +This package determines that growth exactly for normalized shifted Gaussian +sections and their inverses, and converts it into the exact minimum number +of ordinary lower-times-upper triangular Toeplitz generator terms. + +## Result and why it matters + +Let `B_i[j,k]=q_i^((j-k)^2) v_i^(j-k)`, with `00`, and factor +dimensions `n_i>=2`. Put `H=B_1 tensor ... tensor B_g` and `T=product n_i`. +With the last tensor index fastest and Z the ordinary strict lower shift of +size T, each of + +\[ + \operatorname{rank}(HZ-ZH),\quad + \operatorname{rank}(H-ZHZ^{\mathsf T}),\quad + \operatorname{rank}(H^{-1}Z-ZH^{-1}),\quad + \operatorname{rank}(H^{-1}-ZH^{-1}Z^{\mathsf T}) +\] + +is exactly `2T/n_g`. The best lexicographic axis ordering therefore gives +`2T/max_i n_i`. Both H and its inverse require exactly that many terms in +an ordinary `sum L(u) U(v)` representation. In particular, two-point factors +have full displacement rank in every lexicographic axis order. + +The stronger underlying theorem allows any invertible outer matrix A and +any Toeplitz fastest factor B: a selected `2m`-square boundary minor has +determinant `(-b_-1^2)^m det(A)^2` for the Sylvester displacement and +`(-b_-1 b_1)^m det(A)^2` for the Stein displacement. Thus the forward claims +need only the relevant nonzero adjacent coefficients. The inverse Stein +conclusion additionally uses tensor persymmetry. [PROOF.md](PROOF.md) gives +the complete all-size argument and a Vandermonde proof of Gaussian +invertibility. + +The retained one-dimensional shallow inverse uses short ordinary Toeplitz +generator sums. The result identifies the exact representation cost of +transplanting that formula to a flattened tensor. It prevents confusing +tensor rank one with constant ordinary displacement rank. It leaves direct +separable circuits and different grouped algorithms available. + +## Source binding and scope + +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. Exact Git blobs and SHA256 +digests are in [SOURCES.json](SOURCES.json). These files are historical +provenance, not runtime inputs: the standalone verifier uses only its own +literal rational fixtures. The original task card and scope change are in +[TASK.json](TASK.json). + +The normalized shifted kernel is from section 2 of +`research/capped-fusion-t74-k554/outer/GAUGEFREE-INTERIORS.md`; the ordinary +inverse generator formula is from section 5 of +`research/capped-phase-fusion/SHALLOW-TOEPLITZ.md`. The source's actual paid +gauges and conditioning requirements remain in force. The theorem also +applies to an exact truncated/rounded Toeplitz table if its invertibility and +nonzero adjacent coefficients are established separately; PROOF.md states +a sufficient structure-preserving perturbation test. + +The selected #7000 record has conditional kappa +`363005817/100000000000` and five retained assumptions. All five remain. +This package is an analytic-recovery representation audit, not an admission +of a new grouped service or an unconditional multiplication result. + +The following exclusions are substantive: + +- No lower bound for recursive Full, separable circuits, arbitrary grouping, + or complete multiplication runtime. A direct local-axis circuit coexists + with maximal ordinary displacement rank. +- No minimum over arbitrary coordinate permutations. A four-coordinate Gray + order reduces both ranks from four to two in a checked example. +- No approximate-rank or finite-precision lower bound from exact nonzero + determinants alone. +- No automatic rank identity for diagonally gauged source blocks, the full + periodic Reference, holes, or unstructured rounded matrices. + +## Reproduce + +From the repository root: + +```sh +python3 -I -W error -B research/tensor-gaussian-displacement-rank/verify.py +python3 -I -O -W error -B research/tensor-gaussian-displacement-rank/verify.py +python3 scripts/research_package.py --package research/tensor-gaussian-displacement-rank --check-only +python3 scripts/research_package.py --package research/tensor-gaussian-displacement-rank +``` + +The first two commands were executed on Python 3.12.14 and return identical +JSON with `status: PASS`. The registered hook declares the repository's +Python 3.12 generic environment and has no third-party requirements. + +The bounded domain is 48 rational generic cases with `1<=m<=3`, +`2<=n<=5`, four fixtures per size, seed 641; 47 have invertible B and also +check the inverse Sylvester identity. Eleven Gaussian tensors have dimensions +`(2)`, `(3)`, `(4)`, `(2,2)`, `(2,3)`, `(3,2)`, `(3,3)`, `(2,4)`, `(4,2)`, +`(2,2,2)`, `(2,2,3)`. All four ranks, Gaussian determinants, inverse residuals, +persymmetry and 22 minimum-generator reconstructions are checked. All six +axis orders of a distinct-factor `(2,3,2)` tensor are checked separately. + +Ranks use exact rational row reduction. Selected minor determinants use +denominator-cleared integer Bareiss elimination. Literal shift-matrix +products are compared with independently indexed entry formulas. Six +negative/scope controls cover zero adjacent coefficients, singular outer +factors, the wrong axis shift, a Gray permutation, a direct tensor circuit, +and deliberate wrong-rank rejection. Checks use explicit exceptions and +remain active under optimized Python. These finite controls do not replace +the written universal proof, and no random or finite search is claimed +to cover all matrices. + +## Relationship to predecessor work + +The Beatty-run inverse in [#5566](https://github.com/CrocSwap/integer-mult-bounds/pull/5566), +fine-grid inverse in [#5571](https://github.com/CrocSwap/integer-mult-bounds/pull/5571), +and physical periodic inverse in [#6905](https://github.com/CrocSwap/integer-mult-bounds/pull/6905) +provide different one-axis application and error contracts. This package +does not duplicate or replace them. It adds the exact flattened ordinary +displacement calculation, matching generator minimum, and scope controls. +The previously familiar factor-of-axes serial scan budget is not claimed +as a new result. Bounded repository overlap searches and these selected +predecessor reads found no matching exact theorem; this is not a claim of +literature-wide priority. + +Classical background: Olshevsky, Oseledets and Tyrtyshnikov, +[*Tensor properties of multilevel Toeplitz and related matrices*](https://www2.math.uconn.edu/~olshevsky/papers/tenprop_revision2.pdf). +Tensor structure and displacement structure are established concepts. + +## Open next questions + +1. Can retained source perturbations admit a quantitative lower bound for the + selected minors? This would determine whether the exact obstruction has + a useful approximate analogue. Start by bounding the inverse boundary + minor or its smallest singular value; exact determinants alone do not + provide a usable precision threshold. +2. Can a source-faithful grouped inverse exploit multilevel structure with a + complete fixed-tape budget? Start with one grouped block and charge source + generation, all gauge/frame changes, restoration, precision and movement. + The ordinary generator obstruction does not rule out this route. +3. Can such a grouped operation compose with the actual periodic Reference + and hole completion? First bind it to the exact #6905 physical consumer + rather than substituting its normalized core. The source-to-consumer and + full three-transform budgets remain open. + +The structured versions of these questions are in TASK.json. + +## Credit + +Prepared for @CubeJerry with substantial OpenAI ChatGPT assistance. The +orchestrator and research worker independently derived the boundary-minor +argument; the orchestrator extended the initial two-point calculation to +arbitrary Toeplitz sections, and the worker independently checked and +packaged the extension. Retain the originating source authors' credit, +including Vlado Vojdanovski's capped-phase-fusion work and the cited +predecessor packages. New files are Apache-2.0. diff --git a/research/tensor-gaussian-displacement-rank/REVIEW.md b/research/tensor-gaussian-displacement-rank/REVIEW.md new file mode 100644 index 0000000000..6c2d3a76af --- /dev/null +++ b/research/tensor-gaussian-displacement-rank/REVIEW.md @@ -0,0 +1,74 @@ +# Independent mathematical review: flattened Gaussian displacement rank + +Reviewed: `worker-a/research/tensor-gaussian-displacement-rank/PROOF.md`. +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +Method: independent entrywise algebra and rank-factorization argument; +the package verifier was neither read nor used for this review. + +**Outcome: the stated all-size algebraic theorem and its scoped generator +corollary are correct. No substantive mathematical defect found.** + +## Boundary minors + +With row index `(a,i)` and column index `(b,j)`, fast B coordinate last, +`(HZ-ZH)` cancels whenever `i>0` and `j0` cancel. Selecting +fast0,1 gives blocks `b0(A-Z_m A Z_m^T)`, `RA`, `AS`,0, with +`S=b_1 I-b_(-(n-1))Z_m^T`. Swapping the two m-column blocks has sign +`(-1)^(m^2)=(-1)^m`; the determinant is exactly +`(-b_-1 b_1)^m det(A)^2`. Thus both stated nonzero minors are valid over +an arbitrary field under their respective assumptions. + +Minor wording clarification recommended: in section2.1, replace “its +determinant” after the sentence about R with “the determinant of this +2m-by-2m minor.” The displayed determinant is that of the block minor, +whereas `det R=b_-1^m`. The intended mathematics is unambiguous from the +display, but the pronoun currently permits the wrong antecedent. + +## Inverse Stein orientation and persymmetry + +The Sylvester identity follows directly by multiplying +`-H^-1(HZ-ZH)H^-1`. For the Stein identity, pivoting respectively on H and +H^-1 in `[[H,Z],[Z^T,H^-1]]` gives the two ranks +`N+rank(H^-1-Z^T H^-1 Z)` and `N+rank(H-ZHZ^T)`. This validates the +reverse-shift statement for general invertible H. + +For a tensor of Toeplitz factors, full reversal is the tensor of factor +reversals and gives `JHJ=H^T`, hence `JH^-1J=H^-T`. Conjugating the +same-shift inverse Stein displacement by J and then transposing gives +exactly `H^-1-Z^T H^-1 Z`. Consequently same-shift rank equality is +correct in the stated persymmetric tensor setting; the proof correctly +avoids extending it merely from arbitrary invertible A. + +## Gaussian nonsingularity and generator minimality + +The Gaussian diagonal/Vandermonde factorization is exact. Each pair i 0, "Gaussian Vandermonde determinant") + + +def reconstruct_generators(a): + """Recover the minimum ordinary generator count by rank factorization.""" + e = entry_displacements(a)[1] + reduced, pivots = rref(e) + c = [[row[j] for j in pivots] for row in e] + r = reduced[:len(pivots)] + require(multiply(c, r) == e, "rank factorization residual") + n = len(a) + recovered = zeros(n) + for k in range(len(pivots)): + u = [c[i][k] for i in range(n)] + v = r[k] + lower = [[u[i - j] if i >= j else F(0) for j in range(n)] for i in range(n)] + upper = [[v[j - i] if j >= i else F(0) for j in range(n)] for i in range(n)] + term = multiply(lower, upper) + require(entry_displacements(term)[1] == [[x * y for y in v] for x in u], + "single generator displacement") + recovered = add(recovered, term) + require(recovered == a, "Toeplitz generator reconstruction residual") + return len(pivots) + + +def generic_controls(): + rng = random.Random(641) + count, inverse_count = 0, 0 + for m in range(1, 4): + for n in range(2, 6): + for _ in range(4): + a = [[F(rng.randint(-3, 3), rng.randint(1, 3)) for _ in range(m)] + for _ in range(m)] + a = add(a, scale(identity(m), F(20))) + da = determinant(a) + require(da != 0, "fixture A unexpectedly singular") + coeff = {k: F(rng.choice((-3, -2, -1, 1, 2, 3)), rng.randint(1, 4)) + for k in range(1 - n, n)} + b = [[coeff[i - j] for j in range(n)] for i in range(n)] + h = kron(a, b) + d, e = displacements(h) + require((d, e) == entry_displacements(h), "literal shift orientation") + require(rank(d) == rank(e) == 2 * m, "general forward rank") + r = sub(scale(identity(m), coeff[-1]), scale(shift(m), coeff[n - 1])) + s = sub(scale(identity(m), coeff[1]), scale(transpose(shift(m)), coeff[1 - n])) + dc = [i * n for i in range(m)] + [i * n + n - 1 for i in range(m)] + ec = [i * n for i in range(m)] + [i * n + 1 for i in range(m)] + dm, em = select(d, dc), select(e, ec) + require(dm == block(multiply(r, a), scale(sub(multiply(a, shift(m)), + multiply(shift(m), a)), coeff[0]), zeros(m), scale(multiply(a, r), F(-1))), + "Sylvester boundary minor entries") + require(em == block(scale(sub(a, multiply(multiply(shift(m), a), + transpose(shift(m)))), coeff[0]), multiply(r, a), multiply(a, s), zeros(m)), + "Stein boundary minor entries") + require(determinant(dm) == (-coeff[-1] ** 2) ** m * da ** 2, + "Sylvester boundary minor determinant") + require(determinant(em) == (-coeff[-1] * coeff[1]) ** m * da ** 2, + "Stein boundary minor determinant") + if determinant(b): + hi = inverse(h) + di = entry_displacements(hi)[0] + require(di == scale(multiply(multiply(hi, d), hi), F(-1)), + "inverse Sylvester identity") + require(rank(di) == 2 * m, "inverse Sylvester rank") + inverse_count += 1 + count += 1 + return count, inverse_count + + +def gaussian_controls(): + dimensions = [(2,), (3,), (4,), (2, 2), (2, 3), (3, 2), (3, 3), + (2, 4), (4, 2), (2, 2, 2), (2, 2, 3)] + count, generator_count = 0, 0 + qs, vs = [F(1, 2), F(2, 3), F(1, 3)], [F(2, 3), F(3, 2), F(2)] + for dims in dimensions: + factors = [gaussian(n, qs[i % 3], vs[i % 3]) for i, n in enumerate(dims)] + for i, a in enumerate(factors): + check_gaussian_det(a, qs[i % 3]) + h = tensor(factors) + hi = inverse(h) + expected = 2 * len(h) // dims[-1] + for x in (h, hi): + d, e = displacements(x) + require((d, e) == entry_displacements(x), "Gaussian literal shift orientation") + require(rank(d) == rank(e) == expected, "Gaussian tensor forward/inverse ranks") + require([list(reversed(row)) for row in reversed(x)] == transpose(x), + "tensor persymmetry") + require(reconstruct_generators(x) == expected, "minimum generator construction") + generator_count += 1 + z = shift(len(h)) + reverse = sub(hi, multiply(multiply(transpose(z), hi), z)) + require(rank(reverse) == rank(entry_displacements(h)[1]), "Schur-complement rank identity") + count += 1 + # Distinct factors, all six lexicographic axis orders; no arbitrary permutation claim. + factors = [gaussian(2, F(1, 2), F(2)), gaussian(3, F(1, 3), F(3, 2)), + gaussian(2, F(2, 3), F(2, 3))] + ranks = [] + for order in permutations(range(3)): + h = tensor([factors[i] for i in order]) + expected = 2 * len(h) // len(factors[order[-1]]) + for x in (h, inverse(h)): + require(tuple(map(rank, entry_displacements(x))) == (expected, expected), + "axis-order rank formula") + ranks.append(expected) + require(min(ranks) == 8, "optimal lexicographic axis order") + return count, generator_count, len(ranks) + + +def failure_controls(): + controls = [] + # Missing adjacent coefficients and singular outer factor must not be accepted. + d, e = displacements(identity(6)) + require((rank(d), rank(e)) == (0, 1), "identity negative control") + controls.append("zero-adjacent-coefficients") + a = [[F(1), F(2)], [F(2), F(4)]] + h = kron(a, gaussian(2, F(1, 2), F(2))) + require(all(rank(x) < 4 for x in displacements(h)), "singular A negative control") + controls.append("singular-outer-factor") + h = kron(identity(2), gaussian(3, F(1, 2), F(1))) + wrong = kron(shift(2), identity(3)) + require(rank(sub(multiply(h, wrong), multiply(wrong, h))) == 0, + "wrong-axis shift control") + require(rank(displacements(h)[0]) == 4, "full shift distinction") + controls.append("axis-shift-is-not-full-shift") + b = gaussian(2, F(1, 2), F(1)) + h = kron(b, b) + gray = select(h, [0, 1, 3, 2]) + require(tuple(map(rank, displacements(h))) == (4, 4), "lexicographic baseline") + require(tuple(map(rank, displacements(gray))) == (2, 2), "Gray-order scope control") + controls.append("arbitrary-coordinate-permutation-can-reduce-rank") + factors = [gaussian(2, F(1, 2), F(1)), gaussian(2, F(1, 3), F(2)), + gaussian(2, F(2, 3), F(3, 2))] + product = identity(8) + for axis in range(3): + local = tensor([factors[i] if i == axis else identity(2) for i in range(3)]) + product = multiply(local, product) + require(product == tensor(factors), "direct separable circuit control") + require(tuple(map(rank, displacements(product))) == (8, 8), "high rank with cheap circuit") + controls.append("separable-circuit-despite-full-displacement-rank") + # Force an intentionally false formula through the same explicit check path. + caught = False + try: + require(rank(displacements(product)[0]) == 7, "deliberately wrong rank") + except VerificationError: + caught = True + require(caught, "failure detection was disabled") + controls.append("wrong-rank-rejected-under-optimized-python") + return controls + + +def main(): + generic, inverse_generic = generic_controls() + gaussian_cases, generators, axis_orders = gaussian_controls() + controls = failure_controls() + result = { + "status": "PASS", "arithmetic": "exact fractions; integer Bareiss minors", + "seed": 641, "generic_forward_cases": generic, + "generic_inverse_sylvester_cases": inverse_generic, + "gaussian_tensor_cases": gaussian_cases, + "minimum_generator_reconstructions": generators, + "distinct_axis_orders": axis_orders, "negative_controls": controls, + "claim_scope": "finite controls for PROOF.md; no kappa or runtime lower bound" + } + print(json.dumps(result, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main()