arxiv: v1 [quant-ph] 4 May 2017

Transcription

1 Quantum SDP-Solvers: Better upper and lower bounds Joran van Apeldoorn András Gilyén Sander Gribling Ronald de Wolf arxiv: v1 [quant-ph] 4 May 2017 Abstract Brandão and Svore [BS16] very recently gave quantum algorithms for approximately solving semidefinite programs, which in some regimes are faster than the best-possible classical algorithms in terms of the dimension n of the problem and the number m of constraints, but worse in terms of various other parameters. In this paper we improve their algorithms in several ways, getting better dependence on those other parameters. To this end we develop new techniques for quantum algorithms, for instance a general way to efficiently implement smooth functions of sparse Hamiltonians, and a generalized minimum-finding procedure. We also show limits on this approach to quantum SDP-solvers, for instance for combinatorial optimizations problems that have a lot of symmetry. Finally, we prove some general lower bounds showing that in the worst case, the complexity of every quantum LP-solver and hence also SDP-solver) has to scale linearly with mn when m n, which is the same as classical. QuSoft, CWI, the Netherlands. The work was supported by the Netherlands Organization for Scientific Research, grant number QuSoft, CWI, the Netherlands. Supported by ERC Consolidator Grant QPROGRESS. QuSoft, CWI, the Netherlands. The work was supported by the Netherlands Organization for Scientific Research, grant number QuSoft, CWI and University of Amsterdam, the Netherlands. Partially supported by ERC Consolidator Grant QPROGRESS. 1

3 1 Introduction 1.1 Semidefinite programs In the last decades, particularly since the work of Grötschel, Lovász, and Schrijver[GLS88], semidefinite programs SDPs) have become an important tool for designing efficient optimization and approximation algorithms. SDPs generalize and strengthen the better-known linear programs LPs), but like LPs) they are still efficiently solvable. The basic form of an SDP is the following: max TrCX) 1) s.t. TrA j X) b j X 0, for all j [m], where[m] := {1,...,m}. TheinputtotheproblemconsistsofHermitiann nmatricesc,a 1,...,A m and reals b 1,...,b m. For normalization purposes we assume C, A j 1. The number of constraints is m we do not count the standard X 0 constraint for this). The variable X of this SDP is an n n positive semidefinite psd) matrix. LPs correspond to the case where all matrices are diagonal. A famous example is the algorithm of Goemans and Williamson [GW95] for approximating the size of a maximum cut in a graph G = [n],e): the maximum, over all subsets S of vertices, of the number of edges between S and its complement S. Computing MAXCUTG) exactly is NP-hard. It corresponds to the following integer program max 1 2 {i,j} E 1 v i v j ) s.t. v j {+1, 1} for all j [n], using the fact that 1 v i v j )/2 = 1 if v i and v j are different signs, and 1 v i v j )/2 = 0 if they are the same. We can relax this integer program by replacing the signs v j by unit vectors, and replacing the product v i v j in the objective function by the dot product v T i v j. We can implicitly optimize over such vectors of unspecified dimension) by explicitly optimizing over an n n psd matrix X whose diagonal entries are 1. This X is the Gram matrix corresponding to the vectors v 1,...,v n, so X ij = v T i v j. The resulting SDP is max 1 2 {i,j} E 1 X ij ) s.t. TrE jj X) = 1 for all j [n], X 0, where E jj is the n n matrix that has a 1 at the j,j)-entry, and 0s elsewhere. This SDP is a relaxation of a maximization problem, so it may overshoot the correct value, but Goemans and Williamson showed that an optimal solution to the SDP can be rounded to a cut in G whose size is within a factor of MAXCUTG). 1 This SDP can be massaged into the form of 1) by replacing the equality TrE jj X) = 1 by inequality TrE jj X) 1 so m = n) and letting C be a properly normalized version of the Laplacian of G. 1 Amazingly, their approximation factor is exactly optimal under the Unique Games Conjecture [KKMO07]. 3

4 1.2 Classical solvers for LPs and SDPs Ever since Dantzig s development of the simplex algorithm for solving LPs in the 1940s [Dan51], much work has gone into finding faster solvers, first for LPs and then also for SDPs. The simplex algorithm for LPs with some reasonable pivot rule) is usually fast in practice, but has worst-case exponential runtime. Ellipsoid methods and interior-point methods can solve LPs and SDPs in polynomial time; they will typically approximate the optimal value to arbitrary precision. The best known general SDP-solvers [LSW15] approximate the optimal value OPT of such an SDP up to additive error ε, with complexity Omm 2 +n ω +mns)log O1) mnr/ε)), where ω [2, 2.373) is the still unknown) optimal exponent for matrix multiplication; s is the sparsity: the maximal number of non-zero entries per row of the input matrices; and R is an upper bound on the trace of an optimal X. 2 The assumption here is that the rows and columns of the matrices of SDP 1) can be accessed as adjacency lists: we can query, say, the lth non-zero entry of the kth row of A j in constant time. Arora and Kale[AK16]see also[ahk12]) gave an alternative way to approximate OPT, using a matrix version of the multiplicative weights update method. In Section 2.1 we will describe their framework in more detail, but in order to describe our result we will start with an overly simplified sketch here. The algorithm goes back and forth between candidate solutions to the primal SDP and to the corresponding dual SDP, whose variables are non-negative reals y 1,...,y m : min b T y 2) m s.t. y j A j C 0, y 0. Under assumptions that will be satisfied everywhere in this paper, strong duality applies: the primal SDP 1) and dual SDP 2) will have the same optimal value OPT. The algorithm does a binary search for OPT by trying different guesses α for it. Suppose we have fixed some α, and want to find out whether α is bigger or smaller than OPT. Start with some candidate solution X 1) for the primal, for example a multiple of the identity matrix X 1) has to be psd but need not be a feasible solution to the primal). This X 1) induces the following polytope: P ε X 1) ) := {y R m : b T y α, Tr m ) y j A j C y 0}. X 1) ε, This polytope can be thought of as a relaxation of the feasible region of the dual SDP with the extra constraint that OPT α: instead of requiring that j y ja j C is psd, we merely require that its inner product with the particular psd matrix X 1) is not too negative. The algorithm 2 See Lee, Sidford, and Wong [LSW15, Section 10.2 of arxiv version], and note that our m,n are their n,m, their S is our mns, and their M is our R. 4

