Alphabeta Math
Pipeline-generated
How statement and proof provenance work

The first chip identifies the source of the statement or construction; the second identifies the source of its local proof or verification.

  • Literature-sourced: the exact statement appears in a cited source; only wording and notation differ.
  • AI-adapted: a semantically identical restatement of literature-sourced material, modulo indexing, notation, and boundary cases adopted by the library.
  • AI-generated: a genuinely novel statement formulated by AI, with no source for the claim itself.

These labels describe origin, not correctness: citations and verification chips remain separate evidence.

✓ 10 results · all verified · 5 also independently AI-judged
Every result on this page is machine-checked by a proof checker and read in full and owner-audited; the judge is an additional, independent cross-model AI review of the proofs. The 5 not AI-judged were verified by owner audit (typically over a confirmed judge false positive), not failures.

Hierarchical low rank matrices and error propagation

1 · Prerequisites

2 · Summary

For a finite matrix, the page first fixes ordered cluster trees, geometric admissibility, and a recursive block partition. Near blocks stay dense. Each admissible far block in an H representation is assumed to have rank at most the declared cap; admissibility alone does not prove that rank bound. The Cauchy example A separated Cauchy block has a geometric rank bound proves one explicit separated-kernel rank estimate.

Core-SVD recompression uses the compact factors without forming a dense block. Bottom-up recompression processes a factor-sum tree for each admissible block, retaining the sum of local discarded-tail bounds. The block matvec is exact for the represented matrix. Addition and product use fixed compatible partitions and local Frobenius tolerances; their global Frobenius error bounds follow from the disjoint block supports and the product perturbation identity in Blockwise Frobenius errors propagate by disjoint block sums.

The complexity claims require the stated balanced tree and bounded-partition counts. Under those hypotheses, H storage and matvec cost are O(knlog⁡(2n/k)); nested H² bases with O(n/k) total transfers and interactions give O(kn) storage and matvec cost. The addition and product procedures do not receive the same rank-linear complexity claim.

For factorization, Compress exact block LU factors with local tolerances compresses supplied exact block LU factors and retains each local discarded-tail bound. Compressed block LU factors have a residual and inverse certificate turns these into a residual and inverse-error certificate when ∥A−1∥2η<1. This is an exact-arithmetic result; it does not claim to construct an H-LU factorization or certify floating-point residual computations.

The schematic below has two leaf clusters I0,I1. It assumes the diagonal pairs fail admissibility and the two cross pairs pass it. Gray cells are dense near blocks; blue cells are represented by factors of rank at most k. The picture illustrates the definitions only; every proof uses the block entries and factor formulas.

\begin{tikzpicture}[
  block/.style={draw,minimum width=3.7cm,minimum height=1.05cm,align=center},
  every node/.style={font=\small}
]
\node[block,fill=gray!15] at (0,1.1) {row I0 × column I0\\dense D00 (near)};
\node[block,fill=blue!10] at (4,1.1) {row I0 × column I1\\U01 V01* (rank at most k)};
\node[block,fill=blue!10] at (0,-0.1) {row I1 × column I0\\U10 V10* (rank at most k)};
\node[block,fill=gray!15] at (4,-0.1) {row I1 × column I1\\dense D11 (near)};
\node at (-2.35,1.1) {row I0};
\node at (-2.35,-0.1) {row I1};
\node at (0,2.0) {column I0};
\node at (4,2.0) {column I1};
\end{tikzpicture}

3 · Logical flowchart

4 · Definitions, theorems and proofs

DefinitionDefinition: AI-adaptedProof: Not applicableOpen item page →

Finite cluster trees and geometric admissibility

Definition

Let I be a nonempty finite totally ordered set, let d≥1, and assign a point ξi∈Rd to each i∈I. A cluster is a nonempty subset of I. For a cluster τ, write Xτ={ξi:i∈τ}, diam⁡(τ)=max⁡i,j∈τ∥ξi−ξj∥2, and dist⁡(τ,σ)=min⁡i∈τ,j∈σ∥ξi−ξj∥2. These extrema exist because the index sets are finite and nonempty; repeated geometric points are allowed.

A balanced cluster tree with leaf threshold b, where 1≤b≤∣I∣, is the rooted binary tree whose root is I, whose children of an internal cluster τ are its first ⌊∣τ∣/2⌋ and last ⌈∣τ∣/2⌉ indices in the fixed order, and which stops splitting at clusters of size at most b. Its two children are disjoint and their union is τ.

For the column side, let J be a nonempty finite totally ordered set, assign points ζj∈Rd for j∈J, and build its balanced cluster tree by the same rule with its own threshold 1≤bJ≤∣J∣. Column clusters are nonempty subsets σ⊆J, with Xσ={ζj:j∈σ} and diam⁡(σ)=max⁡j,j′∈σ∥ζj−ζj′∥2. For a row cluster τ⊆I and a column cluster σ⊆J, set dist⁡(τ,σ)=min⁡i∈τ,j∈σ∥ξi−ζj∥2. Row and column roles distinguish the assignments even when the index sets overlap. In the square case with a common point assignment, take J=I and ζi=ξi.

Fix an admissibility parameter η>0. A pair of clusters (τ,σ) is admissible when dist⁡(τ,σ)>0 and dist⁡(τ,σ)≥ηmax⁡(diam⁡(τ),diam⁡(σ)). The strict positive-distance condition keeps coincident or intersecting clusters in the near field, including diagonal singleton blocks.

