JohannesK.Fichte,MarkusHecher,andStefanSzeider BreakingSymmetrieswithRootCliqueandLexTopSort TechnicalReportAC-TR-20-010

(1)

Algorithms and Complexity Group | Institute of Logic and Computation | TU Wien, Vienna, Austria

Technical Report AC-TR-20-010

September 2020

Breaking Symmetries with RootClique and LexTopSort

Johannes K. Fichte, Markus Hecher, and Stefan Szeider

This is the authors’ copy of a paper that will appear in the proceedings of CP’20, the 26th International Conference on Principles and Practice of Constraint Program- ming. DOI 10.1007/978-3-030-58475-7_17

(2)

Breaking Symmetries with RootClique and LexTopSort

^?

Johannes K. Fichte¹, Markus Hecher², and Stefan Szeider³

1 School of Engineering Sciences, TU Dresden, Dresden, Germany johannes.fichte@tu-dresden.de

2 Database and Artificial Intelligence Group, TU Wien, Vienna, Austria hecher@dbai.tuwien.ac.at

3 Algorithms and Complexity Group, TU Wien, Vienna, Austria sz@ac.tuwien.ac.at

Abstract Bounded fractional hypertree width is the most general known structural property that guarantees polynomial-time solvability of the constraint satisfaction problem. Fichte et al. (CP 2018) presented a robust and scalable method for finding optimal fractional hypertree decompositions, based on an encoding to SAT Modulo Theory (SMT).

In this paper, we provide an in-depth study of two powerful symmetry breaking predicates that allow us to further speed up the SMT-based decomposition: RootClique fixes the root of the decomposition tree;

LexTopSort fixes the elimination ordering with respect to an underlying DAG. We perform an extensive empirical evaluation of both symmetry- breaking predicates with respect to the primal graph (which is known in advance) and the induced graph (which is generated during the search).

Keywords: Symmetry Breaking·Hypergraphs·Elimination Orderings

·SAT Modulo Theory.

1 Introduction

Boundedfractional hypertree width, introduced by Grohe and Marx [24,25], is the most general known purely structural restriction that guarantees polynomial-time tractability of the CSP. It generalizes all previously introduced structural restriction, including treewidth [11,19], spread-cut width [10] and hypertree width [22].

However, in order to utilize bounded fractional hypertree width of a CSP instance for solving it efficiently, one needs to have a fractional hypertree decomposition of the constraint hypergraph of the CSP instance available, witnessing the bounded fractional hypertree width. Computing such a decomposition of smallest width is again an NP-hard task [18]. Nevertheless, previous work by Fichte et al. [16]

showed that a practically feasible SMT (SAT Modulo Theory) encoding exists, which supports the computation of optimal fractional hypertree decompositions of constraint hypergraphs with several hundred of vertices.

?The work has been supported by the Austrian Science Fund (FWF), Grants Y698, 32441, and 32830, and the Vienna Science and Technology Fund, Grant WWTF ICT19-065. Hecher is also affiliated with the University of Potsdam, Germany.

TechnicalReportAC-TR-20-010

(3)

Contribution. In this paper, we introduce and study new symmetry breaking methods that speed up the SMT-approach for finding optimal fractional hypertree decompositions. Fractional hypertree decompositions are defined in terms of an (unrooted) decomposition tree, whose nodes are labeled with so-called bags of vertices of the decomposed hypergraph. However, the SMT encoding is based on a characterization of fractional hypertree width in terms of linear elimination orderings of the vertices of the decomposed constraint hypergraph. A hypergraph withnvertices hasn! linear elimination orderings, where many of these correspond to the same decomposition tree. Consequently, that there is much room for symmetry breaking (SB) strategies. We take a closer look at two symmetry breaking methods:RootCliqueandTopSort.

RootClique is based on the observation, that we can pick any clique of the primal graph of the decomposed hypergraph, and assume that this clique appears in the bag of the decomposition tree’s root; hence we call it a root clique. This symmetry breaking predicate allows us to restrict the considered linear orderings to only those where vertices of the root clique appear at the very end.

A linear ordering of the vertices gives rise to a decomposition DAG on the same vertex set, whose arcs correspond to the edges of the induced primal graph of the decomposed hypergraph, oriented according to the linear ordering.

LexTopSort is based on the observation that from the many linear orderings that are all topological sort of the same decomposition DAG, it suffices to consider only one of them.

For both symmetry breaking predicates, we consider static and dynamic variants. The static variants operate on theprimal graphof the given hypergraph.

The dynamic variant operates on the induced primal graph, which is obtained from the primal graph during the search by adding fill-in edges according to the computed elimination ordering. Whereas the static variants have the advantage that the symmetry breaking constraints can be computed in a preprocessing phase before the decomposition process starts, it has the disadvantage of having fewer edges available and thus breaks fewer symmetries. Our experiments show whether advantage or disadvantage dominates.

A static version of RootClique was initially suggested for tree decompositions by Bodlaender et al. [7] and then ported to fractional hypertree decompositions by Fichte et al. [16]. For tree decompositions, it is reasonable to take a largest clique as the root clique, as it has the best chance to break the most symmetries.

For a hypergraph, it is not clear what makes a clique well-suited for symmetry breaking. In addition to the size of the root clique, we consider several other criteria such as the size of the root clique including its neighborhood, the size of the root clique not counting twin vertices, or the number of hyperedges being incident with a vertex of the root clique. We also introduce a dynamic variant of RootClique, which requires a nontrivial SMT encoding.

For the other symmetry breaking predicate, LexTopSort, it is the other way around: a dynamic version has been suggested for hypertree decompositions by Schidler and Szeider [35], and we introduce and test a first static variant.

(4)

We provide an extensive experimental evaluation of all the discussed variants and combinations of RootClique and LexTopSort within the basic SMT encoding for fractional hypertree widthfrasmtby Fichte et al. [16]. For the experiments, we ran all the mentioned variants on the two leading SMT solvers z3 [32]

andoptimathsat [36]. Overall, RootClique seems to show better results than LexTopSort. However, combining the two techniques at the same time even further improved the performance and the number of solved instances. Notably, it seems that using both solvers z3 and optimathsat in combination, where we preferred the latter for instances of higher fractional hypertree width, the resulting portfolio is quite close to the virtual best solver of our experiments.

