Cardinality & Sorting Networks

1. Cardinality & Sorting Networks

2. Cardinality constraint • Appears in many practical problems: scheduling, timetabling etc’. • Also takes place in the Max-Sat problem. • Has the form: where the symbol is one of , variables are boolean.

3. Cardinality constraint • As an example, the car sequencing problem (from last week) defines the number of cars to be manufactured, per model. • If we agree that a Boolean variable is true iff the i‘th car of the resulting sequence belongs to some model M, then the constraint enforces the existence of k cars from that model to be in the sequence (where the sequence size is n).

4. Cardinality constraint car sequence instance: 1 2 3 4 5 6 7 8 9 10 3 5 4 3 4 2 5 0 1 2 0 0 1 0 0 0 0 0 0 1 Each Boolean variable below the sequence is 1 iff a “yellow” model appears in the corresponding position.

5. Cardinality constraint • In the Max-Sat problem we seek an assignment which satisfies the maximal number of clauses in a propositional formula • One approach to solve the problem is to add “fresh” blocking variables to each clause, giving . We then search for a minimal k such that is satisfied.

6. Cardinality constraint • There are several ways to encode a cardinality constraint as propositional formula. • In this presentation we consider encoding which is based on sorting networks.

7. Sorting networks • A (Boolean) sorting network is a circuit that receives n Boolean inputs and permutes them to obtain the sorted outputs . • The network is composed of “wired” comparators. • Each comparator has two inputs and two outputs . The upper output, , receives the maximal input value, where the lower output, , receives the minimal input value. • The network computation is performed in parallel.

8. The 0-1 principle • Theorem: If a sorting network sorts every sequence of 0's and 1's, then it sorts every arbitrary sequence of values.

9. Sorting networks 0 1 1 0 1 0 1 0 0 0 1 1 0 0 1 1 0 1 1 0

10. Sorting networks Is it a sorting network ? No it’s not! 0 1 0 1 1 0 1 0

11. Sorting network encoding • A comparator can be encoded into CNF by the following 6 clauses: • Given a set of comparators of any sorting network, it is straightforward to construct a CNF which is a conjunction of the encoded comparators.

12. Sorting network encoding • For any assignment on the sequence input, a complete satisfying assignment of the CNF, yields a sorted output assignment. • We can use this property to check whether a given network is a sorting network. This could be done by adding constraint which is satisfied only if the output is not sorted. A satisfying assignment for the CNF and the above constraint means that the network does not sort.

13. Cardinality constraint encoding • The cardinality constraint, over the input sequence is obtained by setting the k’thlargest output to 0. It implies that all outputs from position k are zero. Hence, there are less than k ones amongst the input values. • If the propositional formula describes the relation between the input and the output of a sorting network, we search a satisfying assignment for

14. Cardinality constraint encoding Sorter(8)

15. Cardinality constraint encoding Sorter(8)

16. Cardinality constraint encoding Sorter(8) 0 0 0 0 0

17. The odd-even sorting network • Batcher’s odd-even network is a classic sorting network. It was devised back in 68’. • It uses the divide and conquer design. • The approach is similar to the merge-sort algorithm: for sorting a list of 2n inputs, partition the list into two sub lists, with n values each. Recursively sort these two lists, and finally merge them. • Network’s size: , depth: .

18. The odd-even sorting network Sorter(2n)

19. The odd-even sorting network Sorter(n) Sorter(n) Merger(2n)

20. The odd-even sorting network Sorter(n/2) Sorter(n/2) Sorter(n/2) Sorter(n/2) Merger(n) Merger(n) Merger(2n)

21. The odd-even merger • The odd even merger uses the divide and conquer design, as well. • It is assumed that its two input sequences: and are already sorted. • The procedure divides each input into odd and even sequences, namely: and for the a’s. and for the b’s. • The even and the odd sequences are merged recursively. • The merged sequences are combined by comparing each in the result outcome

22. The odd-even merger Merger(n)

23. The odd-even merger Merger(n/2) Merger(n/2)

24. The odd-even merger 1 1 1 0 1 1 0 1 Merger(n/2) Merger(n/2) 1 1 1 1

25. The odd-even merger 1 0 1 0 Merger(n/2) Merger(n/2) 1 1 0 0

26. The odd-even merger Merger(n/2) Merger(n/2) 1 1 1 1 1 1 0 0 1 1 1 0 1 1 1 0

27. Unit Propagation • If a set of propositional clauses contains a unit clause l, the other clauses are simplified. This process is called unit propagation. • For a comparator : • If the cardinality constraint parameter k is known a priory, we can use the above process in order to design a simplified network.

28. Odd-Even sorting network properties • If there are p input variables that are set to 1, then by unit propagation the first p output variables are set to 1, as well. • If there are p input variables that are set to 1, and the output variable in the p+1 position is set to 0, then by unit propagation the reminder of the input variables are set to 0.

29. Odd-Even sorting network properties Sorter(8)

30. Odd-Even sorting network properties Sorter(8) 1 1 1 1

31. Odd-Even sorting network properties Sorter(8)

32. Odd-Even sorting network properties Sorter(8)

33. The pairwise sorting network • Devised in 94’ by Ian Parberry • Takes a different form of the odd-even sorting network.

34. The pairwise sorting network • Has the same size, depth and properties of the odd-even sorting network. • Better unit propagation. The simplified CNF of the corresponding cardinality network is significantly smaller. • Simple recursive definition of the corresponding cardinality network when k is known a priory. • Experiments have shown better performance for structured problems.

35. Cardinality (0,1) matrix constraint • A cardinality (0,1) matrix constraint is a constraint C defined on a Matrix M=x[i,j] of boolean variables. • Every row i is associated with two positive integers lr[i] and ur[i], such that lr[i] ≤ ur[i]. • Every column j is associated with two positive integers lc[j] and uc[j], such that lc[j] ≤ uc[j]. • Each row and column of variables in the matrix M is constrained by:

36. Cardinality (0,1) matrix constraint • The following Boolean martix is a solution instance for the cardinality (0,1) matrix, where each sum of row and column is bounded by 3 from bottom, and by 4 from top.

37. Exercise • You are required to solve n cardinality (0,1) matrix constraint instances. • The boolean matrix size for each problem instance is n×n, choose significant size n. • For each problem instance i [1..n] the sum of each row and column is exactly i. • Use a sorting network for the cardinality encoding. • Measure the solving time of each problem instance. • Explain your results.