Algebraic Adaptive In-Solve Coarsening

• Algebraic Adaptive In-Solve Coarsening is a dynamic method that constructs and updates coarse representations on-the-fly using algebraic transfers, adapting to local solution features.
• It integrates with iterative solvers like multigrid, CG, and GMRES to accelerate convergence while preserving fine-scale fidelity without explicit remeshing.
• Realizations include matrix-free multigrid on adaptive octrees and AGIPC for GPU simulations, demonstrating robust performance, scalability, and efficient in-solve coarsening.

Algebraic Adaptive In-Solve Coarsening denotes a family of solver constructions in which coarse degrees of freedom, coarse operators, or coarse spaces are generated or updated algebraically during the solve itself rather than by a fixed offline remeshing or purely geometric hierarchy. Across the literature, the defining ingredients are an algebraic transfer or projection mechanism, a coarse representation tailored to the current linear or linearized system, and an integration with an iterative method such as multigrid, Schwarz, CG, PCG, or GMRES. In recent work, the term is used both for matrix-free multigrid on adaptive octrees, where coarse operators are formed on-the-fly and refinement-interface corrections are applied inside the V- or W-cycle, and for GPU implicit contact simulation, where selective edge-collapse tags induce a coarse system inside each Newton iteration without changing the fine topology (Wang et al., 20 Apr 2026, Wang et al., 6 May 2026).

1. Definition and conceptual scope

In the octree multigrid formulation, coarsening is called algebraically consistent if the coarse operator is defined by the Galerkin principle with the same restriction and prolongation used in the multigrid cycle,

$A_H = R A_h P,$

with exact satisfaction on uniform-resolution patches and a flux-consistent correction at T-junctions to restore cross-level consistency while keeping a compact matrix-free representation (Wang et al., 20 Apr 2026). In that setting, adaptivity refers to an octree AMR hierarchy with a level restriction of at most $1{:}1$ across faces, and in-solve coarsening means that coarse operators are formed on-the-fly from fine-level coefficients by a GPU kernel and that interface corrections are evaluated every cycle without sparse matrix assembly (Wang et al., 20 Apr 2026).

In AGIPC, algebraic adaptive in-solve coarsening is defined as a GPU-oriented method that dynamically reduces degrees of freedom within the Newton solve of implicit time integration without explicit topological modification. Starting from a fine mesh, adaptivity is expressed as a selective edge-collapse process governed by per-edge tags, and the resulting coarse linear system is assembled algebraically by mapping and reducing fine-scale gradients and Hessians (Wang et al., 6 May 2026). This establishes a second, distinct usage of the term: the coarse representation is not a geometric mesh hierarchy in the classical sense, but an implicit coarse mesh induced by algebraic aggregation.

A plausible synthesis is that the phrase identifies a design pattern rather than a single algorithm. The pattern is algebraic because transfers or coarse operators are defined from system algebra rather than remeshing alone; adaptive because the coarse representation depends on current local structure such as refinement interfaces, strain increments, or contact activity; and in-solve because these decisions are made or updated inside the active iterative or Newton process.

2. Core algebraic mechanisms

The central algebraic mechanism is projection or reduction. In the octree Poisson solver, prolongation is constant injection,

$$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$

and restriction satisfies $P=\alpha R^T$ with $\alpha=2$, giving exact Galerkin coarse operators on uniform fluid patches when Coarsen is applied (Wang et al., 20 Apr 2026). The matrix-free storage uses per-cell diagonal and three negative-direction face coefficients, and the coarse kernel accumulates child contributions and rescales them without assembling a global sparse matrix (Wang et al., 20 Apr 2026).

In AGIPC, the fine-to-coarse map is encoded by a prolongation operator $P \in \mathbb{R}^{3n_f \times m_c}$. Identity-mapped coarse nodes use one-hot $3$-DoF blocks, while affine-mapped coarse nodes use $12$-DoF affine embeddings $A_i \in \mathbb{R}^{12\times 3}$ built from rest-pose homogeneous coordinates. Restriction is $R=P^T$, and the reduced system is assembled by Galerkin projection:

$1{:}1$0

followed by

$1{:}1$1