The block-cluster tree starts at (I,J). It stops at a pair if that pair is admissible or if both clusters are leaves. Otherwise, if only one cluster is nonleaf, it splits that cluster. If both are nonleaf, it splits the cluster of larger cardinality; ties are resolved by splitting the row cluster. The children of a split are the corresponding child-cluster pairs. Its terminal pairs are called block-cluster leaves. Admissible leaves are far blocks; nonadmissible leaves, which have two leaf clusters, are near blocks.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passOpen item page →

Size and depth of a balanced cluster tree

Statement

Let I be a finite ordered set of size n≥1, and let b be an integer with 1≤b≤n. In the balanced cluster tree of Finite cluster trees and geometric admissibility, every cluster at depth h has size at most ⌈n/2h⌉. The tree has depth at most ⌈log⁡2(n/b)⌉, at most 2n/b leaves, and at most 4n/b−1 nodes.

Facts & Assumptions

Given: The finite ordered index set I, its size n, the leaf threshold b, and the balanced cluster tree.

[F1]

Finite cluster trees and geometric admissibility: each cluster larger than b splits into two disjoint children of sizes ⌊m/2⌋ and ⌈m/2⌉, and clusters of size at most b are leaves.

Proof

1.1givenF1inductionalgebra

At depth zero the root has size n=⌈n/20⌉. If a cluster at depth h has size at most ⌈n/2h⌉, each child has size at most ⌈⌈n/2h⌉/2⌉=⌈n/2h+1⌉, since the split sizes differ by at most one. Induction proves the size bound at every depth.

2.1givenF1step 1.1algebra

Put H=⌈log⁡2(n/b)⌉. Then 2H≥n/b, so ⌈n/2H⌉≤b. By step 1.1 every cluster at depth H has size at most b and is a leaf; hence the tree depth is at most H.

3.1givenF1algebra∎

If a leaf is not the root, its parent has an integer size m>b, so the smaller child has size ⌊m/2⌋≥⌊(b+1)/2⌋≥b/2. The same lower bound on leaf size holds when the root is a leaf because then there is one leaf and n≥b/2. Since the leaves partition I, their number L satisfies Lb/2≤n, hence L≤2n/b. A full binary tree with L leaves has L−1 internal nodes, so it has 2L−1≤4n/b−1 nodes.

Remarks

The bounds include b=1 and b=n. For b=n the root alone is a leaf; for b=1 every leaf is a singleton.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passOpen item page →

Block-cluster leaves partition the index-pair set

Statement

Let I,J be nonempty finite index sets with finite cluster trees, and construct the block-cluster tree as in Finite cluster trees and geometric admissibility. Its terminal rectangles τ×σ are pairwise disjoint and their union is I×J.

Facts & Assumptions

Given: Finite row and column cluster trees and the recursive block-cluster construction.

[F1]

Finite cluster trees and geometric admissibility: children of a cluster are disjoint and cover the parent; a block pair is stopped exactly when it is admissible or both clusters are leaves, and otherwise one nonleaf cluster is split into its child pairs.

Proof

1.1givenF1algebra

If a block node (τ,σ) is split on the row side, its child rectangles (τi,σ) are disjoint and cover τ×σ because the τi partition τ. If it is split on the column side, the rectangles (τ,σj) are disjoint and cover τ×σ because the σj partition σ. Thus every split replaces a block by a disjoint cover of that block.

2.1givenF1step 1.1induction

Each split increases the depth of one cluster in a finite tree, so along every branch the sum of the remaining row and column depths decreases and the recursion terminates. Induct on this finite sum: a terminal node is its own terminal cover; a nonterminal node has children whose terminal covers partition their respective rectangles by the induction hypothesis, and step 1.1 shows that their union is a disjoint cover of the parent rectangle. Applying this to the root (I,J) proves that the terminal rectangles partition I×J.

3.1step 1.1step 2.1∎

Two distinct terminal rectangles lie in different children of their first common split, whose rectangles are disjoint by step 1.1. Hence all terminal rectangles are pairwise disjoint, completing the partition claim.

AlgorithmAlgorithm: Literature-sourcedProof: Not applicablejudge pass (gpt-6-luna)Open item page →

Core-SVD recompression with rank and error tolerances

Definition

Input: A field F∈{R,C}, positive integers m,n, a finite factor list Us∈Fm×rs and Vs∈Fn×rs representing M=∑sUsVs∗, a rank cap 0≤k≤min⁡(m,n), and a Frobenius tolerance δ≥0. The conjugate transpose M∗ and Frobenius norm are those of Finite tensor arrays and the Frobenius inner product.

Procedure: Concatenate the factors as U=[U1 ⋯ Up] and V=[V1 ⋯ Vp], so M=UV∗. Take compact singular value decompositions U=QURU and V=QVRV, where the columns of QU,QV are orthonormal and span the respective column spaces. Form the core C=RURV∗ and compute an SVD C=PΣQ∗. Let its positive singular values be s1≥⋯≥st>0. Find the smallest q∈{0,…,min⁡(k,t)} for which eq:=(∑j>qsj2)1/2≤δ. If no such q exists, return tolerance-not-met. Otherwise return success with factors U^=QUP[:,1:q]Σq and V^=QVQ[:,1:q], where Σq=diag⁡(s1,…,sq), and the exact discarded-tail certificate eq; when q=0, use empty m×0 and n×0 factors.

The compact decompositions retain only positive singular directions. If the factor list is empty or its represented matrix is zero, then t=0 and the procedure returns the rank-zero representation because δ≥0. Any SVD choices in repeated singular subspaces are permitted. No result is returned when the requested cap cannot certify the tolerance.

DefinitionDefinition: Literature-sourcedProof: Not applicableOpen item page →

H-matrix block representation

Definition