5 then calls an oracle that provides a y 1) P ε X 1) ), or outputs fail if P 0 X 1) ) is empty how to efficiently implement such an oracle depends on the application). In the fail case we know there is no dual-feasible y with objective value α, so we can increase our guess α for OPT, and restart. In case the oracle produced a y 1), this is used to define a Hermitian matrix H 1) and a new candidate solution X 2) for the primal, which is proportional to e H1). Then the oracle for the polytope P ε X 2) ) induced by this X 2) is called to produce a candidate y 2) P ε X 2) ) for the dual or fail ), this is used to define H 2) and X 3) proportional to e H2), and so on. Surprisingly, the average of the dual candidates y 1),y 2),... converges to a nearly-dual-feasible solution. Let R be an upper bound on the trace of an optimal X of the primal, r be an upper bound on the sum of entries of an optimal y for the dual, and w be the width of the oracle for a certain SDP: the maximum of m y ja j C over all psd matrices X and all vectors y that the oracle may output for the corresponding polytope P ε X). In general we will not know the width of an oracle exactly, but only an upper bound w w, that may depend on the SDP; this is, however, enough for the Arora-Kale framework. In Section 2.1 we will show that without loss of generality we can assume the oracle returns a y such that y 1 r. Because we assumed A j, C 1, we have w r +1 as an easy width-bound. General properties of the multiplicative weights update method guarantee that after T = Õw2 R 2 /ε 2 ) iterations 3, if no oracle call yielded fail, then the vector 1 T T t=1 yt) is close to dual-feasible and satisfies b T y α. This vector can then be turned into a dual-feasible solution by tweaking its first coordinate, certifying that OPT α+ε, and we can decrease our guess α for OPT accordingly. The framework of Arora and Kale is really a meta-algorithm, because it does not specify how to implement the oracle. They themselves provide oracles that are optimized for special cases, which allows them to give a very low width-bound for these specific SDPs. For example for the MAXCUT SDP, they obtain a solver with near-linear runtime in the number of edges of the graph. They also observed that the algorithm can be made more efficient by not explicitly calculating the matrix X t) in each iteration: the algorithm can still be made to work if instead of providing the oracle with X t), we feed it good estimates of TrA j X t) ) and TrCX t) ). Arora and Kale do not describe oracles for general SDPs, but as we show at the end of Section 2.4 using Appendix A to estimate TrA j X t) ) and TrCX t) )), one can get a general SDP-solver in their framework with complexity ) Rr 4 ) ) Rr 7 Õ nms +ns. 3) ε ε Compared to the complexity of the SDP-solver of [LSW15], this has much worse dependence on R and ε, but better dependence on m and n. Using the Arora-Kale framework is thus preferable over standardsdp-solvers for thecasewhererr is small comparedto mn, andaroughapproximation to OPT say, small constant ε) is good enough. It should be noted that for many specific cases, Arora and Kale get significantly better upper bounds than 3) by designing oracles that are specifically optimized for those cases. 1.3 Quantum SDP-solvers: the Brandão-Svore algorithm Given the speed-ups that quantum computers give over classical computers for various problems [Sho97, Gro96, DHHM06, Amb07, HHL09], it is natural to ask whether quantum computers 3 The Õ ) notation hides polylogarithmic factors in all parameters. 5

6 can solve LPs and SDPs more efficiently as well. Very little was known about this, until very recently Brandão and Svore [BS16] discovered quantum algorithms that significantly outperform classical SDP-solvers in certain regimes. Because of the general importance of quickly solving LPs and SDPs, and the limited number of quantum algorithms that have been found so far, this is a very interesting development. The key idea of the Brandão-Svore algorithm is to take the Arora-Kale approach and to replace two of its steps by more efficient quantum subroutines. First, given a vector y t 1), it turns out one can use Gibbs sampling to prepare the new primal candidate X t) e Ht 1) as a logn)-qubit quantum state ρ t) := X t) /TrX t) ) in much less time than needed to compute X t) as an n n matrix. Second, one can efficiently implement the oracle for P ε X t) ) based on a number of copies of ρ t), using those copies to estimate TrA j ρ t) ) and TrA j X t) ) when needed note that TrAρ) is the expectation value of operator A for the quantum state ρ). This is based on something called Jaynes s principle. The resulting oracle is weaker than what is used classically, in the sense that it outputs a sample j y j / y 1 rather than the whole vector y. However, such sampling still suffices to make the algorithm work it also means we can assume the vector y t) to be quite sparse). Using these ideas, Brandão and Svore obtain a quantum SDP-solver of complexity Õ mns 2 R 32 /δ 18 ), with multiplicative error 1 ± δ for the special case where b j 1 for all j [m], and OPT 1 the latter assumption allows them to convert additive error ε to multiplicative error δ) [BS16, Corollary5inarXivversion4]. TheydescribeareductiontotransformageneralSDPoftheform1) to this special case, but that reduction significantly worsens the dependence of the complexity on the parameters R, r, and δ. Note that compared to the runtime 3) of our general instantiation of the original Arora-Kale framework, there are quadratic improvements in both m and n, corresponding to the two quantum modifications made to Arora-Kale. However, the dependence on R, r, s and 1/ε is much worse now than in 3). This quantum algorithm thus provides a speed-up only in situations where R,r,s,1/ε are fairly small compared to mn and to be honest, neither we nor Brandão and Svore have particularly good examples of such SDPs). 1.4 Our results In this paper we present two sets of results: improvements to the Brandão-Svore algorithm, and better lower bounds for the complexity of quantum LP-solvers and hence for quantum SDP-solvers as well) Improved quantum SDP-solver Our quantum SDP-solver, like the Brandão-Svore algorithm, works by quantizing some aspects of the Arora-Kale algorithm. However, the way we quantize is different and faster than theirs. First, we give a more efficient procedure to estimate the quantities TrA j ρ t) ) required by the oracle. Instead of first preparing some copies of Gibbs state ρ t) e Ht 1) as a mixed state, we coherently prepare a purification of ρ t), which can then be used to estimate TrA j ρ t) ) more efficiently using amplitude-estimation techniques. Also, our purified Gibbs sampler has logarithmic dependence on the error, which is exponentially better than the Gibbs sampler of Poulin and Wocjan [PW09b] that Brandão and Svore invoke. Chowdhury and Somma [CS16] also gave a 6

