A Fast Minimum Degree Algorithm and Matching Lower Bound

07/28/2019 ∙ by Robert Cummings, et al. ∙ University of Waterloo Georgia Institute of Technology 0

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 rich history of bridging techniques from data structures, graph algorithms, and direct methods in scientific computing. We present a simple but novel combinatorial algorithm for computing minimum degree elimination orderings in O(nm) time that relies on a careful amortized analysis. Furthermore, we show that there cannot exist an algorithm for this problem that runs in O(nm^1-ε) time, for any ε > 0, assuming the strong exponential time hypothesis.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The minimum degree algorithm is one of the most widely-used heuristics for reducing the cost of solving sparse linear systems of equations. The algorithm was first 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 scientific computing 

[Ros72, Tar76, GL79, GL81, GL89]. These advancements culminated in the approximate minimum degree algorithm (AMD) of Amestoy, Davis, and Duff [ADD96], which plays a critical role in the sparse linear algebra libraries in Julia, MATLAB, Mathematica, and SciPy. Concretely, the minimum degree algorithm is a preprocessing step that permutes the rows and columns of a sparse symmetric positive-definite matrix before applying Cholesky decomposition in order to minimize the number of nonzero entries in the Cholesky factor. Without a judicious reordering, the decomposition typically becomes dense with fill-in (i.e., additional nonzeros). The objective of the minimum degree algorithm is to efficiently compute a permutation matrix P such that the Cholesky factor L in the reordered matrix 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. For further details and motivation, see “The Sparse Cholesky Challenge” in [GVL13, Chapter 11.1].

The minimum degree algorithm leverages a separation between the structural 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 edges. Note that permuting the matrix by 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 matrix decomposition, each greedy step corresponds to performing row and column permutations that minimize the number of off-diagonal non-zeros in the pivot row and column. We point out that a clique is induced on the neighbors of in the subsequent graph because of the commonly-used no numerical cancellation assumption (i.e., nonzero entries remain nonzero). Motivated by the ubiquity of reordering algorithms in sparse linear algebra libraries and also by a recent development in the hardness of computing minimum degree orderings [FMP18], we investigate the time complexity of the minimum degree ordering problem from both a theoretical and practical perspective.

1.1 Results and Techniques

Our main results complement each other and nearly characterize the time complexity for computing a minimum degree elimination ordering. The first result is a simple but novel combinatorial algorithm that computes an exact minimum degree ordering in time. This algorithm efficiently avoids the redundant computation incurred by the naive algorithm and emits an elegant amortized analysis.

Theorem 1.1.

The FastMinimumDegree algorithm produces a minimum degree ordering in time.

To achieve this result, we augment the disjoint-set data structure to maintain sets of reachable vertices through eliminated vertices, similar to quotient graphs in the minimum degree literature [GL81]. Then we bound the time of all of its merge operations via a potential function and disjoint decomposition of vertices.

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 [FMP18].

Theorem 1.2.

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 original graph, for any and .

This result is given in its full generality above and it implies an answer to -hardness conjecture posed in [FMP18]. Specifically, we have the following matching lower bound for our main algorithm.

Corollary 1.3.

Assuming the strong exponential time hypothesis, there does not exist an  time algorithm for computing a minimum degree elimination ordering, for any .

The conditional hardness in Theorem 1.2 also rules out the existence of an

algorithm, assuming the strong exponential time hypothesis. The approach we use to prove this hardness result reduces the orthogonal vectors problem 

[Wil05] to computing a minimum degree ordering on a sparse graph built using a careful recursion construction. The graph gadgets we develop in Section 4 meet challenging sparsity and low-degree requirements necessary for the fine-grained reduction and are likely of independent interest.

1.2 Related Works

Finding elimination orderings that minimize fill-in is closely related to chordal graph completion and is known to be NP-complete [Yan81, BS90]. Algorithms that approximate the fill-in to within polynomial factors have been studied [NSS00], as well as fixed-parameter algorithms [KST99, FV13] and corresponding hardness results [WAPL14, BCK16, CS17]. To the best of our knowledge, there do not exist any algorithms that produce an exact minimum degree ordering in time faster than , so our algorithm is a significant step forward in characterizing the time complexity of computing a minimum degree ordering.

