Part 0 · the ground floor · spine

Models, instances, and an oracle you trust

What a combinatorial problem is, the nine you will meet all course, and the one tool that lets you believe your own code.

needs nothing~1¼ h slides + 2 h lablab: uv run co lab 00

How to use these slides

These are written for reading on your own, not for presenting. The slide carries the statement; the notes carry the explanation you would otherwise get from a lecturer or a textbook paragraph. Read both.

N shows the notes beside the slide (and remembers it).
R switches to reading mode: all slides in one scroll with the notes beside each (stacked underneath on a narrow window). Best for a second pass or for looking something up.
Esc gives the overview grid.

What this unit is for

Nothing here is deep. It is the unit you will use most. Every later lab checks your code against a slow, obviously correct solver on small instances, and this is where that solver and that habit come from. It also introduces the question that runs through the whole course: what does it take to prove that a solution is optimal?

00 · overview

Three things to leave with

vocabulary

Problem vs instance. A feasible set described implicitly. Decision, optimization, counting.

the nine problems

Knapsack, set cover, assignment, bin packing, colouring, max-cut, TSP, job-shop, vertex cover.

two habits

Test every algorithm against an oracle. Ask what would prove an answer optimal, not just what the answer is.

Roadmap: definitions → the nine → spaces and symmetry → certificates → the oracle and the harness → the wall.

getting around

Words with a dotted underline are glossary terms: click one for its definition. G lists every term in the unit, N shows the notes. One small graph, the running example, comes back on most slides; a solid underline like that one shows it on hover. Optional extra: interactive figures, linked from the slides they support by a small ▸ chip; skip them freely.

section 1

What makes a problem combinatorial

Finite, but only in the least useful sense of the word.

00 · definitions

Problems and instances

definition

An optimization problem is a set of instances. An instance is a pair $(F, c)$: a feasible set $F$ and an objective $c : F \to \mathbb{R}$. We want $x^* \in F$ with $c(x^*) \le c(x)$ for all $x \in F$ (or $\ge$, for maximization).

combinatorial

$F$ is finite, and given implicitly: a simple, enumerable space $S$ and constraints, $\;F = \{x \in S : x \text{ satisfies the constraints}\}$.

Example. Vertex cover: an instance is a graph $G=(V,E)$. The space is $S = \{0,1\}^V$, the constraints are $x_u + x_v \ge 1$ for every $uv \in E$, and the objective is $c(x) = \sum_v x_v$, to be minimized. In words: pick the fewest vertices so that every edge touches one of them. The next slide does it on one graph.

The distinction between problem and instance matters from the first complexity statement onward. "Vertex cover is NP-hard" is a claim about the problem, meaning all graphs. "This graph has a cover of size 12" is a claim about an instance. Running times are functions of the encoding size of an instance: the bits needed to write down the graph, the weights, the capacity.

Finite is what separates this from continuous optimization. Nothing here needs limits, derivatives or convergence arguments: in principle you can look at every element of $F$. Implicit is what makes that useless. $F$ is never handed to you as a list. You get a short description that generates an exponentially large set, and the whole subject is about reasoning over that set without listing it.

The formal definition is Papadimitriou & Steiglitz ch. 1. Korte & Vygen use the same idea with more machinery.

00 · definitions · example

The running example

A triangle $0,1,2$ with one extra edge to vertex $3$. Four edges: $01,\ 02,\ 12,\ 23$. A candidate is $x \in \{0,1\}^4$, the vertices it picks.

candidate $x$	picks	uncovered edges	$c(x)$
$(0,1,1,0)$	$\{1, 2\}$	none ✓	2
$(1,1,0,1)$	$\{0, 1, 3\}$	none ✓	3
$(0,0,1,1)$	$\{2, 3\}$	$01$ ✗	—
$(0,0,1,0)$	$\{2\}$	$01$ ✗	—

Feasibility is checking every edge. $\{2,3\}$ misses edge $01$, so it is not in $F$ and its size doesn't matter. Of all $2^4 = 16$ candidates, 7 are covers, and the smallest have 2 vertices.

