A Fast Minimum and Matching Lower Bound

Robert Cummings∗3, Matthew Fahrbach†1, and Animesh Fatehpuria‡2

1Google Research 2Nuro 3School of Computer Science, University of Waterloo

July 24, 2020

Abstract The minimum degree algorithm is one of the most widely-used heuristics for reducing the cost of solving large sparse systems of linear equations. It has been studied for nearly half a century and has a rich history of bridging techniques from data structures, graph , and scientic computing. In this paper, we present a simple but novel combinatorial algorithm for computing an exact minimum degree elimination ordering in time, which improves on the best known of and oers practical improvements for sparse systems with small values of . Our approach leverages a careful amortized analysis, which also allows us to derive output-sensitive bounds for the running time3 of ,O where(nm) is the number of unique ll edges and original edges thatO( then ) algorithm encounters and is the maximum degree of the input graph. m Furthermore,√ + we show+ there cannot exist+ an exact minimum degree algorithm that runs in time,O(min{ for anym m , Δ,m assuming} log n) the strongm exponential time hypothesis. This ne-grained reduction goes through the orthogonal vectorsΔ problem and uses a new low-degree graph construction called -llers1−" , which act as pathological inputs and cause any minimum degree algorithm to exhibit nearly worst-caseO(nm ) performance." With > 0 these two results, we nearly characterize the time complexity of computing an exact minimum degree ordering. U arXiv:1907.12119v2 [cs.DS] 22 Jul 2020

∗Email: [email protected]. †Email: [email protected]. Part of this work was done at the Georgia Institute of Technology while supported by an NSF Graduate Research Fellowship under grant DGE-1650044. ‡Email: [email protected].

1 Contents

1 Introduction 1 1.1 Results and Techniques ...... 1 1.2 Related Works ...... 2

2 Preliminaries 3 2.1 Fill Graphs and Minimum Degree Orderings ...... 3 2.2 SETH-Hardness for Computing Minimum Degree Orderings ...... 3

3 A Fast Minimum Degree Algorithm3 3.1 The Algorithm ...... 4 3.2 Complexity Analysis ...... 5

4 Improved SETH-Based Hardness8 4.1 Constructing Sparse Min-Degree -Fillers ...... 9 4.2 Reduction from Orthogonal Vectors ...... 11

5 Conclusion U 12 1 Introduction

The minimum degree algorithm is one of the most widely-used heuristics for reducing the cost of solving sparse systems of linear equations. This algorithm was rst proposed by Markowitz [Mar57] in the context of reordering equations that arise in asymmetric linear programming problems, and it has since been the impetus for using graph algorithms and data structures in scientic computing [Ros72, Tar76, GL79, GL81, GL89]. This line of work culminated in the approximate minimum degree algorithm (AMD) of Amestoy, Davis, and Du [ADD96], which has long been a workhorse in the sparse linear algebra libraries for Julia, MATLAB, Mathematica, and SciPy. Formally, the minimum degree algorithm is a preprocessing step that permutes the rows and columns of a sparse symmetric positive-denite matrix A , before applying , in an attempt to minimize the number of nonzeros in the Cholesky factor. Without a judicious reordering, the decomposition typically becomes dense with ll-in (i.e., additionaln×n nonzeros). The goal of the minimum degree algorithm is to eciently compute a permutation∈ ℝ matrix P such that the Cholesky factor L in the reordered matrix PAP| LL| is close to being optimally sparse. Finding an optimal permutation, however, is NP-complete [Yan81], so practical approaches such as minimum degree orderings, the Cuthill–McKee algorithm [CM69], and nested dissection [Geo73] are used instead. We direct the reader to “The Sparse Cholesky Challenge” in [=GVL13, Chapter 11.1] to further motivate ecient reordering algorithms and for a comprehensive survey. The minimum degree algorithm takes advantage of a separation between the symbolic and numerical properties of a matrix. To see this, start by viewing the nonzero structure of A as the adjacency matrix of an undirected graph with nnz A diag A edges. Permuting the matrix by PAP| does not change the underlying graph. In each iteration, the algorithm (1) selects the vertex with minimum degree, (2) adds edges between all pairs of neighbors of to form a clique, and (3) deletes from the graph. Through the lens of ,G m = each( greedy− step( ))/2 corresponds to performing row and column permutations that minimize the number of o-diagonal nonzeros in the pivot row and column.u A clique is induced on the neighbors of in the subsequent graph becauseu of the widely-used no numericalu cancellation assumption (i.e., nonzero entries remain nonzero). Motivated by the success and ubiquity of reordering algorithms in sparse linear algebra packages, and also by recent developments in the hardness of computing minimum degree orderings ofu Fahrbach et al. [FMP 18], we investigate the ne-grained time complexity of the minimum degree ordering problem. + 1.1 Results and Techniques Our main results complement each other and nearly characterize the time complexity to compute a minimum degree ordering. Our rst result is a new combinatorial algorithm that outputs an exact minimum degree ordering in time. This improves upon the best known result of achieved by the naive algorithm. We maintain two dierent data structures for the ll graph to eciently detect and avoid the redundant work encountered by the naive algorithm. Using careful amortized analysis, we3 prove the following theorems. O(nm) O(n ) Theorem 1.1. The FastMinimumDegree algorithm outputs an exact minimum degree ordering in time. Our analysis also allows us to derive output-sensitive bounds. The ll produced by the minimum degree heuristic is typically small in practice, so the performance of the algorithm is often faster than O(nm). The algorithm also allows for further practical implementations, such as using hash table-based adjacency lists. Theorem 1.2. The algorithm can be implemented to run in FastMinimumDegree O(nm) time and use space, where is the number of unique ll edges and original edges that the algorithm encounters and is the maximum degree of the original graph. √ + + + + O(min{m m , Δm } log n) O(m ) m 1 Δ Our second main result improves upon a recent conditional hardness theorem of for computing exact minimum degree elimination orderings assuming the strong exponential time hypothesis [FMP 18]. 4/3−" Theorem 1.3. Assuming the strong exponential time hypothesis, there does not existO an(m ) algorithm+ for computing a minimum degree elimination ordering, where is the maximum degree of the original graph, for any and . 2−" k O(m Δ ) This result is given in its full generality above, and it impliesΔ an answer to -hardness conjecture posed in" [ >FMP0 18k].≥ Specically,0 we have the following matching lower bound for our main algorithm. 1−" Corollary 1.4.+ Assuming the strong exponential time hypothesis, there doesO(nm not exist) an time algorithm for computing a minimum degree elimination ordering, for any . 1−" The hardness in Theorem 1.3 also rules out the existence of an time algorithm.O(nm ) We prove our hardness results by reducing the orthogonal vectors problem ["Wil05 > 0 ] to computing a minimum 2 degree ordering of a special graph constructed using building blocks calledv∈V -llers. One of our main contributions is a simple recursive algorithm for constructing -llerO( graphs∑ deg( thatv) satisfy) the challenging sparsity and degree requirements necessary for the ne-grained reduction. In particular, these -llers correspond to pathological sparsity patterns, and hence adversarial linear systems,U that cause any minimum degree algorithm to exhibit worst-case performance (i.e., to outputU Cholesky factors with nonzeros). These graphs are of independent interest and could be useful in lower bounds for other greedy algorithms.U 2 1.2 Related Works Ω(̃ n ) Computing an elimination ordering that minimizes ll-in is an NP-complete problem closely related to chordal graph completion [Yan81]. Agrawal, Klein, and Ravi [AKR93] gave the rst for the minimum ll-in problem, building on earlier heuristics by George [Geo73] and by Lipton, Rose, and Tarjan [LRT79]. Natanzon, Shamir, and Sharan [NSS00] later developed the rst algorithm to approximate the minimum possible ll-in to within a polynomial factor. There has since been a wealth of recent results on xed-parameter tractable algorithms [KST99, FV13, CM16, BFPP18] and the conditional hardness of minimizing ll-in [WAPL14, BCK 16, CS17, BCCR19]. Due to this computational complexity, we rely on the practicality and eciency of greedy heuristics. In particular, the multiple minimum+ degree algorithm (MMD) of Liu [Liu85] and the approximate minimum degree algorithm (AMD) of Amestoy, Davis, and Du [ADD96] have been the mainstays for solving sparse linear systems of equations. These algorithms, however, have some drawbacks. MMD eliminates a maximal independent set of minimum degree vertices in each step, but it runs in time and this is known to be tight [HEKP01]. On the other hand, AMD is a single elimination algorithm that runs in time, but achieves its speedup by using an easy-to-compute upper bound as a proxy to2 the true vertex degrees. While many variants of the minimum degree algorithm exist, an algorithm thatO(n computesm) an exact minimum degree ordering with time complexity better than has never been proven. Therefore, ourO(nm contributions) are a signicant step forward in the theory of minimum degree algorithms. There have also been other major advancements3 in the theory of minimum degree algorithms recently. Fahrbach et al. [FMP 18] designed an algorithm thatO(n computes) a -approximate greedy minimum degree elimination ordering in time. Although this result is a signicant theoretical milestone, it is currently quite far+ from being practical. Ost, Schulz, and Strash [OSS20] recently gave a comprehensive set of vertex elimination rules that5 are−2 to be used before applying(1+ a" greedy) reordering algorithm and never degrade the quality of theO( output.m log ( Then)" minimum) degree heuristic has also appeared in algorithms for graph compression and coarsening [Ash95, CKL 09, FGP 20].