7 Gibbs sampler with logarithmic error-dependence, but assuming query access to the entries of H rather than H itself. Second, we have a different implementation of the oracle, without using Gibbs sampling or Jaynes s principle though, as mentioned above, we still use purified Gibbs sampling for approximating the TrAρ) quantities). We observe that the vector y t) can be made very sparse: two non-zero entries suffice. 4 We then show how we can efficiently find such a 2-sparse vector rather than merely sampling from it) using two applications of the well-known quantum minimum-finding algorithm of Dürr and Høyer [DH96], which is based on Grover search [Gro96]. These modifications both simplify and speed up the quantum SDP-solver, resulting in complexity Õ mns 2 Rr/ε) 8 ). The dependence on m, n, and s is the same as in Brandão-Svore, but our dependence on R, r, and 1/ε is substantially better. Note that each of the three parameters R, r, and 1/ε now occurs with the same 8th power in the complexity. This is no coincidence: as we show in Appendix E, these three parameters can all be traded for one another, in the sense that we can massage the SDP to make each one of them small at the expense of making the others proportionally bigger. These trade-offs suggest we should actually think of Rr/ε as one parameter of the primal-dual pair of SDPs, not three separate parameters. For the special case of LPs, we can improve the runtime to Õ mns 2 Rr/ε) 5 ). Like in Brandão-Svore, our quantum oracle produces very sparse vectors y, in our case even of sparsity 2. This means that after T iterations, the final ε-optimal dual-feasible vector which is a slightly tweaked version of the average of the T y-vectors produced in the T iterations) has only OT) non-zero entries. Such sparse vectors have some advantages, for example they take much less space to store than arbitrary y R m. However, this sparsity of the algorithm s output also points to a weakness of these methods: if every ε-optimal dual-feasible vector y has many non-zero entries, then the number of iterations needs to be large. For example, if every ε-optimal dual-feasible vector y has Ωm) non-zero entries, then these methods require T = Ωm) iterations before they can reach an ε-optimal dual-feasible vector. As we show in Section 3, this will actually be the case for families of SDPs that have a lot of symmetry Tools that may be of more general interest Along the way to our improved SDP-solver, we developed some new techniques that may be of independent interest. These are mostly tucked away in appendices, but here we will highlight two. Implementing smooth functions of a given Hamiltonian. In Appendix B we describe a general technique to apply a function fh) of a sparsehamiltonian H to a given state φ. Roughly speaking, whatthismeansisthatwewantaunitarycircuitthatmaps 0 φ to 0 fh) φ + 1. If need be, we can then combine this with amplitude amplification to boost the 0 fh) φ part of the state. If the function f : R C can be approximated well by a low-degree Fourier series, then our 4 Independentlyof us, Ben David, Eldar, Garg, Kothari, Natarajan, and Wright at MIT), and separately Ambainis observed that in the special case where all b i are at least 1, the oracle can even be made 1-sparse, and the one entry can be found using one Grover search over m points in both cases personal communication 2017). The same happens implicitly in our Section 2.3 in this case. 7

8 preparation will be efficient in the sense of using few queries to H and few other gates. The novelty of our approach is that we construct a good Fourier series from the polynomial that approximates f for example a truncated Taylor series for f). Our Theorem 40 can be easily applied to various smooth functions without using involved integral approximations, unlike previous works building on similar techniques. Our most general result Corollary 42 only requires that the function f can be nicely approximated locally around each possible eigenvalues of H, improving on Theorem 40. In this paper we mostly care about the function fx) = e x, which is what we want for generating a purification of the Gibbs state corresponding to H; and the function fx) = x, which is what we use for estimating quantities like TrAρ). However, our techniques apply much more generally than these two functions. For example, they also simplify the analysis of the improved linear-systems solver of Childs et al. [CKS15], where the relevant function is fx) = 1/x. As in their work, the Linear Combination of Unitaries Lemma of Berry et al. [BCC + 15, BCK15] is a crucial tool for us. A generalized minimum-finding algorithm. Dürr and Høyer [DH96] showed how to find the minimal value of a function f : [N] R using O N) queries to f, by repeatedly using Grover search to find smaller and smaller elements of the range of f. In Appendix C we describe a more general minimum-finding procedure. Suppose we have a unitary U which prepares a quantum state U 0 = N k=1 ψ k x k. Our procedure can find the minimum value x k among the x k s that have support in the second register, using roughly O1/ ψ k ) applications of U and U 1. Also upon finding the minimal value k the procedure actually outputs the state ψ k x k. This immediately gives the Dürr-Høyer result as a special case, if we take U to produce U 0 = 1 N N k=1 k fk) using one query to f. More interestingly for us, if we combine our minimum-finder with a U that does phase-estimation on one half of a maximally entangled state, we obtain an algorithm for estimating the smallest eigenvalue of a given n-dimensional Hamiltonian H, using roughly O n) applications of phase estimation with unitary e ih. Note that, unlike the Dürr-Høyer procedure, this does not assume query access to the individual eigenvalues. A similar result on approximating the smallest eigenvalue ofahamiltonian was alreadyshownbypoulinandwocjan [PW09a], butweimproveontheanalysis to be able to apply it as a subroutine in our procedure to estimate TrA j ρ) Lower bounds What about lower bounds for quantum SDP-solvers? Brandão and Svore already proved a lower bound saying that a quantum SDP-solver has to make Ω n+ m) queries to the input matrices, for some SDPs. Their lower bound is for a family of SDPs where s,r,r,1/ε are all constant, and is by reduction from a search problem. In this paper we prove lower bounds that are quantitatively stronger in m and n, but for SDPs with non-constant R and r. The key idea is to consider a Boolean function F on N = abc input bits that is the composition of an a-bit majority function with a b-bit OR function with a c-bit majority function. The known quantum query complexities of majority and OR, combined with composition properties of the adversary lower bound, imply that every quantum algorithm that computes this functions requires Ωa bc) queries. We define a family of LPs, with constant 1/ε but non-constant r and R we could massage this to make R or r constant using the results of Appendix E, but not Rr/ε), such that constant-error approximation of OPT computes F. Choosing a, b, and c 8