The space $S$ is all 16 candidates. The feasible set $F$ is the 7 covers. Nobody wrote $F$ down: the four edge constraints describe it.

Filled: the cover $\{1,2\}$. Every edge has a filled end.

explore interactively

00 · definitions

Finite, and astronomically so

space	size	at $n = 50$
subsets, $\{0,1\}^n$	$2^n$	$1.1 \times 10^{15}$
set partitions	Bell $B_n$	$1.9 \times 10^{47}$
tours from a fixed city	$(n-1)!$	$6.1 \times 10^{62}$

Enumerating is always correct and almost always useless.

The running example has $2^4 = 16$ candidates. Each vertex added doubles that: a graph with 50 vertices has the number in the first row.

Almost always useless, but it is not worthless: for $n \lesssim 20$ it is the only solver whose correctness you can see by reading it.

scale

At a billion candidates a second, $2^{50}$ takes 13 days. $(50-1)!$ takes about $10^{46}$ years.

Check the arithmetic once, so the numbers feel real. $2^{50} \approx 1.13\times10^{15}$, and at $10^9$ per second that is $1.13\times10^6$ seconds, about 13 days. $49! \approx 6.08\times10^{62}$, so $6\times10^{53}$ seconds, or about $2\times10^{46}$ years. The universe is about $1.4\times10^{10}$ years old.

The course could be described as a list of reasons you do not have to enumerate:

structure that makes greedy exact (matroids, unit 13);
a continuous relaxation that is already integral (total unimodularity, 06);
bounds that prune most of the tree (branch and bound, 07);
propagation that removes values before search reaches them (CP, 17);
and, when none of these works, settling for a guaranteed approximation (Part V).

Your lab's then step measures where enumeration stops being possible on your own machine. Those numbers set the size of every small instance used in later tests.

00 · definitions

Four questions about one instance

version	asks	on the running example, $k = 2$
decision	is there $x \in F$ with $c(x) \le k$?	is there a cover with at most 2 vertices? yes (with $k = 1$: no)
evaluation	what is $\min_{x\in F} c(x)$?	the smallest cover has 2 vertices
search / optimization	find an $x^*$ achieving it	here is one: $\{1, 2\}$
counting	how many $x \in F$ have $c(x) \le k$?	2 covers: $\{1, 2\}$ and $\{0, 2\}$

fact

For integer objectives of polynomial bit size, the first three are equally hard, up to polynomial factors. Counting can be much harder.

how, on the example

Decision to evaluation: ask $k = 0, 1, 2, \dots$ and stop at the first yes. Evaluation to search: delete vertex 0 and its edges. The rest ($12$, $23$) needs 1, one less than 2, so some best cover uses 0. Keep it and repeat on the rest.

Decision to evaluation: the optimum lies in a range of integers whose width is exponential in the bit size, so binary search needs polynomially many calls to the decision version.

Evaluation to search: self-reducibility. For vertex cover, try deleting vertex $v$ and its edges and ask whether the optimum of the rest is one less. If it is, $v$ belongs to some optimal cover: commit to it and recurse. That is $|V|$ more evaluation calls.

The example box, finished. The optimum is 2. Deleting vertex 0 leaves edges $12$, $23$, whose optimum is 1 (vertex 2), one less than 2, so some optimal cover contains 0: keep it and recurse on $\{12, 23\}$, optimum 1. Deleting vertex 1 there leaves $23$, optimum still 1, not one less, so 1 is not needed. Deleting vertex 2 leaves nothing, optimum 0: keep 2. Result $\{0, 2\}$. Trying the vertices in a different order can give the other optimal cover, $\{1, 2\}$.

Counting is a different world. Deciding whether a bipartite graph has a perfect matching takes polynomial time (unit 15). Counting perfect matchings is #P-complete (Valiant 1979), and so is computing the permanent of a 0/1 matrix. The course is almost entirely about decision and optimization; this is here so that "easy" is never assumed to mean "easy to count".

Complexity classes are defined on decision versions, which is why hardness statements are phrased as "is there a solution of value at most $k$?"

section 2

The nine problems

Each one is the textbook example of at least one technique later in the course.

00 · the nine

The cast