2 Preliminaries

Hypergraphs.Ahypergraph is a pairH = (V(H), E(H)), consisting of a set V(H) of vertices and a set E(H) of hyperedges, each hyperedge is a subset ofV(H). For a hypergraphH = (V, E) and a vertexv∈V, we writeEH(v) = {e∈E|v∈e}andNH(v) = (S

EH(v))\ {v}; the latter set is theneighborhood ofv. Ifu∈NH(v) we say thatu andv areadjacent. ThehypergraphH−vis defined byH= (V \ {v},{e\ {v} |e∈E}). Theprimal graph (or 2-section) of a hypergraphH= (V, E) is the graphP(H) = (V, EP(H)) with EP(H)={ {u, v} | u6=v, there is somee∈E such that{u, v} ⊆e}.

Consider a hypergraph H = (V, E) and a setS ⊆ V. An edge cover of S (with respect toH) is a set F ⊆ E such that for every v ∈S there is some e∈F withv∈e. Afractional edge cover ofS (with respect toH) is a mapping γ:E→[0,1] such that for everyv∈S we haveP

e∈EH(v)γ(e)≥1. Theweight ofγis defined asP

e∈Eγ(e). Thefractional edge cover number ofS(with respect to a hypergraphH), denotedfnH(S), is the minimum weight over all its fractional edge covers with respect toH.

Atree decomposition of a hypergraphH= (V, E) is a pairT = (T, χ) where T = (V(T), E(T)) is a tree andχis a mapping that assigns eacht∈V(T) a set χ(t)⊆V (called thebag att) such that the following properties hold:

– for eachv∈V there is somet∈V(T) withv∈χ(t) (“vis covered byt”), – for eache∈Ethere is somet∈V(T) withe⊆χ(t) (“eis covered byt”), – for any threet, t⁰, t⁰⁰∈V(T) wheret⁰ lies on the path betweentandt⁰⁰, we

haveχ(t⁰)⊆χ(t)∩χ(t⁰⁰) (“bags containing the same vertex are connected”).

The width of a tree decompositionT ofH is the size of a largest bag ofT minus 1. The treewidth tw(H) of H is the smallest width over all its tree decompositions.

Hypertree Decompositions.Ageneralized hypertree decomposition ofH is a tripleG= (T, χ, λ) where (T, χ) is a tree decomposition ofH andλis a mapping that assigns eacht∈V(T) anedge cover λ(t) ofχ(t). Thewidth ofG is the size of a largest edge coverλ(t) over all t∈V(T). Ahypertree decomposition is a generalized hypertree decomposition that satisfies a certain additional property,

(5)

which was added to make the computation of the decomposition tractable [22].

The generalized hypertree width ghtw(H) ofH is the smallest width over all generalized hypertree decompositions ofH. Thehypertree width htw(H) is the smallest width over all hypertree decompositions ofH.

A fractional hypertree decomposition of H is a triple F = (T, χ, γ) where (T, χ) is a tree decomposition ofH andγis a mapping that assigns eacht∈V(T) a fractional edge coverλ(t) ofχ(t) with respect to H. The width of F is the largest weight of the fractional edge coversλ(t) over allt∈V(T). The fractional hypertree widthfhtw(H) ofH is the smallest width over all fractional hypertree decompositions ofH.

To avoid trivial cases, we consider only hypergraphsH= (V, E) withEH(v)6=

∅for allv∈V. Consequently, every considered hypergraphH has a (fractional) edge cover andfhtw(H) is always defined. If |V|= 1 thenfhtw(H) = 1.

Since an edge cover can be seen as the special case of a fractional edge cover, with weights restricted to{0,1}, it follows that for every hypergraphH we have fhtw(H)≤ghtw(H)≤htw(H)≤tw(P(H)).

Elimination Orderings.The first SAT encoding of treewidth was suggested by Samer and Veith [34]. It uses an ordering-based characterization of treewidth which is also used by more recent SAT encodings of treewidth [3,6]. Later, ordering- based encodings where used for hypertree width [35], generalized hypertree width [5], and fractional hypertree width [16,28].

Let H = (V, E) be a hypergraph with n = |V| and L = (v1, . . . , vn) a linear ordering of the vertices ofH. We define thehypergraph induced byLas H_Lⁿ= (V, Eⁿ) whereEⁿ is obtained fromEby adding hyperedges successively as follows. We letE⁰ =E, and for 1≤ i≤n we letEⁱ =Eⁱ⁻¹∪ {ei}where ei ={v ∈ {vi+1, . . . , vn} | there is some e ∈Eⁱ⁻¹ containing v and vi}. We consider the binary relation ArcL = {(vi, vj) ∈ V ×V | i < j and vi and vj are adjacent in H_Lⁿ}. We write ArcL(i) = {vi} ∪ {vj | (vi, vj) ∈ ArcL}, henceArcL(i) ={vi} ∪ei. We refer toP(H_Lⁿ), the primal graph of the induced hypergraphH_Lⁿ, as theinduced primal graph.

Thefractional hypertree width ofHwith respect to a linear orderingL, denoted fhtwL(H), is the largest fractional edge cover number with respect toH over all the setsArcL(i), i.e.,

fhtwL(H) =maxⁿ

i=1 fnH(ArcL(i)).

Theorem 1 ([16]).The fractional hypertree width of a hypergraphH equals the smallest fractional width over all its linear orderings:fhtw(H) = minLfhtwL(H).

3 Symmetry Breaking for Elimination Orderings

In this section, we define all the symmetry breaking predicates, static and dynamic, and describe their encoding. Throughout this section, letH= (V, E) be a fixed hypergraph.

(6)

As laid out in the proof of Theorem 1, one can translate back and forth between linear orderings and fractional hypertree decomposition, preserving the fractional width. The translation from the linear ordering into a decomposition is canonical and deterministic. The translation in the other direction, however, depends on several choices. Let us briefly describe the translation.