Algorithms such as the multiple minimum degree algorithm (MMD) [Liu85] and approximate minimum degree (AMD) [ADD96] have been mainstays in direct methods for sparse linear system solvers but have some potential drawbacks. The running time of MMD is and is known to be tight. On the other hand, AMD runs in but achieves its substantial speedup by using inexpensive upper bounds as a proxy to the true vertex degrees. A recent advancement of Fahrbach et al. [FMP18] shows the existence of an algorithm for computing a -approximate minimum degree elimination ordering in time, but it is currently quite far from being practical.

2 Preliminaries

2.1 Fill Graphs and Minimum Degree Orderings

For a connected undirected graph , let denote the neighborhood of the vertex  and denote the degree. We overload to denote the neighborhood of a set of vertices. For two graphs and let be their union, and for a given set of vertices let be the complete graph with vertex set . We also regularly use the shorthand . Our notation for fill graphs extends that of Gilbert, Ng, and Peyton [GNP94], who gave an extremely efficient algorithm to compute the number of nonzero entries in each row and column of the Cholesky factor for a given elimination ordering.

Definition 2.1.

Let be an undirected graph and . The fill graph is the graph resulting from eliminating the vertices in . It is defined by and if and only if there is a -path in such that all of the internal vertices are in .

This characterization of fill-in allows us to compute the fill degree of a vertex in any partially eliminated state without explicitly computing the eliminated matrix. Formally, we can also view  as the nonzero structure of the Schur complement of the adjacency matrix . Note that we use and without subscripts to refer to the input graph .

An elimination ordering naturally induces a sequence of fill graphs such that and is the empty graph, and we reserve this notation for minimum degree orderings.

Definition 2.2.

A minimum degree elimination ordering is permutation of the vertices such that for all .

Several popular tie-breaking strategies exist when there are many vertices with minimum degree [GL89]. For example, choosing the lexicographically least vertex defines a canonical minimum degree ordering, and eliminating a maximal independent set all at once is the key idea behind the MMD algorithm [Liu85].

2.2 SETH-Hardness for Computing 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], and many of these results rely on a fine-grained reduction to the orthogonal vectors problem and make use of the following theorem.

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.

We take a similar approach and build on the work of [FMP18], which shows how the orthogonal vectors problem can be viewed as deciding whether the fill graph of a certain partially eliminated bipartite graph is a clique. The orthogonal vectors problem is often posed as deciding if there exists a pair of orthogonal vectors from two different sets, but we can reduce this problem to considering a single combined set by appending to all vectors in the first set and to all vectors in the second set.

3 A Fast Minimum Degree Algorithm

In this section we present a new combinatorial algorithm called FastMinimumDegree for computing exact minimum degree orderings and prove the following theorem.

See 1.1

We start with a high-level description of our algorithm before presenting it formally. Then we use amortized analysis in Section 3.1 to show that its running time matches the lower bound in Corollary 1.3.

Throughout the algorithm, we maintain a disjoint-set data structure [CLRS09, Chapter 21] modified for reachability on the vertices of . Specifically, for every disjoint set whose root is , we maintain a set called that contains the vertices that are reachable from through eliminated nodes in . We also maintain an adjacency matrix and degree sequence corresponding to the state of the fill graph at each point of the algorithm as it eliminates vertices and merges disjoint sets. To see the key insight behind the design of our fast algorithm, let be a minimum-degree vertex in the fill graph . In order to transition from to , a naive algorithm would iterate over all pairs of active neighbors and add an edge between and if they are not adjacent. However, if the algorithm has previously introduced the fill edge , then this operation is redundant and can potentially be avoided. Our algorithm uses the reachability data structure to efficiently filter the set of vertices on which we induce a clique and never considers the same pair twice. The main challenge in the analysis of our algorithm is bounding the total running time needed to induce cliques on pairs of vertices in the refined neighborhood sets and  as it eliminate vertices. This requires careful use of a potential function that bounds the number of edge additions needed to build an intermediate disjoint set of eliminated vertices over its history of merges.

Now we formally present our algorithm FastMinimumDegree in Algorithm 1 along with its underlying data structure for efficiently maintaining reachability through the eliminated vertices.