Knapsack{0,1}ⁿ · max DP (16), cover cuts (08), weakly NP-hard, FPTAS (22)

Set cover{0,1}ᵐ · min greedy $H_n$ (23), LP rounding & primal–dual (24)

Assignmentpermutations · min integral LP (06), Hungarian (15), Sinkhorn (31)

Bin packingset partitions · min strongly NP-hard, column generation (10)

Graph colouringset partitions · min SAT encodings (20), symmetry (27), Lovász θ (25)

Max-cut{0,1}ⁿ · max no constraints at all, Goemans–Williamson 0.878 (25)

TSPtours · min subtour separation (09), Held–Karp (11, 16), Christofides (23), 2-opt (26)

Job-shopmachine orders · min disjunctive & cumulative (18), LNS (19), CP-SAT (21)

Vertex cover{0,1}ⁿ · min 2-approx (23), half-integral LP (24), FPT (16), UGC (22)

subsets orderings partitions schedules

You don't need to memorize this grid now. It is here so that when a later unit says "recall knapsack" you have met it. All nine are in colib.problems with a random generator, so any later lab can say Knapsack.random(12, seed=3).

Things to notice already:

Assignment is the odd one out: it is solvable in polynomial time. It is on the list because it is the clearest case where the LP relaxation is already integral. Solving the LP solves the problem.
Knapsack and bin packing are both NP-hard, in different ways. Knapsack has a pseudo-polynomial DP, $O(nC)$, which is fast whenever the capacity $C$ is small. Bin packing stays NP-hard even when every number is small (strongly NP-hard). Unit 22 makes that precise.
Max-cut has no constraints. Every subset is feasible. All of the difficulty is in the objective, which is why it is the natural testbed for relaxations (unit 25).
Vertex cover is the one you will model yourself in the lab, and the one used for the certificate example below.

00 · the nine

One problem, three descriptions

As a predicate

what an oracle needs

def feasible(G, x):
    return all(x[u] or x[v]
               for u, v in G.edges)

def objective(G, x):
    return sum(x)

As an integer program

Parts I–II

$$\begin{aligned}\min\ & \textstyle\sum_{v} x_v \\ \text{s.t. } & x_u + x_v \ge 1 \quad \forall uv \in E \\ & x \in \{0,1\}^V\end{aligned}$$

As a constraint model

Part IV

x = [model.NewBoolVar(f"x{v}")
     for v in V]
for u, v in E:
    model.AddBoolOr(x[u], x[v])
model.Minimize(sum(x))

Same feasible set, three languages. What differs is what a solver can infer from the description without enumerating.

The predicate is a black box. The only thing you can do with it is evaluate it at a point, so enumeration is the only algorithm it admits. The integer program exposes linear structure: drop $x \in \{0,1\}$ to $0 \le x \le 1$ and you get an LP whose optimum is a lower bound. For vertex cover that LP has a surprising property (unit 24): some optimal solution uses only the values $0$, $\tfrac12$, $1$. The constraint model exposes logical structure: once $x_u$ is false, $x_v$ must be true, and a propagator can deduce that without search.

A theme to watch for: the same problem, written two ways that are logically equivalent, can differ in solve time by orders of magnitude. Unit 05 measures this for MIP formulations and unit 18 for global constraints.

The third block is OR-Tools CP-SAT syntax, shown only to recognize later. Nothing in this unit uses a solver.

00 · spaces

The space is a modelling choice

Bin packing, $n$ items. Two spaces, the same feasible packings:

space	size	$n = 10$
every map item → bin	$n^n$	10 000 000 000
set partitions	$B_n$	115 975

The first space counts every relabelling of the bins as a new packing. The second counts each packing once: 86 000× fewer.

restricted growth strings

$a_0 = 0,\quad a_i \le 1 + \max(a_0,\dots,a_{i-1})$

$a_i$ is item $i$'s bin. Bins are opened in order, so each partition of $\{0,\dots,n-1\}$ has exactly one string. The next slide lists them for $n = 3$.

This is symmetry breaking. Later it is the biggest single lever on real MIP and CP models (units 05, 27).

