1. Branch and Bound.

The LP relaxation of the problem [] gives
x = 21/5
y = 21/5
z = 63/5  (objective value)

splitting on x we add x <= 4 on the left branch, the LP solution [1] is
x = 4
y = 30/7
z = 88/7

splitting on y we add y <= 4 on the left branch, the LP solution [1,1] is 
x = 4
y = 4
z = 12
[This is our first integer solution]

On the right branch we add y >= 5, the LP solution [1,2] is 
x = 7/3
y = 5
z = 37/3
Since the objective is better than the best integer solution we keep
splitting.

On the left branch we add x <= 2 [1,2,1]
x = 2
y = 36/7
z = 86/7
The objective is still better so we keep splitting

On the left branch we add y <= 5, [1,2,1,1]
x = 2
y = 5
z = 12

On the right branch we add y >= 6 [1,2,1,2]
x = 0
y = 6
z = 12

On the right branch of the previous problem we add x >= 3 [1,2,2]
which fails

On the right branch of the previous problem we add x >= 5 [2]
x = 5
y = 11/3
z = 37/3
Still better than the best previous solution 12

So split, on the left branch we add y <= 3 [2,1]
x = 6
y = 3
z = 12

On the right branch we add y >= 4 [2,2]
which fails.

The optimal solution is 12, there are 3 ways to generate it

2. Cutting planes

x = 21/5 + 7/5s1 -3/5s2
x - 7/5s1 + 3/5s2 = 21/5
x - 2 s1 +3/5s1 + 3/5s2 = 4 + 1/5
x - 2 s1 + 4 = 1/5 - 3/5s1 -3/5s2
Cut is
    1/5 - 3/5s1 -3/5s2 <= 0

y = 21/5 -3/5s1 +2/5s2
y + 3/5s1 - 2/5s2 = 21/5
y + 3/5s1 -s2 + 3/5s1 = 4 + 1/5
y + s2 - 4 = 1/5 - 3/5s1 - 3/5s2
Cut is
    1/5 - 3/5s1 -3/5s2 <= 0

the same!

3. 
z = 63/5 - 1/5s1 - 1/5s2
x = 21/5 + 7/5s1 - 3/5s2
y = 21/5 - 3/5s1 + 2/5s2
s3= -4/5 - 7/5s1 + 3/5s2

exit row = s3
entry var = s2
pivot results in

z = 37/3 - 2/3s1 - 1/3s3
x =    5         +    s3
y = 11/3 - 1/3s1 - 2/3s3
s2=  4/3 + 8/3s1 + 5/3s3   

Note this is exactly the solution of the problem [2] above.

4. Preprocessing.

Fixing variables gives
x1 = 0,
x2 = 1,
x3 = 1,
x5 = 1,
x8 = 0

Simplifying and removing redundant constraints gives
2x9 - 2x10 + x11 <= 1
x9 + x10 + x11 <= 2

The constraint 2x4 + 3x6 + 3x10 <= 4 can be replaced by
x6 + x10 <= 1
x4 + x6 <= 1
x6 + x10 <= 1
using the cutting plane algorithm given, but better yet it
can be tightened to

x4 + x6 + x10 <= 1


[NOT COVERED IN SLIDES BUT INTERESTING TO SEE SOME OTHER THINGS]
For this problem you can also from
2x9 - 2x10 + x11 <= 1
x9 + x10 + x11 <= 2
generate this constraint by adding the first to two times the second

4x9 + 3x11 <= 5
which simplifies to
x9 + x11 <= 1

This new constraint makes x9 + x10 + x11 <= 2 redundant (since x10 <= 1)

5. 1UIP

Ideally dont by drawing the implication graph

Set b1 true

b1 -> -b3  {-b1,-b3}
b1 -> b4   {-b1,b4}

set b2 true

b2,b4 -> b8    {-b2,-b4,b8}
b2,-b3 -> -b6  {-b2,b3,-b6}
-b6 -> -b16    {b6,-b16}

set b5 true

-b3,b5,b8 -> -b10 {b3,-b5,-b8,-b10}
-b10 -> b14       {b10,b14}
b5,-b6 -> -b7     {-b5,b6,-b7}
-b7,-b10 -> b9    {b7,b9,b10}
b9 -> b13         {-b9,b13}
b9 -> b15         {-b9,b15}
b4,b15 -> b12     {-b4,b12,-b15}
-b3,b13,b12 -> fail  {b3,-b12,-b13}

1 UIP nogood is

  -b3,b4,b9 -> fail or {b3,-b4,-b9}

Execution backjumps to just before setting b2 = true

The nogood propagates to give

-b3,b4 -> -b9  {b3,-b4,-b9}

6. Cardinality Encodings:
   let s(n,d) denote xn + ... + x8 <= d 

   s(1,3) is then the original formula

   s(1,3) = if x1 then s(2,2) else s(2,3)
   s(2,2) = if x2 then s(3,1) else s(3,2)
   s(2,3) = if x2 then s(3,2) else s(3,3)
   s(3,1) = if x3 then s(4,0) else s(4,1)
   s(3,2) = if x3 then s(4,1) else s(4,2)
   s(3,3) = if x3 then s(4,2) else s(4,3)
   s(4,0) = if x4 then false  else s(5,0)
   s(4,1) = if x4 then s(5,0) else s(5,1)
   s(4,2) = if x4 then s(5,1) else s(5,2)
   s(4,3) = if x4 then s(5,2) else s(5,3)
   s(5,0) = if x5 then false  else s(6,0)
   s(5,1) = if x5 then s(6,0) else s(6,1)
   s(5,2) = if x5 then s(6,1) else s(6,2)
   s(5,3) = if x5 then s(6,2) else true
   s(6,0) = if x6 then false  else s(7,0)
   s(6,1) = if x6 then s(7,0) else s(7,1)
   s(6,2) = if x6 then s(7,1) else true
   s(7,0) = if x7 then false  else s(8,0)
   s(7,1) = if x7 then s(8,0) else true
   s(8,0) = if x8 then false  else true    (-x8)

To convert this into a diagram each s(,) is a node with a full arrow
to the first node (then) in its definition 
and a dashed arrow to the second node (else)

The sorting network is shown in a separate PDF.
The circuit for x1 + .. + x8 <= 3 is shown below

We can simplify the circuit by removing comparators both
of whose outputs are 0, since this forces both inputs to 0.
We can remove comparators that only swap dont care outputs
(the last top one in this case)
We can also simplify the comparators one output is 0 to
get a smaller cnf: these are shown dashed-dotted.
The CNF is input a,b, c = max(a,b), d = min(a,b) = 0 
    {-a, c}. {-b, c}, {-a, -b}, {a, b, -c}

We dont need to ever force outputs to 0 since that will not
cause the circuit to fail we can hence replace the CNF for a
comparator by
   {-a, c}. {-b, c}, {-a, -b, d}
and the simplified comparator [d = 0] by
   {-a, c}. {-b, c}, {-a, -b}