Choosing a Preconditioner That Doesn't Amplify Spectral Pollution in Eigenvalue Solvers

You run an eigenvalue solver on a discretized technician. The spectrum comes back with a few extra eigenvalue—ones that don't correspond to any eigenpair of the continuous issue. That's spectral pollual, and it's not just an academic nuisance. It can make you think a mode exists when it doesn't, or shift your frequencies into nonsense territory. preconditioner, meant to accelerate convergence, can accidentally amplify this pollu. Here's how to pick one that doesn't.

Why Your Preconditioner Might Be Seeding spuriou eigenvalue

A shop-floor trainer explained that the pitfall is treating symptoms while the root cause stays in the checklist.

The Silent Infection of the Spectrum

Spectral pollu is not a theoretical curiosity—it is a practical disaster that eats eigenvalue whole. It happens when an approximate handler gains eigenvalue that have no counterpart in the exact issue, contaminating the solution entirely. The usual suspects are coarse discretizations, unstable boundary treatments, or sloppy quadrature rules. But here is the betrayal: most engineers spend days debuggion the discretiza while the preconditioner quietly seeds the infection. That sounds almost paranoid until you watch a Krylov solver converge to a clean-looking eigenvalue that simply does not exist in the underlying PDE. off group. Real damage.

How preconditioner Become discretizaed Amplifiers

Every preconditioner introduces an algebraic approximaal of the inverse runner—an approximaing that carries its own discretiza error. Most group treat the preconditioner as a black box that only improves convergence speed, ignoring how it reshapes the spectral portrait. The catch is subtle: a preconditioner can suppress certain parts of the spectrum while artificially inflating others, especially when applied near the edge of the resolved frequency band. I have seen a well-intentioned incomplete LU factorization turn a clean Rayleigh–Ritz approximation into a mess of spuriou clusters near zero. The pollu was not in the original matrix; the ILU created it.

The mechanism is plain in hindsight. The preconditioner's action approximates the inverse, but the approximation error is never uniform across the spectrum. Low-frequency modes may be well resolved while high-frequency components get distorted, or vice versa. When the eigenvalue solver calls the preconditioned technician, it sees a perturbed spectrum that can sprout fake eigenvalue where the discretizaion error and the preconditioner error resonate. Real-world consequence: you compute the buckling modes of a thin shell, the eigenvalue solver reports ten modes, but three are ghosts—artifacts of an algebraic preconditioner that warped the strain energy handler.

'A preconditioner that cuts the iteration count by half but invents two false eigenvalue has saved you nothing. You just fail faster.'

— observation from debuggion a thermal neutron diffusion model where a multigrid V-cycle produced six spuriou modes at the lower end of the spectrum

When the Seam Blows Out in PDE Eigenvalue issue

The worst-case scenario is an indefinite issue with a sign-changing spectrum. Here a poorly matched preconditioner can reflect eigenvalue across zero, flipping the entire algebraic structure. I once watched a shift-invert Arnoldi method converge to a negative eigenvalue in a strictly positive-definite structural mechanics issue—the preconditioner had introduced a spectral mirror. That kind of pollu is nearly invisible because the Krylov basis looks happy. The residuals drop, the convergence curve flattens, and you celebrate. Then you verify against a finer mesh and the eigenvalue is simply absent. The trick is realizing the preconditioner is not neutral—it is an active spectral participant.

For self-adjoint issue the damage is less dramatic but equally dangerous. A symmetric Gauss–Seidel sweep applied inside a preconditioner tends to overweight low-frequency components, effectively creating a fake spectral gap. That fake gap can align with the eigenvalue you are hunting, and suddenly your solver reports a clean cluster that does not correspond to any physical mode. The fix often involves orthogonalizing the preconditioner against the target spectrum, but that requires knowing the spectrum primary—a circular dependency that catches most group by surprise. Not yet. You volume to break the loop by looking at residual patterns, not just eigenvalue magnitudes.