Why the strings work: read left to right, and give each new block the next unused label. Every partition has exactly one such canonical labelling, and every restricted growth string is canonical, so the map is a bijection with partitions. Counting them gives the Bell numbers $1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975, \dots$

The same idea elsewhere: a TSP tour is a cyclic order, so fixing city 0 first cuts $n!$ to $(n-1)!$. For symmetric distances, identifying a tour with its reverse halves it again. Colouring has the same symmetry as bin packing, since colours are interchangeable.

Symmetry matters far beyond enumeration. A branch-and-bound solver on a symmetric model proves the same subtree infeasible once for every relabelling. Solvers detect and break symmetry automatically (orbital fixing, orbitopes), but a model that avoids it is still better. You will write the enumerator in lab step 2.

00 · spaces · example

Set partitions, on three items

Every restricted growth string for $n = 3$, and the set partition it names. Read $a_i$ as "item $i$ goes in bin $a_i$".

string	bins	why it is allowed
`000`	$\{0,1,2\}$	never opens a new bin
`001`	$\{0,1\}\ \{2\}$	item 2 opens bin 1
`010`	$\{0,2\}\ \{1\}$	item 1 opens bin 1
`011`	$\{0\}\ \{1,2\}$	item 1 opens bin 1
`012`	$\{0\}\ \{1\}\ \{2\}$	each item opens the next bin

Not allowed: 002 skips bin 1, and 100 starts at bin 1. Both are relabellings of strings already in the table (001, and 011). That is the symmetry being removed.

bin packing on these five

Items of size $3, 2, 1$; bins of capacity $4$.

string	bin loads	bins
`000`	$6$ ✗	—
`001`	$5,\ 1$ ✗	—
`010`	$4,\ 2$ ✓	2
`011`	$3,\ 3$ ✓	2
`012`	$3,\ 2,\ 1$ ✓	3

Five candidates, three feasible, optimum 2 bins. The "every map item → bin" space would have checked $3^3 = 27$.

The rule $a_i \le 1 + \max(a_0, \dots, a_{i-1})$ says: an item may go into any bin already opened, or open exactly the next one. So the first item always opens bin 0, and bins are numbered in the order they are first used. Given any packing, you recover its string by walking the items in order and naming each bin the first time you meet it.

The 27 maps from three items to three bins fall into the same five partitions: 000-type (all together) arises 3 ways, each of the three two-bin splits 6 ways, and all-apart 6 ways. $3 + 3\cdot 6 + 6 = 27$.

The packing arithmetic: 010 puts items 0 and 2 (sizes 3 and 1) in bin 0, load 4, exactly full, and item 1 (size 2) alone. 011 puts item 0 alone (3) and items 1, 2 together (2 + 1 = 3). A lower bound confirms 2 is optimal: total size 6 over capacity 4 needs at least $\lceil 6/4 \rceil = 2$ bins. That is a certificate, the subject of the next section.

section 3

Certificates

"Here is the answer" and "here is why nothing is better" are different objects.

00 · certificates

Two kinds of evidence

upper bound · "at most k"

Exhibit $x \in F$ with $c(x) = k$.

Anyone checks it by evaluating the constraints and the objective. For all nine problems that takes polynomial time. This is exactly what puts the decision versions in NP.

lower bound · "at least k"

Show that no $x \in F$ has $c(x) < k$.

Enumeration proves it, but the proof is exponentially long. Is there a short proof? For NP-hard problems, in general, it is believed there is not: that is NP ≠ coNP.

on the running example

At most 2: hand over $\{1, 2\}$; checking it is four edge lookups. At least 2: enumeration checks all 16 candidates and finds no cover of size 0 or 1. That works at 4 vertices, not at 50. The next two slides replace it with two edges.

For particular instances, and for whole problem classes, short lower-bound proofs do exist. Finding them is most of the course.

A certificate in this course is any short object that lets someone else check a claim without redoing the search.

For a minimization problem, a feasible solution gives an upper bound on the optimum, and it is its own certificate. A lower bound needs an argument about every solution at once.

In complexity terms, the decision question "is the optimum at most $k$?" has short, checkable "yes" certificates, which is NP. Short checkable "no" certificates would put it in coNP. If any NP-complete problem were in coNP, then NP = coNP, which is widely believed false. So no general short lower-bound certificate is expected for vertex cover.