1:function FastMinimumDegree(adjacency list for undirected graph called input_graph)
2:     Let
3:     Initialize arrays and to agree with input_graph
4:     Initialize arrays to true and to
6:     for  to  do
7:         Let be the active vertex minimizing
8:         Set
9:         Set
10:         for vertex  do
11:              if  then
12:                  for vertex  do
13:                       if  then
14:                           Add edge to adjacency_matrix if not present and increment degree                                          
15:              else
17:         for  to  do
18:              Delete edge from adjacency_matrix if present and decrement degree               
19:     return elimination_ordering
1:function InitializeReachabilityDataStructure
2:     Initialize arrays to and to
3:     for  to  do
4:         Set
5:         Set      
1:function JoinReachable()
2:     if  then
3:         Set
4:         Set
5:         for vertex  do
6:              for vertex  do
7:                  Add edge to adjacency_matrix if not present and increment degree                        
8:         Set
9:         Set      
1:function Root()
2:     if  then
3:         Set      
4:     return
Algorithm 1 A fast minimum degree algorithm for producing exact elimination orderings.

3.1 Analysis of the Algorithm

We analyze the time and space complexity of FastMinimumDegree in three parts. First, we prove the correctness of the algorithm in Lemma 3.1 by showing that it maintains the desired state in each iteration. Second, we show in Lemma 3.2 that the runtime of the algorithm excluding calls to JoinReachable is . Third, we analyze the amortized time complexity across all calls to JoinReachable in Lemma 3.3 and show that the total running time for this component of the algorithm is also .

Lemma 3.1.

At the end of each iteration of FastMinimumDegree, the following are true:

  1. The vertex has the minimum degree in the fill graph .

  2. If a vertex is eliminated, then is the set of vertices reachable from in such that all internal vertices on the path are eliminated.

  3. The state of adjacency_matrix and degree corresponds to the fill graph .


We prove the claim by induction on . After initializing all variables and before entering the main for loop (i.e., iteration ), the second and third properties are true by construction since all vertices are active and . Now we assume the claim as the induction hypothesis. In every iteration , FastMinimumDegree selects the vertex with minimum degree in by the induction hypothesis and stores this vertex in .

For the second property, observe that FastMinimumDegree deactivates and calls for all inactive vertices . At the beginning of iteration , we initially have . Then for each call, the update adds the nodes that are reachable from via eliminated nodes by the induction hypothesis. All nodes  that are eliminated are considered and all nodes in this disjoint set have the same root, so the claim follows.

For the third property, we need to show that a clique is induced on the neighbors of in and that  is removed from the adjacency matrix. Let be the connected components of inactive vertices neighboring defined by the disjoint sets, and let be the set of neighbors of in that are active. The algorithm creates a clique on by adding edges for all pairs if they are not already present. For each connected component of inactive vertices , there is already a clique on the active vertices in by the induction hypothesis. This follows from the fact that if and are connected in  via a path of inactive vertices, then is an edge in by the definition of the fill graph.

Now we show how the calls to complete the clique. Let be nodes of the disjoint sets incident to in , and assume JoinReachable unites them with in this order. The call to completes the clique on the active vertices in since and contains the set of active nodes reachable from  in  using inactive nodes by the second property of the induction hypothesis. The correctness follows from the definitions of and in JoinReachable. At the end of this call, the set of vertices reachable from  via inactive vertices is updated to . In the next step, forms a complete bipartite graph on the active nodes in and , and hence a clique on the active vertices in . Repeating this argument up to shows that there is a clique on the active vertices of in the adjacency matrix. Last, the algorithm deletes all edges for in the adjacency matrix and updates the degree sequence. Therefore, at the end of iteration , the adjacency_matrix and degree arrays correspond to , as desired. ∎

Lemma 3.2.

The running time of FastMinimumDegree excluding the calls to JoinReachable is .


The variable initialization of FastMinimumDegree runs in time if the sets in reachable are represented using boolean arrays of size . The total cost of finding the minimum degree vertices is because there are linear scans over the degree array. There are edge insertions, where is the degree of in the input graph , and each takes time, so it follows that we can bound the complexity of adding edges by . Last, there are potential edge deletions and each runs in . Therefore, the running time of FastMinimumDegree excluding calls to JoinReachable is . ∎

Bounding the total running time across all calls to JoinReachable is less straightforward and requires a careful amortized analysis. At a high level, FastMinimumDegree gradually merges connected components of eliminated vertices in the input graph that are represented using a modified disjoint set data structure, so all together the algorithm makes nontrivial unions. Each time two disjoint sets are merged, the algorithm only considers edges of the induced clique that have not previously been considered. This avoids a substantial amount of redundant computation compared to the naive algorithm. We use a potential function to explicitly bound the number of edge additions needed to form a given disjoint set of eliminated vertices at any point in the algorithm, and we analyze it by considering a refined disjoint decomposition of the relevant vertices and edges of the input graph.