+ + 2 2 Preliminaries

2.1 Fill Graphs and Minimum Degree Orderings For an undirected, unweighted graph , let denote the neighborhood of vertex and denote its degree. We overload the notation to be the neighborhood of a set of vertices. For two graphs and , dene their union to be G = (V,E) N (u) = {v ∈ V ∶ {u, v} ∈ E} . For a given set of vertices , let be the complete graph withu∈U vertex set . u deg(u) = |N (u)| N (U ) = N (u) Now we introduce the idea of ll graphs. Our notation1 extends1 1 that2 of Gilbert,2 2 Ng and⋃ Peyton [GNP94]. G = (V ,E ) G = (V ,E ) We1 use2 the shorthand1 2 1 2 throughout the paper.U G ∪ G = (V ∪ V ,E ∪ E ) U K U Denition 2.1. For any undirected graph and subset , the ll graph is the graph resulting from eliminating the vertices in . Its vertex set is , and an edge if [n] = {1, 2, … , n} + + + and only if there exists a path in such that for all . U U U G = (V,E) U ⊆+ V G = (V ,E ) + Characterizing ll-in by -paths through eliminated vertices allows usU to compute the ll degree of a vertexU U V = V ⧵ U {u, v} ∈ E in any partially eliminated state 1withoutt explicitly computingi the eliminated matrix. For a ll graph , (u, x , … , x , v) G x ∈ U i ∈ [t] we avoid double subscripts and use the analogous notation and to uv + denote the degree and neighborhood of a vertex . Alternatively, we can use tools from linear algebraU + + U + U + U G and view as the nonzero structure of the Schur complement ofU the adjacencyG matrixUA . G + deg (v) = deg (v) N (v) = N (v) An elimination ordering naturallyU induces a sequence of ll graphs , + v ∈ V where U and is the empty graph. Let denote the degree of vertex in the -th ll G (G+)/U + + graph of this sequence. This allows1 us2 to denen a minimum degree elimination ordering. 0 1 n + + p = (v , v , … , v ) + (+G ,G , … ,G ) Denition0 2.2. A minimumn degree elimination orderingi is permutation of the vertices i such G = G G deg (v) v ∈ V i that for all . 1 2 n + i−1 + (v , v , … , v ) i v∈V i−1 2.2v SETH-Hardness∈ arg min deg for(v Computing) i ∈ [n] Minimum Degree Orderings Our lower bound for the time complexity of computing a minimum degree elimination ordering is based on the strong exponential time hypothesis (SETH), which asserts that for every , there exists an integer such that -SAT cannot be solved in time. SETH has been tremendously useful in establishing tight conditional lower bounds for a diverse set of problems [Wil18]. Many of these results rely on a ne-grained reduction to the orthogonal vectors(1−")n problem and make use of the" > following0 theorem. k k O(2 ) Theorem 2.3 ([Wil05]). Assuming SETH, for any , there does not exist an time algorithm that takes binary vectors with bits and decides if there is an orthogonal pair. 2−" 2 " > 0 O(n ) 3 An Fast MinimumΘ(log Degreen) Algorithm We present a new combinatorial algorithm called FastMinimumDegree for computing minimum degree orderings. Its key feature is that it maintains the ll graph using an implicit representation of ll-in together with an explicit graph representation. This combination allows us to reduce the number of redundant edge insertions to the ll graph. Using a specialized amortized analysis, we prove the following theorems. Theorem 1.1. The FastMinimumDegree algorithm outputs an exact minimum degree ordering in time. Theorem 1.2. The FastMinimumDegree algorithm can be implemented to run in time and use space, where is the number of unique ll edges and original edges that the algorithm O(nm) encounters and is the maximum degree of the original graph. √ + + + + O(min{m m , Δm } log n) O(m ) m 3 Δ 3.1 The Algorithm We begin by describing an alternative approach for representing the ll graphs as vertices are eliminated. This hypergraph representation stores hyperedges such that at + the end of each iteration. Variants of this have frequently been used in previous literaturei on the min-degree + G + 1 2 k algorithm. Our presentation closely follows that of George1 2 andk Liu [iGL89], albeit withi dierentU U terminology.U Given a graph , we construct the initial hypergraphU ,U , … representation,U ⊆ V consistingG = ofK all hyperedges∪ K ∪ ⋯ ∪ K , for every edge . Next, we consider how to update the hypergraph representation as vertices are eliminated. Suppose we wish to eliminate a vertex . Let be precisely the hyperedges that contain . ConstructG . Let be the graph represented by the current hypergraph{u, v} {u, v} ∈ E(G) representation. Then is precisely the neighborhood of in 1 .2 It followst that the ll graph obtained by ¨v U ,U , … ,U eliminating is represented1 by removing2 t the hyperedges and adding the hyperedge . Ourv algorithm toW nd= a (U minimum∪U ∪⋯ degree∪U )⧵{ orderingv} G can be summarized¨ as maintaining both a hypergraph W v G representation and an adjacency matrix of the ll graph. The1 adjacency2 t matrix is used to eciently compute the minimumv degree vertex in each step, and the hypergraphU ,U representation, … ,U is used to reduce the numberW of redundant updates to the adjacency matrix. When eliminating the vertex in the current ll graph , we nd the hyperedges containing , as described above. We also compute . We must add + + edges to the ll graph so that it contains the clique . Therefore,i it is enough for our1 algorithm2 t to tryi v G +U ,U , … ,U ⊆ V adding the edges in that are not in , since1 these2 aret already guaranteedi to be in . v W = (U ∪ U ∪ ⋯ ∪ U ) ⧵ {v} = N (v) Below we give high-level pseudocode to describe thisW algorithm. Although the implementation details of 1 2 K t + the algorithm are veryW important to the eciencyU U of the algorithm,U we defer these discussions to Section 3.2i . K K ∪ K ∪ ⋯ ∪ K G Algorithm 1 A fast minimum degree algorithm for producing exact elimination orderings. 1: function FastMinimumDegree(adjacency list for undirected graph with ) 2: Initialize adjacency structure fill_graph to agree with 3: for each edge do 4: Add to the list of hyperedges G = (V,E) |V | = n 5: Mark all vertices as active and initialize array elimination_orderingG of size 6: for to do{u, v} ∈ E 7: Let {beu, v the} active vertex with minimum degree in fill_graph 8: Deactivate and set elimination_ordering n 9: Initializei = 1 n 10: for aeach hyperedge containing do 11: Removea from the list of hyperedges [i] ← a 12: Set W ← ∅ 13: Let Uand a 14: for eachU pair in do 15: UAdd← edgeU ⧵ {a} to fill_graph if not present 16: for Xeach← vertexW ⧵ U Ydo← U ⧵ W 17: Remove edge(x, y) Xfrom× Y fill_graph {x, y} 18: Update b ∈ Y 19: Add to the list of hyperedges {a, b} 20: return elimination_ordering W ← W ∪ Y W

4 We claim that the algorithm is correct and maintains the desired state at the end of each iteration.

Lemma 3.1. FastMinimumDegree produces a correct minimum degree ordering elimination_ordering. Furthermore, suppose is the sequence of ll graphs induced by elimination_ordering. Then, at the end of each iteration of the FastMinimumDegree algorithm: + + + 0 1 n 1. The state of fill_graph(G ,G , …corresponds,G ) to the ll graph . i ∈ [n] 2. The list of hyperedges satises + (i.e., the hypergraph representation i is maintained). G 1 2 k + 1 2 k U U U i Proof. We proceed by inductionU ,U and, … show,U that theseK invariants∪K ∪⋯∪ holdK = atG the end of each iteration. Before any vertices are eliminated (line 5) both properties are true since . Assume the claim as the induction hypothesis and suppose that the algorithm begins iteration . Clearly FastMinimumDegree selects a elimination_ordering+ minimum degree vertex in and updates 0 correctly. Now we consider what happens when vertex is eliminated.G Let= G be all the hyperedges + i ∈ [n] containing at the start of iterationi−1 . When the algorithm reaches line 19, we have . G All hyperedges are removed from the hypergraph representation1 2 byt the end of this iteration, a U ,U , … ,U ⊆ V and is added in their place. Since by the induction hypothesis, it follows1 that2 the newt list a i W = (U ∪U ∪⋯∪U )⧵{a} of hyperedges at1 the2 end oft iteration corresponds to and satises the second property. U ,U , … ,U fill_graph + Ensuring that the state of isi updated−1 correctly requires a little more work. By the induction W W = N (a) + hypothesis, fill_graph is equal to at the beginningi of iteration . The hypergraph representation also corresponds to at the start of thisi iteration, so it followsG that for each hyperedge that contains , the fill_graph+ fill_graph edges in are present in i−1. Lines 9–18 attempt to insert edges from into that + G i may be missing. Ini−1 particular, clique is constructed one hyperedge at a time to reduce redundant work. G U a When processingU the -th hyperedge , we have and W K K on line 13. Only edges spanningW the symmetric dierence can be missing from fill_graph, K so at the end of iteration , all edges inj have been considered.1 2 Finally,j−1 allj edges adjacentj 1 to 2 in jare−1 removed in lines 16–17.j Therefore, itU follows thatX the= ( stateU ∪ U of ∪fill_graph … U ) ⧵ U correspondsY = U ⧵ ( toU ∪ Uat∪ the⋯ ∪ endU of) {x, y} ∈ X × Y + the iteration. This proves the rst propertyW and completes the proof by induction. i−1 i K + a G i 3.2 Complexity Analysis G To thoroughly investigate the time complexity of minimum degree algorithms, we rst relax any rigid space requirements [GL80, HEKP01]. This allows us to more conveniently present an algorithm whose running time matches the SETH-based lower bound in Corollary 1.4. Our goal is to bound the running time of FastMinimumDegree not just by , but by more accurate bounds in terms of the total ll produced by the returned minimum degree ordering. Since the ll produced by the minimum degree heuristic is typically small in practice, our analysis shows that the performance of the algorithm will often be better than . Below are the main quantities usedO(nm to) describe the total ll.

Denition 3.2. Let be the set of all edges in the ll graph at some iteration, and let . O(nm) We have that is+ preciselyn the+ edge set of the input graph, together with all edges inserted throughout+ + i=0 i the course of the algorithm.E = ⋃ ClearlyE is a simple graph, and so . These edges are importantm = |E | because they correspond+ to nonzero entries in the corresponding Cholesky factor L. In fact, is precisely the number of nonzeros.E Intuitively, is+ the size of the “output” of the+ reordering2 procedure, and is the quantity that the minimum degree heuristic(V,E ) is designed to minimize. m ≤ n + + m m 5 First, we claim that any adjacency structure for the evolving ll graph can easily be extended to handle fast minimum degree queries. This technique uses a bucket queue and is inspired by ideas in [MB83].

Lemma 3.3. The fill_graph adjacency structure can be augmented to support the selection of the minimum degree vertex, increasing the total running time by at most .

Proof. We maintain the data structure of doubly linked lists, which+ are “buckets” corresponding to degrees. Each vertex in the graph has a node in exactly one bucket.O Every(m ) time we update the degree of a vertex, we delete it from one bucket and add it to another. This operation can be performed in time. The total number of degree updatesn is also . For each entry of the adjacency matrix, there are at most two degree updates: one when the edge is added (line 15), and one when it is deleted (line 17). These operations are only applied to precisely the entries+ corresponding to the edgesO(1) in . Selecting the minimum degree vertex is doneO(m by) checking the buckets in order of increasing degree, until a nonempty bucket is found. The running time+ for the -th step is linear in , which+ is at most the degree of in the graph . So in total,O(m the) running time is . E v + i The next lemma builds on Lemma+ 3.3 to bound the runningi time of the+ algorithmdeg by(v the) total ll-in, the number of edgev insertion attempts,(V,E ) and the cost of edge updates. TheO proof(m ) uses a simple credit analysis to show that computing all of the sets , , and over the course of the algorithm is not too expensive.

Lemma 3.4. Let be the total number of edge insertion attempts, and let be the cost of querying, inserting, or deleting an edge. Then the algorithmX Y can be implementedW to run in time.

Proof. Let k be the ordering found by the algorithm. The numberc + of edge removals performed in iteration is . Summed across all iterations, the total numberO(c(m of+ edgek)) removals is . The other queries1 and2 insertionsn to the adjacency structure happen at most times. Therefore, the total running (v , v , …+, v ) + time of adjacency structurei−1 i operations is . We claimi thatdeg the(v rest) of the algorithm can be implemented to run in a total of Otime.(m ) The rst step of this is an amortized analysis that assigns+ credits to eachk hyperedge when it is created, so that when the hyperedge is removed,O( thec(m algorithm+ k)) can aord an extra running time+ of . The initial hypergraph requires a total of credits. O(m + k) Consider iteration of the algorithm, and let |U | be the hyperedges containingU . The set produced by the algorithm is,U by the end of the iteration, equal to O(|U. So,|) the O(m) hyperedge added in iteration has size , which1 2 summedt over all iterations, requires i credits. i U ,U , … ,U v+ W This amortized analysis assigns credits to the iteration where1 2 t arei thei hyperedgesi + (U ∪ U ∪ ⋯ ∪ U ) ⧵ {v } = N (v+) being manipulated and removed. i i i t deg (v ) O(m ) Therefore, it suces to show thatj=1 iterationj runs in time,1 2 wheret is the number of edge insertion attempts in iteration∑ . First,|U | consider the loop over the hyperedgesU ,U , … ,U . For , t let be the set at the beginning of the iteration that considersj=1 j . Mosti of the operationsi in the loop i O( |U | + k ) k clearly run in time. ∑ 1 2 t i U ,U , … ,U j ∈ [t] Thej exception is the computation of and j . In general, nding when W W U and have values inj is done by having a global array of size modied to represent the contents of . O(|U |) Then can be found in time. Thisj also requiresj j j timej toj modify and reset the relevant array entries. Our implementation maintains suchX = anW array⧵ U that representsY = U ⧵ W as it changes over allA ⧵ Biterations,A in aB total of time.[n] This allows to be computed in n time. B If A ⧵isB empty, our algorithmO(|A|) can end iteration of theO inner(|B|) loop early. Otherwise, the number of edge + W t insertion attemptsi i in this iteration is at leastj . In thisi case, the set is found in |N (v )| Y O(|U |) j Y j j j j j j j |X × Y |6≥ |X | X O(|W | + |U |) time. Note that

So, the running time of these operations summed over all iterations is . j j j j j j j j Finally, we consider the| hypergraphW | + |U | ≤ ( data|W ⧵ structureU | + |U |) used + |U to| = ecientlyO(|X | + |U determine|). the hyperedges that t contain a vertex , and how this data structure is updated throughout the algorithm.j=1 In thej implementation,i each hyperedge ever created has a marker that determines whetherj it∈ is [t valid] O or(∑ invalid|U | + (i.e.,k ) whether the hyperedge has since been removed). There is also a array of lists that determines, for each vertex , the list of all hyperedgesa (valid or invalid) that contain it. This data structure is ecient to use and maintain. When a hyperedge is inserted, we iterate through all and add a pointer to to the list of vertex . a The bottleneck of the algorithm is the total number of attempted edge insertions across all vertex pairs U. A trivial bound on the total runningb ∈ timeU of this step is .U Improving on this requiresb a careful amortized analysis. Note that the algorithm may attempt to insert an edge between the same pair of vertices multiple times. Our approach is to investigate and bound precisely3 how many times an edge in is(x, attempted y) ∈ X × Y to be inserted. The lemma below is the key technical resultO( inn ) the analysis of the algorithm. + Lemma 3.5. The number of edge insertion attempts is at most , where the E is the degree of in the original graph. + {u,v}∈E Proof. Each not in is never inserted by the algorithm.∑ So, it sucesmin(deg( to showu), deg( thatv)) for all deg(v), the insertion ofv is attempted at most times. Suppose , and assume without loss of generality that+ . Let be the number of hyperedges that+ contain but{u, not v} . TheE quantity changes over time as the algorithm progresses. + {u, v} ∈ E First, we claim{u, that v} until or is eliminated,min(deg(u),onlydeg(v decreases)) over time.{ Thisu, v} is ∈ becauseE the only operations done to hyperedgesdeg( is tou) merge = min(deg( themu and), deg( tov delete)) eliminatedf (u, v) vertices. Merging hyperedges does notu increase thev number that contain but not , so until or is eliminated, cannot increase. Next, we claim that for eachu timev the algorithmf ( attemptsu, v) to insert , strictly decreases. This is because an insertion attempt only happens when a set containing but not is merged with a set that contains . So, after the merge operation, u hasv decreasedu by atv least one. f (u, v) Finally, note that when all of the hyperedges are rst initialized, {u, v}isf ( atu, most v) . All insertion attempts for must happen before or is eliminated, and duringu this time,v . Thus, there are at mostv insertionf (u, v) attempts for the edge . f (u, v) deg(u) Corollary 3.6.{u,There v} are edge insertionu v attempts, where is the maximum degreef+(u, v of) ≥ the0 input graph. deg(u) = min(deg(u), deg(v)) {u, v} ∈ E We note that the approximate+ minimum degree algorithm (AMD) of Amestoy, Davis, and Du [ADD96] also emits a tighter time complexityO(Δm ) of on bounded-degreeΔ graphs [HEKP01]. This is one of the key reasons why it is exceptionally useful for reordering linear systems of equations on grid graphs. Now we present a useful folklore result that+ allows us to make the sum over minimum degrees expression in Lemma 3.5 more comprehensible. ThisO( inequalitym ) leverages the existence of a structured edge orientation of its input graph and holds for any nonnegative assignment to the vertices, including the degree function.

Fact 3.7. Let be a simple graph and . For any vertex function , we have

≥0 G = (V,E) m = |E| f ∶ V → ℝ √ {u,v∑}∈E min(f (u), f (v)) ≤ 2m v∑∈V f (v).

7 Proof. We rst claim there is an orientation of such that each vertex has out-degree at most . Orient the edge such that if , then . Let out denote the out-degree of . Then √ E out 2m {u, v} u → v out deg(u) ≤ deg(outv) deg (u) u 2 Therefore, every vertex has out-degree at most . The result then follows from the inequality 2m ≥ v∈N∑ (u) deg(v) ≥ v∈N∑ (u) deg(u) ≥ deg (u) .

√ out 2m out which completes the proof. √ {u,v∑}∈E min(f (u), f (v)) = u∑∈V v∈N∑ (u) min(f (u), f (v)) ≤ u∑∈V v∈N∑ (u) f (u) ≤ 2m u∑∈V f (u).

Corollary 3.8. The number of edge insertion attempts is . In particular, it is at most .

Proof. First, we apply Fact 3.7 to the graph using the degree function of the input graph . √ + The bound then follows from Lemma 3.5 and theO(m factm that) . The O(nm)bound is a consequence of the inequality . + + (V,E ) G = (V,E) √ v∈V WeO(m arem now) prepared to prove our+ main2 theorems about the FastMinimumDegree∑ deg(v) = 2malgorithm.O(nm Our) rst result states that the algorithm runsm in ≤ n time, matching the conditional hardness result in Corollary 1.4. Our second result is an output-sensitive bound on the running time that demonstrates the nuances in the speed of the algorithm across various inputs. The two proofs are analogous to each other, but use dierent adjacency structures for the ll graphO in(nm order) to achieve a space-time tradeo that is benecial in practice.

Proof of Theorem 1.1. We use an adjacency matrix to represent fill_graph. Thus, initializing fill_graph requires time and space. Note that we may assume is connected, so . Using Lemma 3.4, the algorithm runs in time since adjacency matrices support constant-time edge queries, insertions, and deletions.2 Here is the total number of edge insertion attempts. By Corollary 3.8, we have . Therefore,O( then ) overall running+ time is bounded by G m ≥ n −1 , as desired. O(m + k) Proof of Theorem 1.2k. We represent fill_graph as an2 adjacency+ list where2 2 the neighborhood of everyk = O( nodenm) is stored in a balanced binary search tree [CLRS09O, Chapter(n +m 13].+k) Each = O(n edge+n query+nm) and = O update(nm) costs . Initializing requires time and space. The algorithm then runs in time by Lemma 3.4, where is the number of edge insertion attempts. The output-sensitive bounds in Corollary 3.6 and Corollary 3.8 imply that . Since we have + O(log n), the time complexityG follows.O(m log Further,n) the totalO(m space) used is because of theO binary((m + searchk) log n trees.) k √ + + + √ +√ + √ + √ + k = O(min{m m , Δm }) + m = m m ≤ n m = O(m m ) 4 Improved SETH-Based Hardness O(m ) Now we armatively answer a conjecture of Fahrbach et al. in [FMP 18] about the conditional hardness of nding a minimum degree ordering. In particular, we prove the following stronger result. + Theorem 1.3. Assuming the strong exponential time hypothesis, there does not exist an algorithm for computing a minimum degree elimination ordering, where is the maximum degree of the original graph, for any and . 2−" k O(m Δ ) Δ " > 0 k ≥ 0

8 The previous best SETH-based lower bound in [FMP 18] ruled out the existence of a nearly linear time algorithm for computing an exact minimum degree ordering by showing that a time algorithm could be used to solve any instance of the orthogonal vectors+ problem in subquadratic time, for any . Our approach has several similarities to that of Fahrbach et. al, and a consequence of4/3− our" main hardness result gives a nearly matching lower bound for the running time of the FastMinimumDegreeO(m ) algorithm. " > 0 Corollary 1.4. Assuming the strong exponential time hypothesis, there does not exist an time algorithm for computing a minimum degree elimination ordering, for any . 1−" The key to our reduction is a recursive algorithm for constructing a graph with O(nmvertices) and edges such that after any minimum degree ordering eliminates all but vertices," > 0 the resulting graph is . Although this construction was originally motivated by connections to SETH-based hardness, it has several O(n log n) interesting standalone properties. In particular, it demonstrates a case where the minimum degree heuristicn has extremely poor performance (i.e., it is an input of size thatn always results in ll edges).K

4.1 Constructing Sparse Min-Degree -Fillers 2 O(n log n) Ω(n ) Our goal in this subsection is to construct sparse graphs that contain the vertex set and have the additional property that by repeatedly eliminating a minimum degree vertex, the resulting ll graph is eventually . We begin by dening several specic propertiesU that are helpful for presenting our construction. U U Denition 4.1. A -ller is a graph with vertex set , where , such that after eliminatingK all of the vertices in , the resulting ll graph is . We call the set of extra vertices.

Many of the graphsU we construct haveG a subset of extra+ U vertices∪W similarU ∩ toW the= ∅ one in this denition. When W U taking the union of graphsW with extra vertices, weG always= K assume theW sets of extra vertices are disjoint. A simple example of a -ller is the star graph with vertices , where is the center vertex with degree . Although stars are sparse, their maximum degree can be arbitrarily large. This is the main challenge in designing adversarial inputs for minimum degree algorithms. Note that is itself a -ller. U U ∪ {w} w Denition 4.2.|U | A -ller is min-degree if after eliminating any proper subset of extra vertices , all U of the minimum-degree vertices in are extra vertices. K U

It immediately followsU from Denition+ 4.2 that every minimum degree elimination ordering of a min-degreeX ⊂ W X -ller eliminates all of the extra verticesG in before any of the vertices in . Another key property we use in our construction is the following notion of degree bound.

UDenition 4.3. A -ller is -bounded if afterW eliminating any subset of extra verticesU , all remaining extra vertices have degree at most in .

The rst graphU constructiond we use is+ called a -comb. We dene a -comb to consistX ⊆ W of a path of X extra vertices together with edgesd thatG form a matching between the path vertices and those in . Lemma 4.4. A -comb is a -bounded -ller. U U |U | Proof. The extra vertices of the|U | -comb form a connected component, so eliminating them resultsU in . Now suppose someU subset of|U extra| verticesU is eliminated, and let be one of the remaining extra vertices. Consider the neighbors of in the ll graph. Let be another extra vertex of the -comb. If has notU been eliminated, cannot be adjacentU to ’s neighbor in . So for any of the other extra vertices,K has at most one neighbor in the ll graph. Since is adjacent to av single other vertex in , it follows that the -comb is -bounded.v w ≠ v U w v w U |U | − 1 v v 9 U U |U | There is also a straightforward way to combine -combs to obtain -bounded -llers for any , although the size of the solution depends on the ratio .

Lemma 4.5. Let and suppose . Then weU can construct a -boundedd -llerU with dedges≥ 2 and maximum degree . |U |/d

Proof. We partitiond ≥ 2 into parts|U |/d ≤ c each of size at mostd . WeU then let Obe(|U the|c) union of -combs overO( allc) unordered pairs . The result of eliminating all extra vertices of is the union of , which is exactly 1 .2 Since k , the combs are all -bounded by Lemma 4.4. Therefore,U Ois(c a) -boundedU ,U , …-ller.,U [ Wek] constructed fromd/2 combsG each with i j 2 (U ∪ U ) i j {i, j} ∈ G edges, so has U ∪U edges. TheU extra verticesi  j of the combs have maximum degree , but each vertex in hasK degree exactly , so theK maximum|U ∪ degreeU | ≤ d of/2 +isd/2 = .d 2 d 2 G d U G O(c ) O(d) We nowG useO Lemma(c d) = O 4.5(|U to|c) construct min-degree -llers. The main idea of our approach3 is to (1) recursivelyU construct min-degreek − llers 1 for two halves of , and (2)G connectO(c) the halves using a new -ller with edges whose extra vertices are guaranteed to be eliminated before any vertices in . Combining this idea with divide-and-conquer, we show that the solutionU is of size . Before proceeding to the proof, we reiterate that all extra vertices introduced inU this construction are unique. U O(|U |) U Theorem 4.6. We can construct a -bounded min-degree -ller withO(|U | log|U |) vertices and edges, and maximum degree .

Proof. We prove this theorem by( describing|U | − 3) a recursive divide-and-conquerU O(| algorithm.U | log|U |) In the base case when , simply returnO(log|U |). Since has no extra vertices, it is a -bounded min-degree -ller. Now suppose , and partition into and with sizes and , respectively. We then recursively apply the theoremU to constructU min-degree llers and for and . Finally, we apply |U | ≤ 7 K K (|U | − 3) U Lemma 4.5 to construct a -bounded 1 -ller 2 . (We can do this because .) |U | ≥ 8 U U U ⌊|U |/2⌋ ⌈|U |/2⌉ Then we return the union . 1 2 1 2 G G U U Since we have that , , and3 are -bounded. Since is a -ller, (⌊|U |/2⌋ − 2) U G ⌊|U |/2⌋ − 2 ≥ 8/2 − 2 = 2 so is . Therefore,1 2 3 is a -bounded -ller. Since , this implies in G ∪ G ∪ G particular that is -bounded.1 2 3 3 ⌈|U |/2⌉ − 3 ≤ ⌊|U |/2⌋ − 2 G G G (⌊|U |/2⌋ − 2) G U Suppose1 2 for contradiction3 that1 2 3 is not min-degree, i.e., after eliminating some proper subset of G ∪ G ∪ G G ∪ G ∪ G (⌊|U |/2⌋ − 2) U |U | ≥ 8 extra vertices, there1 is2 a vertex3 of minimum degree. Let be the part of that contains . Note that G ∪ G ∪ G (|U | − 3) the degree of in after elimination1 2 3 is at least that of in after eliminating the corresponding G ∪G ∪G extra vertices of . So for to have minimum degree, the min-degreei property of implies all extra u ∈ U U U u vertices of are eliminated.1 2 3 Then, since is a -ller, the degreei of is at least . u G ∪ G ∪ G u G But since i is -bounded, this implies that all extra vertices were eliminated,i which is G u G impossible. Therefore,i is min-degree.i i i G G U u |U | − 1 ≥ ⌊|U |/2⌋ − 1 Finally,1 we claim2 3 that has edges and maximum degree . Since G ∪ G ∪ G (⌊|U |/2⌋ − 2) 1 2 3 G ∪ G ∪ G 1 2 3 G ∪ G ∪ G O(|U | log|U |) O(log|U |) has edges and maximum degree by Lemma 4.5. Now consider the divide-and-conquer nature of the construction. The number|U |/(⌊| ofU edges|/2⌋ − when 2) ≤ |U |/(|U |/2follows − 3) = a 2/(1 recurrence − 6/|U |) of≤ the8, form , which3 has the solution . So, the resulting graph has vertices and edges. The GdegreesO of(|U all|) extra vertices are , andO any(1) vertex in is adjacent to at most llers across all recursive levels. Therefore, the overall maximum|U | degree= n is . f (n) = 2f (n/2)+O(n) f (n) = O(n log n) O(|U | log|U |) O(1) U O(log|U |) 10 O(log|U |) 4.2 Reduction from Orthogonal Vectors We now use our min-degree -ller construction to demonstrate the hardness of nding an exact minimum degree ordering, assuming SETH. Our connection to SETH is through the following problem.

Denition 4.7. The clique unionU problem takes as input a set of vertices with and subsets of the vertices , where , and asks whether . Lemma 4.8. Assuming the strong exponential time hypothesis, for any , there is no time algorithm 2 1 V 2 |V | =d n 1 2 d U U U V for the cliqueU ,U union, … ,U problem.⊆ V d = Θ(log n) K ∪ K ∪ ⋯ ∪ K = K 2−" Proof. Let each set correspond to the set of vectors with a nonzero" > entry0 in the O-th(n dimension.) There is a pair of orthogonal vectors if and only if the union is not the complete graph . Therefore, the resulti follows from Theorem 2.3([Wil05]). U 1 2 d i U U U V Our approach to prove Theorem 1.3 using Lemma 4.8K is∪ outlinedK ∪ ⋯ in∪ AlgorithmK 2 below. It is essentiallyK a reduction from the clique union problem to the problem of nding an exact minimum degree ordering. The graph on which we call the minimum degree ordering subroutine is built as a union over -llers produced by Theorem 4.6. As we prove below, has special properties that, given any minimum degree ordering, allow us to eciently determine the answer to the clique union instance. i G U Algorithm 2 Decides if G . 1: function ClieUnion(vertex sets and ) 1 2 d 2: for to do U U U V K ∪ K ∪ ⋯ ∪ K = K 3: Let be a min-degree -ller constructed1 2 usingd Theorem 4.6 4: Let V U ,U , … ,U ⊆ V i = 1 d 5: Let bei the set of extra verticesi of G U 6: Set elimination_ordering1 2 d MinimumDegreeOrdering 7: for G ←toG ∪ Gdo∪ ⋯ ∪ G 8: ifWelimination_ordering G then 9: return false ← (G) 10: Set i = 1 elimination_ordering|W | 11: Determine the vertices in that[i] are ∉ W reachable from via paths whose internal vertices are in 12: Let be the number of vertices in that are reachable from , including 13: returnv ← [|W | + 1] G v W k V v v Lemma 4.9. If MinimumDegreeOrdering returns a minimum degree ordering, then ClieUnion correctly k = |V | decides if . false Proof. First,1 consider2 the cased where ClieUnion terminates early by returning on line 9. Then for U U U V some properK subset∪ K ∪ ⋯ ∪ K, a minimum= K degree vertex of is not in . Suppose is an index such that . By Theorem 4.6, is a min-degree -ller. By considering the ll graph of after eliminating all + vertices in , it follows that all the extra vertices of X have been eliminated. Therefore, the degree X ⊂ W v G W i of ini equals that of i in i . But Theorem 4.6 guarantees thati for all , is v ∈ U G U G -bounded, andi thus -bounded. So since i , the degree of in is at + X ∩ V (G ) 1 2 d G most X . Therefore, the algorithmU U correctly decidesU that . i v G v K ∪ K ∪ ⋯ ∪ K 1 2 i ∈ [d] d G i Now assume that the algorithm does not terminate early. Then the vertex thatU is chosenU on lineU 10 is (|U | − 3) (|V | − 2) X ≠ W 1 2 v d K ∪ K ∪ ⋯ ∪ K the minimum degree vertex of . Since is a -ller for allU U , U V . Recall |V | − 2 K ∪ K ∪ ⋯ ∪ K ≠ K + + v 1 2 d W i i11 W U U U G G U i ∈ [d] G = K ∪ K ∪ ⋯ ∪ K that an edge is in if and only if there is a path from to in with internal vertices in . It follows that the value of found by the algorithm is one plus the degree of in . Therefore, if + and only if , so theW algorithm returns the correct decision. {u, v} G u v G + W W Lemma 4.10.+ If MinimumDegreeOrderingk runs in time (for somev G and ) onk input= |V | V with edgesG and= K max degree , then ClieUnion runs in time for some , where . 2−" k ¨ Proof. For all , the graph is constructed in O(m time,Δ 2−) " hask+2 "vertices > 0 ¨ andk ≥ edges,0 and hasG maximumm degree by ΔTheorem 4.6. Therefore, hasO(n d ) vertices and edges" > 0 and maximumn = |V | degree . We can computei the union of two graphs of size in time, so we can construct ini ∈ [d] time.G The next step ofO the(n log algorithmn) is toO run(n logMinimumDegreeOrderingn) , and the running timeO(log ofn this) step is G O(nd log n) O(d log n) 2 O(m) O(m log m) G O(nd log n) (G) ¨ for some . To2− determine" k reachability2−" at line 11k of the algorithm,2−" k+2 itk suces+2 to use2− a" breadth-rstk+2 search that runs in Om Δ  = O(nd logtime.n) Therefore,(d log n)  the= O algorithmn d runslog inn = On dtime., ¨ ¨ We conclude" > 0 with the proof of our improved conditional hardness result for2− computing" k+2 exact minimum degree eliminationO(|E(G) orderings.|) = O(nd log Then) complementary lower bound in CorollaryO( 1.4n immediatelyd ) follows. Proof of Theorem 1.3. Assume for contradiction that an time algorithm exists for computing a min- imum degree ordering. By Lemma 4.9 and Lemma 4.10, we can to obtain an time algorithm for 2−" k deciding if , for some . For instances where ¨ , this algorithm runs in time , for some O(m. However,Δ ) this contradicts2−" k+2 SETH by Lemma 4.8, 1 2 d ¨ O(n d )2 so the result follows.U U¨ U V ¨¨ K ∪2−K" ∪ ⋯2(k+2)∪ K = K 2−" " > 0¨¨ d = Θ(log n) O(n log n) = O(n ) " > 0 5 Conclusion

We have presented a new combinatorial algorithm for computing an exact minimum degree ordering with an worst-case running time. This is the rst algorithm that improves on the naive algorithm. We achieve this result using a careful amortized analysis, which also leads to strong output-sensitive bounds for the algorithm. 3 OWe(nm also) show a matching conditional hardness of , for any and , whichO(n armatively) answers a conjecture in [FMP 18] and implies there are no minimum degree algorithms with running time or , assuming SETH. Together with2−" thek algorithm, this nearly characterizes the time complexity for computing+ an exact minimumO(m degreeΔ ) ordering." > 0 Extendingk ≥ 0 our -ller graph 1−" 2 construction to achievev∈V ne-grained hardness results for other elimination-based greedy algorithms is of independentO(nm ) O interest(∑ deg( andv an) ) exciting future direction of this work.O(nm) U Acknowledgments

We thank Richard Peng for many helpful discussions about the ideas in this paper.

12 References

[ADD96] Patrick R. Amestoy, Timothy A. Davis, and Iain S. Du. An approximate minimum degree ordering algorithm. SIAM Journal on Matrix Analysis and Applications, 17(4):886–905, 1996.

[AKR93] Ajit Agrawal, Philip Klein, and Ramamurthy Ravi. Cutting down on ll using nested dissection: Provably good elimination orderings. In Graph Theory and Computation, pages 31–55. Springer, 1993.

[Ash95] Cleve Ashcraft. Compressed graphs and the minimum degree algorithm. SIAM Journal on Scientic Computing, 16(6):1404–1411, 1995.

[BCCR19] David Bergman, Carlos H. Cardonha, Andre A. Cire, and Arvind U. Raghunathan. On the minimum chordal completion polytope. Operations Research, 67(2):532–547, 2019.

[BCK 16] Ivan Bliznets, Marek Cygan, Pawel Komosa, Lukáš Mach, and Michał Pilipczuk. Lower bounds for the parameterized complexity of minimum ll-in and other completion problems. In + Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1132–1151. SIAM, 2016.

[BFPP18] Ivan Bliznets, Fedor V. Fomin, Marcin Pilipczuk, and Michał Pilipczuk. Subexponential parame- terized algorithm for interval completion. ACM Transactions on Algorithms (TALG), 14(3):1–62, 2018.

[CKL 09] Flavio Chierichetti, Ravi Kumar, Silvio Lattanzi, Michael Mitzenmacher, Alessandro Panconesi, and Prabhakar Raghavan. On compressing social networks. In Proceedings of the 15th ACM + SIGKDD international conference on Knowledge discovery and data mining, pages 219–228, 2009.

[CLRS09] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Cliord Stein. Introduction to Algorithms. MIT press, 2009.

[CM69] Elizabeth Cuthill and James McKee. Reducing the bandwidth of sparse symmetric matrices. In Proceedings of the 1969 24th National Conference, pages 157–172. ACM, 1969.

[CM16] Yixin Cao and Dániel Marx. Chordal editing is xed-parameter tractable. Algorithmica, 75(1):118– 137, 2016.

[CS17] Yixin Cao and RB Sandeep. Minimum ll-in: Inapproximability and almost tight lower bounds. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 875–880. SIAM, 2017.

[FGP 20] Matthew Fahrbach, Gramoz Goranci, Richard Peng, Sushant Sachdeva, and Chi Wang. Faster graph embeddings via coarsening. arXiv preprint arXiv:2007.02817, 2020. + [FMP 18] Matthew Fahrbach, Gary L. Miller, Richard Peng, Saurabh Sawlani, Junxing Wang, and Shen Chen Xu. Graph sketching against adaptive adversaries applied to the minimum de- + gree algorithm. In 2018 IEEE 59th Annual Symposium on Foundations of Computer Science (FOCS), pages 101–112. IEEE, 2018.

[FV13] Fedor V. Fomin and Yngve Villanger. Subexponential parameterized algorithm for minimum ll-in. SIAM Journal on Computing, 42(6):2197–2216, 2013.

13 [Geo73] Alan George. Nested dissection of a regular nite element mesh. SIAM Journal on , 10(2):345–363, 1973.

[GL79] Alan George and Joseph W. H. Liu. A quotient graph model for symmetric factorization. In Sparse Matrix Proceedings, pages 154–175, 1979.

[GL80] Alan George and Joseph W. H. Liu. A minimal storage implementation of the minimum degree algorithm. SIAM Journal on Numerical Analysis, 17(2):282–299, 1980.

[GL81] Alan George and Joseph W. Liu. Computer Solution of Large Sparse Positive Denite. Prentice Hall Professional Technical Reference, 1981.

[GL89] Alan George and Joseph W. H. Liu. The evolution of the minimum degree ordering algorithm. SIAM Review, 31(1):1–19, 1989.

[GNP94] John R. Gilbert, Esmond G. Ng, and Barry W. Peyton. An ecient algorithm to compute row and column counts for sparse cholesky factorization. SIAM Journal on Matrix Analysis and Applications, 15(4):1075–1091, 1994.

[GVL13] Gene H. Golub and Charles F. Van Loan. Matrix Computations. The Johns Hopkins University Press, fourth edition, 2013.

[HEKP01] Pinar Heggernes, S. C. Eisestat, Gary Kumfert, and Alex Pothen. The computational complexity of the minimum degree algorithm. Technical report, Institute for Computer Applications in Science and Engineering, 2001.

[KST99] Haim Kaplan, Ron Shamir, and Robert E. Tarjan. Tractability of parameterized completion problems on chordal, strongly chordal, and proper interval graphs. SIAM Journal on Computing, 28(5):1906–1922, 1999.

[Liu85] Joseph W. H. Liu. Modication of the minimum-degree algorithm by multiple elimination. ACM Transactions on Mathematical Software (TOMS), 11(2):141–153, 1985.

[LRT79] Richard J. Lipton, Donald J. Rose, and Robert E. Tarjan. Generalized nested dissection. SIAM Journal on Numerical Analysis, 16(2):346–358, 1979.

[Mar57] Harry M. Markowitz. The elimination form of the inverse and its application to linear program- ming. Management Science, 3(3):255–269, 1957.

[MB83] David W. Matula and Leland L. Beck. Smallest-last ordering and clustering and graph coloring algorithms. Journal of the ACM (JACM), 30(3):417–427, 1983.

[NSS00] Assaf Natanzon, Ron Shamir, and Roded Sharan. A polynomial approximation algorithm for the minimum ll-in problem. SIAM Journal on Computing, 30(4):1067–1079, 2000.

[OSS20] Wolfgang Ost, Christian Schulz, and Darren Strash. Engineering data reduction for nested dissection. arXiv preprint arXiv:2004.11315, 2020.

[Ros72] Donald J. Rose. A graph-theoretic study of the numerical solution of sparse positive denite systems of linear equations. In Graph Theory and Computing, pages 183–217. Elsevier, 1972.

14 [Tar76] Robert E. Tarjan. Graph theory and . In Sparse Matrix Computations, pages 3–22. Elsevier, 1976.

[WAPL14] Yu Wu, Per Austrin, Toniann Pitassi, and David Liu. Inapproximability of treewidth and related problems. Journal of Articial Intelligence Research, 49:569–600, 2014.

[Wil05] Ryan Williams. A new algorithm for optimal 2-constraint satisfaction and its implications. Theoretical Computer Science, 348(2-3):357–365, 2005.

[Wil18] Virginia Vassilevska Williams. On some ne-grained questions in algorithms and complexity. In Proceedings of the ICM, 2018.

[Yan81] Mihalis Yannakakis. Computing the minimum ll-in is NP-complete. SIAM Journal on Algebraic Discrete Methods, 2(1):77–79, 1981.

15