That is a worst-case statement. On a given instance there is often a short proof, and the machinery of the course exists to find one:

LP duality (03): a dual solution is a lower-bound certificate for the LP.
Branch and bound (07): the search tree together with the LP bounds at its leaves is the certificate.
Cutting planes (08): the derivation of the cuts.
DRAT proofs (20): SAT solvers emit a checkable proof of unsatisfiability.

Linear programming is the example that matters most: it had short certificates in both directions, so it was known to be in NP ∩ coNP, years before Khachiyan (1979) showed it is in P. Unit 01 builds the "no" certificate for feasibility.

00 · certificates

A lower bound for vertex cover

lemma

If $M$ is a matching (edges sharing no endpoint) and $C$ a vertex cover in the same graph, then $|C| \ge |M|$.

why

Each matched edge needs one of its own endpoints in the cover. Matched edges share no endpoints, so no cover vertex can serve two of them: the cover needs $|M|$ different vertices.

So a cover and a matching of the same size prove each other optimal. This is the matching lower bound, the course's first instance of weak duality.

A path on four vertices. Filled vertices: a cover of size 2. Thick edges: a matching of size 2. Each proves the other optimal.

This is the first duality argument of the course, in miniature. Write $\nu(G)$ for the largest matching and $\tau(G)$ for the smallest cover. The lemma says $\nu(G) \le \tau(G)$ for every graph: weak duality. Any matching is a lower bound on any cover, just as, in unit 03, any dual feasible solution bounds any primal one.

The certificate is short (at most $|V|/2$ edges) and quick to check: are these edges of $G$, and are they disjoint? You will write the checker in lab step 4.

A second look at the proof: it only used that matched edges are disjoint and that each needs a cover vertex. That is the LP inequality $\sum_{uv \in M} (x_u + x_v) \ge |M|$ together with $\sum_v x_v \ge \sum_{uv\in M}(x_u+x_v)$, the second holding because $M$ is a matching. Adding up constraints with nonnegative weights to bound the objective is exactly what an LP dual does.

00 · certificates · example

A certificate, checked step by step

Claim: the smallest cover of the running example has 2 vertices. The certificate is a cover $C = \{1,2\}$ and a matching $M = \{01, 23\}$.

check	on the example
1. every edge of $M$ is an edge of $G$	$01$ ✓, $23$ ✓	✓
2. edges of $M$ share no endpoint	endpoints $0,1,2,3$: all different	✓
3. $C$ covers every edge	$01{:}\,1$ · $02{:}\,2$ · $12{:}\,1,2$ · $23{:}\,2$	✓
4. sizes agree	$\|C\| = 2 = \|M\|$	✓

What follows: check 3 says the optimum is at most 2. Checks 1–2 and the lemma say every cover has at least 2. So 2 is optimal, and nobody enumerated anything.

A wrong certificate fails a check. $M = \{01, 12\}$ fails check 2 (vertex 1 twice), and rightly: one vertex, 1, touches both edges.

Filled: the cover. Thick: the matching. Each thick edge has its own filled end.

explore interactively

How long is this check on a big graph? Check 1 is a lookup per matched edge, check 2 is a pass over at most $|V|$ endpoints, check 3 is a pass over the edges. Linear time, against $2^{|V|}$ candidates for enumeration. That contrast is what "short certificate" means. Lab step 4 asks you to write exactly these checks.

Notice what check 4 does not need: it doesn't need $M$ to be a maximum matching, or $C$ to be a minimum cover. Equal sizes are enough, because each one bounds the other. If the sizes differed, say $|C| = 3$ and $|M| = 2$, the certificate would only prove $2 \le \text{optimum} \le 3$.

The running example contains a triangle, and the next slide shows that a triangle on its own has no such certificate. Here the pendant edge $23$ rescues it: it gives the matching a second edge, disjoint from $01$, that the triangle alone cannot supply.

00 · certificates

When the bound is not enough

On a triangle, the largest matching has 1 edge, and the smallest cover needs 2 vertices. No matching certifies the optimum. This duality gap is real.