Let F = (T, χ, γ) be a fractional hypertree decomposition ofH. First, we choose a noderofT as the root and consider a rooted versionTr ofT. For each vertex v ∈V, let t =f(v) be the node of Tr with v ∈χ(t) that is closest to the rootr. This consideration yields a partial ordering≤F ofV, whereu≤F v if and only iff(u) is a descendant off(v) in Tr. The proof of Theorem 1 [16]

shows that any linear orderingLofV that refines≤F, has the same fractional width as F. We observe that the linear orderings that refine ≤F are exactly thetopological sorts of the DAGD_F = (V, A) where A={(u, v)|u6=v and u≤F v}. Any topological sortLcan be obtained fromD_F by repeatedly deleting vertices without incoming arcs until all vertices have been deleted:Lis then the set of vertices arranged by their succession of deletion.

When we fix the root and the topological sort, we have determined the linear ordering uniquely. We will fix the root with the RootClique symmetry breaking predicate, and we will fix the topological sort with the LexTopSort symmetry breaking predicate.

3.1 RootClique

The static RootClique predicate is based on the well-known fact that, if (T, χ) is a tree decomposition of a graphGandK a clique inG, then there exists a nodet ∈V(T) with V(K)⊆ χ(t) (see, e.g., [8]). Hence, when we choose any clique K in the primal graphP(H), the static RootClique predicate requires that the rootris chosen among the nodes for whichV(K)⊆χ(r) holds. This is not a full symmetry breaking, since a clique may appear in different bags. Hence, we suggest several strategies for choosing a clique that suits this purpose. In particular, we choose a clique inP(H), maximizing

1. the size of the clique,

2. the size of the clique including its neighborhoodNH(K) inP(H),

3. the size of the clique not countingtwin vertices, which are any two verticesu, v sharing the same neighborhood, i.e., whereNH(u) =NH(v), and

4. the number of hyperedges being incident with a vertex of the clique.

We also considerk-hypercliques which are cliques inP(H) not intersecting with any hyperedge ofH in more thankvertices. This concept was proposed by Fichte et al. [16], and was primarily intended to obtain lower bounds during the computation of fractional hypertree width. The dynamic RootClique predicate is based on the fact that each bagχ(t) is a clique in theinduced primal graph, and conversely, every maximal clique in the induced primal graph corresponds toχ(t) for some nodet. We uniquely determine the root of the decomposition tree by fixing the largest clique of the induced primal graph as the root clique.

Further details and the encodings are given after the next subsection.

(7)

3.2 LexTopSort

We start by explaining the dynamic variant of LexTopSort. For better integration with RootClique, we use the inverse variant of topological sorting, where vertices without outgoing arcs are deleted, proving the ordering “from right to left.” When there are several vertices without outgoing arcs, we choose the lexicographically smallest vertex next. This choice uniquely determines the linear ordering, which corresponds to the reflected lexicographically smallest topological sort. We denote for two vertices vi, vj by lex(vi, vj) that vi precedes vj in the lexicographic ordering.

We enforce this restriction on the linear orderingL= (v1, . . . , vn) of V with the following predicate:For any 1≤i < j ≤n, if lex(vi, vj), then there must be some k∈ {i+ 1, . . . , j} such that the induced primal graph contains the edge {vi, vk}.In other words, when we delete the lexicographically larger vertexvj

before we delete the lexicographically smaller vertex vi, thenvi must have a neighborvk which has not been eliminated at that time, i.e.,vihas an outgoing arc inD_F to a vertexvk that is still present whenvj is deleted.

Since the encoding of dynamic LexTopSort is expensive, we propose a new relaxed static version, which does not break all symmetries but can be encoded in a significantly more compact way. The static version is obtained by a small but influential change in the symmetry breaking predicate, by using the primal graph, not the induced primal graph:For any1≤i < j≤n, if lex(vi, vj), then there must be some k∈ {i+ 1, . . . , j} such that the primal graph contains the edge{vi, vk}.

3.3 Encodings for Symmetry Breaking

In this section, we describe how RootClique and LextTopSort can be encoded within the SMT encoding for fractional hypertree width due to Fichte et al. [16], which we briefly review. To this end, letH = (V, E) be a given hypergraph with V ={v1, . . . , vn}andwbe a rational number. The encoding is an SMT formula that is satisfiable if and only if the hypergraph has a linear orderingLofV such thatfhtwL(H)≤w. For computing the relationArcL, it uses Booleanordering variables oi,j for 1≤i < j≤nand Booleanarc variables ai,j for 1≤i, j≤n.

Clauses are added that ensure that an ordering variableoi,j is true if and only if i < j andvi precedesvj inL. In the following, we leto^∗(i, j) refer too(i, j) if i < j and¬o(j, i) otherwise. The arc variables are used to represent the relation ArcL for the ordering Lrepresented by the ordering variables, where a(i, j) is true if and only if (vi, vj)∈ArcL, i.e., ifvj ∈ArcL(i). Finally, weight variable w(i, e) for each 1 ≤i≤nande∈E is used to represent the weight ofein a fractional edge coverγL(i) of the setArcL(i), whereLis the ordering represented by the ordering variables.

Static RootClique (s-RQ). We encoded all the different variants for choosing cliques, and computed them by a solver in a separate solving step, executed before the actual decomposition. To this end, we use Booleanclique variables of

(8)

the formk(i) for each vertexvi∈V(H), where those vertices set to true form a cliqueK. All variants have in common, that a clique is computed as follows.

[¬k(i)∨ ¬k(j)] for any two verticesvi, vj ∈V(H) withvj6∈NH(vi).

Then, we considered different maximization constraints on top, resulting in different variants. In the following, we present variants for computing cliques that require adding different constraints to the constraint above.

Largest Clique (LQ). For obtaining a clique of size at least`, we add the following constraints.

[P

vi∈V(H)k(i)≥`]

Largest Clique Including Neighbors (LQ+N). We also considered maximizing a clique, where we additionally count the neighbors of the clique.

[P

vi∈V(H)k(i)+|NH(vi)| ≥`]

Largest Clique Excluding Twins (LQ-T). The following variant excludes twin vertices, when computing a maximal clique.

[P

vi∈V(H)k(i)− (P

vi∈V(H)|{vj∈V(H)|j > i, NH(vj)=NH(vi)}|)≥`]

Largest k-Hyperclique (k-Hy). For k-hypercliques, we need the following additional constraints.