Let F∈{R,C}, let I,J be nonempty finite index sets with point assignments as in Finite cluster trees and geometric admissibility, and let P be the block-cluster leaves of Block-cluster leaves partition the index-pair set. Fix an integer rank cap k≥1. An H-matrix representation with cap k assigns to each far block b=(τ,σ)∈P factors Ub∈Fτ×rb and Vb∈Fσ×rb with 0≤rb≤k, representing that block by UbVb∗. Each near block is stored as its full dense matrix Db∈Fτ×σ. Since P partitions I×J, these blocks determine a unique represented matrix A~∈FI×J.

The rank cap on far blocks is an assumption about the representation or the target's approximability; geometric admissibility alone does not imply that a given matrix block has low rank. Near blocks remain dense and receive no low-rank guarantee.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-luna)Open item page →

Core-SVD recompression is best at the declared Frobenius tolerance

Statement

Let M=∑sUsVs∗ be the finite matrix input to Core-SVD recompression with rank and error tolerances, and let k and δ≥0 be its rank cap and Frobenius tolerance. If the algorithm returns success with rank q, its returned matrix M^ has rank q and satisfies ∥M−M^∥F=(∑j>qsj(M)2)1/2≤δ. No lower-rank matrix meets the same tolerance. If the algorithm returns tolerance-not-met, no matrix of rank at most k meets the tolerance.

Facts & Assumptions

Given: Finite real or complex factor matrices Us,Vs, their represented matrix M, an integer rank cap k, a tolerance δ≥0, and the procedure and status returned by Core-SVD recompression with rank and error tolerances.

[F1]

Core-SVD recompression with rank and error tolerances: the procedure forms C=RURV∗ from compact SVDs of the concatenated factors, takes an SVD of C, selects the smallest q≤k whose discarded singular-value tail is at most δ, and reports that tail as eq.

[F2]

Every linear map between finite-dimensional real or complex inner product spaces admits a singular value decomposition: every finite real or complex matrix has an SVD with orthonormal left and right singular vectors and nonnegative singular values.

[F3]

Finite tensor arrays and the Frobenius inner product: matrix rank is the dimension of the column image, the Frobenius norm is the square root of the sum of squared entry moduli, and M∗ is the conjugate transpose.

[F4]

Best rank-k matrix approximation in Frobenius norm: the rank-at-most-r truncated SVD has Frobenius error equal to the square root of the discarded squared singular values, and every rank-at-most-r matrix has at least that error.

Proof

1.1F1F2F3algebra

The compact SVDs in [F1] give U=QURU and V=QVRV with orthonormal columns in QU,QV. Hence M=QU(RURV∗)QV∗=QUCQV∗. If C=PΣQ∗ is its SVD, then M=(QUP)Σ(QVQ)∗; both outer factors have orthonormal columns, so completing them by orthonormal bases gives an SVD of M. Thus the core and M have the same positive singular values.

2.1F1F2F3F4step 1.1algebra∎

On success, the output factors in [F1] form the rank-q truncation of the lifted SVD in step 1.1. Its retained singular values are positive and their singular vectors are orthonormal, so its rank is exactly q. Applying [F4] gives ∥M−M^∥F=(∑j>qsj(M)2)1/2≤δ. By the minimal choice in [F1], every smaller r<q has discarded tail greater than δ; [F4] then rules out every rank-at-most-r approximation meeting the tolerance. If the algorithm fails, then k<t and the tail at k is greater than δ (otherwise q=k would pass); [F4] rules out every rank-at-most-k approximation. This includes q=0, k=0, zero factors, and repeated singular values.

DefinitionDefinition: Literature-sourcedProof: Not applicablejudge pass (gpt-6-luna)Open item page →

Nested H² cluster bases and interaction lists

Definition

In the H-matrix setting of H-matrix block representation, an H² representation assigns a row basis Uτ∈Fτ×rτ to every row cluster τ and a column basis Vσ∈Fσ×sσ to every column cluster σ, with 0≤rτ,sσ≤k. For every internal row cluster τ with children τ1,τ2, it stores transfer matrices EτiU∈Frτi×rτ satisfying

Uτ∣τi=UτiEτiU(i=1,2).

For every internal column cluster σ with children σ1,σ2, it stores transfer matrices EσjV∈Fsσj×sσ satisfying Vσ∣σj=VσjEσjV. These identities are the nested-basis conditions. An admissible block leaf (τ,σ) is represented by UτSτσVσ∗ with coupling matrix Sτσ∈Frτ×sσ; near block leaves remain dense.

Let Pfar denote the admissible leaves of the block-cluster partition. The row interaction list of τ is LU(τ)={σ:(τ,σ)∈Pfar}, and the column interaction list of σ is LV(σ)={τ:(τ,σ)∈Pfar}. An H² representation may impose a bound on these list lengths or on their total count; any complexity theorem must state which bound it uses.

Storage convention: Store the basis arrays explicitly only at leaf clusters. Store each internal cluster's child-to-parent transfer matrices; the basis of an internal cluster is reconstructed recursively from its children and these transfers.

AlgorithmAlgorithm: Literature-sourcedProof: Not applicablejudge pass (gpt-6-luna)Open item page →

H-matrix block matrix-vector multiplication

Definition

Input: An H-matrix representation A~ on a finite block-cluster partition P as in H-matrix block representation, and a vector x∈FJ.

Procedure: Initialize y∈FI to zero. For every far block b=(τ,σ) with factors Ub,Vb, compute zb=Vb∗x∣σ and add Ubzb to y∣τ. For every near block with dense entries Db, compute Dbx∣σ and add it to y∣τ. Return y. All arithmetic is exact; contributions to a row cluster are summed over its block leaves.

AlgorithmAlgorithm: Literature-sourcedProof: Not applicablejudge pass (gpt-6-luna)Open item page →

Bottom-up low-rank recompression of block contributions