Delete the running example's edge $23$ and you are here: the matching loses its second edge, the cover still needs 2.

könig, 1931

In a bipartite graph, $\max |M| = \min |C|$. The certificate always exists.

The triangle is the smallest odd cycle, and odd cycles are exactly what bipartite graphs lack. That coincidence is where polyhedral combinatorics starts (units 06, 15).

Any edge is a maximum matching (1). Any two vertices form a minimum cover (2).

explore interactively

Can the gap be large? Not in ratio, and it is worth seeing why: the endpoints of a maximal matching always form a cover, so $\tau \le 2\nu$. The matching bound is never off by more than a factor of 2, and this is the 2-approximation for vertex cover in unit 23, which is this slide turned into an algorithm.

The fractional view (unit 24): relax both to LPs. The fractional vertex cover $x_v = \tfrac12$ on the triangle costs $\tfrac32$, and the fractional matching $y_e = \tfrac12$ has value $\tfrac32$. These two LPs are duals, so their optima coincide: $$\nu = 1 \;\le\; \nu^* = \tfrac32 = \tau^* \;\le\; \tau = 2.$$ All of the gap comes from integrality, not from duality. On bipartite graphs the constraint matrix is totally unimodular (unit 06), so the LPs have integral optima, and König's theorem follows from LP duality.

The lab's step 4 test runs your checker over every cover and every edge set of the triangle, and expects every certificate to be rejected.

section 4

An oracle you trust

Slow, obviously correct, and the reference every later lab is checked against.

00 · oracle

Brute force, done once and done right

def brute_force(problem):
    best = best_x = None
    feasible = examined = 0
    for x in problem.space():
        examined += 1
        if not problem.is_feasible(x):
            continue
        feasible += 1
        v = problem.objective(x)
        if best is None or better(v, best, problem.sense):
            best, best_x = v, x
    return Result(best, best_x, feasible, examined)

Where people slip: initializing best to 0 or ∞ (wrong for one sense), and reporting a value on infeasible instances.

Obviously correct: it is the definition of the optimum, executed.

Self-certifying: examined == space.size() is the lower-bound proof.

Generic: one function for all nine problems, because every problem has the same problem interface.

on the running example

examined=16, feasible=7, value 2 at (0, 1, 1, 0): the cover $\{1, 2\}$. It keeps the first best it meets, so the tie $\{0, 2\}$, found later, is not reported.

explore interactively

The value of an oracle comes entirely from being easy to believe. That rules out anything clever. No pruning, no early exit, no incremental evaluation: each of those is a new place for a bug to hide, and a buggy oracle is worse than none, because it teaches you to trust wrong answers.

The interface, space(), is_feasible, objective, sense, is what makes the oracle generic. Every problem in colib has it. When a later unit adds a problem, it gets an oracle for free.

The example, step by step. The space lists the 16 vectors in order $(0,0,0,0), (0,0,0,1), \dots, (1,1,1,1)$. The first feasible one is $(0,1,1,0)$, the 7th examined, value 2: it becomes best. The next feasible one of value 2 is $(1,0,1,0)$, examined 11th; better(2, 2, "min") is false, so best_x stays. Five more covers, all of size 3 or 4, change nothing.

Keeping both counts, feasible and examined, costs nothing and gives two sanity checks. examined must equal the size of the space. And feasible tells you how constrained an instance is: random set cover instances are mostly infeasible, max-cut instances are all feasible. That changes how informative a random test is.

00 · oracle

Differential testing

Smallest first. The first failure is the smallest counterexample the sweep contains, and so the easiest one to draw.

Feasibility checked separately. A "better than optimal" answer is always an infeasible one.

Ratio mode. For approximation algorithms, pass ratio=2 and check a guarantee, not equality.

Differential testing is property-based testing with a problem-specific property. The property is "agrees with the definition". If you have used Hypothesis or QuickCheck, the harness is a hand-rolled version, with instance generators in place of strategies and size ordering in place of shrinking.