9 appropriately, this implies a lower bound of ) Ω max{n,m}min{n,m}) 3/2 queries to the entries of the input matrices for quantum LP-solvers. Since LPs are SDPs with sparsity s = 1, we get the same lower bound for quantum SDP-solvers. If m and n are of the same order, this lower bound is Ωmn), the same scaling with mn as the classical general instantiation of Arora-Kale 3). In particular, this shows that we cannot have an O mn) upper bound without simultaneously having polynomial dependence on Rr/ε. Organization. The paper is organized as follows. In Section 2 we start with a description of the Arora-Kale framework for SDP-solvers, and then we describe how to quantize different aspects of it to obtain a quantum SDP-solver with better dependenceon R, r, and 1/ε or rather, on Rr/ε) than Brandão and Svore got. In Section 3 we describe the limitations of primal-dual SDP-solvers using general oracles not optimized for specific SDPs) that produce sparse dual solutions y: if good solutions are dense, this puts a lower bound on the number of iterations needed. In Section 4 we give our lower bounds. A number of the proofs are relegated to the appendices: how to classically approximate TrA j ρ) Appendix A), how to efficiently implement smooth functions of Hamiltonians on a quantum computer Appendix B), our generalized method for minimum-finding Appendix C), upper and lower bounds on how efficiently we can query entries of sums of sparse matrices Appendix D), how to trade off R, r, and 1/ε against each other Appendix E), and the composition property of the adversary method that we need for our lower bounds Appendix F). 2 An improved quantum SDP-solver Here we describe our quantum SDP-solver. In Section 2.1 we describe the framework designed by Arora and Kale for solving semidefinite programs. As in the recent work by Brandão and Svore, we use this framework to design an efficient quantum algorithm for solving SDPs. In particular, we show that the key subroutine needed in the Arora-Kale framework can be implemented efficiently on a quantum computer. Our implementation uses different techniques than the quantum algorithm of Brandão and Svore, allowing us to obtain a faster algorithm. The techniques required for this subroutine are developed in Sections 2.2 and 2.3. In Section 2.4 we put everything together to prove the main theorem of this section the notation is explained below): Theorem 1. Instantiating Meta-Algorithm 1 using the trace calculation algorithm from Section 2.2 and the oracle from Section 2.3 with width bound w := r+1), and using this to do a binary search for OPT [ R,R] using different guesses α for OPT), gives a quantum algorithm for solving SDPs of the form 1), which with high probability) produces a feasible solution y to the dual program which is optimal up to an additive error ε, and uses Õ nms 2 Rr ε ) 8 ) queries to the input matrices and the same number of other gates. 9

10 Notation/Assumptions. We use log to denote the logarithm in base 2. Throughout we assume each element of the input matrices can be represented by a bitstring of size polylogn,logm). We use s as the sparsity of the input matrices, that is, the maximum number of non-zero entries in a row or column) of any of the matrices C,A 1,...,A m is s. Recall that for normalization purposes we assume A 1,..., A m, C 1. We furthermore assume that A 1 = I and b 1 = R, that is, the trace of primal-feasible solutions is bounded by R and hence also the trace of primal-optimal solutions is bounded by R). The analogous quantity for the dual SDP 2), an upper bound on m y j for an optimal dual solution y, will be denoted by r. We will assume r 1. For r to be well-defined we have to make the explicit assumption that the optimal solution in the dual is attained. In Section 3 it will be necessary to work with the best possible upper bounds: we let R be the smallest trace of an optimal solution to SDP 1), and we let r be the smallest l 1 -norm of an optimal solution to the dual. These quantities are well-defined; indeed, both the primal and dual optimum are attained: the dual optimum is attained by assumption, and due to the assumption A 1 = I, the dual SDP is strictly feasible, which means that the optimum in 1) is attained. Unless specified otherwise, we always consider additive error. In particular, an ε-optimal solution to an SDP will be a feasible solution whose objective value is within error ε of the optimum. Oracles: Weassumesparseblack-box accesstotheelements ofthematricesc,a 1,...,A m defined in the following way: for input j,l) [n] [s] we can query the location and value of the lth non-zero entry in the jth row of the matrix M. Specifically inthequantumcase, as describedin[bck15], foreach matrix M {A 1,...,A m,c} we assume access to an oracle OM I, which serves the purpose of sparse access. OI M calculates the index : [n] [s] [n] function, which for input j,l) gives the column index of the lth non-zero element in the jth row. We assume this oracle computes the index in place : O I M j,l = j,indexj,l). 4) In the degenerate case where the jth row has fewer than l non-zero entries, indexj,l) is defined to be l together with some special symbol.) We also need another oracle O M, returning a bitstring representation of M ji for any j,i [n]: O M j,i,z = j,i,z M ji. 5) The slightly unusual in place definition of oracle OM I of this issue see, e.g., the introduction of [BCK15]. is not too demanding; for a brief discussion Computational model: As a computational model, we assume a slight relaxation of the usual quantum circuit model: a classical control system that can run quantum subroutines. When we talk about gate complexity, we count the number of three-qubit quantum gates needed for implementation of the quantum subroutines. Additionally, we assume for simplicity that there exists a unit-cost QRAM gate that allows us to store and retrieve qubits in a memory indexed by one register: QRAM : i,x,r 1,...,r K i,r i,r 1,...,r i 1,x,r i+1,r K, where the registers r 1,...,r K are only accessible through this gate. The only place where we need QRAM is in Appendix D, for a data structure that allows efficient access to the non-zero entries of a sum of sparse matrices; for the special case of LP-solving it is not needed at all. 10

11 We furthermore assume access to the input matrices by oracles of the form defined above. We limit the classical control system so that its number of operations is at most a polylogarithmic factor bigger than the gate complexity of the quantum subroutines, i.e., if the quantum subroutines use C gates, then the classical control system may not use more than OC polylogc)) operations. 2.1 The Arora-Kale framework for solving SDPs In this section we give a short introduction to the Arora-Kale framework for solving semidefinite programs. We refer to [AK16, AHK12] for a more detailed description and omitted proofs. The key building block is the Matrix Multiplicative Weights MMW) algorithm introduced by Arora and Kale in [AK16]. The MMW algorithm can be seen as a strategy for you in a game between you and an adversary. We first introduce the game. There is a number of rounds T. In each round you present a density matrix ρ to an adversary, the adversary replies with a loss matrix M satisfying I M I. After each round you have to pay TrMρ). Your objective is to pay as little as possible. The MMW algorithm is a strategy for you that allows you to lose not too much, in a sense that is made precise below. In Algorithm 1 we state the MMW algorithm, the following theorem shows the key property of the output of the algorithm. Input Parameter η 1, number of rounds T. Rules In each round player 1 you) presents a density matrix ρ, player 2 the adversary) replies with a matrix M satisfying I M I. Output A sequence of symmetric n n matrices M 1),...,M T) satisfying I M t) I, for t [T] and a sequence of n n psd matrices ρ 1),...,ρ T) satisfying Tr ρ t)) = 1 for t [T]. Strategy of player 1: Take ρ 1) := I/n In round t: 1. Show the density matrix ρ t) to the adversary. 2. Obtain the loss matrix M t) from the adversary. 3. Update the density matrix as follows: t ρ t+1) := exp η M )/Tr τ) exp η τ=1 )) t M τ) τ=1 Algorithm 1: Matrix Multiplicative Weights MMW) Algorithm Theorem 2 [AK16, Theorem 3.1]). For every adversary, the sequence ρ 1),...,ρ T) of density matrices constructed using the Matrix Multiplicative Weights Algorithm 1) satisfies T Tr M t) ρ t)) T λ min M )+η t) t=1 t=1 T t=1 Tr M t) ) 2 ρ t)) + lnn) η. 11

