Conjugate gradient method

From HandWiki
Short description: Mathematical optimization algorithm
A comparison of the convergence of gradient descent with optimal step size (in green) and conjugate vector (in red) for minimizing a quadratic function associated with a given linear system. Conjugate gradient, assuming exact arithmetic, converges in at most n steps, where n is the size of the matrix of the system (here n = 2).

In mathematics, the conjugate gradient method is an algorithm for the numerical solution of particular systems of linear equations, namely those whose matrix is positive-definite. The conjugate gradient method is often implemented as an iterative algorithm, applicable to sparse systems that are too large to be handled by a direct implementation or other direct methods such as the Cholesky decomposition. Large sparse systems often arise when numerically solving partial differential equations or optimization problems.

The conjugate gradient method can also be used to solve unconstrained optimization problems such as energy minimization. It is commonly attributed to Magnus Hestenes and Eduard Stiefel,[1][2] who programmed it on the Z4,[3] and extensively researched it.[4][5]

The biconjugate gradient method provides a generalization to non-symmetric matrices. Various nonlinear conjugate gradient methods seek minima of nonlinear optimization problems.

Description of the problem addressed by conjugate gradients

Suppose we want to solve the system of linear equations

𝐀𝐱=𝐛

for the vector 𝐱, where the known n×n matrix 𝐀 is symmetric (i.e., AT = A), positive-definite (i.e. xTAx > 0 for all non-zero vectors 𝐱 in Rn), and real, and 𝐛 is known as well. We denote the unique solution of this system by 𝐱*.

Derivation as a direct method

Main page: Derivation of the conjugate gradient method

The conjugate gradient method can be derived from several different perspectives, including specialization of the conjugate direction method for optimization, and variation of the Arnoldi/Lanczos iteration for eigenvalue problems. Despite differences in their approaches, these derivations share a common topic—proving the orthogonality of the residuals and conjugacy of the search directions. These two properties are crucial to developing the well-known succinct formulation of the method.

We say that two non-zero vectors u and v are conjugate (with respect to 𝐀) if

𝐮T𝐀𝐯=0.

Since 𝐀 is symmetric and positive-definite, the left-hand side defines an inner product

𝐮T𝐀𝐯=𝐮,𝐯𝐀:=𝐀𝐮,𝐯=𝐮,𝐀T𝐯=𝐮,𝐀𝐯.

Two vectors are conjugate if and only if they are orthogonal with respect to this inner product. Being conjugate is a symmetric relation: if 𝐮 is conjugate to 𝐯, then 𝐯 is conjugate to 𝐮. Suppose that

P={𝐩1,,𝐩n}

is a set of n mutually conjugate vectors with respect to 𝐀, i.e. 𝐩iT𝐀𝐩j=0 for all ij. Then P forms a basis for n, and we may express the solution 𝐱* of 𝐀𝐱=𝐛 in this basis:

𝐱*=i=1nαi𝐩i𝐀𝐱*=i=1nαi𝐀𝐩i.

Left-multiplying the problem 𝐀𝐱=𝐛 with the vector 𝐩kT yields

𝐩kT𝐛=𝐩kT𝐀𝐱*=i=1nαi𝐩kT𝐀𝐩i=i=1nαi𝐩k,𝐩i𝐀=αk𝐩k,𝐩k𝐀

and so

αk=𝐩k,𝐛𝐩k,𝐩k𝐀.

This gives the following method[4] for solving the equation Ax = b: find a sequence of n conjugate directions, and then compute the coefficients αk.

As an iterative method

If we choose the conjugate vectors 𝐩k carefully, then we may not need all of them to obtain a good approximation to the solution 𝐱*. So, we want to regard the conjugate gradient method as an iterative method. This also allows us to approximately solve systems where n is so large that the direct method would take too much time.

We denote the initial guess for x by x0 (we can assume without loss of generality that x0 = 0, otherwise consider the system Az = bAx0 instead). Starting with x0 we search for the solution and in each iteration we need a metric to tell us whether we are closer to the solution x (that is unknown to us). This metric comes from the fact that the solution x is also the unique minimizer of the following quadratic function

f(𝐱)=12𝐱T𝐀𝐱𝐱T𝐛,𝐱𝐑n.