Why smallest first instead of shrinking? For combinatorial instances a general shrinker is awkward to write (what is a smaller job-shop?), while sweeping sizes $1,2,3,\dots$ with many seeds is trivial and nearly as good. A failure at $n=6$ is a picture you can draw; a failure at $n=40$ is not.

Random instances have blind spots. They rarely produce the structured cases (complete bipartite graphs, instances with many ties, degenerate LPs) that break algorithms in practice. Later labs add hand-built instances next to the random sweep for this reason. Unit 28 treats instance selection as a methodological question in its own right.

The call is one line: differential(my_alg, instances(VertexCover, sizes=range(1, 13))).

00 · oracle

The harness catches what you believe

"Take the vertex covering the most uncovered edges." (max-degree greedy)

On this spider it takes the centre (degree 3). The three leg-ends are then disjoint edges, and each costs one more vertex: 4.

The middle row covers everything with 3, and the three thick edges are a matching of size 3, so 3 is provably optimal.

No graph with fewer vertices makes max-degree greedy fail whatever the tie-breaking. In lab step 5 you write the heuristic, and the harness has to find a case like this on its own.

explore interactively

The counterexample was found by exhaustive search over all graphs with up to 7 vertices, looking for graphs where every tie-breaking choice of the greedy gives a suboptimal cover. There are none on 6 or fewer vertices; on 7, the spider with three legs of length 2 has the fewest edges. With a fixed tie-breaking rule, smaller failures exist, and the harness usually finds one around $n=6$.

The heuristic is not just occasionally wrong. There are bipartite families on which max-degree greedy is off by a factor of $\Theta(\log n)$, while the trivial "take both endpoints of an uncovered edge" rule is never worse than 2×. The more intuitive algorithm has the worse guarantee. Unit 23 has the construction.

Notice the slide uses both halves of this unit at once. The harness found that greedy is wrong; the matching certifies what right looks like, with no enumeration needed. On a graph of 1 000 vertices you could not run the oracle, but you could still check a matching.

00 · oracle

The wall

Pure-Python brute force, reference machine, extrapolated from µs per candidate:

space	1 minute	1 hour	1 year
$2^n$ — vertex cover	25	31	44
$(n-1)!$ — TSP	11	13	16
$B_n$ — bin packing	12	15	19

A year of computing buys five more TSP cities than a minute does. That limit is the wall.

rule for the rest of the course

Tests against brute force use $n \le 12$ for subset spaces, $n \le 8$ for tours and partitions. Anything larger needs a certificate or a trusted solver.

00 · lab

Lab 00 — what you build

about 2 hours · uv run co lab 00

Model it: feasibility and objective for vertex cover and bin packing.
Set partitions: the restricted-growth-string enumerator.
The oracle: generic brute force, checked against the reference on all nine problems.
A certificate: the matching lower bound, and a checker that rejects the triangle.
Break it: a heuristic you believe, and the harness proving you wrong.

uv run co test 00      # after each step: · not started  ✗ failing  ✓ done
uv run co then 00      # find your wall

00 · checkpoint

Done when

checkpoint

All five lab steps are ✓.
You can generate and exactly solve an instance of any of the nine problems at the sizes your wall allows.
The harness caught your deliberately wrong heuristic without you pointing it at the failure.
Without notes, you can explain the two kinds of certificate, and use the triangle to show why a matching cannot always certify a cover.

Reading

Papadimitriou & Steiglitz, Combinatorial Optimization, ch. 1.
Korte & Vygen, Combinatorial Optimization, §1.1–1.3 (optional).

Any of three roots: 01 polyhedra (LP trunk), 13 matroids (combinatorial trunk), 17 propagation (constraint trunk).

Models, instances, and an oracle you trust

Three things to leave with

What makes a problem combinatorial

Problems and instances

The running example

Finite, and astronomically so

Four questions about one instance

The nine problems

The cast

One problem, three descriptions

As a predicate

As an integer program

As a constraint model

The space is a modelling choice

Set partitions, on three items

Certificates

Two kinds of evidence

A lower bound for vertex cover

A certificate, checked step by step

When the bound is not enough

An oracle you trust

Brute force, done once and done right

Differential testing

The harness catches what you believe

The wall

Lab 00 — what you build

Done when

Reading

Next