12 Arora and Kale use the MMW algorithm to construct an SDP-solver. For that, they assume an adversary that promises to satisfy an additional condition: in each round t the adversary returns a matrix M t) such that its trace inner product with your density matrix ρ t) is non-negative. The above theorem shows that then, in fact, after T rounds, the average of the adversary s responses satisfies a stronger condition, namely that its smallest eigenvalue is not too negative: λ 1 ) T min T t=1 Mt) η lnn) ηt. More explicitly, the MMW algorithm is used to build a vector y 0 such that 1 T T M t) t=1 m y j A j C and b T y α. That is, y is almost dual-feasible and its objective value is at most α. We now explain how to tweak y to make it really dual-feasible. Since A 1 = I, increasing the first coordinate of y makes the smallest eigenvalue of j y ja j C bigger, so that this matrix becomes psd. By the above we know how much the minimum eigenvalue has to be shifted, and with the right choice of parameters it can be shown that this gives a dual-feasible vector y that satisfies b T y α +ε. In order to present the algorithm formally, we require some definitions. Given a candidate solution X 0 for the primal problem 1) and a parameter ε 0, define the polytope One can verify the following: P ε X) := {y R m : b T y α, Tr m ) y j A j C X ε, y 0}. Lemma 3 [AK16, Lemma 4.2]). If for a given candidate solution X 0 the polytope P 0 X) is empty, then a scaled version of X is primal-feasible and of objective value at least α. The Arora-Kale framework for solving SDPs uses the MMW algorithm where the role of the adversary is taken by an ε-approximate oracle: Input An n n psd matrix X, a parameter ε, and the input matrices and reals of 2). Output Either the Oracle ε returns a vector y from the polytope P ε X) or it outputs fail. It may only output fail if P 0 X) =. Algorithm 2: ε-approximate Oracle ε for maximization SDPs As we will see later, the runtime of the Arora-Kale framework depends on a property of the oracle called the width: Definition 4 Width of Oracle ε ). The width of Oracle ε for an SDP is the smallest w 0 such that for every primal candidate X 0, the vector y returned by Oracle ε satisfies m y ja j C w. 12

13 In practice, the width of an oracle is not always known. However, it suffices to work with an upper bound w w : as we can see in Meta-Algorithm 1, the purpose of the width is to rescale the matrix M t) in such a way that it forms a valid response for the adversary in the MMW algorithm. The following theorem shows the correctness of the Arora-Kale primal-dual meta-algorithm for Input The input matrices and reals of SDP 1) and trace bound R. The current guess α of the optimal value of the dual 2). An additive error tolerance ε > 0. An ε 3-approximate oracle Oracle ε/3 as in Algorithm 2 with width bound w. Output Either Lower and a vector y R m + feasible for 2) with bt y α+ε or Higher and a symmetric n n matrix X that, when scaled suitably, is primal-feasible with objective value at least α. 9w 2 R 2 lnn) T :=. ε 2 lnn) η := T. ρ 1) := I/n for t = 1,...,T do Run Oracle ε/3 with X t) = Rρ t). if Oracle ε/3 outputs fail then return Higher and a description of X t). end if Let y t) be the vector generated by Oracle. Set M t) = 1 m ) w yt) j A j C. Define H t) = t τ=1 Mτ). Update the state matrix as follows: ρ t+1) := exp ηh t)) /Tr exp ηh t))). end for If Oracle ε/3 does not output fail in any of the T rounds, then output the dual solution y = ε R e T T t=1 yt) where e 1 = 1,0,...,0) R m. Meta-Algorithm 1: Primal-Dual Algorithm for solving SDPs solving SDPs, stated in Meta-Algorithm 1: Theorem 5 [AK16, Theorem 4.7]). Given an SDP of the form 1) with input matrices A 1 = I,A 2,...,A m and C having operator norm at most 1, and input reals b 1 = R,b 2,...,b m. Assume Meta-Algorithm 1 does not output fail in any of the rounds, then the returned vector y is feasible for the dual 2) with objective value at most α+ε. If Oracle ε/3 outputs fail in the t-th round then a suitably scaled version of X t) is primal-feasible with objective value at least α. The SDP-solver uses T = 9w 2 R 2 lnn) ε 2 iterations. In each iteration several steps have to be taken. The most expensive two steps are computing the matrix exponential of the matrix ηh t) and the application of the oracle. Note that the only purpose of computing the matrix exponential is to allow the oracle to compute the values TrA j X) for all j and TrCX), since the polytope depends on X only through those values. To obtain faster algorithms it is important to note, as was done already by Arora and Kale, that the primal-dual algorithm also works if we provide a 13