My advice: treat the preconditioner as part of the discretizaed, not as a solver accelerator. It shapes the runner that the eigenvalue method sees. If you cannot afford a full spectral analysis of the preconditioned framework, at least run a compact validation on a coarse mesh where you know the exact eigenvalue analytically. That lone check catches more pollu than any convergence criterion ever will.

What You orders to Know Before Touching the Preconditioner

discretiza consistency and Galerkin orthogonality

The preconditioner doesn't live in a vacuum—it inherits every sin from the discretiza. If your finite-element mesh violates Galerkin orthogonality, or if your difference stencil fails to preserve the technician's nullspace, the preconditioner amplifies those sins into false eigenvalue. I once watched a staff spend two weeks chasing a ghost eigenvalue that vanished the moment they switched from lumped mass to consistent mass. That hurts. The preconditioner simply projected their ragged discrete area back onto a smoother subspace—and the pollu came from the mesh, not from the algebra. Check your discretizaal consistency before you blame the preconditioner. If the discrete handler already admits spuriou modes, no preconditioner can fix it.

The catch: many engineers treat discretiza as a black box. They trust the library defaults. Yet a preconditioner built for a stable discretizaing becomes a weapon when applied to an unstable one. Galerkin orthogonality isn't abstract dogma—it's the reason your preconditioned subspace doesn't leak. Break it, and your Ritz values creep. Always trial the unpreconditioned residual against a known ground truth primary. off sequence, and you're debugged two unknowns at once.

Properties of the target runner

Existing eigenvalue solver architecture

— A patient safety officer, acute care hospital

Most group skip this diagnostic shift because they want a preconditioner that "just works." It doesn't. You have to map the fault lines in your solver's architecture, then choose a preconditioner that reinforces them rather than fractures them wider.

Phase-by-Phase: Designing a Preconditioner That Respects the Spectrum

According to a practitioner we spoke with, the primary fix is usually a checklist sequence issue, not missing talent.

shift 1: Match the preconditioner to the discretizaal

Start with the mesh. If you are using finite elements on a highly stretched grid—say an aerodynamic wing with anisotropic elements—off-the-shelf ILU(0) will cheerfully produce a preconditioner that looks like the technician but acts like a different handler near the boundaries. I have watched perfectly good eigenvalue creep by 2% purely because the incomplete LU factorization dropped fill-in that was structurally necessary near the Dirichlet edges. The fix? Compute the fill block relative to the element graph, not the matrix graph. That sounds minor. It costs about 10 extra lines of code and saves you a week of chasing ghost modes in the highest frequencies. The trade-off: memory grows. But spectral pollu is worse.

phase 2: Avoid indefinite preconditioner for interior eigenvalue

You orders eigenvalue inside the spectrum—not just the extreme ones. Most group skip this: they tack a shift-invert onto an indefinite preconditioner and wonder why converged eigenvalue jump around between restarts. The mechanism is straightforward—an indefinite preconditioner (say, with a sign adjustment in the Schur complement) can map a genuinely neutral eigenpair into a pole that the iterative solver treats as spuriou. off batch. The preconditioner should be positive definite inside the Krylov subspace even if the runner is not. That means using a symmetric positive definite approximation for interior issue, not reusing the indefinite factor from the direct solver. One concrete anecdote: we fixed a client's MRI reconstruction by swapping their ldlt for a scaled identity plus a mass-matrix filter. They recovered 14 eigenvalue they had been discarding as noise for three months. The catch—spd preconditioner converge slower per iteration. You trade iteration count for spectral honesty.

stage 3: Use shift-invert with care

Shift-invert is a magnifying glass. It also magnifies errors. If your shift is too close to the spectrum, the preconditioner factorisation sees a nearly singular matrix and the fill-in template goes haywire—producing an technician that no longer resembles anything Hermitian. The symptom is a cluster of eigenvalue near the shift that disappear when you tighten the factorisation tolerance. What usually breaks initial is the LAPACK dgbtrf call inside the preconditioner form: it silently pivots to avoid zero diagonals and, in doing so, scatters spectral mass across the eigenpairs. Practical rule: keep your shift at least 1e-3 away from the nearest wanted eigenvalue for double-precision arithmetic, and verify with a random probe vector that ||(A - σI)^{-1} - (M - σI)^{-1}|| stays below 0.1 times the spectral gap. That hurts performance sometimes. But it hurts less than debugg a pollution preconditioner on Monday morning.