The existence of a unique minimizer is apparent as its Hessian matrix of second derivatives is symmetric positive-definite

𝐇(f(𝐱))=𝐀,

and that the minimizer (use Df(x)=0) solves the initial problem follows from its first derivative

f(𝐱)=𝐀𝐱𝐛.

This suggests taking the first basis vector p0 to be the negative of the gradient of f at x = x0. The gradient of f equals Axb. Starting with an initial guess x0, this means we take p0 = bAx0. The other vectors in the basis will be conjugate to the gradient, hence the name conjugate gradient method. Note that p0 is also the residual provided by this initial step of the algorithm.

Let rk be the residual at the kth step:

𝐫k=𝐛𝐀𝐱k.

As observed above, 𝐫k is the negative gradient of f at 𝐱k, so the gradient descent method would require to move in the direction rk. Here, however, we insist that the directions 𝐩k must be conjugate to each other. A practical way to enforce this is by requiring that the next search direction be built out of the current residual and all previous search directions. The conjugation constraint is an orthonormal-type constraint and hence the algorithm can be viewed as an example of Gram-Schmidt orthonormalization. This gives the following expression:

𝐩k=𝐫ki<k𝐩iT𝐀𝐫k𝐩iT𝐀𝐩i𝐩i

(see the picture at the top of the article for the effect of the conjugacy constraint on convergence). Following this direction, the next optimal location is given by

𝐱k+1=𝐱k+αk𝐩k

with

αk=𝐩kT(𝐛𝐀𝐱k)𝐩kT𝐀𝐩k=𝐩kT𝐫k𝐩kT𝐀𝐩k,

where the last equality follows from the definition of 𝐫k . The expression for αk can be derived if one substitutes the expression for xk+1 into f and minimizing it with respect to αk

f(𝐱k+1)=f(𝐱k+αk𝐩k)=:g(αk)g(αk)=!0αk=𝐩kT(𝐛𝐀𝐱k)𝐩kT𝐀𝐩k.

The resulting algorithm

The above algorithm gives the most straightforward explanation of the conjugate gradient method. Seemingly, the algorithm as stated requires storage of all previous searching directions and residue vectors, as well as many matrix–vector multiplications, and thus can be computationally expensive. However, a closer analysis of the algorithm shows that 𝐫i is orthogonal to 𝐫j, i.e. 𝐫iT𝐫j=0 , for i ≠ j. And 𝐩iis 𝐀-orthogonal to 𝐩j , i.e. 𝐩iT𝐀𝐩j=0 , for ij. This can be regarded that as the algorithm progresses, 𝐩i and 𝐫i span the same Krylov subspace. Where 𝐫i form the orthogonal basis with respect to the standard inner product, and 𝐩i form the orthogonal basis with respect to the inner product induced by 𝐀. Therefore, 𝐱k can be regarded as the projection of 𝐱 on the Krylov subspace.

That is, if the CG method starts with 𝐱0=0, then[6]xk=argminyn{(xy)A(xy)T:yspan{b,Ab,,Ak1b}}The algorithm is detailed below for solving 𝐀𝐱=𝐛 where 𝐀 is a real, symmetric, positive-definite matrix. The input vector 𝐱0 can be an approximate initial solution or 0. It is a different formulation of the exact procedure described above.

𝐫0:=𝐛𝐀𝐱0if 𝐫0 is sufficiently small, then return 𝐱0 as the result𝐩0:=𝐫0k:=0repeatαk:=𝐫kT𝐫k𝐩kT𝐀𝐩k𝐱k+1:=𝐱k+αk𝐩k𝐫k+1:=𝐫kαk𝐀𝐩kif 𝐫k+1 is sufficiently small, then exit loopβk:=𝐫k+1T𝐫k+1𝐫kT𝐫k𝐩k+1:=𝐫k+1+βk𝐩kk:=k+1end repeatreturn 𝐱k+1 as the result

This is the most commonly used algorithm. The same formula for βk is also used in the Fletcher–Reeves nonlinear conjugate gradient method.

Restarts

We note that 𝐱1 is computed by the gradient descent method applied to 𝐱0. Setting βk=0 would similarly make 𝐱k+1 computed by the gradient descent method from 𝐱k, i.e., can be used as a simple implementation of a restart of the conjugate gradient iterations.[4] Restarts could slow down convergence, but may improve stability if the conjugate gradient method misbehaves, e.g., due to round-off error.