14 more accurate) oracle with approximations of TrA j X). In fact, it will be convenient to work with TrA j ρ) = TrA j X)/TrX). To be more precise, given a list of reals a 1,...,a m,c and a parameter θ 0, such that a j TrA j ρ) θ for all j, and c TrCρ) θ, define the polytope Pa 1,...,a m,c r +1)θ) := {y R m : b T y α, m y j r, m a j y j c r +1)θ y 0}. For convenience we will denote a = a 1,...,a m ) and c := c r+1)θ. Notice that P also contains a new type of constraint: j y j r. Recall that r is defined as a positive real such that there exists an optimal solution y with y 1 r. Hence, using that P 0 X) is a relaxation of the feasible region of the dual with bound α on the objective value), we may restrict our oracle to return only such y: m P 0 X) P 0 X) {y R m : y j r}. The benefit of this restriction is that an oracle that always returns a vector with bounded l 1 - norm automatically has a width w r + 1, due to the assumptions on the norms of the input matrices. The downside of this restriction is that the analogue of Lemma 3 does not hold for P 0 X) {y R m : j y j r}. 5 The following shows that an oracle that always returns a vector y Pa,c ) if one exists, is a 4Rrθ-approximate oracle as defined in Algorithm 2. Lemma 6. Let a 1,...,a m and c be θ-approximations of TrA 1 ρ),...,tra m ρ) and TrCρ), respectively, where X = Rρ. Then the following holds: P 0 X) {y R m : m y j r} Pa,c ) P 4Rrθ X). Proof. First, suppose y P 0 X) {y R m : j y j r}. We now have m m a j y j c a j TrA j ρ) y j c TrCρ) θ y 1 θ r +1)θ which shows that y Pa,c ). 5 Using several transformations of the SDP, from Appendix E and Lemma 2 of [BS16], one can show that there is a way to remove the need for this restriction. Hence, after these modifications, if for a given candidate solution X 0 the oracle outputs that the set P 0X) is empty, then a scaled version of X is primal feasible for this new SDP, with objective value at least α. This scaled version of X can be modified to a near-feasible solution to the original SDP it will be psd, but it might violate the linear constraints a little bit) with nearly the same objective value. 14

15 Next, suppose y Pa,c ). We show that y P 4Rrθ X). Indeed, since TrA j ρ) a j θ we have m m Tr y j A j C ρ r+1)θ TrA j ρ) a j y j + c TrCρ) 2+r+ y 1 )θ 4rθ where the last inequality used our assumptions r 1 and y 1 r. Hence m Tr y j A j C X 4rTrX)θ = 4Rrθ. For the latter inequality we use TrX) = R. We have now seen the Arora-Kale framework for solving SDPs. To obtain a quantum SDPsolver it remains to provide a quantum oracle subroutine. By the above discussion it suffices to set θ = ε/12rr) and to use an oracle that is based on θ-approximations of TrAρ) for A {A 1,...,A m,c}), since with that choice of θ we have P 4Rrθ X) = P ε/3 X). In the section below we first give a quantum algorithm for approximating TrAρ) efficiently see also Appendix A for a classical algorithm). Then, in Section 2.3, we provide an oracle using those estimates. The oracle will be based on a simple geometric idea and can be implemented both on a quantum computer and on a classical computer of course, resulting in different runtimes). In Section 2.4 we conclude with an overview of the runtime of our quantum SDP-solver. We want to stress that our solver is meant to work for any SDP. In particular, our oracle does not use the structure of a specific SDP. As we will show in Section 3, any oracle that works for all SDPs necessarily has a large width bound. To obtain quantum speedups for a specific class of SDPs it will be necessary to develop oracles tuned to that problem, we view this as an important direction for future work. Recall from the introduction that Arora and Kale also obtain fast classical algorithms for problems such as MAXCUT by developing specialized oracles. 2.2 Approximating the expectation value TrAρ) using a quantum algorithm In this section we give an efficient quantum algorithm to approximate quantities of the form TrAρ). We are going to work with Hermitian matrices A,H C n n, such that ρ is the Gibbs state e H /Tr e H). Note the analogy with quantum physics: in physics terminology TrAρ) is simply called the expectation value of A for a quantum system in a thermal state corresponding to H. The general approach is to separately estimate Tr Ae H) and Tr e H), and then to use the ratiooftheseestimates asanapproximationoftraρ) = Tr Ae H) /Tr e H). Bothestimations are done using state preparation to prepare a pure state with a flag, such that the probability that the flag is 0 is proportional to the quantity we want to estimate, and then to use amplitude estimation to estimate that probability. Below in Section we first describe the general approach. In Section we then instantiate this for the special case where all matrices are diagonal, which is the relevant case for LP-solving. In Section we handle the general case of arbitrary matrices needed for SDP-solving); the state-preparation part will be substantially more involved there, because in the general case we need not know the diagonalizing bases for A and H, and A and H may not be simultaneously diagonalizable. 15

17 In practice we will not be able to construct such a U A,H exactly, instead we will construct a ŨA,H that yields a sufficiently close approximation of the correct probability. Since we have access to such a unitary, the following lemma ) allows us to use amplitude estimation to estimate the probability and hence Tr I+A/2 4 e H up to the desired error. Lemma 9. Suppose we have a unitary U acting on q qubits such that U = 0 ψ + Φ with 0 I) Φ = 0 and ψ 2 = p p min for some known bound p min ). Let µ 0,1] be the allowed 1 multiplicative error in our estimation of p. Then with O µ p min uses of U and U 1 and using O gates on the q qubits we obtain a p such that p p µp with probability at least 4/5. ) q µ p min Proof. We use the amplitude-estimation algorithm of [BHMT02, Theorem 12] with M applications of U and U 1. This provides an estimate p of p, that with probability at least 8/π 2 > 4/5 satisfies p p 2π p1 p) M + π2 M 2 π 2 p+ π ). M M Choosing M the smallest power of 2 such that M 3π/µ p min ), with probability at least 4/5 we get pmin p p µ 2 ) pmin p p+µ µ p) µp. The q factor in the gate complexity comes from the implementation of the amplitude amplification steps needed in amplitude-estimation. The gate complexity of the whole amplitude-estimation procedure is dominated by this contribution proving the final gate complexity. Corollary 10. Suppose we are given the positive numbers z Tr e H), θ 0,1], and unitary circuits ŨA,H for A = 0 and A = A with A 1, each acting on at most q qubits such that 0 I)ŨA,H Tr I +A /2)e H) 4n θz 144n. Applying the procedure of Lemma 9 to ŨA,H both for A = 0 and for A = A) with p min = z 9n and µ = θ/19, and combining the results using Corollary 8 yields an additive θ-approximation of TrAρ) with high probability. The procedure uses ) 1 n O θ z applications of ŨA,H, Ũ0,H and their inverses, and O q θ n z) additional gates. Proof. First note that since I +A /2 I/2 we have and thus p := Tr I +A /2)e H) 4n 0 I)ŨA,H p θz Tr e H) 8n 144n θ 18 Tr e H ) 8n 17 θ 18 p p 18. 6)

