Decremental -Approximate Maximum Eigenvector: Dynamic Power Method
Abstract
We present a dynamic algorithm for maintaining -approximate maximum eigenvector and eigenvalue of a positive semi-definite matrix undergoing decreasing updates, i.e., updates which may only decrease eigenvalues. Given a vector updating , our algorithm takes amortized update time, i.e., polylogarithmic per non-zeros in the update vector.
Our technique is based on a novel analysis of the influential power method in the dynamic setting. The two previous sets of techniques have the following drawbacks (1) algebraic techniques can maintain exact solutions but their update time is at least polynomial per non-zeros, and (2) sketching techniques admit polylogarithmic update time but suffer from a crude additive approximation.
Our algorithm exploits an oblivious adversary. Interestingly, we show that any algorithm with polylogarithmic update time per non-zeros that works against an adaptive adversary and satisfies an additional natural property would imply a breakthrough for checking psd-ness of matrices in time, instead of time.
Keywords and phrases:
Power Method, Dynamic AlgorithmsCategory:
Track A: Algorithms, Complexity and GamesFunding:
Deeksha Adil: Supported by Dr. Max Rössler, the Walter Haefner Foundation and the ETH Zürich Foundation.Copyright and License:
![[Uncaptioned image]](x1.png)
2012 ACM Subject Classification:
Theory of computation Algorithm design techniquesEditors:
Keren Censor-Hillel, Fabrizio Grandoni, Joël Ouaknine, and Gabriele PuppisSeries and Publisher:

1 Introduction
Computing eigenvalues and eigenvectors of a matrix is predominant in several applications, including principle component analysis, clustering in high-dimensional data, semidefinite programming, spectral graph partitioning, and algorithms such as Google’s PageRank algorithm. In the era of massive and dynamic datasets, developing algorithms capable of efficiently updating spectral information with changing inputs has become indispensable.
The study of the change in the spectrum of a matrix undergoing updates spans over five decades, with [13] providing the first algebraic characterization of the change for positive semi-definite matrices via the secular equation. This result offered an explicit formula for exactly computing all new eigenvalues when a matrix undergoes a single rank-one update, assuming knowledge of the entire eigen-decomposition of the initial matrix. Subsequently, [12] showed how to additionally compute eigenvectors explicitly, and handle the case of repeated eigenvalues of the initial matrix. A decade later, [5] extended the works of [13, 12] to compute all new eigenvalues and eigenvectors of a positive semi-definite matrix undergoing an update of the form of a small-rank matrix, or a single batch update. Further works extend these techniques to computing singular values [27], as well as computing new eigenvalues and eigenvectors when only the partial eigen-decomposition of the initial matrix is known [21]. However, all these works require a full eigen-decomposition of the initial matrix and only handle a single update to the matrix.
Another independent line of work aims at finding a small and sparse matrix that has eigenvalues close to the original matrix. A recent work in this direction by [10] provides a universal sparsifier for positive semi-definite matrices , such that has at most non-zero entries and . [28] give an alternate technique by using gaussian sketches with rows to approximate all eigenvalues of to an additive error of . The algorithms that find sparse matrices approximating the eigenvalues in these works may be extended to handle updates in the initial matrix quickly. However, the approximation of the eigenvalues achieved is quite crude, i.e., at least additive factor. This approximation is also shown to be tight for such techniques.
Now consider the simpler task of only maintaining the maximum eigenvalue and eigenvector of a matrix as it undergoes updates. As we have seen above, known methods based on algebraic techniques require full spectral information before computing the new eigenvalues, and maintaining the entire eigen-decomposition can be slow. Sparsification-based algorithms are fast but only achieve large additive approximations of at least , which is not quite satisfactory. Works on streaming PCA, which have a similar goal of maintaining large eigenvectors focus on optimizing the space complexity instead of runtimes [2]. Previous works based on dynamically maintaining the matrix inverse can maintain -multiplicative approximations to the maximum eigenvalues of an symmetric matrix undergoing single-entry updates with an update time of [26]. This was further improved to [32]. The update time is even slower for row, column, or rank-one updates. In any case, it takes polynomial time per non-zeros of the updates. This leads to the following natural question:
Is there a dynamic algorithm that can maintain a multiplicative approximation of the maximum eigenvalue of a matrix using polylogarithmic update time per non-zeros in the update?
In this paper, we study the problem of maintaining a -multiplicative approximation to the maximum eigenvalue and eigenvector of a positive semi-definite matrix as it undergoes a sequence of rank-one updates that may only decrease the eigenvalues. We note that this is equivalent to finding the minimum eigenvalue and eigenvector of a positive semi-definite matrix undergoing rank-one updates that may only increase the eigenvalues. We now formally state our problem.
Problem 1 (Decremental Approximate Maximum Eigenvalue and Eigenvector).
We are given a size parameter , an accuracy parameter , a psd matrix of size , and an online sequence of vectors that update with a promise that for all . The goal is to maintain an -approximate eigenvalue and -approximate eigenvector of for all time . That is and unite vector satisfying,
(1) |
and
(2) |
1.1 Our Results
We give an algorithm for the Decremental Approximate Maximum Eigenvalue and Eigenvector Problem that has an amortized update time of 111 hides polynomials in .. In other words, the total time required by our algorithm over updates is at most . Observe that our algorithm only requires time that is (time required to read the input) and can handle any number of decremental updates. Our algorithm works against an oblivious adversary, i.e., the update sequence is fixed from the beginning. This is the first algorithm that can handle a sequence of updates while providing a multiplicative approximation to the eigenvalues and eigenvectors in a total runtime of and an amortized update time faster than previous algorithms by a factor of . Formally, we prove the following:
Theorem 2.
There is an algorithm for Problem 1 under a sequence of decreasing updates, that given parameters , , and as input, with probability at least works against an oblivious adversary in total time,
Our algorithm is a novel adaptation of the classical power method (see, e.g., [29]) to the dynamic setting, along with a new analysis that may be of independent interest.
Our work can also be viewed as the first step towards generalizing the dynamic algorithms for solving positive linear programs of [11] to solving dynamic positive semi-definite programs. We discuss this connection in detail in Appendix A.
1.2 Towards Separation between Oblivious and Adaptive adversaries
We also explore the possibility of removing the assumption of an oblivious adversary and working against adaptive adversaries. Recall that update sequences are given by adaptive adversaries when the update sequence can depend on the solution of the algorithm.
We show that if there is an algorithm for Problem 1 with a total running time of at most such that the output ’s satisfy an additional natural property (which is satisfied by the output of the power method, but not by our algorithm), then it contradicts the hardness of a well-known barrier in numerical linear algebra, therefore ruling out such algorithms.
We first state the barrier formally, and then state our result for adaptive adversaries. Recall that, given a matrix , the condition number of is .
Problem 3 (Checking psdness with certificate).
Given , parameter , and a symmetric matrix of size with condition number at most , either
-
Compute a matrix where , certifying that is a psd matrix, or
-
Report that is not a psd matrix.
Recall that is a psd matrix iff there exists such that . The matrix of is called a vector realization of , and note that is not unique. The problem above asks to compute a (highly accurate) vector realization of . Both eigendecomposition and Cholesky decomposition of give a solution for Problem 3.222Given an eigendecomposition where is a non-negative diagonal matrix and is an orthogonal matrix, we set . Given a Cholesky decomposition where is a lower triangular matrix, we set . Banks et al [7] showed how to compute with high accuracy an eigendecomposition of a psd matrix in time for any constant , where is the matrix multiplication exponent. Hence, a vector realization of can be found in the same time. Observe that, when , Problem 3 is at least as hard as certifying that a given matrix is a psd matrix. It is a notorious open problem whether certifying the psd-ness of a matrix can be done faster than even when the condition number is polynomial in . Therefore, we view Problem 3 as a significant barrier and formalize it as follows.
Hypothesis 4 (PSDness Checking Barrier).
There is a constant such that, every randomized algorithm for solving Problem 3 for instances with , correctly with probability at least requires time.
Our negative result states that, assuming Hypothesis 4, there is no algorithm for Problem 1 against adaptive adversaries with sub-polynomial update time that maintains satisfying an additional property stated below.
Property 5.
For every let denote the eigenvectors of and denote the eigenvalues. For all such that ,
Theorem 6.
Assuming Hypothesis 4, there is no algorithm for Problem 1 that maintains ’s additionally satisfying Property 5, and given parameters and as input, works against an adaptive adversary in time .
Let us motivate Property 5 from several aspects below. First, in the static setting, this property can be easily satisfied since the static power method strongly satisfies it (see Lemma 14). Second, the statement of the property itself is a natural property that we might expect from an algorithm. Consider a “bad” eigenvector whose corresponding eigenvalue is very small, i.e., less than half of the maximum one. It states that the projection of the output along should be very small, i.e., a polynomial factor smaller than the projection along the maximum eigenvector. This is intuitively useful because we do not want the output to direct to the “bad” direction. It should mainly direct along the approximately maximum eigenvector. Third, we formalize this intuition and crucially exploit Property 5 to prove a reduction in Theorem 6. Specifically, Property 5 allows us to decrease eigenvalues of a psd matrix while maintaining the psd-ness, which is crucial for us. See Section 4 for more details. Lastly, our current algorithm from Theorem 2, a dynamic version of the power method, actually maintains ’s that satisfy this property for certain snapshots, but not at every step. Unfortunately, we do not see how to strengthen our algorithm to satisfy Property 5 nor how to remove it from the requirement of Theorem 6. We leave both possibilities as open problems.
Understanding the power and limitations of dynamic algorithms against an oblivious adversary vs. an adaptive adversary has become one of the main research programs in the area of dynamic algorithms. However, finding a natural dynamic problem that separates oblivious and adaptive adversaries is still a wide-open problem.333 Beimel et al. [9] gave the first separations for artificial problems assuming a strong cryptographic assumption. Bateni et al. [8] shows a separation between the adversaries for the -center clustering problem, however, their results are based on the existence of a black box which the adaptive adversary can control. In this paper, we suggest the problem of maintaining approximate maximum eigenvectors as a natural candidate for the separation and give some preliminary evidence for this.
Organization
In the following sections, we begin with some preliminaries required to prove our results in Section 2, followed by our algorithm and its analysis in Section 3, and our conditional lower bound in Section 4. In Section 5, we present some open problems. In the appendix (Section A), we show connections with positive semi-definite programs.
2 Preliminaries
Let denote the initial matrix. Let denote the maximum eigenvalue of the initial matrix . The following are the key definitions we use in our analysis.
Definition 7 (-max span and dimension).
We define to denote the space spanned by all eigenvectors of corresponding to eigenvalues satisfying . Let to denote the dimension of the space .
We emphasize that depends only on . So, it is a static value that does not change through time. We will use the following linear algebraic notations.
Definition 8.
Let and be two subspaces of a vector space . The sum is the space,
The complement of is the vector space such that , and . The difference, is defined as,
Next, we list standard facts about high-dimensional probability needed in our analysis.
Lemma 9 (Chernoff Bound).
Let be independent random variables such that for all . Let and let . Then for all ,
Lemma 10 (Norm of Gaussian Vector).
A random vector with every coordinate chosen from a normal distribution, satisfies,
Proof.
The vector has entries that are from . Now, every follows a distribution. From Lemma 1 of [18] we have the following tail bound for a sum of random variables,
Choosing gives,
as required.
Lemma 11 (Distribution of Variable).
Let be a gaussian random variable. Then,
Proof.
The probability distribution function for is given by,
It is known that . Now,
3 Algorithms against an Oblivious Adversary
To prove Theorem 2, we first reduce Problem 1 to solving a normalized threshold version of the problem where we assume that initially, the maximum eigenvalue is not much bigger than one. Then we want to maintain a certificate that the maximum eigenvalue is not much less than one until no such certificate exists. This is formalized below.
Problem 12 (DecMaxEV()).
Let be an symmetric PSD matrix such that . The DecMaxEV() problem asks to find for every , a vector such that
or return False indicating that .
We defer the proof of the standard reduction stated below to the appendix.
Lemma 13.
Next, we describe Algorithm 1 which can be viewed as an algorithm for Problem 12 when there are no updates. Our algorithm essentially applies the power iteration, which is a standard algorithm used to find an approximate maximum eigenvalue and eigenvector of a matrix. In the algorithm, we make copies to boost the probability.
Below, we state the guarantees of the power method.
Lemma 14.
Let and . Let be as defined in Line 9 in the execution of PowerMethod(). With probability at least , for some , it holds that . The total time taken by the algorithm is at most .
Furthermore, let and denote the eigenvalues and eigenvectors of . For all such that , with probability at least , .
We note that the last line of the above lemma is saying that the vectors returned by the power method satisfy Property 5, which we state for completeness but is not required by our algorithm. The following result is a direct consequence of Lemma 14.
Corollary 15.
Let . Let be as defined in Line 9 in the execution of PowerMethod(). If , then with probability at least , for some . Furthermore, if , then with probability at least , for some . The total time taken by the algorithm is at most .
Observe that, if the algorithm returns , then for , and is therefore a solution to Problem 12 when there is no update. The power method and its analysis are standard, and we thus defer the proof of Lemma 14 to the appendix.
Next, in Algorithms 2 and 3 we describe an algorithm for Problem 12 when we have an online sequence of updates . The algorithm starts by initializing copies of the approximate maximum eigenvectors from the power method. Given a sequence of updates, as long as one of the copies is the witness that the current matrix still has a large eigenvalue, i.e., there exists where , we can just return as the solution to Problem 12. Otherwise, for all and none of the vectors from the previous call to the power method are a witness of large eigenvalues anymore. In this case, we simply recompute these vectors by calling the power method again. If the power method returns that there is no large eigenvector, then we return False from now. Otherwise, we continue in the same manner. Note that our algorithm is very simple, but as we will see, the analysis is not straightforward.
3.1 Proof Overview
The overall proof of Theorem 2, including the proof of correctness and the runtime depends on the number of executions in Line 4 in Algorithm 3. If the number of executions of Line 4 is bounded by , then the remaining analysis is straightforward. Therefore, the majority of our analysis is dedicated to proving this key lemma, i.e., bound on the number of calls to the power method:
Lemma 16 (Key Lemma).
The number of executions of Line 4 over all updates is bounded by with probability at least .
Given the key lemma, the correctness and runtime analyses are quite straightforward. We now give an overview of the proof of Lemma 16.
Let us consider what happens between two consecutive calls to Line 4, say at and . We first define the following subspaces of and . Recall Definition 8, which we use to define the following subspaces.
Definition 17 (Subspaces of and ).
Given , , and define for :
and,
That is, the space and are spanned by eigenvectors of and , respectively, corresponding to eigenvalues between and .
Let and . Also define,
and let , .
Observe that and similarly . We next define some indices/levels corresponding to large subspaces, which we call “important levels”.
Definition 18 (Important ).
We say a level is important if,
We will use to denote the set of that are important.
The main technical lemma that implies Lemma 16 is the following:
Lemma 19 (Measure of Progress).
Let and let be as defined in Line 9 in the execution of PowerMethod(). Let be a sequence of updates generated by an oblivious adversary and define .
Suppose that and for all . Then, with probability at least , for some ,
-
if , or
-
if .
We prove this lemma in the full version. Intuitively speaking, it means that, whenever Line 4 of Algorithm 3 is executed, there is some important level such that an -fraction of eigenvalues of at level have decreased in value. This is the crucial place where we exploit an oblivious adversary.
Given Lemma 19, the remaining proof of Lemma 16 follows a potential function analysis which is presented in detail in the full version. We consider potentials for . The main observation is that is non-increasing over time for all , and whenever there exists that satisfies the condition of Lemma 19, decreases by . Since and , i.e., , we can prove that decreases by a multiplicative factor of . As a result, every time our algorithm executes Line 4, decreases by a multiplicative factor for some , and since we have at most values of , we can only have executions of Line 4.
It remains to describe how we prove Lemma 19 at a high level. We can write for any as
for . Our strategy is to show that:
() |
Given (3.1) as formalized in the full version, we can conclude Lemma 19 because, from the definition of and , we have that for some , by Corollary 15 and . As a result for this , . Now, by contra-position of (3.1), we have that is large for some .
To prove (3.1), we further decompose as
In the above equation, , and where denote the projections matrices that project any vector onto the spaces , , and respectively444Suppose a subspace is spanned by vectors . Let . Recall that the projection matrix onto is .. Refer to the full version for proof of why such a split is possible. Our proof of (3.1) then bounds the terms on the right-hand side. Let us consider each term separately.
-
1.
: We prove that this is always at most . From the definition of
Since is the projection of along the large eigenspace of , the second term on the right-hand side above is large, i.e. . The first term on the right-hand side can be bounded as, . Therefore the difference on the right-hand side is at most .
-
2.
: Observe that this term corresponds to the projection of along the space spanned by the eigenvalues of of size at most . Let and denote an eigenvector and eigenvalue pair with . Since the power method can guarantee that , we have is tiny. So we have that .
Before we look at the final case, we define a basis for the space .
Definition 20 (Basis for ).
Let be as defined in Definition 17. Define indices and with such that the basis of is given by , where are the eigenvectors of in decreasing order of eigenvalues.
-
3.
: For this discussion, we will ignore the constant factors and assume that the high probability events hold. Let denote the projection matrix for the space . Observe that , where the last inequality is because , and therefore, . Hence, it suffices to bound .
We can write where ’s are the eigenvalues and eigenvectors of and . Define where . That is, . Since , it suffices to show that . We show this in two separate cases. In both cases, we start with the following bound
which holds with high probability. To see this, let be a gaussian vector in the space . We can couple with so that is dominated by . So . By Lemma 10, the norm square of gaussian vector is concentrated to its dimension so with high probability, thus proving the inequality. Next, we will bound in terms of in two cases.
When
From the definition of the important levels, we have
Now, we have because is gaussian and the norm square of gaussian vector is concentrated to its dimension (Lemma 10). Since , we have that
Therefore, we have
where the last inequality is trivial because by definition.
When
From these three cases, we can conclude that if is small for all , then , proving our claim.
We defer the formal proofs of the claims made in this section to the full version.
4 Conditional Lower Bounds for an Adaptive Adversary
In this section, we will prove a conditional hardness result for algorithms against adaptive adversaries. In particular, we will prove Theorem 6. Consider Algorithm 4 for solving Problem 3. The only step in Algorithm 4 whose implementation is not specified is Line 8. We will implement this step using an algorithm for Problem 1.
High-level idea
Overall for our hardness result, we use the idea that an adaptive adversary can use the maximum eigenvectors returned to perform an update. This can happen times and in the process, we would recover the entire eigen-decomposition of the matrix, which is hard. Now consider Algorithm 4. We claim that Algorithm 4 solves Problem 3. At the first glance, this claim looks suspicious because the input matrix for Problem 3 might not be PSD, but the dynamic algorithm for Problem 1 at Line 8 has any guarantees only when the matrices remain PSD. However, the reduction does work by crucially exploiting Property 5. The high-level idea is as follows.
-
If the input matrix is initially PSD, then we can show that remains PSD for all by exploiting Property 5, (see Lemma 21). So, the approximation guarantee of the algorithm at Line 8 is valid at all steps. From this guarantee, must be tiny since we keep decreasing the approximately maximum eigenvalues (see Lemma 22). At the end, the reduction will return .
-
If the input matrix is initially not PSD, there must exist a direction such that . Since in the reduction, we update for some , we must have that . That is, this negative direction remains negative or gets even more negative. It does not matter at all what guarantees the algorithm at Line 8 has. We still have that cannot be tiny. We can distinguish whether is tiny or not using the static power method at Line 11, and, hence, we will return False in this case (see Lemma 22).
Analysis
We prove the guarantees of the output of Algorithm 4 when ’s satisfy Property 5 for all .
Lemma 21.
In Algorithm 4, let ’s, be generated such that they additionally satisfy Property 5. If , then for all .
We would like to point out that our parameter is quite large. This just implies that our reduction can work even if we find crude approximations to the maximum eigenvector as long as this is along the directions with large eigenvalue, since also has to satisfy Property 5. We defer the proof of the above to the Appendix.
Lemma 22.
In Algorithm 4, let ’s, be generated such that they additionally satisfy Property 5.
-
If , then Algorithm 4 returns such that .
-
If is not psd, then Algorithm 4 returns False.
Proof of Theorem 6
We are now ready to prove our conditional lower bound.
Proof.
Let denote an algorithm for Problem 1 that maintains an -max eigenvalue (1), , and eigenvector (2), , for matrices such that ’s satisfy Property 5. We will show that if the total update time of is , then there is an -time algorithm for Problem 3 which contradicts Hypothesis 4.
Given an instance of Problem 3, we will run Algorithm 4 where Line 8 is implemented using . We will generate the input and the update sequence for as follows. Set . Set and according to Algorithm 4. For , we set according to Line 7 of Algorithm 4. We note that this is a valid update sequence for Problem 1 when since from Lemma 21, if then, .
Now, we describe what we return as an answer for Problem 3. From Lemma 22 if is not PSD, then Algorithm 4 returns False and reports the matrix is not PSD. Additionally if , the algorithm returns as a certificate that is PSD. This completes the reduction from Problem 3 to Problem 1.
The total time required by the reduction is
which is at most when .
To conclude, we indeed obtain an -time algorithm for Problem 3. Assuming Hypothesis 4, the algorithm cannot have total update time.
5 Conclusion and Open Problems
Upper Bounds
We have presented a novel extension of the power method to the dynamic setting. Our algorithm from Theorem 2 maintains a multiplicative -approximate maximum eigenvalue and eigenvector of a positive semi-definite matrix that undergoes decremental updates from an oblivious adversary. The algorithm has polylogarithmic amortized update time per non-zeros in the updates.
Our algorithm is simple, but our analysis is quite involved. While we believe a tighter analysis that improves our logarithmic factors is possible, it is an interesting open problem to give a simpler analysis for our algorithm. Other natural questions are whether we can get similar algorithms in incremental or fully dynamic settings and whether one can get a worst-case update time.
Lower Bounds
We have shown a conditional lower bound for a class of algorithms against an adaptive adversary in Theorem 6. It would also be very exciting to generalize our lower bound to hold for any algorithm against an adaptive adversary, as that would imply an oblivious-vs-adaptive separation for a natural dynamic problem.
Incremental Updates
We believe that the corresponding incremental updates problem, i.e., we update the matrix as cannot be solved in polylogarithmic amortized update time, even when the update sequence ’s are from an oblivious adversary. At a high level, the incremental version of our problem seems significantly harder for the following reasons. When we perform decremental updates to a matrix, the new maximum eigenvector must be a part of the eigenspace spanned by the original maximum eigenvectors. Furthermore, it is easy to detect whether the maximum eigenvalue has gone down as we have shown in our paper. For the incremental setting, it is possible that after an update the maximum eigenvalue has gone up and the new maximum eigenvector is a direction that was not the previous one or the update direction and in such cases we cannot really detect this quickly with known information on previous eigenvectors and update directions. This can also happen times and in every such case, we have to compute the eigenvalue and eigenvector from scratch. Therefore, we leave lower bounds and algorithms for incremental setting as an open problem.
Dynamic SDPs
As discussed in Appendix A, Theorem 2 can be viewed as a starting point towards a dynamic algorithm for general positive semi-definite programs. Can we make further progress? The dynamic semi-definite program problem, even with just two matrix constraints, already seems to be challenging.
One promising approach to attack this problem is to dynamize the matrix multiplicative weight update (MMWU) method for solving a packing/covering SDP [23] since the corresponding approach was successful for linear programs – the near-optimal algorithms of [11] are essentially dynamized multiplicative weight update methods for positive linear programs. However, in our preliminary study exploring this approach, we could only obtain an algorithm that solves Problem 24, which has a single matrix constraint, and solves Problem 1 partially, i.e., maintains an approximate eigenvalue only. The main barrier in this approach is that the algorithm requires maintaining the exponential of the sum of the constraint matrices, and to do this fast, we require that for any two constraint matrices and , which only holds when and commute i.e., . Note that when and are diagonal, this is true; therefore, we can obtain the required algorithms for positive LPs. Even when we have just two constraint matrices where one of them is a diagonal matrix, this remains an issue as the matrices still do not commute.
References
- [1] Zeyuan Allen-Zhu, Yin Tat Lee, and Lorenzo Orecchia. Using optimization to obtain a width-independent, parallel, simpler, and faster positive sdp solver. In Proceedings of the twenty-seventh annual ACM-SIAM symposium on Discrete algorithms, pages 1824–1831. SIAM, 2016. doi:10.1137/1.9781611974331.CH127.
- [2] Zeyuan Allen-Zhu and Yuanzhi Li. First efficient convergence for streaming -pca: a global, gap-free, and near-optimal rate. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 487–492. IEEE, 2017. doi:10.1109/FOCS.2017.51.
- [3] Zeyuan Allen-Zhu and Lorenzo Orecchia. Nearly-linear time positive lp solver with faster convergence rate. In Proceedings of the forty-seventh annual ACM symposium on Theory of Computing, pages 229–236, 2015. doi:10.1145/2746539.2746573.
- [4] Zeyuan Allen-Zhu and Lorenzo Orecchia. Nearly linear-time packing and covering lp solvers: Achieving width-independence and-convergence. Mathematical Programming, 175:307–353, 2019. doi:10.1007/S10107-018-1244-X.
- [5] Peter Arbenz, Walter Gander, and Gene H Golub. Restricted rank modification of the symmetric eigenvalue problem: Theoretical considerations. Linear Algebra and its Applications, 104:75–95, 1988.
- [6] Sanjeev Arora and Satyen Kale. A combinatorial, primal-dual approach to semidefinite programs. In Proceedings of the thirty-ninth annual ACM symposium on Theory of computing, pages 227–236, 2007. doi:10.1145/1250790.1250823.
- [7] Jess Banks, Jorge Garza-Vargas, Archit Kulkarni, and Nikhil Srivastava. Pseudospectral shattering, the sign function, and diagonalization in nearly matrix multiplication time. Foundations of Computational Mathematics, pages 1–89, 2022.
- [8] MohammadHossein Bateni, Hossein Esfandiari, Hendrik Fichtenberger, Monika Henzinger, Rajesh Jayaram, Vahab Mirrokni, and Andreas Wiese. Optimal fully dynamic k-center clustering for adaptive and oblivious adversaries. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2677–2727. SIAM, 2023. doi:10.1137/1.9781611977554.CH101.
- [9] Amos Beimel, Haim Kaplan, Yishay Mansour, Kobbi Nissim, Thatchaphol Saranurak, and Uri Stemmer. Dynamic algorithms against an adaptive adversary: Generic constructions and lower bounds. In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing, pages 1671–1684, 2022. doi:10.1145/3519935.3520064.
- [10] Rajarshi Bhattacharjee, Gregory Dexter, Cameron Musco, Archan Ray, and David P Woodruff. Universal matrix sparsifiers and fast deterministic algorithms for linear algebra. arXiv preprint arXiv:2305.05826, 2023.
- [11] Sayan Bhattacharya, Peter Kiss, and Thatchaphol Saranurak. Dynamic algorithms for packing-covering lps via multiplicative weight updates. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1–47. SIAM, 2023. doi:10.1137/1.9781611977554.CH1.
- [12] James R Bunch, Christopher P Nielsen, and Danny C Sorensen. Rank-one modification of the symmetric eigenproblem. Numerische Mathematik, 31(1):31–48, 1978.
- [13] Gene H Golub. Some modified matrix eigenvalue problems. SIAM review, 15(2):318–334, 1973.
- [14] Garud Iyengar, David J Phillips, and Cliff Stein. Feasible and accurate algorithms for covering semidefinite programs. In Scandinavian Workshop on Algorithm Theory, pages 150–162. Springer, 2010.
- [15] Garud Iyengar, David J Phillips, and Clifford Stein. Approximating semidefinite packing programs. SIAM Journal on Optimization, 21(1):231–268, 2011. doi:10.1137/090762671.
- [16] Arun Jambulapati, Yin Tat Lee, Jerry Li, Swati Padmanabhan, and Kevin Tian. Positive semidefinite programming: Mixed, parallel, and width-independent, 2021. arXiv:2002.04830.
- [17] Philip Klein and Hsueh-I Lu. Efficient approximation algorithms for semidefinite programs arising from max cut and coloring. In Proceedings of the twenty-eighth annual ACM symposium on Theory of computing, pages 338–347, 1996. doi:10.1145/237814.237980.
- [18] Beatrice Laurent and Pascal Massart. Adaptive estimation of a quadratic functional by model selection. Annals of statistics, pages 1302–1338, 2000.
- [19] Yin Tat Lee and He Sun. An sdp-based algorithm for linear-sized spectral sparsification. In Proceedings of the 49th annual acm sigact symposium on theory of computing, pages 678–687, 2017. doi:10.1145/3055399.3055477.
- [20] Michael Luby and Noam Nisan. A parallel approximation algorithm for positive linear programming. In Proceedings of the twenty-fifth annual ACM symposium on Theory of computing, pages 448–457, 1993. doi:10.1145/167088.167211.
- [21] Roy Mitz, Nir Sharon, and Yoel Shkolnisky. Symmetric rank-one updates from partial spectrum with an application to out-of-sample extension. SIAM Journal on Matrix Analysis and Applications, 40(3):973–997, 2019. doi:10.1137/18M1172120.
- [22] Lorenzo Orecchia, Sushant Sachdeva, and Nisheeth K Vishnoi. Approximating the exponential, the lanczos method and an o (m)-time spectral algorithm for balanced separator. In Proceedings of the forty-fourth annual ACM symposium on Theory of computing, pages 1141–1160, 2012. doi:10.1145/2213977.2214080.
- [23] Richard Peng, Kanat Tangwongsan, and Peng Zhang. Faster and simpler width-independent parallel algorithms for positive semidefinite programming. In Proceedings of the twenty-fourth annual ACM symposium on Parallelism in algorithms and architectures, pages 101–108, 2012.
- [24] Serge A Plotkin, David B Shmoys, and Éva Tardos. Fast approximation algorithms for fractional packing and covering problems. Mathematics of Operations Research, 20(2):257–301, 1995. doi:10.1287/MOOR.20.2.257.
- [25] Kent Quanrud. Nearly linear time approximations for mixed packing and covering problems without data structures or randomization. In Symposium on Simplicity in Algorithms, pages 69–80. SIAM, 2020. doi:10.1137/1.9781611976014.11.
- [26] Piotr Sankowski. Dynamic transitive closure via dynamic matrix inverse. In 45th Annual IEEE Symposium on Foundations of Computer Science, pages 509–517. IEEE, 2004.
- [27] Peter Stange. On the efficient update of the singular value decomposition. In PAMM: Proceedings in Applied Mathematics and Mechanics, volume 8, pages 10827–10828. Wiley Online Library, 2008.
- [28] William Swartworth and David P Woodruff. Optimal eigenvalue approximation via sketching. In Proceedings of the 55th Annual ACM Symposium on Theory of Computing, pages 145–155, 2023. doi:10.1145/3564246.3585102.
- [29] Lloyd N Trefethen and David Bau. Numerical linear algebra, volume 181. Siam, 2022.
- [30] Luca Trevisan. Parallel approximation algorithms by positive linear programming. Algorithmica, 21(1):72–88, 1998. doi:10.1007/PL00009209.
- [31] Luca Trevisan. Max cut and the smallest eigenvalue. In Proceedings of the forty-first annual ACM symposium on Theory of computing, pages 263–272, 2009. doi:10.1145/1536414.1536452.
- [32] Jan van den Brand, Danupon Nanongkai, and Thatchaphol Saranurak. Dynamic matrix inverse: Improved algorithms and matching conditional lower bounds. In 2019 IEEE 60th Annual Symposium on Foundations of Computer Science (FOCS), pages 456–480. IEEE, 2019. doi:10.1109/FOCS.2019.00036.
- [33] Di Wang, Satish Rao, and Michael W Mahoney. Unified acceleration method for packing and covering problems via diameter reduction. In 43rd International Colloquium on Automata, Languages, and Programming (ICALP 2016). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016.
Appendix A Connections to Dynamic Positive Semi-definite Programs
This section discusses connections between our Problem 1 and the dynamic versions of positive semi-definite programs. Using this connection, we conclude that Theorem 2 implies a dynamic algorithm for a special case of the dynamic covering SDP problem.
We first define packing and covering semi-definite programs (SDPs).555Some papers [16] flip our definition of packing and covering SDPs by considering their dual form.
Definition 23 (Packing/Covering SDP).
Let ’s for be symmetric PSD matrices and ’s denote positive real numbers. The packing SDP problem asks to find
The covering SDP problem asks to find
Note that when the matrices and ’s are all diagonal matrices, the packing and covering SDP problems above are precisely the well-studied packing and covering LP problems, respectively. Near-linear time algorithms for -approximately solving packing and covering LPs are very well-studied in a long line of work, some of which are [3, 4, 33, 25], and these problems have many applications, such as in graph embedding [24], approximation algorithms [20, 30], scheduling [24], to name a few.
Dynamic LPs
Near-optimal dynamic algorithms for packing and covering LPs were shown in [11]. The paper studies two kinds of updates – restricting and relaxing updates. Restricting updates can only shrink the feasible region. In contrast, relaxing updates can only grow the feasible region. In [11], the authors gave a deterministic algorithm that can maintain a -approximate solution to either packing and covering LPs that undergo only restricting updates or only relaxing updates in total time , where is the total number of nonzeros in the initial input and the updates, and is the number of updates. Hence, this is optimal up to logarithmic factors.
A natural question is whether one can generalize the near-optimal dynamic LP algorithms with polylogarithmic overhead by [11] to work with SDPs since SDPs capture many further applications such as maximum cuts [15, 17], Sparse PCA [15], sparsest cuts [14], and balanced separators [22], among many others.
Static SDPs
Unfortunately, the algorithms for solving packing and covering SDPs are much more limited, even in the static setting. Near-linear time algorithms are known only for covering SDPs when the cost matrix is the identity [23, 1].
The fundamental barrier to working with general psd matrix in covering SDPs is that it is as hard as approximating the minimum eigenvalue of (consider the program such that ). To the best of our knowledge, near-linear time algorithms for approximating the minimum eigenvalue assume a near-linear-time solver for , i.e., to compute in the near-linear time given . This can be done, for example, by applying the power method to . When admits a fast solver, sometimes one can approximately solve a covering SDP fast, such as for spectral sparsification of graphs [19], and the max-cut problem [6, 31].
For packing SDPs, there is simply no near-linear time algorithm known. An algorithm for approximately solving packing SDPs and even the generalization to mixed packing-covering SDPs was claimed in [16], but there is an issue in the convergence analysis even for pure packing SDPs. Fast algorithms for this problem, hence, remain open.
Dynamic SDPs
Since near-linear time static algorithms are prerequisites for dynamic algorithms with polylogarithmic overhead, we can only hope for a dynamic algorithm for covering SDPs when is an identity. Below, we will show that our algorithm for Theorem 2 implies a dynamic algorithm for maintaining the covering SDP solution when there is a single constraint and the updates are restricting. This follows because this problem is equivalence to Problem 1.
We first define the dynamic covering problem with a single constraint under restricting updates.
Problem 24 (Covering SDP with a Single Matrix Constraint under Restricting Updates).
Given , an accuracy parameter , and an online sequence of vectors that update such that . The problem asks to explicitly maintain, for all , an -approximate optimal value of the SDP, i.e.,
Furthermore, given a query request, return a matrix where is a -approximate optimal solution, i.e.,
Problem 24 is equivalent to Problem 1 in the following sense: given an algorithm for Problem 1, we can obtain an algorithm for Problem 24 with the same total update time and optimal query time. Conversely, given an algorithm for Problem 24, we can obtain an algorithm for Problem 1 in the eigenvalue-only version with the same total update time.
Proposition 25.
The following holds,
- 1.
- 2.
Proof.
Let us first characterize the solution to Problem 24 at any for . Since any feasible solution is PSD it can be characterized as, for some unit vectors ’s. Now and
The above implies that for any feasible solution , it must hold that , and equality holds iff ’s are the maximum eigenvector of for all . Since the problem is asking to minimize , the solution must be where is the maximum eigenvector of . Note that here .
We now show the first part, by proving that at any , given , the solution to Problem 1 gives a solution to Problem 24. Let and denote an -approximate solution to Problem 1 for some . Consider the solution which gives . Then,
Therefore, satisfies the constraints of Problem 24. Next we look at the objective value, We can maintain by just maintaining which requires no extra time. The time required to obtain , which is the query time, from and is at most and the value of can be obtained in time.
To see the other direction, consider the solution , of Problem 24. We can set . This implies that,
as required. In this case, we do not require any extra time.
By plugging Theorem 2 into Proposition 25, we conclude the following.
Corollary 26.
There is a randomized algorithm for Problem 24 under a sequence of restricting updates, that given and as input, with probability at least works against an oblivious adversary in total update time
and query time .