Explicit residual calculation

The formulas 𝐱k+1:=𝐱k+αk𝐩k and 𝐫k:=𝐛𝐀𝐱k, which both hold in exact arithmetic, make the formulas 𝐫k+1:=𝐫kαk𝐀𝐩k and 𝐫k+1:=𝐛𝐀𝐱k+1 mathematically equivalent. The former is used in the algorithm to avoid an extra multiplication by 𝐀 since the vector 𝐀𝐩k is already computed to evaluate αk. The latter may be more accurate, substituting the explicit calculation 𝐫k+1:=𝐛𝐀𝐱k+1 for the implicit one by the recursion subject to round-off error accumulation, and is thus recommended for an occasional evaluation.[7]

A norm of the residual is typically used for stopping criteria. The norm of the explicit residual 𝐫k+1:=𝐛𝐀𝐱k+1 provides a guaranteed level of accuracy both in exact arithmetic and in the presence of the rounding errors, where convergence naturally stagnates. In contrast, the implicit residual 𝐫k+1:=𝐫kαk𝐀𝐩k is known to keep getting smaller in amplitude well below the level of rounding errors and thus cannot be used to determine the stagnation of convergence.

Computation of alpha and beta

In the algorithm, αk is chosen such that 𝐫k+1 is orthogonal to 𝐫k. The denominator is simplified from

αk=𝐫kT𝐫k𝐫kT𝐀𝐩k=𝐫kT𝐫k𝐩kT𝐀𝐩k

since 𝐫k+1=𝐩k+1βk𝐩k. The βk is chosen such that 𝐩k+1 is conjugate to 𝐩k. Initially, βk is

βk=𝐫k+1T𝐀𝐩k𝐩kT𝐀𝐩k

using

𝐫k+1=𝐫kαk𝐀𝐩k

and equivalently

𝐀𝐩k=1αk(𝐫k𝐫k+1),

the numerator of βk is rewritten as

𝐫k+1T𝐀𝐩k=1αk𝐫k+1T(𝐫k𝐫k+1)=1αk𝐫k+1T𝐫k+1

because 𝐫k+1 and 𝐫k are orthogonal by design. The denominator is rewritten as

𝐩kT𝐀𝐩k=(𝐫k+βk1𝐩k1)T𝐀𝐩k=1αk𝐫kT(𝐫k𝐫k+1)=1αk𝐫kT𝐫k

using that the search directions pk are conjugated and again that the residuals are orthogonal. This gives the β in the algorithm after cancelling αk.

