Fault Tolerance of Accelerated Asynchronous Fixed-Point Iterations on Flexible Computing Infrastructure EVAN COLEMAN, University of Mary Washington, USA MASHA SOSONKINA, Old Dominion University, USA Asynchronous iterative methods tolerate straggling processors by allowing workers to proceed with stale data, but at a cost: the iterates become inconsistent, potentially degrading convergence. We investigate whether convergence accelerators such as Anderson
arXiv:2605.28426v1 [cs.DC] 27 May 2026
acceleration compensate for this degradation. We experimentally study three fixed-point iterations: the Jacobi method for sparse linear systems, value iteration for the Bellman equation, and the Hartree–Fock self-consistent field (SCF) iteration. The experiments are conducted using a high-performance execution framework Ray, which abstracts the complexity of distributed systems and enables code parallelization and fault injection with minimal changes. We establish two main results. First, straggler tolerance is universal: asynchronous execution provides wall-clock speedups of 2.9× (Jacobi), 7.7× (VI), and 16.9× (SCF) over synchronous execution with a 100 ms-delayed worker, independent of whether acceleration is used. Second, Anderson acceleration’s effectiveness under asynchrony depends on where staleness enters the computation. We identify two staleness mechanisms: iterate-level corruption, where stale worker returns directly overwrite portions of the accelerated iterate (as in block Jacobi), and evaluation-level perturbation, where staleness acts as a bounded perturbation to the fixed-point map evaluation (as in VI and SCF). Anderson acceleration fails categorically under the first mechanism but retains its benefits under the second, consistent with the perturbation analysis of Toth et al. (2017). This distinction, rather than the contraction norm or smoothness of the map, is the primary determinant of whether acceleration survives asynchronous execution. CCS Concepts: • Computer systems organization → Cloud computing; • Mathematics of computing → Numerical analysis; • Computing methodologies → Parallel algorithms. Additional Key Words and Phrases: asynchronous iteration, Anderson acceleration, DIIS, fault tolerance, distributed computing, value iteration, reinforcement learning, flexible infrastructure ACM Reference Format: Evan Coleman and Masha Sosonkina. 2026. Fault Tolerance of Accelerated Asynchronous Fixed-Point Iterations on Flexible Computing Infrastructure. In The 35th International Symposium on High-Performance Parallel and Distributed Computing (HPDC ’26), July 13–16, 2026, Cleveland, OH, USA. ACM, New York, NY, USA, 16 pages. https://doi.org/10.1145/3806645.3816236
1
Introduction
Fixed-point iterations, 𝑥 (𝑘+1) = 𝐺 (𝑥 (𝑘 ) ), are found in many places throughout scientific computing. Classical iterative solvers for linear systems (Jacobi, Gauss–Seidel, Richardson), value iteration for Markov decision processes, and self-consistent field (SCF) iterations in electronic structure theory are prominent examples. In standard parallel implementations, these methods execute in a bulk-synchronous fashion: all processors complete the current iteration before any can begin the next. This model is straggler-sensitive (a single slow processor determines the wall-clock time Authors’ Contact Information: Evan Coleman, University of Mary Washington, Fredericksburg, Virginia, USA, [email protected]; Masha Sosonkina, Old Dominion University, Norfolk, Virginia, USA, [email protected].
This work is licensed under a Creative Commons Attribution 4.0 International License. © 2026 Copyright held by the owner/author(s). Manuscript submitted to ACM
Manuscript submitted to ACM
1
of each step), as well as fragile (any hardware fault during an iteration typically requires discarding partial results and restarting from a checkpoint). As computing platforms grow more heterogeneous and adopt cloud-based and preemptible resources, both liabilities become increasingly costly. Asynchronous iterative methods, first analyzed by Chazan and Miranker [9] and unified by Frommer and Szyld [17], offer a possible alternative. In the asynchronous model, each processor updates its block of the solution using whatever information is currently available, potentially including stale values. When the underlying map is contractive, convergence is guaranteed under a bounded-delay assumption, although the asynchronous iteration may converge at a different rate, or to a different fixed point. Separately, convergence accelerators like Anderson acceleration [1] (equivalently, DIIS in quantum chemistry [25]) have long been used to speed up synchronous fixed-point iterations. These methods maintain a window of recent iterates and their residuals, then extrapolate to reduce the error. Their behavior under asynchronous execution, however, has received almost no study. This is a significant gap: if acceleration can compensate for the inconsistencies introduced by staleness, it could substantially broaden the regime in which asynchronous methods are practical. In this paper, we take a step toward closing this gap through systematic empirical investigation. We present a Ray-based experimental framework [21] for studying fault tolerance of asynchronous fixed-point iterations under controlled injection of delay. We study three iterations of increasing complexity: (1) Jacobi iteration for sparse linear systems. This is a linear fixed-point map whose asynchronous convergence is fully characterized by the spectral radius of the iteration matrix [9, 17]. The iteration contracts in the ℓ2 -norm, and the Walker–Ni equivalence [34] gives a reference convergence rate for the accelerated synchronous case. (2) Value iteration for the Bellman optimality equation. This is a nonlinear fixed-point map involving the nonsmooth max operator, contractive in the ℓ∞ -norm with contraction constant 𝛾 (the discount factor) [8]. Asynchronous value iteration is well studied [7], but its combination with Anderson acceleration raises subtle theoretical questions: the ℓ2 -norm least-squares problem at the heart of Anderson acceleration is mismatched to the ℓ∞ -contraction of the Bellman operator, and the non-smoothness of max violates regularity assumptions in existing convergence analyses [33]. Recent work has applied Anderson acceleration to synchronous value iteration [18, 28, 29]; we look to extend this by testing it under asynchronous execution with delays. (3) SCF iteration for electronic structure. This is a nonlinear fixed-point map whose contraction properties vary with problem parameters. We use the Pariser–Parr–Pople (PPP) model Hamiltonian [23, 24] as a testbed with tunable nonlinearity. To our knowledge, no prior work studies SCF under asynchronous execution These three problems span two axes of difficulty for Anderson-type acceleration, summarized in Table 1. The first axis is the contraction norm: Jacobi and SCF contract in the ℓ2 -norm, where Anderson’s least-squares residual minimization is naturally well-matched, while value iteration contracts in the ℓ∞ -norm, creating a norm mismatch. The second axis is the regularity of the map: the Bellman operator’s max is non-differentiable, which invalidates the quasi-Newton interpretation of Anderson acceleration [16] and the smoothness assumptions in convergence proofs [33], while Jacobi and SCF are both smooth. By testing the same coordinator-level acceleration mechanism on all three, we can begin to disentangle which theoretical properties are actually necessary for Anderson acceleration to correct async bias. In all three settings, we apply Anderson acceleration at the coordinator level; the same algorithmic mechanism under different names (Anderson mixing for Jacobi and VI, DIIS for SCF), and study whether it can compensate for the convergence degradation introduced by staleness. Our central finding is that the answer depends not on the contraction 2
Table 1. Theoretical landscape of the three test problems.
Problem
Linear?
Contraction
Smooth?
Anderson theory
Jacobi Value iter. SCF
Yes No No
∥ · ∥2 ∥ · ∥∞ ∥ · ∥2
Yes No Yes
= GMRES [34] Open / heuristic Local [33]
norm or smoothness properties (Table 1), but on how staleness enters the computation relative to the Anderson subspace. We identify two distinct mechanisms: • Iterate-level corruption (Jacobi): stale worker returns directly overwrite portions of the coordinator’s extrapolated iterate, destroying the subspace correction. Anderson fails at every window size and firing frequency tested. • Evaluation-level perturbation (VI, SCF): staleness acts as a bounded perturbation to the fixed-point map e(𝑥) = 𝐺 (𝑥) +𝑒, where ∥𝑒 ∥ is controlled by the contraction constant. Anderson retains its acceleration evaluation, 𝐺 properties, consistent with the perturbation analysis of Toth et al. [32]. This distinction provides a practical criterion for predicting whether acceleration will survive asynchronous execution: if the worker’s computation produces a full evaluation of the fixed-point map (possibly on stale data), acceleration works; if it produces a partial update that overwrites part of the iterate, acceleration fails. Separately, the straggler tolerance of the unaccelerated asynchronous iteration is robust across all three problems, providing wall-clock speedups of 2.9–16.9× at the cost of increased total work. 2
Related Work
The theoretical foundations were laid by Chazan and Miranker [9], extended to block decompositions by Baudet [6], and unified by Frommer and Szyld [17]. Bertsekas and Tsitsiklis [7] established convergence of asynchronous value iteration. More recent work has analyzed convergence rates under randomization [4], asynchronous Richardson iterations [12], and performance models for asynchronous Jacobi [19, 20]. Fault tolerance for asynchronous iterative methods has been approached from several angles. Algorithm-based fault tolerance (ABFT) techniques, pioneered by Chen [10] for synchronous iterations extended by Sao and Vuduc [27] via selfstabilizing solvers, detect and correct soft errors through invariant-checking and state projection. These self-stabilizing techniques have been further applied to asynchronous methods by Coleman and Sosonkina [14]. Anzt et al. [2] showed that component-wise update rejection transforms a synchronous Jacobi into an asynchronous fault-tolerant iteration with modest convergence delay. Coleman et al [13] investigated soft-error vulnerability of asynchronous stationary solvers directly, proposing detection and recovery strategies based on monitoring component-wise residuals and providing a theoretical framework for fault impact on asynchronous convergence. These approaches target silent data corruption (bit-flips, memory errors); our work targets delay-induced staleness as the fault model, motivated by cloud and heterogeneous-cluster deployments where straggling and preemption dominate. Anderson [1] and Pulay [25] independently proposed mathematically equivalent acceleration methods. Walker and Ni [34] proved the GMRES equivalence for linear problems; Toth and Kelley [33] established local convergence of Anderson(𝑚); Evans et al. [15] proved strict rate improvement for linearly converging methods. Fang and Saad [16] followed by Rohwedder and Schneider [26] analyzed DIIS convergence; Banerjee et al. [5] proposed Periodic Pulay. To our knowledge, no existing electronic structure code implements asynchronous SCF [30]. A result of particular relevance 3
to our setting is that of Toth et al. [32], who analyzed Anderson acceleration with inaccurate function evaluations; a model that encompasses the stale evaluations characteristic of asynchronous execution. They showed local improvement results persist under bounded perturbation, though they did not study the asynchronous setting explicitly. Zhang et al. [35] established global convergence of Anderson acceleration for non-smooth fixed-point iterations under only a nonexpansiveness assumption, which is directly relevant to the Bellman operator’s max non-smoothness. To our knowledge, no prior work applies Anderson acceleration (or DIIS) as a coordinator-level corrector in an asynchronous iteration. Separately, Geist and Scherrer [18] first applied Anderson acceleration to (synchronous) value iteration, reporting significant speedups but noting the lack of theoretical guarantees. Shi et al. [28] proposed Regularized Anderson Acceleration (RAA) for off-policy deep RL. Sun et al. [29] provided the first convergence analysis for Andersonaccelerated policy iteration by using the smooth MellowMax operator to replace max, showing that smoothing restores the contraction and differentiability properties that Anderson acceleration requires. Despite this active literature on Anderson acceleration for synchronous RL, no prior work combines it with asynchronous execution, which is a notable gap given that the Ray framework underlying much modern RL was designed precisely for asynchronous distributed computation. 3
Background
3.1
Asynchronous Fixed-Point Iteration
Consider a fixed-point iteration 𝑥 (𝑘+1) = 𝐺 (𝑥 (𝑘 ) ) with the solution partitioned into 𝑝 blocks: 𝑥 = (𝑥 1, . . . , 𝑥 𝑝 ). In the Frommer–Szyld asynchronous model [17], processor 𝑙 updates its block using a snapshot that may lag behind the global state: (𝑠 (𝑘 ) )
𝑥𝑙(𝑘+1) = 𝐺𝑙 𝑥 1(𝑠1 (𝑘 ) ) , . . . , 𝑥 𝑝 𝑝
(1)
where 𝑠 𝑗 (𝑘) ≤ 𝑘 records the vintage of block 𝑗 as seen by processor 𝑙 at iteration 𝑘. The bounded delay assumption requires 𝑘 − 𝑠 𝑗 (𝑘) ≤ 𝜏 for some finite 𝜏. Theorem 3.1 (Frommer–Szyld [17]). If 𝐺 is a contraction on a complete metric space with contraction constant 𝜌 (|𝐶 |) < 1, then the asynchronous iteration (1) converges to the unique fixed point 𝑥 ∗ under the bounded delay assumption. For linear systems 𝐴𝑥 = 𝑏 with the Jacobi splitting 𝐴 = 𝐷 − (𝐿 + 𝑈 ), the iteration matrix is 𝑀 = 𝐷 −1 (𝐿 + 𝑈 ) and convergence requires 𝜌 (𝑀) < 1. For nonlinear maps such as the SCF iteration, the relevant spectral radius is that of the Jacobian 𝜕𝐺/𝜕𝑥 evaluated at the fixed point. 3.2
Anderson Acceleration
𝑘 Anderson acceleration [1] maintains a window of 𝑚 recent iterates {𝑥 (𝑘 − 𝑗 ) } 𝑗=0 and their residuals 𝑟 (𝑘 ) = 𝐺 (𝑥 (𝑘 ) ) − 𝑥 (𝑘 ) .
𝑚
It computes coefficients {𝛼 𝑗 } by solving min 𝛼 0 ,...,𝛼𝑚𝑘
and forms 𝑥 (𝑘+1) =
Í
𝑗 𝛼 𝑗 𝐺 (𝑥
𝑚𝑘 ∑︁
𝛼 𝑗 𝑟 (𝑘 − 𝑗 )
𝑗=0
2
s.t.
𝑚𝑘 ∑︁
𝛼 𝑗 = 1,
(2)
𝑗=0
(𝑘 − 𝑗 ) ).
This is identical to Pulay’s DIIS [25], where 𝑥 (𝑘 ) is the Fock matrix 𝐹𝑘 and 𝑟 (𝑘 ) is the commutator error 𝐹𝑘 𝑃𝑘 𝑆 −𝑆𝑃𝑘 𝐹𝑘 . The equivalence was established by Fang and Saad [16] and further analyzed by Rohwedder and Schneider [26]. 4
Two results are central to our setting. First, Walker and Ni [34] proved that for affine 𝐺 (𝑥) = 𝑀𝑥 + 𝑏, Anderson acceleration without truncation is equivalent to GMRES applied to (𝐼 − 𝑀)𝑥 = 𝑏. This gives convergence rate predictions for the Jacobi case. Second, Toth et al. [32] showed that Anderson acceleration retains local improvement properties e(𝑥) = 𝐺 (𝑥) + 𝑒, provided ∥𝑒 ∥ is sufficiently small, which is a model that under inaccurate function evaluations 𝐺 naturally encompasses the stale evaluations arising in asynchronous execution. 3.3
Test Problems
3.3.1 Asynchronous Jacobi. For sparse 𝐴𝑥 = 𝑏 with splitting 𝐴 = 𝐷 − 𝐿 − 𝑈 , the Jacobi iteration 𝑥 (𝑘+1) = 𝐷 −1 (𝑏 + (𝐿 + 𝑈 )𝑥 (𝑘 ) ) has residual 𝑟 (𝑘 ) = 𝑏 − 𝐴𝑥 (𝑘 ) . In our partitioned model, worker 𝑙 owns rows 𝑖 ∈ B𝑙 and computes Í (𝑠 (𝑘 ) ) 𝑥𝑖(𝑘+1) = 𝑑𝑖𝑖−1 𝑏𝑖 − 𝑗≠𝑖 𝑎𝑖 𝑗 𝑥 𝑗 𝑗 . The coordinator collects partial updates as they arrive and applies Anderson acceleration over the global iterate/residual history. This provides a controlled testbed since prior work helps define expected convergence rates. 3.3.2 Asynchronous Value Iteration. A Markov decision process (MDP) is defined by states S, actions A, transition probabilities 𝑃 (𝑠 ′ |𝑠, 𝑎), rewards 𝑅(𝑠, 𝑎), and a discount factor 𝛾 ∈ (0, 1). The optimal value function 𝑉 ∗ satisfies the Bellman optimality equation h i ∑︁ 𝑉 ∗ (𝑠) = max 𝑅(𝑠, 𝑎) + 𝛾 𝑃 (𝑠 ′ |𝑠, 𝑎) 𝑉 ∗ (𝑠 ′ ) . 𝑎∈ A
(3)
𝑠′ ∈ S
This defines a fixed-point map, 𝑉 = 𝑇𝑉 , where the Bellman operator 𝑇 is a 𝛾-contraction in the supremum norm [8]. Value iteration 𝑉 (𝑘+1) = 𝑇𝑉 (𝑘 ) converges at rate 𝛾 for any initial 𝑉 (0) . In our partitioned model, the state space is divided among 𝑝 workers, where worker 𝑙 owns states 𝑠 ∈ S𝑙 and computes 𝑉 (𝑘+1) (𝑠) = max [𝑅(𝑠, 𝑎) + 𝛾
∑︁
𝑎
𝑠′
𝑃 (𝑠 ′ |𝑠, 𝑎) 𝑉 (𝑠𝑠 ′ (𝑘 ) ) (𝑠 ′ )],
(4)
where 𝑠𝑠 ′ (𝑘) reflects potentially stale values of other workers’ states. Asynchronous convergence is guaranteed under bounded delay by the ℓ∞ -contraction of 𝑇 [7]. As noted in Table 1, value iteration poses two challenges for Anderson: ℓ2 /ℓ∞ norm mismatch and non-differentiability of max [16, 33]. Despite these concerns, Anderson acceleration has been empirically successful on synchronous value iteration. Geist and Scherrer [18] reported significant speedups. Sun et al. [29] addressed the non-smoothness by replacing max with the smooth MellowMax operator, enabling a convergence proof for the accelerated iteration. Zhang et al. [35] proved global convergence of a stabilized Anderson variant for non-smooth nonexpansive maps, requiring only nonexpansiveness, which is a property that the Bellman operator satisfies (it is in fact contractive). Our experiments test whether these empirical and theoretical results for synchronous Anderson-accelerated VI extend to the asynchronous setting under faults. As a sub-experiment, we also test policy evaluation (the linear fixed-point 𝑉 𝜋 = 𝑟 𝜋 + 𝛾𝑃 𝜋 𝑉 𝜋 ) which removes the max operator and gives a linear system (𝐼 − 𝛾𝑃 𝜋 )𝑉 = 𝑟 𝜋 . Anderson acceleration applies cleanly via the Walker–Ni GMRES equivalence, but the ℓ∞ -contraction (with constant 𝛾) remains. Comparing policy evaluation against full value iteration isolates the effect of non-smoothness from the effect of norm mismatch. 3.3.3 Asynchronous SCF. The Hartree–Fock SCF iteration defines a nonlinear fixed-point map F : 𝑃 ↦→ 𝑃 ′ on the one-particle density matrix [31], given 𝑃, (1) builds the Fock matrix, 𝐹 𝜇𝜈 = 𝐻 𝜇𝜈 +
Í
1 𝜆𝜎 𝑃𝜆𝜎 [(𝜇𝜈 |𝜆𝜎) − 2 (𝜇𝜆|𝜈𝜎)], 5
(2) solves 𝐹𝐶 = 𝑆𝐶𝜺, and ′ = 2Í (3) forms 𝑃 𝜇𝜈 𝑖 ∈occ 𝐶 𝜇𝑖 𝐶 𝜈𝑖 . We partition 𝑃 by rows: worker ℓ owns rows 𝜇 ∈ Bℓ , reads the current (possibly stale) global 𝑃, executes the full SCF map, and returns only its owned rows of 𝑃 ′ . The coordinator assembles, symmetrizes, and optionally applies DIIS/Anderson acceleration. As a model problem with full HF algebraic structure but no integral evaluation cost, we use the Pariser–Parr–Pople (PPP) Hamiltonian [23, 24] for a 1D atomic chain. Each atom contributes one orthogonal basis function (𝑆 = 𝐼 ), the core Hamiltonian has nearest-neighbor hopping 𝑡, and two-electron integrals use the Ohno parameterization [22]: √︁ 𝛾 𝜇𝜈 = 𝑈 / 1 + (𝑈 𝑅 𝜇𝜈 ) 2 , where 𝑈 is the on-site Coulomb repulsion. The ratio 𝑈 /|𝑡 | controls the correlation strength and hence the spectral radius of the SCF Jacobian: small 𝑈 /|𝑡 | gives rapid contraction; large 𝑈 /|𝑡 | can cause oscillation or divergence even synchronously. The PPP model is a standard benchmark for SCF convergence studies, providing full Hartree–Fock algebraic structure (Fock build, diagonalization, density construction) at minimal computational cost [31]. It has been used to test DIIS convergence [26], level-shifting strategies, and other acceleration techniques. 3.4
Coordinator-Level Acceleration Under Asynchrony
In all three test problems, the coordinator maintains a history of global iterates and residuals and applies Anderson Acceleration via the least-squares problem Equation (2). Under asynchronous execution, each iterate in the history is a composite: some blocks are current while others are stale. The residual is therefore evaluated at an inconsistent point. We identify three modes: (1) Monitor-only: compute the residual norm for convergence monitoring but do not modify the iterates. Workers always see the raw asynchronously updated solution. (2) Coordinator acceleration: extrapolate the solution at the coordinator and feed the accelerated iterate back to workers. This periodically “resets” the global state toward a consistent solution, limiting staleness-induced drift. (3) Periodic acceleration: apply mode (2) every 𝑘 iterations with damped linear mixing in between, following the Periodic Pulay approach [5]. For Jacobi, mode (2) corresponds to Anderson-accelerated Jacobi, which is equivalent to preconditioned GMRES in the synchronous case [34]. For SCF, mode (2) is coordinator DIIS. For value iteration, mode (2) is Anderson-accelerated VI in the style of Geist and Scherrer [18], with the residual defined as 𝑟 (𝑘 ) = 𝑇𝑉 (𝑘 ) − 𝑉 (𝑘 ) , the Bellman residual. Testing the same mechanism on all three problems, each with different contraction norms and regularity properties, is the core experimental design. 3.5
Staleness and Acceleration: A Coupling Perspective
Consider a partitioned fixed-point iteration with 𝑝 workers and coordinator-level Anderson acceleration. After the coordinator computes the extrapolated iterate 𝑥˜ (𝑘 ) , each worker ℓ begins computing on a snapshot 𝑥ˆℓ(𝑘 ) that may differ from 𝑥˜ (𝑘 ) due to communication delays. The worker returns a partial result that the coordinator incorporates into the global state. The question is whether the Anderson subspace — built from the history of these composite, partially-stale iterates — retains enough structure to accelerate convergence. The key observation is that different fixed-point maps produce partial updates with very different information content. In value iteration, the Bellman update for a single state 𝑠 reads the entire value vector through the transition Í matrix: 𝑇𝑉 (𝑠) = max𝑎 [𝑅(𝑠, 𝑎) + 𝛾 𝑠 ′ 𝑃 (𝑠 ′ |𝑠, 𝑎) 𝑉 (𝑠 ′ )]. Even though a worker returns updates for only |Sℓ | states, each 6
update reflects the global state of the iterate. In the framework of Toth et al. [32], the staleness acts as a bounded e(𝑥) = 𝐺 (𝑥) + 𝑒, where ∥𝑒 ∥ ≤ 𝜌 𝜏 is controlled by the contraction constant 𝜌 and perturbation to the map evaluation, 𝐺 the staleness depth 𝜏. Under this bound, Anderson acceleration retains its local improvement properties. By contrast, in Jacobi iteration on a sparse system (e.g., a 2D Laplacian with the 5-point stencil), the update for Í 𝑗 ∈ N (𝑖 ) 𝑎𝑖 𝑗 𝑥 𝑗 ). Each worker’s return encodes local boundary
DOF 𝑖 reads only its immediate neighbors: 𝑥𝑖+ = 𝑑𝑖𝑖−1 (𝑏𝑖 −
information, not global structure. When these returns are assembled into the global iterate and fed to Anderson, the subspace history is dominated by block-boundary artifacts rather than the global error modes that Anderson needs to build an effective extrapolation. We refer to this property as the coupling density of the fixed-point map: the fraction of the full iterate that each DOF’s update depends on. Value iteration has coupling density close to 1 (every state couples to every other through 𝑃). Jacobi on a banded system has coupling density O (1/𝑁 ) for each DOF, though the block-level coupling (fraction of a block’s neighbors within the same block) can be higher. Our coupling threshold experiments (Section 5.1) show that block internal coupling must exceed ∼90% for the base iteration to benefit from multi-sweep local solves, confirming that the information content of each worker’s return is the critical factor. The practical implication is a design heuristic: Anderson acceleration under asynchrony is most likely to succeed when each worker’s computation depends on a large fraction of the global iterate (high coupling density), because the resulting partial updates carry enough global information for the subspace to remain well-conditioned. Coupling density thus determines which staleness mechanism dominates: high coupling produces evaluation-level perturbation (bounded by 𝜌 𝜏 ), while low coupling produces iterate-level corruption that destroys the Anderson subspace. When coupling is low, as in banded linear solvers, acceleration may require alternative strategies such as having workers return full residual evaluations rather than partial updates, or using smaller blocks to reduce the stale fraction. 4
Implementation
Our framework uses Ray [21] actors, one per worker, each executing its iteration map and returning partial updates. A coordinator actor collects results via ray.wait(), applies updates in arrival order, optionally runs the Anderson / DIIS extrapolation, and relaunches workers. Fault injection is controlled per-worker through a FaultProfile parameterizing delay (mean/std), additive Gaussian noise on returned components, drop probability, and maximum staleness. Convergence is measured in worker-updates, the number of partial updates applied, which provides a consistent work metric across synchronous and asynchronous modes. A key implementation detail is the safeguard on Anderson extrapolation. After computing the extrapolated iterate 𝑥˜ (𝑘+1) , the coordinator evaluates the residual and accepts the step only if, ∥𝐺 (𝑥˜ (𝑘+1) ) − 𝑥˜ (𝑘+1) ∥ < ∥𝐺 (𝑥 (𝑘 ) ) − 𝑥 (𝑘 ) ∥.
(5)
Otherwise, the un-extrapolated iterate 𝐺 (𝑥 (𝑘 ) ) is used. This safeguard is essential: without it, Anderson acceleration diverges catastrophically for value iteration (residual → 1068 ) due to the ℓ2 /ℓ∞ norm mismatch, and can produce transient blowups for Jacobi under high staleness. For Jacobi, we use the 2D Laplacian on a 100 × 100 grid (𝑁 = 10,000 unknowns) with the standard 5-point stencil, partitioned into contiguous blocks across 4 workers. Each worker performs 10 local Jacobi sweeps per update, which is effective when the block’s internal coupling (fraction of a DOF’s neighbors within the same block) exceeds approximately 90%. For value iteration, we use Garnet random MDPs [3] with |S| ∈ {200, 500, 1000}, |A| ∈ {4, 10}, branching factor 𝑏 = 5, and 𝛾 ∈ {0.9, 0.95, 0.99}. Grid-world navigation problems with known optimal policies serve as validation. 7
Table 2. Straggler tolerance: sync vs. async Jacobi (100×100 grid, 4 workers). All experiments converge.
Delay
0 ms 5 ms 20 ms 100 ms
Synchronous
Asynchronous
WU
Time
WU
Time
speedup
12,960 12,960 12,960 12,960
23.4 s 30.5 s 87.8 s 348.0 s
15,610 15,400 23,710 81,535
17.6 s 20.4 s 33.2 s 118.6 s
1.3× 1.5× 2.6× 2.9×
(a) Work efficiency Relative residual b Ax / b
Wall
(b) Wall-clock performance
Straggler delay
100
0ms 5ms 20ms 100ms
10 1 10 2 10 3 10 4 10 5
Synchronous Asynchronous
10 6 0
20000
40000
60000
Worker updates
80000
0
50
100 150 200 250 300 350
Wall time (s)
Fig. 1. Jacobi straggler tolerance. Left: residual vs. worker-updates (sync curves overlap; async fans right). Right: residual vs. wall time (sync fans right; async stays compact). Solid = synchronous; dashed = asynchronous.
For SCF, we use the PPP chain with 𝑛 atoms = 8 at 𝑈 /|𝑡 | ∈ {2, 2.5} and 𝑛 atoms = 20 at 𝑈 /|𝑡 | = 4. Straggler experiments inject per-worker delays of 5–100 ms on one or two workers; all experiments are repeated over multiple fault realizations. All experiments were run on the ACES HPC cluster at Texas A&M University using 2 nodes with 8 CPUs each. 5
Results
5.1
Jacobi Iteration
Table 2 summarizes the straggler tolerance experiments on a 100 × 100 Laplacian with 4 workers, where one worker is artificially delayed. Synchronous iteration always converges in exactly 12,960 worker-updates (WU), equal 3,240 rounds × 4 workers, regardless of delay; the algorithm is deterministic and delay only affects wall time. Asynchronous iteration needs progressively more work (up to 6.3×) because the straggler’s DOFs become stale, but the wall-clock savings dominate: 2.9× faster even at 100 ms delay (Figure 1). In synchronous mode, Anderson acceleration is spectacularly effective: Anderson(20) reduces the iteration count by 38× (85 vs. 3,240 iterations), consistent with the Walker–Ni GMRES equivalence [34]. In asynchronous mode, however, Anderson actively hurts convergence regardless of tuning (Figure 2). We swept both the window size 𝑚 ∈ {1, 2, 3, 5, 10, 20} and the firing frequency (every 𝐸 ∈ {1, 2, 4, 8, 16, 32} worker returns). Every combination requires more worker-updates than plain async Jacobi (Table 2). Firing every 𝐸 = 2 or 𝐸 = 4 returns causes divergence; firing less 8
Fig. 2. Anderson acceleration for async Jacobi. (a) Window size: sync improves monotonically; async always above the no-Anderson baseline (gray line). (b) Firing frequency: 𝐸 = 2, 4 diverge; 𝐸 ≥ 8 converge but do not beat no-Anderson.
frequently (𝐸 ≥ 8) converges but still requires 40–60% more work than the un-accelerated baseline. The mechanism is clear: when Anderson extrapolates the global iterate, workers with in-flight updates computed on the pre-extrapolation state return stale results that partially overwrite the extrapolated solution. This is consistent with the coupling density analysis of Section 3.5: each Jacobi worker’s return encodes only local boundary information (low coupling), so the Anderson subspace history is dominated by block-boundary artifacts rather than global error modes. No amount of tuning recovers the Anderson-acceleration benefit because the information deficit is structural. We identify a sharp threshold for multi-sweep local solves (Figure 3): block internal coupling must exceed ∼90% for multiple sweeps to be effective. Below this threshold (1–2 rows, 66–86% coupling), 10 sweeps provide negligible benefit; above it (5–10 rows, 95–97%), they yield a 30,000× improvement, explaining the block design choice in [11]. 5.2
Value Iteration
We test on Garnet MDPs with |S| ∈ {200, 500, 1000} and 𝛾 ∈ {0.9, 0.95, 0.99}, using 4 workers and 10 random fault realizations per configuration. Unlike the Jacobi case, safeguarded Anderson(5) provides a consistent 1.2–1.7× iteration reduction for value iteration in both synchronous and asynchronous modes (Figure 4). The benefit grows with the discount factor: 1.2× at 𝛾 = 0.9, 1.4× at 𝛾 = 0.95, and 1.7× at 𝛾 = 0.99 in synchronous mode (Figure 5). In asynchronous mode, Anderson provides a ∼1.3× speedup at 𝛾 ≤ 0.95; at 𝛾 = 0.99 the perturbation bound loosens and Anderson still helps but requires a larger iteration budget (Figure 5). Damping (𝛼 = 0.3) uniformly hurts convergence compared to plain async VI. This is consistent with the coupling density analysis of Section 3.5: the Bellman operator couples each state to the full value vector through the transition matrix, so each worker’s partial update carries global information. Staleness enters as a bounded perturbation ∥𝑒 ∥ ≤ 𝛾 𝜏 to the map evaluation, within the regime analyzed by Toth et al. [32]. The bound 9
Final residual (100k wu)
10 1
~90% threshold
10 3
Tolerance 1 sweep 10 sweeps
10 5 10 7 10 9
1 row (66%)
2 rows (86%)
5 rows (95%)
10 rows (97%)
Block size (internal coupling)
Fig. 3. Block coupling threshold. Multi-sweep local solves become transformative above ∼90% internal coupling.
Value iteration: Garnet(500,4,5), 4 workers (ACES) Sync VI Sync Anderson(5) Async VI Async Anderson(5) Async damped
10 1 10 3 10 5
(b) Error vs V*
101 10 1
Error
Bellman residual
(a) Bellman residual
10 3 10 5 10 7
10 7 500 1000 1500 2000 2500
500 1000 1500 2000 2500
Worker updates
Worker updates
Fig. 4. VI convergence on Garnet(500,4,5,𝛾 =0.95). Anderson(5) accelerates both sync and async. Damping hurts. Dashed = async (median of 10 realizations).
tightens with 𝛾, explaining why Anderson’s benefit grows with the discount factor while simultaneously predicting that it will diminish as 𝛾 → 1. Selection strategy interacts with coupling density (Section 3.5). For Jacobi, block size is the primary factor and greedy selection does not help, likely because residuals are dominated by block-boundary effects. For VI, greedy selection converges in 2,680 iterations vs. >5,000 for uniform at 𝑘 = 25, suggesting that which states to update matters more than how many; consistent with VI’s high coupling density propagating corrections globally. Fixed-partition async (𝑘 = 125) converges fastest in total work (1,680 iterations) by avoiding selection overhead. 10
Bellman residual TV V
Anderson acceleration across discount factors (ACES) S=200, =0.9
S=500, =0.95
S=1000, =0.99
Sync Sync+AA Async Async+AA
10 1 10 3 10 5 10 7 250
500
750
Worker updates
1000
500 1000 1500 2000 0
Worker updates
2000 4000 6000
Worker updates
Fig. 5. Anderson benefit grows with 𝛾 . At 𝛾 = 0.99, sync Anderson reduces iterations by 1.7× but async needs more budget. Orange = Anderson; blue = plain.
VI selection strategies: Garnet(500,4,5) (ACES)
(a) Bellman residual Sync+AA Async fixed (k=125) Uniform k=50 Greedy k=25 Greedy k=50
10 3 10 5
(b) Error vs V* 10 1
Error vs V*
Bellman residual
10 1
10 7
10 3 10 5 10 7
0
5000
10000
15000
0
Worker updates
5000
10000
15000
Worker updates
Fig. 6. VI selection strategies. Greedy outperforms uniform at every 𝑘. Fixed partition is fastest in total work.
5.3
SCF Iteration
We test the PPP Hamiltonian at two regimes of correlation strength (Figure 9). Synchronous SCF+DIIS converges in 28 iterations to machine precision (Δ𝐸 = 2.8 × 10−14 eV). Without DIIS, asynchronous SCF converges to a different fixed point with 0.6 eV energy error. With coordinator-level DIIS, however, asynchronous SCF converges to the correct energy with error 6.5 × 10−7 eV in 177 iterations—6.3× more iterations than sync, but the same correct answer. This demonstrates that DIIS can correct the async bias for SCF at weak correlation, at the cost of increased iteration count. 11
Bellman residual TV V
(a) Work efficiency
101
(b) Wall-clock performance
Straggler delay 0ms 5ms 20ms 100ms
10 1 10 3 10 5
Synchronous Asynchronous
0
10000
20000
30000
0
Worker updates
5
10
15
Wall time (s)
20
25
Fig. 7. VI straggler tolerance on Garnet(500,4,5,𝛾 =0.95), ACES data. Same pattern as Jacobi: sync curves fan out on wall time (right); async stays compact.
Async damped SCF, 8 atoms, U/|t| = 2.5, = 0.3 (straggler on worker 0) (a) Correct convergence rate
(b) Energy error (10 realizations)
0.8
Energy error |E Eref| (eV)
Fraction finding correct FP
1.0
7/10
0.6 0.4 0.2 0.0
2/10
3/10 0/10
0 ms
5 ms
20 ms
100 ms
10 1 correct FP threshold
10 3 10 5 10 7 10 9
Correct FP Wrong FP
0 ms
5 ms
20 ms
100 ms
Fig. 8. Stochastic SCF convergence at 𝑈 /|𝑡 | = 2.5 with damped mixing (10 realizations per delay). (a) Fraction finding the correct fixed point. (b) Energy error per realization; circles = correct FP, crosses = wrong FP.
At intermediate correlation (𝑈 /|𝑡 | = 2.5, 8 atoms), the SCF energy landscape admits multiple fixed points and async convergence becomes stochastic: different Ray scheduling realizations lead to different solutions. We ran 10 realizations of damped async SCF (𝛼 = 0.3) at each straggler delay (Figure 8). With no straggler, only 2/10 realizations find the correct fixed point; the other 8 converge to 6 distinct spurious solutions with Δ𝐸 ranging from 0.05 to 0.48 eV. Counterintuitively, moderate delay improves reliability: at 20 ms, 7/10 realizations find the correct energy (Δ𝐸 ∼ 10−5 eV). The likely mechanism is that the straggler effectively serializes one worker’s contributions, reducing the inconsistency among the remaining workers and narrowing the basin of attraction toward the correct solution. At 100 ms delay, no realization finds the correct fixed point: the perturbation bound is exceeded regardless of scheduling. 12
(a) 8 atoms, U/|t| = 2
10 1 10 2 Sync DIIS Async DIIS Async (no accel.)
10 3 10 4 10 5 10 6 10 7
0
50
100
Iteration
(b) 20 atoms, U/|t| = 4
101
SCF residual FPS SPF
SCF residual FPS SPF
100
100 10 1 10 3 10 4 10 5 10 6
150
Sync damped Async damped Async + 20ms Async + 100ms
10 2
0
100
200
300
Iteration
400
500
Fig. 9. SCF convergence. (a) 8 atoms, 𝑈 /|𝑡 | = 2: DIIS corrects async bias (177 vs. 28 iterations). (b) 20 atoms, 𝑈 /|𝑡 | = 4: damped SCF shows wall-clock straggler tolerance despite incomplete convergence.
At strong correlation (𝑈 /|𝑡 | = 4, 20 atoms), even synchronous DIIS diverges and damped SCF barely converges, but the straggler tolerance remains dramatic: 16.9× wall-clock speedup at 100 ms delay. All three regimes are consistent with the coupling density framework of §3.5: each worker computes the full SCF map on a stale density snapshot, coupling each basis function to all others through the two-electron integrals. The perturbation bound ∥𝑒 ∥ ≤ 𝜌 𝜏 depends on the spectral radius 𝜌 of the SCF Jacobian. At 𝑈 /|𝑡 | = 2, 𝜌 is small and DIIS retains its corrective power. At 𝑈 /|𝑡 | = 2.5, 𝜌 is large enough that the iteration is near the basin boundary—scheduling noise determines which fixed point is reached—explaining both the stochasticity and the non-monotonic effect of delay. 5.4
Analysis
Table 3 summarizes the experimental results through the lens of coupling density (Section 3.5). Straggler tolerance (row 1) is universal and independent of the acceleration question, depending only on the throughput advantage of asynchronous execution. The acceleration results (rows 2–4) are explained by the information content of each worker’s return. In VI and SCF, high coupling means each partial update reflects the full iterate; staleness acts as a bounded perturbation to the map evaluation, and Anderson/DIIS retains its benefits when the contraction is sufficiently strong (𝛾 ≤ 0.95 for VI, small 𝑈 /|𝑡 | for SCF). The 𝑈 /|𝑡 | = 2.5 SCF experiments further show that near the basin boundary, convergence becomes stochastic: scheduling order determines which fixed point is reached, and moderate delay can paradoxically improve reliability by partially serializing worker contributions. In Jacobi on a sparse system, each worker’s return encodes only local boundary information, and Anderson’s subspace cannot capture the global error modes needed for effective extrapolation; regardless of window size or firing frequency. This resolves an apparent puzzle: why does Anderson fail for Jacobi (a linear, ℓ2 -contractive, smooth problem with well-understood theory) but succeed for VI (a nonlinear, ℓ∞ -contractive, non-smooth problem with weaker guarantees)? 13
Table 3. Cross-problem comparison through the coupling density lens.
Straggler speedup Coupling density Anderson sync Anderson async
Jacobi
Value iter.
SCF
2.9× Low 38× Hurts
7.7× High 1.2–1.7× 1.3×
16.9× High DIIS: 28 iter Depends on 𝜌, 𝜏
The classical properties in Table 1 govern the synchronous iteration. Under asynchrony, the relevant property is how much global information each worker’s computation carries—a property of the problem’s structure, not its contraction norm or smoothness. An open question is whether low-coupling problems like Jacobi can be restructured (e.g., having workers return full residual vectors rather than solution updates, or using overlapping blocks) to recover acceleration benefits. 6
Conclusion
The critical factor is coupling density: how much of the global iterate does each worker’s computation depend on? High coupling (VI, SCF) produces evaluation-level perturbation bounded by 𝜌 𝜏 , and Anderson/DIIS retains its acceleration within the regime predicted by Toth et al. [32]. Low coupling (Jacobi) produces iterate-level corruption, and no tuning of window size or firing frequency recovers the benefit. This explains why Anderson fails for the mathematically “easiest” problem (linear, smooth Jacobi) but succeeds for the “hardest” (nonlinear, non-smooth VI): the relevant property is coupling structure, not contraction norm or smoothness. This distinction is a property of the system design—how workers partition and return their work—not the underlying mathematics, providing a practical criterion for predicting whether acceleration will survive asynchronous deployment. Separately, we confirm that the straggler tolerance of unaccelerated asynchronous iteration is universal across all three problems, providing wall-clock speedups of 2.9–16.9× at the cost of 1.2–6.3× more total work. This tradeoff is independent of the acceleration question and represents the primary practical value of asynchronous methods on flexible infrastructure. Two additional findings provide practical design guidance. First, for spatially-coupled problems, multi-sweep local solves require block internal coupling above a sharp ∼90% threshold to be effective. Second, greedy (Gauss–Southwell) state selection substantially outperforms uniform random selection for value iteration. Future work will extend this framework to larger-scale cloud deployments with naturally occurring straggler distributions, and will investigate whether iterate-corruption problems can be redesigned (e.g., by having workers return full fixed-point map evaluations rather than partial updates) to recover acceleration benefits. Acknowledgments This work leveraged the ACES Cluster at Texas A&M University under allocation CIS250436 from the Advanced Cyberinfrastructure Coordination Ecosystem: Services & Support (ACCESS) program, which is supported by U.S. National Science Foundation grants #2138259, #2138286, #2138307, #2137603, and #2138296. References [1] Donald G. Anderson. 1965. Iterative Procedures for Nonlinear Integral Equations. J. ACM 12, 4 (1965), 547–560. doi:10.1145/321296.321305 [2] Hartwig Anzt, Jack Dongarra, and Enrique S. Quintana-Ortí. 2019. Fine-grained bit-flip protection for relaxation methods. Journal of Computational Science 36 (2019). doi:10.1016/j.jocs.2016.11.013 14
[3] Thomas W. Archibald, Ken I.M. McKinnon, and Lyn C. Thomas. 1995. On the Generation of Markov Decision Processes. Technical Report. University of Edinburgh. Journal of the Operational Research Society, 46(3):354–361. [4] Haim Avron, Alex Druinsky, and Anshul Gupta. 2015. Revisiting Asynchronous Linear Solvers: Provable Convergence Rate Through Randomization. J. ACM 62, 6 (2015), 51:1–51:27. doi:10.1145/2814566 [5] Amartya S. Banerjee, Phanish Suryanarayana, and John E. Pask. 2016. Periodic Pulay Method for Robust and Efficient Convergence Acceleration of Self-Consistent Field Iterations. Chemical Physics Letters 647 (2016), 31–35. doi:10.1016/j.cplett.2016.01.033 [6] Gérard M. Baudet. 1978. Asynchronous Iterative Methods for Multiprocessors. J. ACM 25, 2 (1978), 226–244. doi:10.1145/322063.322067 [7] Dimitri P. Bertsekas and John N. Tsitsiklis. 1989. Parallel and Distributed Computation: Numerical Methods. Prentice Hall. [8] Dimitri P. Bertsekas and John N. Tsitsiklis. 1996. Neuro-Dynamic Programming. Athena Scientific, Belmont, MA. [9] Daniel Chazan and Willard Miranker. 1969. Chaotic Relaxation. Linear Algebra Appl. 2, 2 (1969), 199–222. doi:10.1016/0024-3795(69)90028-7 [10] Zizhong Chen. 2013. Online-ABFT: An online algorithm based fault tolerance scheme for soft error detection in iterative methods. In Proc. 18th ACM SIGPLAN Symp. Principles and Practice of Parallel Programming (PPoPP). 167–176. doi:10.1145/2442516.2442533 [11] Edmond Chow, Hartwig Anzt, and Jack Dongarra. 2015. Asynchronous Iterative Algorithm for Computing Incomplete Factorizations on GPUs. In High Performance Computing (ISC High Performance 2015) (Lecture Notes in Computer Science, Vol. 9137). Springer, 1–16. doi:10.1007/978-3-319-20119-1_1 [12] Edmond Chow, Andreas Frommer, and Daniel B. Szyld. 2021. Asynchronous Richardson Iterations: Theory and Practice. Numerical Algorithms 87 (2021), 1635–1651. doi:10.1007/s11075-020-01023-3 [13] Evan Coleman, Erik J Jensen, and Masha Sosonkina. 2021. Fault recovery methods for asynchronous linear solvers. International Journal of Parallel Programming 49, 1 (2021), 51–80. [14] Evan Coleman and Masha Sosonkina. 2018. Self-stabilizing fine-grained parallel incomplete LU factorization. Sustainable Computing: Informatics and Systems 19 (2018), 291–304. [15] Caleb Evans, Sara Pollock, Leo G. Rebholz, and Mengying Xiao. 2020. A Proof That Anderson Acceleration Improves the Convergence Rate in Linearly Converging Fixed-Point Methods (But Not in Those Converging Quadratically). SIAM J. Numer. Anal. 58, 1 (2020), 788–810. doi:10.1137/19M1245384 [16] Haw-ren Fang and Yousef Saad. 2009. Two Classes of Multisecant Methods for Nonlinear Acceleration. Numerical Linear Algebra with Applications 16, 3 (2009), 197–221. doi:10.1002/nla.617 [17] Andreas Frommer and Daniel B. Szyld. 2000. On Asynchronous Iterations. J. Comput. Appl. Math. 123, 1–2 (2000), 201–216. doi:10.1016/S03770427(00)00409-X [18] Matthieu Geist and Bruno Scherrer. 2018. Anderson Acceleration for Reinforcement Learning. In European Workshop on Reinforcement Learning (EWRL). arXiv:1809.09501. [19] Erik J Jensen, Evan Coleman, and Masha Sosonkina. 2018. Using modeling to improve the performance of asynchronous jacobi. In Proceedings of the International Conference on Parallel and Distributed Processing Techniques and Applications (PDPTA). The Steering Committee of The World Congress in Computer Science, Computer . . . , 117–126. [20] Erik J Jensen, Evan Coleman, and Masha Sosonkina. 2019. Predictive modeling of the performance of asynchronous iterative methods: EJ Jensen et al. The Journal of Supercomputing 75, 8 (2019), 5084–5105. [21] Philipp Moritz, Robert Nishihara, Stephanie Wang, Alexey Tumanov, Richard Liaw, Eric Liang, Melih Elibol, Zongheng Yang, William Paul, Michael I. Jordan, and Ion Stoica. 2018. Ray: A Distributed Framework for Emerging AI Applications. In 13th USENIX Symposium on Operating Systems Design and Implementation (OSDI 18). USENIX Association, 561–577. [22] Kimio Ohno. 1964. Some Remarks on the Pariser–Parr–Pople Method. Theoretica Chimica Acta 2, 3 (1964), 219–227. doi:10.1007/BF00528281 [23] Rudolph Pariser and Robert G. Parr. 1953. A Semi-Empirical Theory of the Electronic Spectra and Electronic Structure of Complex Unsaturated Molecules. I. The Journal of Chemical Physics 21, 3 (1953), 466–471. doi:10.1063/1.1698929 [24] John A. Pople. 1953. Electron Interaction in Unsaturated Hydrocarbons. Transactions of the Faraday Society 49 (1953), 1375–1385. doi:10.1039/ TF9534901375 [25] Péter Pulay. 1980. Convergence Acceleration of Iterative Sequences. The Case of SCF Iteration. Chemical Physics Letters 73, 2 (1980), 393–398. doi:10.1016/0009-2614(80)80396-4 [26] Thorsten Rohwedder and Reinhold Schneider. 2011. An Analysis for the DIIS Acceleration Method Used in Quantum Chemistry Calculations. Journal of Mathematical Chemistry 49, 9 (2011), 1889–1914. doi:10.1007/s10910-011-9863-y [27] Piyush Sao and Richard Vuduc. 2013. Self-stabilizing iterative solvers. In Proc. Workshop on Latest Advances in Scalable Algorithms for Large-Scale Systems (ScalA). 1–8. doi:10.1145/2530268.2530272 [28] Wenjie Shi, Shiji Song, Hui Wu, Ya-Chien Hsu, Cheng Wu, and Gao Huang. 2019. Regularized Anderson Acceleration for Off-Policy Deep Reinforcement Learning. Advances in Neural Information Processing Systems 32 (2019). [29] Ke Sun, Yafei Li, Yingnan Chen, Yingbin Lin, Hongyuan Zha, and Baoyuan Wu. 2021. Damped Anderson Mixing for Deep Reinforcement Learning: Acceleration, Convergence, and Stabilization. In Advances in Neural Information Processing Systems, Vol. 34. [30] Qiming Sun, Timothy C. Berkelbach, Nick S. Blunt, George H. Booth, Sheng Guo, Zhendong Li, Junzi Liu, James D. McClain, Elvira R. Sayfutyarova, Sandeep Sharma, Sebastian Wouters, and Garnet Kin-Lic Chan. 2018. PySCF: The Python-Based Simulations of Chemistry Framework. WIREs Computational Molecular Science 8, 1 (2018), e1340. doi:10.1002/wcms.1340 [31] Attila Szabo and Neil S. Ostlund. 1996. Modern Quantum Chemistry: Introduction to Advanced Electronic Structure Theory (revised ed.). Dover Publications. 15
[32] Alex Toth, J. Austin Ellis, Thomas Evans, Steven Hamilton, C. T. Kelley, Roger Pawlowski, and Stuart Slattery. 2017. Local Improvement Results for Anderson Acceleration with Inaccurate Function Evaluations. SIAM Journal on Scientific Computing 39, 5 (2017), S47–S65. doi:10.1137/16M1080677 [33] Alex Toth and C. T. Kelley. 2015. Convergence Analysis for Anderson Acceleration. SIAM J. Numer. Anal. 53, 2 (2015), 805–819. doi:10.1137/130919398 [34] Homer F. Walker and Peng Ni. 2011. Anderson Acceleration for Fixed-Point Iterations. SIAM J. Numer. Anal. 49, 4 (2011), 1715–1735. doi:10.1137/ 10078356X [35] Junzi Zhang, Brendan O’Donoghue, and Stephen Boyd. 2020. Globally Convergent Type-I Anderson Acceleration for Non-Smooth Fixed-Point Iterations. SIAM Journal on Optimization 30, 4 (2020), 3170–3197. doi:10.1137/18M1232772
16