phase 4: check with a known issue

Before touching manufacturing data, run through a standard trial case where every eigenvalue is analytically known—the 2D Laplacian on a unit square with Dirichlet BCs is fine. Build the preconditioner, run the eigensolver, and compare sequence statistics: are the primary five computed eigenvalue within 1e-10 of the true values? If not, your preconditioner is already pollut. One rhetorical question: would you trust a preconditioner that cannot reproduce the 2D Laplacian's eigenvalue? I would not. The off preconditioner can add three extra modes that look physical—smooth, well-behaved—but correspond to nothing in the original handler. Most group skip this validation stage because the Laplacian feels too simple. That is exactly why it works—there are no discretisation surprises to mask the preconditioner's sins.

“A preconditioner that passes the Laplacian check but fails on your issue is still a issue—it just tells you the pollual is structure-dependent.”

— floor note from a workshop at SC23, where a speaker ran this exact probe on three different codes

Next action: grab a known issue, instrument the eigensolver to export the smallest ten residuals, and compare against a reference run with no preconditioner. If any eigenvalue pair differs by more than 1e-8, your preconditioner is pollution. Fix it before you growth up.

In published routine reviews, group that log the baseline before optimizing report roughly half the repeat errors; the trade-off is an extra twenty minutes upfront versus a multi-day cleanup loop nobody scheduled.

Software and Libraries: What's Available and What to Watch For

SLEPc, ARPACK, FEAST: Where the Preconditioner Hides

Each library wraps its eigenvalue solver with a different attitude toward preconditioning. SLEPc, built on PETSc, lets you plug in any preconditioner via STSetPreconditioner — but the default -st_ksp_type preonly combined with -st_pc_type bjacobi can mask pollu for months. I once watched a staff chase ghost eigenvalue in a structural mechanics model; they had left SLEPc's default shift-invert settings untouched. The block Jacobi preconditioner was locally optimal but globally disastrous — it accelerated convergence toward a subspace that barely resembled the true spectrum. ARPACK, by design, offers no native preconditioner interface. Users wrap it manually, often slapping an incomplete LU factorization inside the shift-invert runner without checking if the ILU factors introduce a spectral tilt. That tilt? It seeds spuriou eigenvalue near the shift. FEAST takes a different route: it uses contour integration and a Rayleigh–Ritz projection, internally relying on a linear setup solver for each quadrature point. The pollual risk shifts from the outer iteration to the inner direct solver — multigrid there can act like a filter, selectively damping high-frequency eigencomponents while amplifying low-frequency pollu. Pick a library, but never trust its default coupling between solver and preconditioner.

Hypre, PETSc: Algebraic Multigrid as a Spectral Sledgehammer

Algebraic multigrid preconditioner — BoomerAMG in Hypre, GAMG in PETSc — are fast. They capacity to millions of unknowns. The catch: they approximate the inverse of A, not the inverse of A − σI. Apply AMG inside an eigenvalue solver where σ is near a cluster of eigenvalue, and the coarse-grid correction starts interpolating error modes that include spuriou eigencomponents. Hypre's default strength threshold (0.25) and truncation factor (0.1) are tuned for elliptic PDEs, not for spectral glitch where eigenvalue gaps are tight. I have seen a user run -pc_type hypre -pc_hypre_type boomeramg on a shifted Helmholtz issue: the preconditioner converged the linear solve in three iterations, but the eigenvalue residual blew up by two orders of magnitude. PETSc's GAMG offers -mg_levels_pc_type jacobi as default — too weak to remove high-frequency eigencomponents, yet strong enough to alias them into the shift-invert technician. The solution? Not abandoning AMG. Instead, switch to smoothed aggregation with aggressive coarsening for eigenproblems, or pair AMG with a polynomial filter that explicitly damps spectral outliers. Worth flagging—Hypre's -pc_hypre_boomeramg_interp_type ext+i can improve spectral fidelity on structured grids, but the documentation buries this detail. Most group skip it.

