Datasets:
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
formal-verification
symbolic-algebra
theorem-proving
multi-agent-systems
benchmark
Download tests/test_flow.py from tailot/lingologos-math: direct link, hf CLI and curl.
- Browser
- Download file 13.9 kB
-
https://huggingface.co/datasets/tailot/lingologos-math/resolve/main/tests/test_flow.py
- Command line
-
hf download hf://datasets/tailot/lingologos-math/tests/test_flow.py
-
curl -L -o test_flow.py https://huggingface.co/datasets/tailot/lingologos-math/resolve/main/tests/test_flow.py
13.9 kB
| """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"] | |