High-Level Overview

To explain our main ideas, let us make four important observations. These will high- light the problems we face and will indicate solutions.

First, assume that we have two simple connected hypergraphs Hv = (v, Ev) and

Hw = (w, Ew) with |v| > 1 ∨ |w| > 1. Now we want to connect both graphs with one

edge. We discuss two possible solutions: (1) A connected complex hyperedge (v, w) covering the whole vertex sets v, w on both sides. We refer to the resulting complex hypergraph as Hcomplex. (2) Instead of (v, w) we introduce a simple edge ({x}, {y}),

where x ∈ v ∧ y ∈ w holds. We refer to this connected simple hypergraph as Hsimple.

According to Definition 3.2.13, Hcomplexis more restrictive than Hsimple, since parti-

tioning the resulting set V = v ∪ w into all possible ccps (Definition 3.2.8) leaves us with much fewer choices if a complex hyperedge (|Pccp(v ∪ w)| = 2) is introduced (1) instead of a simple edge (2). To exemplify this, consider the disconnected graph H = (V = v ∪ w, E = {({R0}, {R1})}) with v = {R0, R1} ∧ w = {R2}. On the

one hand, if we connect v and w by the complex hyperedge (v, w), then Pccp(v ∪ w) has two ccps: ({R0, R1}, {R2}) and ({R2}, {R0, R1}). On the other hand, if we

L C Cset X Xmap F N ↓ 1 0 ∅ ∅ ∅ empty ∅ {{t = R0}} 2 1 R0 {{R0}} ∅ empty ∅ {{R1, R2}, {R₄}} 3 1 emitting ({R0}, {R1, R2, R3, R4})

4 1 v = {R1, R2} →GETCONNECTEDCOMPONENTS(S, {R₀, R1, R2}) → {{R3, R4}}

5 2 R0→R1, R2

{{R₀}, {R₁},

∅ empty ∅ {{R3},

{R2}} {R4}}

6 2 v = {R3} →GETCONNECTEDCOMPONENTS(S, {R0, R1, R2, R3}) → {{R4}}

7 3 R0→R1, R2→R3 {{R0, R1, R2, R3}} ∅ empty ∅ {{R4}}

8 3 emitting ({R0, R1, R2, R3}, {R4})

9 2 v = {R4} →GETCONNECTEDCOMPONENTS(S, {R0, R1, R2, R4}) → {{R3}}

10 3 R0→R1, R2→R4

{{R0, R2, R4}, _{R

3} empty ∅ ∅

{R₁}}

11 3 no emission of ({R0, R1, R2, R4}, {R3}) since |Cset| > 1

12 1 v = {R4} →GETCONNECTEDCOMPONENTS(S, {R₀, R4}) → {{R1, R2, R3}}

13 1 call toMAINTAINXMAP({R1, R2}, empty) → R1: {R1, R2}, R2: {R1, R2}

14 2 R0→R4 {{R0, R4}} ∅

R1:{R1,R2}, {R1, {{R2},

R2:{R1,R2} R2} {R3}}

15 2 emitting ({R0, R4}, {R1, R2, R3})

16 2 v = {R2} →GETCONNECTEDCOMPONENTS(S, {R0, R2, R4}) → {{R1, R3}}

17 2 call toCHECKXMAP({R0, R2, R4}, {R1,R2},R1:{R1,R2}, R2:{R1,R2}) → returnsTRUE 18 3 R0→R4→R2 {{R0, R2, R4}} ∅ R1:{R1,R2 }, {R1, _{{R 3}} R2:{R1,R2} R2} 19 3 emitting ({R0, R2, R4}, {R1, R3})

20 3 v = {R3} →GETCONNECTEDCOMPONENTS(S, {R₀, R2, R3, R4}) → {{R1}} 21 4 R0→R4→R2→R3{{R0, R2, R3, R4}} ∅ R1:{R1,R2}, {R1, _{{R 1}} R2:{R1,R2} R2} 22 4 emitting ({R0, R2, R3, R4}, {R1})