[¬k(i1)∨ · · · ∨ ¬k(ik)] for anykverticesvi1, . . . , vik of hyperedgee∈E(H), [P

vi∈V(H)k(i)≥`]

Clique with Largest Number of Used Hyperedges (LuH). This variant concerns only about maximizing the number of hyperedges that are adjacent to a clique.

[P

e∈E(H)( W

vi∈e

k(i))≥`]

Finally, after having computed a cliqueK, which can be obtained with any of the variants above, one can add the following constraints to the base encoding in order to actually break symmetries, statically guided byK. More precisely, the cliqueK is ensured to be eliminated before the other vertices (and considered the root of the decomposition) such that each vertex of K is eliminated in lexicographic order, i.e., according toL.

[o^∗(i, j)] for vj∈V(H)\K,vi∈K,

[o^∗(i, j)] for vi, vj∈K,vi6=vj, lex(vi, vj).

(9)

Dynamic RootClique (d-RQ). While the main idea of this approach is similar to static RootClique, here we aim for a largest bag of the resulting decomposition to be the root node. However, this does not depend on the presence of a clique in the primal graph P(H). Instead, we require such a clique in the induced primal graph of H. As a result, the SMT encoding for fractional hypertree decompositions based on elimination orderings is directly extended. For finding a largest bag, Boolean variablesB(i), b(i) for 1≤i≤nand integer variablesd(i) for computing the degree of outgoing arcs in the induced primal graph ofH are used. Intuitively,B(i) indicates thatvi∈V(H) is the lexicographically largest vertex inLthat is contained in a largest bag. Consequently, smaller vertices ofi are in this largest bag, whose member elements are indicated by variablesb(j).

The following constraints model this construction, where the degree variables are computed and only one largest bag is allowed.

[d(i) =P

1≤j≤n,j6=ia(i, j)] for 1≤i≤n, [¬B(i)∨ ¬B(j)] for 1≤i < j ≤n, [W

vi∈V(H)B(i)].

We ensure that if for vertexvithere is a lex-smaller vertexvj, where there is no arc fromvi tovj,vicannot be the largest vertex in a largest bag. Further, for vertexvi withB(i) it is not allowed that there is a larger bag (of larger degree) with a lexicographically larger vertexvj.

[¬o^∗(j, i)∨a(i, j)∨ ¬B(i)] for 1≤i, j ≤n,i6=j, [¬o^∗(i, j)∨B(j)∨ ¬B(i)∨d(j)≤d(i)] for 1≤i, j ≤n,i6=j.

For fixing the order of the elements within the bag and in relation to elements outside this bag, we compute the elements of this largest bag as follows.

[¬b(i)∨ ¬o^∗(j, i)∨ ¬B(j)] for 1≤i, j ≤n [¬B(i)∨ ¬o^∗(j, i)∨b(j)] for 1≤i, j ≤n.

Then, we fine-tune the symmetry breaking by setting the order within this (largest) bag and in relation to the other vertices. This is similar to symmetry

breaking for RootClique, but depending on the elements of the largest bag.

[¬b(i)∨b(j)∨o^∗(i, j)] for 1≤i < j ≤n,

[¬b(i)∨ ¬b(j)∨o^∗(i, j)] for 1≤i < j ≤n, lex(vi, vj).

LexTopSort. For encoding LexTopSort, we need the following additional SMT variables. Boolean variables s(i, j) for each 1 ≤ i, j ≤ n with i6= j are used to represent thatvi hasvj as the lex-smallest vertex with an arc fromvi tovj

in the induced primal graph. For connected hypergraphsH, obviously, such a vertexvj has to exist for every vertexvi, except for the smallest vertex in the

(10)

orderingL. Being the smallest vertexviis represented with Boolean variablesl(i) (for every 1≤i≤n).

For both static and dynamic LexTopSort, we need to encode that there is only one such smallest vertex. Further, we need to make sure that if for three vertices vi, vj, vk with lex(vi, vj) either we have that o^∗(i, j) (i is eliminated beforej), orvk is not the lex-smallest vertex ofvi, or otherwise it is guaranteed thatj is eliminated beforek. Intuitively, this ensures that either the succession of elimination coincides withLor deleting the lexicographically larger vertexvj

is allowed sincevk is present inD_F whenvj is deleted.

[¬l(i)∨ ¬l(j)] for 1≤i < j ≤n,

[o^∗(i, j)∨ ¬s(i, k)∨o^∗(j, k)] for 1≤i, j, k≤n, lex(vi, vj).

Then, we add one of the following two blocks of constraints, depending on the static or dynamic variant of LexTopSort.

Static LexTopSort (s-LT). The static variant ensures that for every vertexvi

that eitherviis the smallest vertex orvi has a lex-smallest vertex. Then, for two neighborsvj, vk ofvi, ifs(i, k),vj cannot be eliminated beforevk inD_F. [W

{vi,vj}∈E(P(H))s(i, j)∨l(i)] forvi∈V(H),

[¬o^∗(j, k)∨ ¬s(i, k)] for 1≤i, j, k≤n,j6=k,{vj, vk}⊆NH(vi).

Dynamic LexTopSort (d-LT). Conceptually, dynamic LexTopSort is similar to static LexTopSort, although the variants show major differences in runtime as we will see in Section 4.2. First, for every vertexvi eithervi is the smallest vertex or there is a lex-smallest vertex forvi. Then, ifvi hasvj as the lex-smallest vertex, we require an arc fromvi tovj in the induced primal graph ofH. Similar to static LexTopSort, if there are two candidatesvj andvkfor being the lex-smallest vertex ofvi, it is prohibited to takevk if vj is eliminated beforevk.

[W

i6=js(i, j)∨l(i)] for vi∈V(H), [¬s(i, j)∨a(i, j)] for 1≤i, j ≤n,i6=j,

[¬a(i, j)∨ ¬a(i, k)∨ ¬o(j, k)∨ ¬s(i, k)] for 1≤i, j, k≤n,i6=j,i6=k,j6=k.

Combining RootClique with LexTopSort. For combining RootClique with LexTopSort, we have to take care that the orderingLis in line with the vertices of the root clique being lexicographically first.