Definition

Let b=(τ,σ) be an admissible leaf of the finite block-cluster partition in H-matrix block representation. A factor-sum tree for b is a finite rooted binary tree whose leaves carry factor pairs Uv∈Fτ×rv, Vv∈Fσ×rv for exact contributions Mv=UvVv∗; each internal node denotes the sum of the exact matrices denoted by its two children. Here F∈{R,C}, ∗ is conjugate transpose, and all factors have the displayed finite dimensions.

Input: Such a tree, a rank cap k≥1, node tolerances θv≥0 whose sum over all nodes is at most a requested block tolerance δb≥0, and the procedures/results Core-SVD recompression with rank and error tolerances and Core-SVD recompression is best at the declared Frobenius tolerance.

Procedure: Traverse the tree in postorder. At a leaf, pass its exact factor pair to core-SVD recompression. At an internal node, concatenate the returned child factor pairs, which represents the sum of the two child approximations, and pass that pair to core-SVD recompression. At every node use effective core cap kb=min⁡(k,∣τ∣,∣σ∣) and tolerance θv. If any call returns tolerance-not-met, return that status and node. On success, retain its factors and exact discarded-tail norm ρv. Define the node's reported error bound by ev=ρv at a leaf and ev=ev1+ev2+ρv at an internal node. If all calls succeed, return the root factors and eroot. Then the root matrix has rank at most k and its Frobenius error from the sum of all leaf contributions is at most eroot≤∑vθv≤δb. A failed call means only that this chosen tree and its assigned local budgets did not produce a certificate; it does not assert that no rank-k approximation of the full sum meets δb.

Near blocks are not passed to this routine: they are assembled and stored densely and exactly. For a leaf carrying a dense contribution D∈Fm×n, use the exact factor pair (D,In), where In is the identity matrix; the routine may then compress it under its assigned tolerance.

The rank and error guarantees are proved in Bottom-up factor-sum recompression has the reported rank and Frobenius error bound ↗.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passOpen item page →

A separated Cauchy block has a geometric rank bound

Statement

Let 0≤a<b, c≥0, and choose m,n≥1 points xi∈[0,a] and yj∈[b,b+c]. Put q=a/b<1 and define the Cauchy block Kij=1/(yj−xi). For any integer r≥1, the matrix K~ with entries K~ij=∑ℓ=0r−1xiℓyj−(ℓ+1) has rank at most r and satisfies ∣Kij−K~ij∣≤qr/(b−a) and ∥K−K~∥F≤mn qr/(b−a). If b−a≥ηmax⁡(a,c) and the H-matrix rank cap satisfies k≥r, the sampled clusters are admissible and K~ is a permitted rank-at-most-k far-block representation.

Facts & Assumptions

Given: The real intervals, their sample points, and the integer truncation order r.

[F1]

Finite cluster trees and geometric admissibility: admissibility requires positive distance and dist⁡(τ,σ)≥ηmax⁡(diam⁡(τ),diam⁡(σ)).

[F2]

Finite tensor arrays and the Frobenius inner product: the matrix Frobenius norm is the square root of the sum of squared entry moduli, and the rank is the dimension of the column image.

[F3]

H-matrix block representation: an admissible H-matrix block is stored as UV∗ with rank at most the declared cap.

Proof

1.1givenalgebra

For z=x/y one has (1−z)∑ℓ=0r−1zℓ=1−zr. Since y−x>0, division by y(1−x/y) gives the exact identity 1y−x=∑ℓ=0r−1xℓyℓ+1+xryr(y−x).

2.1F2step 1.1algebra

Because 0≤xi/yj≤a/b=q and yj−xi≥b−a, step 1.1 gives ∣Kij−K~ij∣=xir/(yjr(yj−xi))≤qr/(b−a). Each summand of K~ is the outer product of (xiℓ)i=1m and (yj−(ℓ+1))j=1n, so its column image lies in the span of at most r vectors and its rank is at most r.

3.1F1F2F3step 2.1algebra∎

Summing the squared entrywise bound from step 2.1 over the mn entries and using [F2] gives ∥K−K~∥F≤mn qr/(b−a). The sample clusters have distance at least b−a and diameters at most a and c; since b−a>0, the additional inequality in the Statement implies admissibility by [F1]. The rank bound in step 2.1 and k≥r then meet the far-block representation in [F3].

AlgorithmAlgorithm: Literature-sourcedProof: Not applicableOpen item page →

Compress exact block LU factors with local tolerances

Definition

Input: An exact factorization A=LU of a square matrix A∈Fn×n, where F∈{R,C} and n≥1, with L block lower triangular and U block upper triangular on a common ordered cluster partition; an integer rank cap k≥1; and a nonnegative local Frobenius tolerance for each admissible off-diagonal block of L and U. The factorization A=LU is supplied as a hypothesis, not computed by this procedure.

Procedure: Copy every dense nearfield block and every diagonal block exactly. For each strictly lower admissible block Db∈Fmb×nb of L and each strictly upper admissible block Db of U, form the one-pair factor list (Db,Inb), representing Db=DbInb∗, and pass it to Core-SVD recompression with rank and error tolerances with effective cap min⁡(k,mb,nb) and its given local tolerance. Keep structural zero blocks zero. If any compression reports tolerance-not-met, return that status and the factor/block identity. Otherwise return L^,U^ and the local discarded-tail bounds ϵbL,ϵcU reported by the recompressions. The exact diagonal blocks preserve block triangularity; no claim is made that the compressed factors are exact factors of A.

LemmaStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-luna)Open item page →

Bottom-up factor-sum recompression has the reported rank and Frobenius error bound

Statement

