Inclusion/Exclusion Branching for Partial Requirements An algorithm for k-Set Splitting

1. Inclusion/Exclusion Branching for Partial RequirementsAn algorithm for k-Set Splitting JesperNederlof Johan M. M. van Rooij Excellent Student Paper Award IPEC 2010

2. Problem: k-Set Splitting k-Set Splitting: • Input: A set of sets S over a universe U. • Parameter: Integer k > 0. • Question: Can we partition the elements of U into two sets (red/green) such that at least k sets from S contain elements from both partitions. Our result: • An O*(1.8213k) algorithm, using: • Kernelisation. • Probabilistic arguments. • Extended inclusion/exclusion-branching (NEW!!). • Dynamic programming over tree decompositions. • Measure and conquer.

3. Examples A A B E • Cycle of five sets of size 2. • Yes, iff k · 4. • No, iff ¸ 5. • Powerset of a set of four elements: • Yes iff k · 9. • No, iff k ¸ 10. {},{1},{2},{3},{4},{1,2},{1,3},{1,4},{2,3},{2,4}, {3,4},{1,2,3},{1,2,4},{1,3,4},{2,3,4},{1,2,3,4} • (Unparameterised) problem also known as: • Max Hypergraph 2-Colouring. • Same result also applies to Max-Not-All-Equal-SAT. B E D C D C

4. Previous Results • O*(72k): Dehne, Fellows, Rosamond. (WG 2003) • O*(8k): Dehne, Fellows, Rosamond, Shaw. (IWPEC 2004) • O*(2.6499k): Lokshtanov and Sloper. (ACiD 2005) • O*(2k) randomised: Chen and Lu. (COCOON 2007) • O*(2k): Lokshtanov and Saurabh (IWPEC 2009) • Result by obtaining a kernel with at most k elements and 2k sets. • O*(1.9630k) exp space: also, Lokshtanov and Saurabh. Compare to our result: • O*(1.8213k) time and polynomial space.

5. Exact Algorithm on the Incidence Graph of Parameterised Problem after Kernelisation. A B E Algorithm: • Apply Lokshtanov and Saurabh’s kernel. • Use an exact algorithm to the incidence graph of the remaining instance. • The incidence graph of an instance: • Vertex for each elements. • Vertex for each sets. • Edge between a vertex for an element e and a set s iff e 2 s. D C A B C D E

6. Branching on Elements • The algorithm computes for each j (0 · j · 2k) the number of 2-colourings that split exactly j sets. • Split sets are removed. • Coloured elements are removed. • Set vertices (3 states): uncoloured, red, green. Update parameter j (shift list of numbers) + + j-1 j

7. Branching on Sets? Inclusion/Exclusion based branching? [Bax 1993 - van Rooij, Nederlof, van Dijk 2009] • A set must be split; when counting 2-colourings: • #Split = #All 2-colourings - #Unsplit • These two subproblems are easier: • All 2-colourings: remove set. • Unsplit: all elements same colour, i.e, merge elements. • Or, if set coloured: make all elements the same colour. • But wait: a set does not need to be split! • How can we still use inclusion/exclusion branching? • Extended Inclusion/Exclusion Branching!

8. Branching on Coloured Sets! • A set may be split! • Do not split the set, • Or, split the set: then apply inclusion/exclusion branching. • Consider a coloured set. - + j j-1 j-1

9. Branching on Uncoloured Sets! • A set may be split! • Do not split the set, • Or, split the set: then apply inclusion/exclusion branching. • Consider an uncoloured set. - + j j-1 j-1

10. The Cool Idea!!  • How many subproblems do we generate when branching on sets? • 3? • 2? • Each branch computes for each j (0 · j · 2k) the number of 2-colourings that split exactly j sets. • Hence: first and last branch are the same subproblem! - + j j-1 j-1

11. Kernelisation and Preprocessing • Apply the kernel by Lokshtanov and Saurabh. • Remaining instance: at most k elements and 2k sets. • Output Yes unless: • Where si is the number of sets of cardinality i. • Why? Consider a random 2-colouring of the elements. • Each colour assigned with probability ½. • Each element is coloured independently of the other elements. • Consider a set of size i¸2, then: • Probability that it is split equals: 1-1/(2i-1). • Expected number of split sets equals RHS of formula. • k smaller than this number: Yes-Instance.

12. The Complete Algorithm • Kernelisation: at most k elements and 2k sets. • Check for many large sets (previous slide). • Branch and Reduce phase on the incidence graph: Reduce: Let A be the set of annotated vertices, consider G[V\A]: • If G[V\A] contains a degree one vertex: put it in A. • If G[V\A] contains identical degree two vertices: put one in A. • If G[V\A] is of maximum degree two: dynamic programming. Branch: Let e, u, c be vertices of maximum degree of each type. (element vertex, uncoloured set vertex, coloured set vertex) • If e is of maximum degree in G[V\A]: branch on e. • If u is of maximum degree in G[V\A]: branch on u. • Otherwise, c is of maximum degree in G[V\A]: branch on c.