Further, for static RootClique, where we have a (static) cliqueK prior the actual solving with the SMT encoding, we can easily fix the smallest vertex of the LexTopSort encoding as follows.

[l(i)] forvi∈K, if for everyvj∈K withj6=i, we have lex(vi, vj).

(11)

4 Implementation and Experiments

We ported frasmttoPython 3.8. and implemented the different strategies for symmetry breaking. The source code of our solverfrasmt is readily available atgithub.com/daajoe/frasmtand detailed results as well as analysis are online at Zenodo [12]. In our implementation, we support two SMT solvers, namelyz3 4.8.7 [32] as well asoptimathsat 1.6.4 [36]. Hence, we have two configurations:

frasmt z3, which uses the SMT solverz3 andfrasmt om, which uses the SMT solveroptimathsat. As it turns out, while one solver is overall better than the other, both solvers complement each other quite well. To demonstrate this finding, our results also show a portfolio variantfrasmt z3+om that uses both solvers, where for instances of fractional hypertree width larger than 4 solveroptimathsat is invoked and below, solverz3 is invoked. Further, for computing the cliques that are used in the static variant of RootClique, we applied a solver calledclingo 5.4.0 [20], which is an extension of SAT solvers and allows for incremental solving as well as optimization without manual cardinality constraints. For obtaining these cliques, we relied on the any-time algorithm ofclingo. We allowed this solver to use up to 500 seconds, which showed almost the same results as using no internal time limit and –in the worst case– spending the total runtime on symmetry breaking only. Indeed, for symmetry breaking, we then used the best clique according to the optimization criteria of the clique variant that could be computed within these 500 seconds. However, we observed that it is indeed crucial to allow some time for symmetry breaking since the vanilla configuration offrasmt z3is almost identical tofrasmt, which spends only 10 seconds on limited approaches of symmetry breaking.

4.1 Benchmark Setup

We compared the different strategies of symmetry breaking with respect to the goal of finding the best variant. To this end, we configured the following setup.

Measure and Resources.In order to draw conclusions about the efficiency of the compared solvers, we mainly inspected wall clock times. We set a timeout of 7200 seconds and limited available RAM to 16 GB per instance. Resource limits were set and enforced by the toolrunsolver[33].

Benchmark Instances.We considered a selection of 2191 instances collected by Fischl et al. [17] (publicly available at [15]) from various sources, consisting of hypergraphs that originate from CSP instances and conjunctive database queries.

The instances and their original sources are summarized in Table 1. The instances contain up to 2993 vertices and 2958 hyperedges.

Benchmark Hardware.Solvers were executed on a cluster of 12 nodes. Each node is equipped with two Intel Xeon E5-2650 CPUs consisting of 12 physical cores each at 2.2 GHz clock speed, 256 GB RAM and 1 TB hard disc drives (not an SSD) Seagate ST1000NM0033. The results were gathered on Ubuntu 16.04.1 LTS machines with disabled hyperthreading on kernel 4.4.0-139.

(12)

Benchmark Set Type #Instances Origin DaimlerChrysler Industrial 15

Grid2D Grid 12

ISCAS’89 Competition 24 [23]

MaxSAT MaxSAT 35 [5]

csp application XCSP 1090 [2]

csp random XCSP 863 [2]

csp other Misc 82

CQ Conjunctive Queries 156 [1,4,21,26,30,37]

P Hyperbench 2191 [17]

Table 1.The benchmark sets consisting of the type, the number of instances as well as the origin, of the instances we considered in our experiments. Note that some benchmark sets are overlapping and therefore the numbers do not add up to 2191.

Compared Solvers.We mainly compare variants offrasmt z3andfrasmt omto see the influence of symmetry breaking. The vanilla configurationfrasmt z3has the same features as the best reported configuration [16] offrasmt, where no extensive symmetry breaking is used. The results offrasmt z3 and frasmtare almost identical (small differences may occur due toPython version upgrade), which is why we refrained from further adding additional data to our plots and tables. We also considered the recent solvertriangulator [29]. Whiletriangulator overall is extremely fast on about half of the instances (about 1190), we observed that the solver quickly runs out of main memory on most of the other instances, which still persists if increasing main memory to 64GB. In consequence, we only report results for the more recent solvertriangulator-msc, which usescplex and is available atgithub.com/Laakeri/triangulator-msc. However, we follow other recent work on symmetry breaking [9] and stress that the main goal of our experiments is to demonstrate thebenefit of our symmetry breaks, not to compare the speed of our approach to other algorithms with different techniques.

4.2 Benchmark Results

We discuss the following three aspects, where we first elaborate on the variants of RootClique. Then, we cover the performance of LexTopSort, including the combination with RootClique, followed by static vs. dynamic symmetry breaking.

Computing Static RootCliques. Figure 1 depicts a cactus plot of the variants s-RQfor static RootClique, as presented in the previous section. In this figure, the x-axis refers to the number of instances, where for each solver the runtime (y-axis) is sorted in ascending order. Therefore, this plot provides an overview of the variants over all instances. In this plot, we mainly focused on showing the variants for solverz3, which showed overall the best performance, since the results forom, while different compared toz3, draw a similar picture. Surprisingly, the

(13)

1600

1000 1200 1400 1500

number of instances 0

1000 2000 3000 4000 5000 6000 7000

wall clock time [s]

frasmt_vbest frasmt_z3 s-RQ(k-Hy) frasmt_z3 s-RQ(LQ-T) frasmt_z3 s-RQ(LQ) frasmt_z3 s-RQ(LuH) frasmt_z3 s-RQ(LQ+N) frasmt_z3

Figure 1.A cactus plot of the static variants of RootClique, compared to the vanilla configurationfrasmt z3. The x-axis shows the number of instances and the y-axis depicts wall clock runtimes in seconds, which are sorted in ascending order, but for each solver configuration individually. Solver “frasmt vbest” refers to the virtually best solver by taking for each instance the best result among all displayed solver (configurations). The legend is ordered from best to worst (from right to left in the plot).

k-hyperclique variant(k-Hy)shows the best results⁴, which is, however, almost as good as the two variantsLQ-TandLQfor computing largest cliques. While the variant on aiming for the largest clique without twin vertices(LQ-T)seems to have a slight advantage over going for the largest clique(LQ), the differences are minor. The fact that k-hyperclique performs best was, however, surprising.

