A Fast Minimum Degree Algorithm and Matching Lower Bound

TL;DR

This paper introduces a new combinatorial algorithm for exact minimum degree ordering that runs faster than previous methods, provides output-sensitive bounds, and establishes a lower bound under the exponential time hypothesis.

Contribution

It presents a novel $O(nm)$ time algorithm for exact minimum degree ordering and proves a near-optimal lower bound assuming ETH, advancing understanding of the problem's complexity.

Findings

New $O(nm)$ time algorithm for exact minimum degree ordering

Output-sensitive bounds for the algorithm's running time

Proof of a lower bound under ETH for any faster algorithm

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 algorithms, and scientific computing. In this paper, we present a simple but novel combinatorial algorithm for computing an exact minimum degree elimination ordering in $O(nm)$ time, which improves on the best known time complexity of $O(n^3)$ and offers practical improvements for sparse systems with small values of $m$. Our approach leverages a careful amortized analysis, which also allows us to derive output-sensitive bounds for the running time of $O(\min\{m\sqrt{m^+}, \Delta m^+\} \log n)$, where $m^+$ is the number of unique fill edges and original edges that the algorithm encounters and $\Delta$ is the maximum degree of the input graph. Furthermore, we show there cannot exist an exact minimum degree algorithm that runs in $O(nm^{1-\varepsilon})$ time, for any $\varepsilon > 0$, assuming the strong exponential time hypothesis. This fine-grained reduction goes through the orthogonal vectors problem and uses a new low-degree graph construction called $U$-fillers, which act as pathological inputs and cause any minimum degree algorithm to exhibit nearly worst-case performance. With these two results, we nearly characterize the time complexity of computing an exact minimum degree ordering.

Equations

$$|W_j|+|U_j|\le (|W_j\setminus U_j|+|U_j|)+|U_j|=O(|X_j|+|U_j|).$$

$$\sum _{\{u,v\}\in E}\min \left(f(u),f(v)\right)\le \sqrt{2m}\sum _{v\in V}f(v).$$

$$2m\ge \sum _{v\in N_{\text{out}}(u)}\mathrm{deg}(v)\ge \sum _{v\in N_{\text{out}}(u)}\mathrm{deg}(u)\ge {\mathrm{deg}}_{\text{out}}(u{)}^2.$$

$$\sum _{\{u,v\}\in E}\min (f(u),f(v))=\sum _{u\in V}\sum _{v\in N_{\text{out}}(u)}\min (f(u),f(v))\le \sum _{u\in V}\sum _{v\in N_{\text{out}}(u)}f(u)\le \sqrt{2m}\sum _{u\in V}f(u).$$

$$|U|/(\lfloor |U|/2\rfloor -2)\le |U|/(|U|/2-3)=2/(1-6/|U|)\le 8,$$

$$O\left(m^{2-\epsilon }{\Delta }^k\right)=O\left((nd\log n{)}^{2-\epsilon }(d\log n{)}^k\right)=O\left(n^{2-\epsilon }{d}^{k+2}{\log }^{k+2}n\right)=O\left(n^{2-{\epsilon }^{\prime }}{d}^{k+2}\right),$$

Full text

Furthermore, we show there cannot exist an exact minimum degree algorithm that runs in $O(nm^{1-\varepsilon})$ time, for any $\varepsilon>0$, assuming the strong exponential time hypothesis. This fine-grained reduction goes through the orthogonal vectors problem and uses a new low-degree graph construction called $U$-fillers, which act as pathological inputs and cause any minimum degree algorithm to exhibit nearly worst-case performance. With these two results, we nearly characterize the time complexity of computing an exact minimum degree ordering.

1. 1 Introduction

2. 1.1 Results and Techniques

3. 1.2 Related Works

4. 2 Preliminaries

5. 2.1 Fill Graphs and Minimum Degree Orderings

6. 2.2 SETH-Hardness for Computing Minimum Degree Orderings

7. 3 A Fast Minimum Degree Algorithm

8. 3.1 The Algorithm

9. 3.2 Complexity Analysis

10. 4 Improved SETH-Based Hardness

11. 4.1 Constructing Sparse Min-Degree $U$-Fillers

12. 4.2 Reduction from Orthogonal Vectors

