Original: Posterior and Computational Uncertainty in Gaussian Processes
Revised: Posterior and Computational Uncertainty in Gaussian Processes

Original: Abstract
Revised: Abstract

Original: Gaussian processes scale prohibitively with the size of the dataset.
Revised: Gaussian processes scale prohibitively with the size of the dataset.

Original: In response, many approximation methods have been developed, which inevitably introduce approximation error.
Revised: In response, many approximation methods have been developed, which inevitably introduce approximation error.

Original: This additional source of uncertainty, due to limited computation, is entirely ignored when using the approximate posterior.
Revised: This additional source of uncertainty, due to limited computation, is entirely ignored when using the approximate posterior.

Original: Therefore in practice, GP models are often as much about the approximation method as they are about the data.
Revised: Therefore in practice, GP models are often as much about the approximation method as they are about the data.

Original: Here, we develop a new class of methods that provides consistent estimation of the combined uncertainty arising from both the finite number of data observed and the finite amount of computation expended.
Revised: Here, we develop a new class of methods that provides consistent estimation of the combined uncertainty arising from both the finite number of data observed and the finite amount of computation expended.

Original: The most common GP approximations map to an instance in this class, such as methods based on the
Revised: The most common GP approximations map to an instance in this class, such as methods based on the

Original: Cholesky factorization, conjugate gradients, and inducing points.
Revised: Cholesky factorization, conjugate gradients, and inducing points.

Original: For any method in this class, we prove (i) convergence of its posterior mean in the associated RKHS, (ii) decomposability of its combined posterior covariance into mathematical and computational covariances, and (iii) that the combined variance is a tight worst-case bound for the squared error between the method’s posterior mean and the latent function.
Revised: For any method in this class, we prove (i) convergence of its posterior mean in the associated RKHS, (ii) decomposability of its combined posterior covariance into mathematical and computational covariances, and (iii) that the combined variance is a tight worst-case bound for the squared error between the method’s posterior mean and the latent function.

Original: Finally, we empirically demonstrate the consequences of ignoring computational uncertainty and show how implicitly modeling it improves generalization performance on benchmark datasets.
Revised: Finally, we empirically demonstrate the consequences of ignoring computational uncertainty and show how implicitly modeling it improves generalization performance on benchmark datasets.

Original:  Introduction
Revised:  Introduction

Original: Gaussian processes (GPs) are an expressive probabilistic model class, but their prohibitive scaling necessitates approximation [1].
Revised: Gaussian processes (GPs) are an expressive probabilistic model class, but their prohibitive scaling necessitates approximation [1].

Original: A range of approximations based on kernel [2–10] or precision matrix [11–14] estimates, inducing point methods [15–22] and iterative solvers [23–29] have been proposed.
Revised: A range of approximations based on kernel [2–10] or precision matrix [11–14] estimates, inducing point methods [15–22] and iterative solvers [23–29] have been proposed.

Original: These methods all use an affordable amount of computation to obtain an approximation of the mathematical posterior, which exists theoretically but cannot be accessed given limited computational resources.
Revised: These methods all use an affordable amount of computation to obtain an approximation of the mathematical posterior, which exists theoretically but cannot be accessed given limited computational resources.

Original: The approximate posterior is then used as a direct replacement of the mathematical posterior in downstream applications.
Revised: The approximate posterior is then used as a direct replacement of the mathematical posterior in downstream applications.

Original: Doing so, however, completely ignores the fact that we only expended a limited amount of compute.
Revised: Doing so, however, completely ignores the fact that we only expended a limited amount of compute.

Original: By analogy to the typical GP operation, where limited data induces modeling error captured by mathematical uncertainty , our work is motivated by the fact that limited computation induces approximation error that must be captured by computational uncertainty .
Revised: By analogy to the typical GP operation, where limited data induces modeling error captured by mathematical uncertainty , our work is motivated by the fact that limited computation induces approximation error that must be captured by computational uncertainty .

Original: Here, we introduce IterGP, a class of methods which return a combined uncertainty that is the sum of mathematical and computational uncertainty.
Revised: Here, we introduce IterGP, a class of methods which return a combined uncertainty that is the sum of mathematical and computational uncertainty.

Original: Figure 1 illustrates the difference between ignoring computational uncertainty and explicitly modeling it.
Revised: Figure 1 illustrates the difference between ignoring computational uncertainty and explicitly modeling it.

Original: We perform GP regression using a Matérn( 32 ) kernel on a toy dataset and compare SVGP ( ) [22] to its analog in our framework, IterGP-PI ( + ), for a fixed set of inducing points.
Revised: We perform GP regression using a Matérn( 32 ) kernel on a toy dataset and compare SVGP ( ) [22] to its analog in our framework, IterGP-PI ( + ), for a fixed set of inducing points.

Original: The computational shortcuts of inducing point methods can lead to unavoidable biases in their posterior mean and covariance [30, 31].
Revised: The computational shortcuts of inducing point methods can lead to unavoidable biases in their posterior mean and covariance [30, 31].

Original: As Figure 1 illustrates, SVGP
Revised: As Figure 1 illustrates, SVGP

Original: Y
Revised: Y

Original: [Figure]
Revised: [Figure]

Original: ea n
Revised: ea n

Original: [Figure]

Original:  rr .
Revised: E rr .

Original: [Figure]
Revised: [Figure]

Original: V a r .
Revised: V a r .

Original: E rr .
Revised: E rr .

Original: [Figure]
Revised: [Figure]

Original: may underestimate the marginal variance where inducing points do not coincide with datapoints.
Revised: may underestimate the marginal variance where inducing points do not coincide with datapoints.

Original: In contrast, IterGP is guaranteed to overestimate the mathematical uncertainty – with the difference precisely given by the computational uncertainty ( ).
Revised: In contrast, IterGP is guaranteed to overestimate the mathematical uncertainty – with the difference precisely given by the computational uncertainty ( ).

Original: Additionally, the computational uncertainty is a worst-case bound (—) on the error of the approximate posterior mean.
Revised: Additionally, the computational uncertainty is a worst-case bound (—) on the error of the approximate posterior mean.

Original: To be clear, this overestimation is desirable: IterGP is not a typical approximation in the sense that its combined posterior attempts to approximate the mathematical posterior.
Revised: To be clear, this overestimation is desirable: IterGP is not a typical approximation in the sense that its combined posterior attempts to approximate the mathematical posterior.

Original: Rather, IterGP recognizes that the mathematical posterior exists, but we do not have access to it, given computational constraints.
Revised: Rather, IterGP recognizes that the mathematical posterior exists, but we do not have access to it, given computational constraints.

Original: Finite compute is as true a source of posterior uncertainty as finite data.
Revised: Finite compute is as true a source of posterior uncertainty as finite data.

Original: Taking this view seriously, the true goal of GPs in the limited compute regime should in fact be to track combined uncertainty.
Revised: Taking this view seriously, the true goal of GPs in the limited compute regime should in fact be to track combined uncertainty.

Original: This intuition motivates IterGP and is formally a feature of our results.
Revised: This intuition motivates IterGP and is formally a feature of our results.

Original: We show that, if you update your GP via computation, specifically matrix-vector multiplication, then the combined uncertainty of the IterGP algorithm is precisely the correct object to capture your belief (Theorem 2) – in the same way the mathematical posterior is the correct object given finite data and unlimited computation.
Revised: We show that, if you update your GP via computation, specifically matrix-vector multiplication, then the combined uncertainty of the IterGP algorithm is precisely the correct object to capture your belief (Theorem 2) – in the same way the mathematical posterior is the correct object given finite data and unlimited computation.

Original: Formally, IterGP  treats the (unknown) representer weights as a latent variable with a prior belief that, when marginalized out, corresponds to a GP prior conditioned on no data.
Revised: Formally, IterGP is a probabilistic numerical method [32–35]. It treats the (unknown) representer weights as a latent variable with a prior belief that, when marginalized out, corresponds to a GP prior conditioned on no data.

Original: We then use a computational primitive (matrix-vector multiplication) that corresponds to tractable Bayesian updates on the representer weight distribution; that is, conditioning on computations performed on the data.
Revised: We then use a computational primitive (matrix-vector multiplication) that corresponds to tractable Bayesian updates on the representer weight distribution; that is, conditioning on computations performed on the data.

Original: The resulting belief can then be marginalized out to obtain a closed form, tractable expression for the combined – mathematical plus computational – uncertainty.
Revised: The resulting belief can then be marginalized out to obtain a closed form, tractable expression for the combined – mathematical plus computational – uncertainty.

Original: This uncertainty quantification can be done exactly in quadratic time and linear space complexity.
Revised: This uncertainty quantification can be done exactly in quadratic time and linear space complexity.

Original: Our framework admits three key theoretical properties.
Revised: Our framework admits three key theoretical properties.

Original: First, common GP approximations such as the partial Cholesky, the method of conjugate gradients and inducing point methods (e.g. SVGP) map to a corresponding IterGP instance.
Revised: First, common GP approximations such as the partial Cholesky, the method of conjugate gradients and inducing point methods (e.g. SVGP) map to a corresponding IterGP instance.

Original: Therefore, these approaches can either be directly extended or modified to properly account for computational uncertainty.
Revised: Therefore, these approaches can either be directly extended or modified to properly account for computational uncertainty.

Original: Second, the approximate posterior mean of any method in our proposed class converges to the mathematical posterior mean in RKHS norm in at most n steps, where the convergence rate is determined by the choice of method (Theorem 1).
Revised: Second, the approximate posterior mean of any method in our proposed class converges to the mathematical posterior mean in RKHS norm in at most n steps, where the convergence rate is determined by the choice of method (Theorem 1).

Original: Third, the combined uncertainty is a tight worst case bound on the relative error between the approximate posterior mean and the latent function (Theorem 2).
Revised: Third, the combined uncertainty is a tight worst case bound on the relative error between the approximate posterior mean and the latent function (Theorem 2).

Original: To the best of our knowledge no existing GP approximation has this last property; an analoguous guarantee only holds for exact GPs [32, Sec. 3.4].
Revised: To the best of our knowledge no existing GP approximation has this last property; an analoguous guarantee only holds for exact GPs [36, Sec. 3.4].

Original: In summary, this work introduces IterGP, which defines(a) a new class of GP approximations that accounts for computational uncertainty.
Revised: Contribution This work introduces IterGP, which defines a new class of GP approximations that accounts for computational uncertainty arising from limited computation.

Original: Some IterGP instances extend classic methods with improved uncertainty estimation.
Revised: Some IterGP instances extend classic methods with improved uncertainty quantification (Table 1).

Original: For any method in this class, we prove that the (b) approx. posterior mean converges to the mathematical posterior mean (Theorem 1) and that (c) combined uncertainty is a tight worst-case bound on the relative distance to the latent function one is trying to learn (Theorem 2 and Corollary 1).
Revised: For any method in this class, we prove that the approximate posterior mean converges to the mathematical posterior mean (Theorem 1) and that the combined uncertainty is a tight worst-case bound on the relative distance to the latent function one is trying to learn (Theorem 2, Corollary 1).

Original: Finally, we show empirically that modeling computational uncertainty can either(d) save computation or improve generalization on a set of regression benchmark datasets.
Revised: We demonstrate empirically that modeling computational uncertainty can either save computation or improve generalization on a set of regression benchmark datasets.

Revised: In conclusion, we show that it is possible to exactly quantify the inevitable error of GP approximations at quadratic cost by propagating said error to the posterior in the form of computational uncertainty.

Original:  Computation-Aware Gaussian Process Inference
Revised:  Computation-Aware Gaussian Process Inference

Original: We aim to learn a latent function h : X → Y from X ⊆
Revised: We aim to learn a latent function h : X → Y from X ⊆

Original: R
Revised: R

Original: d to Y ⊆
Revised: d to Y ⊆

Original: R given a training dataset X = ( x 1 , . . .
Revised: R given a training dataset X = ( x 1 , . . .

Original: , x n ) ∈ R n × d of n inputs x j ∈ R d and corresponding outputs y
Revised: , x n ) ∈ R n × d of n inputs x j ∈ R d and corresponding outputs y

Original: = ( y 1 , . . .
Revised: = ( y 1 , . . .

Original: , y n ) ⊺ ∈ R n .
Revised: , y n ) ⊺ ∈ R n .

Original: Gaussian Processes A stochastic process f ∼ GP ( µ, k ) with mean function µ : R d → R and kernel k : R d × R d → R is called a Gaussian process (GP) if any collection of function values f
Revised: Gaussian Processes A stochastic process f ∼ GP ( µ, k ) with mean function µ : R d → R and kernel k : R d × R d → R is called a Gaussian process (GP) if any collection of function values f

Original: =
Revised: =

Original: ( f ( x 1 ) , . .
Revised: ( f ( x 1 ) , . .

Original: f ( x n )) ⊺ ∼ N ( µ , K ) is jointly Gaussian with µ j = µ ( x j ) and K ij = k
Revised: f ( x n )) ⊺ ∼ N ( µ , K ) is jointly Gaussian with µ j = µ ( x j ) and K ij = k

Original: ( x i , x j ) .
Revised: ( x i , x j ) .

Original: Assuming observation noise y | f ∼ N ( f , σ 2 I ) , the posterior distribution at test inputs X ⋄ is given by f ⋄ ∼ N ( µ ∗ ( X ⋄ ) , k ∗ ( X ⋄ , X ⋄ )) where the posterior mean and covariance functions are given by µ ∗ ( · ) = µ ( · ) + k ( · , X ) v ∗ ˆ K − 1 ( y − µ ) , and k ∗ ( · , · ) =
Revised: Assuming observation noise y | f ∼ N ( f , σ 2 I ) , the posterior distribution at test inputs X ⋄ is given by f ⋄ ∼ N ( µ ∗ ( X ⋄ ) , k ∗ ( X ⋄ , X ⋄ )) where the posterior mean and covariance functions are given by µ ∗ ( · ) = µ ( · ) + k ( · , X ) v ∗ ˆ K − 1 ( y − µ ) , and k ∗ ( · , · ) =

Original: k ( · , · ) − k ( · , X ) ˆ K − 1 k ( X , · ) (1) where ˆ K := K + σ 2 I ∈ R n × n .
Revised: k ( · , · ) − k ( · , X ) ˆ K − 1 k ( X , · ) (1) where ˆ K := K + σ 2 I ∈ R n × n .

Original: Computing the representer weights v ∗
Revised: Computing the representer weights v ∗

Original: =
Revised: =

Original: ˆ K − 1 ( y − µ ) exactly (as well as the posterior variance) is prohibitive given our limited computational budget.
Revised: ˆ K − 1 ( y − µ ) exactly (as well as the posterior variance) is prohibitive given our limited computational budget.

Original: Learning Representer Weights Consider the conditional distribution of the latent GP given its representer weights:
Revised: Learning Representer Weights Consider the conditional distribution of the latent GP given its representer weights:

Original: [Equation]
Revised: [Equation]

Original: When v ∗ is known exactly, we recover eq.
Revised: When v ∗ is known exactly, we recover eq.

Original: However, if we instead treat v ∗ as a random variable with the prior p ( v ∗ ) =
Revised: However, if we instead treat v ∗ as a random variable with the prior p ( v ∗ ) =

Original: N ( v ∗ ; 0 , ˆ K − 1 ) , then the resulting marginal (cid:82) p ( f ⋄ | v ∗ ) p ( v ∗ )
Revised: N ( v ∗ ; 0 , ˆ K − 1 ) , then the resulting marginal (cid:82) p ( f ⋄ | v ∗ ) p ( v ∗ )

Original: d v ∗ recovers the GP prior N ( µ ( X ⋄ ) , k ( X ⋄ , X ⋄ )) .
Revised: d v ∗ recovers the GP prior N ( µ ( X ⋄ ) , k ( X ⋄ , X ⋄ )) .