Lemma 3.3.

The amortized running time of JoinReachable over all calls in FastMinimumDegree is .


There are calls to JoinReachable and therefore calls to Root. Without path compression, each call to Root runs in , so we can generously bound the time needed for all calls to Root by . Since JoinReachable unites disjoint sets of inactive vertices, there are nontrivial unions over the course of the algorithm. If JoinReachable performs a nontrivial union, we can construct and in  time assuming the sets are stored as boolean arrays of size . The final update to also takes  time. Therefore, the total running time for all nontrivial calls to JoinReachable excluding the cost of the double for loop over is .

It remains to show that the number of edge insertions across all of the nontrivial unions is . We proceed by analyzing the underlying disjoint sets defined by the parent array. For a given vertex , its disjoint set is defined as . Let be a potential function that counts the number of edge additions across all calls to JoinReachable during FastMinimumDegree needed to form . Since all vertices are eliminated at the end of the algorithm, we want to show that .

For a disjoint set , let be the set of active vertices in the neighborhood of . Note that when JoinReachable unites two disjoint sets, all of the vertices in each set are inactive. Let denote the edges in such that both terminals are in , and let denote the set of edges in such that one terminal is in and the other is in . We prove by induction that for any disjoint set that exists during the course of the algorithm, we have


If this inequality is true, it immediately follows that when the algorithm terminates.

We proceed by induction on the cardinality of . If , then no calls to JoinReachable are needed to form , so and the claim is true. Assume Equation 1 as the induction hypothesis. If , then is the union of the nonempty disjoint sets and . Let be the set of active vertices in the neighborhood of  and let be the set of active vertices in the neighborhood of . Setting , we can partition into the sets since and . Using a disjoint decomposition of the vertices and the observation that , it follows from the induction hypothesis that

Therefore, the upper bound Equation 1 holds by induction and we have , which completes the proof. ∎

Now that we have all the prerequisite lemmas, we can complete our analysis of FastMinimumDegree.

Proof of Theorem 1.1.

The correctness of FastMinimumDegree follows from Lemma 3.1, and the bound for the running time is a consequence of Lemma 3.2 and Lemma 3.3. ∎

We conclude the section by briefly mentioning a few variants of the algorithm that improve its performance in practice. If denotes the total fill incurred by the algorithm, then by using an adjacency list implemented with hash tables instead of an adjacency matrix we have an algorithm whose running time is in expectation but uses space. We also note that any tie breaking strategy also yields an time algorithm, so computing maximal independent sets for mass vertex elimination or generalizing the problem to th order statistic queries does not hinder the running time.

4 Improved SETH-Based Hardness

In this section we affirmatively answer a conjecture of Fahrbach et al. in [FMP18] about the conditional hardness of producing a minimum degree ordering. In particular, we prove the following stronger result.

See 1.2

The previous best SETH-based lower bound in [FMP18] ruled out the existence of a nearly linear time algorithm for computing an exact minimum degree ordering by showing that a time algorithm can 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 of our main hardness result gives a nearly matching lower bound for the running time of the FastMinimumDegree algorithm.

See 1.3

Our analysis begins with the following graph-theoretic connection to the orthogonal vectors problem.

Lemma 4.1.

Assuming the strong exponential time hypothesis, for any , there is no time algorithm that takes as input a set of vertices with and subsets , where , and decides whether .


Let each set correspond to the set of vectors with a nonzero entry in the th dimension. There is a pair of orthogonal vectors if and only if the union is not the complete graph . Therefore, the result follows from Theorem 2.3. ∎

The approach of Fahrbach et al. [FMP18] is to construct a graph such that for any minimum degree ordering, there is a partially eliminated state in which the fill graph contains . The minimum degree ordering is then used to compute the degree of the vertex in with minimum degree, which can be done efficiently using a breadth-first search in via the characterization of fill graphs by reachability in order to determine if . The key difference in our approach is to relax the requirement that a minimum degree ordering always produces . Specifically, since the end goal is to decide if , we allow for a minimum degree ordering of  to not necessarily produce , as long as this allows us to immediately conclude that . This approach allows us to decompose the problem of constructing such a  into that of constructing graphs that produce after partial elimination. We call these graphs -fillers.

Definition 4.2.

A graph is a -filler if and eliminating the vertices not in results in .