Use Bottom-up low-rank recompression of block contributions on a finite factor-sum tree for one admissible block over F∈{R,C}, with exact arithmetic, rank cap k≥1, node tolerances θv≥0, and ∑vθv≤δb. Let Tv be the subtree rooted at v, and let Mv be the sum of its exact leaf contributions. Whenever all calls in Tv succeed, the returned factors represent a matrix M^v of rank at most k, and the reported bound satisfies ∥Mv−M^v∥F≤ev=∑w∈Tvρw≤∑w∈Tvθw. In particular, if the routine succeeds at the root, rank⁡(M^root)≤k,∥Mroot−M^root∥F≤eroot=∑wρw≤∑wθw≤δb. Here ρw is the exact discarded-tail norm returned at node w. A tolerance-not-met status at a node only means this chosen tree and these assigned local budgets did not produce the requested certificate; it does not assert that no rank-k approximation of the exact full sum meets δb.

Facts & Assumptions

Given: A finite factor-sum tree for one admissible block, a cap k, nonnegative local tolerances, and exact arithmetic.

[F1]

Core-SVD recompression with rank and error tolerances: on success, recompresses the supplied factor product and returns the exact discarded singular-value tail ρv with ρv≤θv.

[F2]

Core-SVD recompression is best at the declared Frobenius tolerance: the returned core-SVD factors represent the truncated singular expansion, and their Frobenius residual is exactly the reported tail ρv.

[F3]

Finite tensor arrays and the Frobenius inner product: the Frobenius norm is the Euclidean norm of the finite list of matrix entries, with inner product ⟨X,Y⟩F=∑i,jXij‾Yij.

[F4]

Cauchy–Schwarz: ∣⟨x,y⟩∣≤∥x∥ ∥y∥, with equality exactly for dependent pairs: ∣⟨x,y⟩∣≤∥x∥∥y∥ in a real or complex inner-product space; together with [F3] this gives the Frobenius triangle inequality.

Proof

Every successful node call uses kb=min⁡(k,∣τ∣,∣σ∣) and returns a truncated singular expansion of rank at most kb≤k, by [F1] and [F2]. Clipping the cap changes no feasible matrix rank: every matrix of the block dimensions already has rank at most min⁡(∣τ∣,∣σ∣). The following two steps give the unchanged error induction.

1.1givenF1F2

At a leaf v, the routine compresses its exact contribution Mv; by [F1] and [F2], ∥Mv−M^v∥F=ρv=ev≤θv.

2.1givenF1F2F3F4step 1.1inductionalgebra∎

Suppose v is internal with children v1,v2. Their exact targets add to Mv, and their returned approximations add to the matrix Zv supplied to the core-SVD call. The Frobenius triangle inequality from [F3,F4] gives ∥Mv−Zv∥F≤ev1+ev2. By [F1,F2], ∥Zv−M^v∥F=ρv, hence ∥Mv−M^v∥F≤ev1+ev2+ρv=ev. Step 1.1 is the leaf base case; induction over the finite tree proves the root error bound. The recurrence for ev gives eroot=∑v∈Tρv≤∑v∈Tθv≤δb.

AlgorithmAlgorithm: Literature-sourcedProof: Not applicablejudge pass (gpt-6-luna)Open item page →

Tolerance-controlled H-matrix block addition

Definition

Input: Two H-matrix representations A,B on the same block-cluster partition P, a rank cap k≥1, and for each far block b∈P a factor-sum tree with node tolerances whose total is at most δb≥0. The tree leaves are the exact factors of Ab and Bb.

Procedure: For each near block, store the exact dense sum Ab+Bb and report local error eb=0. For each far block, run Bottom-up low-rank recompression of block contributions on its factor-sum tree with cap k. If any block returns tolerance-not-met, return that status and the block identity; otherwise store the root factors, report the certified error bound eb returned by that routine, and retain the block partition. The input's node budgets sum to at most δb, so eb≤δb by the bottom-up error guarantee.

AlgorithmAlgorithm: Literature-sourcedProof: Not applicableOpen item page →

Tolerance-controlled H-matrix block product

Definition

Input: H-matrix representations A∈FI×K and B∈FK×J, a recursively generated output block-cluster partition as in Finite cluster trees and geometric admissibility, a rank cap k≥1, local tolerances δb≥0 for far output blocks, and for each output block b=(τ,σ) a finite intermediate-cluster family Kb partitioning K such that the restrictions Aτκ and Bκσ are available in dense or factorized form for each κ∈Kb. For a far output block, its factor-sum tree has one exact product term for each κ∈Kb and node tolerances totaling at most δb. This compatibility condition is part of the input.

Procedure: For each output block, use the exact identity Cb=∑κ∈KbAτκBκσ. If the output block is near, form and store this dense sum exactly and report eb=0. For a far output block, convert each product term to factor form: UV∗⋅PQ∗=U(V∗P)Q∗ when both factors are low rank; UV∗⋅D=U(D∗V)∗ and D⋅PQ∗=(DP)Q∗ when one factor is dense; and D1D2=D1(D2∗)∗ when both are dense. These formulas produce factors with matching inner dimensions. Run Bottom-up low-rank recompression of block contributions on the resulting finite factor-sum tree with cap k. If any block returns tolerance-not-met, return that status and block identity; otherwise store the root factors and its certified bound eb≤δb.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-luna)Open item page →

H-matrix block multiplication returns the represented matrix action

Statement

For every H-matrix representation A~∈FI×J on the block-cluster partition of Block-cluster leaves partition the index-pair set and every vector x∈FJ, H-matrix block matrix-vector multiplication returns A~x exactly.

Facts & Assumptions

Given: The represented H-matrix A~, its block-cluster partition, and x∈FJ.