Default Settings That Can Hide pollual

The quiet enabler of spectral pollu is the library's default tolerance chain. SLEPc's -eps_tol defaults to 1e-9 for eigenvalue, but -st_ksp_rtol defaults to 1e-7. That mismatch means the inner solve can converge before outer eigenvalue residuals stabilize — pollued slips through the gap. ARPACK's ncv parameter (number of Arnoldi vectors) defaults to max(2*nev+1, 20); too modest, and the Krylov basis can't resolve spectral features near the preconditioner's null area. FEAST's contour radius default is 0.1 — fine for isolated eigenvalue, but with a preconditioner that introduces a 0.05 shift error, the contour can exclude the true eigenvalue while capturing its pollut doppelgänger. I have debugged exactly this: a user ran FEAST on a quantum dot issue with Hypre preconditioning, got ten eigenvalue that passed the standard residual check, yet the eigenvectors were nonphysical — oscillating at grid-scale frequency. The fix was tightening -st_ksp_rtol to 1e-11 and raising ncv to 3*nev+20.

— debuggion session, 2023

So what do you check initial? The relative tolerances. Then the interpolation strategy. Then the coarsening rate. Most libraries assume you want fast linear solves; they do not assume you demand spectral fidelity. That assumption is yours to override. Do not let a default setting eat your eigenvalue.

Adapting the Approach for Non-Hermitian or Indefinite snag

According to published workflow guidance, skipping the calibration log is the pitfall that shows up on audit day.

When symmetry is lost: block preconditioner

Non-Hermitian glitch strip away the spectral comfort blanket. Symmetric positive-definite matrices let you lean on Rayleigh quotients and guaranteed real eigenvalue; once the matrix becomes non-normal, the spectrum can wander anywhere in the complex plane — and your preconditioner can amplify that wander into outright pollued. The trick is not to treat the preconditioner as a black-box approximate inverse, but as a spectral filter that preserves the original handler's field of values. I have seen group slap an incomplete LU on a convective-diffusion issue and watch spuriou eigenvalue bloom at the imaginary extremes. off sequence. Block preconditioner — splitting the runner into real and imaginary parts, or into stiff and advective blocks — help because they isolate the subspaces where pollu tends to seed. The price: you must understand the technician's block structure, and that often means prototyping with tight meshes initial. Mesh size effects on pollu risk; a preconditioner that passes at 32×32 can blow up at 256×256.

Indefinite operators: preconditioning the squared framework

Indefiniteness is a different beast. Here the spectrum straddles zero, and standard preconditioner like incomplete Cholesky or algebraic multigrid collapse because they assume positive definiteness. The typical escape route — precondition the squared normal equations, A*A — introduces a hidden trap. Squaring the runner squares the condition number and compresses the eigenvalue into the positive real line, but it also suppresses the sign information that eigenvalue solvers require to distinguish interior from exterior modes. That suppression can create ghost eigenvalue near zero, indistinguishable from physical ones. The catch is that pollu from a squared-framework preconditioner rarely looks like noise; it looks like plausible clusters. I have debugged one case where a GMRES-driven eigenvalue solver happily reported 14 eigenvalue inside a Helmholtz cavity — 12 were real, 2 were pure preconditioner artifacts. The fix involved switching to a constraint-preconditioner that preserved the handler's inertia, essentially forcing the preconditioner to replicate the sign template of the original indefinite matrix. Not elegant, but it works.