On the other hand, if one also considers the variantLuHfor preferring cliques with the largest number of used hyperedges, it seems that k-hypercliques might form a good compromise. Notably, if also considering LexTopSort, the situation changes slightly. It turns out that the variantLQ-Tperforms better than using the k-hyperclique, followed byLQ.

Combining RootClique with LexTopSort. Before we discuss the combination of RootClique with LexTopSort, we briefly elaborate on the performance of the variants of LexTopSort without RootClique. It seems that especially dynamic LexTopSort worsens the picture. In more detail, both static and dynamic LexTop- Sort without RootClique show a rather bad performance, which is sometimes even worse than the vanilla configurationfrasmt z3. This observation is underlined by Figure 2, which shows a cactus plot of variants of LexTopSort and combinations with variants of RootClique. The best variants use full static symmetry breaking only (s-LT, s-RQ). While the result forfrasmt z3suggests not much difference between full static symmetry breaking and static RootClique only (s-RQ), the

4For comparability withfrasmt, we usedk= 6 (the option reported best [16]).

(14)

800 1000 1200 1400 1500 1600 1700 number of instances

0 1000 2000 3000 4000 5000 6000 7000

wall clock time [s]

frasmt_vbest

frasmt_z3+om s-LT s-RQ(LQ-T) frasmt_z3 s-LT s-RQ(LQ-T) triangulator-msc frasmt_z3 s-LT s-RQ(k-Hy) frasmt_z3 s-RQ(LQ-T) frasmt_om s-LT s-RQ(LQ-T) frasmt_om s-RQ(LQ-T) frasmt_z3 d-LT s-RQ(LQ-T) frasmt_om s-LT d-RQ frasmt_z3 s-LT d-RQ frasmt_z3 frasmt_z3 d-LT frasmt_z3 d-LT d-RQ

Figure 2.A cactus plot showing (combinations of) both RootClique and LexTopSort symmetry breaking, where the x-axis refers to the number of instances, and the y-axis depicts wall clock runtimes in seconds. Runtimes are sorted in ascending order for each solver configuration individually. Solver “frasmt vbest” refers to the virtually best solver by taking for each instance the best result among all displayed frasmt configurations. The legend is ordered from best to worst (from right to left in the plot).

results forfrasmt omreveal that indeed with static LexTopSort, one can further improve the results obtained by static RootClique only. This might also be emphasized due to the fact that the combination of solversz3 andoptimathsat provides significant improvements compared to both single configurations. No- tably,triangulator-msc is very fast, but overallfrasmt z3solves more instances.

Table 2 reports on the number of solved instances and total runtimes for the larger benchmark sets, where timeouts count as 7200 seconds, and results are detailed and grouped by fractional hypertree width.

Static vs. Dynamic Symmetry Breaking. The results of the previous paragraphs seem to be rather bad for the dynamic variants of symmetry breaking. However, this is not too surprising if one considers that the encoding size of dynamic LexTopSort is inO(n³) and that for RootClique the encoding is inO(n²), wheren is the number of vertices contained in the hypergraph. Still, against all odds the cactus plot of Figure 2 already depicts dynamic variants, whose curve is sometimes below other static variants and even below our best variant frasmt z3+om.

Further, Figure 3 shows two scatter plots comparing runtimes instance-by-instance of the best variant of the previous paragraph (frasmt z3+om, x-axis) with (y-axis) both the best variant (left) of dynamic symmetry breaking and the worst dynamic variant (right). Both dynamic variants show that, whilefrasmt z3+omperforms better on plenty of instances, there are still instances on the bottom left of the plots, where the dynamic variants are faster. Further, some instances on the

(15)

0 1000 2000 3000 4000 5000 6000 7000 frasmt_z3+om s-LT s-RQ(LQ-T) 0

1000 2000 3000 4000 5000 6000 7000

frasmt_z3 d-LT s-RQ(LQ-T)

0 1000 2000 3000 4000 5000 6000 7000 frasmt_z3+om s-LT s-RQ(LQ-T) 0

1000 2000 3000 4000 5000 6000 7000

frasmt_z3 d-LT d-RQ

Figure 3.Scatter plots comparing runtimes of instances (in seconds) one-by-one of our best configuration (x-axis) with the best dynamic symmetry breaking method (y-axis, left) and with the worst dynamic configuration (y-axis, right).

bottom right of both plots cannot be solved byfrasmt z3+om, which are solved by dynamic variants.

5 Conclusion and Future Work

In this work, we analyzed different strategies for symmetry breaking in charac- terizations of fractional hypertree width. While we focused on this particular width parameter, the overall idea of our methods immediately apply to the computation of other width parameters, such as treewidth. Hence, we expect that our findings can be used to gain significant improvements for other ordering-based encodings [34]. Our two methods RootClique and LexTopSort for eliminating symmetries seem to be good companions, since a combination of both state- of-the-art SMT solversz3[32] andoptimathsat[36] reached the virtually best configuration. Still, we only considered the best variant of RootClique in this configuration, and it seems there is potential for algorithm selection involving machine-learning tools like autofolio [31]. Overall, we perceived static symmetry breaking strategies as superior to dynamic techniques. While this might not be too surprising, we observed that some instances could still be solved faster with dynamic techniques. We see future work in analyzing the impact of fractional hypertree width for practical solving (counting) similar to treewidth [13,14,27]

and in the context of other measurements such as bag size and domain size.

(16)

Set Solver P fhtwrange group

time[h]

max(fhtw) 0-2 3-4 >4

cspother

frasmt vbest 46 7.0 28 5 13 103.57

frasmt z3 s-RQ(LQ-T) 44 6.0 28 5 11 104.62

frasmt z3 s-LT s-RQ(LQ-T) 43 6.0 27 5 11 106.09

frasmt z3 s-LT s-RQ(k-Hy) 43 6.0 27 5 11 106.69

frasmt z3 43 6.0 28 5 10 110.17

frasmt z3 s-LT d-RQ 41 6.0 27 5 9 111.02

frasmt z3+om s-LT s-RQ(LQ-T) 40 7.0 27 5 8 112.63