13. 5 Conclusion

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 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]. This line of work culminated in the approximate minimum degree algorithm (AMD) of Amestoy, Davis, and Duff [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-definite matrix $\textbf{A}\in\mathbb{R}^{n\times n}$, before applying Cholesky decomposition, in an attempt to minimize the number of nonzeros in the Cholesky factor. Without a judicious reordering, the decomposition typically becomes dense with fill-in (i.e., additional nonzeros). The goal of the minimum degree algorithm is to efficiently compute a permutation matrix P such that the Cholesky factor L in the reordered matrix $\textbf{P}\textbf{A}\textbf{P}^{\intercal}=\textbf{L}\textbf{L}^{\intercal}$ 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 efficient 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 $G$ with $m=\textnormal{\text{nnz}}(\textbf{A}-\textnormal{\text{diag}}(\textbf{A}))/2$ edges. Permuting the matrix by $\textbf{P}\textbf{A}\textbf{P}^{\intercal}$ does not change the underlying graph. In each iteration, the algorithm (1) selects the vertex $u$ with minimum degree, (2) adds edges between all pairs of neighbors of $u$ to form a clique, and (3) deletes $u$ 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 nonzeros in the pivot row and column. A clique is induced on the neighbors of $u$ in the subsequent graph because of the widely-used no numerical 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 of Fahrbach et al. [FMP*+*18], we investigate the fine-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 first result is a new combinatorial algorithm that outputs an exact minimum degree ordering in $O(nm)$ time. This improves upon the best known result of $O(n^{3})$ achieved by the naive algorithm. We maintain two different data structures for the fill graph to efficiently detect and avoid the redundant work encountered by the naive algorithm. Using careful amortized analysis, we prove the following theorems.

Theorem 1.1**.**

The FastMinimumDegree algorithm outputs an exact minimum degree ordering in $O(nm)$ time.

Our analysis also allows us to derive output-sensitive bounds. The fill 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 FastMinimumDegree algorithm can be implemented to run in $O(\min\{m\sqrt{m^{+}},\Delta m^{+}\}\log n)$ time and use $O(m^{+})$ space, where $m^{+}$ is the number of unique fill edges and original edges that the algorithm encounters and $\Delta$ is the maximum degree of the original graph.

Our second main result improves upon a recent conditional hardness theorem of $O(m^{4/3-\varepsilon})$ for computing exact minimum degree elimination orderings assuming the strong exponential time hypothesis [FMP*+*18].

Theorem 1.3**.**

Assuming the strong exponential time hypothesis, there does not exist an $O(m^{2-\varepsilon}\Delta^{k})$ algorithm for computing a minimum degree elimination ordering, where $\Delta$ is the maximum degree of the original graph, for any $\varepsilon>0$ and $k\geq 0$.

This result is given in its full generality above, and it implies an answer to $O(nm^{1-\varepsilon})$-hardness conjecture posed in [FMP*+*18]. Specifically, we have the following matching lower bound for our main algorithm.

Corollary 1.4**.**

Assuming the strong exponential time hypothesis, there does not exist an $O(nm^{1-\varepsilon})$ time algorithm for computing a minimum degree elimination ordering, for any $\varepsilon>0$.

The hardness in Theorem 1.3 also rules out the existence of an $O(\sum_{v\in V}\deg(v)^{2})$ time algorithm. We prove our hardness results by reducing the orthogonal vectors problem [Wil05] to computing a minimum degree ordering of a special graph constructed using building blocks called $U$-fillers. One of our main contributions is a simple recursive algorithm for constructing $U$-filler graphs that satisfy the challenging sparsity and degree requirements necessary for the fine-grained reduction. In particular, these $U$-fillers correspond to pathological sparsity patterns, and hence adversarial linear systems, that cause any minimum degree algorithm to exhibit worst-case performance (i.e., to output Cholesky factors with $\tilde{\Omega}(n^{2})$ nonzeros). These graphs are of independent interest and could be useful in lower bounds for other greedy algorithms.

1.2 Related Works

Computing an elimination ordering that minimizes fill-in is an NP-complete problem closely related to chordal graph completion [Yan81]. Agrawal, Klein, and Ravi [AKR93] gave the first approximation algorithm for the minimum fill-in problem, building on earlier heuristics by George [Geo73] and by Lipton, Rose, and Tarjan [LRT79]. Natanzon, Shamir, and Sharan [NSS00] later developed the first algorithm to approximate the minimum possible fill-in to within a polynomial factor. There has since been a wealth of recent results on fixed-parameter tractable algorithms [KST99, FV13, CM16, BFPP18] and the conditional hardness of minimizing fill-in [WAPL14, BCK*+*16, CS17, BCCR19].

Due to this computational complexity, we rely on the practicality and efficiency 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 Duff [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 $O(n^{2}m)$ time and this is known to be tight [HEKP01]. On the other hand, AMD is a single elimination algorithm that runs in $O(nm)$ time, but achieves its speedup by using an easy-to-compute upper bound as a proxy to the true vertex degrees. While many variants of the minimum degree algorithm exist, an algorithm that computes an exact minimum degree ordering with time complexity better than $O(n^{3})$ has never been proven. Therefore, our contributions are a significant step forward in the theory of minimum degree algorithms.

There have also been other major advancements in the theory of minimum degree algorithms recently. Fahrbach et al. [FMP*+*18] designed an algorithm that computes a $(1+\varepsilon)$-approximate greedy minimum degree elimination ordering in $O(m\log^{5}(n)\varepsilon^{-2})$ time. Although this result is a significant theoretical milestone, it is currently quite far from being practical. Ost, Schulz, and Strash [OSS20] recently gave a comprehensive set of vertex elimination rules that are to be used before applying a greedy reordering algorithm and never degrade the quality of the output. The minimum degree heuristic has also appeared in algorithms for graph compression and coarsening [Ash95, CKL*+*09, FGP*+*20].

2 Preliminaries

2.1 Fill Graphs and Minimum Degree Orderings

For an undirected, unweighted graph $G=(V,E)$, let $N(u)=\{v\in V:\{u,v\}\in E\}$ denote the neighborhood of vertex $u$ and $\deg(u)=|N(u)|$ denote its degree. We overload the notation $N(U)=\bigcup_{u\in U}N(u)$ to be the neighborhood of a set of vertices. For two graphs $G_{1}=(V_{1},E_{1})$ and $G_{2}=(V_{2},E_{2})$, define their union to be $G_{1}\cup G_{2}=(V_{1}\cup V_{2},E_{1}\cup E_{2})$. For a given set of vertices $U$, let $K_{U}$ be the complete graph with vertex set $U$.

Now we introduce the idea of fill graphs. Our notation extends that of Gilbert, Ng and Peyton [GNP94]. We use the shorthand $[n]=\{1,2,\dots,n\}$ throughout the paper.

Definition 2.1**.**

For any undirected graph $G=(V,E)$ and subset $U\subseteq V$, the fill graph $G^{+}_{U}=(V^{+}_{U},E^{+}_{U})$ is the graph resulting from eliminating the vertices in $U$. Its vertex set is $V^{+}_{U}=V\setminus U$, and an edge $\{u,v\}\in E^{+}_{U}$ if and only if there exists a path $(u,x_{1},\dots,x_{t},v)$ in $G$ such that $x_{i}\in U$ for all $i\in[t]$.

Characterizing fill-in by $uv$-paths through eliminated vertices allows us to compute the fill degree of a vertex in any partially eliminated state $U$ without explicitly computing the eliminated matrix. For a fill graph $G_{U}^{+}$, we avoid double subscripts and use the analogous notation $\deg_{U}^{+}(v)=\deg_{G_{U}^{+}}(v)$ and $N^{+}_{U}(v)=N_{G_{U}^{+}}(v)$ to denote the degree and neighborhood of a vertex $v\in V_{U}^{+}$. Alternatively, we can use tools from linear algebra and view $G^{+}_{U}$ as the nonzero structure of the Schur complement of the adjacency matrix $\textbf{A}(G)/U$.

An elimination ordering $p=(v_{1},v_{2},\dots,v_{n})$ naturally induces a sequence of fill graphs $(G_{0}^{+},G_{1}^{+},\dots,G_{n}^{+})$, where $G_{0}^{+}=G$ and $G_{n}^{+}$ is the empty graph. Let $\deg_{i}^{+}(v)$ denote the degree of vertex $v\in V^{+}_{i}$ in the $i$-th fill graph of this sequence. This allows us to define a minimum degree elimination ordering.

Definition 2.2**.**

A minimum degree elimination ordering is permutation of the vertices $(v_{1},v_{2},\dots,v_{n})$ such that $v_{i}\in\operatorname*{arg\,min}_{v\in V_{i-1}^{+}}\deg_{i-1}^{+}(v)$ for all $i\in[n]$.

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 $\varepsilon>0$, there exists an integer $k$ such that $k$-SAT cannot be solved in $O(2^{(1-\varepsilon)n})$ 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 fine-grained reduction to the orthogonal vectors problem and make use of the following theorem.

Theorem 2.3** ([Wil05]).**

Assuming SETH, for any $\varepsilon>0$, there does not exist an $O(n^{2-\varepsilon})$ time algorithm that takes $n$ binary vectors with $\Theta(\log^{2}n)$ bits and decides if there is an orthogonal pair.

3 A Fast Minimum Degree Algorithm

We present a new combinatorial algorithm called FastMinimumDegree for computing minimum degree orderings. Its key feature is that it maintains the fill graph using an implicit representation of fill-in together with an explicit graph representation. This combination allows us to reduce the number of redundant edge insertions to the fill graph. Using a specialized amortized analysis, we prove the following theorems.

See 1.1 See 1.2

3.1 The Algorithm

We begin by describing an alternative approach for representing the fill graphs $G_{i}^{+}$ as vertices are eliminated. This hypergraph representation stores hyperedges $U_{1},U_{2},\dots,U_{k}\subseteq V_{i}^{+}$ such that $G_{i}^{+}=K_{U_{1}}\cup K_{U_{2}}\cup\cdots\cup K_{U_{k}}$ at the end of each iteration. Variants of this have frequently been used in previous literature on the min-degree algorithm. Our presentation closely follows that of George and Liu [GL89], albeit with different terminology.

Given a graph $G$, we construct the initial hypergraph representation consisting of all hyperedges $\{u,v\}$, for every edge $\{u,v\}\in E(G)$. Next, we consider how to update the hypergraph representation as vertices are eliminated. Suppose we wish to eliminate a vertex $v$. Let $U_{1},U_{2},\dots,U_{t}$ be precisely the hyperedges that contain $v$. Construct $W=(U_{1}\cup U_{2}\cup\cdots\cup U_{t})\setminus\{v\}$. Let $G^{\prime}$ be the graph represented by the current hypergraph representation. Then $W$ is precisely the neighborhood of $v$ in $G^{\prime}$. It follows that the fill graph obtained by eliminating $v$ is represented by removing the hyperedges $U_{1},U_{2},\dots,U_{t}$ and adding the hyperedge $W$.

Our algorithm to find a minimum degree ordering can be summarized as maintaining both a hypergraph representation and an adjacency matrix of the fill graph. The adjacency matrix is used to efficiently compute the minimum degree vertex in each step, and the hypergraph representation is used to reduce the number of redundant updates to the adjacency matrix.

When eliminating the vertex $v$ in the current fill graph $G_{i}^{+}$, we find the hyperedges $U_{1},U_{2},\dots,U_{t}\subseteq V_{i}^{+}$ containing $v$, as described above. We also compute $W=(U_{1}\cup U_{2}\cup\cdots\cup U_{t})\setminus\{v\}=N_{i}^{+}(v)$. We must add edges to the fill graph so that it contains the clique $K_{W}$. Therefore, it is enough for our algorithm to try adding the edges in $K_{W}$ that are not in $K_{U_{1}}\cup K_{U_{2}}\cup\cdots\cup K_{U_{t}}$, since these are already guaranteed to be in $G_{i}^{+}$.

Below we give high-level pseudocode to describe this algorithm. Although the implementation details of the algorithm are very important to the efficiency of the algorithm, we defer these discussions to Section 3.2.

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 $(G_{0}^{+},G_{1}^{+},\dots,G_{n}^{+})$ is the sequence of fill graphs induced by elimination_ordering. Then, at the end of each iteration $i\in[n]$ of the FastMinimumDegree algorithm:*

The state of fill_graph corresponds to the fill graph $G_{i}^{+}$. 2. 2.

The list of hyperedges $U_{1},U_{2},\dots,U_{k}$ satisfies $K_{U_{1}}\cup K_{U_{2}}\cup\cdots\cup K_{U_{k}}=G_{i}^{+}$ (i.e., the hypergraph representation is maintained).

Proof.

We proceed by induction and show that these invariants hold at the end of each iteration. Before any vertices are eliminated (line 5) both properties are true since $G_{0}^{+}=G$. Assume the claim as the induction hypothesis and suppose that the algorithm begins iteration $i\in[n]$. Clearly FastMinimumDegree selects a minimum degree vertex in $G_{i-1}^{+}$ and updates elimination_ordering correctly.

Now we consider what happens when vertex $a$ is eliminated. Let $U_{1},U_{2},\dots,U_{t}\subseteq V$ be all the hyperedges containing $a$ at the start of iteration $i$. When the algorithm reaches line 19, we have $W=(U_{1}\cup U_{2}\cup\dots\cup U_{t})\setminus\{a\}$. All hyperedges $U_{1},U_{2},\dots,U_{t}$ are removed from the hypergraph representation by the end of this iteration, and $W$ is added in their place. Since $W=N_{i-1}^{+}(a)$ by the induction hypothesis, it follows that the new list of hyperedges at the end of iteration $i$ corresponds to $G_{i}^{+}$ and satisfies the second property.

Ensuring that the state of fill_graph is updated correctly requires a little more work. By the induction hypothesis, fill_graph is equal to $G_{i-1}^{+}$ at the beginning of iteration $i$. The hypergraph representation also corresponds to $G_{i-1}^{+}$ at the start of this iteration, so it follows that for each hyperedge $U$ that contains $a$, the edges in $K_{U}$ are present in fill_graph. Lines 9–18 attempt to insert edges from $K_{W}$ into fill_graph that may be missing. In particular, clique $K_{W}$ is constructed one hyperedge at a time to reduce redundant work. When processing the $j$-th hyperedge $U_{j}$, we have $X=(U_{1}\cup U_{2}\cup\dots U_{j-1})\setminus U_{j}$ and $Y=U_{j}\setminus(U_{1}\cup U_{2}\cup\dots\cup U_{j-1})$ on line 13. Only edges $\{x,y\}\in X\times Y$ spanning the symmetric difference can be missing from fill_graph, so at the end of iteration $i$, all edges in $K_{W}$ have been considered. Finally, all edges adjacent to $a$ in $G_{i-1}^{+}$ are removed in lines 16–17. Therefore, it follows that the state of fill_graph corresponds to $G_{i}^{+}$ at the end of the iteration. This proves the first property and completes the proof by induction. ∎

3.2 Complexity Analysis

To thoroughly investigate the time complexity of minimum degree algorithms, we first 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 $O(nm)$, but by more accurate bounds in terms of the total fill produced by the returned minimum degree ordering. Since the fill 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 $O(nm)$. Below are the main quantities used to describe the total fill.

Definition 3.2**.**

Let $E^{+}=\bigcup_{i=0}^{n}E_{i}^{+}$ be the set of all edges in the fill graph at some iteration, and let $m^{+}=\lvert E^{+}\rvert$.

We have that $E^{+}$ is precisely the edge set of the input graph, together with all edges inserted throughout the course of the algorithm. Clearly $(V,E^{+})$ is a simple graph, and so $m^{+}\leq n^{2}$. These edges are important because they correspond to nonzero entries in the corresponding Cholesky factor L. In fact, $m^{+}$ is precisely the number of nonzeros. Intuitively, $m^{+}$ is the size of the “output” of the reordering procedure, and is the quantity that the minimum degree heuristic is designed to minimize.

First, we claim that any adjacency structure for the evolving fill 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 $O(m^{+})$.

Proof.

We maintain the data structure of $n$ doubly linked lists, which are “buckets” corresponding to degrees. Each vertex in the graph has a node in exactly one bucket. Every 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 $O(1)$ time.

The total number of degree updates is also $O(m^{+})$. 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 $O(m^{+})$ entries corresponding to the edges in $E^{+}$.

Selecting the minimum degree vertex $v$ is done by checking the buckets in order of increasing degree, until a nonempty bucket is found. The running time for the $i$-th step is linear in $\deg^{+}_{i}(v)$, which is at most the degree of $v$ in the graph $(V,E^{+})$. So in total, the running time is $O(m^{+})$. ∎

The next lemma builds on Lemma 3.3 to bound the running time of the algorithm by the total fill-in, the number of edge insertion attempts, and the cost of edge updates. The proof uses a simple credit analysis to show that computing all of the sets $X$, $Y$, and $W$ over the course of the algorithm is not too expensive.

Lemma 3.4**.**

Let $k$ be the total number of edge insertion attempts, and let $c$ be the cost of querying, inserting, or deleting an edge. Then the algorithm can be implemented to run in $O(c(m^{+}+k))$ time.

Proof.

Let $(v_{1},v_{2},\dots,v_{n})$ be the ordering found by the algorithm. The number of edge removals performed in iteration $i$ is $\deg^{+}_{i-1}(v_{i})$. Summed across all iterations, the total number of edge removals is $O(m^{+})$. The other queries and insertions to the adjacency structure happen at most $k$ times. Therefore, the total running time of adjacency structure operations is $O(c(m^{+}+k))$.

We claim that the rest of the algorithm can be implemented to run in a total of $O(m^{+}+k)$ time. The first step of this is an amortized analysis that assigns $\lvert U\rvert$ credits to each hyperedge $U$ when it is created, so that when the hyperedge $U$ is removed, the algorithm can afford an extra running time of $O(\lvert U\rvert)$. The initial hypergraph requires a total of $O(m)$ credits.

Consider iteration $i$ of the algorithm, and let $U_{1},U_{2},\dots,U_{t}$ be the hyperedges containing $v_{i}$. The set $W$ produced by the algorithm is, by the end of the iteration, equal to $(U_{1}\cup U_{2}\cup\cdots\cup U_{t})\setminus\{v_{i}\}=N_{i}^{+}(v_{i})$. So, the hyperedge added in iteration $i$ has size $\deg^{+}_{i}(v_{i})$, which summed over all iterations, requires $O(m^{+})$ credits. This amortized analysis assigns $\sum_{j=1}^{t}\lvert U_{j}\rvert$ credits to the iteration where $U_{1},U_{2},\dots,U_{t}$ are the hyperedges being manipulated and removed.

Therefore, it suffices to show that iteration $i$ runs in $O(\sum_{j=1}^{t}\lvert U_{j}\rvert+k_{i})$ time, where $k_{i}$ is the number of edge insertion attempts in iteration $i$. First, consider the loop over the hyperedges $U_{1},U_{2},\dots,U_{t}$. For $j\in[t]$, let $W_{j}$ be the set $W$ at the beginning of the iteration that considers $U_{j}$. Most of the operations in the loop clearly run in $O(\lvert U_{j}\rvert)$ time.

The exception is the computation of $X_{j}=W_{j}\setminus U_{j}$ and $Y_{j}=U_{j}\setminus W_{j}$. In general, finding $A\setminus B$ when $A$ and $B$ have values in $[n]$ is done by having a global array of size $n$ modified to represent the contents of $B$. Then $A\setminus B$ can be found in $O(\lvert A\rvert)$ time. This also requires $O(\lvert B\rvert)$ time to modify and reset the relevant array entries. Our implementation maintains such an array that represents $W$ as it changes over all $t$ iterations, in a total of $\lvert N_{i}^{+}(v_{i})\rvert$ time. This allows $Y_{j}$ to be computed in $O(\lvert U_{i}\rvert)$ time.

If $Y_{j}$ is empty, our algorithm can end iteration $j$ of the inner loop early. Otherwise, the number of edge insertion attempts in this iteration is at least $\lvert X_{j}\times Y_{j}\rvert\geq\lvert X_{j}\rvert$. In this case, the set $X_{j}$ is found in $O(\lvert W_{j}\rvert+\lvert U_{j}\rvert)$ time. Note that

[TABLE]

So, the running time of these operations summed over all iterations $j\in[t]$ is $O(\sum_{j=1}^{t}\lvert U_{j}\rvert+k_{i})$.

Finally, we consider the hypergraph data structure used to efficiently determine the hyperedges that contain a vertex $a$, and how this data structure is updated throughout the algorithm. In the implementation, each hyperedge ever created has a marker that determines whether it is valid or invalid (i.e., whether the hyperedge has since been removed). There is also a array of lists that determines, for each vertex $a$, the list of all hyperedges (valid or invalid) that contain it. This data structure is efficient to use and maintain. When a hyperedge $U$ is inserted, we iterate through all $b\in U$ and add a pointer to $U$ to the list of vertex $b$. ∎

The bottleneck of the algorithm is the total number of attempted edge insertions across all vertex pairs $(x,y)\in X\times Y$. A trivial bound on the total running time of this step is $O(n^{3})$. Improving on this requires 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 precisely how many times an edge in $E^{+}$ is attempted to be inserted. The lemma below is the key technical result in the analysis of the algorithm.

Lemma 3.5**.**

The number of edge insertion attempts is at most $\sum_{\{u,v\}\in E^{+}}\min(\deg(u),\deg(v))$, where the $\deg(v)$ is the degree of $v$ in the original graph.

Proof.

Each $\{u,v\}$ not in $E^{+}$ is never inserted by the algorithm. So, it suffices to show that for all $\{u,v\}\in E^{+}$, the insertion of $\{u,v\}$ is attempted at most $\min(\deg(u),\deg(v))$ times. Suppose $\{u,v\}\in E^{+}$, and assume without loss of generality that $\deg(u)=\min(\deg(u),\deg(v))$. Let $f(u,v)$ be the number of hyperedges that contain $u$ but not $v$. The quantity changes over time as the algorithm progresses.

First, we claim that until $u$ or $v$ is eliminated, $f(u,v)$ only decreases over time. This is because the only operations done to hyperedges is to merge them and to delete eliminated vertices. Merging hyperedges does not increase the number that contain $u$ but not $v$, so until $u$ or $v$ is eliminated, $f(u,v)$ cannot increase.

Next, we claim that for each time the algorithm attempts to insert $\{u,v\}$, $f(u,v)$ strictly decreases. This is because an insertion attempt only happens when a set containing $u$ but not $v$ is merged with a set that contains $v$. So, after the merge operation, $f(u,v)$ has decreased by at least one.

Finally, note that when all of the hyperedges are first initialized, $f(u,v)$ is at most $\deg(u)$. All insertion attempts for $\{u,v\}$ must happen before $u$ or $v$ is eliminated, and during this time, $f(u,v)\geq 0$. Thus, there are at most $\deg(u)=\min(\deg(u),\deg(v))$ insertion attempts for the edge $\{u,v\}\in E^{+}$. ∎

Corollary 3.6**.**

There are $O(\Delta m^{+})$ edge insertion attempts, where $\Delta$ is the maximum degree of the input graph.

We note that the approximate minimum degree algorithm (AMD) of Amestoy, Davis, and Duff [ADD96] also emits a tighter time complexity of $O(m^{+})$ 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. This inequality 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 $G=(V,E)$ be a simple graph and $m=\lvert E\rvert$. For any vertex function $f:V\to\mathbb{R}_{\geq 0}$, we have

[TABLE]

Proof.

We first claim there is an orientation of $E$ such that each vertex has out-degree at most $\sqrt{2m}$. Orient the edge $\{u,v\}$ such that if $u\rightarrow v$, then $\deg(u)\leq\deg(v)$. Let $\deg_{\text{out}}(u)$ denote the out-degree of $u$. Then

[TABLE]

Therefore, every vertex has out-degree at most $\sqrt{2m}$. The result then follows from the inequality

[TABLE]

which completes the proof. ∎

Corollary 3.8**.**

The number of edge insertion attempts is $O(m\sqrt{m^{+}})$. In particular, it is at most $O(nm)$.

Proof.

First, we apply 3.7 to the graph $(V,E^{+})$ using the degree function of the input graph $G=(V,E)$. The $O(m\sqrt{m^{+}})$ bound then follows from Lemma 3.5 and the fact that $\sum_{v\in V}\deg(v)=2m$. The $O(nm)$ bound is a consequence of the inequality $m^{+}\leq n^{2}$. ∎

We are now prepared to prove our main theorems about the FastMinimumDegree algorithm. Our first result states that the algorithm runs in $O(nm)$ 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 different adjacency structures for the fill graph in order to achieve a space-time tradeoff that is beneficial in practice.

Proof of Theorem 1.1.

We use an adjacency matrix to represent fill_graph. Thus, initializing fill_graph requires $O(n^{2})$ time and space. Note that we may assume $G$ is connected, so $m\geq n-1$. Using Lemma 3.4, the algorithm runs in $O(m^{+}+k)$ time since adjacency matrices support constant-time edge queries, insertions, and deletions. Here $k$ is the total number of edge insertion attempts. By Corollary 3.8, we have $k=O(nm)$. Therefore, the overall running time is bounded by $O(n^{2}+m^{+}+k)=O(n^{2}+n^{2}+nm)=O(nm)$, as desired. ∎

Proof of Theorem 1.2.

We represent fill_graph as an adjacency list where the neighborhood of every node is stored in a balanced binary search tree [CLRS09, Chapter 13]. Each edge query and update costs $O(\log n)$. Initializing $G$ requires $O(m\log n)$ time and $O(m)$ space. The algorithm then runs in $O((m^{+}+k)\log n)$ time by Lemma 3.4, where $k$ is the number of edge insertion attempts. The output-sensitive bounds in Corollary 3.6 and Corollary 3.8 imply that $k=O(\min\{m\sqrt{m^{+}},\Delta m^{+}\})$. Since we have $m^{+}=\sqrt{m^{+}}\sqrt{m^{+}}\leq n\sqrt{m^{+}}=O(m\sqrt{m^{+}})$, the time complexity follows. Further, the total space used is $O(m^{+})$ because of the binary search trees. ∎

4 Improved SETH-Based Hardness

Now we affirmatively answer a conjecture of Fahrbach et al. in [FMP*+*18] about the conditional hardness of finding a minimum degree ordering. In particular, we prove the following stronger result.

See 1.3

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 $O(m^{4/3-\varepsilon})$ time algorithm could be used to solve any instance of the orthogonal vectors problem in subquadratic time, for any $\varepsilon>0$. 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.4

The key to our reduction is a recursive algorithm for constructing a graph with $O(n\log n)$ vertices and edges such that after any minimum degree ordering eliminates all but $n$ vertices, the resulting graph is $K_{n}$. Although this construction was originally motivated by connections to SETH-based hardness, it has several interesting standalone properties. In particular, it demonstrates a case where the minimum degree heuristic has extremely poor performance (i.e., it is an input of size $O(n\log n)$ that always results in $\Omega(n^{2})$ fill edges).

4.1 Constructing Sparse Min-Degree $U$-Fillers

Our goal in this subsection is to construct sparse graphs that contain the vertex set $U$ and have the additional property that by repeatedly eliminating a minimum degree vertex, the resulting fill graph is eventually $K_{U}$. We begin by defining several specific properties that are helpful for presenting our construction.

Definition 4.1**.**

A $U$-filler is a graph $G$ with vertex set $U\cup W$, where $U\cap W=\emptyset$, such that after eliminating all of the vertices in $W$, the resulting fill graph is $G_{W}^{+}=K_{U}$. We call $W$ the set of extra vertices.

Many of the graphs we construct have a subset of extra vertices similar to the one in this definition. When taking the union of graphs with extra vertices, we always assume the sets of extra vertices are disjoint.

A simple example of a $U$-filler is the star graph with vertices $U\cup\{w\}$, where $w$ is the center vertex with degree $|U|$. 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 $K_{U}$ is itself a $U$-filler.

Definition 4.2**.**

A $U$-filler is min-degree if after eliminating any proper subset of extra vertices $X\subset W$, all of the minimum-degree vertices in $G_{X}^{+}$ are extra vertices.

It immediately follows from Definition 4.2 that every minimum degree elimination ordering of a min-degree $U$-filler eliminates all of the extra vertices in $W$ before any of the vertices in $U$.

Another key property we use in our construction is the following notion of degree bound.

Definition 4.3**.**

A $U$-filler is $d$-bounded if after eliminating any subset of extra vertices $X\subseteq W$, all remaining extra vertices have degree at most $d$ in $G_{X}^{+}$.

The first graph construction we use is called a $U$-comb. We define a $U$-comb to consist of a path of $\lvert U\rvert$ extra vertices together with $\lvert U\rvert$ edges that form a matching between the path vertices and those in $U$.

Lemma 4.4**.**

A $U$-comb is a $\lvert U\rvert$-bounded $U$-filler.

Proof.

The extra vertices of the $U$-comb form a connected component, so eliminating them results in $K_{U}$. Now suppose some subset of extra vertices is eliminated, and let $v$ be one of the remaining extra vertices. Consider the neighbors of $v$ in the fill graph. Let $w\neq v$ be another extra vertex of the $U$-comb. If $w$ has not been eliminated, $v$ cannot be adjacent to $w$’s neighbor in $U$. So for any of the $\lvert U\rvert-1$ other extra vertices, $v$ has at most one neighbor in the fill graph. Since $v$ is adjacent to a single other vertex in $U$, it follows that the $U$-comb is $\lvert U\rvert$-bounded. ∎

There is also a straightforward way to combine $U$-combs to obtain $d$-bounded $U$-fillers for any $d\geq 2$, although the size of the solution depends on the ratio $\lvert U\rvert/d$.

Lemma 4.5**.**

Let $d\geq 2$ and suppose $\lvert U\rvert/d\leq c$. Then we can construct a $d$-bounded $U$-filler with $O(\lvert U\rvert c)$ edges and maximum degree $O(c)$.

Proof.

We partition $U$ into $O(c)$ parts $U_{1},U_{2},\dots,U_{k}$ each of size at most $d/2$. We then let $G$ be the union of $(U_{i}\cup U_{j})$-combs over all unordered pairs $\{i,j\}\in\binom{[k]}{2}$. The result of eliminating all extra vertices of $G$ is the union of $K_{U_{i}\cup U_{j}}$, which is exactly $K_{U}$. Since $\lvert U_{i}\cup U_{j}\rvert\leq d/2+d/2=d$, the combs are all $d$-bounded by Lemma 4.4. Therefore, $G$ is a $d$-bounded $U$-filler. We constructed $G$ from $O(c^{2})$ combs each with $O(d)$ edges, so $G$ has $O(c^{2}d)=O(\lvert U\rvert c)$ edges. The extra vertices of the combs have maximum degree $3$, but each vertex in $U$ has degree exactly $k-1$, so the maximum degree of $G$ is $O(c)$. ∎

We now use Lemma 4.5 to construct min-degree $U$-fillers. The main idea of our approach is to (1) recursively construct min-degree fillers for two halves of $U$, and (2) connect the halves using a new $U$-filler with $O(|U|)$ edges whose extra vertices are guaranteed to be eliminated before any vertices in $U$. Combining this idea with divide-and-conquer, we show that the solution is of size $O(\lvert U\rvert\log\lvert U\rvert)$. Before proceeding to the proof, we reiterate that all extra vertices introduced in this construction are unique.

Theorem 4.6**.**

We can construct a $(\lvert U\rvert-3)$-bounded min-degree $U$-filler with $O(\lvert U\rvert\log\lvert U\rvert)$ vertices and edges, and maximum degree $O(\log\lvert U\rvert)$.

Proof.

We prove this theorem by describing a recursive divide-and-conquer algorithm. In the base case when $\lvert U\rvert\leq 7$, simply return $K_{U}$. Since $K_{U}$ has no extra vertices, it is a $(\lvert U\rvert-3)$-bounded min-degree $U$-filler.

Now suppose $\lvert U\rvert\geq 8$, and partition $U$ into $U_{1}$ and $U_{2}$ with sizes $\lfloor\lvert U\rvert/2\rfloor$ and $\lceil\lvert U\rvert/2\rceil$, respectively. We then recursively apply the theorem to construct min-degree fillers $G_{1}$ and $G_{2}$ for $U_{1}$ and $U_{2}$. Finally, we apply Lemma 4.5 to construct a $(\lfloor\lvert U\rvert/2\rfloor-2)$-bounded $U$-filler $G_{3}$. (We can do this because $\lfloor\lvert U\rvert/2\rfloor-2\geq 8/2-2=2$.) Then we return the union $G_{1}\cup G_{2}\cup G_{3}$.

Since $\lceil\lvert U\rvert/2\rceil-3\leq\lfloor\lvert U\rvert/2\rfloor-2$ we have that $G_{1}$, $G_{2}$, and $G_{3}$ are $(\lfloor\lvert U\rvert/2\rfloor-2)$-bounded. Since $G_{3}$ is a $U$-filler, so is $G_{1}\cup G_{2}\cup G_{3}$. Therefore, $G_{1}\cup G_{2}\cup G_{3}$ is a $(\lfloor\lvert U\rvert/2\rfloor-2)$-bounded $U$-filler. Since $\lvert U\rvert\geq 8$, this implies in particular that $G_{1}\cup G_{2}\cup G_{3}$ is $(\lvert U\rvert-3)$-bounded.

Suppose for contradiction that $G_{1}\cup G_{2}\cup G_{3}$ is not min-degree, i.e., after eliminating some proper subset of extra vertices, there is a vertex $u\in U$ of minimum degree. Let $U_{i}$ be the part of $U$ that contains $u$. Note that the degree of $u$ in $G_{1}\cup G_{2}\cup G_{3}$ after elimination is at least that of $u$ in $G_{i}$ after eliminating the corresponding extra vertices of $G_{i}$. So for $u$ to have minimum degree, the min-degree property of $G_{i}$ implies all extra vertices of $G_{i}$ are eliminated. Then, since $G_{i}$ is a $U_{i}$-filler, the degree of $u$ is at least $\lvert U_{i}\rvert-1\geq\lfloor\lvert U\rvert/2\rfloor-1$. But since $G_{1}\cup G_{2}\cup G_{3}$ is $(\lfloor\lvert U\rvert/2\rfloor-2)$-bounded, this implies that all extra vertices were eliminated, which is impossible. Therefore, $G_{1}\cup G_{2}\cup G_{3}$ is min-degree.

Finally, we claim that $G_{1}\cup G_{2}\cup G_{3}$ has $O(\lvert U\rvert\log\lvert U\rvert)$ edges and maximum degree $O(\log\lvert U\rvert)$. Since

[TABLE]

$G_{3}$ has $O(\lvert U\rvert)$ edges and maximum degree $O(1)$ by Lemma 4.5. Now consider the divide-and-conquer nature of the construction. The number of edges when $\lvert U\rvert=n$ follows a recurrence of the form $f(n)=2f(n/2)+O(n)$, which has the solution $f(n)=O(n\log n)$. So, the resulting graph has $O(\lvert U\rvert\log\lvert U\rvert)$ vertices and edges. The degrees of all extra vertices are $O(1)$, and any vertex in $U$ is adjacent to at most $O(\log\lvert U\rvert)$ fillers across all recursive levels. Therefore, the overall maximum degree is $O(\log\lvert U\rvert)$. ∎

4.2 Reduction from Orthogonal Vectors

We now use our min-degree $U$-filler construction to demonstrate the hardness of finding an exact minimum degree ordering, assuming SETH. Our connection to SETH is through the following problem.

Definition 4.7**.**

The clique union problem takes as input a set of vertices $V$ with $\lvert V\rvert=n$ and subsets of the vertices $U_{1},U_{2},\dots,U_{d}\subseteq V$, where $d=\Theta(\log^{2}n)$, and asks whether $K_{U_{1}}\cup K_{U_{2}}\cup\dots\cup K_{U_{d}}=K_{V}$.

Lemma 4.8**.**

Assuming the strong exponential time hypothesis, for any $\varepsilon>0$, there is no $O(n^{2-\varepsilon})$ time algorithm for the clique union problem.

Proof.

Let each set $U_{i}$ correspond to the set of vectors with a nonzero entry in the $i$-th dimension. There is a pair of orthogonal vectors if and only if the union $K_{U_{1}}\cup K_{U_{2}}\cup\dots\cup K_{U_{d}}$ is not the complete graph $K_{V}$. Therefore, the result follows from Theorem 2.3 ([Wil05]). ∎

Our approach to prove Theorem 1.3 using Lemma 4.8 is outlined in Algorithm 2 below. It is essentially a reduction from the clique union problem to the problem of finding an exact minimum degree ordering. The graph $G$ on which we call the minimum degree ordering subroutine is built as a union over $U_{i}$-fillers produced by Theorem 4.6. As we prove below, $G$ has special properties that, given any minimum degree ordering, allow us to efficiently determine the answer to the clique union instance.

Lemma 4.9**.**

If MinimumDegreeOrdering returns a minimum degree ordering, then CliqueUnion correctly decides if $K_{U_{1}}\cup K_{U_{2}}\cup\dots\cup K_{U_{d}}=K_{V}$.

Proof.

First, consider the case where CliqueUnion terminates early by returning false on line 9. Then for some proper subset $X\subset W$, a minimum degree vertex $v$ of $G^{+}_{X}$ is not in $W$. Suppose $i$ is an index such that $v\in U_{i}$. By Theorem 4.6, $G_{i}$ is a min-degree $U_{i}$-filler. By considering the fill graph of $G_{i}$ after eliminating all vertices in $X\cap V(G_{i})$, it follows that all the extra vertices of $G_{i}$ have been eliminated. Therefore, the degree of $v$ in $G^{+}_{X}$ equals that of $v$ in $K_{U_{1}}\cup K_{U_{2}}\cup\cdots\cup K_{U_{d}}$. But Theorem 4.6 guarantees that for all $i\in[d]$, $G_{i}$ is $(\lvert U_{i}\rvert-3)$-bounded, and thus $(\lvert V\rvert-2)$-bounded. So since $X\neq W$, the degree of $v$ in $K_{U_{1}}\cup K_{U_{2}}\cup\cdots\cup K_{U_{d}}$ is at most $\lvert V\rvert-2$. Therefore, the algorithm correctly decides that $K_{U_{1}}\cup K_{U_{2}}\cup\cdots\cup K_{U_{d}}\neq K_{V}$.

Now assume that the algorithm does not terminate early. Then the vertex $v$ that is chosen on line 10 is the minimum degree vertex of $G^{+}_{W}$. Since $G_{i}$ is a $U_{i}$-filler for all $i\in[d]$, $G^{+}_{W}=K_{U_{1}}\cup K_{U_{2}}\cup\dots\cup K_{U_{d}}$. Recall that an edge $\{u,v\}$ is in $G^{+}_{W}$ if and only if there is a path from $u$ to $v$ in $G$ with internal vertices in $W$. It follows that the value of $k$ found by the algorithm is one plus the degree of $v$ in $G^{+}_{W}$. Therefore, $k=\lvert V\rvert$ if and only if $G^{+}=K_{V}$, so the algorithm returns the correct decision. ∎

Lemma 4.10**.**

If MinimumDegreeOrdering runs in $O(m^{2-\varepsilon}\Delta^{k})$ time (for some $\varepsilon>0$ and $k\geq 0$) on input $G$ with $m$ edges and max degree $\Delta$, then CliqueUnion runs in $O(n^{2-\varepsilon^{\prime}}d^{k+2})$ time for some $\varepsilon^{\prime}>0$, where $n=\lvert V\rvert$.

Proof.

For all $i\in[d]$, the graph $G_{i}$ is constructed in $O(n\log n)$ time, has $O(n\log n)$ vertices and edges, and has maximum degree $O(\log n)$ by Theorem 4.6. Therefore, $G$ has $O(nd\log n)$ vertices and edges and maximum degree $O(d\log n)$. We can compute the union of two graphs of size $O(m)$ in $O(m\log m)$ time, so we can construct $G$ in $O(nd\log^{2}n)$ time. The next step of the algorithm is to run $\textnormal{{MinimumDegreeOrdering}}(G)$, and the running time of this step is

[TABLE]

for some $\varepsilon^{\prime}>0$. To determine reachability at line 11 of the algorithm, it suffices to use a breadth-first search that runs in $O(\lvert E(G)\rvert)=O(nd\log n)$ time. Therefore, the algorithm runs in $O(n^{2-\varepsilon^{\prime}}d^{k+2})$ 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.4 immediately follows.

Proof of Theorem 1.3.

Assume for contradiction that an $O(m^{2-\varepsilon}\Delta^{k})$ time algorithm exists for computing a minimum degree ordering. By Lemma 4.9 and Lemma 4.10, we can to obtain an $O(n^{2-\varepsilon^{\prime}}d^{k+2})$ time algorithm for deciding if ${K_{U_{1}}\cup K_{U_{2}}\cup\dots\cup K_{U_{d}}=K_{V}}$, for some $\varepsilon^{\prime}>0$. For instances where $d=\Theta(\log^{2}n)$, this algorithm runs in time $O(n^{2-\varepsilon^{\prime}}\log^{2(k+2)}n)=O(n^{2-\varepsilon^{\prime\prime}})$, for some $\varepsilon^{\prime\prime}>0$. However, this contradicts SETH by Lemma 4.8, so the result follows. ∎

5 Conclusion

We have presented a new combinatorial algorithm for computing an exact minimum degree ordering with an $O(nm)$ worst-case running time. This is the first algorithm that improves on the naive $O(n^{3})$ algorithm. We achieve this result using a careful amortized analysis, which also leads to strong output-sensitive bounds for the algorithm.

We also show a matching conditional hardness of $O(m^{2-\varepsilon}\Delta^{k})$, for any $\varepsilon>0$ and $k\geq 0$, which affirmatively answers a conjecture in [FMP*+*18] and implies there are no minimum degree algorithms with running time $O(nm^{1-\varepsilon})$ or $O(\sum_{v\in V}\deg(v)^{2})$, assuming SETH. Together with the $O(nm)$ algorithm, this nearly characterizes the time complexity for computing an exact minimum degree ordering. Extending our $U$-filler graph construction to achieve fine-grained hardness results for other elimination-based greedy algorithms is of independent interest and an exciting future direction of this work.

Acknowledgments

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