All fine-scale contributions, including elasticity, IPC barrier, and inertia/damping, enter $1{:}1$2 and $1{:}1$3 before reduction (Wang et al., 6 May 2026).

The broader domain-decomposition literature provides related algebraic coarse constructions. The Discretely-Discontinuous Galerkin coarse grid forms $1{:}1$4 from subdomain-restricted polynomial input vectors and is integrated as a coarse correction inside two-level overlapping Schwarz (Edwards et al., 2015). Fully algebraic adaptive Schwarz methods extract local Dirichlet blocks and Schur complements from the assembled matrix and build coarse spaces from local eigenproblems, again with coarse stiffness $1{:}1$5 (Heinlein et al., 2022). For non-symmetric two-level preconditioners, local extended generalized eigenproblems identify troublesome modes and define a global coarse space $1{:}1$6 (Nataf et al., 2024). These constructions do not use the exact phrase as a method name, but they supply the algebraic and in-solve ingredients that later formulations make explicit.

3. Adaptive criteria and dynamic update strategies

The adaptive part of the concept varies by application. On adaptive octrees, refinement is geometric, but the coarsening action remains dynamic because coarse coefficients and refinement-interface corrections are recomputed during the solve. T-junctions are detected at runtime, ghost values on the fine side are reconstructed from coarse/fine gradients,

$1{:}1$7

and the coarse right-hand side is modified in FAS style so that the coarse solve accounts for flux already generated by fine-level smoothing (Wang et al., 20 Apr 2026). The corrected coarse update uses

$1{:}1$8

with $1{:}1$9 at restriction (Wang et al., 20 Apr 2026).

In AGIPC, adaptivity is driven by per-edge binary tags $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$0. The default $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$1 marks an edge as collapsible; $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$2 protects local detail near large strain, sharp features, or active contacts (Wang et al., 6 May 2026). The mapping is rebuilt every Newton iteration from the fixed fine topology, which the paper describes as stateless coarsening. Protected edges preserve local resolution, while collapsible edges induce super-nodes through warp-level connectivity hashing (Wang et al., 6 May 2026). The paper reports that re-evaluating tags every Newton iteration is effective, whereas less frequent updates can lag physical changes (Wang et al., 6 May 2026).

Other algebraic frameworks formulate adaptivity spectrally or combinatorially. The fully algebraic Schwarz method based on optimal local approximation spaces allows dynamic enrichment during the iterative solve by monitoring edge or subdomain residual projections and then adding local transfer or Dirichlet eigenmodes to the coarse basis when stagnation is detected (Heinlein et al., 2022). The non-symmetric ASM/RAS framework similarly allows online addition of local generalized eigenvectors when local Rayleigh quotients exceed a threshold $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$3, with coarse-space updates followed by GMRES restart (Nataf et al., 2024). In reduction-based AMG, MacLachlan–Saad coarse-grid selection is posed as a constrained combinatorial optimization, and simulated annealing is proposed as an approximation mechanism; the synthesis explicitly suggests localized, residual-driven annealing moves for adaptive in-solve updates (Zaman et al., 2021). In bootstrap AMG, LARS-based coarsening can be updated from recent smoothed residuals or search directions, with MaxVol stabilization and restricted local refreshes (Kahl et al., 2018). Gaussian-process AMG likewise suggests refitting a semivariogram from a fresh smoothed residual and enriching the coarse set by high posterior-variance points when convergence stalls (Gottschalk et al., 2020).

4. Realizations in multigrid, domain decomposition, and GPU simulation

A concise way to organize the principal realizations is to separate the octree multigrid and IPC formulations from the broader adaptive coarse-space literature.

Realization	Algebraic object updated in-solve	Solve context
Matrix-free multigrid on adaptive octrees	$$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$4, coarse RHS, ghost/interface corrections	Poisson and pressure projection on octrees
AGIPC	Fine-to-coarse map $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$5, reduced $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$6, reduced $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$7	Newton solves for GPU IPC
Adaptive Schwarz / DD methods	Coarse basis $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$8, $$P_{i,J}=1 \text{ if } i \text{ is a child of } J, \; 0 \text{ otherwise},$$9, $P=\alpha R^T$0 or $P=\alpha R^T$1	Two-level preconditioners inside Krylov
Adaptive AMG variants	C/F splitting, interpolation $P=\alpha R^T$2, coarse operator $P=\alpha R^T$3	Two-grid or multilevel AMG

