Many applications rely on solving sparse linear systems,
which can be sped up significantly by permuting the ma-
trix to minimize the number of non-zeros introduced by
factorization—the fill-in. Equivalently, one can compute an
elimination order of the graph that minimizes the number
of introduced edges, for which the fast but inexact nested
dissection algorithm is often used in practice. In this paper,
we engineer new data reduction rules for the minimum fill-
in problem, which significantly reduce the size of the graph
while producing an equivalent (or near-equivalent) instance.
By applying both new and existing data reduction rules
exhaustively before nested dissection, we obtain improved
quality and at the same time large improvements in running
time on a variety of instances. For example, on road net-
works, where nested dissection algorithms are typically used
as a preprocessing step for shortest path computations, our
algorithms are on average six times faster than Metis while
computing orderings with less fill-in.
1 Introduction
Solving sparse linear systems of equations is a funda-mental task in scientific computing with a variety of ap-plications, such as computational fluid dynamics, elec-trical flows, structural engineering, economic modelingand circuit simulation [15, 52]. Another important ap-plication is solving Laplacian systems which is, amongmany other use cases, needed to gain insights on thespectral properties of a given network by examining theeigenvalues and eigenvectors of the graph Laplacian [52].Sparse linear systems, of the form Ax = b, can in princi-ple be solved by direct methods [16, 28]. Such methodsdecompose the matrix A into factors that simplify solv-ing the system. The drawback is that such factors canbecome dense, having many more non-zeros than theoriginal matrix [16, 28, 49]. Solving the system thenbecomes prohibitively expensive in terms of storage and
∗Faculty of Computer Science, University of Vienna, Austria,[email protected].†Faculty of Mathematics and Computer Science, Hei-
delberg University, Germany, [email protected]. Partially supported by DFG grant SCHU 2567/1-2.Corresponding author.‡Department of Computer Science, Hamilton College, USA,
computation time. The number of new non-zeros intro-duced by factorization is called the fill-in. By reorder-ing the system, fill-in can be significantly reduced, lead-ing to sparse factors [16, 28, 49]. Thus, a problem ofcentral importance is to reduce the fill-in as much aspossible to reduce computation time and storage over-head. For symmetric positive definite matrices, whichcan be factored by Cholesky factorization [28], we canreorder rows and columns by a symmetric permutationPAP> [28, 49]. The minimum fill-in problem is to finda permutation matrix P , such that the number of non-zeros introduced during factorization is minimized.
Yannakakis [55] showed that the problem is NP-complete. Hence, heuristic algorithms such as the mini-mum degree algorithm [49, 54], nested dissection [22] orcombinations of both that work on a graph representa-tion of the input matrix are typically used in practice.More precisely, a symmetric matrix can be representedby an undirected graph. In this graph nodes representrows and columns of the matrix. There is an edge {u, v}in the graph if the matrix element au,v is not zero.An elimination step in the matrix is reflected in thegraph by removing the node corresponding to the elimi-nated column and connecting its neighborhood to form aclique. The added edges provide an upper bound to thenumber of non-zeros introduced in an elimination step.
On the other hand, many NP-hard graph problemshave been shown to be fixed-parameter tractable (FPT):large inputs can be solved efficiently and provablyoptimally, as long as some parameter of the input issmall. Over the last two decades, significant advanceshave been made in the design and analysis of FPTalgorithms for a wide variety of graph problems. Thishas resulted in a rich algorithmic toolbox that is bynow well-established and described in several textbooksand surveys, e.g. [13, 39]. Few of the new techniquesare implemented and tested on real datasets, and theirpractical potential is far from understood. However,recently the engineering part in area has gained somemomentum [1, 14, 31–35, 40, 53]. Surprisingly, theminimum fill-in problem also admits a wide range ofsimple data reduction techniques that have not yet beensuccessfully used in practice.
Our Results. We engineer a new node ordering al-gorithm that employs novel and existing data reduction
rules before using a nested dissection algorithm. Afterthe nested dissection algorithm terminates, reductionsare undone to compute the final node ordering. Byapplying data reduction rules exhaustively we obtainimproved quality and at the same time large improve-ments in running time on a variety of instances. Notethat this directly translates to improvements for typicalapplications. Overall, we arrive at a system that outper-forms the state of the art significantly. For example, onroad networks, where nested dissection algorithms aretypically used as a preprocessing step for shortest pathcomputations [18, 29], our algorithms are on averagesix times faster than Metis while computing orderingswith less fill-in.
2 Preliminaries
In the following we consider an undirected graph G =(V,E), where V are the vertices and E are the edges. Weuse |V | = n and |E| = m. ΓG(v) := {u : {v, u} ∈ E}denotes the neighborhood of a node v. The set ΓG[v] :=ΓG(v) ∪ {v} is the closed neighborhood of v in G. Fora set of nodes A ⊆ V we define its neighborhoodΓG(A) :=
(⋃x∈A ΓG(x)
)\ A. When clear from the
context we omit G and write Γ(x), Γ[x] and Γ(A),respectively.
For a set of nodes V ′ ⊆ V we define the set of edgeswith both endpoints in V ′ as E(V ′) := E∩ (V ′×V ′). Agraph S = (V ′, E′) is said to be a subgraph ofG = (V,E)if V ′ ⊆ V and E′ ⊆ E(V ′). We call S an inducedsubgraph when E′ = E(V ′). For a set of nodes U ⊆ V ,G[U ] denotes the subgraph induced by U .
A graph G is triangulated or chordal, if for everycycle of four or more nodes, there is an edge connectingtwo non-consecutive nodes in the cycle. A triangulationof a graph G = (V,E) is a set of edges T , such that(V,E ∪ T ) is a triangulated graph. A triangulation isminimal if no proper subset is also a triangulation. Ifthere is no triangulation T ′ with |T ′| < |T |, then T isa minimum triangulation. A clique is a set of verticesK ⊆ V such that ∀u, v ∈ K where u 6= v {u, v} ∈ E.A vertex v ∈ V is simplicial if Γ(v) is a clique. Agraph G is said to have a perfect elimination ordering ifthere is an ordering of vertices v1v2 · · · vn such that eachvertex vi is simplicial in the subgraph G[{vi+1, . . . , vn}]induced by vertices later in the ordering.
In this work, we consider several related partition-ing problems. The graph partitioning problem asks forblocks of nodes V1,. . . ,Vk that partition V ; that is,V1 ∪ · · · ∪Vk = V and Vi ∩Vj = ∅ for i 6= j. A balancingconstraint demands that ∀i ∈ {1..k} : |Vi| ≤ Lmax :=(1 + ε)d|V |/ke for some parameter ε. In this case, theobjective is often to minimize the total cut
∑i<j |Eij |
where Eij := {{u, v} ∈ E : u ∈ Vi, v ∈ Vj}. The set of
cut edges is also called an edge separator. A node v ∈ Vithat has a neighbor w ∈ Vj , i 6= j, is a boundary node.The node separator problem asks to find blocks, V1, V2
and a separator S that partition V such that there areno edges between the blocks. Again, a balancing con-straint demands |Vi| ≤ (1+ε)d|V |/ke. However, there isno balancing constraint on the separator S. The objec-tive is to minimize the size of the separator |S|. We callV1 and V2 the components and the induced subgraphsG[S ∪ Vi] the leaves of S. A separator that is also aclique is a separation clique.
In general, a multilevel approach consists of threemain phases: coarsening, initial solution, and uncoars-ening. These phases are typically adjusted depending onthe optimization problem that is tackled. In the coars-ening phase, contraction should quickly reduce the sizeof the input. Contraction is stopped when the graphis small enough so a problem can be solved by someother potentially more expensive algorithm, producingthe initial solution. In the uncoarsening phase, contrac-tions are iteratively undone and local search is used onall levels to improve a solution. The intuition behind theapproach is that a good solution at one level of the hier-archy will also be a good solution on the next finer levelso that local search will quickly find a good solution.
Parameterized Complexity and Data Reduc-tion Rules. Many times, tighter analysis of an algo-rithm is possible by considering the running time interms of an input parameter, generally denoted by k,which is independent of the input size n. The field ofparameterized complexity investigates theoretical algo-rithms involving such input parameters. Following theframework of Downey and Fellows [19], we say a problemis fixed-parameter tractable (FPT) if it can be solved intime f(k) ·poly(n), where k is a (hopefully small) inputparameter and poly(n) is a polynomial-time function ofthe input size n that does not include k.
Tightly connected to fixed-parameter tractability isthe concept of data reduction rules and kernelization.Normally discussed in terms of a decision problem, adata reduction rule maps a problem instance (in ourcase a pair (G, k) where G is the graph and k is theminimum fill-in) to an new instance (G′, k′) of smallersize, such that (G′, k′) is a ‘yes’ instance if and only if(G, k) is a ‘yes’ instance.
The Node Ordering Problem. Given a matrixA ∈ Rn×n and a column vector b ∈ Rn we want to solvethe system of linear equations given by Ax = b. Thisis usually accomplished by first factoring the matrixA. For symmetric matrices the Cholesky decompositioncan be used which factorizes A into a lower triangularmatrix L and its transpose L> such that A = LL>.An extension of the simple Cholesky decomposition is
to reorder the rows and columns of A prior to thefactorization. This is done by applying a permutationmatrix P to rows and columns of the matrix A whichleads to PAP> = LL>. For large sparse matrices itis crucial to choose a good permutation matrix P inorder to reduce the fill-in during the factorization whichreduces both the amount of memory needed to store thefactors as well as the number of operations needed tofactorize the matrix. A permutation matrix can alsobe expressed as a permutation vector which maps eachrow respectively column to a rank in {1, . . . , n}. Thematrix A can be viewed as a graph G = (V,E) suchthat V := {1, . . . , n} and there exists an edge for everynon-zero entry in A which does not lie on the diagonal:E := {{i, j} : i 6= j ∧ A[i, j] 6= 0}. Elimination of acolumn and row in A is reflected in G by eliminating thecorresponding node and connecting its neighborhood toform a clique. Finding a permutation matrix for A thencorresponds to finding an elimination order of nodes inG, which is called a node ordering.
The deficiency DG(x) of a node x in a graph Gis the set of distinct pairs of nodes in ΓG(x), that arenot themselves neighbors: DG(x) := {{a, b} | a, b ∈ΓG(x), a 6= b, a /∈ ΓG(b)}. When clear from thecontext we omit G and write D(x). Eliminating a nodex from a graph G = (V,E) results in the eliminationgraph Gx := (V \ {x}, E(V \ {x}) ∪ DG(x)), which isobtained by removing x and its incident edges from G,and connecting the neighborhood of x to a clique. Wecall this process an elimination step. The eliminationgraph obtained by eliminating a sequence of nodes X =x1x2 · · ·xm is denoted by GX := (. . . ((Gx1
)x2) . . . )xm
.A node ordering of a graph G = (V,E) with
n = |V | is a bijection σ : {1, 2, . . . , n} → V , that de-fines a sequence of elimination graphs G(1)G(2) . . . G(n),where G(i) := (G(i−1))σ(i) if i = 1, . . . , n and G if i =
0. In G(n), all nodes have been eliminated. Thefill-in of an ordering σ is the number of edgesadded during the elimination process, denoted byφ(G, σ) :=
∑ni=1 |DG(i−1)(σ(i))|. We let Σ(G) =
arg minσ{φ(G, σ)} be some minimum fill-in orderingof a graph G, with the corresponding minimum fill-inΦ(G) = φ(G,Σ(G)). Note that
(2.1) Φ(G) ≥ Φ(G(1)) ≥ . . . ≥ Φ(G(n−1)).
An ordering σ of a graph G = (V,E) generates atriangulation T (σ) of G, such that the graph (V,E ∪T (σ)) is chordal. T (σ) is the set of edges addedduring the elimination process and |T (σ)| = φ(G, σ).A minimum fill-in ordering Σ(G) generates a minimumtriangulation T (Σ(G)), where Φ(G) = |T (Σ(G))| [44].If G is triangulated, then its minimum triangulation isthe empty set and it has a perfect elimination order,
i.e., Φ(G) = 0. We use the following notation fornode orderings: σ = x1x2 · · ·xn corresponds to σ(1) =x1, σ(2) = x2, . . . , σ(n) = xn. We write xΣ(Gx) if x is tobe eliminated before the nodes in Gx. To denote nodesordering where a set of nodes P = {p1, p2, . . . , pn} areeliminated in any order, we use P in the notation insteadof p1p2 · · · pn. For example, PΣ(GP ) is an ordering inwhich the nodes in P are eliminated in any order beforethe nodes in GP .
3 Related Work
There has been a huge amount of research on graph par-titioning, node separators and minimum fill-in ordering;we refer the reader to the overviews [10, 12, 50] for pre-liminary material in this area. Here, we focus on issuesclosely related to our main contributions and previouswork on the node ordering problem.
Yannakakis proved that the problem of finding aminimum fill-in ordering is NP-complete [55]. Exactalgorithms have been introduced in the context of non-serial dynamic programming [8, 9], but they are notpractical for large matrices due to their exponential run-ning time [49]. The fastest such algorithm is due toFomin et al. [21], with running time O∗(1.7347n), whereO∗ hides polynomial factors. Parameterized algorithmsoffer a promising alternative to algorithms that are ex-ponential in the input size. In particular, the problemis fixed-parameter tractable [36], when the input pa-rameter k is the minimum fill-in. The fastest-knownFPT algorithm for the problem is due to Fomin and Vil-
langer [20], with running time O(
2O(√k log k) + k2nm
)that is subexponential in the minimum fill-in k. Here,the additive O
(k2nm
)is the time to compute a kernel of
size k2 using data reduction rules, using the algorithm ofKaplan et al. [37]. This is the smallest known kernel forthe problem. Despite these theoretical improvements, inpractice, the minimum fill-in problem is extremely hardto solve exactly. Indeed, in the Second ParameterizedAlgorithms and Computational Experiments Challenge(PACE 2017), even when using generalized variants ofthe reduction rules of Bodlaender et al. [11], the win-ning solver for the minimum fill-in problem only solved54 out of 100 instances [17].
For graphs with a perfect elimination order, theproblem can be solved in O(|V |+ |E|) time [47]. Tinneyand Walker [54] introduced a heuristic algorithm wherethe next column to eliminate is selected based on thenumber of non-zeros. This algorithm is known as theminimum degree algorithm, since a node of minimumdegree is eliminated at each step [49]. There havebeen several improvements to this algorithm, both in itsdesign and implementation [23, 25, 26]. The minimum
degree algorithm spends a significant part of its timein updating node degrees. Most of the improvementsto the minimum degree algorithm are thus focused onreducing the number of nodes to update [26]. Amestoyet al. [2] introduced an approximate minimum degreealgorithm in which the degree update is not performedexactly. The minimum deficiency algorithm is a greedyalgorithm similar to the minimum degree algorithm [49,54]: at every step the node with the smallest deficiencyis eliminated. If the graph to be ordered has a perfectelimination ordering, the minimum deficiency algorithmfinds it. However, finding the deficiency of a node isexpensive, so the algorithm is slower than the minimumdegree algorithm [49].
In 1973, George [22] introduced an algorithm to pro-duce orderings for regular finite element meshes, callednested dissection. This algorithm computes a node sep-arator, and then recursively orders the partitions beforethe separator. George and Liu generalized the algo-rithm to work on arbitrary graphs [24]. The fastestand most widely used nested dissection implementa-tion is in the highly-optimized graph partitioning soft-ware package, called Metis, due to Karypis and Ku-mar [38]. In practice, nested dissection is combinedwith algorithms such as the minimum degree algorithm:once the subgraphs are small enough, they are orderedby the minimum degree algorithm [4, 5, 38]. A simi-lar approach based on multisectors instead of bisectorswas presented by Ashcraft and Liu [5]. LaSalle andKarypis [41] gave a shared-memory parallel algorithm tocompute node separators used to compute fill-reducingorderings. Within a multilevel approach they evaluatedifferent local search algorithms indicating that a com-bination of greedy local search with a segmented FM al-gorithm can outperform serial FM algorithms. On roadnetworks nested dissection is used as preprocessing stepfor shortest path computations [29]. The authors usedegree-2 preprocessing to speed up their nested dissec-tion algorithm.
Minimum fill-in is closely related to the notions oftree width and tree depth. The tree width of a chordalgraph is one less than the size of its maximum clique.The tree width of a graph G is the minimum tree widthof a chordal graph that contains G. We can obtainthe tree width of G by computing a triangulation T ofG = (V,E) that minimizes the size of the maximumclique of the chordal graph (V,E ∪ T ). The tree depthof a graph is the minimum height of an eliminationtree of the graph. An elimination tree is a spanningtree of the triangulated graph and is defined by a nodeordering. We are interested in finding a node orderingwith minimum fill-in, i.e., a triangulation of minimum
size, and do not evaluate our algorithm in terms of treewidth and tree depth.
4 Advanced Node Ordering
We now outline our reduced nested dissection algorithmand describe our reductions in detail. For completeness,we outline the standard nested dissection algorithmin Algorithm 1 in Algorithm 4 as implemented forexample in Metis [38]. We extend the nested dissectionby transforming the input graph G into a (smaller)equivalent graph G′ using our reduction rules. Weapply reductions in a fixed order and each reduction isapplied exhaustively, i.e., the graph is reduced as muchas possible by each reduction. Then, we apply nesteddissection on the reduced graph G′ to obtain an orderingσ. After the nested dissection algorithm returns theordering σ, the ordering of the reduced graph is thentransformed to an ordering of the input graph σ′. Wenow explain the data reduction rules that we use.
Algorithm 1: UnreducedNestedDissection(G)
input : Undirected graph G = (V,E)output: Ordering σ
1 if |G| ≥ recursion limit then2 V1, V2, S ← Separator(G)3 foreach G′ in (G[V1], G[V2], G[S]) do4 σ′ ← UnreducedNestedDissection(G′)5 σ ← σσ′
6 else7 σ ← MinDegree(G)
8 return σ
4.1 Data Reduction Rules. A data reduction ruletransforms an input graph G into a smaller, reducedgraph G′. This new smaller problem instance is gener-ally equivalent to the original, and can be solved in lesstime. The solution on G′ can then be transformed intoa node ordering of the nodes of G. If the running timeof the transformations is small, solving the problem onG in this way will be faster than a direct approach.
We use four exact and two inexact reduction rules.The simplicial node reduction eliminates nodes whoseneighborhood is already a clique. These nodes can beordered first in a minimum fill-in ordering, since theydo not contribute to the fill-in. The indistinguishablenode reduction and twin reduction contract sets of nodeswith equal closed and open neighborhood, respectively.When any node in such a set is eliminated, then theother nodes become simplicial. Thus, such sets can beordered together. With path compression we replaceany path of nodes with degree 2 by a single degree-
2 node. If one node on the path is eliminated, then itsdegree-2 neighbors can be eliminated next in a minimumfill-in ordering.
Degree-2 elimination is an inexact reduction rulethat eliminates nodes of degree 2. This reduction turnsout to be exact if none of the eliminated nodes are alsoseparators. Lastly, triangle contraction contracts adja-cent nodes of degree 3 that share at least one neighbor.
To our knowledge, only the indistinguishable nodereduction has been used in practice in combinationwith nested dissection. While linear time algorithmsfor ordering chordal graphs are known, it appears thatthe special structure of simplicial nodes is not exploitedin non-chordal graphs. There are two well-knownreductions we do not discuss here. First, connectedcomponents can be ordered separately. For our testinstances this reduction was not useful. Second,cut-vertices can be ordered last. We do not use thisreduction in our implementation: in finite elementmeshes and similar graphs such cut-vertices are rare.In social networks, we observe that, after simplicialnode reduction, the largest biconnected component isclose to the size of the full graph. We now describethe reduction rules in greater detail. Proofs of thestatements can be found in Appendix A.
4.2 The Simplicial Node Reduction. A node xis simplicial if its neighborhood Γ(x) is a clique (seeFigure 1 for an example). There exists a minimum fill-in ordering where x is eliminated first.
Theorem 4.1. Let G = (V,E) be a graph with asimplicial node x. The ordering xΣ(Gx) is a minimumfill-in ordering of G.
This allows us to eliminate all simplicial nodes first bythe following procedure: Find any simplicial node x inG = (V,E), eliminate x from G and place it next in
Simplicial
s
Indistinguishable
i1 i2
Twins
t1 t2
Figure 1: Examples for simplicial nodes, indistinguish-able nodes and twins. The neighborhood of s is a clique,so s is simplicial. Nodes i1 and i2 are indistinguishable,since they are neighbors and adjacent to all unlabelednodes, i.e., Γ[i1] = Γ[i2]. Nodes t1 and t2 are twins,since they are both adjacent to all unlabeled nodes, butnot to each other. Γ(t1) = Γ(t2).
the node ordering. If the elimination graph Gx hassimplicial nodes, then repeat the procedure for Gx. Ifevery elimination graph in the elimination sequence σhas at least one simplicial node, then φ(G, σ) = 0.In this case, σ is a perfect elimination ordering of G.Graphs that admit such an ordering are called chordalor triangulated graphs [48, 49].
Reduction 1. (Simplicial Node Reduction) Given agraph G = (V,E) and a simplicial node x ∈ V , constructa new graph G′ = G[V \ {x}]. Φ(G) = Φ(G′) andxΣ(G′) is a minimum fill-in ordering of G.
4.3 The Indistinguishable Node Reduction.Two nodes a and b are indistinguishable if Γ[a] = Γ[b](see Figure 1 for an example). Such nodes can beeliminated together: if a and b are indistinguishablenodes, then there exists a minimum fill-in orderingx1 · · ·xiabxi+1 · · ·x`, where {x1, . . . , xi, xi+1, . . . , x`} =V \ {a, b}. To obtain a reduced graph G′, we contract aset of indistinguishable nodes S in G to a single node.
We first establish that indistinguishable nodes stayindistinguishable throughout the elimination sequence.Then, we show that eliminating indistinguishable nodesdoes in fact lead to minimum fill-in orderings.
Lemma 4.1. If a, b are indistinguishable nodes in agraph G, then a and b are indistinguishable in anyelimination graph Gx for x /∈ {a, b}.
Theorem 4.2. Let G = (V,E) be a graph with a setof nodes A ⊆ V , where ∀ ai, aj ∈ A, Γ[ai] = Γ[aj ].There is an ordering σ′ = x1 · · ·xiAxi+1 · · ·x`, whereV \A = {x1, . . . , x`}, such that φ(G, σ′) = Φ(G).
Reduction 2. (Indistinguishable Node Reduction)
Given a graph G = (V,E) with indistinguishable nodesa, b ∈ V , construct a new graph G′ = G(V \ {b}).Replacing a in Σ(G′) by ab results in a minimumordering of G.
Note, that in the reduced graph G′, the deficiencyof any node neighboring a set of indistinguishablenodes is different from that of the corresponding nodein the original graph G. Thus, we have to optimizethe ordering in G′ not in terms of the deficiency ofa node in G′, but in terms of the deficiency of thecorresponding node in G. Indistinguishable nodesare commonly used to speed up the minimum degreealgorithm [23, 25, 27]. In this context the reduction hasbeen shown to be exact. This reduction is also knownas graph compression and is used in other variants ofnested dissection and the minimum degree algorithm,see for example the algorithms by Ashcraft [3] andHendrickson and Rothberg [30].
4.4 The Twin Reduction. Two nodes a and b aretwins if Γ(a) = Γ(b) (see Figure 1). As indistinguishablenodes, twins can be eliminated together.
Theorem 4.3. Let a, b be twins in a graph G = (V,E).There exists an ordering σ′ = x1 · · ·xiabxi+1 · · ·xl, withxj ∈ V \ {a, b}, such that φ(G, σ′) = Φ(G).
We can treat twins similarly to indistinguishable nodes:we obtain a reduced graph by contracting twins. Aswith Reduction 2, the deficiency of a node neighboringcontracted twins in G′ is smaller than the deficiencyof the corresponding node in G. Thus, orderings ofG′ should be evaluated not in terms of the deficiencyof nodes in G′, but in terms of the deficiency ofcorresponding nodes in G.
Reduction 3. (Twin Reduction) Given a graph G =(V,E) with twins a, b ∈ V , construct a new graphG′ = G[V \ {b}]. Replacing a in Σ(G′) by ab resultsin a minimum ordering of G.
4.5 Path Compression. We now show that a pathof nodes with degree 2 can be eliminated together.More formally, let P = {a1, a2, . . . , ak} be a pathin a graph G = (V,E) with deg(ai) = 2 for allai ∈ P . There is a minimum fill-in ordering Σ =x1 · · ·xia1 · · · akxi+1 · · ·x`, where V \ P = {x1, . . . , x`}.
We prove this by distinguishing three cases based onwhich nodes are separation cliques, and using the rela-tionship between minimum triangulation and minimumfill-in orderings. Corollary 1 and Proposition 2 from [49]are central to our proof and we restate them here.
Lemma 4.2. (Corollary 1 from [49]) LetG = (V,E) be a graph with separation clique Swith components C1, C2, . . . , Ck. Any minimumtriangulation T of G contains only edges e = {x, y} ∈ Twith x and y in the same component Cj, or edgese = {x, y} ∈ T with x ∈ Cj and y ∈ S.
Lemma 4.3. (Proposition 2 from [49]) Let C =(V,E) be a cycle with |V | ≥ 3 nodes. Any orderingof C is a minimum fill-in ordering.
Furthermore, we need to show that nodes with degree2 in induced cycles of four or more nodes can beeliminated first.
Lemma 4.4. Let G = (V,E) be a graph with a nodea ∈ V where deg(a) = 2, Γ(a) /∈ E and {a} is not aseparation clique. Then, aΣ(Ga) is a minimum orderingof G.
To prove Lemma 4.4 we establish that there exists aminimum triangulation that does not contain an edgeto such a node a.
Lemma 4.5. Let G and a be as in Lemma 4.4. Thereexists a minimum triangulation T of G, with Γ(a) ∈ Tand {a, x} /∈ T for all x ∈ V .
With these results we now prove our original statement:
Theorem 4.4. Let G = (V,E) and P = {a1, . . . , ak} ⊆V such that G[P ] is a path graph and ∀ a ∈P deg(a) = 2. Let Γ(P ) = {a0, ak+1} and Γ(ai) ={ai−1, ai+1}, i = 1, . . . , k. There exists an ordering σ′ =x1 · · ·xia1 · · · akxi+1 · · ·x` where V \ P = {x1, . . . , x`},such that φ(G, σ′) = Φ(G).
Since such sets of nodes P can be eliminated together,we can contract them to a single node. It is possiblethat in a minimum elimination sequence of a graph G,the degree of a1 ∈ P becomes 1. Then, P has to beordered as a1a2 · · · ak to obtain a minimum ordering.
Reduction 4. (Path Compression) Given a graphG = (V,E) with a set of nodes P = {a1, . . . , ak},where G[P ] is a path graph, N(P ) = {a0, ak+1}and ∀ a ∈ P deg(a) = 2, construct a newgraph G′ = (V \ {a2, . . . , ak}, E′), whereE′ = (E \ E(P ∪ {ak+1})) ∪ {{a1, ak+1}}. Re-placing a1 in Σ(G′) by a1a2 · · · ak yields a minimumordering of G.
4.6 Degree-2 Elimination. Our first inexact reduc-tion removes any vertices of degree 2 that remain afterapplying the simplicial node and path compression re-ductions. Since the graph has minimum degree two,these nodes would be eliminated first by the minimumdegree algorithm, and therefore (judging by that algo-rithm’s success in practice) these are good candidatesfor removal. Note if this reduction is used after pathcompression, then the compressed paths are eliminated.
Inexact Reduction 1. (Degree-2 Elimination)
Given a graph G = (V,E) and any node x with degree2, construct the elimination graph Gx. The potentiallynon-minimum ordering of G is xΣ(Gx). The method isapplied recursively while there are nodes with degree 2.
Note that according to the path compression reduction,this reduction is exact when the vertices are in (induced)cycles of at least three vertices. The proof of The-orem 4.4 reveals general conditions for when degree-2elimination is exact, which are captured in the follow-ing two corollaries.
Corollary 4.1. Let G = (V,E) be a graph. If x ∈ Vis in any cycle C ⊆ V and deg(x) = 2, xΣ(Gx) is aminimum ordering of G.
Corollary 4.2. Let G = (V,E) be a graph. Let x ∈ Vbe a separator with deg(x) = 2. xΣ(Gx) is a non-minimum fill-in ordering of G.
Corollaries 4.1 and 4.2 imply that degree-2 eliminationis exact if only degree-2 nodes that are part of a cycleare eliminated. In graphs where no degree-2 nodes areseparators, degree-2 elimination is therefore exact.
4.7 Triangle Contraction. For our next and finalinexact reduction, we consider contracting the nodes ofa triangle. We assume that simplicial node reductionand degree-2 elimination have already been applied andthe minimum degree is 3. Consider two adjacent nodesa, b ∈ V where deg(a) = deg(b) = 3 and |Γ(a) ∩ Γ(b)| ≥1, i.e., nodes a and b share at least one neighbor, forminga triangle. If |Γ(a) ∩ Γ(b)| = 2, then a and b areindistinguishable and can be contracted. Now, considerthe case where |Γ(a) ∩ Γ(b)| = 1. Eliminating node adoes not increase the degree of node b, and vice versa.After eliminating a, |D(b)| ≤ 2, i.e., eliminating b onlyinserts two edges into the graph. Since this fill-in issmall, we eliminate b as soon as a was eliminated, andvice versa. Thus, we contract nodes a and b.
Inexact Reduction 2. (Triangle Contraction)
Given a graph G = (V,E) and adjacentnodes a, b with deg(a) = deg(b) = 3 and|Γ(a) ∩ Γ(b)| = 1, construct a new graphG′ = (V \ {a}, E \ (∪x∈Γ(a){a, x}) ∪x∈Γ(a) {x, b}).Replacing b by ba in Σ(G′) yields a potentiallynon-minimum ordering of G.
5 Implementation Details
To apply simplicial node reduction (Reduction 1), weiterate through nodes in order by non-decreasing degree.To test if a node x is simplicial, we iterate through theneighbors y ∈ Γ(x). If |Γ(y) ∩ Γ(x)| = deg(x) − 1 forall y, then x is simplicial. When a node is found to besimplicial, we mark it as removed and adjust the degreesof its neighbors accordingly. Removed nodes are ignoredwhen testing the other nodes. The order in whichsimplicial nodes are found yields their elimination order.Since we only evaluate each node once in a single pass,this method may introduce new simplicial nodes thatremain in the graph. However, in practice we find thatmost simplicial nodes are eliminated in a single pass.Deciding if a node v is simplicial takes time O(deg(v)2).For graphs where deg(v) = O(n) this implies a totaltime for simplicial node reduction of O(n3). To avoidthis case, we introduce a parameter ∆ and only testnodes v that have degree deg(v) ≤ ∆. The total timefor simplicial node reduction is then O(n∆2).
The indistinguishable node and twin reductions(Reductions 2 and 3) are similar in their implementa-tion and are based on the algorithms by Ashcraft [3] andHendrickson and Rothberg [30]. For both reductions wefirst compute a hash of the neighborhood of each node
xi as hc(xi) =∑yj∈Γ[xi]
j and ho(xi) =∑yj∈Γ(xi)
j Weonly compare the neighborhoods directly if the hashesof two candidates are equal. To detect indistinguishablenodes, we now go through all pairs (u, v) of adjacentnodes and, if hc(u) = hc(v), test if Γ[u] = Γ[v]. De-tecting and contracting sets of indistinguishable nodesin this way takes time O(m). To detect twins, we firstsort the list of hashes ho. We then go through the list,and, for pairs of nodes (u, v) with equal hash and de-gree, test if Γ(u) = Γ(v). In the worst case, if all hashesare equal and all nodes have the same degree, our im-plementation takes time O(mn + n log(n)).
In path compression (Reduction 4) and degree-2elimination (Inexact Reduction 1), nodes to contractor eliminate are detected in time O(n). The reducedgraph is then built in time O(m). We order sets ofnodes contracted by to path compression starting at theend whose neighbor is eliminated first. Nodes removedduring degree-2 elimination appear in the final orderingas they are removed from the graph.
We detect set of nodes A to be contracted in trianglecontraction (Inexact Reduction 2) by the followingprocedure: Let x be some node with deg(x) = 3. Add xto A. Then we repeat the following procedure: If x has aneighbor y with deg(y) = 3 and |Γ(x)∩Γ(y)| ≥ 1, add xand y to A. Let a ∈ (Γ(x)∩ Γ(y)). Let z ∈ Γ(y), z /∈ A.If deg(z) = 3 and a ∈ Γ(z), add z to A. Otherwise,stop. Repeat the procedure with the neighbors of z.This reduction can be implemented in time O(m). Inthe ordering of the input graph, nodes in A are orderedas they are added to A.
6 Experimental Evaluation
Methodology. We implemented the reductions inC++ and compiled using g++ 8.3.0 with optimizationflag -O3. Additional implementation details can befound in Section 5. We use Metis (version 5.0) [38]to perform nested dissection. All running times weremeasured on a machine with four Intel Xeon E7-8867v3 processors (16 cores, 2.5 GHz, 45 MB L3-cache) and1000 GB RAM. The machine is running 64-bit Debian10 with Linux kernel version 4.19.67. Our implemen-tation runs on a single core. For each graph and set ofparameters we average the results of ten repetitions. Weuse nested dissection in Metis with default parameters.Our reference is Metis without reductions. We also com-pare our result with orderings from the gord-programfrom the software package Scotch (version 6.0.6) [46]. Inevaluating our orderings we focus on the number of non-zeros in the matrix factors and the running time of theordering algorithm. We obtain the number of non-zeroswith the gotst-program from Scotch. This programperforms a Cholesky factorization and reports statistics
on the elimination process. Some of our plots are perfor-mance profiles. These plots relate the running times orquality of all algorithms to the fastest/best algorithm ona per-instance basis. For each algorithm A, these ratiosare sorted in increasing order. The plots show
(tfastesttA
)(in case of running time) or
(φbest
φA
)on the y-axis. A
point close to zero shows that the algorithm was con-siderably slower/worse than the fastest/best algorithm.
We run compare our algorithm to the winningsolver of the PACE 2017 challenge [17]. We run thesolver using OpenJDK 11.0.6 with a time limit of 24hours. The exact solver outputs the fill-edges of aminimum triangulation. We compare our solutions bycomputing the number of fill-edges.
Instances. We evaluate our algorithm on the largeundirected graphs from [43]. These graphs includesocial networks, citation networks and web graphscompiled from [6] and [42]. These are complexnetworks of up to 1.38 million vertices with lowdiameter and are scale-free, having few high-degreenodes, many low-degree nodes. We also use thegraphs from Walshaw’s graph partitioning archive [51],which are mostly meshes and similar graphs, whichare medium-sized networks of up to 448K vertices,generally have small degree, and are fairly symmetric,and road networks obtained from [7], which have upto 50.9 million vertices and uniformly low degree.Properties of our benchmark instances can be foundin the appendix of the technical report [45]. We alsoevaluate our algorithm on the public and hiddeninstances of the second PACE challenge [17], andcompare the results to the winning submission byKobayashi and Tamaki.
Parameters and Abbreviations. We apply the re-ductions in a fixed order on each recursion level. Thereductions are specified by their first letter; ∆ for tri-angle contraction. We add a number to the configura-tion to specify the degree limit on simplicial nodes usedfor social networks. For example, SD18 means simpli-cial node reduction is applied before degree-2 elimina-tion, with the degree limit set to 18 on the social net-work dataset. Note that we never use Reductions 4 and1 together. After degree-2 elimination, path compres-sion cannot reduce the graph and degree-2 eliminationeliminates any nodes contracted by path-compression.Thus, using all reductions equates to the configurationSITD∆. Nodes with high degree can cause simplicialnode reduction (Reduction 1) to be slow. Social net-works tend to contain high-degree nodes, so we limit thedegree of simplicial nodes on these graphs. On meshesand road networks such nodes do not cause problems.Thus, we do not limit the degree for meshes or road
networks. See the technical report [45] for details onthe choice of the degree limit. We use the defaultparameters for nested dissection in Metis. For Scotchwe choose the default ordering strategy (option -cq),which emphasizes quality over speed.
6.1 Experimental Results. We now look at theperformance of different reductions when used as apreprocessing step before running Metis. The timereported for our algorithm is the overall running timeneeded, i.e., compute the kernel, run Metis on thekernel, convert the solution on the kernel to a solutionon the input graph. Figure 2 compares the results fordifferent combinations of reductions and graph classes.We look at each graph class separately, i.e. socialnetworks, mesh-like networks, and road networks. Seethe technical report [45] for results for each instance forconfiguration SID∆12.
Social Networks. We first look at social net-works. In general, reducing the graph before nesteddissection yields significant speedups on most instancesover nested dissection without any reductions. At thesame time the number of non-zeros is also reduced.
With configuration SID∆12 we obtain a speedup of1.5 on average (see Table 2); the improvement in num-ber of non-zeros is 1.06. This configuration yields thehighest speedup and improvement in quality, on aver-age. Note, that for the other configurations, the averagespeedup is greater than 1.35 on average. The social net-works can be reduced to 57% of their original size, onaverage (see Table 2). Out of all graphs and configu-rations we observe the largest speedup of 3.92 for theinstance as-22july06. The smallest speedup for thisgraph is 1.72 with configuration SITP12. Only two outof 21 of the social graphs do not benefit from the reduc-tions in terms of speedup: on the instances eu-2005 andas-skitter nested dissection with reductions is alwaysslower than nested dissection without reductions. Foras-skitter the speedup lies between 0.74 and 0.91, foreu-2005 between 0.81 and 0.95. Out of all graphs andconfigurations the lowest speedup is 0.75 for instancesas-skitter and p2p-Gnutella04, with configurationSITP12 in both cases. With configuration SD18 weobserve a speedup of 1.03 for p2p-Gnutella04.
The largest improvement in number of non-zerosout of all graphs and configurations is 1.31 relative toMetis for the instance coAuthorsCiteseer with config-uration SITP12. The speedup is 1.85 for this graph andconfiguration. Only on the instance coPapersCiteseer
the number of non-zeros is not reduced when applyingreductions. For this graph the number of non-zeros is4% above that of Metis with configuration SD18. Here,the speedup is 1.19. On 13 of the social graphs the
Figure 2: Performance plots for number of non-zeros (left) and running time (right) for different graph classes,from top to bottom: social graphs, meshes and road networks.
number of non-zeros is reduced by all of the configura-tions. The highest number of non-zeros we observe is21% higher than that of Metis on the graph eu-2005
using configuration SITP12.For this graph class, the largest kernel has 96%
of the nodes of the original graph and is obtained byconfiguration SITP12 for instance p2p-Gnutella. Thesmallest kernel has 25% of the nodes and is obtained byall configurations for instance email-EuAll.
Compared to Scotch and averaged over the socialnetworks our algorithm is between 1.8 and 2.2 timesfaster than Scotch and produces orderings with animprovement between 2.13 and 2.23 in terms of thenumber of non-zeros.
Meshes. On the meshes, the reductions do notyield a speedup except for a few instances. Those in-stances are chordal graphs (add20, add32, memplus) and
stiffness matrices (bcsstk*). Chordal graphs are re-duced completely by simplicial node reduction. Here,we observe speedups between 6.9 (add20) and 11.5(memplus). The stiffness matrices contain many indis-tinguishable nodes, so the graph size is reduced signifi-cantly. After applying simplicial node reduction and in-distinguishable node reduction, bcsstk29 is reduced to72% of its original size and bcsstk30 is reduced to 30%in terms of number of nodes. For these bcsstk30/31/32we obtain speedups between 1.08 and 1.36 with config-uration SID∆. For bcsstk29 and bcsstk33 we do notobserve a speedup with this configuration. Note thatour reference, Metis without reductions, contracts indis-tinguishable nodes by default. When indistinguishablenodes are not contracted, our algorithm is more than20% slower on these instances. On the other instancesthe reductions do not have a sufficient impact to reduce
Table 1: Avg. speedup S, improvement in num. of non-zeros (nnz) and kernel size n′ from simplicial node re-duction and degree-2 elimination on the road networks.
Configuration nnz S n′
S 1.04 1.35 0.77D 1.00 4.69 0.30SD 1.06 6.03 0.20
Table 2: Top: Geometric means of the improvement innumber of non-zeros (nnz) relative to Metis (larger isbetter) and speedup (S) relative to Metis for differentconfigurations. Bottom: Average number of nodes inthe kernel and standard deviation σ (smaller is better).
running time or number of non-zeros. On 6 instancesconfiguration SD leads to speedups between 1.03 (cs4)and 1.18 (uk); finan512 has a speedup of 1.11 with con-figuration SID∆. No configuration leads to a speedupgreater than 1 on the remaining instances. The im-provement in number of non-zeros ranges from 0.96(vibrobox, configuration SID∆) to 1.07 (fe ocean,configuration SID∆). The graphs are reduced by nomore than 20%, on average (see Table 2).
Scotch is faster than Metis without reductions on afew instances, but slower in general. Its orderings leadto more non-zeros. Compared to Scotch, our algorithmis between 2 and 2.4 times faster and improves thenumber of non-zeros between 1.26 and 1.3 times.
Road Networks. Applying reductions to roadnetworks leads to high speedups (see Figure 2) andimprovements in quality (see Figure 2). The averagespeedups are between 1.79 and 6.37 (see Table 2). Thenumber of non-zeros is improved between 1.03 and 1.06-fold. Road networks contain many degree-2 nodes, sodegree-2 elimination is highly effective. After removingsimplicial nodes and degree-2 nodes the osm instances
retain less than 20% of their nodes; the instancesroad usa and road central are reduced to around 45%of their original size. Simplicial node reduction on itsown yields a speedup of 1.35 and an improvement innumber of non-zeros by 4% (see Table 1). Degree-2 elimination without simplicial node reduction doesnot improve the number of non-zeros, but leads toa 4.69-fold speedup. Reducing the road networks byboth simplicial node reduction and degree-2 elimination(configuration SD) yields a 6-fold speedup on average(see Table 2), with the lowest speedup at 3.5 and thehighest speedup at 8.2. This is also the highest speedupwe observe. The number of non-zeros is improved by1.06 on average with this configuration. While trianglecontraction further improves the running time, it alsoleads to a larger number of non-zeros.
Configuration SITP results in the lowest speedups,between 1.3 (road central) and 2.2 (asia.osm). Withconfiguration SID∆ the number of non-zeros is in-creased on 4 of the 10 road networks, however,never by more than 6%. Configuration SD improvesthe number of non-zeros the most, by up to 1.08(great-britain.osm). On the road networks Scotch isconsistently faster than Metis without reductions, butthe quality of its orderings is significantly worse. Com-pared to Scotch, our algorithm is between 1.4 and 5.4times faster whenever degree-2 elimination or path com-pression are used, on average. Otherwise, our algorithmis slower. The number of non-zeros is always improved,between 1.6 and 1.7 times.
Using All Reductions. The configurationSITD∆ uses all reductions. For this configuration de-gree limit 12 results in the best performance. For allgraph classes, using all reductions is no better than us-ing configuration SID∆12. The kernels obtained bythe former are within 1% of the size of the kernels ob-tained by the latter, on average. This is not sufficientto reduce the running time. On the social networks, thespeedup of configuration SITD∆12 is 1.44, on average,which is lower than the speedup of 1.5 obtained withconfiguration SID∆12. On the meshes, the speedup ofconfiguration SITD∆ is 0.94; on the road networks it is4.11, on average. The improvement in number of non-zeros does not change by more than 1.5% between thetwo configurations. Adding triangle contraction to theconfiguration SITD yields the configuration SITD∆.With the configuration SITD∆12 we achieve a speedupof 4.11 on the road networks. The number of non-zerosis increased compared to Metis, the improvement being0.99. On the social networks, the average speedup doesnot change and the improvement in number of non-zerosis reduced by less than 1%. On the meshes the num-ber of non-zeros is not changed and the running time is
increased, with the average speedup at 0.94. Adding tri-angle contraction to configuration SITD does not leadto an improvement in running time or quality. On roadnets we get faster running time at the expense of quality.
Comparison with Exact Solutions. In thissection we evaluate our algorithm on the 200 instancesof the PACE 2017 challenge and compare it againstthe winning code of the PACE challenge by Kobayashiand Tamaki. We restrict the evaluation to the PACEchallenge instances since the exact code could only solvethe three chordal instances from the test set used abovewithin a 30 minute time limit. The largest instance inthe PACE challenge test set has roughly 30k nodes and22k edges. We modified the code by Kobayashi andTamaki to output the time needed to compute the fill-edges. Note that we are interested in node orderings,which can be computed from the fill-edges in lineartime. We do not include the time of this postprocessingin the running time of the code since we did not tunethe running time of this postprocessing. This meansthat our speedups are in practice a little bit larger thanreported here.
On our machine, the exact solver solved 64 of thepublic instances and 58 of the hidden instances (122 in-stances in total) in under 24 hours. Our algorithm com-putes orderings on all 200 instances in this time limit. Infact, it takes less than a second on all instances. Figure 3compares the number of fill-edges of our solutions andthe exact solution. Nested dissection without reductionsyields a minimum fill-in ordering for 3 instances. Withreductions, we can solve between 29 instances (with con-figuration SITD) and 34 instances (with configurationSID∆) to optimality. There are 23 chordal instancesthat both algorithms can solve, of which only one ouralgorithm does not solve to optimality.
The reductions also reduce the fill-in of nesteddissection orderings on non-chordal graphs. Nesteddissection without reduction yields orderings with 151more fill-edges than the optimum solution, on average.Using configuration SD this is reduced to 142 edges.The remaining three configurations improve the fill-ineven further, yielding orderings with 106 more fill-edgesthan the optimum. On average, with our reductionswe have between 29% (SID∆) and 43% (SD) morefill-edges than the optimum solution; nested dissectionwithout reductions yields 67% more fill-edges.
The performance plot in Figure 3 clearly showsthat (reduced) nested dissection is significantly fasterthan the exact algorithm. With all configurations weobtain a speedup of at least 4 over the exact algorithm;nested dissection without reduction yields a minimumspeedup of 2. The low minimum speedup is due tothe fact that the exact algorithm tests if the input
reductionsSITP
SITD
SID∆
SD
exact
Metis
1
10
100
1000
10000
1 20 40 60 80 100
# of instances
nu
mb
erof
fill
-ed
ges
0.00
0.25
0.50
0.75
1.00
1 20 40 60 80 100
# of instances
t fast
est/t
alg
ori
thm
Figure 3: Top: number of fill-edges of orderings com-puted by our algorithms compared to the optimum fill-in computed by the exact algorithm of Kobayashi andTamaki submitted to PACE 2017 [17] ordered by size ofthe optimum solution. The instances are sorted by thevalue of the exact solution. Bottom: performance plotfor running time.
graph is chordal, which our algorithm does not do.Taking into account only the non-chordal instances,the minimum speedup is 13 with reductions and 12without reductions. On average over all instances,the speedup over the exact algorithm is between 267(configuration SITP ) and 344 (configuration SD). Forthe non-chordal instances, the speedup over the exactalgorithm is between 499 (configuration SITP ) and663 (configuration SD). No configuration speeds upnested dissection: the lowest speedup is 0.72 withconfiguration SITP and the highest speedup is 0.95with configuration SD.
7 Conclusion
By applying data reduction rules exhaustively we obtainimproved quality and at the same time large improve-ments in running time on a variety of instances. Thisdirectly translates to improvements for typical applica-tions. Overall, we arrive at a system that outperformsthe state-of-the-art significantly.
On road networks we obtain orderings with lowerfill-in six times faster than nested dissection alone. Asorderings of such networks are used in preprocessing ofshortest path algorithm like customizable contractionhierarchies, we believe that the additional reductionspresented here can yield a significant speed up in thepreprocessing time of such algorithms [18, 29].
We have so far not explored the use of these reduc-tion rules in combinations with other algorithms for theminimum fill-in problem. However, the rules presentedhere are mostly independent of the underlying algo-rithm. In particular, eliminating simplicial nodes when-ever possible appears to be very effective in reducingrunning time without harming the quality of the result-ing ordering. Our implementation is part of the KaHIPframework, available at github.com/KaHIP/KaHIP.
References
[1] T. Akiba, Y. Iwata, Y. Sameshima, N. Mizuno,and Y. Yano. Cut tree construction frommassive graphs. In 16th Intl. Conf. on DataMining, ICDM 2016, pages 775–780, 2016.doi:10.1109/ICDM.2016.0089.
[2] P. Amestoy, T. Davis, and I. Duff. An ap-proximate minimum degree ordering algorithm.SIAM J. Matrix Anal. Appl., 17(4):886–905, 1996.doi:10.1137/S0895479894278952.
[3] C. Ashcraft. Compressed graphs and the minimumdegree algorithm. SIAM J. Sci. Comput., 16(6):1404–1411, 1995. doi:10.1137/0916081.
[4] C. Ashcraft and J. W. H. Liu. Generalized nesteddissection: Some recent progress. In J. G. Lewis,editor, Proceedings of the Fifth SIAM Conferenceon Applied Linear Algebra, pages 130–134. SIAM,1994.
[5] C. Ashcraft and J. W. H. Liu. Robust or-dering of sparse matrices using multisection.SIAM J. Matrix Anal. Appl., 19(3):816–832, 1998.doi:10.1137/S0895479896299081.
[6] D. Bader, A. Kappes, H. Meyerhenke, P. Sanders,C. Schulz, and D. Wagner. Benchmarking forGraph Clustering and Partitioning. In Ency-clopedia of Social Network Analysis and Mining.Springer, 2014. doi:10.1007/978-1-4939-7131-2 23.
[7] D. Bader, H. Meyerhenke, P. Sanders, andD. Wagner, editors. Proc. of the 10th DIMACSImpl. Challenge, Cont. Mathematics, 2012. AMS.doi:10.1090/conm/588.
[8] U. Bertele and F. Brioschi. Contribution to non-serial dynamic programming. J. Math. Anal.Appl., 28(2):313–325, 1969. doi:10.1016/0022-247X(69)90030-4.
[9] U. Bertele and F. Brioschi. A new algorithm for thesolution of the secondary optimization problem innon-serial dynamic programming. J. Math. Anal.Appl., 27(3):565–574, 1969. doi:10.1016/0022-247X(69)90137-1.
[10] C. Bichot and P. Siarry, editors. Graph Partition-ing. Wiley, 2011.
[11] H. L. Bodlaender, P. Heggernes, and Y. Vil-langer. Faster parameterized algorithms for min-imum fill-in. Algorithmica, 61(4):817–838, 2011.doi:10.1007/s00453-010-9421-1.
[12] A. Buluc, H. Meyerhenke, I. Safro, P. Sanders, andC. Schulz. Recent advances in graph partitioning.In L. Kliemann and P. Sanders, editors, AlgorithmEngineering: Selected Results and Surveys, pages117–158. Springer, 2016. doi:10.1007/978-3-319-49487-6 4.
[13] M. Cygan, F. V. Fomin, L. Kowalik, D. Loksh-tanov, D. Marx, M. Pilipczuk, M. Pilipczuk, andS. Saurabh. Parameterized Algorithms. Springer,2015. doi:10.1007/978-3-319-21275-3.
[14] J. Dahlum, S. Lamm, P. Sanders, C. Schulz,D. Strash, and R. F. Werneck. Accelerating lo-cal search for the maximum independent set prob-lem. In Intl. Symp. on Experimental Algorithms,pages 118–133. Springer, 2016. doi:10.1007/978-3-319-38851-9 9.
[15] T. A. Davis and Y. Hu. The universityof florida sparse matrix collection. ACMTrans. Math. Softw., 38(1):1–25, 2011.doi:10.1145/2049662.2049663.
[16] T. A. Davis, S. Rajamanickam, and W. M. Sid-Lakhdar. A survey of direct methods for sparselinear systems. Acta Numer., 25:383—-566, 2016.doi:10.1017/S0962492916000076.
[17] H. Dell, C. Komusiewicz, N. Talmon, andM. Weller. The PACE 2017 Parameterized Al-gorithms and Computational Experiments Chal-lenge: The Second Iteration. In 12th Inter-national Symposium on Parameterized and Ex-act Computation (IPEC 2017), volume 89 ofLIPIcs, pages 30:1–30:12, Dagstuhl, Germany,2018. Schloss Dagstuhl–Leibniz-Zentrum fuer In-formatik. doi:10.4230/LIPIcs.IPEC.2017.30.
[18] J. Dibbelt, B. Strasser, and D. Wagner. Customiz-able contraction hierarchies. ACM Journal of Ex-perimental Algorithmics, 21(1):1.5:1–1.5:49, 2016.doi:10.1145/2886843.
[19] R. G. Downey and M. R. Fellows. ParameterizedComplexity. Spinger, 1999. doi:10.1007/978-1-4612-0515-9.
[20] F. V. Fomin and Y. Villanger. Subexponen-tial parameterized algorithm for minimum fill-in.SIAM Journal on Computing, 42(6):2197–2216,2013. doi:10.1137/11085390X.
[21] F. V. Fomin, I. Todinca, and Y. Villanger. Largeinduced subgraphs via triangulations and CMSO.SIAM Journal on Computing, 44(1):54–87, 2015.doi:10.1137/140964801.
[22] A. George. Nested dissection of a regular finiteelement mesh. SIAM J. Numer. Anal., 10(2):345–363, 1973. doi:10.1137/0710032.
[23] A. George and J. W. H. Liu. A quotient graphmodel for symmetric factorization. In I. S. Duff andG. W. Stewart, editors, Sparse Matrix Proceedings1978, pages 154–175. SIAM, 1978.
[24] A. George and J. W. H. Liu. An automatic nesteddissection algorithm for irregular finite elementproblems. SIAM J. Numer. Anal., 15(5):1053–1069, 1978. doi:10.1137/0715069.
[25] A. George and J. W. H. Liu. A fast implementationof the minimum degree algorithm using quotientgraphs. ACM Trans. Math. Softw., 6(3):337–358,1980. doi:10.1145/355900.355906.
[26] A. George and J. W. H. Liu. The evolution of theminimum degree ordering algorithm. SIAM Rev.,31(1):1–19, 1989. doi:10.1137/1031001.
[27] A. George and J. W. Liu. The evolution ofthe minimum degree ordering algorithm. SIAMReview, 31(1):1–19, 1989. doi:10.1137/1031001.
[28] G. H. Golub and C. F. Van Loan. Matrix Computa-tions. Johns Hopkins Studies in the MathematicalSciences. Johns Hopkins University Press, 2013.
[29] L. Gottesburen, M. Hamann, T. N. Uhl, andD. Wagner. Faster and better nested dissectionorders for customizable contraction hierarchies. Al-gorithms, 12(9):196, 2019. doi:10.3390/a12090196.
[30] B. Hendrickson and E. Rothberg. Improving therun time and quality of nested dissection order-ing. SIAM J. Sci. Comput., 20(2):468–489, 1998.doi:10.1137/S1064827596300656.
[31] M. Henzinger, A. Noe, C. Schulz, and D. Strash.Practical minimum cut algorithms. In Proc.of the 20th Workshop on Algorithm Engineeringand Experiments, ALENEX, pages 48–61, 2018.doi:10.1137/1.9781611975055.5.
[32] M. Henzinger, A. Noe, and C. Schulz. Shared-memory exact minimum cuts. In Interna-tional Parallel and Distributed Processing Sym-posium, IPDPS, pages 13–22. IEEE, 2019.doi:10.1109/IPDPS.2019.00013.
[33] M. Henzinger, A. Noe, and C. Schulz. Shared-memory branch-and-reduce for multiterminal cuts.In Proceedings of the Twenty-First Workshopon Algorithm Engineering and Experiments,ALENEX 2020, pages 42–55. SIAM, 2020.doi:10.1137/1.9781611976007.4.
[34] D. Hespe, C. Schulz, and D. Strash. Scalable ker-nelization for maximum independent sets. In Proc.of the 20th Workshop on Algorithm Engineeringand Experiments, ALENEX, pages 223–237, 2018.doi:10.1137/1.9781611975055.19.
[35] D. Hespe, S. Lamm, C. Schulz, and D. Strash.WeGotYouCovered: The winning solver fromthe PACE 2019 Implementation Challenge, ver-tex cover track. In 2020 Proceedings ofthe SIAM Workshop on Combinatorial Sci-entific Computing, pages 1–11. SIAM, 2020.doi:10.1137/1.9781611976229.1.
[36] H. Kaplan, R. Shamir, and R. E. Tarjan.Tractability of parameterized completion prob-lems on chordal and interval graphs: Mini-mum fill-in and physical mapping. In Pro-ceedings 35th Annual Symposium on Foundationsof Computer Science, pages 780–791, Nov 1994.doi:10.1109/SFCS.1994.365715.
[37] H. Kaplan, R. Shamir, and R. E. Tarjan. Tractabil-ity of parameterized completion problems onchordal, strongly chordal, and proper intervalgraphs. SIAM Journal on Computing, 28(5):1906–1922, 1999. doi:10.1137/S0097539796303044.
[38] G. Karypis and V. Kumar. A fast and highquality multilevel scheme for partitioning irregulargraphs. SIAM J. Sci. Comput., 20(1):359–392,1998. doi:10.1137/S1064827595287997.
[39] S. Kratsch. Recent developments in kerneliza-tion: A survey. Bulletin of the EATCS, 113,2014. URL http://eatcs.org/beatcs/index.
[40] S. Lamm, C. Schulz, D. Strash, R. Williger, andH. Zhang. Exactly solving the maximum weight in-dependent set problem on large real-world graphs.In Proc. of the 21st Workshop on Algorithm En-gineering and Experiments, ALENEX 2019, pages144–158, 2019. doi:10.1137/1.9781611975499.12.
[41] D. LaSalle and G. Karypis. Efficient nested dissec-tion for multicore architectures. In Euro-Par 2015:Parallel Processing, pages 467–478. Springer, 2015.doi:10.1007/978-3-662-48096-0 36.
[42] J. Leskovec and A. Krevl. SNAP Datasets: Stan-ford large network dataset collection. http://
snap.stanford.edu/data, 2014.
[43] H. Meyerhenke, P. Sanders, and C. Schulz. Parti-tioning complex networks via size-constrained clus-tering. In J. Gudmundsson and J. Katajainen,editors, Experimental Algorithms, pages 351–363.Springer, 2014. doi:10.1007/978-3-319-07959-2 30.
[44] T. Ohtsuki, L. K. Cheung, and T. Fujisawa. Min-imal triangulation of a graph and optimal piv-oting order in a sparse matrix. J. Math. Anal.Appl., 54(3):622–633, 1976. doi:10.1016/0022-247X(76)90182-7.
[45] W. Ost, C. Schulz, and D. Strash. Engineer-ing data reduction for nested dissection. CoRR,abs/2004.11315, 2020. URL https://arxiv.org/
abs/2004.11315.
[46] F. Pellegrini. Scotch. Version 6.0.6, 2020.URL https://www.labri.fr/perso/pelegrin/
scotch/.
[47] D. Rose, R. E. Tarjan, and G. S. Lueker.Algorithmic aspects of vertex elimination ongraphs. SIAM J. Comput., 5(2):266–283, 1976.doi:10.1137/0205021.
[48] D. J. Rose. Triangulated graphs and the elimina-tion process. J. Math. Anal. Appl., 32:597–609,1970. doi:10.1016/0022-247X(70)90282-9.
[49] D. J. Rose. A graph-theoretic study of the nu-merical solution of sparse positive definite sys-tems of linear equations. In R. C. Read, editor,Graph Theory and Computing, pages 183–217. Aca-demic Press, 1972. doi:10.1016/B978-1-4832-3187-7.50018-0.
[50] C. Schulz and D. Strash. Graph partitioning:Formulations and applications to big data. InEncyclopedia of Big Data Technologies. Springer,2019. doi:10.1007/978-3-319-63962-8 312-2.
[51] A. J. Soper, C. Walshaw, and M. Cross. Acombined evolutionary search and multileveloptimisation approach to graph-partitioning.J. Global. Optim., 29(2):225–241, 2004.doi:10.1023/B:JOGO.0000042115.44455.f3.
[52] D. A. Spielman. Algorithms, graph theory, and thesolution of laplacian linear equations. In Automata,Languages, and Programming - 39th InternationalColloquium, ICALP, LNCS, pages 24–26, 2012.doi:10.1007/978-3-642-31585-5 5.
[53] H. Tamaki. Positive-instance driven dynamicprogramming for treewidth. In 25th Euro-pean Symposium on Algorithms, ESA’17, vol-ume 87 of LIPIcs, pages 68:1–68:13, 2017.doi:10.4230/LIPIcs.ESA.2017.68.
[54] W. F. Tinney and J. W. Walker. Direct solutionsof sparse network equations by optimally orderedtriangular factorization. Proc. IEEE, 55(11):1801–1809, 1967. doi:10.1109/PROC.1967.6011.
[55] M. Yannakakis. Computing the minimum fill-in is NP-complete. SIAM J. Algebraic DiscreteMethods, 2(1):77–79, 1981. doi:10.1137/0602010.
A Proofs Omitted from the Main Text
Proof. [Proof of Theorem 4.1] Since Γ(x) is a clique,D(x) = ∅. The fill-in associated with eliminating x firstis φ(G, xΣ(Gx)) = |D(x)|+Φ(Gx) = Φ(Gx). From (2.1)it follows that φ(G, xΣ(Gx)) = Φ(G).
Proof. [Proof of Lemma 4.1] Let x ∈ Γ(a) \ {b} =Γ(b) \ {a} be eliminated from G. In the eliminationgraph ΓGx
(a) = (Γ(a) \ {x}) ∪ Γ(x) and ΓGx(b) =
(Γ(b) \ {x}) ∪ Γ(x). Since a ∈ ΓGx(b) and b ∈ ΓGx
(a),ΓGx
[a] = ΓGx[b]. Thus, a and b are indistinguishable in
Gx.If a node y with y /∈ Γ(a) and y /∈ Γ(b) is eliminated
from G, the neighborhoods of a and b do not change,since a, b /∈ Γ(y). In the elimination graph ΓGy
[a] =ΓGy
[b]. Thus, a and b are indistinguishable in Gy.
Proof. [Proof of Theorem 4.2] Lemma 4.1 implies thatall pairs of nodes in A are indistinguishable in all graphsin the elimination sequence. Let a ∈ A be the nodethat is eliminated before all other nodes in A. Thereis a graph G(m) in the elimination sequence with a
minimum ordering aΣ(G(m)a ), a ∈ A. For all b ∈ A\{a}
ΓG
(m)a
(b) is a clique, i.e., these nodes are simplicial
after elimination of a. Thus, AΣ(G(m)A ) is a minimum
ordering of G(m) and G has a minimum ordering of theform of σ′.
Figure 4: Examples for the three cases in the proof ofTheorem 4.4. Red nodes are nodes in P , black nodesare in Γ(P ). Dashed edges lead to some other nodes inthe graph.
Proof. [Proof of Theorem 4.3] If a node x ∈ Γ(a) = Γ(b),is eliminated, a and b form a clique in the eliminationgraph Gx. Thus, a and b are indistinguishable in Gxand Theorem 4.2 holds. If a node x /∈ Γ(a) ∪ {a, b} iseliminated, the neighborhoods of nodes a and b do notchange, i.e., ΓGx
[a] = ΓG[a] and ΓGx[b] = ΓG[b]. Thus,
a and b are twins in Gx. If a is eliminated, ΓGa(b) is
a clique in the elimination graph Ga and b is simplicialin Ga. With Theorem 4.1, bΣ((Ga)b) is a minimumordering of Ga and abΣ((Ga)b) is a minimum orderingof G.
Proof. [Proof of Lemma 4.5] Let C = {C1, . . . , Cn} bethe set of induced cycles that contain a, i.e., for all i,a ∈ Ci and G[Ci] is a cycle. Since a has degree two,Γ(a) ⊂ Ci for all i. By Lemma 4.3, for all Ci ∈ C,there exists a minimum triangulation Ti of G[Ci] withΓ(a) ∈ Ti. Thus, there exists a minimum triangulationT of G with Γ(a) ∈ T . Γ(a) is a separation clique withcomponents {a} and V \({a}∪Γ(a)) in the triangulatedgraph G = (V,E ∪ T ). By Lemma 4.2 there exists noedge {a, x} ∈ T . This implies Γ(a) ∈ T , {a, x} /∈ T andT is minimum.
Proof. [Proof of Lemma 4.4] With Lemma 4.5 thereexists a minimum triangulation T of G with Γ(a) ∈ Tand {a, x} /∈ T . a is simplicial in the triangulated graphG = (V,E ∪ T ) and aΣ(Ga) is a minimum ordering ofG. This implies that aΣ(Ga) is a minimum ordering ofG. Note that eliminating a from G adds the edge Γ(a)to the elimination graph.
Proof. [Proof of Theorem 4.4] G can be decomposedinto non-disjoint graphs G′ := G[V \ P ] and G′′ :=
G[P ∪ Γ(P )], such that G = G′ ∪ G′′. We distinguishthree cases (see Figure 4 for examples):
Case 1: If a0 = ak+1 or a0 ∈ Γ(ak+1), then G′′ is acycle and Γ(P ) is a separation clique with leavesG′ and G′′. Let T ′ be a minimum triangulation ofG′ and T ′′ be a minimum triangulation of G′′. ByLemma 4.2, T ′ ∪ T ′′ is a minimum triangulation ofG. Since any ordering of G′′ generates a minimumtriangulation of G′′ (by Lemma 4.3), PΣ(G′′P )is a minimum ordering of G′′ and PΣ(GP ) is aminimum ordering of G.
Case 2: If a0 6= ak+1, and {a0} and {ak+1} areseparation cliques, then all nodes in P are alsoseparation cliques. By Lemma 4.2, there areno edges {ai, aj}, for all i 6= j in a minimumtriangulation of G.
Let Σ be any minimum fill-in ordering of G and letG(m) be the graph in the elimination sequence fromwhich a ∈ P is eliminated. Node a is simplicialin G(m), otherwise T (Σ) would not be a minimumtriangulation. Since all a ∈ P are separation cliquesand deg(a) = 2 in G, deg(a) = 1 in G(m).
Without loss of generality assume that a1 is elim-inated before all other nodes in P . Let G(m1) bethe graph in the elimination sequence from whicha1 is eliminated. If deg(a1) = 1 in G(m1), then
deg(a2) = 1 in G(m1)a1 . Repeating this argument for
all ai ∈ P proves that PΣ(G(m1)P ) is a minimum
ordering of G(m1) and Σ is of the form of σ′.
Case 3: If {a0}, {ak+1} and Γ(P ) are not separationcliques, then any a ∈ P satisfies the conditions inLemma 4.4. In Ga, {a0}, {ak+1} and Γ(P ) are notseparation cliques. Repeating the argument for Galeads to a minimum ordering PΣ(GP ).
In Case 1 and Case 3, there exists a minimum orderinga1 · · · akx1 · · ·x`. In Case 2, there exists a minimumordering x1 · · ·xia1 · · · akxi+1 · · ·x`. Both orderings areof the form of σ′.
Proof. [Proof of Corollary 4.1] Node x is part of a cycleand thus not a separation clique. Either case 1 or 3of Theorem 4.4 holds, which implies that xΣ(Gx) is aminimum ordering of G.
Proof. [Proof of Corollary 4.2] Since x is a separationclique, Case 2 of Theorem 4.4 holds and thus, x issimplicial in G(i).