frasmt z3 d-LT s-RQ(LQ-T) 37 6.0 26 4 7 118.04

frasmt om s-LT s-RQ(LQ-T) 37 7.0 26 3 8 118.76

frasmt om s-RQ(LQ-T) 36 6.0 26 3 7 119.69

frasmt z3 d-LT 36 6.0 26 4 6 124.27

frasmt om s-LT d-RQ 34 6.0 26 3 5 123.96

frasmt z3 d-LT d-RQ 34 6.0 25 4 5 125.89

triangulator-msc 25 5.¯3 17 4 4 139.92

cspapplication

frasmt vbest 674 7.0 43 397 234 775.44

frasmt z3 s-RQ(LQ-T) 646 7.0 43 396 207 824.72

frasmt z3 559 7.0 43 370 146 974.08

frasmt z3 s-LT d-RQ 554 7.0 43 365 146 980.45

triangulator-msc 551 7.0 43 288 220 973.13

frasmt om s-RQ(LQ-T) 535 7.0 40 293 202 1040.55

frasmt z3 d-LT 498 7.0 40 312 146 1113.74

frasmt z3 d-LT d-RQ 498 7.0 40 312 146 1114.50

frasmt om s-LT d-RQ 482 7.0 38 293 151 1146.85

csprandom

triangulator-msc 860 6.¯6 54 39 767 203.21

frasmt vbest 835 9.0 54 39 742 365.57

frasmt om s-RQ(LQ-T) 830 9.0 54 38 738 444.29

frasmt z3 s-RQ(LQ-T) 734 9.0 54 39 641 490.29

frasmt om s-LT d-RQ 670 9.0 54 31 585 691.12

frasmt z3 s-LT d-RQ 590 9.0 54 23 513 808.34

frasmt z3 d-LT d-RQ 585 9.0 54 19 512 830.63

frasmt z3 d-LT 584 9.0 54 19 511 830.89

frasmt z3 582 9.0 54 18 510 824.62

P

frasmt vbest 1706 9.0 271 446 989 1247.01

frasmt z3+om s-LT s-RQ(LQ-T) 1657 9.0 270 445 942 1362.19 frasmt z3 s-LT s-RQ(LQ-T) 1600 9.0 270 445 885 1423.34

triangulator-msc 1585 7.0 259 336 990 1322.97

frasmt z3 s-RQ(LQ-T) 1576 9.0 271 445 860 1422.65

frasmt om s-RQ(LQ-T) 1553 9.0 266 339 948 1607.00

frasmt om s-LT d-RQ 1337 9.0 264 332 741 1966.01

frasmt z3 s-LT d-RQ 1336 9.0 270 398 668 1903.86

frasmt z3 1335 9.0 271 398 666 1912.94

frasmt z3 d-LT 1269 9.0 266 340 663 2073.04

frasmt z3 d-LT d-RQ 1268 9.0 265 340 663 2075.15

Table 2. Detailed results on the number of solved instances grouped by fractional hypertree width of the solved instance. Runtimes are cumulated wall clock times in hours, where timeouts count as 7200 seconds.

(17)

References

1. Arocena, P.C., Glavic, B., Ciucanu, R., Miller, R.J.: The ibench integration metadata generator. In: Li, C., Markl, V. (eds.) Proceedings of Very Large Data Bases (VLDB) Endowment. vol. 9:3, pp. 108–119. VLDB Endowment (Nov 2015),https:

//github.com/RJMillerLab/ibench

2. Audemard, G., Boussemart, F., Lecoutre, C., Piette, C.: XCSP3: an XML-based format designed to represent combinatorial constrained problems.http://xcsp.org (2016)

3. Bannach, M., Berndt, S., Ehlers, T.: Jdrasil: A modular library for computing tree decompositions. In: Iliopoulos, C.S., Pissis, S.P., Puglisi, S.J., Raman, R. (eds.) 16th International Symposium on Experimental Algorithms, SEA 2017, June 21-23, 2017, London, UK. LIPIcs, vol. 75, pp. 28:1–28:21. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik (2017)

4. Benedikt, M., Konstantinidis, G., Mecca, G., Motik, B., Papotti, P., Santoro, D., Tsamoura, E.: Benchmarking the chase. In: Geerts, F. (ed.) Proceedings of the 36th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems (PODS’17). pp. 37–52. Assoc. Comput. Mach., New York, Chicago, Illinois, USA (2017),https://github.com/dbunibas/chasebench

5. Berg, J., Lodha, N., J¨arvisalo, M., Szeider., S.: MaxSAT benchmarks based on determining generalized hypertree-width. Tech. rep., MaxSAT Evaluation 2017 (2017)

6. Berg, J., J¨arvisalo, M.: SAT-based approaches to treewidth computation: An evaluation. In: 26th IEEE International Conference on Tools with Artificial Intelligence, ICTAI 2014, Limassol, Cyprus, November 10-12, 2014. pp. 328–335. IEEE Computer Society (2014)

7. Bodlaender, H.L., Fomin, F.V., Koster, A.M.C.A., Kratsch, D., Thilikos, D.M.:

On exact algorithms for treewidth. In: Proceedings of the 14th Annual European Symposium on Algorithms (ESA’06). Lecture Notes in Computer Science, vol. 4168, pp. 672–683. Springer Verlag (2006)

8. Bodlaender, H.L., M¨ohring, R.H.: The pathwidth and treewidth of cographs. SIAM J. Discrete Math.6(2), 181–188 (1993)

9. Codish, M., Miller, A., Prosser, P., Stuckey, P.J.: Constraints for symmetry breaking in graph representation. Constraints An Int. J.24(1), 1–24 (2019)

10. Cohen, D., Jeavons, P., Gyssens, M.: A unified theory of structural tractability for constraint satisfaction problems. J. of Computer and System Sciences74(5), 721–743 (2008)

11. Dechter, R.: Bucket elimination: a unifying framework for reasoning. Artificial Intelligence113(1-2), 41–85 (1999)