[F1]

H-matrix block representation: each block leaf stores exactly its represented dense or factorized submatrix, and the leaf blocks determine A~.

[F2]

Block-cluster leaves partition the index-pair set: the terminal block rectangles are disjoint and cover I×J.

[F3]

H-matrix block matrix-vector multiplication: for each leaf it computes the stored block times the corresponding subvector and adds that contribution to the corresponding output rows.

Proof

1.1givenF1construct

By [F1], A~ is the matrix obtained by placing its stored block matrices on their index rectangles and putting no entries outside those rectangles.

2.1F2F3step 1.1algebra∎

By [F2], each pair (i,j)∈I×J lies in exactly one leaf rectangle. By [F3], the algorithm adds the contribution A~ijxj to output coordinate i from that leaf, and no other leaf includes that entry. Summing over the finite partition gives yi=∑j∈JA~ijxj for every i∈I, which is exactly y=A~x.

AlgorithmAlgorithm: Literature-sourcedProof: Not applicablejudge pass (gpt-6-luna)Open item page →

Nested-basis H² matrix-vector multiplication

Definition

Input: An H² representation A~ with row bases Uτ, column bases Vσ, transfer matrices from Nested H² cluster bases and interaction lists, and a vector x∈FJ.

Procedure:

  1. Initialize an upward coefficient vector zσ for each column cluster. At each leaf σ, set zσ=Vσ∗x∣σ. At each internal cluster σ with children σ1,σ2, set zσ=∑j=12(EσjV)∗zσj.
  2. Initialize a downward coefficient vector wτ=0 for each row cluster and an output vector y=0. For each admissible leaf (τ,σ), add Sτσzσ to wτ. For each near leaf (τ,σ), add Dτσx∣σ to y∣τ.
  3. Traverse the row tree from root to leaves. For each parent τ and child τi, add EτiUwτ to wτi. At each row leaf τ, add Uτwτ to y∣τ. Return y.

The upward and downward traversals follow the finite cluster trees; block and cluster contributions are accumulated in exact arithmetic.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-luna)Open item page →

Blockwise Frobenius errors propagate by disjoint block sums

Statement

For any finite matrix partition into disjoint blocks, if each local residual satisfies ∥Eb∥F≤δb, then the assembled residual satisfies ∥E∥F≤(∑bδb2)1/2. In particular, let A,B be conformable finite real or complex matrices, and let A~,B~ be approximations with ∥A−A~∥F≤ϵA and ∥B−B~∥F≤ϵB. If a successful block addition or block product from Tolerance-controlled H-matrix block addition or Tolerance-controlled H-matrix block product returns S^ or C^, with disjoint output blocks b and local Frobenius errors eb≤δb, put δ=(∑bδb2)1/2. Then

∥A+B−S^∥F≤ϵA+ϵB+δ,

and

∥AB−C^∥F≤ϵA∥B∥F+∥A∥FϵB+ϵAϵB+δ.

Facts & Assumptions

Given: The target matrices, their H-matrix approximations, successful block-operation outputs, and local block-error budgets.

[F1]

Tolerance-controlled H-matrix block addition and Tolerance-controlled H-matrix block product: near blocks are computed exactly; on success, each far output block has a certified Frobenius error bound eb no larger than its allocated tolerance.

[F2]

Bottom-up factor-sum recompression has the reported rank and Frobenius error bound: for each successful factor-sum tree, the returned block approximation error is at most the sum of its nodewise core-SVD discarded-tail norms, which is bounded by the sum of its node tolerances.

[F3]

Block-cluster leaves partition the index-pair set: every recursively generated terminal block partition is pairwise disjoint and covers the output index-pair set.

[F4]

Finite tensor arrays and the Frobenius inner product: the Frobenius norm is the Euclidean norm of the finite matrix-entry list.

[F5]

Proof

1.1F1F2F3F4algebra

Let Δb be the actual residual in output block b. For near blocks it is zero; for far blocks [F1] and [F2] give ∥Δb∥F≤eb≤δb. By [F3] their entry supports are disjoint, so [F4] gives ∥Δ∥F2=∑b∥Δb∥F2≤∑bδb2. Hence ∥Δ∥F≤δ.

2.1F4F5step 1.1algebra

For addition, write S^=A~+B~+Δ. Expanding the squared Frobenius norm as the finite entry inner product and applying [F5] gives the triangle inequality. Therefore ∥A+B−S^∥F≤∥A−A~∥F+∥B−B~∥F+∥Δ∥F≤ϵA+ϵB+δ.

3.1F4F5step 1.1algebra∎

For multiplication, put EA=A~−A and EB=B~−B. Since C^=A~B~+Δ, expansion gives AB−C^=−(EAB+AEB+EAEB+Δ). For any conformable X,Y, entrywise Cauchy–Schwarz gives ∣(XY)ij∣2≤(∑ℓ∣Xiℓ∣2)(∑ℓ∣Yℓj∣2); summing over i,j gives ∥XY∥F2≤∥X∥F2∥Y∥F2. Thus ∥EAB∥F≤ϵA∥B∥F, ∥AEB∥F≤∥A∥FϵB, and ∥EAEB∥F≤ϵAϵB. The triangle inequality from [F4,F5] and step 1.1 give the stated product bound.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passOpen item page →

Balanced H and H² storage and matvec complexity

Statement

Let I=J have size n, let 1≤k≤n, and use balanced cluster trees with leaf threshold b=k. Let s≥1 be independent of n,k. Assume:

  1. at each level of the block-cluster tree, the far leaves satisfy ∑(τ,σ)(∣τ∣+∣σ∣)≤2sn;
  2. the total number of near leaves is at most s⌈n/k⌉;
  3. the total number of admissible H² coupling blocks is at most s⌈n/k⌉.