In the following subsections, we present a method for efficiently constructing -fillers with several properties useful for minimum degree orderings. First, our construction guarantees that the -fillers are low-degree and sparse. Second, we can combine these -fillers by a composability property to construct larger low-degree, sparse graphs for which finding a minimum degree ordering is hard, assuming SETH.

4.1 Decomposition into -Fillers

We begin by defining a class of -fillers that is convenient for studying minimum degree orderings.

Definition 4.3.

A -filler is proper min-degree if every minimum degree orderings of eliminates the vertices in before vertices in .

Next, when showing that the union of graphs is proper min-degree, we typically need to enforce special conditions on the degrees of vertices in these graphs. Therefore, we give the following definition.

Definition 4.4.

A -filler is -bounded if after any subset of is eliminated, the remaining vertices in have degree at most .

Now that we have established these definitions, we can state our key composition lemma, which allows for the final constructed graph that produces to be made up of a union of -fillers.

Lemma 4.5.

Suppose with and for all , is an -bounded proper min-degree -filler such that the sets are disjoint. Let . If , then is a proper min-degree -filler.


Suppose there is a minimum degree ordering of that eliminates some vertex of before all vertices in are eliminated. Let be the first vertex from to be eliminated, and let be the fill graph obtained by eliminating all vertices in the ordering before . By assumption, there is a vertex that is not yet eliminated, so let be such that is in . Since is -bounded, has degree at most in , and since is eliminated before , the degree of in is at most that of . Therefore, we have . Since has degree in and , there must be some containing such that the -filler still has vertices that are not eliminated. Let  be such a vertex in , and consider the subsequence of the minimum degree ordering of so far containing only vertices in . Since is proper min-degree and the degrees of vertices in are unchanged, it is also a minimum degree ordering of . However, then we must have the inequality , which contradicts being proper min-degree. ∎

4.2 Recursively Constructing Proper Min-Degree -Fillers

In this subsection we present a method for constructing proper min-degree -fillers. Our ultimate goal is to compose these graphs using Lemma 4.5 and leverage the hardness of the clique-union problem in Lemma 4.1. We start by establishing properties of comb graphs, which are the main building block in our construction.

Definition 4.6.

Let a comb graph on be a graph with vertices , where and , such that is the union of a path graph with vertices and a perfect matching of and .

Lemma 4.7.

If is a comb graph on , then is a -bounded -filler.


Suppose all vertices of not in are eliminated. Then since these vertices form a path in , all pairs of vertices are connected by a path with internal vertices not in . Then by the characterization of fill graphs, eliminating all vertices of not in results in . Therefore, is a -filler.

Now suppose a subset is eliminated, and let be a vertex not in that has not been eliminated. Then for any pair of adjacent vertices in such that exactly one of them is in , at most one of the vertices in the pair is not equal to and reachable from by a path with internal vertices in . Therefore, has degree at most in the fill graph, so we have shown that is -bounded, as desired. ∎

In addition to being -fillers, comb graphs have a maximum degree of at most , which is a useful property for ensuring that certain components of our final graph construction have small maximum degree.

We are now ready to give a high-level description of our construction of proper min-degree -fillers. Start by partitioning into two nearly-equal sized parts and , and recursively construct proper min-degree fillers for and . Next, further partition and into a constant number of parts, and for every pair of parts such that and , introduce a comb on the vertices . The crucial observation here is that all of the combs are -bounded for some strictly less than the degree of the vertices in or , so it follows that the final graph is a proper min-degree -filler. We formalize this procedure with the ConstructFiller algorithm below, and we prove its correctness and running time in Lemma 4.9 and Lemma 4.10.

1:function ConstructFiller()
2:     Let
3:     if  then
4:         return
5:     else
6:         Partition into with and
7:         Set
8:         Set
9:         for  to  do
10:              Let be a minimal partition of such that for all we have          
11:         Let be the empty graph
12:         for  do
13:              for  do
14:                  Let be a -comb
15:                  Update                        
16:         return      
Algorithm 2 Recursive construction for proper min-degree -fillers.
Lemma 4.8.

In the algorithm ConstructFiller, the cardinalities and are bounded by a constant.


For each , we have in the branch of the algorithm that constructs . Also, we have clearly have the property that . Therefore, since is minimal, it follows that

which completes the proof. ∎

Lemma 4.9.

The algorithm ConstructFiller constructs a -bounded proper min-degree -filler.