Original: Our goal is to update this prior by iteratively applying the tractable computational primitive (i.e. matrix-vector multiplies).
Revised: Our goal is to update this prior by iteratively applying the tractable computational primitive (i.e. matrix-vector multiplies).

Original: More specifically, each iteration conditions the current belief distribution p ( v ∗ ) =
Revised: More specifically, each iteration conditions the current belief distribution p ( v ∗ ) =

Original: N ( v ∗ ; v i − 1 , Σ i − 1 ) on a one-dimensional projection of the current residual r i − 1 =
Revised: N ( v ∗ ; v i − 1 , Σ i − 1 ) on a one-dimensional projection of the current residual r i − 1 =

Original: [Equation]
Revised: [Equation]

Original: y
Revised: y

Original: [Equation]
Revised: [Equation]

Original: ) − ˆ Kv i − 1 , where the projection is defined by an arbitrary vector s i :
Revised: ) − ˆ Kv i − 1 , where the projection is defined by an arbitrary vector s i :

Original: [Equation]
Revised: [Equation]

Original: The choice of actions s i , which intuitively weight the approximation error of selected datapoints, defines different instances of our IterGP framework.
Revised: The choice of actions s i , which intuitively weight the approximation error of selected datapoints, defines different instances of our IterGP framework.

Original: Computing eq.
Revised: Computing eq.

Original: (3) requires a single matrix-vector multiplication.
Revised: (3) requires a single matrix-vector multiplication.

Original: After computing α i , we can perform an exact Bayesian update of p ( v ∗ ) via linear
Revised: After computing α i , we can perform an exact Bayesian update of p ( v ∗ ) via linear

Original: Gaussian identities.
Revised: Gaussian identities.

Original: The updated p ( v ∗ ) (conditioned on α i ) is N ( v ∗ | v i , Σ i ) , with
Revised: The updated p ( v ∗ ) (conditioned on α i ) is N ( v ∗ | v i , Σ i ) , with

Original: [Equation]
Revised: [Equation]

Original: where C i := (cid:80) ij =1 1 η j d j d ⊺ j = S i ( S ⊺ i ˆ KS i ) − 1 S ⊺ i is a rank- i matrix
Revised: where C i := (cid:80) ij =1 1 η j d j d ⊺ j = S i ( S ⊺ i ˆ KS i ) − 1 S ⊺ i is a rank- i matrix

Original: (see Proposition S3 for details).
Revised: (see Proposition S3 for details).

Original: With each computation, the uncertainty about the representer weights contracts as C i → ˆ K − 1 =
Revised: With each computation, the uncertainty about the representer weights contracts as C i → ˆ K − 1 =

Original: Σas i → n .
Revised: Σas i → n .

Original: After n iterations, C n = ˆ K − 1 , meaning we fully recovered the representer weights with zero uncertainty.
Revised: After n iterations, C n = ˆ K − 1 , meaning we fully recovered the representer weights with zero uncertainty.

Original: The consistent estimate for the representer weights is consequently v i
Revised: The consistent estimate for the representer weights is consequently v i

Original: = C i ( y − µ ) .
Revised: = C i ( y − µ ) .

Original: Combining Mathematical and Computational Uncertainty We now have a belief p ( v ∗ ) =
Revised: Combining Mathematical and Computational Uncertainty We now have a belief p ( v ∗ ) =

Original: N ( v ∗ ; v i , Σ i ) about the representer weights reflecting the expended computation.
Revised: N ( v ∗ ; v i , Σ i ) about the representer weights reflecting the expended computation.

Original: To account for this computational uncertainty, we treat the representer weights as a latent variable of the mathematical posterior by reparameterizing p ( f ⋄ | y )
Revised: To account for this computational uncertainty, we treat the representer weights as a latent variable of the mathematical posterior by reparameterizing p ( f ⋄ | y )

Original: =
Revised: =

Original: p ( f ⋄ | v ∗ ) and then marginalizing.
Revised: p ( f ⋄ | v ∗ ) and then marginalizing.

Original: The resulting marginal considers all possible representer weights which would have resulted in the same computational observations and therefore implicitly adds the uncertainty coming from the computation itself .
Revised: The resulting marginal considers all possible representer weights which would have resulted in the same computational observations and therefore implicitly adds the uncertainty coming from the computation itself .

Original: Since the posterior mean of a GP is a linear function of the representer weights, the marginal distribution is given by p ( f ⋄ ) =
Revised: Since the posterior mean of a GP is a linear function of the representer weights, the marginal distribution is given by p ( f ⋄ ) =

Original: (cid:82) p ( f ⋄ | v ∗ ) p ( v ∗ )
Revised: (cid:82) p ( f ⋄ | v ∗ ) p ( v ∗ )

Original: d v ∗ =
Revised: d v ∗ =

