{'fraction_non_alphanumeric': 0.03990425314534256, 'fraction_numerical': 0.010683947806287767, 'mean_word_length': 4.237425470111604, 'pattern_counts': {'":': 0, '<': 4, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 18, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Fundamental Resource Trade-offs for Encoded Distributed Optimization

Dealing with the shear size and complexity of today's massive data sets requires computational platforms that can analyze data in a parallelized and distributed fashion. A major bottleneck that arises in such modern distributed computing environments is that some of the worker nodes may run slow. These nodes a.k.a.~stragglers can significantly slow down computation as the slowest node may dictate the overall computational time. A recent computational framework, called encoded optimization, creates redundancy in the data to mitigate the effect of stragglers. In this paper we develop novel mathematical understanding for this framework demonstrating its effectiveness in much broader settings than was previously understood. We also analyze the convergence behavior of iterative encoded optimization algorithms, allowing us to characterize fundamental trade-offs between convergence rate, size of data set, accuracy, computational load (or data redundancy), and straggler toleration in this framework.


Introduction
Modern data sets are massive in size and complexity consisting of tens of billions of examples. These data sets are also very high-dimensional with numerous detailed information gathered for each example. Furthermore, due to the proliferation of a variety of personal devices many modern data sets are stored or collected in a distributed manner. To process such data sets in a timely manner, distributed computing algorithms/platforms that can analyze data in a parallelized or fully decentralized fashion are crucial.
As we scale out computations across many distributed nodes in modern distributed computing environments, such as Amazon EC2, a major performance bottleneck is the latency in waiting for slowest nodes, or "stragglers" to finish their tasks [2]. These stragglers are caused by various forms of "system noise" (e.g., deallocation of computational resources, bandwidth limitation, node failure, etc) and can significantly slow down computation as the slowest node may dictate the overall computational time. The conventional approaches to mitigate the impact of stragglers involve creation of some form of "computational redundancy". For example, replicating the straggling task on another available node is a common approach to deal with stragglers (e.g., [19]).
More recent approaches [9,11,10,18,3,17,5,16] bring to bear ideas from coding theory to distributed computing. These coded computing approaches create redundancy in the computation tasks in unorthodox coded forms (as opposed to conventional replication approaches), thereby alleviating the effect of stragglers more efficiently.
Coded computing has also been proposed for creating redundancy in distributed optimization problems [6,7]. The key idea of this approach, named encoded optimization, is to linearly encode the data variables in the optimization. The encoded data is then distributed across the computational nodes and distributed optimization algorithms are then applied to these encoded data. Due to the redundancy created in the data the optimization algorithms can be completed without having to wait for the straggler nodes.
The encoded optimization framework provides an intriguing approach to deal with the effect of stragglers. However, our mathematical understanding of the effect of this data encoding strategy is limited. In particular existing results such as [6,7] mostly focus on understanding the effect of random encoding strategies on the optimal solution to unconstrained least-squares problems. Furthermore, there is very limited understanding of how such encoding strategies affect the use of various computational and data resources. This is particularly important as in many modern applications ranging from imaging to online advertisement and financial trading we are interested in algorithms that can operate under multiple constraints (e.g. under a limited time budget). Efficient learning from encoded data under these constraints poses new challenges: How can we incorporate domain-specific prior knowledge in a principled manner? What algorithms should we use under a fixed time budget? How much of the data should we use? Should we use all of the data or just parts of it? How many passes (or iterations) of the algorithm is required to get to an accurate solution? How much redundancy should we create in our data? How does the amount of redundancy present in our data encoding strategy affect the convergence behavior and run-time of our algorithms? How many straggler nodes can a particular form of data encoding approach tolerate?
At the heart of answering these questions is the ability to predict run-time of encoded optimization algorithms as a function of the required accuracy, the size of data, the number of straggler nodes, the amount of prior knowledge, etc. That is, we need to understand precise trade-offs between run time, data size, accuracy, data redundancy and straggler toleration of iterative encoded optimization algorithms. In this paper we wish to precisely characterize such trade-offs, significantly broadening our current understanding of the encoded optimization paradigm. Our main contributions in this paper are as follows.
• We study the encoded optimization framework in a much broader setting than previously understood. In particular, we demonstrate how prior knowledge can be incorporated in this framework via constraints on the optimization variables. Our guarantees are very general and can deal with arbitrary and potentially nonconvex constraints.
• Our results require a near minimal amount of data redundancy/replication (a.k.a. computational load). We show that encoded optimization is effective as long as the data redundancy/replication exceeds (up to constants) the sum of the total number of stragglers and a precise quantity capturing the amount of prior knowledge that is enforced in the optimization algorithm. In fact, in certain cases our framework applies even when the number of encoded data is less than the number of data points allowing for data compression in lieu of redundancy/replication.

Problem formulation
In this section we discuss the encoded distributed optimization framework and formulate the underlying fundamental resource trade-offs that we study in this paper.

Setting
In many modern applications in signal processing and machine learning we aim to infer models that best explain the training data. Given training data consisting of n pairs of input features x i ∈ R d and desired outputs y i ∈ R we wish to infer a function that best explains the training data.The simplest functions are linear ones where the outputs are linear functions of the features. Specifically, we are interested in finding a parameter θ * ∈ R d obeying the following equations Here, w i denotes the noise present in our training examples. A natural approach to finding the best linear model is to minimize the empirical risk ∑ n k=1 ℓ(⟨x k , θ⟩, y k ) via a quadratic loss ℓ(u, v) = 1 2 (u − v) 2 . This leads to the following optimization problem Here, y ∈ R n is the output vector consisting of the outputs y = [y 1 y 2 ... y n ] T and X ∈ R n×d is the feature matrix consisting of the data features X is a regularizer function that is used to avoid over-fitting and captures some notion of structure/complexity of the unknown parameter (with R a tuning parameter). We note that while we will focus on linear models and quadratic losses many of the algorithms and technical proofs in this paper generalize to other models/losses. We aim to pursue these extensions in future publications.
To solve optimization problems of the form (2.2) involving massive data sizes we need to utilize modern distributed computing platforms. While there are many popular distributed computing schemes [15], in this paper we focus on a OneToAll scheme which consists of a master node and L workers. We focus on a distributed implementation of Projected Gradient Descent (PGD) for solving problems of the form (2.2). To distribute PGD we assume the master partitions the features matrix and the response vector y across rows between L worker nodes. Specifically, we partition X y into L parts across rows with Here, X ℓ ∈ R n ℓ ×d and y ℓ ∈ R n ℓ with ∑ ℓ n ℓ = n. With this partition, worker ℓ receives data X ℓ y ℓ and carries out updates/computations on this data. Starting from some initial solution θ 0 ∈ R d , in each iterations the master sends the current update θ τ to the workers. Each of the workers then calculates a partial gradient based on the portion of the data it has access to. Specifically, worker ℓ returns to the master the following partial gradient The master then aggregates all of these partial gradients and performs the following update Here, P denotes the Euclidean projection onto the constraint set K = {θ ∈ R d ∶ R(θ) ≤ R} andμ τ is the learning rate. As mentioned in Section 1, a major performance bottleneck that arises when implementing such distributed PGD updates is that some of the worker nodes may run slow (i.e., stragglers). The presence of such stragglers can significantly slow down the computations as the master has to wait for all the workers to send their partial gradient calculations, so that the overall run time is limited by the slowest worker. For instance, in [1] the effect of slow workers under the title of outliers was studied and it was shown that completion time of jobs can be prolonged by %34 at median. In this paper, we will focus on the encoded optimization framework, which will be described next, to mitigate the effect of stragglers.

The Encoded Optimization Framework
To deal with the effect of stragglers in the iterations (2.3), in this paper we utilize a new approach for straggler mitigation, named encoded distributed optimization [6,7] , which was originally developed for unconstrained least-squares problems. The main idea behind this approach is to create redundancy in the data by random embedding/encoding. In this section we discuss this computational paradigm tailored to distributed PGD iterates.
To overcome the computational slowdown caused by stragglers we randomly embed/encode the data by multiplying the feature matrix and the response vector by an encoding matrix A ∈ R m×n . We then partition these embedded data AX Ay and then distribute them across rows between the L worker nodes. Specifically, we partition the matrix A into L parts across rows T with A ℓ ∈ R n ℓ ×d and n = ∑ ℓ n ℓ . Similar to the un-coded case, with this partition worker ℓ receives data A ℓ X A ℓ y and carries out updates/computations on this data so that the partial gradient updates are now calculated based on these randomly encoded data. That is, Due to the effect of stragglers the master may not receive gradient updates from some workers in a timely manner so that computations based on some of the m rows maybe missing. Let us denote the index of the slow workers at iteration τ by I τ ⊂ {1, 2, . . . , L}. Also let W ℓ ⊂ {1, 2, . . . , n} denote the index of the rows of A sent to worker ℓ. Now define which contains the indices of all the rows of A that is not available at the master due to stragglers. We will use s τ = S τ to denote the total number of these straggler rows. Based on the gradient updates available to the master it proceeds with the following PGD update Therefore the master effectively runs the encoded iterations (2.4) in lieu of the uncoded iterates (2.3). Note that, apriori it is not clear when/why the encoded iterates serve as a good proxy for the uncoded ones. Understanding this relationship is the main focus of this paper. In the next section we discuss the main problems that we study in this paper by formalizing various fundamental trade-offs that arise in the distributed encoded optimization framework.

Fundamental Resource Trade-offs
In this paper we wish to understand under what conditions the encoded iterates (2.4) are a good proxy for the uncoded iterates (2.3). We aim to answer fundamental questions such as: When will both set of iterates converge to the same fixed point? How does the convergence behavior change due to the presence of the encoding mapping? What are the various trade-offs involved between various resources. To discuss these problems more precisely we start with two simple definitions related to the encoding matrix A.

Definition 1 (Computational Load)
We use computational load m to refer to the number of rows of A.

Definition 2 (Straggler Toleration)
We use s to denote the maximum number of straggler rows in each iteration ( S τ ≤ s). We refer to this quantity as straggler toleration.
With these definitions in place, we now discuss the fundamental trade-offs that we aim to characterize in this paper.
• Accuracy vs. Computational Time: In many modern learning applications we must operate on a fixed time budget. Therefore, it is crucial to understand how many passes (or iterations) of the algorithm is required to get to a certain accuracy. We wish to characterize this fundamental trade-off between computational time and accuracy for the encoded distributed optimization framework. Stated more formally, we are interested in precisely understanding the distance between the encoded iterates and the true parameter ( θ τ − θ * ℓ 2 ) as a function of the number of iterations (τ ) and the noise level w ℓ 2 .
• Convergence Rate vs. Computational Load: We are interested in understanding how the computational load m affects the convergence behavior of the encoded iterates. Intuitively, as the computational load increases the encoded iterates provide a better approximation to the un-coded iterates. Therefore, we expect the coded iterates to converge faster as the computational load increases. We wish to precisely characterize the convergence rate as a function of the computational load.
• Convergence Rate vs. Straggler Toleration: In each encoded iteration, there are some stragglers which are ignored by the master node. We aim to characterize the impact of stragglers on the speed of convergence. By increasing the number of stragglers (s), the master node ignores more and more data. Therefore, intuitively we expect that the more stragglers we have, the more iterations are needed for the encoded iterates to converge to a certain accuracy. We wish to characterize the convergence rate as a function of the straggler toleration parameter.
• Computational Load vs. Straggler Toleration: Intuitively, as we increase the number of stragglers, s, we need more redundancy in our encoded framework. Stated differently, we need to increase the computational load as a function of the number of stragglers. This leads to a fundamental trade-off between computational load and straggler toleration. We aim to characterize the minimum required computational load as a function of the straggler toleration parameter so as to ensure the encoded iterates eventually converge to a good estimate.
In the next section we state our main result that leads to a precise characterization of the convergence behavior of the encoded iterates as a function of various parameters, allowing us to precisely characterize the above trade-offs.

Main Results
We wish to characterize the convergence behavior of the encoded iterates (2.3) as a function of various problem parameters for the worse possible choice of s straggler rows. More precisely, we are interested in characterizing the relationship between sup Sτ ⊂{1,2,...,m}, Sτ ≤s and the error w ℓ 2 when running the iterations (2.3). To make these connections precise and quantitative we need a few definitions. Naturally our results depend on how well the regularization function R can capture the properties of the unknown parameter θ * . For example, if we know our unknown parameter is approximately sparse, then using an ℓ 1 norm for the regularizer is superior to using an ℓ 2 regularizer. To quantify this capability we first need a couple of standard definitions which we adapt from [12,13].

Definition 3 (Descent Set and Cone)
The set of descent of a function R at a point θ * is defined as The cone of descent is defined as a closed cone C R (θ * ) that contains the descent set, i.e. D R (θ * ) ⊂ C R (θ * ). The tangent cone is the conic hull of the descent set. That is, the smallest closed cone We note that the capability of the regularizer R in capturing the properties of the parameter vector θ * depends on the size of the descent cone C R (θ * ). The smaller this cone is the more suited the function R is at capturing the properties of θ * . To quantify the size of various cones we shall use the notion of mean width.

Definition 4 (Gaussian Width)
The Gaussian width of a set C ∈ R n is defined as ω(C) ∶= E g [sup z∈C ⟨g, z⟩], where the expectation is taken over g ∼ N (0, I n ).
We now have all the definitions in place to quantify the capability of the function R in capturing the properties of the unknown parameter θ * when using an encoding matrix A. This naturally leads us to the definition of the minimum required computational load.
We define the minimal computational load function as where θ * ∈ R d and X ∈ R n×d . We shall often use the short hand m 0 = M(R, X, θ * , η) with the dependence on R, X, θ * , η implied.
The definition above characterizes the minimum computational load required for the encoded iterations to converge to the true parameter in the absence of noise or stragglers.
The convergence rate of the encoded iterates also naturally depends on various characteristics of the feature matrix X. We quantify a few of these characteristics below.
Definition 6 (Cone-Restricted Spectral Norm) Let C R (θ * ) be the cone of descent of the regularization function R at a point θ * per Definition 3. the cone-restricted spectral norm of a matrix X ∈ R n×d with respect to R at a point θ * is defined as σ R (X) = sup We note that the above definition is a natural extension of the spectral norm of a matrix. It is well known that the spectral norm of the feature matrix plays a crucial role in the convergence behavior of least-square problems. The cone-restricted spectral norm defined above plays a similar role in the convergence of constrained least-squares problems.
Furthermore, the convergence behavior of the encoded iterates is also related to that of the uncoded iterates. The following two definitions, adapted from [12], concern the convergence of the uncoded iterates.
Definition 7 (Convergence Rate) Consider the iterations 2.3. Let θ * ∈ R d and X ∈ R n×d and R be the regularizer function as well as µ be the learning rate. We define It is known that ρ(µ) characterizes the convergence rate of the uncoded iterations (2.3) [12].
Definition 8 (Noise Amplification) Consider the iterations 2.3. Let θ * ∈ R d and X ∈ R n×d and R be the regularizer function with w denoting the noise. We define It is known that the uncoded iterations eventually converge to a neighborhood of the unknown parameter θ * [12]. The noise amplification factor defined above plays a crucial role in characterizing the size of this neighborhood. In particular, [12] shows that the diameter of this neighborhood is proportional to ξ(X) w ℓ 2 .
With these definitions in place we are now ready to state our main theorem regarding the convergence of the encoded iterates (2.4).
Theorem 1 Let A ∈ R m×n be a matrix with i.i.d. N (0, 1) entries. Also assume the number of straggler rows obeys s τ = S τ ≤ s with s the straggler toleration parameter per Definition 2 obeying s ≤ m. Furthermore, let m 0 = M(R, X, θ * , η) denote the minimal computational load per Definition 5. Then the encoded iterative updates (2.4) obey sup Sτ ⊂{1,2,...,m} Here, ρ is the convergence rate per Definition 7, ξ is the noise amplifications per Definition 8, σ R (X) is the cone-restricted spectral norm of X per Definition 6. Furthermore, the tunning parameter is set to R = R(θ * ) and the learning rate is Remarks 1 Theorem 1 essentially connects the convergence behavior of the encoded iterations to that of the uncoded iterations. Consider the limit m → ∞ and note that for a Gaussian matrix A S c τ , A T S c τ A S c τ → I and thus the encoded iterations reduce to the uncoded iterations. In this case the convergence bound provided by Theorem 1 reduces to The first term gives the convergence rate to the true parameter. The second term characterizes the size of the neighborhood (of the true parameter) to which the iterates converge, demonstrating that the iterates eventually approximate the true parameter up to a term that is proportional to the Euclidean norm of the noise. The bound (3.2) was proven recently in [12]. Our result generalizes this result to the encoded case while recovering the special uncoded case in the limit m → ∞.
Remarks 2 Theorem 1 characterizes the minimal computational load for convergence of (2.4) in the presence of stragglers. Comparing (3.1) with (3.2) we see that as long as the computational load is sufficiently large the effect of coding is only a slight increase in the convergence rate and the size of approximation neighborhood. For instance, to ensure that in the encoded case the convergence rate only increases by ǫ the computational load must obey In the last inequality we used κ R ≤ 2 and the fact thatμ τ typically scales with 1 σ R (X) 2 (as step size typically scales with the inverse of the smoothness parameter). Thus as long as the computational load exceeds the sum of the number of stragglers and the minimal computational load by a constant factor, i.e.
holds for some numerical constant c depending only on ǫ, then the increase in the convergence rate is small. Similarly, the increase in the size of the approximation neighborhood remains small as long as (3.3) holds.

Remarks 3
We now briefly discuss how our results compare with related work. Theorem 1 demonstrates that the encoded iterates converge at a linear rate whilst dealing with arbitrary and possibly nonconvex constraints. [7] also demonstrates a linear convergence, albeit in terms of the optimal value. However, [7] only focuses on the special case where there are no constraints on the optimization variables. Furthermore, [7] requires a computational load that is larger than the sum of the number of stragglers and the total number of data points i.e. m ≥ 2(n + s). In comparison, our results require a near minimal number of samples that is commensurate to the sum of the straggler toleration and the amount of prior knowledge (m ≥ c(m 0 + s)). This allows for a much smaller computation load that can even be significantly smaller than the number of data points i.e. m << n.
Finally, we would like to mention related work in [14] where the authors focus on sketching of constrained convex programs. This paper focuses on the properties of the optimal solution to problems of the form (2.2) without any stragglers. In comparison, we focus on analyzing the convergence behavior of iterative algorithms when stragglers are present.
Remarks 4 (Convergence Rate vs. Computational Load) Theorem 1 characterizes the effect of the computational load on the convergence rate. In particular, this theorem shows that the increase in the convergence rate is proportional to 1 √ m. Therefore, as the computational load increases the convergence rate decreases. Thus, a larger computational load ensures a faster convergence of the encoded iterates.
Remarks 5 (Convergence Rate vs. Straggler Toleration) Theorem 1 also characterizes the effect of stragglers on the rate of convergence. This result demonstrates a rate proportional to 1 √ m − s so that as the number of stragglers increase, the convergence rate decreases leading to a slower convergence of the encoded iterates.

Numerical Results
In this section, we corroborate the resource trade-offs characterized in Theorem 1 via experiments on synthetic data. We generate the true parameter θ * ∈ R d with d = 4000 and sparsity level k = 20 where the support is chosen at random and the values on support are distributed i.i. d N (0, 1). Moreover, we generate the data matrix X ∈ R n×d i.i.d. ∼ N (0, 1) with n = 3000 and set the output vector via y = Xθ * . In our simulations we vary the computational load m and the straggler toleration s and then plot the various trade-offs. We use two different encoding matrices: a random Gaussian matrix and a random Discrete Cosine Transform (DCT) matrix. In the Gaussian case the entries of the matrix are generated i.i.d. ∼ N (0, 1). The random DCT matrix is generated according to A = HD where H ∈ R m×n is obtained by selecting m rows of an n × n DCT matrix at random and D ∈ R n×n is a diagonal matrix with i.i.d. ±1 entries on the diagonal. In our simulations in each iteration we assume a different set of straggler rows chosen i.i.d. at random from the m rows.
• Convergence Rate vs. Computational Load: In this simulation we fix the straggler toleration at s = 100 and vary the computation load m. We depict the relative error as a function of iterations in Figure 1a. This figure confirms that the convergence is indeed linear and increasing m leads to a faster convergence as predicted by Theorem 1.
• Convergence Rate vs. Straggler Toleration: In this simulation we fix the computational load at m = 800 and vary the straggler toleration s and depict the relative errors as a function of the iterations in Figure 1b. This figure confirms that the iterates converge at a linear rate and increasing s leads to a slower convergence as predicted by Theorem 1.
• Computational Load vs. Straggler Toleration: In this simulation we vary the computational load m, and straggler toleration s and for each case run the encoded PGD iterations. We stop after 500 iterations and record the empirical probability of success. The empirical probability of success is an average over 50 trials, where in each instance, we generate new random parameter vectors, data and encoding matrices. We declare a trial successful if the relative error of the reconstruction θ − θ * ℓ 2 θ * ℓ 2 falls below 10 −3 . Figure 2a depicts the empirical success probabilities via a color map for different straggler tolerations s and computational loads m. Yellow represents certain success, while blue represents certain failure. In the experiments of this figure the encoding matrix is Gaussian. This figure clearly shows that there is a phase transition curve for the computational load as a function of the straggler toleration. On one side of this curve encoded PGD updates is successful with high probability on the other side it fails with high probability. Figure 2a also shows that the computational load scales linearly in terms of the straggler toleration parameter confirming the relationship (3.3) predicted by Theorem 1. Figure 2b depicts the results for randomized DCT matrices. Encoding with such matrices is very efficient requiring only a DCT transform. Perhaps unexpectedly, randomized DCT matrices exhibit very similar behavior to the Gaussian matrix demonstrating that such matrices can act as computational friendly surrogates for encoding purposes. Proving Theorem 1 extends to randomized DCT matrices is an interesting direction for future research.

Proofs
In this section we prove Theorem 1. Define the error vector h τ ∶= θ τ −θ * and the conesC ∶= C R (θ * ) ∈ R d and C ∶= XC ∈ R n . Utilizing [12][Theorem 1.2] we have We now proceed by simplifying each of these two terms. To simplify the first term, define u ∶= Xũ Xũ ℓ 2 ∈ S n−1 and v ∶= Xṽ Xũ ℓ 2 ∈ S n−1 and note that Now we can use the fact that supremum of sum is less than sum of suprema. Thus, In above, we used the cone-restricted spectral norm of X per Definition 6. We now focus on simplifying the second term in 5.1. To this aim, for a vector u ∈ R n define u ⊥ = u − u T w w 2 ℓ 2 w. We can use this definition to separate the second term in (5.1) into two terms as follows Thus using µ τ =μ τ β 2 s,m we have All that remains is to bound the extra additive term in (5.2) and the extra additive and multiplicative terms in (5.3). To this aim note that for any γ τ we have To proceed we state a lemma about bounding set-restricted eigenvalues, which is proved in the Appendix section.
Now we focus on the extra additive and multiplicative terms in (5.3). We begin with the additive term. To this aim note that since u ⊥ is orthagonal to w, u T holds with probability at least 1 − e − η 2 2 − e − m 2 . We now focus on the extra multiplicative term in (5.3). To this aim note that since w is fixed A S c τ w is distributed as w ℓ 2 a with a distributed as N (0, I m− Sτ ). Therefore, holds with probability at least 1 − e − m 2 . Plugging (5.10) and (5.11) into (5.3) we conclude that

Appendix
In this section we aim to prove Lemma 1 stated in the proofs section. Our proof is related to the proof of Gordon's celebrated escape through the mesh [4][Theorem A]. We will first show the bound (5.5). To this aim we make use of Slepian's lemma stated below.
Lemma 2 (Slepian's inequality) [8][Section 3.3] If X t and Y t are a.s. bounded, Gaussian pro- for all s, t ∈ T , then for all real t, Define I S c ∈ R (m−s)×n as the part of the identity matrix that keeps the rows indexed by S c . For u ∈ T and v ∈ S m−s−1 = {v ∈ R m−s ; v ℓ 2 = 1}, we define three Gaussian processes Here a ∈ R m is distributed as N (0, I m ) and g ∈ R n is distributed as N (0, I n ). It follows that for all u,ũ ∈ T , v,ṽ ∈ S m−s−1 and S,S ⊂ {1, 2, . . . , m}, we have We wish to bound f (a) with high probability. To this aim first note that by concentration of Lipschitz functions of Gaussians Using union bound, we have We thus conclude that The latter together with (7.4) allows us to conclude that Now consider the relationship of following sets Furthermore, note for every u ∈ T , a ∶ u ℓ 2 f (a) ≥ u ℓ 2 β s,m + η is a subset of a ∶ f (a) ≥ β s,m + η σ(T ) . Combining the latter with (7.5) we arrive at Also by the concentration of Lipschitz functions of Gaussians for the function max u∈T (g * u) and the definition of Gaussian width, we have So far, we have obtained upper bounds on the probability of sets max In order to utilize these two sets we combine them in the following way. Note that if Using the latter together with (7.6) and (7.7) and using the independence of a and g we have Using the definition of f (x) = sup S⊂{1,2,...,m}, S =s x S c ℓ 2 , the latter statement can be rewritten in the form This together with (7.8) implies As we noted that the two Gaussian processes X (u,S),v and Y (u,S),v have the three assumptions of Slepian's inequality, we can use Slepian's second inequality (7.2) with η u,v = β s,m u ℓ 2 +η +ω(T ). This implies that

Using the fact that
concludes the proof. Next, we turn our attention to proving (5.6). To this aim we begin by stating a lemma due to Gordon [4].

Lemma 3 [Gordon's inequality]
Let (X ij ) and (Y ut ), 1 ≤ i ≤ n, 1 ≤ j ≤ m, be Gaussian random vectors. Assume that we have the following inequalities for all choices of indices: Then, for all real numbers λ i,j , Consequently, Define I S c ∈ R (m−s)×n as the part of the identity matrix that keeps the rows indexed by S c . For u ∈ T and v ∈ S m−s−1 = {v ∈ R m−s ; v ℓ 2 = 1}, we define two Gaussian processes Here, a ∈ R m is distributed as N (0, I m ), g ∈ R n is distributed as N (0, I n ), and g ∈ R is distributed as N (0, 1). The next few steps are essentially identical to the proof of [4][Lemma 3.1] with the text directly borrowed. We mention this part of the argument for the sake of completeness and also to ensure that proper modifications are applied when necessary. Note that and equal to zero if (u, S) = (ũ,S) so that the first two inequalities in (7.9) hold. It is also trivial to check that Thus all three inequalities in (7.9) trivially hold. Now note that for each u ∈ T and S ⊂ {1, 2, . . . , m} is closed in the probability space {R mn+1 , P} where P is the canonical Gaussian measure of R mn+1 .
is closed. The same is true about the corresponding expression with Y (u,S),v . By Lemma 3 above, and so, ordering the collection of finite subsets of T × {1, 2, . . . , m} (denoted by F) by inclusion, we obtain that the limits exist and satisfy the inequality Now using the fact that the sets are closed and P is a regular measure, it follows easily that the two respective limits over F are equal to and satisfy the inequality This immediately implies that

Now setting
(7.10) Since taking infimum over a set is equivalent to taking intersection over all elements of that set, we can write 8σ 2 (T ) . We claim that g(x) is a Lipschitz function and then we can utilize the concentration of measure for Gaussian random variables. Without loss of generality we assume g(x) ≥ g(y). Thus, Hence g(a) is a Lipschitz function of a Gaussian random variable. Thus, the random variable Z ∶= g(a) obeys concluding the proof of (7.13). Combining (7.12) with (7.13) we arrive at E inf S⊂{1,2,...,m}, S =s a S c ℓ 2 ≥ m − 2 − 5s log( em s ) ∶= α s,m (7.14) As mentioned earlier, g(a) is Lipschitz function of a. Thus, by concentration of Lipschitz functions of Gaussians we have Using the fact that u ℓ 2 σ(T ) ≤ 1 and together with (7.12) as well as (7.15), we can deduce that The latter is equivalent to ⋃ u∈T u ℓ 2 inf S =s a S c ℓ 2 + g * u < α s,m u ℓ 2 − (ω(T ) + η) Considering the probability of these sets, we have P ⋃ u∈T u ℓ 2 inf S =s a S c ℓ 2 + g * u < α s,m u ℓ 2 − (ω(T ) + η) Taking complements of both sides and using the bounds from (7.11) and (7.16) we conclude that P ⋂ u∈T u ℓ 2 inf S =s a S c ℓ 2 + g * u ≥ α s,m u ℓ 2 − (ω(T ) + η) The latter inequality together with (7.10) implies that P inf S =s inf u∈T ( A S c u ℓ 2 + g u ℓ 2 −α s,m u ℓ 2 ) ≥ − (ω(T ) + η) 8σ 2 (T ) . (7.19) In order to find the relationship between the probability of the latter set with the probability of the set defined in (5.6), we define the following three probabilities Now note that by the above definitions and the independence of A and g we can conclude that 1 ≥ p + ≥ p 0 ≥ p − . (7.20) By the law of total probability p = p−+p+ 2 . Now using the fact that p + ≤ 1 together with (7.20) we can conclude that The latter inequality together with (7.19) implies that concluding the proof of (5.6).