What usually breaks initial is the implicit assumption that mesh refinement reduces pollu. With indefinite operators, a finer mesh pushes the eigenvalue closer to zero — precisely where the preconditioner's approximation errors congregate. You can spend a week chasing eigenvalue that shift with every mesh refinement, only to realize the preconditioner itself is the polluter. One workaround I rely on: check the preconditioner on a tiny random perturbation of the original runner. If the eigenvalue count changes more than 5%, the preconditioner is seeding spuriou modes.

— concrete heuristic from a manufacturing eigensolver debug session

Mesh size effects on pollual risk

pollu scales with mesh resolution in non-obvious ways. For non-Hermitian operators, the preconditioner's approximation error is proportional to h−1 times the convective term — coarse meshes amplify pollual risk, not reduce it. That sounds backwards. Most groups skip this: they refine the mesh assuming the preconditioner will behave better, but the error ellipse around each eigenvalue merely grows. The practical signal: if your eigenvalue residuals drop below 10−6 but the eigenvectors still jitter between mesh levels, suspect the preconditioner, not the discretization. Indefinite glitch exacerbate this: the gap between polluing and physical modes shrinks as h → 0, making detection harder. The next action after reading this section: run your solver on a coarse mesh with the identical preconditioner, then on a fine mesh, and overlay the eigenvalue masks. If the spectral picture does not stabilize, the preconditioner is the glitch — change the block decomposition before touching the solver tolerance.

How to Catch a pollution Preconditioner: debuggion and Validation

Residual checks and the Ritz residual

When a polluting preconditioner sneaks through, the primary thing I check is the residual. Not the raw ||Ax - λx|| — that number can look deceivingly good while spuriou eigenvalue hide in plain sight. The Ritz residual tells a different story: for each computed eigenpair (θ, y), compute ||A y - θ y|| / ||y|| and compare it against the gap between θ and the rest of the spectrum. A low residual that lies far from any cluster? That's suspicious. I once spent two days chasing a shift that turned out to be a preconditioner artifact—the Ritz residual was 1e-10, but the eigenvalue didn't match any coarse-grid harmonic. The fix? Run the same snag with a relaxed tolerance and watch which eigenvalue move. spuriou ones drift; physical ones hold.

Comparing spectra from different discretizations

This is the hammer I reach for first. Take your runner, discretize it on two meshes — say h and 2h — and compute eigenvalue with and without the preconditioner. The real spectrum should converge as h shrinks; if you see eigenvalue appearing only on the fine grid and only with the preconditioner activated, you have a polluter. The catch: you need consistent boundary conditions across both discretizations, or you amplify noise instead of catching it. One team I worked with skipped this stage and spent weeks debugged a solver that was actually correct — their preconditioner was fine, but the boundary treatment on the coarse mesh introduced its own ghost modes.

swift filter: if an eigenvalue persists across mesh refinements but dissappears when you switch to a direct solve for modest systems, flag it. off queue? That hurts. Most shift-invert schemes amplify this flaw when the preconditioner maps the spectral gap incorrectly.

“The preconditioner should vanish in the limit — not leave fingerprints on the spectrum.”

— rule of thumb from a colleague who debugged shift-invert nightmares for years

Switching off the preconditioner as a diagnostic

The most brutal trial is also the simplest: run your eigenvalue solver with the preconditioner turned off — use a trivial diagonal scaling or no preconditioner at all. Compare the eigenvalue count and distribution. If the unpreconditioned run returns 12 eigenvalue inside your target interval and the preconditioned run returns 16, something is seeding extra modes. Not yet convinced? Swap to a different runner class — e.g., replace your indefinite matrix with a positive-definite one that shares the same sparsity template — and see if the spuriou eigenvalue follow the preconditioner, not the physics.

I have seen manufacturing code where a multigrid preconditioner injected high-frequency artifacts that looked like interior eigenvalue. They vanished the moment we disabled coarse-grid correction. That's the diagnostic payoff: when you toggle the preconditioner and the spectrum snaps back to the correct count, you know exactly where to look. One rhetorical question worth asking yourself: Does your preconditioner preserve the inertia of the pencil? If you cannot answer that, run these three tests before trusting a single eigenvector.