18 Therefore 0 I)ŨA,H Also by 6) we have 1 1 ) p 1 1 ) Tr e H ) > Tr e H) z n 9n 9n = p min. 0 I)ŨA,H θ ) p p. Therefore using Lemma 9, with µ = θ/19, with high probability we get a p satisfying 0 I) p Ũ A,H θ 19 0 I)ŨA,H θ p. 7) 18 By combining 6)-7) using the triangle inequality we get p p θ 9 p, so that Corollary 8 can indeed be applied. The complexity statement follows from Lemma 9 and our choices of p min and µ. Notice the 1/ z 1/ Tre H ) factor in the complexity statement of the last corollary. To make sure this factor is not too large, we would like to ensure Tr e H) = Ω1). This can be achieved by substituting H + = H λ min I, where λ min is the smallest eigenvalue of H. It is easy to verify that this will not change the value Tr Ae H /Tr e H)). It remains to show how to compute λ min and how to apply ŨA,H. Both of these steps are considerably easier in the case where all matrices are diagonal, so we will consider this case first The special case of diagonal matrices for LP-solving In this section we consider diagonal matrices, assuming oracle access to H of the following form: O H i z = i z H ii and similarly for A. Notice that this kind of oracle can easily be constructed from the general sparse matrix oracle 5) that we assume access to. Lemma 11. Let A,H R n n be diagonal matrices such that A 1 and H 0 and let µ > 0 be an error parameter. Then there exists a unitary ŨA,H such that ) 0 I)ŨA,H I +A/2 Tr e H µ, 4n which uses 1 quantum query to A and H and Olog O1) 1/µ)+logn)) other gates. Proof. For simplicity assume n is a power of two. This restriction is not necessary, but makes the proof a bit simpler to state. 18

19 In the first step we prepare the state n i=1 i / n using logn) Hadamard gates on 0 logn). Then we query the diagonal values of H and A to get the state n i=1 i H ii A ii / n. Using these binary values we apply a finite-precision arithmetic circuit to prepare 1 n 1+Aii /2 i H ii A ii β i, where β i := arcsin e n 4 H ii +δi )/π, and δ i µ. i=1 Note that the error δ i comes from writing down only a finite number of bits b 1.b 2 b 3...b log8/µ). Due to our choice of A and H, we know that β i lies in [0,1]. We proceed by first adding an ancilla qubit initialized to 1 in front of the state, then we apply log8/µ) controlled rotations to this qubit: for each b j = 1 we apply a rotation by angle π2 j. In other words, if b 1 = 1, then we rotate 1 fully to 0. If b 2 = 1, then we rotate halfway, and we proceed further by halving the angle for each subsequent bit. We will end up with the state: 1 n n i=1 1+Aii /2 e 4 H ii +δi A ii/2 e 4 H ii δi 1 ) i A ii H ii β i. It is now easy to see that the squared norm of the 0 -part of this state is as required: 1 n 1+Aii /2 2 e n 4 H ii +δi i = 1 n ) 1+Aii /2 e H ii +δ i = Tr I +A/2)e H) + n 4 4n i=1 which is an additive µ-approximation since i=1 n i=1 δ i n µ. Corollary 12. Let A,H R n n be diagonal matrices, with A 1. An additive θ-approximation of TrAρ) = Tr Ae H) Tre H ) n ) n ) can be computed using O queries to A and H and Õ other gates. θ Proof. Since H is a diagonal matrix, its eigenvalues are exactly its diagonal entries. Using the quantum minimum-finding algorithm of Dürr and Høyer [DH96] one can find with high success probability) the minimum λ min of the diagonal entries using O n) queries to the matrix elements. Applying Lemma 11 and Corollary 10 to H + = H λ min I, with z = 1, gives the stated bound General case for SDP-solving In this section we will extend the ideas from the last section to non-diagonal matrices. There are a few complications that arise in this more general case. These mostly follow from the fact that we now do not know the eigenvectors of H and A, which where the basis states before, and that these eigenvectors might not be the same for both matrices. For example, to find the minimal eigenvalue of H, we can no longer simply minimize over its diagonal entries. To solve this, in Appendix C we develop new techniques that generalize minimum-finding. Furthermore, the unitary ŨA,H in the LP case could be seen as applying the operator I +A/ e H θ n i=1 δ i n,

20 to a superposition of its eigenvectors. This is also more complicated in the general setting, due to the fact that the eigenvectors are no longer the basis states. In Appendix B we develop general techniques to apply smooth functions of Hamiltonians to a state. Among other things, this will be used to create an efficient purified Gibbs sampler. Our Gibbs sampler uses similar methods to the work of Chowdhury and Somma [CS16] for achieving logarithmic dependence on the precision. However, the result of [CS16] cannot be applied to our setting, because it implicitly assumes access to an oracle for H instead of H. Although their paper describes a way to construct such an oracle, it comes with a large overhead: they construct an oracle for H = H +νi, where ν R + is some possibly large positive number. This shifting can have a huge effect on Z = Tr e H ) = e ν Tr e H), which can be prohibitive, as there is a 1/Z factor in the runtime, blowing up exponentially in ν. In the following lemma we show how to implement ŨA,H using the techniques we developed in Appendix B. Lemma 13. Let A,H C n n be Hermitian matrices such that A 1 and I H KI for a known K R +. Assume A is s-sparse and H is d-sparse with s d. Let µ > 0 be an error parameter. Then there exists a unitary ŨA,H such that ) 0 I)ŨA,H I +A/2 Tr e H µ 4n that uses ÕKd) queries to A and H, and the same order of other gates. Proof. The basic idea is that we first prepare a maximally entangled state n i=1 i i / n, and then apply the norm-decreasing) maps e H/2 I+A/2 and 4 to the first register. Note that we can assume without loss of generality that µ 1, otherwise the statement is trivial. Let W 0 = 0 I) W 0 I) be a µ/5-approximation of the map e H/2 in operator norm) implemented by using Theorem 43, and let Ṽ0 = 0 I)Ṽ 0 I) be a µ/5-approximation of the I+A/2 map 4 implemented by using Theorem 40. We define ŨA,H := Ṽ W, noting that there is a hidden I factor in both Ṽ and W corresponding to each other s ancilla qubit. As in the linear programming case, we are interested in p, the probability of measuring a 00 in the first register i.e., the two flag qubits) after applying ŨA,H. We will analyze this in terms of these operators 20

Linear Programming Linear programming refers to problems stated as maximization or minimization of a linear function subject to constraints that are linear equalities and inequalities. Although the study

Lecture 7: Approximation via Randomized Rounding Often LPs return a fractional solution where the solution x, which is supposed to be in {0, } n, is in [0, ] n instead. There is a generic way of obtaining