13. Why the Annotation? • Annotation procedure: • Vertices remain in the graph, but are ignored when selecting a vertex to branch on (also as neighbour). • Annotated vertices have degree one, or degree two if they have an identical unannotated copy. • Copies do not cause problems: • Copies are never branched on: we branch on vertices of degree at least three. • If vertices are merged (branching on an uncoloured set), then copies are merged (no larger degree vertices emerge). • When the branching stops: • G[V\A] is of maximum degree two. • G[V] is a generalised series-parallel graph (treewidth · 2).

14. Some Well Known Things • It is well know that the following operations do not increase the treewidth of a graph above two: • Duplication of an edge. • Adding a vertex of degree zero or one. • Subdividing an edge. • Contracting an edge incident to a vertex of degree two. • Graphs of treewidth at most two: • generalised series-parallel graphs. • On these graphs we can compute the number of 2-colourings splitting exactly j sets for each j (0 · j · 2k) in polynomial time.

15. Remaining InstancesHave Treewidth At Most Two • Remind the annotation procedure: • If G[V\A] contains a degree one vertex: put it in A. • If G[V\A] contains twins of degree two vertices: put one in A. • Consider G[V\A] and remove the annotations in reverse order. • Initially max degree two: collection of cycles has treewidth 2. • Adding a vertex has one of the following effects: • Adding a vertex of degree zero or one. • Series of operations: contract an edge incident to a degree two vertex (identical copy), duplicate the edge, subdivide both copies of the edge. • G[V] has treewidth at most 2!

16. The Complete Algorithm Again • Kernelisation: at most k elements and 2k sets. • Check for many large sets (sum of sets per set size). • Branch and Reduce Phase: Reduce: Let A be the set of annotated vertices, consider G[V\A]: • If G[V\A] contains a degree one vertex: put it in A. • If G[V\A] contains twins of degree two vertices: put one in A. • If G[V\A] is of maximum degree two: dynamic programming. Branch: Let e, u, c be vertices of maximum degree of each type. (element vertex, uncoloured set vertex, coloured set vertex) • If e is of maximum degree in G[V\A]: branch on e. • If u is of maximum degree in G[V\A]: branch on u. • Otherwise, c is of maximum degree in G[V\A]: branch on c. Running Time?

17. Running Time Analysiswith Measure and Conquer • Measure and Conquer: • A: Annotated vertices • E: Element vertices • U: Uncoloured set vertices • R, G: Coloured set vertices, red and green. • With the following weights for v, w, and x:

18. Measure and Conquer • Measure: • Suppose the algorithm runs in O*(®¹) time. • How large can ¹ be? • At most k elements, and restrictions on the sizes of sets. • Result: ¹max = 2.205351k

19. Analysing Recurrence Relations • We need a running time of the form O*(®¹). • Analyse each local configuration considered for branching. • Example: branch on an element vertex. • ui: nr of uncoloured set neighbours of degree i. • ri, gi: nr of coloured set neighbours of degree i (red/green). • Only counting unannotated neighbours! • Recurrence Relation:

20. Computing The Running Time • Consider each local configuration considered for branching. • Create a recurrence relation for each such configuration. • Solve the recurrence relations. • Solution: N(¹) = O*(1.31242¹). • Running time: O*(1.312422.205251k) = O*(1.8213k). • Weights chosen such that running time is optimal. • Not only minimise the solution of the recurrence relations. • Also relative to maximum measure of an instance after kernelisation and testing on the number of large sets.

21. Conclusion • We have given a nice algorithm for k-Set Splitting. • Kernelisation. • Probabilistic argument to bound the number of large sets. • Branch and reduce algorithm on reduced instances. • Branching based on extended inclusion/exclusion branching. • Simple instances solved by dynamic programming. • Extended Inclusion/Exclusion branching. • Inclusion/Exclusion branching, but now when it is not required to fulfill all requirements (spilt all sets, cover all elements, etc.). • Two subproblems instead of three. • Also works for other problems: Partial Dominating Set.

22. Additional Results • Partial Dominating set! • Previous best: O(1.6183n) and polynomial space • (M. Liedloff’s PhD Thesis) • Our results using extended inclusion/exclusion branching: • O(1.5012n) and exponential space. • O(1.5673n) and polynomial space. • Algorithms quite similar to the branch and reduce phase of our k-Set Splitting algorithm. • Counts partial dominating sets via counting partial set covers. • Questions?