"""Maximum flow: exact algorithm against cut enumeration, the LP route, and the flow family.""" import random from fractions import Fraction as F from itertools import combinations import pytest from lgmath import corpus, families, flow, lp, parse_a, parse_b, pipeline, smt from lgmath import fam_flow as ff from lgmath.tree import MathError, fmt_q, from_json, to_json, to_math SENTENCES = [ "maxflow [[0, 5, 4, 0], [0, 0, 3, 0], [0, 0, 0, 6], [0, 0, 0, 0]] from 1 to 4", "maxflow [[0, 3/2, 0], [0, 0, 5/4], [0, 0, 0]] from 1 to 3", "maxflow [[0, 4], [4, 0]] from 1 to 2", "maxflow [[0, 2 + 3, 0], [0, 0, 4], [0, 0, 0]] from 1 to 3", "maxflow [[0, 6, 0], [0, 0, 2 + 1], [0, 0, 0]] from 1 to 1 + 2", "maxflow [[0, 0, 0], [0, 0, 5], [0, 0, 0]] from 1 to 3", "maxflow [[0, 3, 0, 2, 0], [0, 0, 3, 0, 0], [0, 0, 0, 2, 0], [0, 0, 0, 0, 4], [0, 0, 0, 0, 0]] from 1 to 5", ] # Sparse networks without an arc from the sink back to the source: the LP route is slow on # dense instances, so it is only exercised on these fixed small cases. SPARSE = [ ([[0, 5, 4, 0], [0, 0, 3, 0], [0, 0, 0, 6], [0, 0, 0, 0]], 1, 4), ([[0, 3, 0, 0], [0, 0, 3, 0], [0, 0, 0, 2], [0, 0, 0, 0]], 1, 4), ([[0, 2, 2, 0], [0, 0, 0, 2], [0, 0, 0, 2], [0, 0, 0, 0]], 1, 4), ([[0, 4, 0, 0, 0], [0, 0, 3, 0, 0], [0, 0, 0, 3, 0], [0, 0, 0, 0, 2], [0, 0, 0, 0, 0]], 1, 5), ([[0, 1, 0], [7, 0, 5], [0, 0, 0]], 1, 3), ] def _matrix(rows): return [[F(value) for value in row] for row in rows] def _equivalence(query): return smt.check(query[0], query[1])[0] def _random_network(rng, n): capacity = [[F(0)] * n for _ in range(n)] for i in range(n): for j in range(n): if i != j and rng.random() < 0.5: capacity[i][j] = F(rng.randint(0, 9)) return capacity # --------------------------------------------------------------------------- # Language: both parsers agree, the printer round trips, the family is registered # --------------------------------------------------------------------------- def test_both_parsers_agree_on_flow_sentences_and_the_printer_round_trips(): for text in SENTENCES: first = parse_a.parse_problem(text) second = parse_b.parse_problem(text) assert first == second, text assert first[0] == "maxflow" assert parse_a.parse_problem(to_math(first)) == first, text assert parse_b.parse_problem(to_math(first)) == first, text assert from_json(to_json(first)) == first, text def test_the_flow_family_is_registered_for_the_new_kind(): family = families.family_of("maxflow") assert family is not None and family.name == "maximum flow" assert "maxflow" in families.all_kinds() def test_the_family_rejects_inputs_outside_the_fragment(): family = families.family_of("maxflow") bad = [ "maxflow [[0, 1], [1, 0]] from 1 to 3", # node number out of range "maxflow [[0, -1], [0, 0]] from 1 to 2", # negative capacity "maxflow [[1, 1], [0, 0]] from 1 to 2", # arc from a node to itself "maxflow [[0, 2], [0, 0]] from 2 to 2", # source and sink are equal "maxflow [[0, 2], [3, 0]] from x to 2", # terminal is not a number "maxflow [[0, 2]] from 1 to 2", # not a square matrix "maxflow [[0, 1, 0, 0, 0, 0, 0, 3], [0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], " "[0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], " "[0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0]] from 1 to 8", # too many nodes ] for text in bad: tree = parse_a.parse_problem(text) with pytest.raises(MathError): family.check_fragment(tree) for text in ("maximize x subject to x <= 1", "det [[1, 2], [3, 4]]"): assert parse_a.parse_problem(text)[0] != "maxflow" # --------------------------------------------------------------------------- # The exact algorithm against a second, independent algorithm # --------------------------------------------------------------------------- def test_max_flow_matches_cut_enumeration_on_random_networks(): rng = random.Random(20241116) for _ in range(120): n = rng.randint(2, 5) capacity = _random_network(rng, n) source, sink = 1, n own = flow.max_flow(capacity, source, sink) brute = flow.min_cut_by_enumeration(capacity, source, sink) assert own["status"] == "flow" and brute["status"] == "cut" assert own["value"] == brute["value"], (capacity, own["value"], brute["value"]) assert flow.check_flow(capacity, source, sink, own["flow"]), capacity assert flow.check_cut(capacity, source, sink, own["cut"]), capacity assert flow.check_max_flow(capacity, source, sink, own["flow"], own["cut"]), capacity assert flow.flow_value(own["flow"], source) == own["value"] def test_a_certificate_that_breaks_capacity_or_conservation_is_rejected(): capacity = _matrix([[0, 5, 4, 0], [0, 0, 3, 0], [0, 0, 0, 6], [0, 0, 0, 0]]) own = flow.max_flow(capacity, 1, 4) assert own["value"] == F(6) over = [row[:] for row in own["flow"]] over[0][1] = over[0][1] + 1 # more than the capacity of the arc assert not flow.check_flow(capacity, 1, 4, over) assert not flow.check_max_flow(capacity, 1, 4, over, own["cut"]) skewed = [row[:] for row in own["flow"]] skewed[0][2] = skewed[0][2] - 1 # node 3 loses one unit on the way through assert not flow.check_flow(capacity, 1, 4, skewed) missing = [node for node in own["cut"] if node != 3] assert not flow.check_cut(capacity, 1, 4, missing) or flow.cut_capacity(capacity, missing) != own["value"] def test_the_cut_side_of_the_certificate_is_a_real_partition(): capacity = _matrix([[0, 3, 0, 2, 0], [0, 0, 3, 0, 0], [0, 0, 0, 2, 0], [0, 0, 0, 0, 4], [0, 0, 0, 0, 0]]) own = flow.max_flow(capacity, 1, 5) cut = own["cut"] assert 1 in cut and 5 not in cut assert len(set(cut)) == len(cut) across = sum(capacity[i - 1][j - 1] for i in cut for j in range(1, 6) if j not in cut) assert across == own["value"] == F(4) # --------------------------------------------------------------------------- # The LP route: the dual of the flow LP is the cut, checked with lp.py # --------------------------------------------------------------------------- def test_the_lp_route_agrees_and_its_dual_reads_out_the_cut(): for rows, source, sink in SPARSE: capacity = _matrix(rows) own = flow.max_flow(capacity, source, sink) data = flow.as_lp(capacity, source, sink) outcome = lp.solve(data["A"], data["b"], data["c"]) assert outcome["status"] == "optimal", (rows, outcome["status"]) assert outcome["value"] == own["value"], (rows, outcome["value"], own["value"]) assert lp.check_optimal(data["A"], data["b"], data["c"], outcome["point"], outcome["dual"], outcome["value"]) rebuilt = flow.flow_of_lp(capacity, source, sink, data, outcome["point"]) cut = flow.cut_of_dual(capacity, source, sink, data, outcome["dual"]) assert flow.check_max_flow(capacity, source, sink, rebuilt, cut), rows with pytest.raises(flow.UnsupportedError): flow.as_lp(_matrix([[0, 1, 0], [0, 0, 1], [5, 0, 0]]), 1, 3) # arc from the sink back # --------------------------------------------------------------------------- # The family through the seven node topology # --------------------------------------------------------------------------- def test_flow_solvers_agree_through_the_topology(): family = families.family_of("maxflow") for text in SENTENCES: tree = parse_a.parse_problem(text) view_a, view_b = family.view_a(tree), family.view_b(tree) assert view_a["vars"] == view_b["vars"] and view_a["meta"] == view_b["meta"] assert view_a["terms"] and len(view_a["terms"]) == len(view_b["terms"]) first = family.solve_z3(tree, view_a, text)[0] second = family.solve_exact(tree, view_b, text)[0] assert family.same(first, second), text final = pipeline.run(text)["final"] assert final["status"] == "VERIFIED", text assert final["answer"]["value"] == second["value"], text assert final["answer"]["flow"] == second["flow"] and final["answer"]["cut"] == second["cut"] def test_the_two_views_of_the_same_network_are_equivalent_and_a_changed_one_is_not(): family = families.family_of("maxflow") left = parse_a.parse_problem("maxflow [[0, 5, 4, 0], [0, 0, 3, 0], [0, 0, 0, 6], [0, 0, 0, 0]] from 1 to 4") right = parse_b.parse_problem("maxflow [[0, 5, 4, 0], [0, 0, 3, 0], [0, 0, 0, 6], [0, 0, 0, 0]] from 1 to 4") query = families.equiv_query(family.view_a(left), family.view_b(right)) assert query is not None and _equivalence(query) == "unsat" other = parse_a.parse_problem("maxflow [[0, 5, 4, 0], [0, 0, 3, 0], [0, 0, 0, 7], [0, 0, 0, 0]] from 1 to 4") second = families.equiv_query(family.view_a(left), family.view_a(other)) assert second is not None and _equivalence(second) == "sat" def test_answer_and_certificates_are_checked_by_both_engines(): family = ff.FlowFamily() text = "maxflow [[0, 5, 4, 0], [0, 0, 3, 0], [0, 0, 0, 6], [0, 0, 0, 0]] from 1 to 4" tree = parse_a.parse_problem(text) view = family.view_a(tree) answer = family.solve_exact(tree, view, text)[0] for config in ("default", "nlsat"): assert family.z3_confirm(tree, view, answer, config)[0] is True, config assert family.exact_confirm(tree, view, answer, text)[0] is True wrong = dict(answer, value=fmt_q(F(answer["value"]) + 1)) assert family.z3_confirm(tree, view, wrong, "default")[0] is False assert family.exact_confirm(tree, view, wrong, text)[0] is False no_cut = dict(answer, cut=[]) assert family.exact_confirm(tree, view, no_cut, text)[0] is False for config in ("default", "nlsat"): assert family.z3_confirm(tree, view, no_cut, config)[0] is False, config for side in ([2], [1, 4], [1, 9], ["a"], [1, 1]): claim = dict(answer, cut=side) assert family.z3_confirm(tree, view, claim, "default")[0] is False, side assert family.exact_confirm(tree, view, claim, text)[0] is False, side corrupt = [row[:] for row in answer["flow"]] corrupt[0][1] = fmt_q(F(corrupt[0][1]) + 1) broken = dict(answer, flow=corrupt) assert family.z3_confirm(tree, view, broken, "default")[0] is False assert family.exact_confirm(tree, view, broken, text)[0] is False other = dict(answer, status="infeasible") assert family.z3_confirm(tree, view, other, "default")[0] is False assert family.exact_confirm(tree, view, other, text)[0] is False def test_every_side_of_the_network_is_judged_by_the_capacity_it_has(): """A side that separates the terminals certifies the value only when its capacity is the value.""" family = ff.FlowFamily() for text in SENTENCES[:3]: tree = parse_a.parse_problem(text) view = family.view_a(tree) answer = family.solve_exact(tree, view, text)[0] net = ff.network_of(tree) capacity, source, sink, n = net["capacity"], net["source"], net["sink"], net["n"] others = [node for node in range(1, n + 1) if node != sink] for size in range(1, n): for extra in combinations(others, size): if source not in extra: continue claim = dict(answer, cut=sorted(extra)) expected = flow.cut_capacity(capacity, extra) == F(answer["value"]) for config in ("default", "nlsat"): got = family.z3_confirm(tree, view, claim, config)[0] assert got == expected, (text, extra, config, got) assert family.exact_confirm(tree, view, claim, text)[0] == expected, (text, extra) def test_perturbations_and_the_gold_comparison_use_the_answer_shape(): family = ff.FlowFamily() text = "maxflow [[0, 5, 4, 0], [0, 0, 3, 0], [0, 0, 0, 6], [0, 0, 0, 0]] from 1 to 4" tree = parse_a.parse_problem(text) answer = family.solve_exact(tree, family.view_a(tree), text)[0] bumped, changed = family.perturb(answer, "off_by_one") assert changed and F(bumped["value"]) == F(answer["value"]) + 1 moved, changed = family.perturb(answer, "extra_solution") assert changed and moved["flow"] != answer["flow"] emptied, changed = family.perturb(answer, "drop_solution") assert changed and emptied["cut"] == [] view = family.view_a(tree) widened, changed = family.perturb(answer, "closed_open") assert changed and widened["cut"] == [1, 2, 3, 4] assert family.z3_confirm(tree, view, widened, "default")[0] is False assert family.exact_confirm(tree, view, widened, text)[0] is False same, changed = family.perturb(answer, "flip_verdict") assert not changed and same == answer assert family.gold_equal(answer, {"status": "flow", "value": "6"}) assert not family.gold_equal(answer, {"status": "flow", "value": "7"}) assert family.gold_equal(answer, {"value": "6", "cut": [1, 2, 3]}) assert "max flow 6" in family.render(answer) def test_corpus_flow_rows_have_gold_from_the_exact_engine(): rows = [item for item in corpus.load() if item["kind"] == "maxflow"] assert rows, "the corpus has no flow rows" for item in rows: tree = parse_a.parse_problem(item["text"]) network = ff.network_of(tree) own = flow.max_flow(network["capacity"], network["source"], network["sink"]) assert item["gold"]["status"] == "flow" assert item["gold"]["value"] == fmt_q(own["value"]), item["id"]