12. Fichte, J.K., Hecher, M., Szeider, S.: Analyzed Benchmarks on Experiments for frasmt v2.0.0 (Dataset). Zenodo (Jul 2020),https://doi.org/10.5281/zenodo.3950097 13. Fichte, J.K., Hecher, M., Thier, P., Woltran, S.: Exploiting database management systems and treewidth for counting. In: Komendantskaya, E., Liu, Y.A. (eds.) Pro- ceedings of the 22nd International Symposium on Practical Aspects of Declarative Languages (PADL’20). Lecture Notes in Computer Science, vol. 12007, pp. 151–167.

Springer Verlag, New Orleans, LA, USA (2020)

14. Fichte, J.K., Hecher, M., Zisser, M.: An improved GPU-based SAT model counter. In:

Schiex, T., de Givry, S. (eds.) Proceedings of the 25th International Conference on Principles and Practice of Constraint Programming (CP’19). pp. 491–509. Springer Verlag, Stamford, CT, USA (Sep 2019)

(18)

15. Fichte, J.K., Hecher, M., Lodha, N., Szeider, S.: A Benchmark Collection of Hyper- graphs. Zenodo (Jun 2018),https://doi.org/10.5281/zenodo.1289383

16. Fichte, J.K., Hecher, M., Lodha, N., Szeider, S.: An SMT approach to fractional hypertree width. In: CP. Lecture Notes in Computer Science, vol. 11008, pp. 109–127.

Springer (2018)

17. Fischl, W., Gottlob, G., Longo, D.M., Pichler, R.: HyperBench: a benchmark of hypergraphs.http://hyperbench.dbai.tuwien.ac.at(2017)

18. Fischl, W., Gottlob, G., Pichler, R.: General and fractional hypertree decompositions:

Hard and easy cases. In: den Bussche, J.V., Arenas, M. (eds.) Proceedings of the 37th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems (PODS’18). pp. 17–32. Assoc. Comput. Mach., New York, Houston, TX, USA (Jun

2018)

19. Freuder, E.C.: A sufficient condition for backtrack-bounded search. J. of the ACM 29(1), 24–32 (1982)

20. Gebser, M., Kaminski, R., Kaufmann, B., Schaub, T.: Multi-shot ASP solving with clingo. Theory Pract. Log. Program.19(1), 27–82 (2019)

21. Geerts, F., Mecca, G., Papotti, P., Santoro, D.: Mapping and cleaning. In: Cruz, I., Ferrari, E., Tao, Y. (eds.) Proceedings of the IEEE 30th International Conference on Data Engineering (ICDE’14). pp. 232–243 (March 2014)

22. Gottlob, G., Leone, N., Scarcello, F.: Hypertree decompositions and tractable queries. J. of Computer and System Sciences64(3), 579–627 (2002)

23. Gottlob, G., Samer, M.: A backtracking-based algorithm for hypertree decomposition. J. Exp. Algorithmics13, 1:1.1–1:1.19 (Feb 2009)

24. Grohe, M., Marx, D.: Constraint solving via fractional edge covers. In: Proceedings of the of the 17th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2006). pp. 289–298. ACM Press (2006)

25. Grohe, M., Marx, D.: Constraint solving via fractional edge covers. ACM Transac- tions on Algorithms11(1), Art. 4, 20 (2014)

26. Guo, Y., Pan, Z., Heflin, J.: LUBM: A benchmark for OWL knowledge base systems.

Web Semantics: Science, Services and Agents on the World Wide Web3(2), 158–182 (2005)

27. Hecher, M., Thier, P., Woltran, S.: Taming high treewidth with abstraction, nested dynamic programming, and database technology. In: Pulina, L., Seidl, M. (eds.) Proceedings of the 23rd International Conference on Theory and Applications of Satisfiability Testing (SAT’20). pp. 343–360. Springer Verlag (2020)

28. Khamis, M.A., Ngo, H.Q., Rudra, A.: FAQ: questions asked frequently. In: Milo, T., Tan, W. (eds.) Proceedings of the 35th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems, PODS 2016, San Francisco, CA, USA, June 26 - July 01, 2016. pp. 13–28. Assoc. Comput. Mach., New York (2016)

29. Korhonen, T., Berg, J., J¨arvisalo, M.: Solving graph problems via potential maximal cliques: An experimental evaluation of the bouchitt´e-todinca algorithm. ACM Journal of Experimental Algorithmics24(1), 1.9:1–1.9:19 (2019)

30. Leis, V., Gubichev, A., Mirchev, A., Boncz, P., Kemper, A., Neumann, T.: How good are query optimizers, really? Proceedings of Very Large Data Bases (VLDB) Endowment9(3), 204–215 (Nov 2015)

31. Lindauer, M., Hoos, H.H., Hutter, F., Schaub, T.: Autofolio: An automatically configured algorithm selector. J. Artif. Intell. Res.53, 745–778 (2015)

32. de Moura, L., Bjørner, N.: Z3: An efficient SMT solver. In: Ramakrishnan, C.R., Rehof, J. (eds.) Proceedings of the International Conference on Tools and Algorithms for the Construction and Analysis of Systems Tools (TACS’08). Lecture Notes in Computer Science, vol. 4963, pp. 337–340. Springer Verlag (2008)

(19)

33. Roussel, O.: Controlling a solver execution with the runsolver tool. J on Satisfiability, Boolean Modeling and Computation7, 139–144 (2011)

34. Samer, M., Veith, H.: Encoding treewidth into SAT. In: Theory and Applications of Satisfiability Testing - SAT 2009, 12th International Conference, SAT 2009, Swansea, UK, June 30 - July 3, 2009. Proceedings. Lecture Notes in Computer Science, vol. 5584, pp. 45–50. Springer Verlag (2009)

35. Schidler, A., Szeider, S.: Computing optimal hypertree decompositions. In: Blelloch, G., Finocchi, I. (eds.) Proceedings of ALENEX 2020, the 22nd Workshop on Algorithm Engineering and Experiments. pp. 1–11. SIAM (2020)

36. Sebastiani, R., Trentin, P.: Optimathsat: A tool for optimization modulo theories.

J. Autom. Reasoning64(3), 423–460 (2020)

37. Transaction Processing Performance Council (TPC): TPC-H decision support benchmark. Tech. rep., TPC (2014),http://www.tpc.org/tpch/default.asp