In the octree formulation, operator application is stencil-wise from per-cell coefficients, a CUDA thread block operates on one $P=\alpha R^T$4 tile, a $P=\alpha R^T$5 shared-memory halo is loaded, and ghost values at refinement interfaces are reconstructed on-the-fly with no global ghost storage (Wang et al., 20 Apr 2026). Restriction and residual computation are fused, and RBGS residual, diagonal, and update are fused in a single kernel (Wang et al., 20 Apr 2026). This realizes in-solve coarsening as a compact matrix-free GPU pipeline.

In AGIPC, vertices are partitioned into contiguous groups of size equal to a CUDA warp. Each vertex builds a compact bit-hash encoding in-group collapsible connectivity, indirect connectivity is propagated by iterative bitwise-OR, identical final hashes define coarse super-nodes, and a prefix sum assigns global coarse indices (Wang et al., 6 May 2026). Coarse assembly then maps fine BCOO triplets $P=\alpha R^T$6 to coarse mixed-size blocks, flattens them to $P=\alpha R^T$7 tiles, and hash-reduces duplicates by $P=\alpha R^T$8-bit keys (Wang et al., 6 May 2026). The result is a sparse reduced system compatible with GPU PCG.

In DDG, the coarse space is built by restricting low-degree polynomial vectors to each subdomain, producing a basis that resembles a discontinuous Galerkin basis on subdomain-sized elements (Edwards et al., 2015). In the fully algebraic robust Schwarz method, the coarse space is

$P=\alpha R^T$9

where the added edge functions come from local Dirichlet and transfer eigenvalue problems extracted solely from the assembled system (Heinlein et al., 2022). In the non-symmetric framework, coarse vectors are generated from local extended generalized eigenproblems involving $\alpha=2$0, which remains Hermitian positive semidefinite even if $\alpha=2$1 is non-symmetric (Nataf et al., 2024). These methods are not GPU IPC or octree multigrid, but they exemplify the same structural principle: the coarse representation is assembled from algebraic local information and can be augmented during solution.

5. Performance, convergence, and robustness

For matrix-free multigrid on adaptive octrees, numerical experiments demonstrate second-order accuracy, grid-independent convergence when used with PCG, and robust performance on cut-cell problems arising in fluid simulation (Wang et al., 20 Apr 2026). On sinusoidal Poisson tests, the relative residual drops by approximately $\alpha=2$2 per PCG iteration and reaches the discretization floor in about $\alpha=2$3 iterations across multiple grid ranges; for cut-cell static pressure projection, the reduction is $\alpha=2$4–$\alpha=2$5 per iteration and again reaches the discretization error in about $\alpha=2$6 iterations (Wang et al., 20 Apr 2026). The same work reports full-solve throughput on a single NVIDIA RTX 4090 GPU of $\alpha=2$7–$\alpha=2$8 million cells per second for analytical Poisson and $\alpha=2$9–$P \in \mathbb{R}^{3n_f \times m_c}$0 million cells per second for pressure projection with cut cells at about $P \in \mathbb{R}^{3n_f \times m_c}$1 million leaf cells (Wang et al., 20 Apr 2026).

For AGIPC, benchmarks across cloth and solid IPC scenarios report an average active DoF ratio between $P \in \mathbb{R}^{3n_f \times m_c}$2 and $P \in \mathbb{R}^{3n_f \times m_c}$3, speedups up to and exceeding $P \in \mathbb{R}^{3n_f \times m_c}$4 compared to StiffGIPC, and transient per-timestep speedups greater than $P \in \mathbb{R}^{3n_f \times m_c}$5 during aggressively coarsenable phases (Wang et al., 6 May 2026). In a heterogeneous stiff squishy-ball case, the total time is reduced from $P \in \mathbb{R}^{3n_f \times m_c}$6 s to $P \in \mathbb{R}^{3n_f \times m_c}$7 s while maintaining visually indistinguishable results (Wang et al., 6 May 2026). The paper also reports that AGIPC with a diagonal preconditioner remains robust and yields $P \in \mathbb{R}^{3n_f \times m_c}$8 speedup even where MAS is unstable for the baseline, whereas MAS can provide speedups around $P \in \mathbb{R}^{3n_f \times m_c}$9–$3$0 with caveats in extreme ill-conditioning (Wang et al., 6 May 2026).

