Alphabeta Math
AlgorithmAlgorithm: Literature-sourcedProof: Not applicablePipeline-generatedjudge pass (gpt-6-luna)
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.

Finite-budget thick and implicitly restarted Arnoldi with residual acceptance and locking

Definition

Let A∈Cn×n, let v≠0, and choose integers 1≤r<m≤n, a residual tolerance τ≥0, a restart budget Nmax⁡≥1, and a restart mode thick or implicit. All operations below use the exact arithmetic model and projected-solver input specified next. The number k of locked pairs is the number of linearly independent locked vectors; it starts at zero. If a restart is needed, a target rule may be supplied for thick mode and is required for an implicit-mode restart after one or more pairs are locked. When invoked, it must return r−k current Ritz vectors independent modulo the span of all locked vectors, or report unavailable; no rule, an unavailable selection, or a wrong-size or dependent selection gives status rank-loss. For an implicit-mode restart with no locked pairs, a shift rule supplies exactly p=m−r complex shifts for the current cycle or reports unavailable; an unavailable list or a list of any other length gives status shift-count-unavailable. The shifts may be chosen from unwanted Ritz values, but the procedure allows any supplied list and asserts no convergence for an arbitrary schedule.

Projected-solver input and exact operations. Supply a projected eigensolver S. For every requested exact square matrix H∈Cd×d with 1≤d≤m, it must return in finite work either unavailable or success with an ordered list of exactly d pairs (θj,yj), 0≤j<d, with θj∈C, 0≠yj∈Cd, Hyj=θjyj, and det⁡(zId−H)=∏j=0d−1(z−θj). Thus eigenvalues are represented with their algebraic multiplicities; projected eigenvectors need not be independent when H is defective. The procedure does not assert existence of an always-successful exact eigensolver in any fixed arithmetic or encoding. A provider may report unavailable; absent provider data give the same result without invoking a solver. Every original successful exact projected-eigensolve instance is retained by supplying its provider.

Outside S, use exact complex field operations, conjugation, nonnegative real square roots, and exact equality/order comparisons on the real quantities compared. Complex operations use their real and imaginary component formulas. The finite-return target and shift rules have the output contracts already stated. Exact rank tests can be performed by Gaussian elimination, scanning columns and choosing the first remaining row with nonzero pivot; normalization divides only by a checked positive Euclidean norm. This is an exact-operation model, not a bit-cost or machine floating-point claim.

At every projected solve, invoke S on the current Hd. An absent provider or unavailable return gives status projected-eigensolve-unavailable. A provider status other than success or unavailable, wrong list/vector shape, zero vector, nonzero exact residual Hdyj−θjyj, or failed characteristic-polynomial identity gives status projected-eigensolve-invalid. Check that identity by exact coefficient arithmetic: expand det⁡(zId−Hd) by the finite permutation formula of For n≥1, the determinant over a commutative ring by the Leibniz formula, and ∣det⁡A∣ for a real matrix, in lexicographic permutation order, multiplying each term's d affine-or-constant entries in increasing column order and using the inversion parity for its sign; form the right side by successive multiplication of its d linear factors in returned list order. Polynomial addition and multiplication mean finite coefficient-array sums and convolutions, and compare all coefficients through degree d exactly. This finite check extracts no roots. All these failures preserve the locked outputs and the most recently completed valid unlocked Ritz list (initially empty), with the failing cycle and projected dimension. Only after the entire successful list passes these checks normalize the vectors, lift them and replace the current Ritz list. The supplied finite-return promise applies to S itself; no timeout or generic eigensolver implementation is silently provided.