We proceed by induction since the algorithm is recursive. However, we need to prove the stronger claim that the construction is -bounded. In the base case, the algorithm returns , which satisfies the claim trivially since it has no vertices outside of .

Now we let and assume . For each , the graph is a -bounded proper min-degree -filler by the induction hypothesis. Note that for all and , we have

Since is a -comb, we have that is an -bounded -filler by Lemma 4.7. At the end of the algorithm, we have

by construction. Since the are -bounded, if some subset of is eliminated from , the remaining vertices in all have degree at most . Note that this property essentially says that is -bounded, apart from the fact that is not a -filler. Let us refer to as the output of the algorithm.

First, we show that is a -filler. Let be the fill graph obtained by eliminating all vertices of not in , and consider any pair of vertices in . Suppose both vertices are in . Since is a -filler, there is an edge between these vertices in . A similar case happens when both vertices are in . Now suppose that one vertex is in and the other is in . There exist and such that one vertex is in  and the other is in . Since is a -filler and is in , there is an edge between these vertices in . Therefore, is a -filler.

Next, we claim that is -bounded. This follows from the facts that and are -bounded, is essentially -bounded, and , , and are all disjoint outside of .

Lastly, we show that  is proper min-degree. Start by considering any minimum degree ordering of . Let be the first vertex from to be eliminated by this ordering, and assign such that . Furthermore, let  be the graph obtained by eliminating all vertices in the ordering before . Since is proper min-degree, all vertices in must have already been eliminated. Then, since is a -filler,

Since and are -bounded and , all vertices in and must have already been eliminated. Moreover, since satisfies the property analogous to being -bounded, all vertices in must have also already been eliminated. Therefore, all vertices in are eliminated before the vertex , so is proper min-degree. ∎

Lemma 4.10.

For a vertex set with , the algorithm ConstructFiller runs in time and constructs a graph with vertices and edges and maximum degree .


We claim that excluding the recursive calls, adds vertices and edges and increases the maximum degree of the overall graph by at most a constant. For all and is a comb, so it has a linear number of vertices and edges and a maximum degree of at most . Then since the cardinalities and are bounded by a constant, , , and the maximum degree of is bounded by a constant. Therefore, the claim holds.

The construction adds vertices and edges outside of the recursive calls, and this can be implemented to run in time. The recursive calls are on two instances of size and , so by standard analysis of divide-and-conquer algorithms the construction has vertices and edges overall. Furthermore, it runs in time. Finally, for all vertices , the degree of in is bounded by the degree of  in one of or (but not both) plus the degree of  in , which is bounded by a constant. Since the graphs and are built recursively on instances of size at most , the degree of is . Now, the new vertices in added by all belong to combs, so they have degree at most . Therefore, the maximum degree of a vertex in is . ∎

4.3 Combining -Fillers

Now we use our recursive construction for -fillers to design an algorithm that efficiently decides whether or not , given a sufficiently fast minimum degree algorithm. This algorithm constructs a graph by uniting -filler graphs produced by ConstructFiller in Algorithm 2 and then computes a minimum degree ordering for . If an original vertex is eliminated prematurely in the ordering, the algorithm can terminate since this implies that by Lemma 4.5. Otherwise, the first original vertex in the minimum degree ordering is considered, and a breadth-first search is used on to determine if . We present this algorithm as CliqueUnion below.

1:function CliqueUnion()
2:     Set
3:     Let be the empty graph
4:     for  to  do
5:         Set
6:         Update      
7:     Set
8:     Initialize array to true
9:     for  to  do
10:         Set
11:         Set
12:         if  then
13:              return false               
14:     Set
15:     Determine the vertices in that are reachable from via paths whose internal vertices are inactive
16:     Let be the number of active vertices in that are reachable from , including
17:     return
Algorithm 3 Determines if given a minimum degree ordering.
Lemma 4.11.

If MinimumDegreeOrdering returns a minimum degree ordering, then CliqueUnion correctly decides if .


For each , the graph is a -bounded proper min-degree -filler by Lemma 4.9. Using Lemma 4.5, if is not a proper min-degree -filler, then . Therefore, if CliqueUnion returns false on Line 13, then there is a minimum degree ordering of that eliminates a vertex of  before all vertices in have been eliminated, so cannot be proper min-degree. It follows that and the algorithm returns the correct decision.