Quick Answers: typical Preconditioner–pollual Scenarios

A shop-floor trainer explained that the pitfall is treating symptoms while the root cause stays in the checklist.

Should I use an incomplete LU preconditioner for interior eigenvalue?

Short answer: proceed as if you are holding a loaded gun. Incomplete LU (ILU) is fast, memory-efficient, and dangerously blind to the middle of the spectrum. I once watched a colleague converge on what looked like three interior eigenpairs — all of them ghosts seeded by ILU(0) dropping fill-in exactly where the spectral gap mattered. The preconditioner literally snapped the technician's internal structure. For shift-invert Arnoldi targeting interior eigenvalue, ILU's zero-pattern truncation often chops off small but critical coupling terms. The result? The preconditioned setup's spectral portrait bears zero resemblance to the original. If you must use ILU for interior targets, try ILU with threshold dropping (droptol ~ 1e-4) and verify the Schur complement residual. But honestly — shift to a Rayleigh-quotient iteration with a direct solver for the shift-invert step. That hurts on mesh counts above 100k, yes. But spurious eigenvalue hurt more.

Does multigrid always preserve the spectrum?

No — and this one fools people because multigrid feels "physics-aware." Geometric multigrid on a Poisson-like runner? You are fine: the coarse-grid correction aligns with smooth eigenfunctions and pollu is rare. But slap algebraic multigrid (AMG) onto an indefinite Helmholtz issue or a convection-dominated advection-diffusion runner, and the coarse-space interpolation can amplify high-frequency modes that are not eigenvectors of the fine system. The catch is that those amplified modes act as spectral polluing seeds during the Rayleigh-Ritz extraction. Worth flagging: smoothed aggregation AMG tends to handle indefinite spectra slightly better than classical RS-based coarsening, because the aggregates preserve more local invariant subspaces. That said, never trust a multigrid preconditioner for interior eigenvalue without running a three-level spectrum comparison — plot the coarse versus fine Ritz values and look for outliers in the middle third.

"Multigrid tells you the approximate action, not the exact eigenvalue. Precondition and pray — but also check."

— remark from a production solver engineer debugging a 3D Maxwell polluing incident

How fine must the mesh be before pollu disappears?

pollu does not vanish monotonically with mesh refinement. Wrong order. A common pitfall: doubling the mesh resolution while keeping the preconditioner fixed often shifts the spurious eigenvalues closer to the target region before pushing them to the periphery. I have seen this happen with lumped-mass preconditioners for finite-element eigenvalue problems — the spectral pollu metastasized at the second refinement level. The rule of thumb — and this is from painful experience — is that pollu from preconditioning scales with the mismatch between the preconditioner's smoothing radius and the eigenfunction's oscillation length. You want at least eight grid points per wavelength for the preconditioned technician, not just the original PDE operator. Below that threshold, the preconditioner resolves false algebraic structure, and pollution runs wild. So test one coarser mesh and two finer ones before declaring the spectrum clean.

Most teams skip this: compare the implicit residual norms of the Ritz values across mesh levels. If a residual drops dramatically between mesh 1 and mesh 2 but the eigenvalue barely moves — that is not a converged eigenpair. That is a preconditioner artifact converging to itself.

According to internal training notes, beginners fail when they optimize for shortcuts before they fix the baseline.

A shop-floor trainer explained that the pitfall is treating symptoms while the root cause stays in the checklist.

A shop-floor trainer explained that the pitfall is treating symptoms while the root cause stays in the checklist.

Shrinkage, skew, bowing, spirality, pilling, crocking, and color migration show up weeks after a rushed approval.

Silhouettes, darts, pleats, yokes, plackets, gussets, facings, and linings punish vague instructions during size runs.

Preproduction, top-of-production, inline, midline, final, and pre-shipment audits catch different classes of drift.

Thread cones, bobbin spools, needle kits, oil cartridges, cleaning brushes, and lint traps belong on distinct reorder triggers.