The broader adaptive coarse-space literature emphasizes scalability guarantees rather than GPU throughput. The DDG coarse grid is proved to yield a high-order convergent coarse approximation and shows optimal scaling with nearly constant iteration counts across scalar and vector-valued second-order and fourth-order PDEs (Edwards et al., 2015). The fully algebraic robust Schwarz method derives a contrast-independent upper bound for $3$1 with explicit dependence on coarse-space thresholds (Heinlein et al., 2022). The non-symmetric two-level framework gives a contraction estimate

$3$2

which directly links selected local eigenmodes to global convergence (Nataf et al., 2024). These results suggest that the in-solve variant is not merely a heuristic acceleration device; it can also be organized so that the adaptive coarse representation targets the modes known to obstruct scalability.

6. Misconceptions, limitations, and open directions

A common misconception is that in-solve coarsening is equivalent to explicit remeshing. The AGIPC formulation is explicit that it preserves the original fine topology as a static backbone and performs adaptivity algebraically inside each Newton step; this is presented as the key distinction from remeshing-based adaptivity, which changes connectivity and vertex ordering and leads to irregular memory access and GPU inefficiencies (Wang et al., 6 May 2026). Likewise, the octree multigrid solver performs matrix-free coarsening and interface correction without assembling sparse matrices, so the term does not imply mesh regeneration at every solve stage (Wang et al., 20 Apr 2026).

A second misconception is that algebraic consistency always means strict Galerkin equality at every interface. On uniform octree patches, the Galerkin identity is exact, but at T-junctions a strictly compact Galerkin operator cannot be maintained without wide stencils or local dense sub-blocks. The method therefore uses a flux-consistent coarse-grid correction rather than assembled wide-stencil Galerkin coarse operators at refinement interfaces (Wang et al., 20 Apr 2026). This is best understood as preserving consistency in an aggregate-flux sense rather than literal stencil equality.

The literature also identifies several limitations. In the octree setting, very high refinement ratios and strongly anisotropic $3$3 may require deeper W-cycles, the ghost-based flux matching can introduce mild local asymmetries in $3$4, and extreme cut-cell configurations increase iteration counts and reduce throughput (Wang et al., 20 Apr 2026). In AGIPC, over-aggressive coarsening can degrade accuracy or increase Newton iterations, complex contact scenes require wide protected regions, highly nonuniform meshes reduce aggregation effectiveness, and affine embedding can lock fine differential motion if clusters are too large (Wang et al., 6 May 2026). In adaptive Schwarz and DD settings, in-solve enrichment creates a variable preconditioner, so PCG correctness requires either fixed-within-run updates, restarts, or flexible Krylov methods such as flexible CG or GMRES (Heinlein et al., 2022, Nataf et al., 2024).

Several future directions recur across the papers. The octree work points to more compact operator encodings across interfaces, mortar-like constraints at refinement boundaries, and improved $3$5-aware transfer operators that preserve strict Galerkin behavior in more adaptive configurations (Wang et al., 20 Apr 2026). AGIPC explicitly lists multi-level coarsening, adaptive refinement by un-aggregation, advanced coarse-level preconditioners, and hybrid CPU-GPU execution (Wang et al., 6 May 2026). The DD and AMG literature suggests residual-driven enrichment, local generalized eigenmodes, dynamic Krylov-derived coarse components, localized simulated annealing, LARS warm-start updates, and uncertainty-driven coarse-point insertion as principled ways to turn static algebraic coarse spaces into fully adaptive in-solve mechanisms (Edwards et al., 2015, Zaman et al., 2021, Kahl et al., 2018, Gottschalk et al., 2020).

Taken together, these works indicate that Algebraic Adaptive In-Solve Coarsening is less a single canonical algorithm than an organizing idea: preserve the fine discretization or fine topology when desirable, detect where reduced representation is admissible from algebraic information, construct or update the coarse representation inside the active solve, and do so in a way compatible with modern iterative methods and hardware.