Section Notes 3 The Simplex Algorithm Applied Math 121 Week of February 14, 2011 Goals for the week understand how to get from an LP to a simplex tableau. be familiar with reduced costs, optimal solutions,

4.6 Linear Programming duality To any minimization (maximization) LP we can associate a closely related maximization (minimization) LP. Different spaces and objective functions but in general same optimal

WEEK 8 Summary of week 8 (Lectures 22, 23 and 24) This week we completed our discussion of Chapter 5 of [VST] Recall that if V and W are inner product spaces then a linear map T : V W is called an isometry

+a 1. R In this and the next section we are going to study the properties of sequences of real numbers. Definition 1.1. (Sequence) A sequence is a function with domain N. Example 1.2. A sequence of real

Solving LPs: The Simplex Algorithm of George Dantzig. Simplex Pivoting: Dictionary Format We illustrate a general solution procedure, called the simplex algorithm, by implementing it on a very simple example.

Approximating the entropy of a -dimensional shift of finite type Tirasan Khandhawit c 4 July 006 Abstract. In this paper, we extend the method used to compute entropy of -dimensional subshift and the technique

Lecture 11 The Lovász ϑ Function 11.1 Perfect graphs We begin with some background on perfect graphs. graphs. First, we define some quantities on Definition 11.1. Given a graph G on n vertices, we define

3.7 Non-autonomous linear systems of ODE. General theory Now I will study the ODE in the form ẋ = A(t)x + g(t), x(t) R k, A, g C(I), (3.1) where now the matrix A is time dependent and continuous on some

A Formalization of the Turing Test Evgeny Chutchev 1. Introduction The Turing test was described by A. Turing in his paper [4] as follows: An interrogator questions both Turing machine and second participant

Mixed states and pure states (Dated: April 9, 2009) These are brief notes on the abstract formalism of quantum mechanics. They will introduce the concepts of pure and mixed quantum states. Some statements

Week 5 Integral Polyhedra We have seen some examples 1 of linear programming formulation that are integral, meaning that every basic feasible solution is an integral vector. This week we develop a theory

Chapter MATRICES Matrix arithmetic A matrix over a field F is a rectangular array of elements from F The symbol M m n (F) denotes the collection of all m n matrices over F Matrices will usually be denoted

ORDERS OF ELEMENTS IN A GROUP KEITH CONRAD 1. Introduction Let G be a group and g G. We say g has finite order if g n = e for some positive integer n. For example, 1 and i have finite order in C, since

Chapter 2 Geometry of Linear Programming The intent of this chapter is to provide a geometric interpretation of linear programming problems. To conceive fundamental concepts and validity of different algorithms

4. MATRICES 170 4. Matrices 4.1. Definitions. Definition 4.1.1. A matrix is a rectangular array of numbers. A matrix with m rows and n columns is said to have dimension m n and may be represented as follows:

Why eigenvalues? Week 8: Friday, Oct 12 I spend a lot of time thinking about eigenvalue problems. In part, this is because I look for problems that can be solved via eigenvalues. But I might have fewer

ENGG2012B Advanced Engineering Mathematics Notes on Determinant Lecturer: Kenneth Shum Lecture 9-18/02/2013 The determinant of a system of linear equations determines whether the solution is unique, without

Copyright c 2009 by Karl Sigman Limiting distribution for a Markov chain In these Lecture Notes, we shall study the limiting behavior of Markov chains as time n In particular, under suitable easy-to-check

Linear Algebra Notes for Marsden and Tromba Vector Calculus n-dimensional Euclidean Space and Matrices Definition of n space As was learned in Math b, a point in Euclidean three space can be thought of

The Hadamard Product Elizabeth Million April 12, 2007 1 Introduction and Basic Results As inexperienced mathematicians we may have once thought that the natural definition for matrix multiplication would

GRADUATE STUDENT NUMBER THEORY SEMINAR MICHELLE DELCOURT Abstract. This talk is based primarily on the paper Interlacing Families I: Bipartite Ramanujan Graphs of All Degrees by Marcus, Spielman, and Srivastava

AN EXTENSION OF THE ELIMINATION METHOD FOR A SPARSE SOS POLYNOMIAL Hayato Waki Masakazu Muramatsu The University of Electro-Communications (September 20, 2011) Abstract We propose a method to reduce the

MATH022 Linear Algebra Brief lecture notes 48 Similarity and Diagonalization Similar Matrices Let A and B be n n matrices. We say that A is similar to B if there is an invertible n n matrix P such that

Math 163 - Introductory Seminar Lehigh University Spring 8 Notes on Fibonacci numbers, binomial coefficients and mathematical induction These are mostly notes from a previous class and thus include some

3.1 Algorithm complexity The algorithms A, B are given. The former has complexity O(n 2 ), the latter O(2 n ), where n is the size of the instance. Let n A 0 be the size of the largest instance that can

Lecture 1: Schur s Unitary Triangularization Theorem This lecture introduces the notion of unitary equivalence and presents Schur s theorem and some of its consequences It roughly corresponds to Sections

2.3 Scheduling jobs on identical parallel machines There are jobs to be processed, and there are identical machines (running in parallel) to which each job may be assigned Each job = 1,,, must be processed

Fourier Series A Fourier series is an infinite series of the form a b n cos(nωx) c n sin(nωx). Virtually any periodic function that arises in applications can be represented as the sum of a Fourier series.

6. ISOMETRIES 6.1. Isometries Fundamental to the theory of symmetry are the concepts of distance and angle. So we work within R n, considered as an inner-product space. This is the usual n- dimensional

Approximation Algorithms 11 Approximation Algorithms Q Suppose I need to solve an NP-hard problem What should I do? A Theory says you're unlikely to find a poly-time algorithm Must sacrifice one of three

Mathematical finance and linear programming (optimization) Geir Dahl September 15, 2009 1 Introduction The purpose of this short note is to explain how linear programming (LP) (=linear optimization) may

Inverse Optimization by James Orlin based on research that is joint with Ravi Ahuja Jeopardy 000 -- the Math Programming Edition The category is linear objective functions The answer: When you maximize

Approximation Algorithms Chapter Approximation Algorithms Q Suppose I need to solve an NP-hard problem What should I do? A Theory says you're unlikely to find a poly-time algorithm Must sacrifice one of

4.B. Tangent and normal lines to conics Apollonius work on conics includes a study of tangent and normal lines to these curves. The purpose of this document is to relate his approaches to the modern viewpoints