Initialize the restart counter c=0 before the first cycle. The initial cycle is an m-step fully reorthogonalized Arnoldi run from v1=v/∥v∥2: each step computes a matrix-vector product, performs two complete orthogonalization passes against the current basis, and accumulates the coefficients in the projected matrix. If a residual vanishes at step j, use the j-column basis and mark its span invariant. If the residual after step m is nonzero, retain its normalized direction and coefficient as the Arnoldi residual data, but use only the first m columns in the projected eigensolve. Every later cycle uses the restarted basis and projected matrix constructed in step 3 or 4. The output is the locked Ritz pairs, the most recently computed unlocked Ritz pairs, and one of converged, budget-exhausted, invariant-subspace-breakdown, rank-loss, shift-count-unavailable, or filtered-breakdown, projected-eigensolve-unavailable, or projected-eigensolve-invalid.

  1. For the initial cycle, start with v1=v/∥v∥2, no locked pairs, and run the m-step Arnoldi procedure described above. Let d be the projected basis dimension, so d=m unless exact breakdown occurs earlier; on a nonbreakdown cycle also retain the residual direction and coefficient from step m. For every cycle, invoke and validate the supplied projected eigensolver as specified above, returning its failure status before processing any pair if it fails. For each returned projected eigenvector y, normalize it so ∥y∥2=1 and lift it to u=Vdy. Process the Ritz pairs in the order returned by the projected eigensolve. For each pair (θ,u), compute the original residual ru=Au−θu directly (on a standard Arnoldi cycle without breakdown it may be evaluated by An Arnoldi Ritz pair has residual norm controlled by the last Hessenberg subdiagonal entry). If ∥ru∥2≤τ and adding u increases the exact rank of the locked-vector matrix, append (θ,u) to the locked outputs and increment k. A residual-accepted vector in the span of the locked vectors is not counted or appended again. Locked vectors are retained as a subspace at every later restart. If k≥r, return converged.

  2. If the current projected subspace is marked invariant and fewer than r pairs are locked, return invariant-subspace-breakdown. If the restart counter satisfies c=Nmax⁡, return budget-exhausted.

  3. For a thick restart, or for an implicit-mode restart when k>0, invoke the target rule. Form a target block from every locked vector and the selected r−k wanted Ritz vectors. For either block to be rank-revealing, use the following exact column-pivoted orthogonalization: start with an empty orthonormal block Q and all input columns remaining. For each remaining column yj, compute cj=yj−Q(Q∗yj). Choose a column with largest ∥cj∥2, breaking ties by original column order. If the largest norm is zero, stop; otherwise append cj/∥cj∥2 to Q and remove that pivot column. The columns appended to Q form an ordered orthonormal basis of the input range. Apply this procedure first to the target block; if it fails to retain all locked and selected directions, return rank-loss. With its resulting orthonormal basis U, compute the residual block RU=(I−UU∗)AU. Apply the same orthogonalization to RU to obtain an ordered orthonormal basis F of its range. If U has s columns, retain only the first min⁡(dim⁡range⁡(RU),m−s) columns of F, so [U,F] has at most m columns. Set the ordered basis to [U,F] and a queue to its columns in order. While the basis has fewer than m columns and the queue is nonempty, remove the first queued column q, compute w=Aq, and orthogonalize w against every current basis column in two complete passes. If the residual is nonzero, normalize it, append it to the basis, and append the new column to the queue; if it is zero, continue with the remaining queue. Set Vd to the resulting basis and compute the projected matrix Hd=Vd∗AVd exactly. If the queue empties before the basis has dimension m, or if d=n, mark this subspace invariant; first process its Ritz pairs in step 5, then return invariant-subspace-breakdown at step 2 if fewer than r pairs have been locked. This projection is required because a thick restart can begin from several retained and residual directions rather than from a single Arnoldi starting vector.

  4. For an implicit restart with no locked pairs, set p=m−r and request a shift list μ1,…,μp from the shift rule. If it reports unavailable or returns a list of the wrong length, return shift-count-unavailable. Starting from the no-breakdown m-step Arnoldi relation AVm=VmHm+βmvm+1em∗, apply exact shifted QR steps to Hm using the transformations of Real Givens rotations and complex Givens transformations. Set H0=Hm and q(z)=∏j=1p(z−μj). For j=1,…,p, initialize R=Hj−1−μjI and Qj=Im. For ℓ=1,…,m−1, generate a left factor from (a,b)=(Rℓ,ℓ,Rℓ+1,ℓ) and apply it to rows ℓ,ℓ+1 by setting R←LR, and update Qj←QjL∗. Use the identity if b=0; if b≠0, put s0=∣a∣2+∣b∣2 and choose the exact coefficients (c,s)=(a/s0,b/s0) over R, while over C choose (c,s)=(0,b‾/∣b∣) if a=0 and (c,s)=(∣a∣/s0,(a/∣a∣)b‾/s0) otherwise. Use L=(cs−s‾c). At the end set Rj=R and Hj=RjQj+μjI=Qj∗Hj−1Qj. Let H+=Hp and put Q=Q1⋯Qp. Test the filtered Krylov dimension exactly by forming w=q(A)v1 and the columns w,Aw,…,Ar−1w. If their rank is below r, return filtered-breakdown. Otherwise retain Vr+=VmQ(:,1:r) and set Hr+=H+(1:r,1:r). Compute g=A(Vr+):r−Vr+Hr+er, the residual of the last retained column; the first r−1 retained columns have zero residual by the upper-Hessenberg relation and shift count p=m−r. If g=0, use Vr+ as the current invariant basis with dimension r. If g≠0, set vr+1+=g/∥g∥2 and βr+=∥g∥2, initialize the continued Arnoldi relation with (Vr+,Hr+,vr+1+,βr+), and continue Arnoldi with two complete orthogonalization passes until dimension m or exact breakdown. On a nonbreakdown continuation, also compute the residual direction and coefficient after its mth Arnoldi step for the next implicit restart. Mark the current subspace invariant when this continuation breaks down.

  5. Increment the restart counter by setting c←c+1, invoke and validate S on the new projected matrix as in step 1, and return the stated projected-solve failure status if it fails. On success, recompute the lifted Ritz pairs and their original residuals, apply the acceptance rule in step 1, and return to step 2 unless a return status applies. No convergence is asserted for an arbitrary shift schedule. The residual acceptance test certifies only the computed residual size; it does not by itself give a forward eigenvalue bound for a nonnormal matrix.

Depends on

Used by

Dependency tree · two levels

28 results within two dependency steps of this one, each drawn at its shortest distance from it. An arrow runs from a result to what uses it, so the chart reads left to right and ends at this result, which carries a heavier outline. Every node is a link to that result. Click elsewhere on the chart to enlarge it.

Sources