Now assume that the algorithm does not terminate early. The active vertices in the algorithm are precisely the vertices in . Let be the fill graph resulting from eliminating all of . The vertex  that is chosen is the minimum degree vertex of . Recall 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 satisfies . Therefore, if and only if . Since is a -filler, it follows that . Thus, we have if and only if , so the algorithm returns the correct decision. ∎

Lemma 4.12.

If MinimumDegreeOrdering runs in time, for some and , where has edges and max degree , then CliqueUnion runs in time for some , where .


For all , the graph is constructed in time, has vertices and edges, and has maximum degree by Lemma 4.10. Therefore, has vertices and edges and maximum degree . We can compute the union of two graphs of size in time, so we can construct in time. The next step of the algorithm is to run , and the running time of this step is

for some . To determine the reachability step at the end of the algorithm, it suffices to use a breadth-first search running in time. Thus, the algorithm runs in time. ∎

We conclude with the proof of our improved conditional hardness result for computing exact minimum degree elimination orderings. The complementary lower bound in Corollary 1.3 immediately follows.

Proof of Theorem 1.2.

Assume an time algorithm exists for finding a minimum degree ordering. By Lemma 4.12, we can to obtain an time algorithm for deciding if , for some . For instances where , this algorithm runs in time, for some . This contradicts SETH by Lemma 4.1, so there cannot exist an time algorithm for finding a minimum degree ordering, for any constants or , assuming SETH. ∎

5 Conclusion

We have made significant progress in characterizing the time complexity of computing an exact minimum degree elimination ordering. In particular, we present a simple combinatorial algorithm that runs in time and offers an elegant amortized analysis. To the best of our knowledge, this is the first algorithm that improves on the naive algorithm. We also give a matching conditional hardness of , for any and , which affirmatively answers a conjecture posed in [FMP18] and implies that no algorithms with running time or exist, assuming SETH. Lastly, our fine-grained reduction to the orthogonal vectors problem leverages a novel construction for sparse, low-degree filler graphs, whose further applications are likely of independent interest.


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


  • [ADD96] Patrick R. Amestoy, Timothy A. Davis, and Iain S. Duff. An approximate minimum degree ordering algorithm. SIAM Journal on Matrix Analysis and Applications, 17(4):886–905, 1996.
  • [BCK16] Ivan Bliznets, Marek Cygan, Pawel Komosa, Lukáš Mach, and Michał Pilipczuk. Lower bounds for the parameterized complexity of minimum fill-in and other completion problems. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1132–1151. SIAM, 2016.
  • [BS90] Piotr Berman and Georg Schnitger. On the performance of the minimum degree ordering for gaussian elimination. SIAM Journal on Matrix Analysis and Applications, 11(1):83–88, 1990.
  • [CLRS09] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford 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.
  • [CS17] Yixin Cao and RB Sandeep. Minimum fill-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.
  • [FMP18] Matthew Fahrbach, Gary L. Miller, Richard Peng, Saurabh Sawlani, Junxing Wang, and Shen Chen Xu. Graph sketching against adaptive adversaries applied to the minimum degree 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 fill-in. SIAM Journal on Computing, 42(6):2197–2216, 2013.
  • [Geo73] Alan George. Nested dissection of a regular finite element mesh. SIAM Journal on Numerical Analysis, 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.
  • [GL81] Alan George and Joseph W. Liu. Computer Solution of Large Sparse Positive Definite. 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 efficient 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.
  • [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. Modification of the minimum-degree algorithm by multiple elimination. ACM Transactions on Mathematical Software (TOMS), 11(2):141–153, 1985.
  • [Mar57] Harry M. Markowitz. The elimination form of the inverse and its application to linear programming. Management Science, 3(3):255–269, 1957.
  • [NSS00] Assaf Natanzon, Ron Shamir, and Roded Sharan. A polynomial approximation algorithm for the minimum fill-in problem. SIAM Journal on Computing, 30(4):1067–1079, 2000.
  • [Ros72] Donald J. Rose. A graph-theoretic study of the numerical solution of sparse positive definite systems of linear equations. In Graph Theory and Computing, pages 183–217. Elsevier, 1972.
  • [Tar76] Robert E. Tarjan. Graph theory and gaussian elimination. 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 Artificial 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 fine-grained questions in algorithms and complexity. In Proceedings of the ICM, 2018.
  • [Yan81] Mihalis Yannakakis. Computing the minimum fill-in is NP-complete. SIAM Journal on Algebraic Discrete Methods, 2(1):77–79, 1981.