Original: N ( f ⋄ ; µ i ( X ⋄ ) , k i ( X ⋄ , X ⋄ )) , where µ i ( ·
Revised: N ( f ⋄ ; µ i ( X ⋄ ) , k i ( X ⋄ , X ⋄ )) , where µ i ( ·

Original: [Equation]
Revised: [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: uncertainty
Revised: uncertainty

Original: [Equation]
Revised: [Equation]

Original: since Σ i
Revised: since Σ i

Original: =
Revised: =

Original: ˆ K − 1 − C i .
Revised: ˆ K − 1 − C i .

Original: As we perform more computation, the computational uncertainty reduces and we approach the mathematical uncertainty.
Revised: As we perform more computation, the computational uncertainty reduces and we approach the mathematical uncertainty.

Original: We note that, while the individual terms are computationally prohibitive, the combined uncertainty can be evaluated cheaply since the approximate
Revised: We note that, while the individual terms are computationally prohibitive, the combined uncertainty can be evaluated cheaply since the approximate

Original: Combined Uncertainty
Revised: Combined Uncertainty

Original: IterGP-CG
Revised: IterGP-CG

Original: IterGP-Chol =
Revised: IterGP-Chol =

Original: Mathematical Uncertainty +
Revised: Mathematical Uncertainty +

Original: Computational Uncertainty
Revised: Computational Uncertainty

Original: IterGP-CG
Revised: IterGP-CG

Original: IterGP-Chol
Revised: IterGP-Chol

Original: [Figure]
Revised: [Figure]

Original: PI
Revised: PI

Original: [Figure]
Revised: [Figure]

Original: PI precision matrix C i is of low rank.
Revised: PI precision matrix C i is of low rank.

Original: Figure 2 illustrates that computational uncertainty is large where there are data and we have not targeted computation yet.
Revised: Figure 2 illustrates that computational uncertainty is large where there are data and we have not targeted computation yet.

Original: Different methods from our proposed class target computation in different parts of the input space.
Revised: Different methods from our proposed class target computation in different parts of the input space.

Original: Where there is no data the prior is a good approximation of the posterior and therefore computational uncertainty is low.
Revised: Where there is no data the prior is a good approximation of the posterior and therefore computational uncertainty is low.

Original: Algorithm 1 computes an estimate of the representer weights v i and the rank- i precision matrix approximation
Revised: Algorithm 1 computes an estimate of the representer weights v i and the rank- i precision matrix approximation

Original: C i .
Revised: C i .

Original: A specific instance of IterGP is defined by a sequence of actions s i .
Revised: A specific instance of IterGP is defined by a sequence of actions s i .

Original: To gain an intuition for how Algorithm 1 operates, it helps to interpret it as targeting a given computational budget towards certain datapoints defined by s i .
Revised: To gain an intuition for how Algorithm 1 operates, it helps to interpret it as targeting a given computational budget towards certain datapoints defined by s i .

Original: Near datapoints x j that are not targeted, i.e. ( s i ) j = 0 , computational uncertainty remains unchanged.
Revised: Near datapoints x j that are not targeted, i.e. ( s i ) j = 0 , computational uncertainty remains unchanged.

Original: In fact, datapoints ( x j , y j ) that are never targeted up to iteration i are not needed to compute GP ( µ i , k i ) , meaning that Algorithm 1 is inherently online and we can observe data sequentially without having to restart the algorithm (see Theorem S7).
Revised: In fact, datapoints ( x j , y j ) that are never targeted up to iteration i are not needed to compute GP ( µ i , k i ) , meaning that Algorithm 1 is inherently online and we can observe data sequentially without having to restart the algorithm (see Theorem S7).

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 2.1 Connection to Other GP Approximation Methods
Revised: 2.1 Connection to Other GP Approximation Methods

Original: IterGP extends the most commonly used GP approximations to include computational uncertainty, with at most quadratic cost (see Table 1 for a summary and Figure 2, Figure S3 for illustration)
Revised: IterGP extends the most commonly used GP approximations to include computational uncertainty, with at most quadratic cost (see Table 1 for a summary and Figure 2, Figure S3 for illustration)

Original: [Table]
Revised: [Table]

Original: Cholesky Decomposition
Revised: Cholesky Decomposition

Original: The (partial) Cholesky decomposition iteratively chooses datapoints or pivots x i based on a given ordering.
Revised: The (partial) Cholesky decomposition iteratively chooses datapoints or pivots x i based on a given ordering.

Original: The resulting Cholesky factor is lower triangular and increases in rank each iteration
Revised: The resulting Cholesky factor is lower triangular and increases in rank each iteration

Original: [Table]
Revised: [Table]

Original: and a well-chosen ordering achieves fast convergence (cf.
Revised: and a well-chosen ordering achieves fast convergence (cf.

Original: [33, Thm. 2.3]).
Revised: [37, Thm. 2.3]).

Original: If one chooses standard unit vectors e i as actions corresponding to the selected datapoint per iteration, then Algorithm 1 recovers the partial Cholesky factorization exactly (Theorem S3).
Revised: If one chooses standard unit vectors e i as actions corresponding to the selected datapoint per iteration, then Algorithm 1 recovers the partial Cholesky factorization exactly (Theorem S3).

Original: Conjugate Gradients CG [34] with preconditioning for GP inference has become increasingly popular [24–29, 35, 36].
Revised: Conjugate Gradients CG [38] with preconditioning for GP inference has become increasingly popular [24–29, 39, 40].

Original: Algorithm 1 recovers preconditioned CG exactly, if we choose either preconditioned conjugate gradients or residuals as actions (see Theorem S5 and Corollary S2).
Revised: Algorithm 1 recovers preconditioned CG exactly, if we choose either preconditioned conjugate gradients or residuals as actions (see Theorem S5 and Corollary S2).

Original: In fact, Algorithm 1 can even construct its own diagonal-plus-low-rank preconditioner by first running a few iterations with an arbitrary policy and then using the byproducts of these iterations for the preconditioner.
Revised: In fact, Algorithm 1 can even construct its own diagonal-plus-low-rank preconditioner by first running a few iterations with an arbitrary policy and then using the byproducts of these iterations for the preconditioner.

Original: For example, if we run IterGP-Chol initially, we can construct an incomplete Cholesky preconditioner for subsequent CG iterations.
Revised: For example, if we run IterGP-Chol initially, we can construct an incomplete Cholesky preconditioner for subsequent CG iterations.

Original: Inducing Point Methods Inducing point methods, such as variants of the Nyström approximation [16], i
Revised: Inducing Point Methods Inducing point methods, such as variants of the Nyström approximation [16], i

Original: [Table]
Revised: [Table]

Original: e. subset of regressors (SoR) [15, 37] and deterministic training conditional (DTC) [18, 38], as well as SVGP [22] share a posterior mean, which by Theorem S6 takes the form
Revised: e. subset of regressors (SoR) [15, 41] and deterministic training conditional (DTC) [18, 42], as well as SVGP [22] share a posterior mean, which by Theorem S6 takes the form

Original: [Equation]
Revised: [Equation]

Original: where Z ∈ R n × i is a set of inducing points and q ( · , · ) =
Revised: where Z ∈ R n × i is a set of inducing points and q ( · , · ) =

Original: k ( · , Z ) K − 1 ZZ k
Revised: k ( · , Z ) K − 1 ZZ k

Original: ( Z , · ) .
Revised: ( Z , · ) .

Original: These approximations also have very closely related posterior covariance functions [20, 39].
Revised: These approximations also have very closely related posterior covariance functions [20, 43].

Original: If we choose actions s i
Revised: If we choose actions s i

Original: = k
Revised: = k

Original: ( X , z i ) , by Proposition S3, Algorithm 1 returns a posterior mean given by
Revised: ( X , z i ) , by Proposition S3, Algorithm 1 returns a posterior mean given by

Original: [Equation]
Revised: [Equation]

Original: Choosing such actions, given by kernel functions k ( · , z i ) centered at inducing points
Revised: Choosing such actions, given by kernel functions k ( · , z i ) centered at inducing points

Original: z i , reduces computational uncertainty in regions close to inducing points (see IterGP-PI in Figure 2), where closeness is determined by the kernel.
Revised: z i , reduces computational uncertainty in regions close to inducing points (see IterGP-PI in Figure 2), where closeness is determined by the kernel.

Original: Comparing SVGP’s and IterGP-PI’s posterior mean provides a probabilistic numerical perspective on why even for small KL-divergence between the approximating distribution of SVGP and the true posterior, the mean estimate can be far from the true mean [31,
Revised: Comparing SVGP’s and IterGP-PI’s posterior mean provides a probabilistic numerical perspective on why even for small KL-divergence between the approximating distribution of SVGP and the true posterior, the mean estimate can be far from the true mean [31,

Original: Prop. 3.1].
Revised: Prop. 3.1].

Original: As outlined in Section 2, eq.
Revised: As outlined in Section 2, eq.

Original: (8) is a Bayesian update on the initially unknown representer weights v ∗ =
Revised: (8) is a Bayesian update on the initially unknown representer weights v ∗ =

Original: ˆ K − 1 ( y − µ ) .
Revised: ˆ K − 1 ( y − µ ) .

Original: The Gram matrix in eq.
Revised: The Gram matrix in eq.

Original: (8) describes how surprising the computational observations K ZX ( y − µ ) =
Revised: (8) describes how surprising the computational observations K ZX ( y − µ ) =

Original: S ⊺ i ( y − µ ) =
Revised: S ⊺ i ( y − µ ) =

Original: S ⊺ i ˆ Kv ∗ of the representer weights should be, given the prior uncertainty Σ 0 about them.
Revised: S ⊺ i ˆ Kv ∗ of the representer weights should be, given the prior uncertainty Σ 0 about them.

Original: SVGP uses a similar form for the posterior mean (c.f. (7) and (8)), but the Gram matrix is “smaller” since q ( X , X ) ⪯ k
Revised: SVGP uses a similar form for the posterior mean (c.f. (7) and (8)), but the Gram matrix is “smaller” since q ( X , X ) ⪯ k

Original: ( X , X ) .
Revised: ( X , X ) .

Original: This can be interpreted as inducing point methods being overconfident in their update of the representer weight estimates to achieve linear time complexity.
Revised: This can be interpreted as inducing point methods being overconfident in their update of the representer weight estimates to achieve linear time complexity.

Original: As the inducing points approach the data points the two posterior mean functions µ SVGP and µ i become closer and are equivalent if the inducing points equal the training data.
Revised: As the inducing points approach the data points the two posterior mean functions µ SVGP and µ i become closer and are equivalent if the inducing points equal the training data.

Original: 2.2 The Cost of Computational Uncertainty
Revised: 2.2 The Cost of Computational Uncertainty

Original: Quantifying combined uncertainty has greater cost than linear time GP approximations such as inducing point methods, due to its use of matrix-vector multiplication as the computational operation to condition on the data.
Revised: Quantifying combined uncertainty has greater cost than linear time GP approximations such as inducing point methods, due to its use of matrix-vector multiplication as the computational operation to condition on the data.

Original: Algorithm 1 in its most general form performs three matrix-vector products per iteration resulting in a quadratic time complexity O ( n 2 i ) overall for i iterations.
Revised: Algorithm 1 in its most general form performs three matrix-vector products per iteration resulting in a quadratic time complexity O ( n 2 i ) overall for i iterations.

Original: In this sense,
Revised: In this sense,

Original: Algorithm 1 represents a middle ground between the mathematical posterior—which incurs a cubic time complexity—and O ( ni 2 ) approximations—which can only estimate their computational error through potentially loose theoretical bounds which may [e.g. 21, 22, 40] or may not be computable in less than O ( n 3 ) [4, 33].
Revised: Algorithm 1 represents a middle ground between the mathematical posterior—which incurs a cubic time complexity—and O ( ni 2 ) approximations—which can only estimate their computational error through potentially loose theoretical bounds which may [e.g. 21, 22, 44] or may not be computable in less than O ( n 3 ) [4, 37].

Original: At any point during a run of Algorithm 1, computing the predictive mean on n ⋄ new data points has cost O ( n ⋄ n ) , while the marginal predictive (co-)variance can be evaluated in O ( n ⋄ ni ) since C i is of rank i .
Revised: At any point during a run of Algorithm 1, computing the predictive mean on n ⋄ new data points has cost O ( n ⋄ n ) , while the marginal predictive (co-)variance can be evaluated in O ( n ⋄ ni ) since C i is of rank i .

Original: Additionally, using Matheron’s rule [41–43], sampling from the approximate posterior at n ⋄ evaluation points also only requires O ( n ⋄ ni ) computation (assuming we can sample from the prior—see Section S3.3).
Revised: Additionally, using Matheron’s rule [45–47], sampling from the approximate posterior at n ⋄ evaluation points also only requires O ( n ⋄ ni ) computation (assuming we can sample from the prior—see Section S3.3).

Original: The objects required to make predictions and draw samples are the vector v i and low rank matrix C i which both require O ( ni ) memory.
Revised: The objects required to make predictions and draw samples are the vector v i and low rank matrix C i which both require O ( ni ) memory.

Original: Finally, the memory cost of Algorithm 1 is only linear in n , since matrix multiplication v (cid:55)→ ˆ Kv can be computed without explicitly forming ˆ K [44].
Revised: Finally, the memory cost of Algorithm 1 is only linear in n , since matrix multiplication v (cid:55)→ ˆ Kv can be computed without explicitly forming ˆ K [48].

Original: 2.3 Related Work
Revised: 2.3 Related Work

Original: GP inference based on matrix-vector multiplies, particularly CG [34], has become popular recently [5, 24–29, 35].
Revised: GP inference based on matrix-vector multiplies, particularly CG [38], has become popular recently [5, 24–29, 39].

Original: Advances in specialized hardware has boosted their scalability without excessive memory footprint [27, 44].
Revised: Advances in specialized hardware has boosted their scalability without excessive memory footprint [27, 48].

Original: Such iterative methods typically rely on preconditioning, which has been shown to significantly improve their performance [25, 26, 29].
Revised: Such iterative methods typically rely on preconditioning, which has been shown to significantly improve their performance [25, 26, 29].

Original: Our method generalizes CG in this setting and thus retains the same benefits.
Revised: Our method generalizes CG in this setting and thus retains the same benefits.

Original: At its core Algorithm 1 employs a (Bayesian) probabilistic numerical method [45–47], more specifically a probabilistic linear solver (PLS) [48–53] applied to the linear system ˆ Kv ∗ =
Revised: At its core Algorithm 1 employs a (Bayesian) probabilistic numerical method [32–35], more specifically a probabilistic linear solver (PLS) [49–54] applied to the linear system ˆ Kv ∗ =

Original: y .
Revised: y .

Original: The fact that a PLS using CG actions can recover CG in its posterior mean was observed previously [48, 50, 52].
Revised: The fact that a PLS using CG actions can recover CG in its posterior mean was observed previously [49, 51, 53].

Original: Here, we extend this result to residual actions and preconditioning.
Revised: Here, we extend this result to residual actions and preconditioning.

Original: Further, we also demonstrate the connection to the Cholesky and singular value decompositions.
Revised: Further, we also demonstrate the connection to the Cholesky and singular value decompositions.

Original: For randomized actions, the PLS as part of Algorithm 1 also recovers the randomized Kaczmarz method in its posterior mean [54–57].
Revised: For randomized actions, the PLS as part of Algorithm 1 also recovers the randomized Kaczmarz method in its posterior mean [55–58].

Original: Employing a PLS for GP approximation by updating beliefs over the kernel and precision matrix was suggested previously [52, 58].
Revised: Employing a PLS for GP approximation by updating beliefs over the kernel and precision matrix was suggested previously [53, 59].

Original: Our work differs in that it updates a belief over the representer weights, as opposed to the kernel function or matrix, considers more general projections than just conjugate residuals, and, most importantly, provides a theoretically motivated combined posterior which can be computed exactly.
Revised: Our work differs in that it updates a belief over the representer weights, as opposed to the kernel function or matrix, considers more general projections than just conjugate residuals, and, most importantly, provides a theoretically motivated combined posterior which can be computed exactly.

Original:  Theoretical Analysis
Revised:  Theoretical Analysis

Original: The main goals of our theoretical analysis will be to prove
Revised: The main goals of our theoretical analysis will be to prove

Original: (a) convergence of IterGP’s posterior mean in norm (Theorem 1) and pointwise (Corollary 1) and
Revised: (a) convergence of IterGP’s posterior mean in norm (Theorem 1) and pointwise (Corollary 1) and

Original: to
Revised: to

Original: provide rigorous justification for the combined and computational uncertainty.
Revised: provide rigorous justification for the combined and computational uncertainty.

Original: Importantly, the (b) combined uncertainty is a tight worst-case bound on the relative distance to all potential latent functions consistent with our (computational) observations (Theorem 2).
Revised: Importantly, the (b) combined uncertainty is a tight worst-case bound on the relative distance to all potential latent functions consistent with our (computational) observations (Theorem 2).

Original: We will demonstrate a
Revised: We will demonstrate a

Original: similar
Revised: similar

Original: interpretation of
Revised: interpretation of

Original: the computational
Revised: the computational

Original: uncertainty as a bound on
Revised: uncertainty as a bound on

Original: the
Revised: the

Original: relative error
Revised: relative error

Original: to the
Revised: to the

Original: mathematical posterior mean (see
Revised: mathematical posterior mean (see

Original: eqs.
Revised: eqs.

Original: and (
Revised: and (

Original: 3.1 Estimation of Representer Weights
Revised: 3.1 Estimation of Representer Weights

Original: At the heart of Algorithm 1 is a probabilistic linear solver [48–50, 52] iteratively updating a belief about the representer weights.
Revised: At the heart of Algorithm 1 is a probabilistic linear solver [49–51, 53] iteratively updating a belief about the representer weights.

Original: It constructs an expanding subspace span { s 1 , . . .
Revised: It constructs an expanding subspace span { s 1 , . . .

Original: , s i } = span { d 1 , . . .
Revised: , s i } = span { d 1 , . . .

Original: , d i } spanned by the actions in which the inverse ˆ K − 1 is perfectly identified.
Revised: , d i } spanned by the actions in which the inverse ˆ K − 1 is perfectly identified.

Original: Each step d i expanding this explored subspace is ˆ K -orthogonal to the previous ones.
Revised: Each step d i expanding this explored subspace is ˆ K -orthogonal to the previous ones.

Original: Proposition 1 (Conjugate Direction Method)
Revised: Proposition 1 (Conjugate Direction Method)

Original: Let the actions s i of Algorithm 1 be linearly independent.
Revised: Let the actions s i of Algorithm 1 be linearly independent.

Original: Then Algorithm 1 is a conjugate direction method, i.e. it holds that d ⊺ i ˆ Kd j = 0 for all i ̸
Revised: Then Algorithm 1 is a conjugate direction method, i.e. it holds that d ⊺ i ˆ Kd j = 0 for all i ̸

Original: = j .
Revised: = j .

Original: Proof.
Revised: Proof.

Original: Without loss of generality assume i > j .
Revised: Without loss of generality assume i > j .

Original: Then the result follows directly from Lemma S1.
Revised: Then the result follows directly from Lemma S1.

Original: Geometrically, Algorithm 1 iteratively projects the representer weights onto the expanding subspace span { S i } with respect to ⟨· , ·⟩ ˆ K .
Revised: Geometrically, Algorithm 1 iteratively projects the representer weights onto the expanding subspace span { S i } with respect to ⟨· , ·⟩ ˆ K .

Original: We can use this intuition to understand the convergence of the representer weights estimate.
Revised: We can use this intuition to understand the convergence of the representer weights estimate.

Original: The relative error ρ ( i ) at iteration i is given by how small the “angle” between this subspace and the representer weights vector is.
Revised: The relative error ρ ( i ) at iteration i is given by how small the “angle” between this subspace and the representer weights vector is.

Original: Proposition 2 (Relative Error Bound for the Representer Weights)
Revised: Proposition 2 (Relative Error Bound for the Representer Weights)

Original: For any choice of actions a relative error bound ρ ( i ) , s.t.
Revised: For any choice of actions a relative error bound ρ ( i ) , s.t.

Original: ∥ v ∗ − v i ∥
Revised: ∥ v ∗ − v i ∥

Original: ˆ K ≤ ρ ( i ) ∥ v ∗ ∥
Revised: ˆ K ≤ ρ ( i ) ∥ v ∗ ∥

Original: ˆ K is given by
Revised: ˆ K is given by

Original: [Equation]
Revised: [Equation]

Original: where ¯ v ∗ = v ∗ / ∥ v ∗ ∥ ˆ K .
Revised: where ¯ v ∗ = v ∗ / ∥ v ∗ ∥ ˆ K .

Original: If the actions { s i } ni =1 are linearly independent, then ρ ( i ) ≤ δ n = i .
Revised: If the actions { s i } ni =1 are linearly independent, then ρ ( i ) ≤ δ n = i .

Original: Proof.
Revised: Proof.

Original: See Section S2.2.
Revised: See Section S2.2.

Original: Proposition 2 guarantees convergence in at most n iterations, if the actions are chosen to be linearly independent, since C
Revised: Proposition 2 guarantees convergence in at most n iterations, if the actions are chosen to be linearly independent, since C

Original: i ˆ K is a ˆ K -orthogonal projection onto span { S i } (see Lemma S1).
Revised: i ˆ K is a ˆ K -orthogonal projection onto span { S i } (see Lemma S1).

Original: Therefore, if our finite computational budget is large enough, we eventually recover the mathematical posterior.
Revised: Therefore, if our finite computational budget is large enough, we eventually recover the mathematical posterior.

Original: This is reflected by the contraction of the posterior over the representer weights (see Proposition S4).
Revised: This is reflected by the contraction of the posterior over the representer weights (see Proposition S4).

Original: The bound in Proposition 2 is tight without further assumptions on the actions, since there exists an adverserial sequence of actions such that the first ( n − 1) are in span { v ∗ } ⊥ ˆ K .
Revised: The bound in Proposition 2 is tight without further assumptions on the actions, since there exists an adverserial sequence of actions such that the first ( n − 1) are in span { v ∗ } ⊥ ˆ K .

Original: Then the inverse is perfectly identified in that subspace, but v i
Revised: Then the inverse is perfectly identified in that subspace, but v i

Original: = C i
Revised: = C i

Original: y
Revised: y

Original: =
Revised: =

Original: C i
Revised: C i

Original: ˆ Kv ∗ = 0 .
Revised: ˆ Kv ∗ = 0 .

Original: In practice, one can derive tighter convergence bounds for specific sequences of actions.
Revised: In practice, one can derive tighter convergence bounds for specific sequences of actions.

Original: For example, for randomized actions the bound depends on their distribution [55, 56].
Revised: For example, for randomized actions the bound depends on their distribution [56, 57].

Original: If residuals r i are chosen as actions, we obtain
Revised: If residuals r i are chosen as actions, we obtain

Original: [Equation]
Revised: [Equation]

Original: since then Algorithm 1’s estimate of the representer weights equals that of CG (Corollary S2).
Revised: since then Algorithm 1’s estimate of the representer weights equals that of CG (Corollary S2).

Original: Here κ is the condition number and λ j the eigenvalues of either (i) the kernel matrix ˆ K if s i =
Revised: Here κ is the condition number and λ j the eigenvalues of either (i) the kernel matrix ˆ K if s i =

Original: r i , or (ii) the preconditioned kernel matrix ˆ P − 12 ˆ K ˆ P −
Revised: r i , or (ii) the preconditioned kernel matrix ˆ P − 12 ˆ K ˆ P −

Original: [Equation]
Revised: [Equation]

Original: 3.2 Convergence in RKHS Norm of the Posterior Mean
Revised: 3.2 Convergence in RKHS Norm of the Posterior Mean

Original: Having established convergence of the representer weights estimate, we can use this result to prove convergence in norm of IterGP’s posterior mean to the mathematical posterior at the same rate.
Revised: Having established convergence of the representer weights estimate, we can use this result to prove convergence in norm of IterGP’s posterior mean to the mathematical posterior at the same rate.

Original: Theorem 1 (Convergence in RKHS Norm of the Posterior Mean Approximation)
Revised: Theorem 1 (Convergence in RKHS Norm of the Posterior Mean Approximation)

Original: Let H k be the RKHS associated with kernel k ( · , · ) , σ 2 > 0 and let µ ∗ − µ ∈ H k be the unique solution to the regularized empirical risk minimization problem
Revised: Let H k be the RKHS associated with kernel k ( · , · ) , σ 2 > 0 and let µ ∗ − µ ∈ H k be the unique solution to the regularized empirical risk minimization problem

Original: [Equation]
Revised: [Equation]

Original: which is equivalent to the mathematical posterior mean up to shift by the prior µ [e.g. 1, Sec. 6.2].
Revised: which is equivalent to the mathematical posterior mean up to shift by the prior µ [e.g. 1, Sec. 6.2].

Original: Then for i ∈ { 0 , . .
Revised: Then for i ∈ { 0 , . .

Original: . , n } the posterior mean µ i ( · ) computed by Algorithm 1 satisfies
Revised: . , n } the posterior mean µ i ( · ) computed by Algorithm 1 satisfies

Original: [Equation]
Revised: [Equation]

Revised: [Equation]

Original: where µ 0 = µ is the prior mean and the constant c ( σ 2 ) =
Revised: where µ 0 = µ is the prior mean and the constant c ( σ 2 ) =

Original: (cid:113) 1 +
Revised: (cid:113) 1 +

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: See Section S2.3.
Revised: See Section S2.3.

Original: Theorem 1 gives a bound on the RKHS-norm error between the posterior mean µ i of IterGP and the mathematical posterior mean µ ∗ .
Revised: Theorem 1 gives a bound on the RKHS-norm error between the posterior mean µ i of IterGP and the mathematical posterior mean µ ∗ .

Original: If for the given prior kernel a bound on the RKHS-norm error between the mathematical posterior mean and the latent function is known, Theorem 1 can be directly used to bound the RKHS-norm error between IterGP’s posterior mean
Revised: If for the given prior kernel a bound on the RKHS-norm error ∥ h − µ ∗ ∥

Original: and the latent function h via the triangle inequality: ∥ h − µ i ∥ H k ≤ ∥ h − µ ∗ ∥ H k → 0 as n →∞ + ∥ µ ∗ 
Revised: H k between the latent function h and the mathematical posterior mean µ ∗ is known,

Original: [Equation] µ i ∥ H k 
Revised: Theorem 1 can be directly used to bound the RKHS-norm error between IterGP’s posterior mean and the latent function h via the triangle inequality: ∥ h − µ i ∥ H k ≤ ∥ h − µ ∗ ∥ H k

Original: →
Revised: →

Original: [Equation]
Revised: [Equation]

Original: i → n 
Revised: as n →∞ + ∥ µ ∗ − µ

Original: [Equation]
Revised: [Equation]

Revised: ∥ H k

Revised: → 0 as i → n .

Original: 3.3 Combined and Computational Uncertainty as Worst Case Errors
Revised: 3.3 Combined and Computational Uncertainty as Worst Case Errors

Original: While Theorem 1 shows convergence in norm for IterGP’s posterior mean, the convergence rate ρ ( i ) may contain expressions which cannot be evaluated at runtime with the limited computation at our disposal.
Revised: While Theorem 1 shows convergence in norm for IterGP’s posterior mean, the convergence rate ρ ( i ) may contain expressions which cannot be evaluated at runtime with the limited computation at our disposal.

Original: For example, for residual actions evaluating eq.
Revised: For example, for residual actions evaluating eq.

Original: (10) requires computation of the kernel matrix spectrum.
Revised: (10) requires computation of the kernel matrix spectrum.

Original: However, the combined uncertainty of IterGP is a tight bound on the pointwise relative error to all possible latent functions which would have resulted in the same computations.
Revised: However, the combined uncertainty of IterGP is a tight bound on the pointwise relative error to all possible latent functions which would have resulted in the same computations.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: Theorem 2 (Combined and Computational Uncertainty as Worst Case Errors)
Revised: Theorem 2 (Combined and Computational Uncertainty as Worst Case Errors)

Original: Let σ 2 ≥ 0 and let k i ( · , · ) =
Revised: Let σ 2 ≥ 0 and let k i ( · , · ) =

Original: k ∗ ( · , · ) + k comp i ( · , · ) be the combined uncertainty computed by Algorithm 1.
Revised: k ∗ ( · , · ) + k comp i ( · , · ) be the combined uncertainty computed by Algorithm 1.

Original: Then, for any x ∈ X (assuming x / ∈ X if σ 2 > 0 ) we have
Revised: Then, for any x ∈ X (assuming x / ∈ X if σ 2 > 0 ) we have

Original: [Equation]
Revised: [Equation]

Original: [Figure]
Revised: [Figure]

Original: [Equation]
Revised: [Equation]

Original: [Figure]
Revised: [Figure]

Original: [Equation]
Revised: [Equation]

Original: [Figure]
Revised: [Figure]

Original: [Equation]
Revised: [Equation]

Original: , and
Revised: , and

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: [Figure]
Revised: [Figure]

Original: [Equation]
Revised: [Equation]

Original: where µ g ∗ ( · ) =
Revised: where µ g ∗ ( · ) =

Original: k ( · , X ) ˆ K − 1 g ( X ) is the mathematical and µ gi ( · ) =
Revised: k ( · , X ) ˆ K − 1 g ( X ) is the mathematical and µ gi ( · ) =

Original: k ( · , X ) C
Revised: k ( · , X ) C

Original: i g ( X ) IterGP’s posterior mean for the latent function g ∈ H k σ .
Revised: i g ( X ) IterGP’s posterior mean for the latent function g ∈ H k σ .

Original: If σ 2 = 0 , then the above also holds for x ∈ X .
Revised: If σ 2 = 0 , then the above also holds for x ∈ X .

Original: Proof.
Revised: Proof.

Original: See Section S2.4.
Revised: See Section S2.4.

Original: Theorem 2 rigorously explains why the combined (mathematical + computational) uncertainty k
Revised: Theorem 2 rigorously explains why the combined (mathematical + computational) uncertainty k

Original: i is the correct object characterizing our belief about the latent function h , given that we are in the limited compute regime.
Revised: i is the correct object characterizing our belief about the latent function h , given that we are in the limited compute regime.

Original: In the same way that the mathematical uncertainty is a tight bound on the distance to all functions g which could have produced the data (see [32, Prop. 3.8]), the combined uncertainty is a tight bound on all functions g which would have produced the same computations.
Revised: In the same way that the mathematical uncertainty is a tight bound on the distance to all functions g which could have produced the data (see [36, Prop. 3.8]), the combined uncertainty is a tight bound on all functions g which would have produced the same computations.

Original: 3.4 Pointwise Convergence of the Posterior Mean
Revised: 3.4 Pointwise Convergence of the Posterior Mean

Original: In particular, as Corollary 1 shows and Figure 3 illustrates, the computational uncertainty ( ) is a pointwise bound on the relative distance to the mathematical posterior mean (16) and the combined uncertainty ( + ) is a pointwise bound on the relative distance to the true latent function (15).
Revised: In particular, as Corollary 1 shows and Figure 3 illustrates, the computational uncertainty ( ) is a pointwise bound on the relative distance to the mathematical posterior mean (16) and the combined uncertainty ( + ) is a pointwise bound on the relative distance to the true latent function (15).

Original: Corollary 1 (Pointwise Convergence of the Posterior Mean)
Revised: Corollary 1 (Pointwise Convergence of the Posterior Mean)

Original: Assume the conditions of Theorem 2 hold and assume the latent function h ∈
Revised: Assume the conditions of Theorem 2 hold and assume the latent function h ∈

Original: H k σ .
Revised: H k σ .

Original: Let µ ∗ be the corresponding mathematical posterior mean and µ i the posterior mean computed by Algorithm 1.
Revised: Let µ ∗ be the corresponding mathematical posterior mean and µ i the posterior mean computed by Algorithm 1.

Original: Then it holds that
Revised: Then it holds that

Original: [Equation]
Revised: [Equation]

Original: and
Revised: and

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: This follows immediately from Theorem 2 by recognizing that h/ ∥ h ∥ H kσ has unit norm
Revised: This follows immediately from Theorem 2 by recognizing that h/ ∥ h ∥ H kσ has unit norm

Original: It is worth noting that Theorem 2 and Corollary 1 generally do not hold for other GP approximations .
Revised: It is worth noting that Theorem 2 and Corollary 1 generally do not hold for other GP approximations .

Original: They explicitly rely on C
Revised: They explicitly rely on C

Original: i ˆ K being the ˆ K -orthogonal projection onto the space spanned by the actions (see Lemma S1).
Revised: i ˆ K being the ˆ K -orthogonal projection onto the space spanned by the actions (see Lemma S1).

Original: Since orthogonal projections are unique, if another GP approximation is such a projection and therefore satisfies Theorem 2, it is in fact an instance of IterGP.
Revised: Since orthogonal projections are unique, if another GP approximation is such a projection and therefore satisfies Theorem 2, it is in fact an instance of IterGP.

Original:  Experiments
Revised:  Experiments

Original: To demonstrate the effects of quantifying computational uncertainty we perform GP regression on synthetic and benchmark datasets for the two most common GP approximations in the largescale setting, SVGP [22] and CGGP [26], and their direct analogs from our class of methods.
Revised: To demonstrate the effects of quantifying computational uncertainty we perform GP regression on synthetic and benchmark datasets for the two most common GP approximations in the largescale setting, SVGP [22] and CGGP [26], and their direct analogs from our class of methods.

Original: An implementation of Algorithm 1, based on KeOps [44] and ProbNum [59], is available at: https://github.com/JonathanWenger/itergp
Revised: An implementation of Algorithm 1, based on KeOps [48] and ProbNum [60], is available at: https://github.com/JonathanWenger/itergp

Original: Experimental Setup We consider a synthetic dataset of iid uniformly sampled inputs x j ∈ [ − 1 , 1] d with y ( x ) = sin( π x ⊺ 1 ) + ε , where ε ∼ N (0 , σ 2 ) , as well as a range of UCI datasets [60] with training set sizes n = 5 , 287 to 57 , 247 , dimensions d = 9 to 26 and standardized features.
Revised: Experimental Setup We consider a synthetic dataset of iid uniformly sampled inputs x j ∈ [ − 1 , 1] d with y ( x ) = sin( π x ⊺ 1 ) + ε , where ε ∼ N (0 , σ 2 ) , as well as a range of UCI datasets [61] with training set sizes n = 5 , 287 to 57 , 247 , dimensions d = 9 to 26 and standardized features.

Original: All experiments were run on an NVIDIA GeForce RTX 2080 Ti graphics card.
Revised: All experiments were run on an NVIDIA GeForce RTX 2080 Ti graphics card.

Original: We perform GP regression using a zero mean prior and a Matérn( 12 ) kernel (for other kernels see Section S4).
Revised: We perform GP regression using a zero mean prior and a Matérn( 12 ) kernel (for other kernels see Section S4).

Original: All experiments were run 10 times with randomly sampled training and test splits of 90 / 10 and we report average metrics with 95% confidence intervals.
Revised: All experiments were run 10 times with randomly sampled training and test splits of 90 / 10 and we report average metrics with 95% confidence intervals.

Original: IterGP reduces the necessary computations for CG-based GP inference.
Revised: IterGP reduces the necessary computations for CG-based GP inference.

Original: We compare IterGP to the CG-based GP inference used in the GPyTorch library [26].
Revised: We compare IterGP to the CG-based GP inference used in the GPyTorch library [26].

Original: For all datasets, we select hyperparameters using the training procedure of Wenger et al.
Revised: For all datasets, we select hyperparameters using the training procedure of Wenger et al.

Original: As we show in Theorem S5, the posterior mean of IterGP with (conjugate) residual actions is exactly equivalent to performing CG to compute the representer weights.
Revised: As we show in Theorem S5, the posterior mean of IterGP with (conjugate) residual actions is exactly equivalent to performing CG to compute the representer weights.

Original: Therefore, both methods produce the exact same posterior mean estimate and thus achieve the same RMSE as a function of CG iterations (Figure 4, bottom).
Revised: Therefore, both methods produce the exact same posterior mean estimate and thus achieve the same RMSE as a function of CG iterations (Figure 4, bottom).

Original: The primary difference between the two methods is in the posterior variance.
Revised: The primary difference between the two methods is in the posterior variance.

Original: The combined variance estimate of IterGP is essentially “free” in the sense that it reuses terms from the posterior mean calculation.
Revised: The combined variance estimate of IterGP is essentially “free” in the sense that it reuses terms from the posterior mean calculation.

Original: In contrast, computing the posterior variance with CG requires n ⋄ additional linear solves ( ˆ K − 1 x ⋄ 1 , . . .
Revised: In contrast, computing the posterior variance with CG requires n ⋄ additional linear solves ( ˆ K − 1 x ⋄ 1 , . . .

Original: , ˆ K − 1 x ⋄ n ⋄ ).
Revised: , ˆ K − 1 x ⋄ n ⋄ ).

Original: GPyTorch relies on the Lanczos Variance Estimate technique [61] which essentially warm-starts each of these solves by reusing quantities from the linear solve ˆ K − 1 k
Revised: GPyTorch relies on the Lanczos Variance Estimate technique [62] which essentially warm-starts each of these solves by reusing quantities from the linear solve ˆ K − 1 k

Original: ( X , x ⋄ 1 ) .
Revised: ( X , x ⋄ 1 ) .

Original: While this approach produces reliable variance estimates that converge to the true posterior variance, it requires additional computation: at least one set of additional CG iterations to compute ˆ K − 1 k
Revised: While this approach produces reliable variance estimates that converge to the true posterior variance, it requires additional computation: at least one set of additional CG iterations to compute ˆ K − 1 k

Original: ( X , x ⋄ 1 ) .
Revised: ( X , x ⋄ 1 ) .

Original: In Figure 4(a) (top), we see that IterGP and GPyTorch’s CGGP achieve nearly identical NLL, suggesting that both methods produce variances that yield similar generalization.
Revised: In Figure 4(a) (top), we see that IterGP and GPyTorch’s CGGP achieve nearly identical NLL, suggesting that both methods produce variances that yield similar generalization.

Original: [Figure]
Revised: [Figure]

Original: [Figure]
Revised: [Figure]

Original: The key difference between the methods is that 1) unlike CGGP, IterGP’s variances exactly capture both mathematical and computational uncertainty, and 2) IterGP’s variances require no additional solves, resulting in half as much computation as GPyTorch’s CGGP implementation (see Figure 4(b)).
Revised: The key difference between the methods is that 1) unlike CGGP, IterGP’s variances exactly capture both mathematical and computational uncertainty, and 2) IterGP’s variances require no additional solves, resulting in half as much computation as GPyTorch’s CGGP implementation (see Figure 4(b)).

Original: Quantifying computational uncertainty improves generalization of inducing point methods.
Revised: Quantifying computational uncertainty improves generalization of inducing point methods.

Original: To understand the benefits of quantifying computational uncertainty, we compare the linear-time
Revised: To understand the benefits of quantifying computational uncertainty, we compare the linear-time

Original: SVGP method (which does not quantify computational uncertainty) with the closest (quadratic-time) inducing point analog from our proposed IterGP framework (see Section 2.1).
Revised: SVGP method (which does not quantify computational uncertainty) with the closest (quadratic-time) inducing point analog from our proposed IterGP framework (see Section 2.1).

Original: While the IterGP method is inherently more expensive than SVGP, our goal is simply to demonstrate that inducing points can yield far more accuracy if one has the budget to account for computational uncertainty.
Revised: While the IterGP method is inherently more expensive than SVGP, our goal is simply to demonstrate that inducing points can yield far more accuracy if one has the budget to account for computational uncertainty.

Original: To that end, we compare SVGP against IterGP using the same set of randomly-placed inducing points.
Revised: To that end, we compare SVGP against IterGP using the same set of randomly-placed inducing points.

Original: We identify a set of kernel hyperparameters by optimizing the ELBO of SVGP on the training data, using these for both SVGP and IterGP.
Revised: We identify a set of kernel hyperparameters by optimizing the ELBO of SVGP on the training data, using these for both SVGP and IterGP.

Original: As Figure 5 shows, we find that across all datasets that IterGP offers better RMSE and NLL than SVGP, despite the fact that the hyperparameters are chosen to favor SVGP.
Revised: As Figure 5 shows, we find that across all datasets that IterGP offers better RMSE and NLL than SVGP, despite the fact that the hyperparameters are chosen to favor SVGP.

Original: This suggests that the extra computation needed to quantify computational uncertainty can more “effectively” utilize a set of inducing points for predictive models.
Revised: This suggests that the extra computation needed to quantify computational uncertainty can more “effectively” utilize a set of inducing points for predictive models.

Original: [Figure]
Revised: [Figure]

Original:  Conclusion
Revised:  Conclusion

Original: Scalable GP approximations inevitably introduce error, leading to a worse model for the latent function in question.
Revised: Scalable GP approximations inevitably introduce error, leading to a worse model for the latent function in question.

Original: This work demonstrates that it is possible to account for both uncertainty arising from limited data and uncertainty arising from limited computation exactly – which as we show improves model performance.
Revised: This work demonstrates that it is possible to account for both uncertainty arising from limited data and uncertainty arising from limited computation exactly – which as we show improves model performance.

Original: IterGP methods return this combined uncertainty which crucially represents a dataset-specific, pointwise worst-case bound on the error to the true latent function.
Revised: IterGP methods return this combined uncertainty which crucially represents a dataset-specific, pointwise worst-case bound on the error to the true latent function.

Original: At its core, IterGP performs repeated matrix-vector multiplication resulting in quadratic complexity.
Revised: At its core, IterGP performs repeated matrix-vector multiplication resulting in quadratic complexity.

Original: Since modern computing architectures (i.e. GPUs) have been specifically designed for this operation at scale, iterative approaches for GP approximation are becoming competitive with theoretically cheaper approximations, like inducing point methods [26, 27].
Revised: Since modern computing architectures (i.e. GPUs) have been specifically designed for this operation at scale, iterative approaches for GP approximation are becoming competitive with theoretically cheaper approximations, like inducing point methods [26, 27].

Original: Finally, in addition to the general utility of IterGP, we expect this class of methods to be particularly useful in applications where accurate uncertainty quantification is important or, due to its inherently online nature, where data is acquired sequentially such as in active learning and Bayesian optimization.
Revised: Finally, in addition to the general utility of IterGP, we expect this class of methods to be particularly useful in applications where accurate uncertainty quantification is important or, due to its inherently online nature, where data is acquired sequentially such as in active learning and Bayesian optimization.

Original: Acknowledgments and Disclosure of Funding
Revised: Acknowledgments and Disclosure of Funding

Original: JW, MP and PH gratefully acknowledge financial support by the European Research Council through
Revised: JW, MP and PH gratefully acknowledge financial support by the European Research Council through

Original: ERC StG Action 757275 / PANAMA; the DFG Cluster of Excellence “Machine Learning - New
Revised: ERC StG Action 757275 / PANAMA; the DFG Cluster of Excellence “Machine Learning - New

Original: Perspectives for Science”, EXC 2064/1, project number 390727645; the German Federal Ministry of Education and Research (BMBF) through the Tübingen AI Center (FKZ: 01IS18039A); and funds from the Ministry of Science, Research and Arts of the State of Baden-Württemberg.
Revised: Perspectives for Science”, EXC 2064/1, project number 390727645; the German Federal Ministry of Education and Research (BMBF) through the Tübingen AI Center (FKZ: 01IS18039A); and funds from the Ministry of Science, Research and Arts of the State of Baden-Württemberg.

Original: The authors thank the International Max Planck Research School for Intelligent Systems (IMPRS-IS) for supporting JW and MP.
Revised: The authors thank the International Max Planck Research School for Intelligent Systems (IMPRS-IS) for supporting JW and MP.

Original: JPC and GP are supported by the Simons Foundation, the McKnight
Revised: JPC and GP are supported by the Simons Foundation, the McKnight

Original: Foundation, the Grossman Center and the Gatsby Charitable Trust.
Revised: Foundation, the Grossman Center and the Gatsby Charitable Trust.

Original: The authors would like to thank
Revised: The authors would like to thank

Original: Hanna Dettki, Frank Schneider, Lukas Tatzel and all anonymous reviewers for helpful feedback on an earlier version of this manuscript.
Revised: Hanna Dettki, Frank Schneider, Lukas Tatzel and all anonymous reviewers for helpful feedback on an earlier version of this manuscript.

Original: Checklist
Revised: Checklist

Original: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
Revised: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?

Original: [Yes] (b) Did you describe the limitations of your work?
Revised: [Yes] (b) Did you describe the limitations of your work?

Original: [Yes] (c) Did you discuss any potential negative societal impacts of your work?
Revised: [Yes] (c) Did you discuss any potential negative societal impacts of your work?

Original: [N/A] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
Revised: [N/A] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?

Original: [Yes] 2.
Revised: [Yes] 2.

Original: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
Revised: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?

Original: [Yes] (b) Did you include complete proofs of all theoretical results?
Revised: [Yes] (b) Did you include complete proofs of all theoretical results?

Original: [Yes] Proofs are included in the supplementary material.
Revised: [Yes] Proofs are included in the supplementary material.

Original: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
Revised: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?

Original: [Yes] (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
Revised: [Yes] (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?

Original: [Yes] (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?
Revised: [Yes] (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?

Original: [Yes] (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
Revised: [Yes] (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?

Original: [Yes] 4.
Revised: [Yes] 4.

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
Revised: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?

Original: [Yes] (b) Did you mention the license of the assets?
Revised: [Yes] (b) Did you mention the license of the assets?

Original: [N/A] (c) Did you include any new assets either in the supplemental material or as a URL?
Revised: [N/A] (c) Did you include any new assets either in the supplemental material or as a URL?

Original: [N/A] (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating?
Revised: [N/A] (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating?

Original: [N/A] (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?
Revised: [N/A] (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?

Original: [N/A] 
Revised: [N/A] 5.

Original: If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?
Revised: If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?

Original: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
Revised: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?

Original: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
Revised: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?

Original: [N/A]
Revised: [N/A]

Original: Supplementary Material
Revised: Supplementary Material

Original: : Posterior and Computational Uncertainty in Gaussian Processes
Revised: : Posterior and Computational Uncertainty in Gaussian Processes

Original: This supplementary material contains additional results and in particular proofs for all theoretical statements.
Revised: This supplementary material contains additional results and in particular proofs for all theoretical statements.

Original: References referring to sections, equations or theorem-type environments within this document are prefixed with ‘S’, while references to, or results from, the main paper are stated as is.
Revised: References referring to sections, equations or theorem-type environments within this document are prefixed with ‘S’, while references to, or results from, the main paper are stated as is.

Original: S1 Connections to Other GP Approximations
Revised: S1 Connections to Other GP Approximations

Original: S1.
Revised: S1.

Original: 1 Pivoted Cholesky Decomposition
Revised: 1 Pivoted Cholesky Decomposition

Original: S1.
Revised: S1.

Original: 2 Singular / Eigenvalue Decomposition
Revised: 2 Singular / Eigenvalue Decomposition

Original: S1.
Revised: S1.

Original: 3 Conjugate Gradient Method
Revised: 3 Conjugate Gradient Method

Original: S1.
Revised: S1.

Original: 4 Inducing Point Methods
Revised: 4 Inducing Point Methods

Original: S2 Theoretical Results and Proofs
Revised: S2 Theoretical Results and Proofs

Original: S2.
Revised: S2.

Original: Properties
Revised: Properties

Original: of
Revised: of

Original: Algorithm
Revised: Algorithm

Original: S
Revised: S

Original: .2 Approximation of Representer Weights
Revised: .2 Approximation of Representer Weights

Original: S
Revised: S

Original: .3 Convergence Analysis of the Posterior Mean Approximation
Revised: .3 Convergence Analysis of the Posterior Mean Approximation

Original: S
Revised: S

Original: Combined Uncertainty as Worst Case Error
Revised: Combined Uncertainty as Worst Case Error

Original: S
Revised: S

Original: Implementation of Algorithm
Revised: Implementation of Algorithm

Original: S
Revised: S

Original: Policy Choice
Revised: Policy Choice

Original: S
Revised: S

Original: Stopping Criterion
Revised: Stopping Criterion

Original: S3.3 Efficient Sampling from the Combined Posterior
Revised: S3.3 Efficient Sampling from the Combined Posterior

Original: S
Revised: S

Original: Additional Experimental Results
Revised: Additional Experimental Results

Original: S Connections to Other GP Approximations S1.1 Pivoted Cholesky Decomposition
Revised: S Connections to Other GP Approximations S1.1 Pivoted Cholesky Decomposition

Original: Theorem S3 (Pivoted Cholesky Decomposition)
Revised: Theorem S3 (Pivoted Cholesky Decomposition)

Original: Let ( j i ) ni
Revised: Let ( j i ) ni

Original: =1 be a set of indices defining the pivot elements of the pivoted Cholesky decomposition and
Revised: =1 be a set of indices defining the pivot elements of the pivoted Cholesky decomposition and

Original: P ∈ R n × n the corresponding permutation matrix.
Revised: P ∈ R n × n the corresponding permutation matrix.

Original: Assume the actions of Algorithm 1 are given by the standard unit vectors s i
Revised: Assume the actions of Algorithm 1 are given by the standard unit vectors s i

Original: = P e i =
Revised: = P e i =

Original: e j i , i.e.
Revised: e j i , i.e.

Original: [Equation]
Revised: [Equation]

Original: Then Algorithm 1 recovers the pivoted Cholesky decomposition, i.e. it holds for all i ∈ { 0 , . . . , n } that
Revised: Then Algorithm 1 recovers the pivoted Cholesky decomposition, i.e. it holds for all i ∈ { 0 , . . . , n } that

Original: [Equation]
Revised: [Equation]

Original: where L i ∈ R n × i is the (partial) Cholesky factor of P ⊺ ˆ KP as computed by Algorithm S2.
Revised: where L i ∈ R n × i is the (partial) Cholesky factor of P ⊺ ˆ KP as computed by Algorithm S2.

Original: i =
Revised: i =

Original: ≈ i
Revised: ≈ i

Original: =≈ i
Revised: =≈ i

Original: =≈
Revised: =≈

Original: P ⊺ ˆ KP
Revised: P ⊺ ˆ KP

Original: L i
Revised: L i

Original: L ⊺ i
Revised: L ⊺ i

Original: Algorithm S
Revised: Algorithm S

Original: Input: kernel matrix ˆ K , permutation matrix P
Revised: Input: kernel matrix ˆ K , permutation matrix P

Original: Output: lower triangular L i , s.t.
Revised: Output: lower triangular L i , s.t.

Original: L i L ⊺ i ≈ P ⊺ ˆ KP 1 procedure
Revised: L i L ⊺ i ≈ P ⊺ ˆ KP 1 procedure

Original: C HOLESKY ( ˆ K , P )
Revised: C HOLESKY ( ˆ K , P )

Original: A ← P ⊺ ˆ KP for i ∈ { 1 , . . . , n } do l i ←
Revised: A ← P ⊺ ˆ KP for i ∈ { 1 , . . . , n } do l i ←

Original: A : i / √ A ii
Revised: A : i / √ A ii

Original: A ← A − l i l ⊺ i = P ⊺ ˆ KP − L i L ⊺
Revised: A ← A − l i l ⊺ i = P ⊺ ˆ KP − L i L ⊺

Original: i
Revised: i

Original: L i =
Revised: L i =

Original: ( L i −l i ) return L i
Revised: ( L i −l i ) return L i

Original: Proof.
Revised: Proof.

Original: We proceed by induction.
Revised: We proceed by induction.

Original: Assume (S18) holds after i iterations of Algorithm 1.
Revised: Assume (S18) holds after i iterations of Algorithm 1.

Original: For the base case i = 0 , it holds by assumption that P ⊺ Q 0 P =
Revised: For the base case i = 0 , it holds by assumption that P ⊺ Q 0 P =

Original: P ⊺ ˆ KC 0 ˆ KP = 0 .
Revised: P ⊺ ˆ KC 0 ˆ KP = 0 .

Original: Now for the induction step i → i + 1 , we have
Revised: Now for the induction step i → i + 1 , we have

Original: [Equation]
Revised: [Equation]

Original: where l i +1 is given by Algorithm S2.
Revised: where l i +1 is given by Algorithm S2.

Original: Combining this with one more use of the induction hypothesis we obtain
Revised: Combining this with one more use of the induction hypothesis we obtain

Original: [Equation]
Revised: [Equation]

Original: This proves the claim.
Revised: This proves the claim.

Original: S1.2 Singular / Eigenvalue Decomposition
Revised: S1.2 Singular / Eigenvalue Decomposition

Original: Theorem S4 (Singular / Eigenvalue Decomposition)
Revised: Theorem S4 (Singular / Eigenvalue Decomposition)

Original: Let the actions s i
Revised: Let the actions s i

Original: =
Revised: =

Original: u i of Algorithm 1 be given by the eigenvectors
Revised: u i of Algorithm 1 be given by the eigenvectors

Original: u i of ˆ K in arbitrary order.
Revised: u i of ˆ K in arbitrary order.

Original: Then for i ∈ { 1 , . . . , n } it holds that
Revised: Then for i ∈ { 1 , . . . , n } it holds that

Original: [Equation]
Revised: [Equation]

Original: where U =
Revised: where U =

Original: ( u 1 , . . .
Revised: ( u 1 , . . .

Original: , u i ) ∈ R n × i and Λ = diag( λ 1 , . . .
Revised: , u i ) ∈ R n × i and Λ = diag( λ 1 , . . .

Original: , λ i
Revised: , λ i

Original: ) ∈
Revised: ) ∈

Original: R i × i is the diagonal matrix of eigenvalues of ˆ K with the order given by the order of the actions.
Revised: R i × i is the diagonal matrix of eigenvalues of ˆ K with the order given by the order of the actions.

Original: Proof.
Revised: Proof.

Original: It holds by assumption and eq.
Revised: It holds by assumption and eq.

Original: (S37), that
Revised: (S37), that

Original: [Equation]
Revised: [Equation]

Original: as well as
Revised: as well as

Original: [Equation]
Revised: [Equation]

Original: This proves the claim.
Revised: This proves the claim.

Original: S1.3 Conjugate Gradient Method
Revised: S1.3 Conjugate Gradient Method

Original: Algorithm S3:
Revised: Algorithm S3:

Original: Preconditioned Conjugate Gradient Method [34]
Revised: Preconditioned Conjugate Gradient Method [38]

Original: Input: kernel matrix ˆ K , labels y , prior mean µ , preconditioner ˆ P
Revised: Input: kernel matrix ˆ K , labels y , prior mean µ , preconditioner ˆ P

Original: Output: representer weights v i
Revised: Output: representer weights v i

Original: ≈ ˆ K − 1 ( y − µ ) 1 procedure CG
Revised: ≈ ˆ K − 1 ( y − µ ) 1 procedure CG

Original: ( ˆ K , y − µ , ˆ P ) v 0 ← s 0 ← while ∥ r i ∥ 2 > max( δ rtol ∥
Revised: ( ˆ K , y − µ , ˆ P ) v 0 ← s 0 ← while ∥ r i ∥ 2 > max( δ rtol ∥

Original: y ∥ 2 , δ atol ) and i < i max do r
Revised: y ∥ 2 , δ atol ) and i < i max do r

Original: [Equation]
Revised: [Equation]

Original: ←
Revised: ←

Original: [Equation]
Revised: [Equation]

Original: µ

Original: [Equation]

Original: − ˆ Kvi
Revised: − ˆ Kv

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: ←
Revised: ←

Original: [Equation]
Revised: [Equation]

Original: s
Revised: s

Original: [Equation]
Revised: [Equation]

Original: v

Original: [Equation]
Revised: [Equation]

Original: ←
Revised: ←

Original: [Equation]
Revised: [Equation]

Original: s i return v
Revised: s i return v

Original: Theorem S5 (Preconditioned Conjugate Gradient Method)
Revised: Theorem S5 (Preconditioned Conjugate Gradient Method)

Original: Let ˆ P ∈ R n × n be a symmetric positive definite preconditioner.
Revised: Let ˆ P ∈ R n × n be a symmetric positive definite preconditioner.

Original: Assume the actions of Algorithmare given by
Revised: Assume the actions of Algorithmare given by

Original: [Equation]
Revised: [Equation]

Original: the preconditioned conjugate gradient method.
Revised: the preconditioned conjugate gradient method.

Original: Then Algorithm 1 recovers preconditioned CG initialized at v CG0 = 0 , i.e. it holds for i ∈ { 1 , . . . , n } that
Revised: Then Algorithm 1 recovers preconditioned CG initialized at v CG0 = 0 , i.e. it holds for i ∈ { 1 , . . . , n } that

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: First note that by assumption s i
Revised: First note that by assumption s i

Original: =
Revised: =

Original: s CG i for all i .
Revised: s CG i for all i .

Original: We prove the remaining claims by induction.
Revised: We prove the remaining claims by induction.

Original: For the base case we have by assumption d 0 = Σ 

Revised: For the base case we have by assumption d 0 = Σ

Original: ˆ Ks 

Revised: ˆ Ks

Original: = s 
 = s
Revised: = s 
 = s

Original: CG0 and v 0 = 

Revised: CG0 and v 0 =

Original: = v CG0 .
Revised: = v CG0 .

Original: Now for the induction step i → i + 1 assume the hypotheses (S20), (S21) and (S22) hold ∀ j ≤ i .
Revised: Now for the induction step i → i + 1 assume the hypotheses (S20), (S21) and (S22) hold ∀ j ≤ i .

Original: Using the properties of CG it holds for j ′ <
Revised: Using the properties of CG it holds for j ′ <

Original: i that
Revised: i that

Original: [Equation]
Revised: [Equation]

Original: We now first show ˆ K -conjugacy of the actions in iteration i + 1 .
Revised: We now first show ˆ K -conjugacy of the actions in iteration i + 1 .

Original: We have for j ≤ i that
Revised: We have for j ≤ i that

Original: [Equation]
Revised: [Equation]

Original: Now if j = i
Revised: Now if j = i

Original: [Equation]
Revised: [Equation]

Original: clearly s ⊺ i +

Revised: clearly s ⊺ i +

Original: ˆ
Revised: ˆ

Original: Ks j = s ⊺
Revised: Ks j = s ⊺

Original: i
Revised: i

Original: +

Revised: +

Original: ˆ
Revised: ˆ

Original: Ks i = 0 .
Revised: Ks i = 0 .

Original: If j < i
Revised: If j < i

Original: [Equation]
Revised: [Equation]

Original: we have using (S26)
Revised: we have using (S26)

Original: [Equation]
Revised: [Equation]

Original: that
Revised: that

Original: [Equation]
Revised: [Equation]

Original: Therefore we obtain for j <
Revised: Therefore we obtain for j <

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: that
Revised: that

Original: [Equation]
Revised: [Equation]

Original: Thus in combination we have
Revised: Thus in combination we have

Original: [Equation]
Revised: [Equation]

Original: Now for the search direction we have
Revised: Now for the search direction we have

Original: [Equation]
Revised: [Equation]

Original: Further
Revised: Further

Original: [Equation]
Revised: [Equation]

Original: we have for the solution estimate,
Revised: we have for the solution estimate,

Original: that v i +

Revised: that v i +

Original: = v i + d i +1 α
Revised: = v i + d i +1 α

Original: i +

Revised: i +

Original: η i +1 .
Revised: η i +1 .

Original: It holds that
Revised: It holds that

Original: [Equation]
Revised: [Equation]

Original: as well as
Revised: as well as

Original: [Equation]
Revised: [Equation]

Original: Combining the above and recalling Algorithm S3, we obtain
Revised: Combining the above and recalling Algorithm S3, we obtain

Original: [Equation]
Revised: [Equation]

Original: Finally, the residual is computed identically in Algorithm 1 as in Algorithm S3, giving
Revised: Finally, the residual is computed identically in Algorithm 1 as in Algorithm S3, giving

Original: [Equation]
Revised: [Equation]

Original: This proves the claims
Revised: This proves the claims

Original: [Equation]
Revised: [Equation]

Original: Corollary S2 (Preconditioned Gradient Actions as CG Actions)
Revised: Corollary S2 (Preconditioned Gradient Actions as CG Actions)

Original: Choosing actions
Revised: Choosing actions

Original: [Equation]
Revised: [Equation]

Original: in Theorem S5 instead also reproduces the preconditioned conjugate gradient method,
Revised: in Theorem S5 instead also reproduces the preconditioned conjugate gradient method,

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: e. it holds for i ∈ { 1 , . .
Revised: e. it holds for i ∈ { 1 , . .

Original: . , n }
Revised: . , n }

Original: that
Revised: that

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: It suffices to show that d i =
Revised: It suffices to show that d i =

Original: s CG i .
Revised: s CG i .

Original: The rest of the argument is then identical to the proof of
Revised: The rest of the argument is then identical to the proof of

Original: Theorem S5.
Revised: Theorem S5.

Original: We prove the claim by induction.
Revised: We prove the claim by induction.

Original: For the base case by assumption s 1 = ˆ P − 1 r 0 =
Revised: For the base case by assumption s 1 = ˆ P − 1 r 0 =

Original: s CG1 .
Revised: s CG1 .

Original: Now for the induction step i → i + 1 , assume that d j = s j for all j ≤ i , then
Revised: Now for the induction step i → i + 1 , assume that d j = s j for all j ≤ i , then

Original: [Equation]
Revised: [Equation]

Original: Now by the same argument as in eq.
Revised: Now by the same argument as in eq.

Original: (S28) in the proof of Theorem S5 we have for all j < i
Revised: (S28) in the proof of Theorem S5 we have for all j < i

Original: that r ⊺
Revised: that r ⊺

Original: i
Revised: i

Original: ˆ P − 1 ˆ
Revised: ˆ P − 1 ˆ

Original: Ks CG j
Revised: Ks CG j

Original: [Equation]
Revised: [Equation]

Original: Therefore
Revised: Therefore

Original: [Equation]
Revised: [Equation]

Original: This proves the claim.
Revised: This proves the claim.

Original: Corollary S3 (Deflated Conjugate Gradient Method)
Revised: Corollary S3 (Deflated Conjugate Gradient Method)

Original: Let the first 0 < ℓ < n actions ( s i ) ℓ i =1 of Algorithm 1 be linearly independent and the remaining ones be given by s i
Revised: Let the first 0 < ℓ < n actions ( s i ) ℓ i =1 of Algorithm 1 be linearly independent and the remaining ones be given by s i

Original: = ˆ P − 1 r
Revised: = ˆ P − 1 r

Original: i , where ˆ P
Revised: i , where ˆ P

Original: ≈ ˆ K is a preconditioner.
Revised: ≈ ˆ K is a preconditioner.

Original: Then Algorithm 1 is equivalent to the preconditioned deflated CG algorithm [62, Alg.
Revised: Then Algorithm 1 is equivalent to the preconditioned deflated CG algorithm [63, Alg.

Original: 3.6] with deflation subspace span { S ℓ } .
Revised: 3.6] with deflation subspace span { S ℓ } .

Original: Proof.
Revised: Proof.

Original: By the form of preconditioned deflated CG given in Algorithm 3.6 of Saad et al.
Revised: By the form of preconditioned deflated CG given in Algorithm 3.6 of Saad et al.

Original: [62] and
Revised: [63] and

Original: Corollary S2, it suffices to show that the residual r ℓ satisfies S ⊺ ℓ r ℓ = 0 and that for all i > ℓ , it holds that
Revised: Corollary S2, it suffices to show that the residual r ℓ satisfies S ⊺ ℓ r ℓ = 0 and that for all i > ℓ , it holds that

Original: [Equation]
Revised: [Equation]

Original: Now it holds by Lemma S2 and eq.
Revised: Now it holds by Lemma S2 and eq.

Original: (S37)
Revised: (S37)

Original: [Equation]
Revised: [Equation]

Original: that
Revised: that

Original: [Equation]
Revised: [Equation]

Original: This proves the first claim.
Revised: This proves the first claim.

Original: Now, by Saad et al.
Revised: Now, by Saad et al.

Original: [62, Alg. 3.6], the search directions ( s defCG i ) ni = ℓ +1 of preconditioned deflated CG are given by
Revised: [63, Alg. 3.6], the search directions ( s defCG i ) ni = ℓ +1 of preconditioned deflated CG are given by

Original: [Equation]
Revised: [Equation]

Original: Corollary
Revised: Corollary

Original: [Equation]
Revised: [Equation]

Original: This proves the claim.
Revised: This proves the claim.

Original: Remark S1 (Preconditioning and Algorithm 1)
Revised: Remark S1 (Preconditioning and Algorithm 1)

Original: Iterative methods typically have convergence rates depending on the condition number of the system matrix.
Revised: Iterative methods typically have convergence rates depending on the condition number of the system matrix.

Original: One successful strategy in practice to accelerate convergence is to use a preconditioner
Revised: One successful strategy in practice to accelerate convergence is to use a preconditioner

Original: ˆ P
Revised: ˆ P

Original: ≈ ˆ K [63].
Revised: ≈ ˆ K [64].

Original: A preconditioner needs to be cheap to compute and allow efficient matrix-vector multiplication v (cid:55)→ ˆ P − 1 v .
Revised: A preconditioner needs to be cheap to compute and allow efficient matrix-vector multiplication v (cid:55)→ ˆ P − 1 v .

Original: Now, Algorithm 1 implicitly constructs and applies a deflation-based preconditioner , which are defined via a deflation subspace to be projected out [64].
Revised: Now, Algorithm 1 implicitly constructs and applies a deflation-based preconditioner , which are defined via a deflation subspace to be projected out [65].

Original: In Algorithm 1 this is precisely the already explored space span { S i } = span { D i } spanned by the actions.
Revised: In Algorithm 1 this is precisely the already explored space span { S i } = span { D i } spanned by the actions.

Original: Therefore, if we run a mixed strategy, meaning first choosing actions that define a certain subspace and then choose residual actions, we recover the deflated conjugate gradient method [62] (see Corollary S3 for a proof).
Revised: Therefore, if we run a mixed strategy, meaning first choosing actions that define a certain subspace and then choose residual actions, we recover the deflated conjugate gradient method [63] (see Corollary S3 for a proof).

Original: Alternatively, one can also use byproducts of the iteration of Algorithm 1 to construct a diagonal-pluslow-rank preconditioner of the form ˆ P = σ 2 I + UU ⊺
Revised: Alternatively, one can also use byproducts of the iteration of Algorithm 1 to construct a diagonal-pluslow-rank preconditioner of the form ˆ P = σ 2 I + UU ⊺

Original: ≈ ˆ K where U =
Revised: ≈ ˆ K where U =

Original: KD i diag( η 1 , . . .
Revised: KD i diag( η 1 , . . .

Original: , η i ) ∈ R n × i .
Revised: , η i ) ∈ R n × i .

Original: Therefore, again if running a mixed strategy, one can first construct a preconditioner and then accelerate the convergence of subsequent CG iterations.
Revised: Therefore, again if running a mixed strategy, one can first construct a preconditioner and then accelerate the convergence of subsequent CG iterations.

Original: In this sense one can double-dip in terms of preconditioning (conjugate) gradient iterations by combining these two techniques at essentially no overhead .
Revised: In this sense one can double-dip in terms of preconditioning (conjugate) gradient iterations by combining these two techniques at essentially no overhead .

Original: v ∗ + span { D i } ⊥ ˆ K =span { S i }
Revised: v ∗ + span { D i } ⊥ ˆ K =span { S i }

Original: ⊥
Revised: ⊥

Original: ˆ K v i − 1 + span { d i } v i v ∗ v
Revised: ˆ K v i − 1 + span { d i } v i v ∗ v

Original: i −
Revised: i −

Original: S1.4 Inducing Point Methods
Revised: S1.4 Inducing Point Methods

Original: Theorem S6 (Approximate Posterior Mean of Nyström, SoR, DTC and SVGP)
Revised: Theorem S6 (Approximate Posterior Mean of Nyström, SoR, DTC and SVGP)

Original: Let Z ∈ R n × m be a set of distinct inducing inputs such that rank( K XZ )
Revised: Let Z ∈ R n × m be a set of distinct inducing inputs such that rank( K XZ )

Original: = m ≤ n .
Revised: = m ≤ n .

Original: Then the posterior mean of the Nyström variants subset of regressors (SoR) and deterministic training conditional (DTC) is identical to the one of SVGP and given by
Revised: Then the posterior mean of the Nyström variants subset of regressors (SoR) and deterministic training conditional (DTC) is identical to the one of SVGP and given by

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: First
Revised: First

Original: [Equation]
Revised: [Equation]

Original: note that by eqns.
Revised: note that by eqns.

Original: (16b) and (20b) of Quiñonero-Candela and Rasmussen [20] the posterior mean of SoR and DTC is identical and given by
Revised: (16b) and (20b) of Quiñonero-Candela and Rasmussen [20] the posterior mean of SoR and DTC is identical and given by

Original: [Equation]
Revised: [Equation]

Original: Now
Revised: Now

Original: [Equation]
Revised: [Equation]

Original: by Theorem 5 of Wild et al
Revised: by Theorem 5 of Wild et al

Original: [Equation]
Revised: [Equation]

Original: [39] the posterior mean of SVGP for a fixed set of inducing points is equivalent to the Nyström approximation
Revised: [43] the posterior mean of SVGP for a fixed set of inducing points is equivalent to the Nyström approximation

Original: [Equation]
Revised: [Equation]

Original: which takes the form above
Revised: which takes the form above

Original: [Equation]
Revised: [Equation]

Original: Recognizing that
Revised: Recognizing that

Original: K ZX K XZ ∈ R m × m is invertible
Revised: K ZX K XZ ∈ R m × m is invertible

Original: [Equation]
Revised: [Equation]

Original: it holds that
Revised: it holds that

Original: [Equation]
Revised: [Equation]

Original: This proves the claim.
Revised: This proves the claim.

Original: S Theoretical Results and Proofs S2.1 Properties of Algorithm
Revised: S Theoretical Results and Proofs S2.1 Properties of Algorithm

Original: Lemma S1 (Geometric Properties of Algorithm 1)
Revised: Lemma S1 (Geometric Properties of Algorithm 1)

Original: Let i ∈ { 1 , . . . , n } , and assume Σ 0 is chosen such that Σ 

Revised: Let i ∈ { 1 , . . . , n } , and assume Σ 0 is chosen such that Σ

Original: ˆ Ks j
Revised: ˆ Ks j

Original: = s j for all j ≤
Revised: = s j for all j ≤

Original: i (e.g. Σ 

Revised: i (e.g. Σ

Original: = ˆ K − 1 ).
Revised: = ˆ K − 1 ).

Original: Then it holds for the quantities computed by Algorithm 1 that
Revised: Then it holds for the quantities computed by Algorithm 1 that

Original: [Equation]
Revised: [Equation]

Original: C
Revised: C

Original: [Equation]
Revised: [Equation]

Original: ˆ
Revised: ˆ

Original: [Equation]
Revised: [Equation]

Original: the ˆ
Revised: the ˆ

Original: [Equation]
Revised: [Equation]

Original: orthogonal projection onto span { D i }
Revised: orthogonal projection onto span { D i }

Original: [Equation]
Revised: [Equation]

Original: S
Revised: S

Original: [Equation]
Revised: [Equation]

Original: Σ i ˆ K is the ˆ K -orthogonal projection onto span { D i } ⊥
Revised: Σ i ˆ K is the ˆ K -orthogonal projection onto span { D i } ⊥

Original: ˆ K
Revised: ˆ K

Original: [Equation]
Revised: [Equation]

Original: S
Revised: S

Original: [Equation]
Revised: [Equation]

Original: d ⊺ i ˆ Kd j =for all j < i
Revised: d ⊺ i ˆ Kd j =for all j < i

Original: [Equation]
Revised: [Equation]

Original: S40) where S i =
Revised: S40) where S i =

Original: ( s 1 · · · s i ) ∈ R n ×
Revised: ( s 1 · · · s i ) ∈ R n ×

Original: i and D i =
Revised: i and D i =

Original: ( d 1 · · · d i ) ∈ R n × i .
Revised: ( d 1 · · · d i ) ∈ R n × i .

Original: Proof.
Revised: Proof.

Original: We prove the claims by induction.
Revised: We prove the claims by induction.

Original: We begin with the base case i = 1 .
Revised: We begin with the base case i = 1 .

Original: By assumption it holds that S 1 = s 1 = Σ 

Revised: By assumption it holds that S 1 = s 1 = Σ

Original: ˆ Ks 1 =
Revised: ˆ Ks 1 =

Original: d 1 = D 1 .
Revised: d 1 = D 1 .

Original: Now by Algorithm 1, we have
Revised: Now by Algorithm 1, we have

Original: C 1 = 1 η 1 d 1 d ⊺ 1 , which with the above proves (S37).
Revised: C 1 = 1 η 1 d 1 d ⊺ 1 , which with the above proves (S37).

Original: By the batched form (S37) of C i , the statements (S38) and (S39) follow immediately.
Revised: By the batched form (S37) of C i , the statements (S38) and (S39) follow immediately.

Original: Finally, ˆ K -orthogonality for a single search direction holds trivially.
Revised: Finally, ˆ K -orthogonality for a single search direction holds trivially.

Original: Now for the induction step i → i + 1 .
Revised: Now for the induction step i → i + 1 .

Original: Assume that eqs.
Revised: Assume that eqs.

Original: (S36) to (S40) hold for iteration i .
Revised: (S36) to (S40) hold for iteration i .

Original: Then we have that
Revised: Then we have that

Original: [Equation]
Revised: [Equation]

Original: By the induction hypothesis the above also implies span { S i +1 }
Revised: By the induction hypothesis the above also implies span { S i +1 }

Original: = span { D i +1 } .
Revised: = span { D i +1 } .

Original: This proves eq.
Revised: This proves eq.

Original: (S36).
Revised: (S36).

Original: Next, we have by the induction hypotheses (S37) and (S40)
Revised: Next, we have by the induction hypotheses (S37) and (S40)

Original: that
Revised: that

Original: [Equation]
Revised: [Equation]

Original: This proves the first equality of eq.
Revised: This proves the first equality of eq.

Original: (S37).
Revised: (S37).

Original: For the second, first recognize that an orthogonal projection onto a linear subspace span { A } with respect to the B -inner product is given by P A =
Revised: For the second, first recognize that an orthogonal projection onto a linear subspace span { A } with respect to the B -inner product is given by P A =

Original: A ( A ⊺ BA ) − 1 A ⊺ B .
Revised: A ( A ⊺ BA ) − 1 A ⊺ B .

Original: The projection onto its B -orthogonal subspace is given by P A ⊥ B
Revised: The projection onto its B -orthogonal subspace is given by P A ⊥ B

Original: =
Revised: =

Original: I − P A .
Revised: I − P A .

Original: Therefore eqs.
Revised: Therefore eqs.

Original: (S38) and (S39) follow directly from the above argument.
Revised: (S38) and (S39) follow directly from the above argument.

Original: Now since projection onto a subspace is unique and independent of the choice of basis, we have by span { D i +1 } =
Revised: Now since projection onto a subspace is unique and independent of the choice of basis, we have by span { D i +1 } =

Original: span { S i +1 } that
Revised: span { S i +1 } that

Original: [Equation]
Revised: [Equation]

Original: Now since ˆ K is non-singular, the second equality of eq.
Revised: Now since ˆ K is non-singular, the second equality of eq.

Original: (S37) follows.
Revised: (S37) follows.

Original: Finally, we will prove ˆ K -orthogonality of the search directions.
Revised: Finally, we will prove ˆ K -orthogonality of the search directions.

Original: Let j < i + 1 , then it holds that
Revised: Let j < i + 1 , then it holds that

Original: [Equation]
Revised: [Equation]

Original: by eqs.
Revised: by eqs.

Original: (S36) and (S39).
Revised: (S36) and (S39).

Original: This completes the proof.
Revised: This completes the proof.

Original: Corollary S
Revised: Corollary S

Original: Let i ∈ { 1 , . . . , n } .
Revised: Let i ∈ { 1 , . . . , n } .

Original: It holds for C
Revised: It holds for C

Original: i ˆ K , the ˆ K -orthogonal projection onto S i , that
Revised: i ˆ K , the ˆ K -orthogonal projection onto S i , that

Original: [Equation]
Revised: [Equation]

Original: Further for H i = Σ
Revised: Further for H i = Σ

Original: i ˆ K
Revised: i ˆ K

Original: = I − C
Revised: = I − C

Original: i ˆ K
Revised: i ˆ K

Original: the ˆ K -orthogonal projection onto S ⊥
Revised: the ˆ K -orthogonal projection onto S ⊥

Original: ˆ K i , we have
Revised: ˆ K i , we have

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: Proof.
Revised: Proof.

Original: By Lemma S1, it holds that C i
Revised: By Lemma S1, it holds that C i

Original: = S i ( S ⊺ i ˆ KS i ) − 1 S ⊺ i .
Revised: = S i ( S ⊺ i ˆ KS i ) − 1 S ⊺ i .

Original: Therefore
Revised: Therefore

Original: [Equation]
Revised: [Equation]

Original: This proves (S42) and (S41).
Revised: This proves (S42) and (S41).

Original: Define H i
Revised: Define H i

Original: = I − C
Revised: = I − C

Original: i ˆ K , then
Revised: i ˆ K , then

Original: [Equation]
Revised: [Equation]

Original: as well as
Revised: as well as

Original: [Equation]
Revised: [Equation]

Original: ˆ K − ˆ KC
Revised: ˆ K − ˆ KC

Original: i ˆ K
Revised: i ˆ K

Original: =
Revised: =

Original: H
Revised: H

Original: ⊺
Revised: ⊺

Original: i ˆ K =
Revised: i ˆ K =

Original: ˆ KH
Revised: ˆ KH

Original: i .
Revised: i .

Original: Lemma S
Revised: Lemma S

Original: Let Σ 

Revised: Let Σ

Original: = ˆ K − 1 , then it holds that
Revised: = ˆ K − 1 , then it holds that

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: We prove the statement by induction.
Revised: We prove the statement by induction.

Original: By assumption C 

Revised: By assumption C

Original: ( y − µ )
Revised: ( y − µ )

Original: = v 0 .
Revised: = v 0 .

Original: Now assume (S45) holds.
Revised: Now assume (S45) holds.

Original: Then for i → i + 1 , we have
Revised: Then for i → i + 1 , we have

Original: [Equation]
Revised: [Equation]

Original: Now by the update to the representer weights in Algorithm 1 it suffices to show that α i +1 =
Revised: Now by the update to the representer weights in Algorithm 1 it suffices to show that α i +1 =

Original: d ⊺ i +1 ( y − µ ) .
Revised: d ⊺ i +1 ( y − µ ) .

Original: We have
Revised: We have

Original: [Equation]
Revised: [Equation]

Original: Lemma S
Revised: Lemma S

Original: Let Σ 

Revised: Let Σ

Original: = ˆ K − 1 , C 0 = 

Revised: = ˆ K − 1 , C 0 =

Original: and consequently v 0 = 0 , then it holds for the residual at iteration i ∈ {
Revised: and consequently v 0 = 0 , then it holds for the residual at iteration i ∈ {

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: n } that
Revised: n } that

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: It holds by definition
Revised: It holds by definition

Original: [Equation]
Revised: [Equation]

Original: that
Revised: that

Original: [Equation]
Revised: [Equation]

Original: Further we have by eq.
Revised: Further we have by eq.

Original: (S46), that
Revised: (S46), that

Original: [Equation]
Revised: [Equation]

Original: and finally, by the definition of the kernel matrix approximation in Algorithm 1, we obtain =
Revised: and finally, by the definition of the kernel matrix approximation in Algorithm 1, we obtain =

Original: [Equation]
Revised: [Equation]

Original: Proposition S3 (Batch of Observations)
Revised: Proposition S3 (Batch of Observations)

Original: Let Σ 0 such that Σ 0 ˆ Ks j = s j for all j ∈ { 1 , . .
Revised: Let Σ 0 such that Σ 0 ˆ Ks j = s j for all j ∈ { 1 , . .

Original: , i } .
Revised: , i } .

Original: Then after i iterations the posterior over the representer weights in (4) is equivalent to the one computed for a batch of observations, i.e.
Revised: Then after i iterations the posterior over the representer weights in (4) is equivalent to the one computed for a batch of observations, i.e.

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: This can be seen as a direct consequence of recursively applying Bayes’ theorem
Revised: This can be seen as a direct consequence of recursively applying Bayes’ theorem

Original: [Equation]
Revised: [Equation]

Original: However, here we also give a geometric proof based on the projection property of the precision matrix approximation C i .
Revised: However, here we also give a geometric proof based on the projection property of the precision matrix approximation C i .

Original: By using eq.
Revised: By using eq.

Original: (S37) and the assumption on Σ 

Revised: (S37) and the assumption on Σ

Original: we have that
Revised: we have that

Original: [Equation]
Revised: [Equation]

Original: This proves that
Revised: This proves that

Original: [Equation]
Revised: [Equation]

Original: Now by eq.
Revised: Now by eq.

Original: (S45) it holds that C i ( y − µ )
Revised: (S45) it holds that C i ( y − µ )

Original: = v i .
Revised: = v i .

Original: This proves the claim.
Revised: This proves the claim.

Original: Proposition S4 (Posterior Contraction)
Revised: Proposition S4 (Posterior Contraction)

Original: Let S i ∈ R n × i be the actions chosen by Algorithm 1, then its posterior contracts as
Revised: Let S i ∈ R n × i be the actions chosen by Algorithm 1, then its posterior contracts as

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Since Σ 0 = ˆ K − 1 , we have by eq.
Revised: Since Σ 0 = ˆ K − 1 , we have by eq.

Original: (S37), that
Revised: (S37), that

Original: [Equation]
Revised: [Equation]

Original: Now, if the actions S i are chosen linearly independent, then rank( S i )
Revised: Now, if the actions S i are chosen linearly independent, then rank( S i )

Original: =
Revised: =

Original: i .
Revised: i .

Original: Theorem S7 (Online GP Approximation with Algorithm 1)
Revised: Theorem S7 (Online GP Approximation with Algorithm 1)

Original: Let n ≤ n ′ ∈ N and consider training data sets X ∈ R n × d , y ∈ R n and X ′ ∈ R n ′
Revised: Let n ≤ n ′ ∈ N and consider training data sets X ∈ R n × d , y ∈ R n and X ′ ∈ R n ′

Original: × d , y ′ ∈
Revised: × d , y ′ ∈

Original: R n ′ .
Revised: R n ′ .

Original: Consider two sequences of actions ( s i ) n i =1 ∈ R n and (˜ s i ) n + n ′ i =
Revised: Consider two sequences of actions ( s i ) n i =1 ∈ R n and (˜ s i ) n + n ′ i =

Original: ∈
Revised: ∈

Original: R n + n ′ such that for all i ∈ { 1 , . .
Revised: R n + n ′ such that for all i ∈ { 1 , . .

Original: . , n } , it holds that
Revised: . , n } , it holds that

Original: [Equation]
Revised: [Equation]

Original: Then the posterior returned by Algorithm 1 for the dataset ( X , y ) using actions
Revised: Then the posterior returned by Algorithm 1 for the dataset ( X , y ) using actions

Original: s i is identical to the posterior returned by Algorithm 1 for the extended dataset using actions
Revised: s i is identical to the posterior returned by Algorithm 1 for the extended dataset using actions

Original: ˜ s i , i.e. it holds for any i ∈ { 1 , . . . , n } , that
Revised: ˜ s i , i.e. it holds for any i ∈ { 1 , . . . , n } , that

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Define ˜ X
Revised: Define ˜ X

Original: = (cid:18) XX ′ (cid:19) and ˜ y
Revised: = (cid:18) XX ′ (cid:19) and ˜ y

Original: =
Revised: =

Original: (cid:18)
Revised: (cid:18)

Original: yy ′ (cid:19) .
Revised: yy ′ (cid:19) .

Original: We begin by showing that the search directions of both methods satisfy
Revised: We begin by showing that the search directions of both methods satisfy

Original: [Equation]
Revised: [Equation]

Original: We proceed by induction.
Revised: We proceed by induction.

Original: For i = 

Revised: For i =

Original: it holds by definition of Algorithm 1 and eq.
Revised: it holds by definition of Algorithm 1 and eq.

Original: (S50) that
Revised: (S50) that

Original: [Equation]
Revised: [Equation]

Original: Now for the induction step i → i + 1 , assume that (S51) holds for j ∈ { 1 , . .
Revised: Now for the induction step i → i + 1 , assume that (S51) holds for j ∈ { 1 , . .

Original: , i } .
Revised: , i } .

Original: Then, we have
Revised: Then, we have

Original: [Equation]
Revised: [Equation]

Original: (cid:19) where we used that ˜
Revised: (cid:19) where we used that ˜

Original: η j = ˜ s ⊺ j ( k ( ˜ X , ˜ X ) + σ 2 I n + n ′ )
Revised: η j = ˜ s ⊺ j ( k ( ˜ X , ˜ X ) + σ 2 I n + n ′ )

Original: ˜
Revised: ˜

Original: d j = s ⊺ j ˆ Kd j = η j .
Revised: d j = s ⊺ j ˆ Kd j = η j .

Original: This proves eq.
Revised: This proves eq.

Original: (S51).
Revised: (S51).

Original: Now recognize that
Revised: Now recognize that

Original: [Equation]
Revised: [Equation]

Original: Therefore
Revised: Therefore

Original: [Equation]
Revised: [Equation]

Original: we finally have that
Revised: we finally have that

Original: [Equation]
Revised: [Equation]

Original: as well as
Revised: as well as

Original: [Equation]
Revised: [Equation]

Original: Remark S2 (Streaming Gaussian Processes)
Revised: Remark S2 (Streaming Gaussian Processes)

Original: Theorem S7 shows that any variant of IterGP can be used in the online setting where data arrives sequentially while the algorithm is running.
Revised: Theorem S7 shows that any variant of IterGP can be used in the online setting where data arrives sequentially while the algorithm is running.

Original: Now, if we assume data points arrive one at a time, we choose unit vector actions (IterGP-Chol) and perform one iteration of Algorithm 1 after each data point, then Algorithm 1 simply computes the mathematical GP posterior.
Revised: Now, if we assume data points arrive one at a time, we choose unit vector actions (IterGP-Chol) and perform one iteration of Algorithm 1 after each data point, then Algorithm 1 simply computes the mathematical GP posterior.

Original: S2.2 Approximation of Representer Weights
Revised: S2.2 Approximation of Representer Weights

Original: Proposition 2 (Relative Error Bound for the Representer Weights)
Revised: Proposition 2 (Relative Error Bound for the Representer Weights)

Original: For any choice of actions a relative error bound ρ ( i ) , s.t.
Revised: For any choice of actions a relative error bound ρ ( i ) , s.t.

Original: ∥ v ∗ − v i ∥
Revised: ∥ v ∗ − v i ∥

Original: ˆ K ≤ ρ ( i ) ∥ v ∗ ∥
Revised: ˆ K ≤ ρ ( i ) ∥ v ∗ ∥

Original: ˆ K is given by
Revised: ˆ K is given by

Original: [Equation]
Revised: [Equation]

Original: where ¯ v ∗ = v ∗ / ∥ v ∗ ∥ ˆ K .
Revised: where ¯ v ∗ = v ∗ / ∥ v ∗ ∥ ˆ K .

Original: If the actions { s i } ni =1 are linearly independent, then ρ ( i ) ≤ δ n = i .
Revised: If the actions { s i } ni =1 are linearly independent, then ρ ( i ) ≤ δ n = i .

Original: Proof.
Revised: Proof.

Original: Define H i = Σ
Revised: Define H i = Σ

Original: i ˆ K
Revised: i ˆ K

Original: = I − C
Revised: = I − C

Original: i ˆ K .
Revised: i ˆ K .

Original: We have by Lemma S2, that
Revised: We have by Lemma S2, that

Original: [Equation]
Revised: [Equation]

Original: This proves the first equality of Proposition 2.
Revised: This proves the first equality of Proposition 2.

Original: Further it holds that
Revised: Further it holds that

Original: [Equation]
Revised: [Equation]

Original: Now by Weyl’s inequality and the fact that ˆ K 12 C i ˆ K 12 is positive semi-definite, it holds that
Revised: Now by Weyl’s inequality and the fact that ˆ K 12 C i ˆ K 12 is positive semi-definite, it holds that

Original: [Equation]
Revised: [Equation]

Original: Now, recall that similar matrices A and B = P − 1 AP have the same eigenvalues.
Revised: Now, recall that similar matrices A and B = P − 1 AP have the same eigenvalues.

Original: Therefore
Revised: Therefore

Original: [Equation]
Revised: [Equation]

Original: and I − C
Revised: and I − C

Original: i ˆ K have the same eigenvalues.
Revised: i ˆ K have the same eigenvalues.

Original: Finally, since by eq.
Revised: Finally, since by eq.

Original: (S39) H i is a projection onto span { S i } ⊥ ˆ K , it has full rank at iteration n if the actions are linearly independent and therefore λ max ( H n ) = 1 .
Revised: (S39) H i is a projection onto span { S i } ⊥ ˆ K , it has full rank at iteration n if the actions are linearly independent and therefore λ max ( H n ) = 1 .

Original: This proves the claim.
Revised: This proves the claim.

Original: S2.3 Convergence Analysis of the Posterior Mean Approximation
Revised: S2.3 Convergence Analysis of the Posterior Mean Approximation

Original: Theorem 1 (Convergence in RKHS Norm of the Posterior Mean Approximation)
Revised: Theorem 1 (Convergence in RKHS Norm of the Posterior Mean Approximation)

Original: Let H k be the RKHS associated with kernel k ( · , · ) , σ 2 > 0 and let µ ∗ − µ ∈ H k be the unique solution to the regularized empirical risk minimization problem
Revised: Let H k be the RKHS associated with kernel k ( · , · ) , σ 2 > 0 and let µ ∗ − µ ∈ H k be the unique solution to the regularized empirical risk minimization problem

Original: [Equation]
Revised: [Equation]

Original: which is equivalent to the mathematical posterior mean up to shift by the prior µ [e.g. 1, Sec. 6.2].
Revised: which is equivalent to the mathematical posterior mean up to shift by the prior µ [e.g. 1, Sec. 6.2].

Original: Then for i ∈ { 0 , . .
Revised: Then for i ∈ { 0 , . .

Original: . , n } the posterior mean µ i ( · ) computed by Algorithm 1 satisfies
Revised: . , n } the posterior mean µ i ( · ) computed by Algorithm 1 satisfies

Original: [Equation]
Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: where µ 0 = µ is the prior mean and the constant c ( σ 2 ) =
Revised: where µ 0 = µ is the prior mean and the constant c ( σ 2 ) =

Original: (cid:113) 1 +
Revised: (cid:113) 1 +

Original: [Equation]
Revised: [Equation]

Original: as σ
Revised: as σ

Original: [Equation]
Revised: [Equation]

Original: → 0 .
Revised: → 0 .

Original: Proof.
Revised: Proof.

Original: Let ρ ( i ) such that ∥ v ∗ − v i ∥ ˆ K ≤ ρ ( i ) ∥ v ∗ − v 

Revised: Let ρ ( i ) such that ∥ v ∗ − v i ∥ ˆ K ≤ ρ ( i ) ∥ v ∗ − v

Original: ∥
Revised: ∥

Original: ˆ K , where v 0 = 0 .
Revised: ˆ K , where v 0 = 0 .

Original: Then, we have for i ∈ { 0 , . . . , n } , that
Revised: Then, we have for i ∈ { 0 , . . . , n } , that

Original: [Equation]
Revised: [Equation]

Original: λ min ( K ) λ min ( K ) ∥ v ∗ − v 

Revised: λ min ( K ) λ min ( K ) ∥ v ∗ − v

Original: ∥≤∥ v ∗ − v 

Revised: ∥≤∥ v ∗ − v

Original: ∥ 2 K (cid:1) ≤ ρ ( i )
Revised: ∥ 2 K (cid:1) ≤ ρ ( i )

Original: [Equation]
Revised: [Equation]

Original: (cid:18) 1 + σ
Revised: (cid:18) 1 + σ

Original: [Equation]
Revised: [Equation]

Original: λ min ( K ) (cid:19) ∥ v ∗ − v 

Revised: λ min ( K ) (cid:19) ∥ v ∗ − v

Original: ∥
Revised: ∥

Original: 2 K
Revised: 2 K

Original: Now by assumption µ i ( · ) = µ ( · ) + (cid:80) nj =1 ( v i )
Revised: Now by assumption µ i ( · ) = µ ( · ) + (cid:80) nj =1 ( v i )

Original: j k ( · , x j ) = µ ( · ) + k ( · , X ) C
Revised: j k ( · , x j ) = µ ( · ) + k ( · , X ) C

Original: i y .
Revised: i y .

Original: By the reproducing property we obtain for ∆ = v ∗ − v i that ∥ v ∗ − v i ∥
Revised: By the reproducing property we obtain for ∆ = v ∗ − v i that ∥ v ∗ − v i ∥

Original: [Equation]
Revised: [Equation]

Original: K
Revised: K

Original: [Equation]
Revised: [Equation]

Original: ⊺
Revised: ⊺

Original: [Equation]
Revised: [Equation]

Original: =
Revised: =

Original: [Equation]
Revised: [Equation]

Original: =
Revised: =

Original: [Equation]
Revised: [Equation]

Original: k is the reproducing kernel of H k = ⟨ n (cid:88) ℓ =
Revised: k is the reproducing kernel of H k = ⟨ n (cid:88) ℓ =

Original: [Equation]
Revised: [Equation]

Original: ∆
Revised: ∆

Original: [Equation]
Revised: [Equation]

Original: n (cid:88) j =
Revised: n (cid:88) j =

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: k = (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) n (cid:88) ℓ = ∆ ℓ k ( · , x ℓ ) (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
Revised: k = (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) n (cid:88) ℓ = ∆ ℓ k ( · , x ℓ ) (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)

Original: H k = (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) n (cid:88) ℓ
Revised: H k = (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) n (cid:88) ℓ

Original: = ( v ∗ ) ℓ k ( · , x ℓ ) − n (cid:88) ℓ
Revised: = ( v ∗ ) ℓ k ( · , x ℓ ) − n (cid:88) ℓ

Original: = ( v i ) ℓ k ( · , x ℓ ) (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
Revised: = ( v i ) ℓ k ( · , x ℓ ) (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)

Original: H k = ∥ µ ∗ − µ i ∥ 2 H k
Revised: H k = ∥ µ ∗ − µ i ∥ 2 H k

Original: See Theorem 3.4 in Kanagawa et al.
Revised: See Theorem 3.4 in Kanagawa et al.

Original: Combining the above and setting c ( σ 2 ) = 1 + σ 2 λ min ( K ) we obtain
Revised: Combining the above and setting c ( σ 2 ) = 1 + σ 2 λ min ( K ) we obtain

Original: [Equation]
Revised: [Equation]

Original: S2.4 Combined Uncertainty as Worst Case Error
Revised: S2.4 Combined Uncertainty as Worst Case Error

Original: Theorem 2 (Combined and Computational Uncertainty as Worst Case Errors)
Revised: Theorem 2 (Combined and Computational Uncertainty as Worst Case Errors)

Original: Let σ 2 ≥ 0 and let k i ( · , · ) =
Revised: Let σ 2 ≥ 0 and let k i ( · , · ) =

Original: k ∗ ( · , · ) + k comp i ( · , · ) be the combined uncertainty computed by Algorithm 1.
Revised: k ∗ ( · , · ) + k comp i ( · , · ) be the combined uncertainty computed by Algorithm 1.

Original: Then, for any x ∈ X (assuming x / ∈ X if σ 2 > 0 ) we have
Revised: Then, for any x ∈ X (assuming x / ∈ X if σ 2 > 0 ) we have

Original: [Equation]
Revised: [Equation]

Original: where µ g ∗ ( · ) =
Revised: where µ g ∗ ( · ) =

Original: k ( · , X ) ˆ K − 1 g ( X ) is the mathematical and µ gi ( · ) =
Revised: k ( · , X ) ˆ K − 1 g ( X ) is the mathematical and µ gi ( · ) =

Original: k ( · , X ) C
Revised: k ( · , X ) C

Original: i g ( X ) IterGP’s posterior mean for the latent function g ∈ H k σ .
Revised: i g ( X ) IterGP’s posterior mean for the latent function g ∈ H k σ .

Original: If σ 2 = 0 , then the above also holds for x ∈ X .
Revised: If σ 2 = 0 , then the above also holds for x ∈ X .

Original: Proof.
Revised: Proof.

Original: Let x 0 = x , c 0 = 1 and c j = −
Revised: Let x 0 = x , c 0 = 1 and c j = −

Original: ( C i k σ ( X , x ))
Revised: ( C i k σ ( X , x ))

Original: j for j = 1 , . . .
Revised: j for j = 1 , . . .

Original: n , where k σ ( · , · ) :
Revised: n , where k σ ( · , · ) :

Original: = k ( · , · ) + σ 2 δ ( · , · ) .
Revised: = k ( · , · ) + σ 2 δ ( · , · ) .

Original: Then by Lemma 3.9 of Kanagawa et al.
Revised: Then by Lemma 3.9 of Kanagawa et al.

Original: [32], it holds that
Revised: [36], it holds that

Original: [Equation]
Revised: [Equation]

Original: Now by the reproducing property
Revised: Now by the reproducing property

Original: [Equation]
Revised: [Equation]

Original: it follows that
Revised: it follows that

Original: [Equation]
Revised: [Equation]

Original: If σ 2 > 0 and x ̸ = x j or if σ 2 =
Revised: If σ 2 > 0 and x ̸ = x j or if σ 2 =

Original: [Equation]
Revised: [Equation]

Original: it holds that k σ ( x , X ) =
Revised: it holds that k σ ( x , X ) =

Original: k ( x , X ) .
Revised: k ( x , X ) .

Original: Further by definition k σ ( X , X ) = ˆ K and finally by (S42)
Revised: Further by definition k σ ( X , X ) = ˆ K and finally by (S42)

Original: [Equation]
Revised: [Equation]

Original: it holds that C i ˆ KC
Revised: it holds that C i ˆ KC

Original: i =
Revised: i =

Original: C i .
Revised: C i .

Original: Therefore we have
Revised: Therefore we have

Original: [Equation]
Revised: [Equation]

Original: We prove eq.
Revised: We prove eq.

Original: (14) by an analogous argument.
Revised: (14) by an analogous argument.

Original: Choose c
Revised: Choose c

Original: j :=
Revised: j :=

Original: (( ˆ K − 1 − C i ) k
Revised: (( ˆ K − 1 − C i ) k

Original: σ ( X , x ))
Revised: σ ( X , x ))

Original: j .
Revised: j .

Original: We have
Revised: We have

Original: [Equation]
Revised: [Equation]

Original: = (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) n (cid:88)
Revised: = (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) n (cid:88)

Original: [Equation]
Revised: [Equation]

Original: Again, we use that k σ ( x , X ) =
Revised: Again, we use that k σ ( x , X ) =

Original: k ( x , X ) by assumption and (S42).
Revised: k ( x , X ) by assumption and (S42).

Original: Therefore =
Revised: Therefore =

Original: k ( x , X )( ˆ K − 1 − C i ) k
Revised: k ( x , X )( ˆ K − 1 − C i ) k

Original: ( X , x ) =
Revised: ( X , x ) =

Original: k comp i ( x , x )
Revised: k comp i ( x , x )

Original: This concludes the proof.
Revised: This concludes the proof.

Original: Y i =
Revised: Y i =

Original: IterGP-Cholesky i
Revised: IterGP-Cholesky i

Original: =i =
Revised: =i =

Original: V a r i a n ce
Revised: V a r i a n ce

Original: Y i =
Revised: Y i =

Original: IterGP-PBR i =i =
Revised: IterGP-PBR i =i =

Original: V a r i a n ce
Revised: V a r i a n ce

Original: Y i =
Revised: Y i =

Original: IterGP-CG i =
Revised: IterGP-CG i =

Original: i =
Revised: i =

Original: V a r i a n ce
Revised: V a r i a n ce

Original: Y i =
Revised: Y i =

Original: IterGP-PI i
Revised: IterGP-PI i

Original: =i =
Revised: =i =

Original: V a r i a n ce
Revised: V a r i a n ce

Original: [Figure]
Revised: [Figure]

Original: S Implementation of AlgorithmS3.1 Policy Choice
Revised: S Implementation of AlgorithmS3.1 Policy Choice

Original: As illustrated in Figure 2, the choice of policy of Algorithm 1 determines where computation in input space is targeted and therefore where the combined posterior contracts first.
Revised: As illustrated in Figure 2, the choice of policy of Algorithm 1 determines where computation in input space is targeted and therefore where the combined posterior contracts first.

Original: However, the policy also determines whether the error in the posterior mean or (co-)variance are predominantly reduced first, as Figure S3 shows (cf.
Revised: However, the policy also determines whether the error in the posterior mean or (co-)variance are predominantly reduced first, as Figure S3 shows (cf.

Original: IterGP-Chol and IterGP-PBR).
Revised: IterGP-Chol and IterGP-PBR).

Original: Therefore the policy choice is application-dependent.
Revised: Therefore the policy choice is application-dependent.

Original: If I am primarily interested in the predictive mean, I may select residual actions (IterGP-CG).
Revised: If I am primarily interested in the predictive mean, I may select residual actions (IterGP-CG).

Original: If downstream I am making use of the predictive uncertainty, I may want to contract uncertainty globally as quickly as possible at the expense of predictive accuracy (IterGP-PI).
Revised: If downstream I am making use of the predictive uncertainty, I may want to contract uncertainty globally as quickly as possible at the expense of predictive accuracy (IterGP-PI).

Original: Such a choice is not unique to IterGP, but necessary whenever we select a GP approximation.
Revised: Such a choice is not unique to IterGP, but necessary whenever we select a GP approximation.

Original: What
Revised: What

Original: IterGP adds is computation-aware, meaningful uncertainty quantification in the sense of Corollaryno matter the choice of policy.
Revised: IterGP adds is computation-aware, meaningful uncertainty quantification in the sense of Corollaryno matter the choice of policy.

Original: S3.2 Stopping Criterion
Revised: S3.2 Stopping Criterion

Original: In our implementation of Algorithm 1 we use the following two stopping criteria.
Revised: In our implementation of Algorithm 1 we use the following two stopping criteria.

Original: Our computational budget can be directly controlled by specifying a maximum number of iterations , since each iteration of IterGP needs the same number of matrix-vector multiplies.
Revised: Our computational budget can be directly controlled by specifying a maximum number of iterations , since each iteration of IterGP needs the same number of matrix-vector multiplies.

Original: Alternatively, we terminate if the absolute or relative norm of the residual are sufficiently small,
Revised: Alternatively, we terminate if the absolute or relative norm of the residual are sufficiently small,

Original: i.e. if
Revised: i.e. if

Original: [Equation]
Revised: [Equation]

Original: Of course other choices are possible.
Revised: Of course other choices are possible.

Original: From a probabilistic numerics standpoint one may want to terminate once the combined marginal uncertainty at the training data is sufficiently small relative to the observation noise.
Revised: From a probabilistic numerics standpoint one may want to terminate once the combined marginal uncertainty at the training data is sufficiently small relative to the observation noise.

Original: S3.3 Efficient Sampling from the Combined Posterior
Revised: S3.3 Efficient Sampling from the Combined Posterior

Original: Sampling from an exact GP posterior has cubic cost O ( n 3 ⋄ ) in the number of evaluation points n ⋄ , which is prohibitive for many useful downstream applications such as numerical integration over the posterior using Monte-Carlo methods.
Revised: Sampling from an exact GP posterior has cubic cost O ( n 3 ⋄ ) in the number of evaluation points n ⋄ , which is prohibitive for many useful downstream applications such as numerical integration over the posterior using Monte-Carlo methods.

Original: Wilson et al.
Revised: Wilson et al.

Original: [42, 43] recently showed how to make use of
Revised: [46, 47] recently showed how to make use of

Original: Matheron’s rule [41, 65, 66] to efficiently sample from a GP posterior by sampling from the prior and then performing a pathwise update.
Revised: Matheron’s rule [45, 66, 67] to efficiently sample from a GP posterior by sampling from the prior and then performing a pathwise update.

Original: We can directly make use of this strategy since Algorithmcomputes a low-rank approximation to the precision matrix.
Revised: We can directly make use of this strategy since Algorithmcomputes a low-rank approximation to the precision matrix.

Original: Assume we are given a draw f ′ prior ∈ H θk from the prior 3 such that y ′ ∼ N ( f ′ prior ( X ) , σ 2 I ) constitutes a draw from the prior predictive.
Revised: Assume we are given a draw f ′ prior ∈ H θk from the prior 3 such that y ′ ∼ N ( f ′ prior ( X ) , σ 2 I ) constitutes a draw from the prior predictive.

Original: Then
Revised: Then

Original: [Equation]
Revised: [Equation]

Original: is a draw from the combined posterior by Matheron’s rule, which we can evaluate in O ( n ⋄ ni ) for n ⋄ evaluation points, since C i has rank i .
Revised: is a draw from the combined posterior by Matheron’s rule, which we can evaluate in O ( n ⋄ ni ) for n ⋄ evaluation points, since C i has rank i .

Original: S Additional Experimental Results
Revised: S Additional Experimental Results

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: LL
Revised: LL

Original: [Figure]
Revised: [Figure]