23 2 v = {R3} →GETCONNECTEDCOMPONENTS(S, {R0, R3, R4}) → {{R1}, {R2}}

24 3 R0→R4→R1, R3 {{R0, R1, R3, R4}} {R2}R1:{R1,R2

}, {R1, _∅

R2:{R1,R2} R2}

25 3 emitting ({R0, R1, R3, R4}, {R2})

Table 3.2.: Exemplified execution of MINCUTCONSERVATIVEHYP for the graph of

3.5. Generic Top-Down Join Enumeration for Hypergraphs R0 R2 R1 R3 R0 R2 R1 R3 R0 R2 R1 R3

Figure 3.19.: (a) Overlapping hyperedges, (b) and (c) simple graphs

choose ({R0}, {R2}), this gives rise to two additional ccps: ({R0, R2}, {R1}) and

({R1}, {R0, R2}). Hence, the latter case is less restrictive.

For the second observation, we take a look at the naive partitioning strategy for hy- pergraphs PARTITIONnaiveHyp(Figure 3.5). Line 1 of PARTITIONnaiveHypenumerates

2|v∪w|− 2 subsets of S = v ∪ w. Considering Hcomplex, we observe that only C = v

and C = w make it past Line 2. This is clearly inefficient, since all other generated subsets of S = v ∪ w are rejected.

Assume that we substitute the complex hyperedge (v, w) of Hcomplex by a simple

edge ({x}, {y}) with x ∈ v ∧ y ∈ w. Then, the complex graph Hcomplex becomes

a simple hypergraph to which we refer as Hcomplex→simple. As a consequence, we

can utilize the reverse mapping (Definition 3.2.12) g−1(Hcomplex→simple) and reuse a

highly efficient graph-aware partitioning algorithm for graphs like MINCUTBRANCH

or MINCUTCONSERVATIVE. However, we have to be careful, since complex hyper-

edges are more restrictive and, thus, by converting hyperedges to simple edges, invalid ccps might be generated. Therefore, we need to check the ccps of the simple graph for connectivity within the original hypergraph. We call partitions of the simple graph that are not valid ccps of the original complex hypergraph false ccps. In the example used in the first observation, the false ccps are ({R0, R2}, {R1}) and ({R1}, {R0, R2}).

Third, if we represent a complex hyperedge (v, w) by a simple edge, there are |v| ∗ |w| possibilities to do so. For the graph presented in Figure 3.19(a), the call to PARTITION_naiveHyp(H|{R0,R1,R2,R3}) generates 14 subsets assigned

to C, but only C = {R₀}, {R1}, {R0, R1, R2}, {R3}, {R0, R2, R3} and

{R1, R2, R3} survive the test in Line 2. Thus, there exist only six valid ccps:

{({R0}, {R1, R2, R3}), ({R0, R1, R2}, {R3}), ({R0, R2, R3}, {R1})} (symmetric

counter pairs left out). For g−1(Definition 3.2.12) applied on the hypergraph given in Figure 3.19(b), a graph-aware partitioning algorithm generates 12 partitions and, there- fore, 6 false ccps. Since the two hyperedges of Figure 3.19(a) overlap, the mapping of Figure 3.19(c) is one of the 4 possible combinations. Here, not a single false ccp is generated when g−1 and a graph-aware partitioning algorithm is used. We conclude that in certain cases, there are good (restrictive) and bad (less restrictive) mappings.

We summarize what we have observed so far: Using PARTITION_naiveHypas a par- titioning algorithm results in a huge computational overhead. Therefore, we are in- terested in reusing efficient graph-partitioning algorithms. For simple hypergraphs, we only have to apply our inverse mapping function g−1 to gain a graph which can be used as input to any graph-partitioning algorithm. Since the hypergraph is simple, no false ccps will be produced. This is because for any simple hypergraph Hsimple:

R0 R1 R2 R3 R4

R0

R1

R2

R3

R4

Figure 3.20.: (a) Hypergraph, (b) simple graph and (c) final graph

hypergraphs Hcomplex: Hcomplex: g(g−1(Hcomplex)) = Hcomplexdoes not hold, since

g−1maps only simple hyperedges to graph edges and ignores complex hyperedges. Thus, we denote by s a function that maps the complex hyperedges of a given hy- pergraph to simple hyperedges. There are several ways of defining s, but for now we leave s undefined. Let Hcomplex be an arbitrary complex hypergraph. Then we

compute the input of our graph-partitioning algorithm as follows: g−1(s(Hcomplex)).

According to our third observation, there are good (restrictive) and bad (less restric- tive) mappings. In other words, by applying s we might loose restrictness so that in many cases g(g−1(s(Hcomplex))) = Hcomplex will not hold. Note that for any simple

hypergraph Hsimple, our mapping s needs to be defined as the identity function such

that g(g−1(s(Hsimple))) = Hsimple holds. In general, if s(H) 6= H holds, then the

simple hypergraph s(H) will be less restrictive and we need connection tests based on H that filter out false ccps. In Section 3.5.3, we presentCOMPUTEADJACENCYINFO

as our implementation for the composition of g−1◦ s.

Now, take a look at Figure 3.20(a). A call to PARTITIONnaiveHyp(H|{R0,R1,R2,R3,

R4}) results in the generation of 30 subsets assigned to C, where just C =

{R0, R1, R2, R3} and C = {R4} make it past Line 2. InvokingCOMPUTEADJACEN- CYINFO(Section 3.5.3) produces the simple graph of Figure 3.20(b). Taking that graph

as an input for a call to any graph-aware partitioning algorithm would return four pairs: ({R0, R1, R2, R3}, {R4}), ({R0, R2, R3, R4}, {R1}), ({R0, R1, R3}, {R2, R4}) and

({R0, R1, R2, R4}, {R3}) (symmetric counter pairs left out). But only the first parti-

tion and its symmetric counter pair are valid ccps. Hence, the produced simple graph of Figure 3.20(b) is less restrictive than the original one. In Figure 3.20(a), we can see that R1cannot be separated from R0, since otherwise, the connection to R2would

be lost. Furthermore, R2 cannot be separated from R0, R1, or the connection to R3

would be lost. On top of that, R2 and R3 have to remain in the same subgraph, or the

connection to R4breaks up. In conclusion, it is only possible to separate R4 from the

rest, because all other combinations would end up in more than two connected subsets and, therefore, false ccps.

From this example we can draw our fourth observation: If a complex hyperedge (v, w) is essential for the connectedness of the hypergraph, i.e., it is a complex ar- ticulation hyperedge, then it is impossible to partition the graph by separating one or two of its complex hypernodes v or w. In other words: There exists no minimal cut involving an edge (s, t) with s ⊂ v ∧ t ⊂ v within a hypernode v that is part of an articulation hyperedge (v, w).

In order to benefit from our last observation, we propose the concept of a compound vertex (Definition 3.2.10). The basic idea is to group those vertices that compose a non-separable hypernode into a new index-introducing compound vertex. Particular- ly, we remove those vertices from the vertex (sub)set S ⊆ V that have been grouped

3.5. Generic Top-Down Join Enumeration for Hypergraphs

and introduce the compound vertex as a new v by adding it to S (actually to some S0, as we will see). In case that non-separable hypernodes are overlapping, we group all overlapping vertex sets together. Those steps are performed throughCOMPOSECOM-

POUNDVERTICES (Section 3.5.4). The result of this step is shown in Figure 3.20(c),

where R8 is the index-introducing compound vertex representing R0, R1, R2, R3 of

Figure 3.20(a-b).