Count scalar storage entries and exact scalar arithmetic operations, with constants allowed to depend on s but not on n,k. Then an H-matrix with far-block ranks at most k has storage and matvec work O(sknlog⁡2(2n/k)). An H²-matrix with nested bases of ranks at most k has storage and matvec work O(skn). The bounds depend on the stated block-count assumptions; geometric admissibility alone does not imply them.

Facts & Assumptions

Given: The balanced cluster trees, block-cluster partition, H/H² representations, rank cap k, and the three stated counting hypotheses.

[F1]

Finite cluster trees and geometric admissibility: each internal cluster splits into two children whose sizes differ by at most one, and the block-cluster recursion splits one cluster at a time until admissibility or two leaf clusters.

[F2]

Size and depth of a balanced cluster tree: a threshold-k cluster tree has depth at most ⌈log⁡2(n/k)⌉, at most 2n/k leaves, and at most 4n/k−1 nodes.

[F3]

H-matrix block representation: each admissible H block stores at most k columns in each factor, and each near block is stored densely.

[F4]

Nested H² cluster bases and interaction lists: H² stores at most k columns for each leaf basis, at most k×k entries for each transfer and coupling matrix, and dense near blocks.

[F5]

H-matrix block matrix-vector multiplication and Nested-basis H² matrix-vector multiplication: H matvec applies each far factor through two rank-sized products and each near block densely; H² matvec uses leaf basis products, transfer products, coupling products, and dense near products.

Proof

1.1F1F2algebra

Let h=⌈log⁡2(n/k)⌉. By [F1], each split descends one level in either the row tree or the column tree, whose depths are each at most h by [F2]. Hence the block tree has depth at most 2h. At each level, the first counting hypothesis bounds the total participating far-block side sizes by 2sn.

2.1F1F3step 1.1algebra

Each far H block stores at most k(∣τ∣+∣σ∣) scalar factor entries. Summing over at most 2h+1 levels gives O(skn(h+1)) far storage. Every near block has both cluster sizes at most k by [F1], so it stores at most k2 entries; the second counting hypothesis bounds total near storage by s⌈n/k⌉k2=O(skn) because k≤n. This proves the H storage bound.

3.1F1F3F5step 1.1step 2.1algebra

In [F5], a far-block product first multiplies an rb×∣σ∣ factor by x∣σ and then a ∣τ∣×rb factor by the result, so it costs O(k(∣τ∣+∣σ∣)). A near-block product costs O(∣τ∣∣σ∣)≤O(k2). The same level and near-block counts used in step 2.1 therefore give H matvec work O(skn(h+1))=O(sknlog⁡2(2n/k)).

3.2F2F3F4step 2.1algebra

By the storage convention in [F4], the leaf row and column bases require at most 2kn entries because the leaves partition I and each basis rank is at most k. By [F2], each tree has O(n/k) nodes, so all k×k transfer matrices require O(kn) entries. The third counting hypothesis gives O(kn) entries for all coupling matrices, and step 2.1 bounds dense near blocks by O(skn). Thus H² storage is O(skn).

4.1F2F4F5step 2.1algebra∎

The leaf basis products in [F5] cost O(kn) because their index sets partition I and J. Each transfer product costs at most O(k2) and there are O(n/k) internal clusters by [F2]; each coupling product costs at most O(k2) and the third hypothesis bounds their number by s⌈n/k⌉. Dense near products cost O(skn) by step 2.1. Summing gives H² matvec work O(skn).

Remarks

This theorem gives storage and matrix-vector costs. It does not assert that formatted H-matrix addition or multiplication is uniformly O(knlog⁡n) in the variable rank k; their recompression work has additional rank-dependent factors.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passjudge pass (gpt-6-luna)Open item page →

Nested-basis H² multiplication is exact for its represented matrix

Statement

For every nested-basis H² representation A~∈FI×J and every vector x∈FJ, Nested-basis H² matrix-vector multiplication returns A~x exactly.

Facts & Assumptions

Given: The H² bases and transfer matrices, the represented matrix A~, its block-cluster partition, and x∈FJ.

[F1]

Nested H² cluster bases and interaction lists: on each child τi of a parent τ, Uτ∣τi=UτiEτiU; column bases satisfy the analogous identity with EV.

[F2]

Nested H² cluster bases and interaction lists: each admissible block is represented by UτSτσVσ∗, and each near block is stored densely.

[F3]

Block-cluster leaves partition the index-pair set: terminal rectangles are disjoint and cover I×J.

[F4]

Nested-basis H² matrix-vector multiplication: the procedure computes column coefficients upward, accumulates coupling products, propagates row coefficients downward, and multiplies dense near blocks directly.

Proof

1.1F1F4inductionalgebra

At a column leaf σ, the algorithm sets zσ=Vσ∗x∣σ. Suppose this identity holds for both children σ1,σ2 of an internal cluster σ. By the nestedness in [F1] and the disjoint union of child indices, Vσ∗x∣σ=∑j=12(EσjV)∗Vσj∗x∣σj=∑j=12(EσjV)∗zσj, exactly the upward update in [F4]. Induction gives zσ=Vσ∗x∣σ for every column cluster.

1.2F1F2F4algebra

Fix a far block (τ,σ). Its coupling contributes Sτσzσ=SτσVσ∗x∣σ to wτ. Each downward transfer from a parent to a child applies the corresponding EU; repeated nestedness [F1] therefore turns UτSτσVσ∗x∣σ into exactly its restriction on every descendant row leaf. Summing the finite far-block contributions gives their full matrix action.

2.1F2F3F4step 1.2algebra∎