"""
    conjugate_gradient!(A, b, x)

Return the solution to `A * x = b` using the conjugate gradient method.
"""
function conjugate_gradient!(
    A::AbstractMatrix, b::AbstractVector, x::AbstractVector; tol=eps(eltype(b))
)
    # Initialize residual vector
    residual = b - A * x
    # Initialize search direction vector
    search_direction = residual
    # Compute initial squared residual norm
    old_sqr_resid_norm = residual' * residual

    # Iterate until convergence
    while old_sqr_resid_norm > tol
        A_search_direction = A * search_direction
        step_size = old_sqr_resid_norm^2 / (search_direction' * A_search_direction)
        # Update solution
        @. x = x + step_size * search_direction
        # Update residual
        @. residual = residual - step_size * A_search_direction
        new_sqr_resid_norm = dot(residual, residual)
        
        # Update search direction vector
        @. search_direction = residual + 
            (new_sqr_resid_norm / old_sqr_resid_norm)^2 * search_direction
        # Update squared residual norm for next iteration
        old_sqr_resid_norm = new_sqr_resid_norm
    end
    return x
end

Numerical example

Consider the linear system Ax = b given by

𝐀𝐱=[4113][x1x2]=[12],

we will perform two steps of the conjugate gradient method beginning with the initial guess

𝐱0=[21]

in order to find an approximate solution to the system.

Solution

For reference, the exact solution is

𝐱=[111711][0.09090.6364]

Our first step is to calculate the residual vector r0 associated with x0. This residual is computed from the formula r0 = b - Ax0, and in our case is equal to

𝐫0=[12][4113][21]=[83]=𝐩0.

Since this is the first iteration, we will use the residual vector r0 as our initial search direction p0; the method of selecting pk will change in further iterations.

We now compute the scalar α0 using the relationship

α0=𝐫0T𝐫0𝐩0T𝐀𝐩0=[83][83][83][4113][83]=733310.2205

We can now compute x1 using the formula

𝐱1=𝐱0+α0𝐩0=[21]+73331[83][0.23560.3384].

This result completes the first iteration, the result being an "improved" approximate solution to the system, x1. We may now move on and compute the next residual vector r1 using the formula

𝐫1=𝐫0α0𝐀𝐩0=[83]73331[4113][83][0.28100.7492].

Our next step in the process is to compute the scalar β0 that will eventually be used to determine the next search direction p1.

β0=𝐫1T𝐫1𝐫0T𝐫0[0.28100.7492][0.28100.7492][83][83]=0.0088.

Now, using this scalar β0, we can compute the next search direction p1 using the relationship

𝐩1=𝐫1+β0𝐩0[0.28100.7492]+0.0088[83]=[0.35110.7229].

We now compute the scalar α1 using our newly acquired p1 using the same method as that used for α0.

α1=𝐫1T𝐫1𝐩1T𝐀𝐩1[0.28100.7492][0.28100.7492][0.35110.7229][4113][0.35110.7229]=0.4122.

Finally, we find x2 using the same method as that used to find x1.

𝐱2=𝐱1+α1𝐩1[0.23560.3384]+0.4122[0.35110.7229]=[0.09090.6364].

The result, x2, is a "better" approximation to the system's solution than x1 and x0. If exact arithmetic were to be used in this example instead of limited-precision, then the exact solution would theoretically have been reached after n = 2 iterations (n being the order of the system).

Convergence properties

The conjugate gradient method can theoretically be viewed as a direct method, as in the absence of round-off error it produces the exact solution after a finite number of iterations, which is not larger than the size of the matrix. In practice, the exact solution is never obtained since the conjugate gradient method is unstable with respect to even small perturbations, e.g., most directions are not in practice conjugate, due to a degenerative nature of generating the Krylov subspaces.

As an iterative method, the conjugate gradient method monotonically (in the energy norm) improves approximations 𝐱k to the exact solution and may reach the required tolerance after a relatively small (compared to the problem size) number of iterations. The improvement is typically linear and its speed is determined by the condition number κ(A) of the system matrix A: the larger κ(A) is, the slower the improvement.[8]

If κ(A) is large, preconditioning is commonly used to replace the original system 𝐀𝐱𝐛=0 with 𝐌1(𝐀𝐱𝐛)=0 such that κ(𝐌1𝐀) is smaller than κ(𝐀), see below.

Convergence theorem

Define a subset of polynomials as

Πk*:={ pΠk : p(0)=1 },

where Πk is the set of polynomials of maximal degree k.

Let (𝐱k)k be the iterative approximations of the exact solution 𝐱*, and define the errors as 𝐞k:=𝐱k𝐱*. Now, the rate of convergence can be approximated as [4][9]

𝐞k𝐀=minpΠk*p(𝐀)𝐞0𝐀minpΠk*maxλσ(𝐀)|p(λ)| 𝐞0𝐀2(κ(𝐀)1κ(𝐀)+1)k 𝐞0𝐀2exp(2kκ(𝐀)) 𝐞0𝐀,

where σ(𝐀) denotes the spectrum, and κ(𝐀) denotes the condition number.

This shows k=12κ(𝐀)log(𝐞0𝐀ε1) iterations suffices to reduce the error to 2ε for any ε>0.

Note, the important limit when κ(𝐀) tends to

κ(𝐀)1κ(𝐀)+112κ(𝐀)forκ(𝐀)1.

This limit shows a faster convergence rate compared to the iterative methods of Jacobi or Gauss–Seidel which scale as 12κ(𝐀).

No round-off error is assumed in the convergence theorem, but the convergence bound is commonly valid in practice as theoretically explained[5] by Anne Greenbaum.

Practical convergence

If initialized randomly, the first stage of iterations is often the fastest, as the error is eliminated within the Krylov subspace that initially reflects a smaller effective condition number. The second stage of convergence is typically well defined by the theoretical convergence bound with κ(𝐀), but may be super-linear, depending on a distribution of the spectrum of the matrix A and the spectral distribution of the error.[5] In the last stage, the smallest attainable accuracy is reached and the convergence stalls or the method may even start diverging. In typical scientific computing applications in double-precision floating-point format for matrices of large sizes, the conjugate gradient method uses a stopping criteria with a tolerance that terminates the iterations during the first or second stage.

The preconditioned conjugate gradient method

In most cases, preconditioning is necessary to ensure fast convergence of the conjugate gradient method. If 𝐌1 is symmetric positive-definite and 𝐌1𝐀 has a better condition number than 𝐀, a preconditioned conjugate gradient method can be used. It takes the following form:[10]

𝐫0:=𝐛𝐀𝐱0
Solve:𝐌𝐳0:=𝐫0
𝐩0:=𝐳0
k:=0
repeat
αk:=𝐫kT𝐳k𝐩kT𝐀𝐩k
𝐱k+1:=𝐱k+αk𝐩k
𝐫k+1:=𝐫kαk𝐀𝐩k
if rk+1 is sufficiently small then exit loop end if
Solve 𝐌𝐳k+1:=𝐫k+1
βk:=𝐫k+1T𝐳k+1𝐫kT𝐳k
𝐩k+1:=𝐳k+1+βk𝐩k
k:=k+1
end repeat
The result is xk+1

The above formulation is equivalent to applying the regular conjugate gradient method to the preconditioned system[11]

𝐄1𝐀(𝐄1)Tx^=𝐄1𝐛

where

𝐄𝐄T=𝐌,x^=𝐄T𝐱.

The Cholesky decomposition of the preconditioner must be used to keep the symmetry (and positive definiteness) of the system. However, this decomposition does not need to be computed, and it is sufficient to know 𝐌1. It can be shown that 𝐄1𝐀(𝐄1)T has the same spectrum as 𝐌1𝐀.

The preconditioner matrix M has to be symmetric positive-definite and fixed, i.e., cannot change from iteration to iteration. If any of these assumptions on the preconditioner is violated, the behavior of the preconditioned conjugate gradient method may become unpredictable.

An example of a commonly used preconditioner is the incomplete Cholesky factorization.[12]

Using the preconditioner in practice

It is importart to keep in mind that we don't want to invert the matrix 𝐌 explicitly in order to get 𝐌1 for use it in the process, since inverting 𝐌 would take more time/computational resources than solving the conjugate gradient algorithm itself. As an example, let's say that we are using a preconditioner coming from incomplete Cholesky factorization. The resulting matrix is the lower triangular matrix 𝐋, and the preconditioner matrix is:

𝐌=𝐋𝐋T

Then we have to solve:

𝐌𝐳=𝐫

𝐳=𝐌1𝐫

But:

𝐌1=(𝐋1)T𝐋1

Then:

𝐳=(𝐋1)T𝐋1𝐫

Let's take an intermediary vector 𝐚:

𝐚=𝐋1𝐫

𝐫=𝐋𝐚

Since 𝐫 and 𝐋 and known, and 𝐋 is lower triangular, solving for 𝐚 is easy and computationally cheap by using forward substitution. Then, we substitute 𝐚 in the original equation:

𝐳=(𝐋1)T𝐚

𝐚=𝐋T𝐳

Since 𝐚 and 𝐋T are known, and 𝐋T is upper triangular, solving for 𝐳 is easy and computationally cheap by using backward substitution.

Using this method, there is no need to invert 𝐌 or 𝐋 explicitly at all, and we still obtain 𝐳.

The flexible preconditioned conjugate gradient method

In numerically challenging applications, sophisticated preconditioners are used, which may lead to variable preconditioning, changing between iterations. Even if the preconditioner is symmetric positive-definite on every iteration, the fact that it may change makes the arguments above invalid, and in practical tests leads to a significant slow down of the convergence of the algorithm presented above. Using the Polak–Ribière formula

βk:=𝐫k+1T(𝐳k+1𝐳k)𝐫kT𝐳k

instead of the Fletcher–Reeves formula

βk:=𝐫k+1T𝐳k+1𝐫kT𝐳k

may dramatically improve the convergence in this case.[13] This version of the preconditioned conjugate gradient method can be called[14] flexible, as it allows for variable preconditioning. The flexible version is also shown[15] to be robust even if the preconditioner is not symmetric positive definite (SPD).

The implementation of the flexible version requires storing an extra vector. For a fixed SPD preconditioner, 𝐫k+1T𝐳k=0, so both formulas for βk are equivalent in exact arithmetic, i.e., without the round-off error.

The mathematical explanation of the better convergence behavior of the method with the Polak–Ribière formula is that the method is locally optimal in this case, in particular, it does not converge slower than the locally optimal steepest descent method.[16]

Vs. the locally optimal steepest descent method

In both the original and the preconditioned conjugate gradient methods one only needs to set βk:=0 in order to make them locally optimal, using the line search, steepest descent methods. With this substitution, vectors p are always the same as vectors z, so there is no need to store vectors p. Thus, every iteration of these steepest descent methods is a bit cheaper compared to that for the conjugate gradient methods. However, the latter converge faster, unless a (highly) variable and/or non-SPD preconditioner is used, see above.

Conjugate gradient method as optimal feedback controller for double integrator

The conjugate gradient method can also be derived using optimal control theory.[17] In this approach, the conjugate gradient method falls out as an optimal feedback controller,u=k(x,v):=γaf(x)γbv for the double integrator system,x˙=v,v˙=u The quantities γa and γb are variable feedback gains.[17]

Conjugate gradient on the normal equations

The conjugate gradient method can be applied to an arbitrary n-by-m matrix by applying it to normal equations ATA and right-hand side vector ATb, since ATA is a symmetric positive-semidefinite matrix for any A. The result is conjugate gradient on the normal equations (CGN or CGNR).

ATAx = ATb

As an iterative method, it is not necessary to form ATA explicitly in memory but only to perform the matrix–vector and transpose matrix–vector multiplications. Therefore, CGNR is particularly useful when A is a sparse matrix since these operations are usually extremely efficient. However the downside of forming the normal equations is that the condition number κ(ATA) is equal to κ2(A) and so the rate of convergence of CGNR may be slow and the quality of the approximate solution may be sensitive to roundoff errors. Finding a good preconditioner is often an important part of using the CGNR method.

Several algorithms have been proposed (e.g., CGLS, LSQR). The LSQR algorithm purportedly has the best numerical stability when A is ill-conditioned, i.e., A has a large condition number.

Conjugate gradient method for complex Hermitian matrices

The conjugate gradient method with a trivial modification is extendable to solving, given complex-valued matrix A and vector b, the system of linear equations 𝐀𝐱=𝐛 for the complex-valued vector x, where A is Hermitian (i.e., A' = A) and positive-definite matrix, and the symbol ' denotes the conjugate transpose. The trivial modification is simply substituting the conjugate transpose for the real transpose everywhere.

Advantages and disadvantages

The advantages and disadvantages of the conjugate gradient methods are summarized in the lecture notes by Nemirovsky and BenTal.[18]:{{{1}}}

A pathological example

This example is from [19] Let t(0,1), and defineW=[ttt1+ttt1+ttttt1+t],b=[100]Since W is invertible, there exists a unique solution to Wx=b. Solving it by conjugate gradient descent gives us rather bad convergence:bWxk2=(1/t)k,bWxn2=0In words, during the CG process, the error grows exponentially, until it suddenly becomes zero as the unique solution is found.

See also


References

  1. Hestenes, Magnus R.; Stiefel, Eduard (December 1952). "Methods of Conjugate Gradients for Solving Linear Systems". Journal of Research of the National Bureau of Standards 49 (6): 409. doi:10.6028/jres.049.044. http://nvlpubs.nist.gov/nistpubs/jres/049/6/V49.N06.A08.pdf. 
  2. Straeter, T. A. (1971). On the Extension of the Davidon–Broyden Class of Rank One, Quasi-Newton Minimization Methods to an Infinite Dimensional Hilbert Space with Applications to Optimal Control Problems (PhD thesis). North Carolina State University. hdl:2060/19710026200 – via NASA Technical Reports Server.
  3. Speiser, Ambros (2004). "Konrad Zuse und die ERMETH: Ein weltweiter Architektur-Vergleich". in Hellige, Hans Dieter (in de). Geschichten der Informatik. Visionen, Paradigmen, Leitmotive. Berlin: Springer. p. 185. ISBN 3-540-00217-0. 
  4. 4.0 4.1 4.2 4.3 Polyak, Boris (1987) (in en). Introduction to Optimization. https://www.researchgate.net/publication/342978480. 
  5. 5.0 5.1 5.2 Greenbaum, Anne (1997) (in en). Iterative Methods for Solving Linear Systems. doi:10.1137/1.9781611970937. ISBN 978-0-89871-396-1. 
  6. Paquette, Elliot; Trogdon, Thomas (March 2023). "Universality for the Conjugate Gradient and MINRES Algorithms on Sample Covariance Matrices" (in en). Communications on Pure and Applied Mathematics 76 (5): 1085–1136. doi:10.1002/cpa.22081. ISSN 0010-3640. https://onlinelibrary.wiley.com/doi/10.1002/cpa.22081. 
  7. Shewchuk, Jonathan R (1994). An Introduction to the Conjugate Gradient Method Without the Agonizing Pain. http://www.cs.cmu.edu/~quake-papers/painless-conjugate-gradient.pdf. 
  8. Saad, Yousef (2003). Iterative methods for sparse linear systems (2nd ed.). Philadelphia, Pa.: Society for Industrial and Applied Mathematics. pp. 195. ISBN 978-0-89871-534-7. https://archive.org/details/iterativemethods0000saad/page/195. 
  9. Hackbusch, W. (2016-06-21). Iterative solution of large sparse systems of equations (2nd ed.). Switzerland: Springer. ISBN 978-3-319-28483-5. OCLC 952572240. 
  10. Barrett, Richard; Berry, Michael; Chan, Tony F.; Demmel, James; Donato, June; Dongarra, Jack; Eijkhout, Victor; Pozo, Roldan et al. (in en). Templates for the Solution of Linear Systems: Building Blocks for Iterative Methods (2nd ed.). Philadelphia, PA: SIAM. p. 13. http://www.netlib.org/templates/templates.pdf. Retrieved 2020-03-31. 
  11. Golub, Gene H.; Van Loan, Charles F. (2013). Matrix Computations (4th ed.). Johns Hopkins University Press. sec. 11.5.2. ISBN 978-1-4214-0794-4. 
  12. Concus, P.; Golub, G. H.; Meurant, G. (1985). "Block Preconditioning for the Conjugate Gradient Method". SIAM Journal on Scientific and Statistical Computing 6 (1): 220–252. doi:10.1137/0906018. https://escholarship.org/uc/item/0j60b61v. 
  13. Golub, Gene H.; Ye, Qiang (1999). "Inexact Preconditioned Conjugate Gradient Method with Inner-Outer Iteration". SIAM Journal on Scientific Computing 21 (4): 1305. doi:10.1137/S1064827597323415. 
  14. Notay, Yvan (2000). "Flexible Conjugate Gradients". SIAM Journal on Scientific Computing 22 (4): 1444–1460. doi:10.1137/S1064827599362314. 
  15. Bouwmeester, Henricus; Dougherty, Andrew; Knyazev, Andrew V. (2015). "Nonsymmetric Preconditioning for Conjugate Gradient and Steepest Descent Methods 1". Procedia Computer Science 51: 276–285. doi:10.1016/j.procs.2015.05.241. 
  16. Knyazev, Andrew V.; Lashuk, Ilya (2008). "Steepest Descent and Conjugate Gradient Methods with Variable Preconditioning". SIAM Journal on Matrix Analysis and Applications 29 (4): 1267. doi:10.1137/060675290. 
  17. 17.0 17.1 Ross, I. M., "An Optimal Control Theory for Accelerated Optimization," arXiv:1902.09004, 2019.
  18. Nemirovsky and Ben-Tal (2023). "Optimization III: Convex Optimization". http://www2.isye.gatech.edu/~nemirovs/OPTIIILN2023Spring.pdf. 
  19. Pennington, Fabian Pedregosa, Courtney Paquette, Tom Trogdon, Jeffrey. "Random Matrix Theory and Machine Learning Tutorial" (in en-ca). https://random-matrix-learning.github.io/. 

Further reading