By [F2] and [F4], every near block contributes its exact dense product Dτσx∣σ. The far and near block leaves partition I×J by [F3], so adding their actions gives every entry of A~x exactly once in the matrix sum. Thus the returned vector is A~x.

TheoremStatement: Literature-sourcedProof: AI-adaptedprecheck passOpen item page →

Compressed block LU factors have a residual and inverse certificate

Statement

Let A∈Fn×n be invertible over F∈{R,C}, n≥1, and let A=LU be an exact block lower-upper factorization. Suppose Compress exact block LU factors with local tolerances returns L^,U^ and exact local discarded-tail errors ebL,ecU. All operations and norms in this theorem are exact. Put ϵL=(∑b(ebL)2)1/2, ϵU=(∑c(ecU)2)1/2, A^=L^U^, and η=ϵL∥U∥F+∥L^∥FϵU. Then

∥A−A^∥F≤ηand∥A−A^∥2≤η.

If q=∥A−1∥2η<1, then A^ is invertible and

∥A^−1−A−1∥2≤∥A−1∥22η1−q.

Facts & Assumptions

Given: The exact factorization A=LU, a successful blockwise compression of L,U, and the finite-dimensional real or complex matrix norms.

[F1]

Compress exact block LU factors with local tolerances: near and diagonal blocks are copied exactly; each admissible factor block is replaced by the factors returned by core-SVD recompression with its local error certificate.

[F2]

Core-SVD recompression is best at the declared Frobenius tolerance: each returned recompression has Frobenius residual exactly its reported discarded singular-value tail.

[F3]

Blockwise Frobenius errors propagate by disjoint block sums: on a disjoint block partition, local Frobenius residual bounds combine by the root sum of their squares.

[F4]

Finite tensor arrays and the Frobenius inner product: the Frobenius norm is the Euclidean norm of the finite entry list and M∗ is conjugate transpose.

[F5]

Cauchy–Schwarz: ∣⟨x,y⟩∣≤∥x∥ ∥y∥, with equality exactly for dependent pairs: ∣⟨x,y⟩∣≤∥x∥∥y∥ in every real or complex inner-product space.

[F6]

The operator norm is zero on the zero domain and otherwise is max_{||v||=1} ||Tv||: ∥T∥2 is the maximum of ∥Tx∥2 over unit vectors.

[F7]

The operator norm is 0 on the zero domain and otherwise equals the largest singular value, attained at a right-singular vector: ∥T∥2 is the largest singular value of a finite-dimensional operator.

[F8]

Best rank-k matrix approximation in Frobenius norm: the Frobenius norm squared is the sum of squared singular values, by taking rank cap zero in the stated truncation formula.

[F9]

Rank-nullity: dim⁡FV=nullity⁡T+rank⁡T: for a linear map with finite-dimensional domain, dimension equals nullity plus rank.

[F11]

Proof

1.1F1F2F3

The factor compression in [F1] copies every near and diagonal block and gives local discarded-tail errors on the disjoint admissible blocks. By [F2] these are the actual local Frobenius residuals, so [F3] gives ∥L−L^∥F≤ϵL and ∥U−U^∥F≤ϵU.

2.1F4F5step 1.1algebra

Write A−A^=LU−L^U^=(L−L^)U+L^(U−U^). For conformable X,Y, entrywise Cauchy–Schwarz [F5] gives ∣(XY)ij∣2≤(∑ℓ∣Xiℓ∣2)(∑ℓ∣Yℓj∣2); summing over i,j gives ∥XY∥F2≤∥X∥F2∥Y∥F2. Also ∥X+Y∥F2=∥X∥F2+∥Y∥F2+2Re⁡⟨X,Y⟩F≤(∥X∥F+∥Y∥F)2 by [F4,F5], so the Frobenius triangle inequality follows. Together with step 1.1 this yields ∥A−A^∥F≤ϵL∥U∥F+∥L^∥FϵU=η.

3.1F7F8step 2.1algebra

For any matrix R, [F7] gives ∥R∥2=σ1(R), while [F8] at rank cap zero gives ∥R∥F=(∑jσj(R)2)1/2. Hence ∥R∥2≤∥R∥F. Applying this to R=A−A^ and using step 2.1 proves ∥A−A^∥2≤η.

4.1F6F9F10F11step 3.1algebra

Let E=A^−A and q=∥A−1∥2η<1. For every x, the operator-norm definition [F6] gives ∥A−1Ex∥2≤∥A−1∥2∥E∥2∥x∥2≤q∥x∥2 by step 3.1. If A^x=0, then x=−A−1Ex, so ∥x∥2≤q∥x∥2 and therefore x=0. Thus A^ is injective. By [F9], its image has dimension n; [F10] makes that image all of Fn, so its multiplication map is an isomorphism and [F11] gives invertibility.

5.1F5F6step 4.1algebra∎

Set F=A−1E. The definition [F6] gives ∥F∥2≤q by the same estimate as in step 4.1. Since A^=A(I+F) is invertible, so is I+F. For z=(I+F)−1y, the vector triangle inequality from [F5] gives ∥z∥2≤∥y∥2+∥Fz∥2≤∥y∥2+q∥z∥2, hence ∥(I+F)−1∥2≤(1−q)−1. Since A^−1=(I+F)−1A−1 and (I+F)−1−I=−(I+F)−1F, operator-norm submultiplicativity follows from [F6] and gives ∥A^−1−A−1∥2≤q∥A−1∥2/(1−q)=∥A−1∥22η/(1−q).

Remarks

The certificate is conditional on exact factor compression and exact norm values. No finite-precision residual enclosure or method for constructing the initial exact L,U is asserted.

5 · Examples, counterexamples and false statements

None yet.

Sources