proofs_common.py

"""Shared machinery for the QuixiProofs program (plans/proofs_plan.md).

The math program's generators are solvers whose traces fall out of
computing the answer; proof generators are provers whose derivations fall
out of constructing the theorem. This module holds the pieces every proof
family shares:

- a small exact expression form (integer coefficients, one variable
  ``x``) whose renderer and parser round-trip exactly,
- the rewrite rules behind the warrant registry,
- ``WARRANTS`` — the closed registry. Unlike scratchpad op-codes (organic,
  model-owned), a warrant name is only legal if a checker function backs
  it; WARRANTS.md is generated from this table as an authoritative doc.
- ``check_proof`` — the validity oracle: replays a record's derivation and
  verifies every STEP follows from its referenced line by exactly one
  application of its named warrant.

Proof-record line grammar (shape-validated by the proofs CLI, semantics
by ``check_proof``):

    PREMISE|<k>|<statement>
    IH|<k>|<assumption>
    STEP|<k>|<claim>|<warrant>|<refs>
    QED|<final_answer>

An ``IH`` line opens an induction scope: it and every later line belong
to the block until a STEP warranted ``induction_conclusion`` discharges
it, after which the block's lines may no longer be cited (the
assumption is gone, so everything conditional on it is too). A record
must not end with an open block, and blocks do not nest (plan §8).

``refs`` is a comma-separated list of earlier line numbers; its length
must equal the warrant's declared arity (``nrefs``, default 1; the
value ``"any"`` accepts any count — certificate conclusions fan in). Two
warrant kinds share the registry (plan §8): **rewrite** warrants declare
``apply`` and validate by membership — ``claim in apply(prev)``, or
``prev in apply(claim)`` for an ``inverse_of`` entry; **judgment**
warrants declare ``check(claim, prevs)`` and validate by direct
verification over the parsed claim and cited lines. A language's
``parse`` may return any comparable form (the sum languages return node
lists; the Euclid language returns a single statement tuple).

Expression form: a sum is a list of nodes; a node is ``("num", n)``,
``("term", c)`` for ``c*x``, ``("pterm", c, e)`` for ``c*x^e`` (e >= 2),
``("group", c, [nodes])`` for ``c*( ... )``, or
``("prodg", c, [sumA, sumB])`` for ``c*(A)(B)``. Coefficients are
nonzero ints (a vanished sum renders as ``0`` via the single node
``("num", 0)``).
"""
import re
from fractions import Fraction
from math import gcd, isqrt

from helpers import DELIM

# ---------------------------------------------------------------------------
# Rendering (canonical) and parsing — must round-trip exactly.
# ---------------------------------------------------------------------------


def _node_sign(node):
    return -1 if node[1] < 0 else 1


def _render_abs(node):
    """Node rendered without its sign (the sign joins the sum)."""
    kind = node[0]
    mag = abs(node[1])
    if kind == "num":
        return str(mag)
    if kind == "term":
        return "x" if mag == 1 else f"{mag}x"
    if kind == "pterm":
        base = f"x^{node[2]}"
        return base if mag == 1 else f"{mag}{base}"
    if kind == "prodg":
        factors = f"({render(node[2][0])})({render(node[2][1])})"
        return factors if mag == 1 else f"{mag}{factors}"
    inner = render(node[2])
    return f"({inner})" if mag == 1 else f"{mag}({inner})"


def render(nodes):
    """Canonical string for a sum: ``6(2x - 3) + 4x - 7``."""
    out = []
    for i, node in enumerate(nodes):
        if i == 0:
            prefix = "-" if _node_sign(node) < 0 else ""
        else:
            prefix = " - " if _node_sign(node) < 0 else " + "
        out.append(prefix + _render_abs(node))
    return "".join(out)


_TOKEN = re.compile(r"\s*(\d+|[x()+\-^·])")


def _tokenize(text):
    tokens, pos = [], 0
    while pos < len(text):
        m = _TOKEN.match(text, pos)
        if not m:
            raise ValueError(f"cannot tokenize expression at {text[pos:]!r}")
        tokens.append(m.group(1))
        pos = m.end()
    return tokens


def parse(text):
    """Parses a rendered sum back to the node-list form (round-trips)."""
    tokens = _tokenize(text)
    idx = 0

    def peek():
        return tokens[idx] if idx < len(tokens) else None

    def parse_sum():
        nonlocal idx
        nodes = []
        sign = 1
        if peek() == "-":
            sign, idx = -1, idx + 1
        elif peek() == "+":
            idx += 1
        while True:
            nodes.append(parse_item(sign))
            tok = peek()
            if tok == "+":
                sign, idx = 1, idx + 1
            elif tok == "-":
                sign, idx = -1, idx + 1
            else:
                return nodes

    def parse_item(sign):
        nonlocal idx
        tok = peek()
        if tok is None:
            raise ValueError("unexpected end of expression")
        coef = None
        if tok.isdigit():
            coef, idx = int(tok), idx + 1
            tok = peek()
        if tok == "x":
            idx += 1
            c = sign * (coef if coef is not None else 1)
            if peek() == "^":
                idx += 1
                exp = peek()
                if exp is None or not exp.isdigit():
                    raise ValueError("exponent must be an integer")
                idx += 1
                return ("pterm", c, int(exp))
            return ("term", c)
        if tok == "(":
            idx += 1
            inner = parse_sum()
            if peek() != ")":
                raise ValueError("missing closing parenthesis")
            idx += 1
            c = sign * (coef if coef is not None else 1)
            if peek() == "(":
                idx += 1
                second = parse_sum()
                if peek() != ")":
                    raise ValueError("missing closing parenthesis")
                idx += 1
                return ("prodg", c, [inner, second])
            return ("group", c, inner)
        if coef is None:
            raise ValueError(f"unexpected token {tok!r}")
        return ("num", sign * coef)

    nodes = parse_sum()
    if idx != len(tokens):
        raise ValueError(f"trailing tokens in expression: {tokens[idx:]!r}")
    return nodes


# ---------------------------------------------------------------------------
# Rewrite rules. Each rule maps a sum to every sum reachable by ONE
# application, at any depth. The checker tests membership; generators
# construct chains whose forward direction is always a member.
# ---------------------------------------------------------------------------


def _scale(c, node):
    return (node[0], c * node[1]) + tuple(node[2:])


def _sites(nodes, path=()):
    """Yields (path, sum) for the top-level sum and every group's inner sum."""
    yield path, nodes
    for i, node in enumerate(nodes):
        if node[0] == "group":
            yield from _sites(node[2], path + (i,))


def _replace_sum(nodes, path, new_sum):
    if not path:
        return new_sum
    i = path[0]
    node = nodes[i]
    inner = _replace_sum(node[2], path[1:], new_sum)
    return nodes[:i] + [("group", node[1], inner)] + nodes[i + 1:]


def apply_distribute(nodes):
    """Every result of expanding one group: c(d + e) -> cd + ce."""
    results = []
    for path, s in _sites(nodes):
        for i, node in enumerate(s):
            if node[0] != "group":
                continue
            expanded = [_scale(node[1], t) for t in node[2]]
            results.append(_replace_sum(nodes, path, s[:i] + expanded + s[i + 1:]))
    return results


def apply_combine(nodes):
    """Every result of merging one pair of like nodes in one sum.

    Merges two like non-group nodes — two ``num``s, two ``term``s, or two
    ``pterm``s of the same exponent — anywhere within one sum; the merged
    node takes the first node's position. A pair summing to zero drops
    out (an emptied sum becomes ``0``).
    """
    results = []
    for path, s in _sites(nodes):
        for i in range(len(s)):
            if s[i][0] in ("group", "prodg"):
                continue
            for j in range(i + 1, len(s)):
                if s[j][0] != s[i][0] or s[j][2:] != s[i][2:]:
                    continue
                total = s[i][1] + s[j][1]
                merged = [(s[i][0], total) + tuple(s[i][2:])] if total else []
                rest = s[:i] + merged + s[i + 1:j] + s[j + 1:]
                if not rest:
                    rest = [("num", 0)]
                results.append(_replace_sum(nodes, path, rest))
    return results


# ---------------------------------------------------------------------------
# Power expressions — the exponent-law family's language. A product is a
# list of nodes: ("xp", e) for x^e, or ("pg", [nodes], b) for
# (product)^b. Rendered with " · " separators; parsed by parse_pow. The
# warrant registry carries per-warrant parsers so one checker serves both
# expression languages.
# ---------------------------------------------------------------------------


def render_pow(nodes):
    out = []
    for node in nodes:
        if node[0] == "xp":
            out.append("x" if node[1] == 1 else f"x^{node[1]}")
        else:
            out.append(f"({render_pow(node[1])})^{node[2]}")
    return " · ".join(out)


def parse_pow(text):
    """Parses a rendered power product back to node-list form."""
    tokens = _tokenize(text)
    idx = 0

    def peek():
        return tokens[idx] if idx < len(tokens) else None

    def expect(tok):
        nonlocal idx
        if peek() != tok:
            raise ValueError(f"expected {tok!r}, got {peek()!r}")
        idx += 1

    def parse_product():
        nonlocal idx
        nodes = [parse_factor()]
        while peek() == "·":
            idx += 1
            nodes.append(parse_factor())
        return nodes

    def parse_factor():
        nonlocal idx
        tok = peek()
        if tok == "x":
            idx += 1
            if peek() == "^":
                idx += 1
                exp = peek()
                if exp is None or not exp.isdigit():
                    raise ValueError("exponent must be an integer")
                idx += 1
                return ("xp", int(exp))
            return ("xp", 1)
        if tok == "(":
            idx += 1
            inner = parse_product()
            expect(")")
            expect("^")
            exp = peek()
            if exp is None or not exp.isdigit():
                raise ValueError("exponent must be an integer")
            idx += 1
            return ("pg", inner, int(exp))
        raise ValueError(f"unexpected token {tok!r} in power expression")

    nodes = parse_product()
    if idx != len(tokens):
        raise ValueError(f"trailing tokens in power expression: {tokens[idx:]!r}")
    return nodes


def _pow_sites(nodes, path=()):
    yield path, nodes
    for i, node in enumerate(nodes):
        if node[0] == "pg":
            yield from _pow_sites(node[1], path + (i,))


def _replace_pow(nodes, path, new_product):
    if not path:
        return new_product
    i = path[0]
    node = nodes[i]
    inner = _replace_pow(node[1], path[1:], new_product)
    return nodes[:i] + [("pg", inner, node[2])] + nodes[i + 1:]


def apply_product_of_powers(nodes):
    """Every result of merging one pair of bare powers: x^a · x^b -> x^(a+b)."""
    results = []
    for path, s in _pow_sites(nodes):
        for i in range(len(s)):
            if s[i][0] != "xp":
                continue
            for j in range(i + 1, len(s)):
                if s[j][0] != "xp":
                    continue
                merged = ("xp", s[i][1] + s[j][1])
                results.append(_replace_pow(
                    nodes, path, s[:i] + [merged] + s[i + 1:j] + s[j + 1:]))
    return results


def apply_power_of_power(nodes):
    """Every result of collapsing one (x^a)^b -> x^(a*b)."""
    results = []
    for path, s in _pow_sites(nodes):
        for i, node in enumerate(s):
            if node[0] == "pg" and len(node[1]) == 1 and node[1][0][0] == "xp":
                collapsed = ("xp", node[1][0][1] * node[2])
                results.append(_replace_pow(
                    nodes, path, s[:i] + [collapsed] + s[i + 1:]))
    return results


# ---------------------------------------------------------------------------
# Fraction expressions — the telescoping family's language. A sum is a
# list of ("fr", p, q) nodes (a reduced signed fraction p/q, q >= 1;
# integers render plain) and ("pf", a, b) nodes (the positive
# product-form unit fraction 1/(a·b)). No nesting: partial-fraction
# splits splice their two terms directly into the sum, paper-style.
# ---------------------------------------------------------------------------

_FRAC_TOKEN = re.compile(r"\s*(\d+|[/()+\-·])")


def _frac_sign(node):
    return -1 if (node[0] == "fr" and node[1] < 0) else 1


def _render_frac_abs(node):
    if node[0] == "pf":
        return f"1/({node[1]}·{node[2]})"
    p, q = abs(node[1]), node[2]
    return str(p) if q == 1 else f"{p}/{q}"


def render_frac(nodes):
    out = []
    for i, node in enumerate(nodes):
        if i == 0:
            prefix = "-" if _frac_sign(node) < 0 else ""
        else:
            prefix = " - " if _frac_sign(node) < 0 else " + "
        out.append(prefix + _render_frac_abs(node))
    return "".join(out)


def parse_frac(text):
    """Parses a rendered fraction sum back to node-list form."""
    tokens, pos = [], 0
    while pos < len(text):
        m = _FRAC_TOKEN.match(text, pos)
        if not m:
            raise ValueError(
                f"cannot tokenize fraction expression at {text[pos:]!r}")
        tokens.append(m.group(1))
        pos = m.end()
    idx = 0

    def peek(offset=0):
        return tokens[idx + offset] if idx + offset < len(tokens) else None

    def expect(tok):
        nonlocal idx
        if peek() != tok:
            raise ValueError(f"expected {tok!r}, got {peek()!r}")
        idx += 1

    def parse_item(sign):
        nonlocal idx
        tok = peek()
        if tok is None or not tok.isdigit():
            raise ValueError(f"expected a number, got {tok!r}")
        idx += 1
        p = int(tok)
        if peek() != "/":
            return ("fr", sign * p, 1)
        idx += 1
        if peek() == "(":
            if p != 1 or sign < 0:
                raise ValueError("product-form fractions must be +1/(a·b)")
            idx += 1
            a = peek()
            if a is None or not a.isdigit():
                raise ValueError("expected a number in 1/(a·b)")
            idx += 1
            expect("·")
            b = peek()
            if b is None or not b.isdigit():
                raise ValueError("expected a number in 1/(a·b)")
            idx += 1
            expect(")")
            return ("pf", int(a), int(b))
        q = peek()
        if q is None or not q.isdigit():
            raise ValueError("expected a denominator")
        idx += 1
        return ("fr", sign * p, int(q))

    nodes = []
    sign = 1
    if peek() == "-":
        sign, idx = -1, idx + 1
    while True:
        nodes.append(parse_item(sign))
        tok = peek()
        if tok == "+":
            sign, idx = 1, idx + 1
        elif tok == "-":
            sign, idx = -1, idx + 1
        else:
            break
    if idx != len(tokens):
        raise ValueError(
            f"trailing tokens in fraction expression: {tokens[idx:]!r}")
    return nodes


def apply_partial_fractions(nodes):
    """Every result of splitting one 1/(a·(a+1)) into 1/a - 1/(a+1)."""
    results = []
    for i, node in enumerate(nodes):
        if node[0] == "pf" and node[2] == node[1] + 1:
            split = [("fr", 1, node[1]), ("fr", -1, node[2])]
            results.append(nodes[:i] + split + nodes[i + 1:])
    return results


def apply_cancel_pair(nodes):
    """Every result of removing one exactly-opposite pair of fractions."""
    results = []
    for i in range(len(nodes)):
        if nodes[i][0] != "fr":
            continue
        for j in range(i + 1, len(nodes)):
            if nodes[j][0] != "fr":
                continue
            if nodes[j][1] == -nodes[i][1] and nodes[j][2] == nodes[i][2]:
                rest = nodes[:i] + nodes[i + 1:j] + nodes[j + 1:]
                results.append(rest if rest else [("fr", 0, 1)])
    return results


def apply_add_fractions(nodes):
    """Every result of exactly adding one pair of fractions (nonzero sum;
    a zero sum is cancel_pair's move)."""
    results = []
    for i in range(len(nodes)):
        if nodes[i][0] != "fr":
            continue
        for j in range(i + 1, len(nodes)):
            if nodes[j][0] != "fr":
                continue
            total = Fraction(nodes[i][1], nodes[i][2]) \
                + Fraction(nodes[j][1], nodes[j][2])
            if total == 0:
                continue
            merged = ("fr", total.numerator, total.denominator)
            results.append(nodes[:i] + [merged]
                           + nodes[i + 1:j] + nodes[j + 1:])
    return results


# ---------------------------------------------------------------------------
# Log expressions — the log-law family's language. A sum is a list of
# ("num", n) and ("klg", k, b, factors) nodes, where factors is a list of
# ("f", m, e) entries: k·log_b(m1^e1 · m2 · ...). All quantities positive
# integers; bases are exact-friendly and every evaluated log is exact.
# ---------------------------------------------------------------------------

_LOG_TOKEN = re.compile(r"\s*(\d+|log|[()+^·_])")


def render_log(nodes):
    out = []
    for node in nodes:
        if node[0] == "num":
            out.append(str(node[1]))
            continue
        k, b, fs = node[1], node[2], node[3]
        arg = " · ".join(str(m) if e == 1 else f"{m}^{e}" for _, m, e in fs)
        lg = f"log_{b}({arg})" if len(fs) > 1 or fs[0][2] > 1 \
            else f"log_{b} {arg}"
        out.append(lg if k == 1 else f"{k}·{lg}")
    return " + ".join(out)


def parse_log(text):
    """Parses a rendered log sum back to node-list form."""
    tokens, pos = [], 0
    while pos < len(text):
        m = _LOG_TOKEN.match(text, pos)
        if not m:
            raise ValueError(f"cannot tokenize log expression at {text[pos:]!r}")
        tokens.append(m.group(1))
        pos = m.end()
    idx = 0

    def peek(offset=0):
        return tokens[idx + offset] if idx + offset < len(tokens) else None

    def expect(tok):
        nonlocal idx
        if peek() != tok:
            raise ValueError(f"expected {tok!r}, got {peek()!r}")
        idx += 1

    def parse_factor():
        nonlocal idx
        m_tok = peek()
        if m_tok is None or not m_tok.isdigit():
            raise ValueError(f"expected a number, got {m_tok!r}")
        idx += 1
        e = 1
        if peek() == "^":
            idx += 1
            e_tok = peek()
            if e_tok is None or not e_tok.isdigit():
                raise ValueError("exponent must be an integer")
            idx += 1
            e = int(e_tok)
        return ("f", int(m_tok), e)

    def parse_item():
        nonlocal idx
        k = 1
        if peek() is not None and peek().isdigit() and peek(1) == "·" \
                and peek(2) == "log":
            k = int(peek())
            idx += 2
        if peek() == "log":
            idx += 1
            expect("_")
            b_tok = peek()
            if b_tok is None or not b_tok.isdigit():
                raise ValueError("log base must be an integer")
            idx += 1
            if peek() == "(":
                idx += 1
                factors = [parse_factor()]
                while peek() == "·":
                    idx += 1
                    factors.append(parse_factor())
                expect(")")
            else:
                factors = [parse_factor()]
            return ("klg", k, int(b_tok), factors)
        tok = peek()
        if tok is None or not tok.isdigit():
            raise ValueError(f"unexpected token {tok!r} in log expression")
        idx += 1
        return ("num", int(tok))

    nodes = [parse_item()]
    while peek() == "+":
        idx += 1
        nodes.append(parse_item())
    if idx != len(tokens):
        raise ValueError(f"trailing tokens in log expression: {tokens[idx:]!r}")
    return nodes


def apply_log_of_product(nodes):
    """Every result of splitting one factor off a multi-factor log."""
    results = []
    for i, node in enumerate(nodes):
        if node[0] == "klg" and len(node[3]) > 1:
            first = ("klg", node[1], node[2], node[3][:1])
            rest = ("klg", node[1], node[2], node[3][1:])
            results.append(nodes[:i] + [first, rest] + nodes[i + 1:])
    return results


def apply_log_of_power(nodes):
    """Every result of pulling one exponent out: k·log_b(m^e) -> (k·e)·log_b m."""
    results = []
    for i, node in enumerate(nodes):
        if node[0] == "klg" and len(node[3]) == 1 and node[3][0][2] > 1:
            _, m, e = node[3][0]
            results.append(nodes[:i]
                           + [("klg", node[1] * e, node[2], [("f", m, 1)])]
                           + nodes[i + 1:])
    return results


def _exact_log(b, m):
    j, value = 0, 1
    while value < m:
        value *= b
        j += 1
    return j if value == m else None


def apply_evaluate_log(nodes):
    """Every result of evaluating one exact log: k·log_b(b^j) -> k·j."""
    results = []
    for i, node in enumerate(nodes):
        if node[0] == "klg" and len(node[3]) == 1 and node[3][0][2] == 1:
            j = _exact_log(node[2], node[3][0][1])
            if j is not None:
                results.append(nodes[:i] + [("num", node[1] * j)]
                               + nodes[i + 1:])
    return results


def apply_add_integers(nodes):
    """Every result of adding one pair of integer terms."""
    results = []
    for i in range(len(nodes)):
        if nodes[i][0] != "num":
            continue
        for j in range(i + 1, len(nodes)):
            if nodes[j][0] != "num":
                continue
            merged = ("num", nodes[i][1] + nodes[j][1])
            results.append(nodes[:i] + [merged]
                           + nodes[i + 1:j] + nodes[j + 1:])
    return results


def _mul_linear(u, v):
    """Product of two linear nodes (num/term) from binomial factors."""
    cu, cv = u[1], v[1]
    if u[0] == "term" and v[0] == "term":
        return ("pterm", cu * cv, 2)
    if u[0] == "num" and v[0] == "num":
        return ("num", cu * cv)
    return ("term", cu * cv)


def apply_expand_product(nodes):
    """Every result of FOIL-expanding one binomial product.

    c(A)(B) becomes c( a1·b1 + a1·b2 + a2·b1 + a2·b2 ) — the four cross
    terms in FOIL order inside a group still carrying c, so a subsequent
    ``distribute`` clears the coefficient exactly as on paper. Factors
    must be sums of ``num``/``term`` nodes.
    """
    results = []
    for path, s in _sites(nodes):
        for i, node in enumerate(s):
            if node[0] != "prodg":
                continue
            fa, fb = node[2]
            if any(t[0] not in ("num", "term") for t in fa + fb):
                continue
            foil = [_mul_linear(u, v) for u in fa for v in fb]
            expanded = ("group", node[1], foil)
            results.append(_replace_sum(nodes, path,
                                        s[:i] + [expanded] + s[i + 1:]))
            if node[1] == 1:
                # With no coefficient to carry, FOIL lands as four bare
                # terms — the way it is actually written on paper.
                results.append(_replace_sum(nodes, path,
                                            s[:i] + foil + s[i + 1:]))
    return results


# ---------------------------------------------------------------------------
# Euclid statements — the integer-arithmetic certificate language shared
# by the gcd/Bezout and primality families. Unlike the sum languages, a
# statement parses to a single tuple:
#
#   ("gcd", a, b)            gcd(a, b)
#   ("int", n)               n
#   ("div", a, q, b, r)      a = q·b + r     (division identity, r >= 0)
#   ("comb", g, s, u, t, v)  g = s·u + t·v   (integer combination; s, t
#                                             may be negative)
#   ("prod", n, a, b)        n = a·b         (factorization)
#   ("prime", n)             n is prime
#   ("pcong", n, k, r, m)    n^k ≡ r (mod m) (k = 1 renders without ^)
#   ("xcong", a, m)          x ≡ a (mod m)   (a congruence condition on
#                                             the unknown x)
#   ("divides", d, n)        d divides n     (worded: "|" is the field
#   ("ndivides", d, n)       d does not divide n        delimiter)
#   ("dsum", n, s)           digitsum(n) = s
#   ("asum", n, s)           altsum(n) = s   (alternating from the units
#                                             digit; s may be negative)
#   ("tail", n, k, m)        last<k>(n) = m  (k in 1..3)
#
# The membership and judgment machinery is agnostic to the parsed form,
# so single tuples ride the same checker as node lists.
# ---------------------------------------------------------------------------

_EUCLID_TOKEN = re.compile(
    r"\s*(\d+|gcd|is|prime|mod|digitsum|altsum|last1|last2|last3"
    r"|divides|does|not|divide|[(),=+\-·^≡x])")


def render_euclid(node):
    kind = node[0]
    if kind == "gcd":
        return f"gcd({node[1]}, {node[2]})"
    if kind == "int":
        return str(node[1])
    if kind == "prime":
        return f"{node[1]} is prime"
    if kind == "prod":
        return f"{node[1]} = {node[2]}·{node[3]}"
    if kind == "pcong":
        _, n, k, r, m = node
        base = str(n) if k == 1 else f"{n}^{k}"
        return f"{base} ≡ {r} (mod {m})"
    if kind == "xcong":
        return f"x ≡ {node[1]} (mod {node[2]})"
    if kind == "divides":
        return f"{node[1]} divides {node[2]}"
    if kind == "ndivides":
        return f"{node[1]} does not divide {node[2]}"
    if kind == "dsum":
        return f"digitsum({node[1]}) = {node[2]}"
    if kind == "asum":
        return f"altsum({node[1]}) = {node[2]}"
    if kind == "tail":
        return f"last{node[2]}({node[1]}) = {node[3]}"
    if kind == "div":
        _, a, q, b, r = node
        return f"{a} = {q}·{b} + {r}"
    _, g, s, u, t, v = node
    head = f"{s}·{u}" if s >= 0 else f"-{-s}·{u}"
    tail = f" + {t}·{v}" if t >= 0 else f" - {-t}·{v}"
    return f"{g} = {head}{tail}"


def parse_euclid(text):
    """Parses a rendered Euclid statement back to its tuple (round-trips)."""
    tokens, pos = [], 0
    while pos < len(text):
        m = _EUCLID_TOKEN.match(text, pos)
        if not m:
            raise ValueError(
                f"cannot tokenize Euclid statement at {text[pos:]!r}")
        tokens.append(m.group(1))
        pos = m.end()
    idx = 0

    def peek():
        return tokens[idx] if idx < len(tokens) else None

    def expect(tok):
        nonlocal idx
        if peek() != tok:
            raise ValueError(f"expected {tok!r}, got {peek()!r}")
        idx += 1

    def parse_int():
        nonlocal idx
        tok = peek()
        if tok is None or not tok.isdigit():
            raise ValueError(f"expected a number, got {tok!r}")
        idx += 1
        return int(tok)

    def done():
        return idx == len(tokens)

    if peek() == "gcd":
        idx += 1
        expect("(")
        a = parse_int()
        expect(",")
        b = parse_int()
        expect(")")
        if not done():
            raise ValueError(f"trailing tokens: {tokens[idx:]!r}")
        return ("gcd", a, b)
    if peek() == "x":
        idx += 1
        expect("≡")
        a = parse_int()
        expect("(")
        expect("mod")
        m = parse_int()
        expect(")")
        if not done():
            raise ValueError(f"trailing tokens: {tokens[idx:]!r}")
        return ("xcong", a, m)
    if peek() in ("digitsum", "altsum", "last1", "last2", "last3"):
        head = peek()
        idx += 1
        expect("(")
        n = parse_int()
        expect(")")
        expect("=")
        neg = peek() == "-"
        if neg:
            if head != "altsum":
                raise ValueError("only altsum may be negative")
            idx += 1
        s = parse_int()
        if not done():
            raise ValueError(f"trailing tokens: {tokens[idx:]!r}")
        if head == "digitsum":
            return ("dsum", n, s)
        if head == "altsum":
            return ("asum", n, -s if neg else s)
        return ("tail", n, int(head[-1]), s)
    n = parse_int()
    if done():
        return ("int", n)
    if peek() in ("^", "≡"):
        k = 1
        if peek() == "^":
            idx += 1
            k = parse_int()
            if k < 2:
                raise ValueError("rendered congruence exponents are >= 2")
        expect("≡")
        r = parse_int()
        expect("(")
        expect("mod")
        m = parse_int()
        expect(")")
        if not done():
            raise ValueError(f"trailing tokens: {tokens[idx:]!r}")
        return ("pcong", n, k, r, m)
    if peek() == "is":
        idx += 1
        expect("prime")
        if not done():
            raise ValueError(f"trailing tokens: {tokens[idx:]!r}")
        return ("prime", n)
    if peek() in ("divides", "does"):
        if peek() == "divides":
            idx += 1
            kind = "divides"
        else:
            idx += 1
            expect("not")
            expect("divide")
            kind = "ndivides"
        m = parse_int()
        if not done():
            raise ValueError(f"trailing tokens: {tokens[idx:]!r}")
        return (kind, n, m)
    expect("=")
    s_neg = peek() == "-"
    if s_neg:
        idx += 1
    k1 = parse_int()
    expect("·")
    m1 = parse_int()
    if done():
        if s_neg:
            raise ValueError("factorization factors must be positive")
        return ("prod", n, k1, m1)
    op = peek()
    if op not in ("+", "-"):
        raise ValueError(f"expected + or -, got {op!r}")
    idx += 1
    n2 = parse_int()
    if done():
        if s_neg or op != "+":
            raise ValueError("division identity must be a = q·b + r")
        return ("div", n, k1, m1, n2)
    expect("·")
    m2 = parse_int()
    if not done():
        raise ValueError(f"trailing tokens: {tokens[idx:]!r}")
    return ("comb", n, -k1 if s_neg else k1, m1, -n2 if op == "-" else n2, m2)


def apply_euclid_step(node):
    """The Euclidean descent step: gcd(a, b) -> gcd(b, a mod b), b >= 1."""
    if node[0] == "gcd" and node[2] >= 1:
        return [("gcd", node[2], node[1] % node[2])]
    return []


def apply_gcd_of_zero(node):
    """Reading off a finished descent: gcd(d, 0) -> d, d >= 1."""
    if node[0] == "gcd" and node[2] == 0 and node[1] >= 1:
        return [("int", node[1])]
    return []


def check_division_identity(claim, prevs):
    """a = q·b + r with 0 <= r < b, cited against the line gcd(a, b)."""
    (ref,) = prevs
    if claim[0] != "div" or ref[0] != "gcd":
        return False
    _, a, q, b, r = claim
    return ref[1] == a and ref[2] == b and a == q * b + r and 0 <= r < b


def check_rearrange_division(claim, prevs):
    """r = 1·a - q·b, cited against the division identity a = q·b + r."""
    (ref,) = prevs
    if claim[0] != "comb" or ref[0] != "div":
        return False
    _, a, q, b, r = ref
    return r >= 1 and claim[1:] == (r, 1, a, -q, b)


def check_substitute_remainder(claim, prevs):
    """From g = s·u + t·v and U = q·u + v, conclude g = t·U + (s - t·q)·u."""
    comb, div = prevs
    if claim[0] != "comb" or comb[0] != "comb" or div[0] != "div":
        return False
    _, g, s, u, t, v = comb
    _, big, q, base, r = div
    if base != u or r != v:
        return False
    return claim[1:] == (g, t, big, s - t * q, u)


def _primes_upto(k):
    return [p for p in range(2, k + 1)
            if all(p % d for d in range(2, isqrt(p) + 1))]


def check_trial_division(claim, prevs):
    """n = q·p + r with 0 <= r < p and p >= 2, cited against the line n."""
    (ref,) = prevs
    if claim[0] != "div" or ref[0] != "int":
        return False
    _, n, q, p, r = claim
    return n == ref[1] and p >= 2 and n == q * p + r and 0 <= r < p


def check_factorization(claim, prevs):
    """n = a·b read off an exact trial division n = q·p + 0."""
    (ref,) = prevs
    if claim[0] != "prod" or ref[0] != "div":
        return False
    _, n, a, b = claim
    _, n2, q, p, r = ref
    return (n2 == n and r == 0 and n == q * p and a >= 2 and b >= 2
            and (a, b) in ((q, p), (p, q)))


def _pcong_true(c):
    """A congruence line re-verified from scratch (guards smuggled refs)."""
    if c[0] != "pcong":
        return False
    _, n, k, r, m = c
    return m >= 2 and 0 <= r < m and k >= 1 and pow(n, k, m) == r


def check_square_congruence(claim, prevs):
    """From n^k ≡ r (mod m) conclude n^(2k) ≡ r² reduced mod m."""
    (ref,) = prevs
    if claim[0] != "pcong" or not _pcong_true(ref):
        return False
    _, n, k, r, m = ref
    return claim[1:] == (n, 2 * k, r * r % m, m)


def check_multiply_congruences(claim, prevs):
    """From n^j ≡ r and n^k ≡ s (mod m) conclude n^(j+k) ≡ r·s mod m."""
    a, b = prevs
    if claim[0] != "pcong" or not (_pcong_true(a) and _pcong_true(b)):
        return False
    _, n, k1, r1, m = a
    _, n2, k2, r2, m2 = b
    if (n2, m2) != (n, m):
        return False
    return claim[1:] == (n, k1 + k2, r1 * r2 % m, m)


# ---------------------------------------------------------------------------
# Induction statements — the sum-induction family's language. Claims in
# the inductive block are bare sum-language expressions (so the Phase-1
# rewrite warrants apply verbatim); the skeleton lines carry three
# special forms, and a shared parser wraps bare expressions for typed
# judgment checks:
#
#   ("ihyp", nodes)   assume S(x) = <expr>
#   ("base", v)       at x = 1, both sides equal <v>
#   ("concl", nodes)  S(x) = <expr> for all x >= 1
#   ("expr", nodes)   any bare sum-language expression
# ---------------------------------------------------------------------------


def render_induction(node):
    if node[0] == "ihyp":
        return f"assume S(x) = {render(node[1])}"
    if node[0] == "base":
        return f"at x = 1, both sides equal {node[1]}"
    if node[0] == "concl":
        return f"S(x) = {render(node[1])} for all x >= 1"
    return render(node[1])


def parse_induction(text):
    """Parses an induction-skeleton statement or a bare expression."""
    if text.startswith("assume S(x) = "):
        return ("ihyp", parse(text[len("assume S(x) = "):]))
    if text.startswith("at x = 1, both sides equal "):
        tail = text[len("at x = 1, both sides equal "):]
        body = tail[1:] if tail.startswith("-") else tail
        if not body.isdigit():
            raise ValueError(f"bad base-case value {tail!r}")
        return ("base", -int(body) if tail.startswith("-") else int(body))
    if text.startswith("S(x) = ") and text.endswith(" for all x >= 1"):
        return ("concl", parse(text[len("S(x) = "):-len(" for all x >= 1")]))
    return ("expr", parse(text))


def _eval_nodes(nodes, v):
    """Exact integer evaluation of a sum-language expression at x = v."""
    total = 0
    for node in nodes:
        kind = node[0]
        if kind == "num":
            total += node[1]
        elif kind == "term":
            total += node[1] * v
        elif kind == "pterm":
            total += node[1] * v ** node[2]
        elif kind == "group":
            total += node[1] * _eval_nodes(node[2], v)
        else:
            total += (node[1] * _eval_nodes(node[2][0], v)
                      * _eval_nodes(node[2][1], v))
    return total


_XP1 = [("term", 1), ("num", 1)]


def _successor_term(nodes):
    """t(x+1) for a linear term formula: c·x -> c·(x + 1)."""
    out = []
    for node in nodes:
        if node[0] == "num":
            out.append(node)
        elif node[0] == "term":
            out.append(("group", node[1], list(_XP1)))
        else:
            return None
    return out


def _successor_formula(nodes):
    """F(x+1) for a quadratic closed form: c·x² -> c(x+1)(x+1)."""
    out = []
    for node in nodes:
        if node[0] == "num":
            out.append(node)
        elif node[0] == "term":
            out.append(("group", node[1], list(_XP1)))
        elif node[0] == "pterm" and node[2] == 2:
            out.append(("prodg", node[1], [list(_XP1), list(_XP1)]))
        else:
            return None
    return out


def check_base_case(claim, prevs):
    """Both sides at x = 1: the first term equals the formula's value."""
    t_ref, ih_ref = prevs
    if claim[0] != "base" or t_ref[0] != "expr" or ih_ref[0] != "ihyp":
        return False
    v = _eval_nodes(t_ref[1], 1)
    return v == _eval_nodes(ih_ref[1], 1) and claim[1] == v


def check_induction_hypothesis(claim, prevs):
    """S(x+1) rewritten as the assumed closed form plus the next term."""
    t_ref, ih_ref = prevs
    if claim[0] != "expr" or t_ref[0] != "expr" or ih_ref[0] != "ihyp":
        return False
    nxt = _successor_term(t_ref[1])
    return nxt is not None and claim[1] == ih_ref[1] + nxt


def check_formula_at_successor(claim, prevs):
    """The assumed closed form instantiated at x + 1."""
    (ih_ref,) = prevs
    if claim[0] != "expr" or ih_ref[0] != "ihyp":
        return False
    target = _successor_formula(ih_ref[1])
    return target is not None and claim[1] == target


def check_induction_conclusion(claim, prevs):
    """Discharge the IH: base re-verified, the increment strand and the
    successor strand meet in the same expression, and the concluded
    formula is the assumed one. Strand ancestry and scope closure are
    enforced by check_proof itself (they need the refs DAG)."""
    t_ref, ih_ref, base_ref, incr_ref, targ_ref = prevs
    if claim[0] != "concl" or t_ref[0] != "expr" or ih_ref[0] != "ihyp" \
            or base_ref[0] != "base" or incr_ref[0] != "expr" \
            or targ_ref[0] != "expr":
        return False
    v = _eval_nodes(t_ref[1], 1)
    return (base_ref[1] == v and v == _eval_nodes(ih_ref[1], 1)
            and incr_ref[1] == targ_ref[1] and claim[1] == ih_ref[1])


# ---------------------------------------------------------------------------
# Exponential-divisibility statements — the divisibility-induction
# family's language: d | a^x - b^x, where d divides a - b. Forms:
#
#   ("xdivh", d, a, b)   assume d divides a^x - b^x       (the IH)
#   ("xdivs", d, a, b)   d divides a^(x+1) - b^(x+1)
#   ("xconcl", d, a, b)  d divides a^x - b^x for all x >= 1
#   ("succid", a, b)     the successor identity
#                        a^(x+1) - b^(x+1) = a·(a^x - b^x) + b^x·(a-b)
#   ("divides", d, m), ("int", n)  as in the divisibility family
#
# b = 1 renders without the trivial 1^x (a^x - 1); the parser enforces
# the identity's internal arithmetic, so a succid claim that parses is
# already a true identity for its (a, b).
# ---------------------------------------------------------------------------

_XDIVH = re.compile(r"^assume (\d+) divides (\d+)\^x - (?:1|(\d+)\^x)$")
_XDIVS = re.compile(r"^(\d+) divides (\d+)\^\(x\+1\) - (?:1|(\d+)\^\(x\+1\))$")
_XCONCL = re.compile(
    r"^(\d+) divides (\d+)\^x - (?:1|(\d+)\^x) for all x >= 1$")
_SUCCID1 = re.compile(
    r"^(\d+)\^\(x\+1\) - 1 = (\d+)·\((\d+)\^x - 1\) \+ (\d+)$")
_SUCCID2 = re.compile(
    r"^(\d+)\^\(x\+1\) - (\d+)\^\(x\+1\) = "
    r"(\d+)·\((\d+)\^x - (\d+)\^x\) \+ (\d+)\^x·(\d+)$")
_XDIVIDES = re.compile(r"^(\d+) divides (\d+)$")
_XINT = re.compile(r"^(\d+)$")


def _pow_diff(a, b, succ):
    e = "(x+1)" if succ else "x"
    tail = "1" if b == 1 else f"{b}^{e}"
    return f"{a}^{e} - {tail}"


def render_xind(node):
    kind = node[0]
    if kind == "xdivh":
        return f"assume {node[1]} divides {_pow_diff(node[2], node[3], False)}"
    if kind == "xdivs":
        return f"{node[1]} divides {_pow_diff(node[2], node[3], True)}"
    if kind == "xconcl":
        return (f"{node[1]} divides {_pow_diff(node[2], node[3], False)} "
                f"for all x >= 1")
    if kind == "succid":
        a, b = node[1], node[2]
        if b == 1:
            return f"{a}^(x+1) - 1 = {a}·({a}^x - 1) + {a - 1}"
        return (f"{a}^(x+1) - {b}^(x+1) = "
                f"{a}·({a}^x - {b}^x) + {b}^x·{a - b}")
    if kind == "divides":
        return f"{node[1]} divides {node[2]}"
    return str(node[1])


def parse_xind(text):
    """Parses an exponential-divisibility statement (round-trips)."""
    m = _XDIVH.match(text)
    if m:
        return ("xdivh", int(m.group(1)), int(m.group(2)),
                int(m.group(3)) if m.group(3) else 1)
    m = _SUCCID2.match(text)
    if m:
        a1, b1, a2, a3, b2, b3, c = (int(g) for g in m.groups())
        if not (a1 == a2 == a3 and b1 == b2 == b3 and b1 >= 2
                and c == a1 - b1):
            raise ValueError(f"inconsistent successor identity: {text!r}")
        return ("succid", a1, b1)
    m = _SUCCID1.match(text)
    if m:
        a1, a2, a3, c = (int(g) for g in m.groups())
        if not (a1 == a2 == a3 and c == a1 - 1):
            raise ValueError(f"inconsistent successor identity: {text!r}")
        return ("succid", a1, 1)
    m = _XCONCL.match(text)
    if m:
        return ("xconcl", int(m.group(1)), int(m.group(2)),
                int(m.group(3)) if m.group(3) else 1)
    m = _XDIVS.match(text)
    if m:
        return ("xdivs", int(m.group(1)), int(m.group(2)),
                int(m.group(3)) if m.group(3) else 1)
    m = _XDIVIDES.match(text)
    if m:
        return ("divides", int(m.group(1)), int(m.group(2)))
    m = _XINT.match(text)
    if m:
        return ("int", int(m.group(1)))
    raise ValueError(f"cannot parse exponential-divisibility statement "
                     f"{text!r}")


def check_base_divides(claim, prevs):
    """d divides a - b, from the cited base pair — the x = 1 case and
    the combination lemma in one line, verified by exact arithmetic."""
    a_ref, b_ref = prevs
    if claim[0] != "divides" or a_ref[0] != "int" or b_ref[0] != "int":
        return False
    d, m = claim[1], claim[2]
    return m == a_ref[1] - b_ref[1] and d >= 2 and m >= 2 and m % d == 0


def check_successor_identity(claim, prevs):
    """The identity a^(x+1) - b^(x+1) = a(a^x - b^x) + b^x(a - b),
    instantiated at the cited pair (its arithmetic is parser-enforced)."""
    a_ref, b_ref = prevs
    return (claim[0] == "succid" and a_ref[0] == "int" and b_ref[0] == "int"
            and claim[1] == a_ref[1] and claim[2] == b_ref[1])


def check_divisibility_combination(claim, prevs):
    """d | a^(x+1) - b^(x+1) from the IH, the successor identity and
    d | a - b: d divides both addends of the identity's right side."""
    ih, succ, div = prevs
    if claim[0] != "xdivs" or ih[0] != "xdivh" or succ[0] != "succid" \
            or div[0] != "divides":
        return False
    _, d, a, b = ih
    return (succ[1] == a and succ[2] == b and div[1] == d
            and div[2] == a - b and d >= 2 and (a - b) % d == 0
            and claim[1:] == (d, a, b))


def check_exponent_induction_conclusion(claim, prevs):
    """Discharge: the base line is d | a - b (the x = 1 instance,
    re-verified) and the step line is the derived successor claim."""
    ih, base, stp = prevs
    if claim[0] != "xconcl" or ih[0] != "xdivh" or base[0] != "divides" \
            or stp[0] != "xdivs":
        return False
    _, d, a, b = ih
    return (base[1] == d and base[2] == a - b and (a - b) % d == 0
            and stp[1:] == (d, a, b) and claim[1:] == (d, a, b))


# ---------------------------------------------------------------------------
# Inequality-induction statements — the program's first ordering claims:
# a^x >= g(x) for all x >= x0, with g linear. Forms:
#
#   ("igeh", a, g)        assume a^x >= <g>                      (the IH)
#   ("ibase", x0, v, w)   at x = x0: v >= w
#   ("powsucc", a)        a^(x+1) = a·a^x
#   ("iscale", a, nodes)  a·a^x >= a(<g>)
#   ("iexp", a, g, h)     a(<g>) = <h>          (h = a·g, expanded)
#   ("igap", h, g2, x0)   <h> >= <g2> whenever x >= x0
#   ("igesucc", a, g2)    a^(x+1) >= <g2>
#   ("iconcl", a, g, x0)  a^x >= <g> for all x >= x0
#   ("expr", nodes)       bare sum-language expression (premises)
#
# The gap lemma is what the threshold buys: h - g2 is linear with
# nonnegative slope, so verifying it at x0 verifies it for all x >= x0.
# ---------------------------------------------------------------------------

_IBASE_RE = re.compile(r"^at x = (\d+): (\d+) >= (-?\d+)$")
_POWSUCC_RE = re.compile(r"^(\d+)\^\(x\+1\) = (\d+)·(\d+)\^x$")
_IGEH_RE = re.compile(r"^assume (\d+)\^x >= (.+)$")
_ICONCL_RE = re.compile(r"^(\d+)\^x >= (.+) for all x >= (\d+)$")
_IGAP_RE = re.compile(r"^(.+) >= (.+) whenever x >= (\d+)$")
_IGESUCC_RE = re.compile(r"^(\d+)\^\(x\+1\) >= (.+)$")
_ISCALE_RE = re.compile(r"^(\d+)·(\d+)\^x >= (.+)$")


def render_ineq(node):
    kind = node[0]
    if kind == "igeh":
        return f"assume {node[1]}^x >= {render(node[2])}"
    if kind == "ibase":
        return f"at x = {node[1]}: {node[2]} >= {node[3]}"
    if kind == "powsucc":
        a = node[1]
        return f"{a}^(x+1) = {a}·{a}^x"
    if kind == "iscale":
        return f"{node[1]}·{node[1]}^x >= {render(node[2])}"
    if kind == "iexp":
        return f"{render([('group', node[1], node[2])])} = {render(node[3])}"
    if kind == "igap":
        return (f"{render(node[1])} >= {render(node[2])} "
                f"whenever x >= {node[3]}")
    if kind == "igesucc":
        return f"{node[1]}^(x+1) >= {render(node[2])}"
    if kind == "iconcl":
        return (f"{node[1]}^x >= {render(node[2])} "
                f"for all x >= {node[3]}")
    return render(node[1])


def parse_ineq(text):
    """Parses an inequality-induction statement (round-trips)."""
    m = _IGEH_RE.match(text)
    if m:
        return ("igeh", int(m.group(1)), parse(m.group(2)))
    m = _ICONCL_RE.match(text)
    if m:
        return ("iconcl", int(m.group(1)), parse(m.group(2)),
                int(m.group(3)))
    m = _IGAP_RE.match(text)
    if m:
        return ("igap", parse(m.group(1)), parse(m.group(2)),
                int(m.group(3)))
    m = _IBASE_RE.match(text)
    if m:
        return ("ibase", int(m.group(1)), int(m.group(2)), int(m.group(3)))
    m = _POWSUCC_RE.match(text)
    if m:
        a1, a2, a3 = (int(g) for g in m.groups())
        if not a1 == a2 == a3:
            raise ValueError(f"inconsistent power identity: {text!r}")
        return ("powsucc", a1)
    m = _IGESUCC_RE.match(text)
    if m:
        return ("igesucc", int(m.group(1)), parse(m.group(2)))
    m = _ISCALE_RE.match(text)
    if m:
        a1, a2 = int(m.group(1)), int(m.group(2))
        if a1 != a2:
            raise ValueError(f"inconsistent scaled power: {text!r}")
        return ("iscale", a1, parse(m.group(3)))
    if " = " in text:
        lhs, rhs = text.split(" = ", 1)
        left = parse(lhs)
        if len(left) != 1 or left[0][0] != "group":
            raise ValueError(f"expected a(<linear>) = <linear>: {text!r}")
        return ("iexp", left[0][1], left[0][2], parse(rhs))
    return ("expr", parse(text))


def _as_int(ref):
    """The integer a premise line carries, or None."""
    if ref[0] == "expr" and len(ref[1]) == 1 and ref[1][0][0] == "num":
        return ref[1][0][1]
    return None


def _linear_parts(nodes):
    """(c, d) for a canonical linear sum, or None if not one."""
    c = d = 0
    seen = set()
    for node in nodes:
        if node[0] == "term" and "term" not in seen:
            c = node[1]
        elif node[0] == "num" and "num" not in seen:
            d = node[1]
        else:
            return None
        seen.add(node[0])
    return (c, d)


def _shifted_linear(c, d):
    """Canonical nodes for g(x+1) = c·x + (c+d), zero constant dropped."""
    out = [("term", c)]
    if c + d:
        out.append(("num", c + d))
    return out


def check_exponential_base_case(claim, prevs):
    """a^x0 >= g(x0), evaluated exactly at the cited threshold."""
    a_ref, g_ref, x0_ref = prevs
    a, x0 = _as_int(a_ref), _as_int(x0_ref)
    if claim[0] != "ibase" or a is None or x0 is None or a < 2 or x0 < 1 \
            or g_ref[0] != "expr":
        return False
    parts = _linear_parts(g_ref[1])
    if parts is None:
        return False
    c, d = parts
    return claim[1:] == (x0, a ** x0, c * x0 + d) and a ** x0 >= c * x0 + d


def check_power_successor(claim, prevs):
    """The identity a^(x+1) = a·a^x for the cited base."""
    (a_ref,) = prevs
    a = _as_int(a_ref)
    return claim[0] == "powsucc" and a is not None and a >= 2 \
        and claim[1] == a


def check_scale_inequality(claim, prevs):
    """Scale the IH by the (positive) base: a·a^x >= a(g)."""
    a_ref, ih = prevs
    a = _as_int(a_ref)
    if claim[0] != "iscale" or ih[0] != "igeh" or a is None or a < 2 \
            or ih[1] != a:
        return False
    return claim[1] == a and claim[2] == [("group", a, ih[2])]


def check_expand_scaled(claim, prevs):
    """a(g) expanded: every coefficient of g scaled by a, exactly."""
    a_ref, g_ref = prevs
    a = _as_int(a_ref)
    if claim[0] != "iexp" or a is None or a < 2 or g_ref[0] != "expr" \
            or _linear_parts(g_ref[1]) is None:
        return False
    g = g_ref[1]
    expected = [(n[0], a * n[1]) + tuple(n[2:]) for n in g]
    return claim[1] == a and claim[2] == g and claim[3] == expected


def check_linear_gap(claim, prevs):
    """h >= g(x+1) for every x >= x0: their difference is linear with
    nonnegative slope, so checking it at x0 checks it forever after."""
    g_ref, x0_ref = prevs
    x0 = _as_int(x0_ref)
    if claim[0] != "igap" or g_ref[0] != "expr" or x0 is None or x0 < 1:
        return False
    parts = _linear_parts(g_ref[1])
    if parts is None:
        return False
    c, d = parts
    h, g2, x0c = claim[1], claim[2], claim[3]
    if x0c != x0 or g2 != _shifted_linear(c, d):
        return False
    h_parts = _linear_parts(h)
    if h_parts is None:
        return False
    p, q = h_parts[0] - c, h_parts[1] - (c + d)
    return p >= 0 and p * x0 + q >= 0


def check_inequality_chain(claim, prevs):
    """a^(x+1) = a·a^x >= a(g) = h >= g(x+1), links matched exactly."""
    powsucc, iscale, iexp, igap = prevs
    if claim[0] != "igesucc" or powsucc[0] != "powsucc" \
            or iscale[0] != "iscale" or iexp[0] != "iexp" \
            or igap[0] != "igap":
        return False
    a = powsucc[1]
    return (iscale[1] == a and iscale[2] == [("group", a, iexp[2])]
            and iexp[1] == a and igap[1] == iexp[3]
            and claim[1] == a and claim[2] == igap[2])


def check_inequality_induction_conclusion(claim, prevs):
    """Discharge: base re-verified at x0, and the successor claim's
    bound is exactly g(x+1) for the assumed g."""
    x0_ref, ih, base, succ = prevs
    x0 = _as_int(x0_ref)
    if claim[0] != "iconcl" or ih[0] != "igeh" or base[0] != "ibase" \
            or succ[0] != "igesucc" or x0 is None or x0 < 1:
        return False
    a, g = ih[1], ih[2]
    parts = _linear_parts(g)
    if parts is None:
        return False
    c, d = parts
    return (base[1:] == (x0, a ** x0, c * x0 + d)
            and a ** x0 >= c * x0 + d
            and succ[1] == a and succ[2] == _shifted_linear(c, d)
            and claim[1:] == (a, g, x0))


# ---------------------------------------------------------------------------
# Recurrence statements — the recurrence-induction family's language:
# a(x+1) = q·a(x) + r with a(1) given, closed form a(x) = A·q^(x-1) - s
# where r = s(q-1) and A = a(1) + s (all values positive integers by
# construction, so renderings carry no sign cases). Forms:
#
#   ("rec", q, r)          a(x+1) = q·a(x) + r         (premise)
#   ("a1", v)              a(1) = v                    (premise)
#   ("rech", A, q, s)      assume a(x) = A·q^(x-1) - s (the IH)
#   ("recbase", v)         at x = 1: a(1) = v
#   ("recsub", q, A, s, r) a(x+1) = q·(A·q^(x-1) - s) + r
#   ("recdist", A, q, w, r) a(x+1) = A·q^x - w + r     (w = q·s)
#   ("recsucc", A, q, s)   a(x+1) = A·q^x - s
#   ("recconcl", A, q, s)  a(x) = A·q^(x-1) - s for all x >= 1
# ---------------------------------------------------------------------------

_REC_RE = re.compile(r"^a\(x\+1\) = (\d+)·a\(x\) \+ (\d+)$")
_A1_RE = re.compile(r"^a\(1\) = (\d+)$")
_RECH_RE = re.compile(r"^assume a\(x\) = (\d+)·(\d+)\^\(x-1\) - (\d+)$")
_RECBASE_RE = re.compile(r"^at x = 1: a\(1\) = (\d+)$")
_RECSUB_RE = re.compile(
    r"^a\(x\+1\) = (\d+)·\((\d+)·(\d+)\^\(x-1\) - (\d+)\) \+ (\d+)$")
_RECDIST_RE = re.compile(r"^a\(x\+1\) = (\d+)·(\d+)\^x - (\d+) \+ (\d+)$")
_RECSUCC_RE = re.compile(r"^a\(x\+1\) = (\d+)·(\d+)\^x - (\d+)$")
_RECCONCL_RE = re.compile(
    r"^a\(x\) = (\d+)·(\d+)\^\(x-1\) - (\d+) for all x >= 1$")


def render_rec(node):
    kind = node[0]
    if kind == "rec":
        return f"a(x+1) = {node[1]}·a(x) + {node[2]}"
    if kind == "a1":
        return f"a(1) = {node[1]}"
    if kind == "rech":
        return f"assume a(x) = {node[1]}·{node[2]}^(x-1) - {node[3]}"
    if kind == "recbase":
        return f"at x = 1: a(1) = {node[1]}"
    if kind == "recsub":
        q, big, s, r = node[1], node[2], node[3], node[4]
        return f"a(x+1) = {q}·({big}·{q}^(x-1) - {s}) + {r}"
    if kind == "recdist":
        return f"a(x+1) = {node[1]}·{node[2]}^x - {node[3]} + {node[4]}"
    if kind == "recsucc":
        return f"a(x+1) = {node[1]}·{node[2]}^x - {node[3]}"
    return (f"a(x) = {node[1]}·{node[2]}^(x-1) - {node[3]} "
            f"for all x >= 1")


def parse_rec(text):
    """Parses a recurrence-induction statement (round-trips)."""
    m = _RECH_RE.match(text)
    if m:
        return ("rech",) + tuple(int(g) for g in m.groups())
    m = _RECCONCL_RE.match(text)
    if m:
        return ("recconcl",) + tuple(int(g) for g in m.groups())
    m = _RECBASE_RE.match(text)
    if m:
        return ("recbase", int(m.group(1)))
    m = _RECSUB_RE.match(text)
    if m:
        q1, big, q2, s, r = (int(g) for g in m.groups())
        if q1 != q2:
            raise ValueError(f"mismatched bases in substitution: {text!r}")
        return ("recsub", q1, big, s, r)
    m = _RECDIST_RE.match(text)
    if m:
        return ("recdist",) + tuple(int(g) for g in m.groups())
    m = _RECSUCC_RE.match(text)
    if m:
        return ("recsucc",) + tuple(int(g) for g in m.groups())
    m = _REC_RE.match(text)
    if m:
        return ("rec", int(m.group(1)), int(m.group(2)))
    m = _A1_RE.match(text)
    if m:
        return ("a1", int(m.group(1)))
    raise ValueError(f"cannot parse recurrence statement {text!r}")


def check_recurrence_base_case(claim, prevs):
    """a(1) equals the closed form at x = 1: A - s."""
    a1_ref, ih = prevs
    if claim[0] != "recbase" or a1_ref[0] != "a1" or ih[0] != "rech":
        return False
    _, big, q, s = ih
    return claim[1] == a1_ref[1] and a1_ref[1] == big - s and q >= 2


def check_apply_recurrence(claim, prevs):
    """Substitute the assumed closed form into the recurrence."""
    rec, ih = prevs
    if claim[0] != "recsub" or rec[0] != "rec" or ih[0] != "rech":
        return False
    q, r = rec[1], rec[2]
    _, big, q2, s = ih
    return q2 == q and q >= 2 and claim[1:] == (q, big, s, r)


def check_distribute_recurrence(claim, prevs):
    """Distribute q through the substituted form: q·A·q^(x-1) = A·q^x
    and q·s computed exactly."""
    (sub,) = prevs
    if claim[0] != "recdist" or sub[0] != "recsub":
        return False
    _, q, big, s, r = sub
    return claim[1:] == (big, q, q * s, r)


def check_combine_constants_recurrence(claim, prevs):
    """Combine the constants: -q·s + r = -s exactly (since r = s(q-1))."""
    (dist,) = prevs
    if claim[0] != "recsucc" or dist[0] != "recdist":
        return False
    _, big, q, w, r = dist
    s = w - r
    return s >= 1 and claim[1:] == (big, q, s)


def check_recurrence_conclusion(claim, prevs):
    """Discharge: base re-verified, r = s(q-1) re-verified, and the
    successor claim is the closed form at x + 1."""
    rec, a1_ref, ih, base, succ = prevs
    if claim[0] != "recconcl" or rec[0] != "rec" or a1_ref[0] != "a1" \
            or ih[0] != "rech" or base[0] != "recbase" \
            or succ[0] != "recsucc":
        return False
    q, r = rec[1], rec[2]
    _, big, q2, s = ih
    return (q2 == q and q >= 2 and s >= 1 and r == s * (q - 1)
            and base[1] == a1_ref[1] and a1_ref[1] == big - s
            and succ[1:] == (big, q, s) and claim[1:] == (big, q, s))


# ---------------------------------------------------------------------------
# Invariant-game statements — Phase 4's first language: a counter with
# additive moves, unreachability by a mod-m invariant or reachability
# by an explicit combination certificate. Forms:
#
#   ("start", v)          start = v                       (premise)
#   ("moves", deltas)     moves: +6, -9, +15              (premise)
#   ("target", t)         target = t                      (premise)
#   ("movezero", d, m)    move +6 ≡ 0 (mod 3)
#   ("invariant", m)      value mod 3 is invariant under every move
#   ("vres", v, r, m)     7 ≡ 1 (mod 3)
#   ("walk", pairs, tot)  3·(+6) + 2·(-9) = 0   (pairs of (count, delta))
#   ("unreach", t) / ("reach", t)   the target t is (un)reachable
# ---------------------------------------------------------------------------

_INV_START = re.compile(r"^start = (\d+)$")
_INV_TARGET = re.compile(r"^target = (\d+)$")
_INV_MOVES = re.compile(r"^moves: ([+-]\d+(?:, [+-]\d+)*)$")
_INV_MOVEZERO = re.compile(r"^move ([+-]\d+) ≡ 0 \(mod (\d+)\)$")
_INV_INVARIANT = re.compile(
    r"^value mod (\d+) is invariant under every move$")
_INV_VRES = re.compile(r"^(\d+) ≡ (\d+) \(mod (\d+)\)$")
_INV_WALK = re.compile(
    r"^(\d+·\([+-]\d+\)(?: \+ \d+·\([+-]\d+\))*) = (-?\d+)$")
_INV_WALK_PAIR = re.compile(r"(\d+)·\(([+-]\d+)\)")
_INV_VERDICT = re.compile(r"^the target (\d+) is (un)?reachable$")


def render_inv(node):
    kind = node[0]
    if kind == "start":
        return f"start = {node[1]}"
    if kind == "target":
        return f"target = {node[1]}"
    if kind == "moves":
        return "moves: " + ", ".join(f"{d:+d}" for d in node[1])
    if kind == "movezero":
        return f"move {node[1]:+d} ≡ 0 (mod {node[2]})"
    if kind == "invariant":
        return f"value mod {node[1]} is invariant under every move"
    if kind == "vres":
        return f"{node[1]} ≡ {node[2]} (mod {node[3]})"
    if kind == "walk":
        body = " + ".join(f"{c}·({d:+d})" for c, d in node[1])
        return f"{body} = {node[2]}"
    if kind == "unreach":
        return f"the target {node[1]} is unreachable"
    return f"the target {node[1]} is reachable"


def parse_inv(text):
    """Parses an invariant-game statement (round-trips)."""
    m = _INV_START.match(text)
    if m:
        return ("start", int(m.group(1)))
    m = _INV_TARGET.match(text)
    if m:
        return ("target", int(m.group(1)))
    m = _INV_MOVES.match(text)
    if m:
        return ("moves", tuple(int(d) for d in m.group(1).split(", ")))
    m = _INV_MOVEZERO.match(text)
    if m:
        return ("movezero", int(m.group(1)), int(m.group(2)))
    m = _INV_INVARIANT.match(text)
    if m:
        return ("invariant", int(m.group(1)))
    m = _INV_VRES.match(text)
    if m:
        return ("vres", int(m.group(1)), int(m.group(2)), int(m.group(3)))
    m = _INV_WALK.match(text)
    if m:
        pairs = tuple((int(c), int(d))
                      for c, d in _INV_WALK_PAIR.findall(m.group(1)))
        return ("walk", pairs, int(m.group(2)))
    m = _INV_VERDICT.match(text)
    if m:
        return ("unreach" if m.group(2) else "reach", int(m.group(1)))
    raise ValueError(f"cannot parse invariant-game statement {text!r}")


def check_move_residue(claim, prevs):
    """One allowed move's delta is ≡ 0 mod m, verified exactly."""
    (ref,) = prevs
    return (claim[0] == "movezero" and ref[0] == "moves"
            and claim[1] in ref[1] and claim[2] >= 2
            and claim[1] % claim[2] == 0)


def check_invariant_from_moves(claim, prevs):
    """The residue mod m is invariant: every move in the cited premise
    is covered by a cited ≡ 0 line, each re-verified."""
    moves = prevs[0]
    if claim[0] != "invariant" or moves[0] != "moves" or claim[1] < 2:
        return False
    m = claim[1]
    seen = set()
    for prev in prevs[1:]:
        if prev[0] != "movezero" or prev[2] != m or prev[1] % m != 0:
            return False
        seen.add(prev[1])
    return len(prevs) > 1 and set(moves[1]) <= seen


def check_reduce_value(claim, prevs):
    """The cited start or target value reduced mod m, exactly."""
    (ref,) = prevs
    if claim[0] != "vres" or ref[0] not in ("start", "target"):
        return False
    v, r, m = claim[1], claim[2], claim[3]
    return v == ref[1] and m >= 2 and r == v % m


def check_invariant_unreachability(claim, prevs):
    """Unreachable: the invariant holds and the start and target
    residues differ (both re-verified against the cited premises)."""
    start, target, inv, sres, tres = prevs
    if claim[0] != "unreach" or start[0] != "start" \
            or target[0] != "target" or inv[0] != "invariant" \
            or sres[0] != "vres" or tres[0] != "vres":
        return False
    m = inv[1]
    return (sres[1] == start[1] and tres[1] == target[1]
            and sres[3] == m and tres[3] == m
            and sres[2] == start[1] % m and tres[2] == target[1] % m
            and sres[2] != tres[2] and claim[1] == target[1])


def check_move_combination(claim, prevs):
    """An explicit combination of allowed moves and its exact total."""
    (ref,) = prevs
    if claim[0] != "walk" or ref[0] != "moves" or not claim[1]:
        return False
    return (all(c >= 1 and d in ref[1] for c, d in claim[1])
            and claim[2] == sum(c * d for c, d in claim[1]))


def check_reachability_conclusion(claim, prevs):
    """Reachable: the cited combination carries start exactly to target."""
    start, target, walk = prevs
    if claim[0] != "reach" or start[0] != "start" \
            or target[0] != "target" or walk[0] != "walk":
        return False
    return target[1] == start[1] + walk[2] and claim[1] == target[1]


# ---------------------------------------------------------------------------
# Termination statements — Phase 4's monovariant language: a two-color
# token game whose moves may add tokens, proved terminating by an
# exhibited potential Φ = a·red + b·green that every move strictly
# decreases. Forms:
#
#   ("tstart", r, g)      start: 5 red, 7 green            (premise)
#   ("tmoves", pairs)     moves: (-2 red, +1 green); ...   (premise)
#   ("weights", a, b)     assign weight a to each red and b to each green
#   ("mdrop", dr, dg, k)  move (dr red, dg green) decreases the potential
#                         by k
#   ("monov",)            the potential strictly decreases on every move
#   ("phi0", v)           the initial potential is v
#   ("halt", n)           the game ends within n moves
# ---------------------------------------------------------------------------

_T_START = re.compile(r"^start: (\d+) red, (\d+) green$")
_T_MOVES = re.compile(
    r"^moves: (\([+-]\d+ red, [+-]\d+ green\)"
    r"(?:; \([+-]\d+ red, [+-]\d+ green\))*)$")
_T_MOVE_PAIR = re.compile(r"\(([+-]\d+) red, ([+-]\d+) green\)")
_T_WEIGHTS = re.compile(
    r"^assign weight (\d+) to each red and (\d+) to each green$")
_T_MDROP = re.compile(r"^move \(([+-]\d+) red, ([+-]\d+) green\) "
                      r"decreases the potential by (\d+)$")
_T_MONOV = "the potential strictly decreases on every move"
_T_PHI0 = re.compile(r"^the initial potential is (\d+)$")
_T_HALT = re.compile(r"^the game ends within (\d+) moves$")


def render_term(node):
    kind = node[0]
    if kind == "tstart":
        return f"start: {node[1]} red, {node[2]} green"
    if kind == "tmoves":
        return "moves: " + "; ".join(f"({dr:+d} red, {dg:+d} green)"
                                     for dr, dg in node[1])
    if kind == "weights":
        return (f"assign weight {node[1]} to each red and {node[2]} "
                f"to each green")
    if kind == "mdrop":
        return (f"move ({node[1]:+d} red, {node[2]:+d} green) decreases "
                f"the potential by {node[3]}")
    if kind == "monov":
        return _T_MONOV
    if kind == "phi0":
        return f"the initial potential is {node[1]}"
    return f"the game ends within {node[1]} moves"


def parse_term(text):
    """Parses a termination statement (round-trips)."""
    m = _T_START.match(text)
    if m:
        return ("tstart", int(m.group(1)), int(m.group(2)))
    m = _T_MOVES.match(text)
    if m:
        return ("tmoves", tuple((int(a), int(b)) for a, b
                                in _T_MOVE_PAIR.findall(m.group(1))))
    m = _T_WEIGHTS.match(text)
    if m:
        return ("weights", int(m.group(1)), int(m.group(2)))
    m = _T_MDROP.match(text)
    if m:
        return ("mdrop", int(m.group(1)), int(m.group(2)), int(m.group(3)))
    if text == _T_MONOV:
        return ("monov",)
    m = _T_PHI0.match(text)
    if m:
        return ("phi0", int(m.group(1)))
    m = _T_HALT.match(text)
    if m:
        return ("halt", int(m.group(1)))
    raise ValueError(f"cannot parse termination statement {text!r}")


def check_potential_weights(claim, prevs):
    """Exhibit positive integer weights for the potential."""
    (ref,) = prevs
    return (claim[0] == "weights" and ref[0] == "tmoves"
            and claim[1] >= 1 and claim[2] >= 1)


def check_move_decreases(claim, prevs):
    """One allowed move drops the potential by exactly k >= 1."""
    moves, w = prevs
    if claim[0] != "mdrop" or moves[0] != "tmoves" or w[0] != "weights":
        return False
    dr, dg, k = claim[1], claim[2], claim[3]
    return ((dr, dg) in moves[1] and k >= 1
            and k == -(w[1] * dr + w[2] * dg))


def check_monovariant(claim, prevs):
    """Every allowed move is covered by a re-verified decrease line."""
    moves, w = prevs[0], prevs[1]
    if claim[0] != "monov" or moves[0] != "tmoves" or w[0] != "weights" \
            or w[1] < 1 or w[2] < 1:
        return False
    seen = set()
    for prev in prevs[2:]:
        if prev[0] != "mdrop" or prev[3] < 1 \
                or prev[3] != -(w[1] * prev[1] + w[2] * prev[2]):
            return False
        seen.add((prev[1], prev[2]))
    return len(prevs) > 2 and set(moves[1]) <= seen


def check_initial_potential(claim, prevs):
    """The potential of the starting position, exactly."""
    start, w = prevs
    if claim[0] != "phi0" or start[0] != "tstart" or w[0] != "weights":
        return False
    return claim[1] == w[1] * start[1] + w[2] * start[2]


def check_termination_conclusion(claim, prevs):
    """Halt within the initial potential: a nonnegative integer that
    strictly decreases can only do so finitely often."""
    w, monov, phi0 = prevs
    if claim[0] != "halt" or w[0] != "weights" or monov[0] != "monov" \
            or phi0[0] != "phi0":
        return False
    return w[1] >= 1 and w[2] >= 1 and claim[1] == phi0[1]


# ---------------------------------------------------------------------------
# Graph statements — Phase 5's certificate language for generated
# graphs. Vertices are 1..n; edges are canonical (u, v) with u < v,
# listed in sorted order. Forms:
#
#   ("graph", n, edges)     graph on n vertices with edges 1-2, ...
#   ("coloring", colors)    coloring: 1→A, 2→B, ...   (per-vertex A/B)
#   ("edgecheck", u, v)     edge u-v joins the two color classes
#   ("bipartite",) / ("notbip",)   verdict lines
#   ("oddcyc", verts)       odd cycle: 1-3-5-1
#   ("spantree", pairs)     spanning tree: 2←1, 3←1, ...  (child←parent)
#   ("connected",) / ("tree",) / ("evendeg",) / ("eulerian",)
#   ("edgecount", m)        the graph has m edges
#   ("degree", v, d)        vertex v has degree d
# ---------------------------------------------------------------------------

_G_GRAPH = re.compile(
    r"^graph on (\d+) vertices with edges (\d+-\d+(?:, \d+-\d+)*)$")
_G_EDGE = re.compile(r"(\d+)-(\d+)")
_G_COLORING = re.compile(r"^coloring: (\d+→[AB](?:, \d+→[AB])*)$")
_G_COLOR_PAIR = re.compile(r"(\d+)→([AB])")
_G_EDGECHECK = re.compile(
    r"^edge (\d+)-(\d+) joins the two color classes$")
_G_ODDCYC = re.compile(r"^odd cycle: (\d+(?:-\d+)+)$")
_G_SPANTREE = re.compile(r"^spanning tree: (\d+←\d+(?:, \d+←\d+)*)$")
_G_ST_PAIR = re.compile(r"(\d+)←(\d+)")
_G_EDGECOUNT = re.compile(r"^the graph has (\d+) edges$")
_G_DEGREE = re.compile(r"^vertex (\d+) has degree (\d+)$")
_G_FIXED = {"the graph is bipartite": ("bipartite",),
            "the graph is not bipartite": ("notbip",),
            "the graph is connected": ("connected",),
            "the graph is a tree": ("tree",),
            "every vertex has even degree": ("evendeg",),
            "the graph has an Eulerian circuit": ("eulerian",)}
_G_FIXED_TEXT = {v: k for k, v in _G_FIXED.items()}


def render_graph(node):
    kind = node[0]
    if kind == "graph":
        edges = ", ".join(f"{u}-{v}" for u, v in node[2])
        return f"graph on {node[1]} vertices with edges {edges}"
    if kind == "coloring":
        return "coloring: " + ", ".join(
            f"{i}→{c}" for i, c in enumerate(node[1], start=1))
    if kind == "edgecheck":
        return f"edge {node[1]}-{node[2]} joins the two color classes"
    if kind == "oddcyc":
        return "odd cycle: " + "-".join(
            str(v) for v in node[1] + (node[1][0],))
    if kind == "spantree":
        return "spanning tree: " + ", ".join(f"{c}←{p}"
                                             for c, p in node[1])
    if kind == "edgecount":
        return f"the graph has {node[1]} edges"
    if kind == "degree":
        return f"vertex {node[1]} has degree {node[2]}"
    if kind == "vcover":
        return (f"the vertices {{{', '.join(str(v) for v in node[1])}}} "
                f"form a vertex cover")
    if kind == "indset":
        return (f"the vertices {{{', '.join(str(v) for v in node[1])}}} "
                f"form an independent set")
    if kind == "vcomp":
        return ("the independent set is exactly the complement of "
                "the cover")
    if kind == "vreduce":
        return (f"a vertex cover of size {node[1]} yields an "
                f"independent set of size {node[2]}: the reduction "
                f"maps yes-instances to yes-instances")
    return _G_FIXED_TEXT[node]


def parse_graph(text):
    """Parses a graph-certificate statement (round-trips)."""
    if text in _G_FIXED:
        return _G_FIXED[text]
    m = _G_GRAPH.match(text)
    if m:
        edges = tuple((int(u), int(v))
                      for u, v in _G_EDGE.findall(m.group(2)))
        return ("graph", int(m.group(1)), edges)
    m = _G_COLORING.match(text)
    if m:
        pairs = _G_COLOR_PAIR.findall(m.group(1))
        if [int(i) for i, _ in pairs] != list(range(1, len(pairs) + 1)):
            raise ValueError(f"coloring must list vertices 1..n: {text!r}")
        return ("coloring", tuple(c for _, c in pairs))
    m = _G_EDGECHECK.match(text)
    if m:
        return ("edgecheck", int(m.group(1)), int(m.group(2)))
    m = _G_ODDCYC.match(text)
    if m:
        verts = [int(v) for v in m.group(1).split("-")]
        if verts[0] != verts[-1]:
            raise ValueError(f"cycle must close: {text!r}")
        return ("oddcyc", tuple(verts[:-1]))
    m = _G_SPANTREE.match(text)
    if m:
        return ("spantree", tuple((int(c), int(p)) for c, p
                                  in _G_ST_PAIR.findall(m.group(1))))
    m = _G_EDGECOUNT.match(text)
    if m:
        return ("edgecount", int(m.group(1)))
    m = _G_DEGREE.match(text)
    if m:
        return ("degree", int(m.group(1)), int(m.group(2)))
    if text == "the independent set is exactly the complement of the cover":
        return ("vcomp",)
    m = _G_VCOVER.match(text)
    if m:
        return ("vcover", tuple(int(v) for v in m.group(1).split(", ")))
    m = _G_INDSET.match(text)
    if m:
        return ("indset", tuple(int(v) for v in m.group(1).split(", ")))
    m = _G_VREDUCE.match(text)
    if m:
        return ("vreduce", int(m.group(1)), int(m.group(2)))
    raise ValueError(f"cannot parse graph statement {text!r}")


_G_VCOVER = re.compile(r"^the vertices \{(\d+(?:, \d+)*)\} form a "
                       r"vertex cover$")
_G_INDSET = re.compile(r"^the vertices \{(\d+(?:, \d+)*)\} form an "
                       r"independent set$")
_G_VCOMP = re.compile(r"^the independent set is exactly the complement "
                      r"of the cover$")
_G_VREDUCE = re.compile(r"^a vertex cover of size (\d+) yields an "
                        r"independent set of size (\d+): the reduction "
                        r"maps yes-instances to yes-instances$")


def check_vertex_cover(claim, prevs):
    """Every edge has an endpoint in the claimed set."""
    (g,) = prevs
    if claim[0] != "vcover" or g[0] != "graph":
        return False
    s = set(claim[1])
    return (s <= set(range(1, g[1] + 1))
            and all(u in s or v in s for u, v in g[2]))


def check_independent_set(claim, prevs):
    """No edge joins two vertices of the claimed set."""
    (g,) = prevs
    if claim[0] != "indset" or g[0] != "graph":
        return False
    s = set(claim[1])
    return (s <= set(range(1, g[1] + 1))
            and all(u not in s or v not in s for u, v in g[2]))


def check_complement_transport(claim, prevs):
    """The independent set is the cover's complement — the reduction's
    translation, verified set-theoretically."""
    g, cover, ind = prevs
    if claim != ("vcomp",) or g[0] != "graph" or cover[0] != "vcover" \
            or ind[0] != "indset":
        return False
    universe = set(range(1, g[1] + 1))
    return set(cover[1]) | set(ind[1]) == universe \
        and not set(cover[1]) & set(ind[1])


def check_reduction_conclusion(claim, prevs):
    """Certificate transport: a size-k cover became a size-(n-k)
    independent set (both certificates and the translation
    re-verified)."""
    g, cover, ind, comp = prevs
    if claim[0] != "vreduce" or g[0] != "graph" or comp != ("vcomp",):
        return False
    if not (check_vertex_cover(cover, [g])
            and check_independent_set(ind, [g])
            and check_complement_transport(("vcomp",), [g, cover, ind])):
        return False
    return claim[1] == len(cover[1]) and claim[2] == len(ind[1]) \
        and claim[1] + claim[2] == g[1]


def check_two_coloring(claim, prevs):
    """A proposed A/B assignment covering every vertex."""
    (g,) = prevs
    return (claim[0] == "coloring" and g[0] == "graph"
            and len(claim[1]) == g[1]
            and all(c in ("A", "B") for c in claim[1]))


def check_edge_bicolored(claim, prevs):
    """One edge's endpoints get different colors under the cited map."""
    g, col = prevs
    if claim[0] != "edgecheck" or g[0] != "graph" or col[0] != "coloring":
        return False
    u, v = claim[1], claim[2]
    return ((u, v) in g[2] and len(col[1]) == g[1]
            and col[1][u - 1] != col[1][v - 1])


def check_bipartite_conclusion(claim, prevs):
    """Bipartite: the coloring bicolors every edge (all re-verified)."""
    g, col = prevs[0], prevs[1]
    if claim != ("bipartite",) or g[0] != "graph" or col[0] != "coloring" \
            or len(col[1]) != g[1] \
            or not all(c in ("A", "B") for c in col[1]):
        return False
    seen = set()
    for prev in prevs[2:]:
        if prev[0] != "edgecheck":
            return False
        u, v = prev[1], prev[2]
        if (u, v) not in g[2] or col[1][u - 1] == col[1][v - 1]:
            return False
        seen.add((u, v))
    return set(g[2]) <= seen


def check_odd_cycle(claim, prevs):
    """An odd-length cycle through distinct vertices along real edges."""
    (g,) = prevs
    if claim[0] != "oddcyc" or g[0] != "graph":
        return False
    verts = claim[1]
    if len(verts) < 3 or len(verts) % 2 == 0 \
            or len(set(verts)) != len(verts):
        return False
    edges = set(g[2])
    return all(tuple(sorted((verts[i], verts[(i + 1) % len(verts)])))
               in edges for i in range(len(verts)))


def check_not_bipartite_conclusion(claim, prevs):
    """Not bipartite: the cited odd cycle, fully re-verified."""
    g, cyc = prevs
    return claim == ("notbip",) and check_odd_cycle(cyc, [g])


def check_spanning_tree(claim, prevs):
    """A parent map rooted at 1: every other vertex once, every link a
    real edge, and the fixpoint from 1 reaches everyone."""
    (g,) = prevs
    if claim[0] != "spantree" or g[0] != "graph":
        return False
    n, edges = g[1], set(g[2])
    pairs = claim[1]
    if sorted(c for c, _ in pairs) != list(range(2, n + 1)):
        return False
    if any(tuple(sorted((c, p))) not in edges for c, p in pairs):
        return False
    reached, remaining = {1}, dict(pairs)
    changed = True
    while changed:
        changed = False
        for c, p in list(remaining.items()):
            if p in reached:
                reached.add(c)
                del remaining[c]
                changed = True
    return not remaining


def check_connected_conclusion(claim, prevs):
    """Connected: the cited spanning tree, fully re-verified."""
    g, st = prevs
    return claim == ("connected",) and check_spanning_tree(st, [g])


def check_count_edges(claim, prevs):
    (g,) = prevs
    return (claim[0] == "edgecount" and g[0] == "graph"
            and claim[1] == len(g[2]))


def check_tree_conclusion(claim, prevs):
    """A tree: connected with exactly n - 1 edges (count re-verified;
    the connectivity line's pedigree is enforced by ancestry)."""
    g, conn, cnt = prevs
    return (claim == ("tree",) and g[0] == "graph"
            and conn == ("connected",) and cnt[0] == "edgecount"
            and cnt[1] == len(g[2]) and cnt[1] == g[1] - 1)


def check_vertex_degree(claim, prevs):
    (g,) = prevs
    if claim[0] != "degree" or g[0] != "graph":
        return False
    v, d = claim[1], claim[2]
    return (1 <= v <= g[1]
            and d == sum(1 for u, w in g[2] if v in (u, w)))


def check_all_degrees_even(claim, prevs):
    """Every vertex covered by a re-verified even-degree line."""
    g = prevs[0]
    if claim != ("evendeg",) or g[0] != "graph":
        return False
    seen = set()
    for prev in prevs[1:]:
        if prev[0] != "degree" or prev[2] % 2 \
                or prev[2] != sum(1 for u, w in g[2] if prev[1] in (u, w)):
            return False
        seen.add(prev[1])
    return seen >= set(range(1, g[1] + 1))


def check_eulerian_conclusion(claim, prevs):
    """Euler's theorem: connected with all degrees even (both cited
    lines' pedigrees enforced by ancestry)."""
    g, conn, ev = prevs
    return (claim == ("eulerian",) and g[0] == "graph" and len(g[2]) >= 1
            and conn == ("connected",) and ev == ("evendeg",))


# ---------------------------------------------------------------------------
# Quadratic-inequality statements — Phase 5's composition language:
# universally valid inequalities between quadratics in x, built from
# axiom-instance atoms. A side is a coefficient triple (a2, a1, a0);
# rendering rides the sum language's canonical renderer. Forms:
#
#   ("real",)             x is real           (the quantifier premise)
#   ("qineq", L, R)       <quad> >= <quad>    (valid for every real x)
# ---------------------------------------------------------------------------


def _qnodes(t):
    a2, a1, a0 = t
    nodes = []
    if a2:
        nodes.append(("pterm", a2, 2))
    if a1:
        nodes.append(("term", a1))
    if a0:
        nodes.append(("num", a0))
    return nodes or [("num", 0)]


def _qtriple(nodes):
    """Coefficient triple for a canonical quadratic node list."""
    a2 = a1 = a0 = 0
    degrees = []
    for n in nodes:
        if n[0] == "pterm" and n[2] == 2:
            a2 = n[1]
            degrees.append(2)
        elif n[0] == "term":
            a1 = n[1]
            degrees.append(1)
        elif n[0] == "num":
            a0 = n[1]
            degrees.append(0)
        else:
            raise ValueError("quadratic sides only")
    if degrees != sorted(degrees, reverse=True) \
            or len(degrees) != len(set(degrees)):
        raise ValueError("non-canonical quadratic")
    if list(nodes) != [("num", 0)] and 0 in degrees and a0 == 0:
        raise ValueError("zero terms must be dropped")
    return (a2, a1, a0)


def render_qineq(node):
    if node == ("real",):
        return "x is real"
    return f"{render(_qnodes(node[1]))} >= {render(_qnodes(node[2]))}"


def parse_qineq(text):
    """Parses a quadratic-inequality statement (round-trips)."""
    if text == "x is real":
        return ("real",)
    if " >= " not in text:
        raise ValueError(f"cannot parse inequality statement {text!r}")
    lhs, rhs = text.split(" >= ", 1)
    return ("qineq", _qtriple(parse(lhs)), _qtriple(parse(rhs)))


def check_amgm_instance(claim, prevs):
    """a²x² + c² >= 2acx — an AM-GM instance, i.e. (ax - c)² >= 0."""
    (ref,) = prevs
    if claim[0] != "qineq" or ref != ("real",):
        return False
    (A, z1, C), (z2, B, z3) = claim[1], claim[2]
    return (z1 == z2 == z3 == 0 and A >= 1 and C >= 1
            and _is_square(A) and _is_square(C)
            and B == 2 * isqrt(A) * isqrt(C))


def check_square_nonneg(claim, prevs):
    """p²x² + 2pqx + q² >= 0 — a perfect square is nonnegative."""
    (ref,) = prevs
    if claim[0] != "qineq" or ref != ("real",) or claim[2] != (0, 0, 0):
        return False
    a2, a1, a0 = claim[1]
    if not (_is_square(a2) and _is_square(a0)) or not (a2 or a0):
        return False
    p, q_mag = isqrt(a2), isqrt(a0)
    return a1 in (2 * p * q_mag, -2 * p * q_mag)


def check_add_inequalities(claim, prevs):
    """Add two inequalities side by side, coefficientwise."""
    x, y = prevs
    if claim[0] != "qineq" or x[0] != "qineq" or y[0] != "qineq":
        return False
    return (claim[1] == tuple(a + b for a, b in zip(x[1], y[1]))
            and claim[2] == tuple(a + b for a, b in zip(x[2], y[2])))


def check_scale_positive(claim, prevs):
    """Multiply both sides by one integer k >= 2."""
    (ref,) = prevs
    if claim[0] != "qineq" or ref[0] != "qineq":
        return False
    base = ref[1] + ref[2]
    scaled = claim[1] + claim[2]
    ks = {s // b for s, b in zip(scaled, base) if b}
    if len(ks) != 1:
        return False
    k = ks.pop()
    return k >= 2 and all(s == k * b for s, b in zip(scaled, base))


def check_weaken_constant(claim, prevs):
    """Lower the right side's constant: L >= R implies L >= R - c."""
    (ref,) = prevs
    if claim[0] != "qineq" or ref[0] != "qineq" or claim[1] != ref[1]:
        return False
    return claim[2][:2] == ref[2][:2] and claim[2][2] < ref[2][2]


def _is_square(n):
    return n >= 0 and isqrt(n) ** 2 == n


# ---------------------------------------------------------------------------
# Exact-trig statements — Phase 5g's surd language. A value is a surd
# quintuple (a, b, c, d, e) meaning (a + b√2 + c√3 + d√6)/e, closed
# under + and · with exact integer arithmetic and a canonical normal
# form (e >= 1, gcd of all five = 1). Forms:
#
#   ("subject", fn, θ)          sin 75°               (premise)
#   ("asplit", θ, α, β, op)     75° = 45° + 30°
#   ("trigexp", fn, θ, α, β, op)  the addition-formula line
#   ("tval", fn, angle, surd)   sin 45° = √2/2   (known value or result)
# ---------------------------------------------------------------------------

_KNOWN_ANGLES = (0, 30, 45, 60, 90)
_KNOWN_TRIG = {
    ("sin", 0): (0, 0, 0, 0, 1), ("sin", 30): (1, 0, 0, 0, 2),
    ("sin", 45): (0, 1, 0, 0, 2), ("sin", 60): (0, 0, 1, 0, 2),
    ("sin", 90): (1, 0, 0, 0, 1),
    ("cos", 0): (1, 0, 0, 0, 1), ("cos", 30): (0, 0, 1, 0, 2),
    ("cos", 45): (0, 1, 0, 0, 2), ("cos", 60): (1, 0, 0, 0, 2),
    ("cos", 90): (0, 0, 0, 0, 1),
}


def _surd_norm(s):
    a, b, c, d, e = s
    if e < 0:
        a, b, c, d, e = -a, -b, -c, -d, -e
    g = gcd(gcd(gcd(abs(a), abs(b)), gcd(abs(c), abs(d))), e)
    if g > 1:
        a, b, c, d, e = a // g, b // g, c // g, d // g, e // g
    if (a, b, c, d) == (0, 0, 0, 0):
        e = 1
    return (a, b, c, d, e)


def _surd_add(x, y):
    a1, b1, c1, d1, e1 = x
    a2, b2, c2, d2, e2 = y
    return _surd_norm((a1 * e2 + a2 * e1, b1 * e2 + b2 * e1,
                       c1 * e2 + c2 * e1, d1 * e2 + d2 * e1, e1 * e2))


def _surd_mul(x, y):
    a1, b1, c1, d1, e1 = x
    a2, b2, c2, d2, e2 = y
    return _surd_norm((
        a1 * a2 + 2 * b1 * b2 + 3 * c1 * c2 + 6 * d1 * d2,
        a1 * b2 + b1 * a2 + 3 * (c1 * d2 + d1 * c2),
        a1 * c2 + c1 * a2 + 2 * (b1 * d2 + d1 * b2),
        a1 * d2 + d1 * a2 + b1 * c2 + c1 * b2,
        e1 * e2))


def _surd_neg(x):
    return (-x[0], -x[1], -x[2], -x[3], x[4])


def render_surd(s):
    a, b, c, d, e = s
    parts = []
    for coef, rad in ((d, 6), (c, 3), (b, 2)):
        if coef:
            mag = "" if abs(coef) == 1 else str(abs(coef))
            parts.append((coef < 0, f"{mag}√{rad}"))
    if a:
        parts.append((a < 0, str(abs(a))))
    if not parts:
        return "0"
    body = ("-" if parts[0][0] else "") + parts[0][1]
    for neg, text in parts[1:]:
        body += (" - " if neg else " + ") + text
    if e == 1:
        return body
    return f"({body})/{e}" if len(parts) > 1 else f"{body}/{e}"


_SURD_TERM = re.compile(r"^(\d+)?√([236])$|^(\d+)$")


def parse_surd(text):
    e = 1
    m = re.match(r"^\((.+)\)/(\d+)$", text)
    if not m:
        m = re.match(r"^(-?(?:\d+)?(?:√[236])?(?:\d+)?)/(\d+)$", text)
    if m:
        body, e = m.group(1), int(m.group(2))
    else:
        body = text
    if body == "0":
        return (0, 0, 0, 0, 1)
    tokens = re.split(r" ([+-]) ", body)
    signs = [-1 if body.startswith("-") else 1]
    terms = [tokens[0].lstrip("-")]
    for i in range(1, len(tokens), 2):
        signs.append(-1 if tokens[i] == "-" else 1)
        terms.append(tokens[i + 1])
    a = b = c = d = 0
    for sign, term in zip(signs, terms):
        m = _SURD_TERM.match(term)
        if not m:
            raise ValueError(f"cannot parse surd term {term!r}")
        if m.group(3) is not None:
            a += sign * int(m.group(3))
        else:
            coef = sign * (int(m.group(1)) if m.group(1) else 1)
            rad = int(m.group(2))
            if rad == 2:
                b += coef
            elif rad == 3:
                c += coef
            else:
                d += coef
    return (a, b, c, d, e)


_TRIG_SUBJECT = re.compile(r"^(sin|cos) (\d+)°$")
_TRIG_SPLIT = re.compile(r"^(\d+)° = (\d+)° ([+-]) (\d+)°$")
_TRIG_EXP = re.compile(
    r"^(sin|cos) (\d+)° = (sin|cos) (\d+)°·(sin|cos) (\d+)° ([+-]) "
    r"(sin|cos) (\d+)°·(sin|cos) (\d+)°$")
_TRIG_REL = re.compile(r"^(sin|cos) (\d+)° = (-?)(sin|cos) (\d+)°$")
_TRIG_PYID = re.compile(r"^sin²(\d+)° \+ cos²(\d+)° = 1$")
_TRIG_VAL = re.compile(r"^(sin|cos) (\d+)° = (.+)$")


def render_trig(node):
    kind = node[0]
    if kind == "subject":
        return f"{node[1]} {node[2]}°"
    if kind == "asplit":
        return f"{node[1]}° = {node[2]}° {node[4]} {node[3]}°"
    if kind == "trigexp":
        fn, th, al, be, op = node[1:]
        if fn == "sin":
            mid = op
            return (f"sin {th}° = sin {al}°·cos {be}° {mid} "
                    f"cos {al}°·sin {be}°")
        mid = "-" if op == "+" else "+"
        return (f"cos {th}° = cos {al}°·cos {be}° {mid} "
                f"sin {al}°·sin {be}°")
    if kind == "trigrel":
        fn, th, sign, fn2, thr = node[1:]
        neg = "-" if sign == "-" else ""
        return f"{fn} {th}° = {neg}{fn2} {thr}°"
    if kind == "pyid":
        return f"sin²{node[1]}° + cos²{node[1]}° = 1"
    return f"{node[1]} {node[2]}° = {render_surd(node[3])}"


def parse_trig(text):
    """Parses an exact-trig statement (round-trips)."""
    m = _TRIG_EXP.match(text)
    if m:
        g = m.groups()
        fn, th, op = g[0], int(g[1]), g[6]
        al, be = int(g[3]), int(g[5])
        if fn == "sin":
            ok = (g[2], g[4], g[7], g[9]) == ("sin", "cos", "cos", "sin") \
                and (int(g[8]), int(g[10])) == (al, be)
        else:
            ok = (g[2], g[4], g[7], g[9]) == ("cos", "cos", "sin", "sin") \
                and (int(g[8]), int(g[10])) == (al, be)
            op = "-" if op == "+" else "+"
        if not ok:
            raise ValueError(f"malformed addition formula: {text!r}")
        return ("trigexp", fn, th, al, be, op)
    m = _TRIG_SPLIT.match(text)
    if m:
        return ("asplit", int(m.group(1)), int(m.group(2)),
                int(m.group(4)), m.group(3))
    m = _TRIG_PYID.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"mismatched identity angles: {text!r}")
        return ("pyid", int(m.group(1)))
    m = _TRIG_REL.match(text)
    if m:
        return ("trigrel", m.group(1), int(m.group(2)),
                "-" if m.group(3) else "+", m.group(4), int(m.group(5)))
    m = _TRIG_SUBJECT.match(text)
    if m:
        return ("subject", m.group(1), int(m.group(2)))
    m = _TRIG_VAL.match(text)
    if m:
        return ("tval", m.group(1), int(m.group(2)),
                parse_surd(m.group(3)))
    raise ValueError(f"cannot parse trig statement {text!r}")


def check_angle_split(claim, prevs):
    """An angle split into two known special angles (self-contained
    arithmetic; the split need not be the subject itself — reference
    and cofunction chains split the auxiliary angle)."""
    (ref,) = prevs
    if claim[0] != "asplit" or ref[0] != "subject":
        return False
    th, al, be, op = claim[1:]
    if al not in _KNOWN_ANGLES or be not in _KNOWN_ANGLES:
        return False
    return th == (al + be if op == "+" else al - be)


def check_sine_addition(claim, prevs):
    """sin(α ± β) expanded by the addition formula for the cited split."""
    (split,) = prevs
    return (claim[0] == "trigexp" and claim[1] == "sin"
            and split[0] == "asplit" and claim[2:5] == split[1:4]
            and claim[5] == split[4])


def check_cosine_addition(claim, prevs):
    """cos(α ± β) expanded by the addition formula for the cited split."""
    (split,) = prevs
    return (claim[0] == "trigexp" and claim[1] == "cos"
            and split[0] == "asplit" and claim[2:5] == split[1:4]
            and claim[5] == split[4])


def check_known_value(claim, prevs):
    """A table value: sin/cos of a special angle, exactly."""
    (ref,) = prevs
    return (claim[0] == "tval" and ref[0] == "subject"
            and (claim[1], claim[2]) in _KNOWN_TRIG
            and claim[3] == _KNOWN_TRIG[(claim[1], claim[2])])


def check_reference_angle(claim, prevs):
    """Relate a quadrant II/III/IV angle to its reference angle with
    the correct sign, per function."""
    (ref,) = prevs
    if claim[0] != "trigrel" or ref[0] != "subject":
        return False
    fn, th, sign, fn2, thr = claim[1:]
    if (fn, th) != (ref[1], ref[2]) or fn2 != fn or th % 90 == 0:
        return False
    if 91 <= th <= 179:
        want = (180 - th, "+" if fn == "sin" else "-")
    elif 181 <= th <= 269:
        want = (th - 180, "-")
    elif 271 <= th <= 359:
        want = (360 - th, "-" if fn == "sin" else "+")
    else:
        return False
    return (thr, sign) == want


def check_cofunction(claim, prevs):
    """sin θ = cos(90° - θ) and vice versa, for acute θ."""
    (ref,) = prevs
    if claim[0] != "trigrel" or ref[0] != "subject":
        return False
    fn, th, sign, fn2, thr = claim[1:]
    return ((fn, th) == (ref[1], ref[2]) and fn2 != fn and sign == "+"
            and 1 <= th <= 89 and thr == 90 - th)


def check_evaluate_relation(claim, prevs):
    """Push an exact value through a cited reference/cofunction
    relation, negating exactly when the relation says so."""
    rel, val = prevs
    if claim[0] != "tval" or rel[0] != "trigrel" or val[0] != "tval":
        return False
    fn, th, sign, fn2, thr = rel[1:]
    if (val[1], val[2]) != (fn2, thr) or (claim[1], claim[2]) != (fn, th):
        return False
    expected = val[3] if sign == "+" else _surd_neg(val[3])
    return claim[3] == expected


def check_pythagorean_identity(claim, prevs):
    """sin²θ + cos²θ = 1, verified by exact surd arithmetic on the two
    cited derived values."""
    s, c = prevs
    if claim[0] != "pyid" or s[0] != "tval" or c[0] != "tval":
        return False
    th = claim[1]
    if (s[1], s[2]) != ("sin", th) or (c[1], c[2]) != ("cos", th):
        return False
    total = _surd_add(_surd_mul(s[3], s[3]), _surd_mul(c[3], c[3]))
    return total == (1, 0, 0, 0, 1)


def check_combine_products(claim, prevs):
    """Substitute the four cited known values into the cited formula
    and combine with exact surd arithmetic."""
    exp = prevs[0]
    ks = prevs[1:]
    if claim[0] != "tval" or exp[0] != "trigexp" or len(ks) != 4:
        return False
    for k in ks:
        if k[0] != "tval" or (k[1], k[2]) not in _KNOWN_TRIG \
                or k[3] != _KNOWN_TRIG[(k[1], k[2])]:
            return False
    fn, th, al, be, op = exp[1:]
    if fn == "sin":
        roles = (("sin", al), ("cos", be), ("cos", al), ("sin", be))
        sign = 1 if op == "+" else -1
    else:
        roles = (("cos", al), ("cos", be), ("sin", al), ("sin", be))
        sign = -1 if op == "+" else 1
    if [(k[1], k[2]) for k in ks] != list(roles):
        return False
    p1 = _surd_mul(ks[0][3], ks[1][3])
    p2 = _surd_mul(ks[2][3], ks[3][3])
    total = _surd_add(p1, p2 if sign > 0 else _surd_neg(p2))
    return claim[1] == fn and claim[2] == th and claim[3] == total


# ---------------------------------------------------------------------------
# Angle-chase statements — Phase 5g's geometry language. Angles are
# first-class atoms (∠a .. ∠l); a configuration is a set of relation
# facts, and proofs are value-propagation chains. Forms:
#
#   ("aval", x, v)      ∠x = 40°
#   ("tri", x, y, z)    ∠x, ∠y, ∠z are the angles of a triangle
#   ("line", x, y)      ∠x and ∠y lie on a straight line
#   ("vert", x, y)      ∠x and ∠y are vertical angles
#   ("alt", x, y)       ∠x and ∠y are alternate angles at parallel lines
#   ("corr", x, y)      ∠x and ∠y are corresponding angles at parallel
#                       lines
#   ("iso", x, y)       ∠x and ∠y are base angles of an isosceles
#                       triangle
#   ("ext", x, y, z)    ∠x is an exterior angle of the triangle with
#                       remote interior angles ∠y and ∠z
# ---------------------------------------------------------------------------

_ANG_VAL = re.compile(r"^∠([a-l]) = (\d+)°$")
_ANG_TRI = re.compile(
    r"^∠([a-l]), ∠([a-l]), ∠([a-l]) are the angles of a triangle$")
_ANG_PAIR = re.compile(r"^∠([a-l]) and ∠([a-l]) (.+)$")
_ANG_EXT = re.compile(
    r"^∠([a-l]) is an exterior angle of the triangle with remote "
    r"interior angles ∠([a-l]) and ∠([a-l])$")
_ANG_PAIR_KINDS = {"lie on a straight line": "line",
                   "are vertical angles": "vert",
                   "are alternate angles at parallel lines": "alt",
                   "are corresponding angles at parallel lines": "corr",
                   "are base angles of an isosceles triangle": "iso",
                   "are complementary": "comp",
                   "are co-interior angles at parallel lines": "coint",
                   "are opposite angles of a cyclic quadrilateral": "cyc"}
_ANG_PAIR_TEXT = {v: k for k, v in _ANG_PAIR_KINDS.items()}
_ANG_POINT = re.compile(
    r"^(∠[a-l](?:, ∠[a-l])+) form a full turn about a point$")
_ANG_POLY = re.compile(r"^(∠[a-l](?:, ∠[a-l])+) are the interior angles "
                       r"of a (quadrilateral|pentagon|hexagon)$")
_POLY_WORD = {4: "quadrilateral", 5: "pentagon", 6: "hexagon"}
_POLY_SIDES = {v: k for k, v in _POLY_WORD.items()}
_ANG_NAME = re.compile(r"∠([a-l])")
_ANG_INSC = re.compile(r"^∠([a-l]) is the central angle and ∠([a-l]) the "
                       r"inscribed angle on the same arc$")


def render_angle(node):
    kind = node[0]
    if kind == "aval":
        return f"∠{node[1]} = {node[2]}°"
    if kind == "tri":
        return (f"∠{node[1]}, ∠{node[2]}, ∠{node[3]} are the angles "
                f"of a triangle")
    if kind == "ext":
        return (f"∠{node[1]} is an exterior angle of the triangle with "
                f"remote interior angles ∠{node[2]} and ∠{node[3]}")
    if kind == "point":
        names = ", ".join(f"∠{n}" for n in node[1])
        return f"{names} form a full turn about a point"
    if kind == "poly":
        names = ", ".join(f"∠{n}" for n in node[1])
        return (f"{names} are the interior angles of a "
                f"{_POLY_WORD[len(node[1])]}")
    if kind == "insc":
        return (f"∠{node[1]} is the central angle and ∠{node[2]} the "
                f"inscribed angle on the same arc")
    return f"∠{node[1]} and ∠{node[2]} {_ANG_PAIR_TEXT[kind]}"


def parse_angle(text):
    """Parses an angle-chase statement (round-trips)."""
    m = _ANG_VAL.match(text)
    if m:
        return ("aval", m.group(1), int(m.group(2)))
    m = _ANG_TRI.match(text)
    if m:
        return ("tri",) + m.groups()
    m = _ANG_EXT.match(text)
    if m:
        return ("ext",) + m.groups()
    m = _ANG_POINT.match(text)
    if m:
        return ("point", tuple(_ANG_NAME.findall(m.group(1))))
    m = _ANG_POLY.match(text)
    if m:
        names = tuple(_ANG_NAME.findall(m.group(1)))
        if len(names) != _POLY_SIDES[m.group(2)]:
            raise ValueError(f"polygon name count mismatch: {text!r}")
        return ("poly", names)
    m = _ANG_INSC.match(text)
    if m:
        return ("insc", m.group(1), m.group(2))
    m = _ANG_PAIR.match(text)
    if m and m.group(3) in _ANG_PAIR_KINDS:
        return (_ANG_PAIR_KINDS[m.group(3)], m.group(1), m.group(2))
    raise ValueError(f"cannot parse angle statement {text!r}")


def _aval_ok(node):
    return node[0] == "aval" and 1 <= node[2] <= 178


def check_triangle_sum(claim, prevs):
    """The third angle of a cited triangle from the other two."""
    rel, v1, v2 = prevs
    if not _aval_ok(claim) or rel[0] != "tri" \
            or not (_aval_ok(v1) and _aval_ok(v2)):
        return False
    names = {rel[1], rel[2], rel[3]}
    return (len(names) == 3 and {v1[1], v2[1], claim[1]} == names
            and claim[2] == 180 - v1[2] - v2[2])


def check_straight_line(claim, prevs):
    """The supplement of the cited angle on a straight line."""
    rel, v1 = prevs
    if not _aval_ok(claim) or rel[0] != "line" or not _aval_ok(v1):
        return False
    return ({v1[1], claim[1]} == {rel[1], rel[2]} and v1[1] != claim[1]
            and claim[2] == 180 - v1[2])


def _check_equal_pair(kind, claim, prevs):
    rel, v1 = prevs
    if not _aval_ok(claim) or rel[0] != kind or not _aval_ok(v1):
        return False
    return ({v1[1], claim[1]} == {rel[1], rel[2]} and v1[1] != claim[1]
            and claim[2] == v1[2])


def check_vertical_angles(claim, prevs):
    """Vertical angles are equal."""
    return _check_equal_pair("vert", claim, prevs)


def check_alternate_angles(claim, prevs):
    """Alternate angles at parallel lines are equal."""
    return _check_equal_pair("alt", claim, prevs)


def check_corresponding_angles(claim, prevs):
    """Corresponding angles at parallel lines are equal."""
    return _check_equal_pair("corr", claim, prevs)


def check_isosceles_base(claim, prevs):
    """Base angles of an isosceles triangle are equal."""
    return _check_equal_pair("iso", claim, prevs)


def check_complementary_angles(claim, prevs):
    """Complementary pair: the angles sum to 90°."""
    rel, v1 = prevs
    if not _aval_ok(claim) or rel[0] != "comp" or not _aval_ok(v1):
        return False
    return ({v1[1], claim[1]} == {rel[1], rel[2]} and v1[1] != claim[1]
            and claim[2] == 90 - v1[2])


def check_cointerior_angles(claim, prevs):
    """Co-interior angles at parallel lines sum to 180°."""
    rel, v1 = prevs
    if not _aval_ok(claim) or rel[0] != "coint" or not _aval_ok(v1):
        return False
    return ({v1[1], claim[1]} == {rel[1], rel[2]} and v1[1] != claim[1]
            and claim[2] == 180 - v1[2])


def _check_angle_total(kind, total_of, claim, prevs):
    rel = prevs[0]
    if not _aval_ok(claim) or rel[0] != kind:
        return False
    names = rel[1]
    if len(set(names)) != len(names):
        return False
    cited = prevs[1:]
    if not all(_aval_ok(v) for v in cited):
        return False
    if {v[1] for v in cited} | {claim[1]} != set(names) \
            or len(cited) + 1 != len(names):
        return False
    return claim[2] == total_of(len(names)) - sum(v[2] for v in cited)


def check_full_turn(claim, prevs):
    """Angles about a point: the cited values and the claim sum to 360°."""
    return _check_angle_total("point", lambda n: 360, claim, prevs)


def check_polygon_sum(claim, prevs):
    """Interior angles of an n-gon sum to (n-2)·180°."""
    return _check_angle_total("poly", lambda n: (n - 2) * 180, claim, prevs)


def check_cyclic_opposite(claim, prevs):
    """Opposite angles of a cyclic quadrilateral sum to 180°."""
    rel, v1 = prevs
    if not _aval_ok(claim) or rel[0] != "cyc" or not _aval_ok(v1):
        return False
    return ({v1[1], claim[1]} == {rel[1], rel[2]} and v1[1] != claim[1]
            and claim[2] == 180 - v1[2])


def check_inscribed_angle(claim, prevs):
    """The central angle is twice the inscribed angle on the same arc
    (usable in either direction)."""
    rel, v1 = prevs
    if not _aval_ok(claim) or rel[0] != "insc" or not _aval_ok(v1):
        return False
    c, i = rel[1], rel[2]
    if claim[1] == c and v1[1] == i:
        return claim[2] == 2 * v1[2]
    if claim[1] == i and v1[1] == c:
        return 2 * claim[2] == v1[2]
    return False


def check_exterior_angle(claim, prevs):
    """Exterior angle = sum of remote interiors (either direction)."""
    rel, v1, v2 = prevs
    if not _aval_ok(claim) or rel[0] != "ext" \
            or not (_aval_ok(v1) and _aval_ok(v2)):
        return False
    x, y, z = rel[1], rel[2], rel[3]
    got = {v1[1]: v1[2], v2[1]: v2[2]}
    if claim[1] == x and set(got) == {y, z}:
        return claim[2] == got[y] + got[z]
    if claim[1] in (y, z) and x in got:
        other = z if claim[1] == y else y
        return other in got and claim[2] == got[x] - got[other]
    return False


# ---------------------------------------------------------------------------
# Triangle-certificate statements — side-length verdicts: right-angled
# or not (Pythagorean converse), and whether segments form a triangle
# at all (triangle inequality). Forms:
#
#   ("tsides", a, b, c)   a triangle has sides 5, 12, 13     (premise)
#   ("segs", a, b, c)     segments of lengths 3, 5, 9        (premise)
#   ("sqv", s, v)         13² = 169
#   ("sumv", x, y, s)     25 + 144 = 169
#   ("ineq", a, b, op, c) 5 + 12 > 13   /   3 + 5 ≤ 9
#   ("right"/"notright", a, b, c)   the verdict lines
#   ("formtri"/"noform", a, b, c)
# ---------------------------------------------------------------------------

_TC_TSIDES = re.compile(r"^a triangle has sides (\d+), (\d+), (\d+)$")
_TC_SEGS = re.compile(r"^segments of lengths (\d+), (\d+), (\d+)$")
_TC_SQV = re.compile(r"^(\d+)² = (\d+)$")
_TC_SUMV = re.compile(r"^(\d+) \+ (\d+) = (\d+)$")
_TC_INEQ = re.compile(r"^(\d+) \+ (\d+) (>|≤) (\d+)$")
_TC_RIGHT = re.compile(r"^the triangle with sides (\d+), (\d+), (\d+) "
                       r"is (not )?right-angled$")
_TC_RATIO = re.compile(r"^the (sin|cos|tan) of the angle opposite the "
                       r"side of length (\d+) is (\d+)/(\d+)$")
_TC_FORM = re.compile(r"^segments of lengths (\d+), (\d+), (\d+) "
                      r"(form|cannot form) a triangle$")


def render_tri_cert(node):
    kind = node[0]
    if kind == "tsides":
        return f"a triangle has sides {node[1]}, {node[2]}, {node[3]}"
    if kind == "segs":
        return f"segments of lengths {node[1]}, {node[2]}, {node[3]}"
    if kind == "sqv":
        return f"{node[1]}² = {node[2]}"
    if kind == "sumv":
        return f"{node[1]} + {node[2]} = {node[3]}"
    if kind == "ineq":
        return f"{node[1]} + {node[2]} {node[3]} {node[4]}"
    if kind in ("right", "notright"):
        tail = "is right-angled" if kind == "right" \
            else "is not right-angled"
        return (f"the triangle with sides {node[1]}, {node[2]}, "
                f"{node[3]} {tail}")
    if kind == "trat":
        return (f"the {node[1]} of the angle opposite the side of "
                f"length {node[2]} is {node[3]}/{node[4]}")
    tail = "form a triangle" if kind == "formtri" \
        else "cannot form a triangle"
    return f"segments of lengths {node[1]}, {node[2]}, {node[3]} {tail}"


def parse_tri_cert(node_text):
    """Parses a triangle-certificate statement (round-trips)."""
    m = _TC_TSIDES.match(node_text)
    if m:
        return ("tsides",) + tuple(int(g) for g in m.groups())
    m = _TC_SEGS.match(node_text)
    if m:
        return ("segs",) + tuple(int(g) for g in m.groups())
    m = _TC_SQV.match(node_text)
    if m:
        return ("sqv", int(m.group(1)), int(m.group(2)))
    m = _TC_SUMV.match(node_text)
    if m:
        return ("sumv",) + tuple(int(g) for g in m.groups())
    m = _TC_INEQ.match(node_text)
    if m:
        return ("ineq", int(m.group(1)), int(m.group(2)), m.group(3),
                int(m.group(4)))
    m = _TC_RIGHT.match(node_text)
    if m:
        kind = "notright" if m.group(4) else "right"
        return (kind, int(m.group(1)), int(m.group(2)), int(m.group(3)))
    m = _TC_RATIO.match(node_text)
    if m:
        return ("trat", m.group(1), int(m.group(2)), int(m.group(3)),
                int(m.group(4)))
    m = _TC_FORM.match(node_text)
    if m:
        kind = "formtri" if m.group(4) == "form" else "noform"
        return (kind, int(m.group(1)), int(m.group(2)), int(m.group(3)))
    raise ValueError(f"cannot parse triangle statement {node_text!r}")


def check_square_side(claim, prevs):
    """One premise side squared, exactly."""
    (ref,) = prevs
    return (claim[0] == "sqv" and ref[0] in ("tsides", "segs")
            and claim[1] in ref[1:] and claim[2] == claim[1] ** 2)


def check_add_squares(claim, prevs):
    """Add the two cited squared values, exactly."""
    x, y = prevs
    if claim[0] != "sumv" or x[0] != "sqv" or y[0] != "sqv":
        return False
    return (claim[1] == x[2] and claim[2] == y[2]
            and claim[3] == x[2] + y[2])


def _tc_scene(premise, claim):
    """(sorted sides, ok) — the claim restates the premise's sides."""
    sides = premise[1:]
    return sorted(sides), claim[1:] == sides


def check_pythagorean_converse(claim, prevs):
    """Right-angled: the two shorter squares sum to the longest square."""
    premise, sumv, hyp = prevs
    if claim[0] != "right" or premise[0] != "tsides" \
            or sumv[0] != "sumv" or hyp[0] != "sqv":
        return False
    (s1, s2, s3), ok = _tc_scene(premise, claim)
    return (ok and sorted((sumv[1], sumv[2])) == sorted((s1 ** 2, s2 ** 2))
            and sumv[3] == s1 ** 2 + s2 ** 2
            and hyp[1] == s3 and hyp[2] == s3 ** 2
            and sumv[3] == hyp[2])


def check_pythagorean_refutation(claim, prevs):
    """Not right-angled: a genuine triangle whose shorter squares do
    not sum to the longest square."""
    premise, sumv, hyp = prevs
    if claim[0] != "notright" or premise[0] != "tsides" \
            or sumv[0] != "sumv" or hyp[0] != "sqv":
        return False
    (s1, s2, s3), ok = _tc_scene(premise, claim)
    return (ok and s1 + s2 > s3
            and sorted((sumv[1], sumv[2])) == sorted((s1 ** 2, s2 ** 2))
            and sumv[3] == s1 ** 2 + s2 ** 2
            and hyp[1] == s3 and hyp[2] == s3 ** 2
            and sumv[3] != hyp[2])


def check_side_sum(claim, prevs):
    """One side-sum comparison over the premise's lengths, exactly."""
    (ref,) = prevs
    if claim[0] != "ineq" or ref[0] not in ("tsides", "segs"):
        return False
    a, b, op, c = claim[1], claim[2], claim[3], claim[4]
    if sorted((a, b, c)) != sorted(ref[1:]):
        return False
    return a + b > c if op == ">" else a + b <= c


def check_triangle_formation(claim, prevs):
    """Formable: the two shorter segments out-sum the longest (which
    settles the other two inequalities for free)."""
    premise, ineq = prevs
    if claim[0] != "formtri" or premise[0] != "segs" \
            or ineq[0] != "ineq" or ineq[3] != ">":
        return False
    (s1, s2, s3), ok = _tc_scene(premise, claim)
    return (ok and ineq[4] == s3 and sorted((ineq[1], ineq[2])) == [s1, s2]
            and s1 + s2 > s3)


def check_right_triangle_ratio(claim, prevs):
    """A trig ratio read off a PROVEN right triangle: sin = opp/hyp,
    cos = adj/hyp, tan = opp/adj, in lowest terms."""
    premise, right = prevs
    if claim[0] != "trat" or premise[0] != "tsides" \
            or right[0] != "right" or right[1:] != premise[1:]:
        return False
    s1, s2, s3 = sorted(premise[1:])
    if s1 ** 2 + s2 ** 2 != s3 ** 2:
        return False
    fn, opp, num, den = claim[1:]
    if opp not in (s1, s2):
        return False
    adj = s2 if opp == s1 else s1
    pair = {"sin": (opp, s3), "cos": (adj, s3), "tan": (opp, adj)}[fn]
    g = gcd(pair[0], pair[1])
    return (num, den) == (pair[0] // g, pair[1] // g)


def check_no_triangle(claim, prevs):
    """Not formable: some pair fails to out-sum the third segment."""
    premise, ineq = prevs
    if claim[0] != "noform" or premise[0] != "segs" \
            or ineq[0] != "ineq" or ineq[3] != "≤":
        return False
    _, ok = _tc_scene(premise, claim)
    return (ok and sorted((ineq[1], ineq[2], ineq[4])) == sorted(premise[1:])
            and ineq[1] + ineq[2] <= ineq[4])


# ---------------------------------------------------------------------------
# Transformation statements — congruence via rigid motions (8.G.A.2):
# the motion is the certificate. Forms:
#
#   ("tript", name, pts)   triangle ABC has vertices A(1, 2), ...
#   ("motion", ops)        the motion: reflect over the y-axis, then
#                          translate by (4, -2)   — ops are ("trans",
#                          dx, dy), ("rot", 90|180|270), ("reflx",),
#                          ("refly",)
#   ("maps", p, q)         the motion sends (1, 2) to (-1, 0)
#   ("sqlen", pair, v)     AB² = 25
#   ("congr",)/("ncongr",) the verdict lines
# ---------------------------------------------------------------------------

_TX_TRI = re.compile(
    r"^triangle (ABC|DEF) has vertices "
    r"([A-F])\((-?\d+), (-?\d+)\), ([A-F])\((-?\d+), (-?\d+)\), "
    r"([A-F])\((-?\d+), (-?\d+)\)$")
_TX_TRANS = re.compile(r"^translate by \((-?\d+), (-?\d+)\)$")
_TX_ROT = re.compile(r"^rotate (90|180|270)° counterclockwise about "
                     r"the origin$")
_TX_MAPS = re.compile(r"^the motion sends \((-?\d+), (-?\d+)\) to "
                      r"\((-?\d+), (-?\d+)\)$")
_TX_SQLEN = re.compile(r"^([A-F])([A-F])² = (\d+)$")
_TX_VERTS = {"ABC": ("A", "B", "C"), "DEF": ("D", "E", "F")}


def _render_txf_op(op):
    if op[0] == "trans":
        return f"translate by ({op[1]}, {op[2]})"
    if op[0] == "rot":
        return f"rotate {op[1]}° counterclockwise about the origin"
    return ("reflect over the x-axis" if op[0] == "reflx"
            else "reflect over the y-axis")


def render_txf(node):
    kind = node[0]
    if kind == "tript":
        letters = _TX_VERTS[node[1]]
        verts = ", ".join(f"{ch}({p[0]}, {p[1]})"
                          for ch, p in zip(letters, node[2]))
        return f"triangle {node[1]} has vertices {verts}"
    if kind == "motion":
        return "the motion: " + ", then ".join(_render_txf_op(op)
                                               for op in node[1])
    if kind == "maps":
        p, q = node[1], node[2]
        return f"the motion sends ({p[0]}, {p[1]}) to ({q[0]}, {q[1]})"
    if kind == "sqlen":
        return f"{node[1]}² = {node[2]}"
    if kind == "congr":
        return "triangle ABC is congruent to triangle DEF"
    return "triangle ABC is not congruent to triangle DEF"


def parse_txf(text):
    """Parses a transformation statement (round-trips)."""
    if text == "triangle ABC is congruent to triangle DEF":
        return ("congr",)
    if text == "triangle ABC is not congruent to triangle DEF":
        return ("ncongr",)
    m = _TX_TRI.match(text)
    if m:
        g = m.groups()
        name = g[0]
        letters = (g[1], g[4], g[7])
        if letters != _TX_VERTS[name]:
            raise ValueError(f"vertex letters mismatch: {text!r}")
        pts = ((int(g[2]), int(g[3])), (int(g[5]), int(g[6])),
               (int(g[8]), int(g[9])))
        return ("tript", name, pts)
    if text.startswith("the motion: "):
        ops = []
        for part in text[len("the motion: "):].split(", then "):
            m = _TX_TRANS.match(part)
            if m:
                ops.append(("trans", int(m.group(1)), int(m.group(2))))
                continue
            m = _TX_ROT.match(part)
            if m:
                ops.append(("rot", int(m.group(1))))
                continue
            if part == "reflect over the x-axis":
                ops.append(("reflx",))
            elif part == "reflect over the y-axis":
                ops.append(("refly",))
            else:
                raise ValueError(f"unknown motion op {part!r}")
        return ("motion", tuple(ops))
    m = _TX_MAPS.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("maps", (g[0], g[1]), (g[2], g[3]))
    m = _TX_SQLEN.match(text)
    if m:
        return ("sqlen", m.group(1) + m.group(2), int(m.group(3)))
    raise ValueError(f"cannot parse transformation statement {text!r}")


def _apply_rigid(ops, p):
    x, y = p
    for op in ops:
        if op[0] == "trans":
            x, y = x + op[1], y + op[2]
        elif op[0] == "rot":
            for _ in range(op[1] // 90):
                x, y = -y, x
        elif op[0] == "reflx":
            y = -y
        else:
            x = -x
    return (x, y)


def check_exhibit_motion(claim, prevs):
    """A candidate rigid motion of one or two atomic moves."""
    (ref,) = prevs
    if claim[0] != "motion" or ref[0] != "tript":
        return False
    ops = claim[1]
    return (1 <= len(ops) <= 2
            and all(op[0] in ("trans", "rot", "reflx", "refly")
                    for op in ops))


def check_apply_motion(claim, prevs):
    """The cited motion applied to one vertex of the cited triangle."""
    motion, tri = prevs
    if claim[0] != "maps" or motion[0] != "motion" or tri[0] != "tript":
        return False
    return (claim[1] in tri[2]
            and claim[2] == _apply_rigid(motion[1], claim[1]))


def check_congruence_conclusion(claim, prevs):
    """Congruent: the exhibited rigid motion carries each vertex of ABC
    to the corresponding vertex of DEF (every application re-verified)."""
    tri1, tri2, motion = prevs[0], prevs[1], prevs[2]
    maps = prevs[3:]
    if claim != ("congr",) or tri1[0] != "tript" or tri1[1] != "ABC" \
            or tri2[0] != "tript" or tri2[1] != "DEF" \
            or motion[0] != "motion" or len(maps) != 3:
        return False
    for src, dst, mp in zip(tri1[2], tri2[2], maps):
        if mp[0] != "maps" or mp[1] != src or mp[2] != dst \
                or _apply_rigid(motion[1], src) != dst:
            return False
    return True


def _pair_sq(tri, pair):
    letters = _TX_VERTS[tri[1]]
    i, j = letters.index(pair[0]), letters.index(pair[1])
    (x1, y1), (x2, y2) = tri[2][i], tri[2][j]
    return (x1 - x2) ** 2 + (y1 - y2) ** 2


def check_side_length_sq(claim, prevs):
    """One side's squared length, exactly, from the cited triangle."""
    (tri,) = prevs
    if claim[0] != "sqlen" or tri[0] != "tript":
        return False
    letters = _TX_VERTS[tri[1]]
    pair = claim[1]
    if pair[0] not in letters or pair[1] not in letters \
            or pair[0] == pair[1]:
        return False
    return claim[2] == _pair_sq(tri, pair)


def check_incongruence_conclusion(claim, prevs):
    """Not congruent: the side-length multisets differ, so no rigid
    motion (which preserves lengths) can exist — under any
    correspondence, since triangles are determined by their sides."""
    tri1, tri2 = prevs[0], prevs[1]
    lens = prevs[2:]
    if claim != ("ncongr",) or tri1[0] != "tript" or tri1[1] != "ABC" \
            or tri2[0] != "tript" or tri2[1] != "DEF" or len(lens) != 6:
        return False
    roles = ("AB", "BC", "CA", "DE", "EF", "FD")
    tris = (tri1, tri1, tri1, tri2, tri2, tri2)
    for role, tri, ln in zip(roles, tris, lens):
        if ln[0] != "sqlen" or ln[1] != role \
                or ln[2] != _pair_sq(tri, role):
            return False
    return sorted(ln[2] for ln in lens[:3]) \
        != sorted(ln[2] for ln in lens[3:])


# ---------------------------------------------------------------------------
# Algebraic-form statements — the GCSE algebraic-proof genre: claims
# about ALL integers via exact linear forms over symbols a..f. A form
# is ("lin", ((sym, coef), ...), const) with symbols alphabetical and
# positive coefficients. Forms:
#
#   ("intro",)                 all variables denote integers  (premise)
#   ("consec", n, sym)         let the consecutive integers be a, a+1...
#   ("rep", kind, m, sym)      any odd number can be written as 2a + 1
#                              (kinds: odd/even with m = 2, mult with m)
#   ("expand", addends, rhs)   (2a + 1) + (2b) = 2a + 2b + 1
#   ("remform", lhs, q, inner, r)   2a + 2b + 2 = 2(a + b + 1)  [+ r]
#   ("vparity", j, k, parity) / ("vconsec", n, div) /
#   ("vmult", m1, m2, d)       the verdict lines
# ---------------------------------------------------------------------------

_AL_TERM = re.compile(r"^(\d+)?([a-f])$|^(\d+)$")
_AL_REP_ODD = re.compile(r"^any odd number can be written as 2([a-f]) \+ 1$")
_AL_REP_EVEN = re.compile(r"^any even number can be written as 2([a-f])$")
_AL_REP_MULT = re.compile(
    r"^any multiple of (\d+) can be written as (\d+)([a-f])$")
_AL_CONSEC = re.compile(
    r"^let the consecutive integers be ([a-f])((?:, [a-f] \+ \d+)+)$")
_AL_REMRHS = re.compile(r"^(\d+)\((.+)\)(?: \+ (\d+))?$")
_AL_VPAR_BOTH = re.compile(r"^the sum of (\d+) odd numbers?(?: and "
                           r"(\d+) even numbers?)? is always (odd|even)$")
_AL_VPAR_EVEN = re.compile(
    r"^the sum of (\d+) even numbers? is always (odd|even)$")
_AL_VCONSEC = re.compile(r"^the sum of (\d+) consecutive integers is "
                         r"(always|never) divisible by (\d+)$")
_AL_VMULT = re.compile(r"^the sum of a multiple of (\d+) and a multiple "
                       r"of (\d+) is always divisible by (\d+)$")


def _render_lin(form):
    _, terms, const = form
    parts = [("x" if False else f"{c}{s}") if c != 1 else s
             for s, c in terms]
    if const:
        parts.append(str(const))
    return " + ".join(parts) if parts else "0"


def _parse_lin(text):
    terms, const = [], 0
    for part in text.split(" + "):
        m = _AL_TERM.match(part)
        if not m:
            raise ValueError(f"cannot parse linear term {part!r}")
        if m.group(3) is not None:
            const += int(m.group(3))
        else:
            coef = int(m.group(1)) if m.group(1) else 1
            terms.append((m.group(2), coef))
    if [s for s, _ in terms] != sorted(s for s, _ in terms):
        raise ValueError(f"symbols must be alphabetical: {text!r}")
    return ("lin", tuple(terms), const)


def _lin_sum(forms):
    coefs, const = {}, 0
    for _, terms, c in forms:
        const += c
        for s, k in terms:
            coefs[s] = coefs.get(s, 0) + k
    return ("lin", tuple(sorted(coefs.items())), const)


def _rep_form(rep):
    _, kind, m, sym = rep
    return ("lin", ((sym, m),), 1 if kind == "odd" else 0)


def _parity_count(count, word):
    plural = "" if count == 1 else "s"
    return f"{count} {word} number{plural}"


def render_alg(node):
    kind = node[0]
    if kind == "intro":
        return "all variables denote integers"
    if kind == "consec":
        _, n, sym = node
        run = [sym] + [f"{sym} + {i}" for i in range(1, n)]
        return "let the consecutive integers be " + ", ".join(run)
    if kind == "rep":
        _, rk, m, sym = node
        if rk == "odd":
            return f"any odd number can be written as 2{sym} + 1"
        if rk == "even":
            return f"any even number can be written as 2{sym}"
        return f"any multiple of {m} can be written as {m}{sym}"
    if kind == "expand":
        lhs = " + ".join(f"({_render_lin(f)})" for f in node[1])
        return f"{lhs} = {_render_lin(node[2])}"
    if kind == "remform":
        _, lhs, q, inner, r = node
        tail = f" + {r}" if r else ""
        return f"{_render_lin(lhs)} = {q}({_render_lin(inner)}){tail}"
    if kind == "sqdiff":
        return (f"({_render_lin(node[1])})² - ({_render_lin(node[2])})² "
                f"= {_render_q(node[3])}")
    if kind == "sqsum":
        return (f"({_render_lin(node[1])})² + ({_render_lin(node[2])})² "
                f"= {_render_q(node[3])}")
    if kind == "prodexp":
        return (f"({_render_lin(node[1])})({_render_lin(node[2])}) "
                f"= {_render_q(node[3])}")
    if kind == "qrem":
        _, lhs, q, inner, r = node
        tail = f" + {r}" if r else ""
        return f"{_render_q(lhs)} = {q}({_render_q(inner)}){tail}"
    if kind == "vquad":
        tag, param = node[1], node[2]
        if tag == "diff_gap":
            if param == 1:
                return _AQ_VDIFF1
            return (f"the difference of the squares of two integers "
                    f"that differ by {param} is always divisible by "
                    f"{param}")
        if tag == "diff_odds":
            return (f"the difference of the squares of two odd numbers "
                    f"that differ by {2 * param} is always divisible "
                    f"by {4 * param}")
        if tag == "sum_odds":
            return (f"the sum of the squares of two odd numbers that "
                    f"differ by {2 * param} always leaves remainder 2 "
                    f"when divided by 4")
        return _AQ_VPROD
    if kind == "vparity":
        _, j, k, parity = node
        parts = []
        if j:
            parts.append(_parity_count(j, "odd"))
        if k:
            parts.append(_parity_count(k, "even"))
        return f"the sum of {' and '.join(parts)} is always {parity}"
    if kind == "vconsec":
        _, n, div = node
        word = "always" if div else "never"
        return (f"the sum of {n} consecutive integers is {word} "
                f"divisible by {n}")
    _, m1, m2, d = node
    return (f"the sum of a multiple of {m1} and a multiple of {m2} "
            f"is always divisible by {d}")


def parse_alg(text):
    """Parses an algebraic-form statement (round-trips)."""
    if text == "all variables denote integers":
        return ("intro",)
    m = _AL_REP_ODD.match(text)
    if m:
        return ("rep", "odd", 2, m.group(1))
    m = _AL_REP_EVEN.match(text)
    if m:
        return ("rep", "even", 2, m.group(1))
    m = _AL_REP_MULT.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"multiple coefficients differ: {text!r}")
        return ("rep", "mult", int(m.group(1)), m.group(3))
    m = _AL_CONSEC.match(text)
    if m:
        sym = m.group(1)
        offs = [int(x) for x in re.findall(r"\+ (\d+)", m.group(2))]
        if offs != list(range(1, len(offs) + 1)):
            raise ValueError(f"non-consecutive run: {text!r}")
        return ("consec", len(offs) + 1, sym)
    m = _AL_VCONSEC.match(text)
    if m:
        if m.group(1) != m.group(3):
            raise ValueError(f"consecutive counts differ: {text!r}")
        return ("vconsec", int(m.group(1)), m.group(2) == "always")
    m = _AL_VMULT.match(text)
    if m:
        return ("vmult", int(m.group(1)), int(m.group(2)),
                int(m.group(3)))
    m = _AL_VPAR_BOTH.match(text)
    if m:
        return ("vparity", int(m.group(1)),
                int(m.group(2)) if m.group(2) else 0, m.group(3))
    m = _AL_VPAR_EVEN.match(text)
    if m:
        return ("vparity", 0, int(m.group(1)), m.group(2))
    if text == _AQ_VDIFF1:
        return ("vquad", "diff_gap", 1)
    if text == _AQ_VPROD:
        return ("vquad", "prod_odds", 0)
    m = _AQ_VDIFF.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"gap divisor mismatch: {text!r}")
        return ("vquad", "diff_gap", int(m.group(1)))
    m = _AQ_VODDDIFF.match(text)
    if m:
        gap, div = int(m.group(1)), int(m.group(2))
        if gap % 2 or div != 2 * gap:
            raise ValueError(f"odd-gap divisor mismatch: {text!r}")
        return ("vquad", "diff_odds", gap // 2)
    m = _AQ_VODDSUM.match(text)
    if m:
        gap = int(m.group(1))
        if gap % 2:
            raise ValueError(f"odd gap must be even: {text!r}")
        return ("vquad", "sum_odds", gap // 2)
    if " = " in text:
        m = _CA_SUB_EVEN.match(text)
        if m:
            return ("csub", "even", int(m.group(1)),
                    _parse_q(m.group(2)))
        m = _CA_SUB_ODD.match(text)
        if m:
            return ("csub", "odd", int(m.group(1)),
                    _parse_q(m.group(2)))
        lhs_text, rhs_text = text.split(" = ", 1)
        for sep, kind in ((")² - (", "sqdiff"), (")² + (", "sqsum"),
                          (")(", "prodexp")):
            if sep in lhs_text and lhs_text.startswith("(") \
                    and "²" not in rhs_text.replace("a²", "").replace(
                        "b²", ""):
                left, right = lhs_text.split(sep, 1)
                f1 = _parse_lin(left[1:])
                f2 = _parse_lin(right[:-2] if kind != "prodexp"
                                else right[:-1])
                return (kind, f1, f2, _parse_q(rhs_text))
        if ("²" in lhs_text or "ab" in lhs_text) and "(" not in lhs_text:
            m = _AL_REMRHS.match(rhs_text)
            if m:
                return ("qrem", _parse_q(lhs_text), int(m.group(1)),
                        _parse_q(m.group(2)),
                        int(m.group(3)) if m.group(3) else 0)
        m = _AL_REMRHS.match(rhs_text)
        if m and "(" not in lhs_text:
            return ("remform", _parse_lin(lhs_text), int(m.group(1)),
                    _parse_lin(m.group(2)),
                    int(m.group(3)) if m.group(3) else 0)
        if lhs_text.startswith("("):
            addends = tuple(_parse_lin(p)
                            for p in re.findall(r"\(([^)]*)\)", lhs_text))
            expected = " + ".join(f"({_render_lin(f)})" for f in addends)
            if expected != lhs_text:
                raise ValueError(f"malformed expansion: {text!r}")
            return ("expand", addends, _parse_lin(rhs_text))
    raise ValueError(f"cannot parse algebraic statement {text!r}")


_QKEY_ORDER = {"a²": 0, "b²": 1, "ab": 2, "a": 3, "b": 4}
_AQ_TERM = re.compile(r"^(\d+)?(a²|b²|ab|a|b)$|^(\d+)$")
_AQ_VDIFF1 = ("the difference of the squares of two consecutive "
              "integers is always odd")
_AQ_VDIFF = re.compile(r"^the difference of the squares of two integers "
                       r"that differ by (\d+) is always divisible by "
                       r"(\d+)$")
_AQ_VODDDIFF = re.compile(r"^the difference of the squares of two odd "
                          r"numbers that differ by (\d+) is always "
                          r"divisible by (\d+)$")
_AQ_VODDSUM = re.compile(r"^the sum of the squares of two odd numbers "
                         r"that differ by (\d+) always leaves remainder "
                         r"2 when divided by 4$")
_AQ_VPROD = "the product of two odd numbers is always odd"


def _render_q(form):
    _, terms, const = form
    parts = [key if coef == 1 else f"{coef}{key}" for key, coef in terms]
    if const:
        parts.append(str(const))
    return " + ".join(parts) if parts else "0"


def _parse_q(text):
    coefs, const = {}, 0
    for part in text.split(" + "):
        m = _AQ_TERM.match(part)
        if not m:
            raise ValueError(f"cannot parse quadratic term {part!r}")
        if m.group(3) is not None:
            const += int(m.group(3))
        else:
            coefs[m.group(2)] = coefs.get(m.group(2), 0) \
                + (int(m.group(1)) if m.group(1) else 1)
    terms = tuple(sorted(coefs.items(),
                         key=lambda kv: _QKEY_ORDER[kv[0]]))
    return ("qlin", terms, const)


def _q_mul_lin(f1, f2):
    """Product of two (at most single-symbol) linear forms, as a qlin."""
    _, t1, c1 = f1
    _, t2, c2 = f2
    coefs = {}

    def add(key, v):
        if v:
            coefs[key] = coefs.get(key, 0) + v

    for s1, k1 in t1:
        for s2, k2 in t2:
            key = f"{s1}²" if s1 == s2 else "".join(sorted((s1, s2)))
            add(key, k1 * k2)
        add(s1, k1 * c2)
    for s2, k2 in t2:
        add(s2, k2 * c1)
    terms = tuple(sorted(coefs.items(),
                         key=lambda kv: _QKEY_ORDER[kv[0]]))
    return ("qlin", terms, c1 * c2)


def _q_combine(x, y, sign):
    coefs = dict(x[1])
    for key, coef in y[1]:
        coefs[key] = coefs.get(key, 0) + sign * coef
    terms = tuple(sorted(((k, c) for k, c in coefs.items() if c),
                         key=lambda kv: _QKEY_ORDER[kv[0]]))
    return ("qlin", terms, x[2] + sign * y[2])


def check_square_diff_expand(claim, prevs):
    """(f1)² - (f2)² expanded exactly, for single-symbol linear forms."""
    (ref,) = prevs
    if claim[0] != "sqdiff" or ref != ("intro",):
        return False
    f1, f2, rhs = claim[1], claim[2], claim[3]
    if any(len(f[1]) > 1 for f in (f1, f2)):
        return False
    return rhs == _q_combine(_q_mul_lin(f1, f1), _q_mul_lin(f2, f2), -1)


def check_square_sum_expand(claim, prevs):
    """(f1)² + (f2)² expanded exactly."""
    (ref,) = prevs
    if claim[0] != "sqsum" or ref != ("intro",):
        return False
    f1, f2, rhs = claim[1], claim[2], claim[3]
    if any(len(f[1]) > 1 for f in (f1, f2)):
        return False
    return rhs == _q_combine(_q_mul_lin(f1, f1), _q_mul_lin(f2, f2), 1)


def check_product_expand(claim, prevs):
    """(f1)(f2) expanded exactly, distinct single symbols."""
    (ref,) = prevs
    if claim[0] != "prodexp" or ref != ("intro",):
        return False
    f1, f2, rhs = claim[1], claim[2], claim[3]
    if len(f1[1]) != 1 or len(f2[1]) != 1 \
            or f1[1][0][0] == f2[1][0][0]:
        return False
    return rhs == _q_mul_lin(f1, f2)


def check_quadratic_remainder(claim, prevs):
    """The quadratic expansion rewritten as q·(...) + r, verified
    coefficientwise. A purely linear expansion (the squares cancel)
    parses as an ordinary remainder form — the payloads are compared
    tag-agnostically."""
    (ref,) = prevs
    if claim[0] not in ("qrem", "remform") \
            or ref[0] not in ("sqdiff", "sqsum", "prodexp", "csub"):
        return False
    _, lhs, q, inner, r = claim
    if (lhs[1], lhs[2]) != (ref[3][1], ref[3][2]) or q < 2 \
            or not 0 <= r < q:
        return False
    return (lhs[1] == tuple((key, q * c) for key, c in inner[1])
            and lhs[2] == q * inner[2] + r)


def check_quad_conclusion(claim, prevs):
    """The GCSE quadratic verdicts, each tied to its exact schema."""
    exp, rem = prevs
    if claim[0] != "vquad" or rem[0] not in ("qrem", "remform") \
            or (rem[1][1], rem[1][2]) != (exp[3][1], exp[3][2]):
        return False
    tag, param = claim[1], claim[2]
    q, r = rem[2], rem[4]
    if tag == "diff_gap":
        if exp[0] != "sqdiff":
            return False
        f1, f2 = exp[1], exp[2]
        if len(f1[1]) != 1 or f1[1] != f2[1] or f1[1][0][1] != 1 \
                or f2[2] != 0 or f1[2] != param or param < 1:
            return False
        return (q, r) == ((2, 1) if param == 1 else (param, 0))
    if tag == "diff_odds":
        if exp[0] != "sqdiff":
            return False
        f1, f2 = exp[1], exp[2]
        k = param
        if f1[1] != f2[1] or len(f1[1]) != 1 or f1[1][0][1] != 2 \
                or (f1[2], f2[2]) != (2 * k + 1, 1) or k < 1:
            return False
        return (q, r) == (4 * k, 0)
    if tag == "sum_odds":
        if exp[0] != "sqsum":
            return False
        f1, f2 = exp[1], exp[2]
        k = param
        if f1[1] != f2[1] or len(f1[1]) != 1 or f1[1][0][1] != 2 \
                or {f1[2], f2[2]} != {1, 2 * k + 1} or k < 1:
            return False
        return (q, r) == (4, 2)
    if tag == "prod_odds":
        if exp[0] != "prodexp":
            return False
        f1, f2 = exp[1], exp[2]
        if any(f[2] != 1 or len(f[1]) != 1 or f[1][0][1] != 2
               for f in (f1, f2)):
            return False
        return (q, r) == (2, 1)
    return False


def check_odd_form(claim, prevs):
    """Introduce a fresh symbol representing an arbitrary odd number."""
    (ref,) = prevs
    return (claim[0] == "rep" and claim[1] == "odd" and claim[2] == 2
            and ref == ("intro",))


def check_even_form(claim, prevs):
    """Introduce a fresh symbol representing an arbitrary even number."""
    (ref,) = prevs
    return (claim[0] == "rep" and claim[1] == "even" and claim[2] == 2
            and ref == ("intro",))


def check_multiple_form(claim, prevs):
    """Introduce a fresh symbol representing an arbitrary multiple."""
    (ref,) = prevs
    return (claim[0] == "rep" and claim[1] == "mult" and claim[2] >= 2
            and ref == ("intro",))


def check_expand_sum(claim, prevs):
    """Sum the cited representations (or the cited consecutive run),
    coefficientwise and exactly."""
    if claim[0] != "expand":
        return False
    addends, rhs = claim[1], claim[2]
    if len(prevs) == 1 and prevs[0][0] == "consec":
        _, n, sym = prevs[0]
        want = tuple(("lin", ((sym, 1),), i) for i in range(n))
        if addends != want:
            return False
    else:
        if len(prevs) != len(addends):
            return False
        syms = []
        for rep, form in zip(prevs, addends):
            if rep[0] != "rep" or form != _rep_form(rep):
                return False
            syms.append(rep[3])
        if len(set(syms)) != len(syms):
            return False
    return rhs == _lin_sum(addends)


def check_remainder_form(claim, prevs):
    """Rewrite the expansion as q·(...) + r with 0 <= r < q, verified
    coefficientwise — the divisibility verdict falls out of r."""
    (ref,) = prevs
    if claim[0] != "remform" or ref[0] != "expand":
        return False
    _, lhs, q, inner, r = claim
    if lhs != ref[2] or q < 2 or not 0 <= r < q:
        return False
    _, lterms, lconst = lhs
    _, iterms, iconst = inner
    return (lterms == tuple((s, q * c) for s, c in iterms)
            and lconst == q * iconst + r)


def check_parity_conclusion(claim, prevs):
    """The parity verdict: j odds and k evens sum to parity j mod 2."""
    expand, rem = prevs
    if claim[0] != "vparity" or expand[0] != "expand" \
            or rem[0] != "remform" or rem[1] != expand[2] or rem[2] != 2:
        return False
    j = sum(1 for f in expand[1] if f[2] == 1)
    k = sum(1 for f in expand[1] if f[2] == 0)
    if any(f[2] not in (0, 1) or len(f[1]) != 1 or f[1][0][1] != 2
           for f in expand[1]):
        return False
    parity = "odd" if rem[4] == 1 else "even"
    return claim[1:] == (j, k, parity) and j % 2 == rem[4]


def check_consecutive_conclusion(claim, prevs):
    """The consecutive-run verdict: divisible by n exactly when the
    remainder form's r is zero — for every starting integer."""
    expand, rem = prevs
    if claim[0] != "vconsec" or expand[0] != "expand" \
            or rem[0] != "remform" or rem[1] != expand[2]:
        return False
    addends = expand[1]
    n = len(addends)
    if n < 2 or rem[2] != n:
        return False
    sym = addends[0][1][0][0] if addends[0][1] else None
    want = tuple(("lin", ((sym, 1),), i) for i in range(n))
    if addends != want:
        return False
    return claim[1] == n and claim[2] == (rem[4] == 0)


def check_multiple_sum_conclusion(claim, prevs):
    """The multiples verdict: m1·a + m2·b = d·(...) exactly."""
    expand, rem = prevs
    if claim[0] != "vmult" or expand[0] != "expand" \
            or rem[0] != "remform" or rem[1] != expand[2] or rem[4] != 0:
        return False
    addends = expand[1]
    if len(addends) != 2 or any(f[2] != 0 or len(f[1]) != 1
                                for f in addends):
        return False
    (s1, m1), (s2, m2) = addends[0][1][0], addends[1][1][0]
    if s1 == s2:
        return False
    return claim[1:] == (m1, m2, rem[2]) and rem[2] >= 2


# ---------------------------------------------------------------------------
# Coordinate-proof statements — G-GPE.B and the G-CO.C theorem block
# proved analytically: midpoints, slopes, squared distances and
# collinearity over integer coordinates (draws are parity-constrained
# so nothing ever leaves ℤ). Forms:
#
#   ("cpts", label, pts)      quadrilateral ABCD has vertices A(0, 0),
#                             ... / triangle ABC has vertices ...
#                             / segment AB has endpoints ... with
#                             point P(x, y)
#   ("mid", p, q, m)          the midpoint of (0, 0) and (6, 4) is (3, 2)
#   ("slope", p, q, dy, dx)   the slope from (0, 0) to (6, 4) is 2/3
#   ("cdist", p, q, v)        the squared distance from (1, 2) to
#                             (4, 6) is 25
#   ("collin", p, q, r)       (0, 0), (3, 2), (6, 4) are collinear
#   verdicts: ("vpara",), ("vbisect",), ("vmidseg",), ("vperp",),
#             ("vcentroid",)
# ---------------------------------------------------------------------------

_CP_PT = r"\((-?\d+), (-?\d+)\)"
_CP_QUAD = re.compile(
    r"^quadrilateral ABCD has vertices A" + _CP_PT + ", B" + _CP_PT
    + ", C" + _CP_PT + ", D" + _CP_PT + "$")
_CP_TRI = re.compile(
    r"^triangle ABC has vertices A" + _CP_PT + ", B" + _CP_PT
    + ", C" + _CP_PT + "$")
_CP_SEG = re.compile(
    r"^segment AB has endpoints A" + _CP_PT + " and B" + _CP_PT
    + ", with point P" + _CP_PT + "$")
_CP_MID = re.compile(r"^the midpoint of " + _CP_PT + " and " + _CP_PT
                     + " is " + _CP_PT + "$")
_CP_SLOPE = re.compile(r"^the slope from " + _CP_PT + " to " + _CP_PT
                       + " is (-?\\d+)/(\\d+)$")
_CP_CDIST = re.compile(r"^the squared distance from " + _CP_PT + " to "
                       + _CP_PT + " is (\\d+)$")
_CP_COLLIN = re.compile(r"^" + _CP_PT + ", " + _CP_PT + ", " + _CP_PT
                        + " are collinear$")
_CP_VERDICTS = {
    "ABCD is a parallelogram": ("vpara",),
    "the diagonals of ABCD bisect each other": ("vbisect",),
    "the segment joining the midpoints of AB and AC is parallel to BC "
    "and half its length": ("vmidseg",),
    "P lies on the perpendicular bisector of AB": ("vperp",),
    "the three medians of ABC pass through one point": ("vcentroid",),
}
_CP_VERDICT_TEXT = {v: k for k, v in _CP_VERDICTS.items()}


def _pt(p):
    return f"({p[0]}, {p[1]})"


def render_coord(node):
    kind = node[0]
    if kind == "cpts":
        label, pts = node[1], node[2]
        if label == "ABCD":
            verts = ", ".join(f"{ch}{_pt(p)}"
                              for ch, p in zip("ABCD", pts))
            return f"quadrilateral ABCD has vertices {verts}"
        if label == "ABC":
            verts = ", ".join(f"{ch}{_pt(p)}"
                              for ch, p in zip("ABC", pts))
            return f"triangle ABC has vertices {verts}"
        return (f"segment AB has endpoints A{_pt(pts[0])} and "
                f"B{_pt(pts[1])}, with point P{_pt(pts[2])}")
    if kind == "mid":
        return (f"the midpoint of {_pt(node[1])} and {_pt(node[2])} "
                f"is {_pt(node[3])}")
    if kind == "slope":
        return (f"the slope from {_pt(node[1])} to {_pt(node[2])} "
                f"is {node[3]}/{node[4]}")
    if kind == "cdist":
        return (f"the squared distance from {_pt(node[1])} to "
                f"{_pt(node[2])} is {node[3]}")
    if kind == "collin":
        return (f"{_pt(node[1])}, {_pt(node[2])}, {_pt(node[3])} "
                f"are collinear")
    return _CP_VERDICT_TEXT[node]


def parse_coord(text):
    """Parses a coordinate-proof statement (round-trips)."""
    if text in _CP_VERDICTS:
        return _CP_VERDICTS[text]
    m = _CP_QUAD.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("cpts", "ABCD", tuple((g[i], g[i + 1])
                                      for i in range(0, 8, 2)))
    m = _CP_TRI.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("cpts", "ABC", tuple((g[i], g[i + 1])
                                     for i in range(0, 6, 2)))
    m = _CP_SEG.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("cpts", "AB_P", tuple((g[i], g[i + 1])
                                      for i in range(0, 6, 2)))
    m = _CP_MID.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("mid", (g[0], g[1]), (g[2], g[3]), (g[4], g[5]))
    m = _CP_SLOPE.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("slope", (g[0], g[1]), (g[2], g[3]), g[4], g[5])
    m = _CP_CDIST.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("cdist", (g[0], g[1]), (g[2], g[3]), g[4])
    m = _CP_COLLIN.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("collin", (g[0], g[1]), (g[2], g[3]), (g[4], g[5]))
    raise ValueError(f"cannot parse coordinate statement {text!r}")


def _cp_has(premise, p):
    return p in premise[2]


def check_midpoint(claim, prevs):
    """The midpoint of two premise points, exactly (draws are
    parity-constrained so it is always integral)."""
    (ref,) = prevs
    if claim[0] != "mid" or ref[0] != "cpts":
        return False
    p, q, mid = claim[1], claim[2], claim[3]
    return (_cp_has(ref, p) and _cp_has(ref, q) and p != q
            and (p[0] + q[0], p[1] + q[1]) == (2 * mid[0], 2 * mid[1]))


def check_slope(claim, prevs):
    """The slope between two points, as a reduced fraction with a
    positive denominator (self-contained arithmetic: the points may be
    computed, e.g. midpoints — conclusions anchor them to the figure)."""
    (ref,) = prevs
    if claim[0] != "slope" or ref[0] != "cpts":
        return False
    p, q, dy, dx = claim[1], claim[2], claim[3], claim[4]
    if p == q:
        return False
    ry, rx = q[1] - p[1], q[0] - p[0]
    if rx == 0 or dx <= 0:
        return False
    g = gcd(abs(ry), abs(rx))
    ry, rx = ry // g, rx // g
    if rx < 0:
        ry, rx = -ry, -rx
    return (dy, dx) == (ry, rx)


def check_coord_distance_sq(claim, prevs):
    """The squared distance between two points, exactly (points may be
    computed; conclusions anchor them to the figure)."""
    (ref,) = prevs
    if claim[0] != "cdist" or ref[0] != "cpts":
        return False
    p, q, v = claim[1], claim[2], claim[3]
    return p != q and v == (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2


def check_collinear(claim, prevs):
    """Three points collinear, by a zero cross product (the middle
    point need not be a premise vertex — medians pass through
    computed points)."""
    (ref,) = prevs
    if claim[0] != "collin" or ref[0] != "cpts":
        return False
    p, q, r = claim[1], claim[2], claim[3]
    if len({p, q, r}) != 3:
        return False
    return ((q[0] - p[0]) * (r[1] - p[1])
            - (r[0] - p[0]) * (q[1] - p[1])) == 0


def check_parallelogram_conclusion(claim, prevs):
    """ABCD is a parallelogram: both pairs of opposite sides have equal
    slopes (all four cited slope lines re-verified)."""
    ref = prevs[0]
    slopes = prevs[1:]
    if claim != ("vpara",) or ref[0] != "cpts" or ref[1] != "ABCD" \
            or len(slopes) != 4:
        return False
    a, b, c, d = ref[2]
    want = ((a, b), (d, c), (b, c), (a, d))
    for (p, q), s in zip(want, slopes):
        if s[0] != "slope" or (s[1], s[2]) != (p, q) \
                or not check_slope(s, [ref]):
            return False
    return (slopes[0][3], slopes[0][4]) == (slopes[1][3], slopes[1][4]) \
        and (slopes[2][3], slopes[2][4]) == (slopes[3][3], slopes[3][4])


def check_bisect_conclusion(claim, prevs):
    """The diagonals of ABCD bisect each other: both midpoints coincide
    (each re-verified)."""
    ref, m1, m2 = prevs
    if claim != ("vbisect",) or ref[0] != "cpts" or ref[1] != "ABCD":
        return False
    a, b, c, d = ref[2]
    if m1[0] != "mid" or (m1[1], m1[2]) != (a, c) \
            or not check_midpoint(m1, [ref]):
        return False
    if m2[0] != "mid" or (m2[1], m2[2]) != (b, d) \
            or not check_midpoint(m2, [ref]):
        return False
    return m1[3] == m2[3]


def check_midsegment_conclusion(claim, prevs):
    """The midsegment theorem: MN is parallel to BC and its squared
    length is a quarter of BC's (parallel + half length, exactly)."""
    ref, m1, m2, s_mn, s_bc, d_mn, d_bc = prevs
    if claim != ("vmidseg",) or ref[0] != "cpts" or ref[1] != "ABC":
        return False
    a, b, c = ref[2]
    if m1[0] != "mid" or (m1[1], m1[2]) != (a, b) \
            or not check_midpoint(m1, [ref]):
        return False
    if m2[0] != "mid" or (m2[1], m2[2]) != (a, c) \
            or not check_midpoint(m2, [ref]):
        return False
    mn, nn = m1[3], m2[3]
    if s_mn[0] != "slope" or (s_mn[1], s_mn[2]) != (mn, nn) \
            or s_bc[0] != "slope" or (s_bc[1], s_bc[2]) != (b, c):
        return False
    if (s_mn[3], s_mn[4]) != (s_bc[3], s_bc[4]):
        return False
    if d_mn[0] != "cdist" or (d_mn[1], d_mn[2]) != (mn, nn) \
            or d_mn[3] != (mn[0] - nn[0]) ** 2 + (mn[1] - nn[1]) ** 2:
        return False
    if d_bc[0] != "cdist" or (d_bc[1], d_bc[2]) != (b, c) \
            or not check_coord_distance_sq(d_bc, [ref]):
        return False
    return 4 * d_mn[3] == d_bc[3]


def check_perp_bisector_conclusion(claim, prevs):
    """P equidistant from A and B lies on AB's perpendicular bisector
    (the equidistance characterization, G-CO.C.9)."""
    ref, d1, d2 = prevs
    if claim != ("vperp",) or ref[0] != "cpts" or ref[1] != "AB_P":
        return False
    a, b, p = ref[2]
    if d1[0] != "cdist" or (d1[1], d1[2]) != (p, a) \
            or not check_coord_distance_sq(d1, [ref]):
        return False
    if d2[0] != "cdist" or (d2[1], d2[2]) != (p, b) \
            or not check_coord_distance_sq(d2, [ref]):
        return False
    return d1[3] == d2[3]


def check_centroid_conclusion(claim, prevs):
    """The medians are concurrent: one exhibited point is collinear
    with each vertex and the opposite side's midpoint (midpoints
    re-verified; the common point must be shared by all three
    collinearity lines)."""
    ref = prevs[0]
    mids = prevs[1:4]
    cols = prevs[4:7]
    if claim != ("vcentroid",) or ref[0] != "cpts" or ref[1] != "ABC" \
            or len(prevs) != 7:
        return False
    verts = ref[2]
    opposite = ((verts[1], verts[2]), (verts[0], verts[2]),
                (verts[0], verts[1]))
    g_points = set()
    for i, (mid, col) in enumerate(zip(mids, cols)):
        if mid[0] != "mid" or (mid[1], mid[2]) != opposite[i] \
                or not check_midpoint(mid, [ref]):
            return False
        if col[0] != "collin" or col[1] != verts[i] \
                or col[3] != mid[3] or not check_collinear(col, [ref]):
            return False
        g_points.add(col[2])
    return len(g_points) == 1


# ---------------------------------------------------------------------------
# Proof-by-contradiction statements — the reductio format on linear
# Diophantine solvability: ASSUME a solution, derive a divisibility
# impossibility, discharge. Forms:
#
#   ("deq", a, b, c)        the equation 6x + 5 = 40        (premise)
#   ("dassume", a, b, c)    assume an integer x satisfies ...
#   ("isolate", a, v)       then 6x = 35
#   ("dremainder", v, q, a, r)   35 = 5·6 + 5
#   ("dnosol", a, b, c)     ... has no integer solution
#   ("dsol", a, b, c, x)    x = 5 solves 6x + 5 = 35
# ---------------------------------------------------------------------------

_DI_EQ = re.compile(r"^the equation (\d+)x \+ (\d+) = (\d+)$")
_DI_ASSUME = re.compile(
    r"^assume an integer x satisfies (\d+)x \+ (\d+) = (\d+)$")
_DI_ISOLATE = re.compile(r"^then (\d+)x = (\d+)$")
_DI_REM = re.compile(r"^(\d+) = (\d+)·(\d+) \+ (\d+)$")
_DI_NOSOL = re.compile(r"^the equation (\d+)x \+ (\d+) = (\d+) has no "
                       r"integer solution$")
_DI_SOL = re.compile(r"^x = (\d+) solves (\d+)x \+ (\d+) = (\d+)$")


def render_dioph(node):
    kind = node[0]
    if kind == "deq":
        return f"the equation {node[1]}x + {node[2]} = {node[3]}"
    if kind == "dassume":
        return (f"assume an integer x satisfies {node[1]}x + {node[2]} "
                f"= {node[3]}")
    if kind == "isolate":
        return f"then {node[1]}x = {node[2]}"
    if kind == "dremainder":
        return f"{node[1]} = {node[2]}·{node[3]} + {node[4]}"
    if kind == "dnosol":
        return (f"the equation {node[1]}x + {node[2]} = {node[3]} has "
                f"no integer solution")
    return (f"x = {node[4]} solves {node[1]}x + {node[2]} = {node[3]}")


def parse_dioph(text):
    """Parses a Diophantine-contradiction statement (round-trips)."""
    for regex, kind in ((_DI_ASSUME, "dassume"), (_DI_NOSOL, "dnosol"),
                        (_DI_EQ, "deq"), (_DI_ISOLATE, "isolate"),
                        (_DI_REM, "dremainder")):
        m = regex.match(text)
        if m:
            return (kind,) + tuple(int(g) for g in m.groups())
    m = _DI_SOL.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("dsol", g[1], g[2], g[3], g[0])
    raise ValueError(f"cannot parse Diophantine statement {text!r}")


def check_isolate_term(claim, prevs):
    """Subtract the constant under the assumption: ax = c - b."""
    deq, assume = prevs
    if claim[0] != "isolate" or deq[0] != "deq" or assume[0] != "dassume" \
            or assume[1:] != deq[1:]:
        return False
    return claim[1] == deq[1] and claim[2] == deq[3] - deq[2]


def check_remainder_witness(claim, prevs):
    """The isolated value's division by a leaves a nonzero remainder."""
    (iso,) = prevs
    if claim[0] != "dremainder" or iso[0] != "isolate":
        return False
    v, q, a, r = claim[1:]
    return (v == iso[2] and a == iso[1] and v == q * a + r
            and 1 <= r < a)


def check_contradiction_conclusion(claim, prevs):
    """Discharge the assumption: ax = v is impossible when a does not
    divide v, so no integer solution exists."""
    deq, iso, rem = prevs
    if claim[0] != "dnosol" or deq[0] != "deq" or iso[0] != "isolate" \
            or rem[0] != "dremainder":
        return False
    if iso[1] != deq[1] or iso[2] != deq[3] - deq[2]:
        return False
    v, q, a, r = rem[1:]
    return (v == iso[2] and a == iso[1] and v == q * a + r
            and 1 <= r < a and claim[1:] == deq[1:])


def check_exhibit_solution(claim, prevs):
    """A direct certificate: the exhibited x satisfies the equation."""
    (deq,) = prevs
    if claim[0] != "dsol" or deq[0] != "deq" or claim[1:4] != deq[1:]:
        return False
    return deq[1] * claim[4] + deq[2] == deq[3]


# ---------------------------------------------------------------------------
# Case-analysis statements — proof by parity cases: n² + cn is always
# even (c odd), CASE n even / CASE n odd, each closed conditionally,
# then joined exhaustively. Forms:
#
#   ("cintro", c)         consider n² + 3n for an integer n  (premise)
#   ("dcase", parity)     case: n is even, say n = 2a
#   ("csub", parity, c, rhs)   (2a)² + 3(2a) = 4a² + 6a
#   ("ccase", parity, c)  if n is even then n² + 3n is even
#   ("callcases", c)      n² + 3n is always even
# ---------------------------------------------------------------------------

_CA_INTRO = re.compile(r"^consider n² \+ (\d+)n for an integer n$")
_CA_CASE = re.compile(r"^case: n is (even|odd), say n = 2a( \+ 1)?$")
_CA_SUB_EVEN = re.compile(r"^\(2a\)² \+ (\d+)\(2a\) = (.+)$")
_CA_SUB_ODD = re.compile(
    r"^\(2a \+ 1\)² \+ (\d+)\(2a \+ 1\) = (.+)$")
_CA_CCASE = re.compile(r"^if n is (even|odd) then n² \+ (\d+)n is even$")
_CA_ALL = re.compile(r"^n² \+ (\d+)n is always even$")


def render_cases(node):
    kind = node[0]
    if kind == "cintro":
        return f"consider n² + {node[1]}n for an integer n"
    if kind == "dcase":
        tail = "2a" if node[1] == "even" else "2a + 1"
        return f"case: n is {node[1]}, say n = {tail}"
    if kind == "csub":
        form = "(2a)" if node[1] == "even" else "(2a + 1)"
        return f"{form}² + {node[2]}{form} = {_render_q(node[3])}"
    if kind == "ccase":
        return f"if n is {node[1]} then n² + {node[2]}n is even"
    return f"n² + {node[1]}n is always even"


def parse_cases(text):
    """Parses a case-analysis statement (round-trips)."""
    m = _CA_INTRO.match(text)
    if m:
        return ("cintro", int(m.group(1)))
    m = _CA_CASE.match(text)
    if m:
        if (m.group(1) == "odd") != (m.group(2) is not None):
            raise ValueError(f"case form mismatch: {text!r}")
        return ("dcase", m.group(1))
    m = _CA_SUB_EVEN.match(text)
    if m:
        return ("csub", "even", int(m.group(1)), _parse_q(m.group(2)))
    m = _CA_SUB_ODD.match(text)
    if m:
        return ("csub", "odd", int(m.group(1)), _parse_q(m.group(2)))
    m = _CA_CCASE.match(text)
    if m:
        return ("ccase", m.group(1), int(m.group(2)))
    m = _CA_ALL.match(text)
    if m:
        return ("callcases", int(m.group(1)))
    # The case blocks cite quadratic-remainder lines from the
    # algebraic-form language; delegate anything else there.
    return parse_alg(text)


def _case_rhs(parity, c):
    if parity == "even":
        return ("qlin", (("a²", 4), ("a", 2 * c)), 0)
    return ("qlin", (("a²", 4), ("a", 4 + 2 * c)), 1 + c)


def check_case_substitute(claim, prevs):
    """Substitute the case's parametric form into n² + cn, exactly."""
    intro, case = prevs
    if claim[0] != "csub" or intro[0] != "cintro" or case[0] != "dcase" \
            or claim[1] != case[1] or claim[2] != intro[1]:
        return False
    return claim[3] == _case_rhs(claim[1], claim[2])


def check_case_conclusion(claim, prevs):
    """Close one case: under its assumption, the expression factors as
    2·(...) exactly, so it is even in this case."""
    case, sub, rem = prevs
    if claim[0] != "ccase" or case[0] != "dcase" or sub[0] != "csub" \
            or rem[0] not in ("qrem", "remform"):
        return False
    if claim[1] != case[1] or sub[1] != case[1] or claim[2] != sub[2]:
        return False
    if (rem[1][1], rem[1][2]) != (sub[3][1], sub[3][2]) \
            or rem[2] != 2 or rem[4] != 0:
        return False
    return True


def check_exhaustive_parity(claim, prevs):
    """Join the cases: even and odd exhaust the integers, and both
    cases concluded even."""
    c1, c2 = prevs
    if claim[0] != "callcases" or c1[0] != "ccase" or c2[0] != "ccase":
        return False
    return ({c1[1], c2[1]} == {"even", "odd"}
            and c1[2] == c2[2] == claim[1])


# ---------------------------------------------------------------------------
# Pigeonhole statements — the counting principle as a certificate:
# n items into m classes with n > m forces a shared class. Forms:
#
#   ("pgiven", n)      suppose 8 integers are given          (premise)
#   ("pboxes", m)      each integer leaves one of 7 possible remainders
#                      mod 7
#   ("pcount", n, m)   8 integers occupy at most 7 remainder classes,
#                      and 8 > 7
#   ("pverd", n, m)    among any 8 integers, two leave the same
#                      remainder mod 7, so their difference is a
#                      multiple of 7
# ---------------------------------------------------------------------------

_PH_GIVEN = re.compile(r"^suppose (\d+) integers are given$")
_PH_BOXES = re.compile(r"^each integer leaves one of (\d+) possible "
                       r"remainders mod (\d+)$")
_PH_COUNT = re.compile(r"^(\d+) integers occupy at most (\d+) remainder "
                       r"classes, and (\d+) > (\d+)$")
_PH_VERD = re.compile(r"^among any (\d+) integers, two leave the same "
                      r"remainder mod (\d+), so their difference is a "
                      r"multiple of (\d+)$")
_PH_CATS = re.compile(r"^suppose (\d+) items are sorted into (\d+) "
                      r"categories$")
_PH_CHOSEN = re.compile(r"^suppose (\d+) numbers are chosen from "
                        r"1, 2, \.\.\., (\d+)$")
_PH_PARTY = re.compile(r"^at a gathering of (\d+) people, each counts "
                       r"their acquaintances \(acquaintance is mutual, "
                       r"no one counts themselves\)$")
_PH_PART = {
    "pair": re.compile(r"^partition 1, \.\.\., (\d+) into the (\d+) "
                       r"pairs of consecutive numbers \{1, 2\}, "
                       r"\.\.\., \{(\d+), (\d+)\}$"),
    "sumpair": re.compile(r"^partition 1, \.\.\., (\d+) into the (\d+) "
                          r"pairs summing to (\d+): \{1, (\d+)\}, "
                          r"\.\.\., \{(\d+), (\d+)\}$"),
    "oddpart": re.compile(r"^classify each of 1, \.\.\., (\d+) by its "
                          r"odd part; there are (\d+) possible odd "
                          r"parts, and numbers sharing an odd part "
                          r"form a doubling chain$"),
}
_PH_DEG = re.compile(r"^each count is one of the (\d+) values 0, "
                     r"\.\.\., (\d+), but 0 and (\d+) cannot both "
                     r"occur, leaving at most (\d+) possible counts$")
_PH_COUNT2 = re.compile(r"^(\d+) numbers fall into at most (\d+) "
                        r"classes, and (\d+) > (\d+)$")
_PH_CEIL = re.compile(r"^if every category held at most (\d+) items, "
                      r"there would be at most (\d+)·(\d+) = (\d+) < "
                      r"(\d+) items$")
_PH_VERDK = re.compile(r"^among any (\d+) items in (\d+) categories, "
                       r"some category holds at least (\d+)$")
_PH_VERD2 = {
    "pair": re.compile(r"^among any (\d+) numbers chosen from 1 to "
                       r"(\d+), two are consecutive$"),
    "sumpair": re.compile(r"^among any (\d+) numbers chosen from 1 to "
                          r"(\d+), two sum to (\d+)$"),
    "oddpart": re.compile(r"^among any (\d+) numbers chosen from 1 to "
                          r"(\d+), one divides another$"),
}
_PH_VERDDEG = re.compile(r"^at any gathering of (\d+) people, two have "
                         r"the same number of acquaintances$")


def render_pigeon(node):
    kind = node[0]
    if kind == "pgiven":
        return f"suppose {node[1]} integers are given"
    if kind == "pboxes":
        return (f"each integer leaves one of {node[1]} possible "
                f"remainders mod {node[1]}")
    if kind == "pcount":
        return (f"{node[1]} integers occupy at most {node[2]} remainder "
                f"classes, and {node[1]} > {node[2]}")
    if kind == "pcats":
        return (f"suppose {node[1]} items are sorted into {node[2]} "
                f"categories")
    if kind == "pchosen":
        return (f"suppose {node[1]} numbers are chosen from "
                f"1, 2, ..., {node[2]}")
    if kind == "pparty":
        return (f"at a gathering of {node[1]} people, each counts "
                f"their acquaintances (acquaintance is mutual, no one "
                f"counts themselves)")
    if kind == "ppart":
        sub, n, top = node[1], node[2], node[3]
        if sub == "pair":
            return (f"partition 1, ..., {top} into the {n} pairs of "
                    f"consecutive numbers {{1, 2}}, ..., "
                    f"{{{top - 1}, {top}}}")
        if sub == "sumpair":
            return (f"partition 1, ..., {top} into the {n} pairs "
                    f"summing to {top + 1}: {{1, {top}}}, ..., "
                    f"{{{n}, {n + 1}}}")
        return (f"classify each of 1, ..., {top} by its odd part; "
                f"there are {n} possible odd parts, and numbers "
                f"sharing an odd part form a doubling chain")
    if kind == "pdeg":
        n = node[1]
        return (f"each count is one of the {n} values 0, ..., {n - 1}, "
                f"but 0 and {n - 1} cannot both occur, leaving at most "
                f"{n - 1} possible counts")
    if kind == "pcount2":
        return (f"{node[1]} numbers fall into at most {node[2]} "
                f"classes, and {node[1]} > {node[2]}")
    if kind == "pceil":
        n, m, k = node[1], node[2], node[3]
        return (f"if every category held at most {k - 1} items, there "
                f"would be at most {m}·{k - 1} = {m * (k - 1)} < {n} "
                f"items")
    if kind == "pverdk":
        return (f"among any {node[1]} items in {node[2]} categories, "
                f"some category holds at least {node[3]}")
    if kind == "pverd2":
        sub, items, top = node[1], node[2], node[3]
        if sub == "pair":
            return (f"among any {items} numbers chosen from 1 to "
                    f"{top}, two are consecutive")
        if sub == "sumpair":
            return (f"among any {items} numbers chosen from 1 to "
                    f"{top}, two sum to {top + 1}")
        return (f"among any {items} numbers chosen from 1 to {top}, "
                f"one divides another")
    if kind == "pverddeg":
        return (f"at any gathering of {node[1]} people, two have the "
                f"same number of acquaintances")
    return (f"among any {node[1]} integers, two leave the same "
            f"remainder mod {node[2]}, so their difference is a "
            f"multiple of {node[2]}")


def parse_pigeon(text):
    """Parses a pigeonhole statement (round-trips)."""
    m = _PH_GIVEN.match(text)
    if m:
        return ("pgiven", int(m.group(1)))
    m = _PH_BOXES.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"box counts differ: {text!r}")
        return ("pboxes", int(m.group(1)))
    m = _PH_COUNT.match(text)
    if m:
        if m.group(1) != m.group(3) or m.group(2) != m.group(4):
            raise ValueError(f"count restatement differs: {text!r}")
        return ("pcount", int(m.group(1)), int(m.group(2)))
    m = _PH_VERD.match(text)
    if m:
        if m.group(2) != m.group(3):
            raise ValueError(f"moduli differ: {text!r}")
        return ("pverd", int(m.group(1)), int(m.group(2)))
    m = _PH_CATS.match(text)
    if m:
        return ("pcats", int(m.group(1)), int(m.group(2)))
    m = _PH_CHOSEN.match(text)
    if m:
        return ("pchosen", int(m.group(1)), int(m.group(2)))
    m = _PH_PARTY.match(text)
    if m:
        return ("pparty", int(m.group(1)))
    for sub, regex in _PH_PART.items():
        m = regex.match(text)
        if m:
            top, n = int(m.group(1)), int(m.group(2))
            if top != 2 * n:
                raise ValueError(f"partition counts differ: {text!r}")
            return ("ppart", sub, n, top)
    m = _PH_DEG.match(text)
    if m:
        n = int(m.group(1))
        if (int(m.group(2)), int(m.group(3)), int(m.group(4))) \
                != (n - 1, n - 1, n - 1):
            raise ValueError(f"degree counts differ: {text!r}")
        return ("pdeg", n)
    m = _PH_COUNT2.match(text)
    if m:
        if m.group(1) != m.group(3) or m.group(2) != m.group(4):
            raise ValueError(f"count restatement differs: {text!r}")
        return ("pcount2", int(m.group(1)), int(m.group(2)))
    m = _PH_CEIL.match(text)
    if m:
        k1, mm, k2, prod, n = (int(g) for g in m.groups())
        if k1 != k2 or prod != mm * k1:
            raise ValueError(f"ceiling arithmetic differs: {text!r}")
        return ("pceil", n, mm, k1 + 1)
    m = _PH_VERDK.match(text)
    if m:
        return ("pverdk", int(m.group(1)), int(m.group(2)),
                int(m.group(3)))
    for sub, regex in _PH_VERD2.items():
        m = regex.match(text)
        if m:
            items, top = int(m.group(1)), int(m.group(2))
            if sub == "sumpair" and int(m.group(3)) != top + 1:
                raise ValueError(f"pair sum differs: {text!r}")
            return ("pverd2", sub, items, top)
    m = _PH_VERDDEG.match(text)
    if m:
        return ("pverddeg", int(m.group(1)))
    raise ValueError(f"cannot parse pigeonhole statement {text!r}")


def check_remainder_classes(claim, prevs):
    """There are exactly m residue classes mod m."""
    (ref,) = prevs
    return (claim[0] == "pboxes" and ref[0] == "pgiven"
            and claim[1] >= 2)


def check_pigeonhole_step(claim, prevs):
    """More items than classes: n > m, exactly as counted."""
    given, boxes = prevs
    if claim[0] != "pcount" or given[0] != "pgiven" \
            or boxes[0] != "pboxes":
        return False
    n, m = claim[1], claim[2]
    return n == given[1] and m == boxes[1] and n > m


def check_pigeonhole_conclusion(claim, prevs):
    """Two items share a class, so their difference is a multiple
    of m — the pigeonhole principle."""
    (count,) = prevs
    if claim[0] != "pverd" or count[0] != "pcount":
        return False
    return claim[1:] == count[1:]


def check_partition_classes(claim, prevs):
    """Partition 1..2n into n structured classes (pairs, complementary
    sum-pairs, or odd-part doubling chains)."""
    (ref,) = prevs
    if claim[0] != "ppart" or ref[0] != "pchosen":
        return False
    _, sub, n, top = claim
    return top == ref[2] and top == 2 * n and n >= 2


def check_count_vs_classes(claim, prevs):
    """Strictly more numbers than classes, counts matched to the
    cited premise and class structure."""
    source, classes = prevs
    if claim[0] != "pcount2":
        return False
    items, cls = claim[1], claim[2]
    if source[0] == "pchosen":
        if items != source[1]:
            return False
    elif source[0] == "pparty":
        if items != source[1]:
            return False
    else:
        return False
    if classes[0] == "ppart":
        want = classes[2]
    elif classes[0] == "pdeg":
        want = classes[1] - 1
    else:
        return False
    return cls == want and items > cls


def _check_pverd2(sub, claim, prevs):
    part, count = prevs
    if claim[0] != "pverd2" or claim[1] != sub or part[0] != "ppart" \
            or part[1] != sub or count[0] != "pcount2":
        return False
    _, _, items, top = claim
    return (top == part[3] and count[1] == items
            and count[2] == part[2] and items > part[2])


def check_consecutive_pair_conclusion(claim, prevs):
    """Two numbers land in one consecutive pair — so they are
    consecutive."""
    return _check_pverd2("pair", claim, prevs)


def check_sum_pair_conclusion(claim, prevs):
    """Two numbers land in one complementary pair — so they sum to
    2n + 1."""
    return _check_pverd2("sumpair", claim, prevs)


def check_divides_pair_conclusion(claim, prevs):
    """Two numbers share an odd part, so they sit on one doubling
    chain — and the smaller divides the larger."""
    return _check_pverd2("oddpart", claim, prevs)


def check_degree_exclusion(claim, prevs):
    """The handshake lemma's box count: someone knowing everyone and
    someone knowing no one cannot coexist, so at most n - 1 counts."""
    (ref,) = prevs
    return (claim[0] == "pdeg" and ref[0] == "pparty"
            and claim[1] == ref[1] and claim[1] >= 2)


def check_same_degree_conclusion(claim, prevs):
    """n people, at most n - 1 possible counts: two counts coincide."""
    deg, count = prevs
    if claim[0] != "pverddeg" or deg[0] != "pdeg" \
            or count[0] != "pcount2":
        return False
    n = claim[1]
    return deg[1] == n and count[1] == n and count[2] == n - 1


def check_ceiling_count(claim, prevs):
    """The generalized principle's counting core: m classes of at most
    k - 1 items hold at most m(k - 1) < n items."""
    (ref,) = prevs
    if claim[0] != "pceil" or ref[0] != "pcats":
        return False
    n, mm, k = claim[1], claim[2], claim[3]
    return (n == ref[1] and mm == ref[2] and k >= 2
            and mm * (k - 1) < n)


def check_at_least_k_conclusion(claim, prevs):
    """Some category holds at least k = ceil(n/m) items."""
    cats, ceil_line = prevs
    if claim[0] != "pverdk" or cats[0] != "pcats" \
            or ceil_line[0] != "pceil":
        return False
    return claim[1:] == (cats[1], cats[2], ceil_line[3]) \
        and ceil_line[1:] == claim[1:]


# ---------------------------------------------------------------------------
# Construction statements — Euclidea-style compass work verified in
# exact surds: with B - A even, the two-circle intersection points have
# coordinates integer ± integer·√3, exactly representable. Forms:
#
#   ("cseg", a, b)            construction on segment AB with A(0, 0)
#                             and B(6, 2)                    (premise)
#   ("cpt", label, sx, sy)    the circles about A and B through each
#                             other meet at C = (3 - √3, 1 + 3√3)
#                             (components are surd quintuples)
#   ("vequi",)                triangle ABC is equilateral
#   ("vperpc",)               the line through C and the midpoint of AB
#                             is the perpendicular bisector of AB
# ---------------------------------------------------------------------------

_CN_SEG = re.compile(r"^construction on segment AB with "
                     r"A\((-?\d+), (-?\d+)\) and B\((-?\d+), (-?\d+)\)$")
_CN_PT = re.compile(r"^the circles about A and B through each other "
                    r"meet at C = \((.+), (.+)\)$")
_CN_EQUI = "triangle ABC is equilateral"
_CN_PERP = ("the line through C and the midpoint of AB is the "
            "perpendicular bisector of AB")


def render_constr(node):
    kind = node[0]
    if kind == "cseg":
        a, b = node[1], node[2]
        return (f"construction on segment AB with A({a[0]}, {a[1]}) "
                f"and B({b[0]}, {b[1]})")
    if kind == "cpt":
        return (f"the circles about A and B through each other meet "
                f"at C = ({render_surd(node[2])}, "
                f"{render_surd(node[3])})")
    return _CN_EQUI if kind == "vequi" else _CN_PERP


def parse_constr(text):
    """Parses a construction statement (round-trips)."""
    if text == _CN_EQUI:
        return ("vequi",)
    if text == _CN_PERP:
        return ("vperpc",)
    m = _CN_SEG.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        return ("cseg", (g[0], g[1]), (g[2], g[3]))
    m = _CN_PT.match(text)
    if m:
        return ("cpt", "C", parse_surd(m.group(1)),
                parse_surd(m.group(2)))
    raise ValueError(f"cannot parse construction statement {text!r}")


def _surd_int(n):
    return (n, 0, 0, 0, 1)


def _surd_sub(x, y):
    return _surd_add(x, _surd_neg(y))


def _constr_distances_ok(seg, pt):
    """|C-A|² == |C-B|² == |AB|², all in exact surd arithmetic."""
    a, b = seg[1], seg[2]
    cx, cy = pt[2], pt[3]
    ab2 = _surd_int((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)
    for p in (a, b):
        dx = _surd_sub(cx, _surd_int(p[0]))
        dy = _surd_sub(cy, _surd_int(p[1]))
        d2 = _surd_add(_surd_mul(dx, dx), _surd_mul(dy, dy))
        if d2 != ab2:
            return False
    return True


def check_circle_intersection(claim, prevs):
    """The constructed point lies on both circles (radius |AB|),
    verified exactly in Q(√3)."""
    (seg,) = prevs
    if claim[0] != "cpt" or seg[0] != "cseg":
        return False
    return _constr_distances_ok(seg, claim)


def check_equilateral_conclusion(claim, prevs):
    """Euclid I.1: all three sides equal |AB| exactly."""
    seg, pt = prevs
    if claim != ("vequi",) or seg[0] != "cseg" or pt[0] != "cpt":
        return False
    return _constr_distances_ok(seg, pt)


def check_perp_construction_conclusion(claim, prevs):
    """C is equidistant from A and B (re-verified), and so is the
    midpoint — two equidistant points determine the perpendicular
    bisector."""
    seg, pt = prevs
    if claim != ("vperpc",) or seg[0] != "cseg" or pt[0] != "cpt":
        return False
    a, b = seg[1], seg[2]
    if (a[0] + b[0]) % 2 or (a[1] + b[1]) % 2:
        return False
    return _constr_distances_ok(seg, pt)


# ---------------------------------------------------------------------------
# Diagonalization statements — Cantor's move on finite tables: flip the
# diagonal and the result differs from every row. The finite kernel of
# Gödel/Turing-style self-reference. Forms:
#
#   ("dtable", rows)     a table lists 5 binary strings: row 1 = 01101;
#                        ... (premise; rows are equal-length bitstrings)
#   ("dstring", s)       the diagonal-flip string is 10010
#   ("ddiff", i)         the diagonal-flip string differs from row 3 at
#                        position 3
#   ("dconc", s, n)      the diagonal-flip string 10010 differs from
#                        every one of the 5 rows
# ---------------------------------------------------------------------------

_DG_TABLE = re.compile(r"^a table lists (\d+) binary strings: (row \d+ "
                       r"= [01]+(?:; row \d+ = [01]+)*)$")
_DG_ROW = re.compile(r"row (\d+) = ([01]+)")
_DG_STRING = re.compile(r"^the diagonal-flip string is ([01]+)$")
_DG_DIFF = re.compile(r"^the diagonal-flip string differs from row "
                      r"(\d+) at position (\d+)$")
_DG_CONC = re.compile(r"^the diagonal-flip string ([01]+) differs from "
                      r"every one of the (\d+) rows$")


def render_diag(node):
    kind = node[0]
    if kind == "dtable":
        rows = "; ".join(f"row {i} = {r}"
                         for i, r in enumerate(node[1], start=1))
        return f"a table lists {len(node[1])} binary strings: {rows}"
    if kind == "dstring":
        return f"the diagonal-flip string is {node[1]}"
    if kind == "ddiff":
        return (f"the diagonal-flip string differs from row {node[1]} "
                f"at position {node[1]}")
    return (f"the diagonal-flip string {node[1]} differs from every "
            f"one of the {node[2]} rows")


def parse_diag(text):
    """Parses a diagonalization statement (round-trips)."""
    m = _DG_TABLE.match(text)
    if m:
        rows = tuple(r for _, r in _DG_ROW.findall(m.group(2)))
        if len(rows) != int(m.group(1)):
            raise ValueError(f"row count differs: {text!r}")
        return ("dtable", rows)
    m = _DG_STRING.match(text)
    if m:
        return ("dstring", m.group(1))
    m = _DG_DIFF.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"diagonal position differs: {text!r}")
        return ("ddiff", int(m.group(1)))
    m = _DG_CONC.match(text)
    if m:
        return ("dconc", m.group(1), int(m.group(2)))
    raise ValueError(f"cannot parse diagonalization statement {text!r}")


def check_diagonal_construction(claim, prevs):
    """Flip the table's diagonal, bit by bit."""
    (table,) = prevs
    if claim[0] != "dstring" or table[0] != "dtable":
        return False
    rows = table[1]
    n = len(rows)
    if any(len(r) != n for r in rows) or len(claim[1]) != n:
        return False
    return all(claim[1][i] != rows[i][i] for i in range(n))


def check_row_difference(claim, prevs):
    """The flip string differs from row i at position i, by
    construction — verified against both cited lines."""
    table, string = prevs
    if claim[0] != "ddiff" or table[0] != "dtable" \
            or string[0] != "dstring":
        return False
    i = claim[1]
    rows = table[1]
    return (1 <= i <= len(rows) and len(string[1]) == len(rows)
            and string[1][i - 1] != rows[i - 1][i - 1])


def check_diagonalization_conclusion(claim, prevs):
    """The flip string equals no row: every row is covered by a
    re-verified difference line — Cantor's argument, closed."""
    table, string = prevs[0], prevs[1]
    diffs = prevs[2:]
    if claim[0] != "dconc" or table[0] != "dtable" \
            or string[0] != "dstring" or claim[1] != string[1]:
        return False
    rows = table[1]
    if claim[2] != len(rows):
        return False
    covered = set()
    for d in diffs:
        if d[0] != "ddiff" \
                or string[1][d[1] - 1] == rows[d[1] - 1][d[1] - 1]:
            return False
        covered.add(d[1])
    return covered >= set(range(1, len(rows) + 1))


# ---------------------------------------------------------------------------
# Arithmetization statements — Boolean formulas as polynomials, and
# counting by summation: ¬x -> (1 - x), (l1 ∨ l2) -> l1 + l2 - l1·l2,
# ∧ -> product. Formulas are conjunctions of two-literal clauses over
# x, y, z. Forms:
#
#   ("aform", clauses)   φ = (x ∨ ¬y) ∧ (y ∨ z)   — clause = pair of
#                        (var, negated) literals            (premise)
#   ("apoly", clauses)   the arithmetization is p = ...
#   ("apoint", bits, v)  p(1, 0, 1) = 1
#   ("acount", c)        summing p over all 8 Boolean points gives c,
#                        so φ has exactly c satisfying assignments
# ---------------------------------------------------------------------------

_AR_VARS = ("x", "y", "z")
_AR_LIT = r"(?:¬?[xyz])"
_AR_FORM = re.compile(rf"^φ = \(({_AR_LIT}) ∨ ({_AR_LIT})\) ∧ "
                      rf"\(({_AR_LIT}) ∨ ({_AR_LIT})\)$")
_AR_TERM = r"(?:[xyz]|\(1 - [xyz]\))"
_AR_POLY = re.compile(
    rf"^the arithmetization is p = \(({_AR_TERM}) \+ ({_AR_TERM}) - "
    rf"({_AR_TERM})·({_AR_TERM})\)·\(({_AR_TERM}) \+ ({_AR_TERM}) - "
    rf"({_AR_TERM})·({_AR_TERM})\)$")
_AR_POINT = re.compile(r"^p\(([01]), ([01]), ([01])\) = ([01])$")
_AR_COUNT = re.compile(r"^summing p over all 8 Boolean points gives "
                       r"(\d+), so φ has exactly (\d+) satisfying "
                       r"assignments$")


def _ar_lit(lit):
    var, neg = lit
    return f"¬{var}" if neg else var


def _ar_term(lit):
    var, neg = lit
    return f"(1 - {var})" if neg else var


def _ar_parse_lit(text):
    return (text[-1], text.startswith("¬"))


def _ar_parse_term(text):
    if text.startswith("("):
        return (text[-2], True)
    return (text, False)


def render_arith(node):
    kind = node[0]
    if kind == "aform":
        parts = [f"({_ar_lit(c[0])} ∨ {_ar_lit(c[1])})"
                 for c in node[1]]
        return "φ = " + " ∧ ".join(parts)
    if kind == "apoly":
        parts = []
        for c in node[1]:
            a, b = _ar_term(c[0]), _ar_term(c[1])
            parts.append(f"({a} + {b} - {a}·{b})")
        return "the arithmetization is p = " + "·".join(parts)
    if kind == "apoint":
        b = node[1]
        return f"p({b[0]}, {b[1]}, {b[2]}) = {node[2]}"
    return (f"summing p over all 8 Boolean points gives {node[1]}, "
            f"so φ has exactly {node[1]} satisfying assignments")


def parse_arith(text):
    """Parses an arithmetization statement (round-trips)."""
    m = _AR_FORM.match(text)
    if m:
        g = m.groups()
        return ("aform", ((_ar_parse_lit(g[0]), _ar_parse_lit(g[1])),
                          (_ar_parse_lit(g[2]), _ar_parse_lit(g[3]))))
    m = _AR_POLY.match(text)
    if m:
        g = m.groups()
        if g[0] != g[2] or g[1] != g[3] or g[4] != g[6] or g[5] != g[7]:
            raise ValueError(f"clause terms inconsistent: {text!r}")
        return ("apoly", ((_ar_parse_term(g[0]), _ar_parse_term(g[1])),
                          (_ar_parse_term(g[4]), _ar_parse_term(g[5]))))
    m = _AR_POINT.match(text)
    if m:
        return ("apoint", tuple(int(b) for b in m.groups()[:3]),
                int(m.group(4)))
    m = _AR_COUNT.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"count restatement differs: {text!r}")
        return ("acount", int(m.group(1)))
    raise ValueError(f"cannot parse arithmetization statement {text!r}")


def _ar_eval(clauses, bits):
    env = dict(zip(_AR_VARS, bits))
    value = 1
    for c in clauses:
        vals = [1 - env[v] if neg else env[v] for v, neg in c]
        value *= vals[0] + vals[1] - vals[0] * vals[1]
    return value


def check_arithmetize(claim, prevs):
    """The standard translation, clause for clause."""
    (form,) = prevs
    return (claim[0] == "apoly" and form[0] == "aform"
            and claim[1] == form[1])


def check_evaluate_arithmetization(claim, prevs):
    """One Boolean point evaluated exactly (0/1 in, 0/1 out)."""
    form, poly = prevs
    if claim[0] != "apoint" or form[0] != "aform" or poly[0] != "apoly" \
            or poly[1] != form[1]:
        return False
    return claim[2] == _ar_eval(form[1], claim[1])


def check_arithmetization_count(claim, prevs):
    """Sum the polynomial over the Boolean cube: counting by
    summation — every point covered by a re-verified evaluation."""
    form, poly = prevs[0], prevs[1]
    points = prevs[2:]
    if claim[0] != "acount" or form[0] != "aform" or poly[0] != "apoly" \
            or poly[1] != form[1]:
        return False
    seen = {}
    for pt in points:
        if pt[0] != "apoint" or pt[2] != _ar_eval(form[1], pt[1]):
            return False
        seen[pt[1]] = pt[2]
    cube = [(a, b, c) for a in (0, 1) for b in (0, 1) for c in (0, 1)]
    if set(seen) != set(cube):
        return False
    return claim[1] == sum(seen.values())


# ---------------------------------------------------------------------------
# Low-degree distance statements — two distinct polynomials of degree
# at most d over F_p agree on at most d points: the error-detecting
# heart of PCPs and codes. Coefficients are little-endian tuples;
# renderings are canonical (nonzero leading term, mod-p residues).
# ---------------------------------------------------------------------------

_RS_PAIR = re.compile(r"^over F_(\d+), f = (.+) and g = (.+)$")
_RS_DIFF = re.compile(r"^f - g ≡ (.+) \(mod (\d+)\)$")
_RS_DEG = re.compile(r"^f - g is nonzero of degree (\d+), so f and g "
                     r"agree on at most (\d+) points$")
_RS_AGREE = re.compile(r"^f and g agree exactly at x ∈ \{(\d*(?:, \d+)*)\}"
                       r", (\d+) of the (\d+) points$")
_RS_CONC = re.compile(r"^distinct polynomials of degree at most (\d+) "
                      r"agree on at most (\d+) of the (\d+) points; f "
                      r"and g agree on only (\d+)$")
_RS_TERM = re.compile(r"^(\d+)?(?:x(?:\^(\d+))?)?$")


def _rs_render(coeffs):
    parts = []
    for i in range(len(coeffs) - 1, -1, -1):
        c = coeffs[i]
        if c == 0:
            continue
        if i == 0:
            parts.append(str(c))
        else:
            xs = "x" if i == 1 else f"x^{i}"
            parts.append(xs if c == 1 else f"{c}{xs}")
    return " + ".join(parts) if parts else "0"


def _rs_parse(text):
    coeffs = {}
    if text == "0":
        return (0,)
    for part in text.split(" + "):
        m = _RS_TERM.match(part)
        if not m or (m.group(1) is None and "x" not in part):
            raise ValueError(f"cannot parse polynomial term {part!r}")
        coef = int(m.group(1)) if m.group(1) else 1
        if "x" not in part:
            power = 0
        elif m.group(2):
            power = int(m.group(2))
        else:
            power = 1
        coeffs[power] = coeffs.get(power, 0) + coef
    top = max(coeffs)
    return tuple(coeffs.get(i, 0) for i in range(top + 1))


def _rs_eval(coeffs, x, p):
    total = 0
    for c in reversed(coeffs):
        total = (total * x + c) % p
    return total


def render_rs(node):
    kind = node[0]
    if kind == "rspair":
        return (f"over F_{node[1]}, f = {_rs_render(node[2])} and "
                f"g = {_rs_render(node[3])}")
    if kind == "rsdiff":
        return f"f - g ≡ {_rs_render(node[1])} (mod {node[2]})"
    if kind == "rsdeg":
        return (f"f - g is nonzero of degree {node[1]}, so f and g "
                f"agree on at most {node[1]} points")
    if kind == "rsagree":
        pts = ", ".join(str(v) for v in node[1])
        return (f"f and g agree exactly at x ∈ {{{pts}}}, "
                f"{len(node[1])} of the {node[2]} points")
    return (f"distinct polynomials of degree at most {node[1]} agree "
            f"on at most {node[1]} of the {node[3]} points; f and g "
            f"agree on only {node[2]}")


def parse_rs(text):
    """Parses a low-degree-distance statement (round-trips)."""
    m = _RS_PAIR.match(text)
    if m:
        return ("rspair", int(m.group(1)), _rs_parse(m.group(2)),
                _rs_parse(m.group(3)))
    m = _RS_DIFF.match(text)
    if m:
        return ("rsdiff", _rs_parse(m.group(1)), int(m.group(2)))
    m = _RS_DEG.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"degree bound differs: {text!r}")
        return ("rsdeg", int(m.group(1)))
    m = _RS_AGREE.match(text)
    if m:
        pts = tuple(int(v) for v in m.group(1).split(", ")) \
            if m.group(1) else ()
        if len(pts) != int(m.group(2)):
            raise ValueError(f"agreement count differs: {text!r}")
        return ("rsagree", pts, int(m.group(3)))
    m = _RS_CONC.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"bound restatement differs: {text!r}")
        return ("rsconc", int(m.group(1)), int(m.group(4)),
                int(m.group(3)))
    raise ValueError(f"cannot parse distance statement {text!r}")


def check_poly_difference(claim, prevs):
    """f - g reduced mod p, coefficientwise, in canonical form."""
    (pair,) = prevs
    if claim[0] != "rsdiff" or pair[0] != "rspair" \
            or claim[2] != pair[1]:
        return False
    p, f, g = pair[1], pair[2], pair[3]
    top = max(len(f), len(g))
    fa = list(f) + [0] * (top - len(f))
    ga = list(g) + [0] * (top - len(g))
    diff = [(a - b) % p for a, b in zip(fa, ga)]
    while len(diff) > 1 and diff[-1] == 0:
        diff.pop()
    return tuple(diff) != (0,) and claim[1] == tuple(diff)


def check_degree_root_bound(claim, prevs):
    """A nonzero polynomial of degree d has at most d roots — so f
    and g agree on at most d points."""
    (diff,) = prevs
    if claim[0] != "rsdeg" or diff[0] != "rsdiff":
        return False
    h = diff[1]
    return h != (0,) and claim[1] == len(h) - 1


def check_agreement_points(claim, prevs):
    """The exact agreement set, verified exhaustively over F_p."""
    (pair,) = prevs
    if claim[0] != "rsagree" or pair[0] != "rspair":
        return False
    p, f, g = pair[1], pair[2], pair[3]
    if claim[2] != p:
        return False
    agree = tuple(x for x in range(p)
                  if _rs_eval(f, x, p) == _rs_eval(g, x, p))
    return claim[1] == agree


def check_distance_conclusion(claim, prevs):
    """The lie spreads: agreement count is within the degree bound."""
    pair, deg, agree = prevs
    if claim[0] != "rsconc" or pair[0] != "rspair" \
            or deg[0] != "rsdeg" or agree[0] != "rsagree":
        return False
    dmax = max(len(pair[2]), len(pair[3])) - 1
    return (claim[1] == dmax and deg[1] <= dmax
            and claim[2] == len(agree[1]) and claim[3] == pair[1]
            and len(agree[1]) <= dmax)


# ---------------------------------------------------------------------------
# Frobenius/AKS statements — the child's binomial identity
# (x + 1)^n ≡ x^n + 1 (mod n) holds exactly for primes; a composite n
# is refuted by one bad binomial coefficient. Forms below.
# ---------------------------------------------------------------------------

_FR_INT = re.compile(r"^consider the coefficients of \(x \+ 1\)\^(\d+) "
                     r"modulo (\d+)$")
_FR_COEF = re.compile(r"^C\((\d+), (\d+)\) = (\d+) ≡ (\d+) "
                      r"\(mod (\d+)\)$")
_FR_PRIME = re.compile(r"^every middle coefficient of \(x \+ 1\)\^(\d+) "
                       r"is divisible by (\d+), so \(x \+ 1\)\^(\d+) ≡ "
                       r"x\^(\d+) \+ 1 \(mod (\d+)\)$")
_FR_REF = re.compile(r"^C\((\d+), (\d+)\) ≡ (\d+) ≢ 0, so "
                     r"\(x \+ 1\)\^(\d+) ≢ x\^(\d+) \+ 1 "
                     r"\(mod (\d+)\)$")


def render_frob(node):
    kind = node[0]
    if kind == "fint":
        return (f"consider the coefficients of (x + 1)^{node[1]} "
                f"modulo {node[1]}")
    if kind == "fcoef":
        return (f"C({node[1]}, {node[2]}) = {node[3]} ≡ {node[4]} "
                f"(mod {node[1]})")
    if kind == "fprime":
        n = node[1]
        return (f"every middle coefficient of (x + 1)^{n} is divisible "
                f"by {n}, so (x + 1)^{n} ≡ x^{n} + 1 (mod {n})")
    n, k, r = node[1], node[2], node[3]
    return (f"C({n}, {k}) ≡ {r} ≢ 0, so (x + 1)^{n} ≢ x^{n} + 1 "
            f"(mod {n})")


def parse_frob(text):
    """Parses a Frobenius-identity statement (round-trips)."""
    m = _FR_INT.match(text)
    if m:
        if m.group(1) != m.group(2):
            raise ValueError(f"modulus differs: {text!r}")
        return ("fint", int(m.group(1)))
    m = _FR_COEF.match(text)
    if m:
        if m.group(1) != m.group(5):
            raise ValueError(f"modulus differs: {text!r}")
        return ("fcoef", int(m.group(1)), int(m.group(2)),
                int(m.group(3)), int(m.group(4)))
    m = _FR_PRIME.match(text)
    if m:
        if len(set(m.groups())) != 1:
            raise ValueError(f"exponents differ: {text!r}")
        return ("fprime", int(m.group(1)))
    m = _FR_REF.match(text)
    if m:
        if not m.group(1) == m.group(4) == m.group(6):
            raise ValueError(f"exponents differ: {text!r}")
        return ("fref", int(m.group(1)), int(m.group(2)),
                int(m.group(3)))
    raise ValueError(f"cannot parse Frobenius statement {text!r}")


def check_binomial_coefficient(claim, prevs):
    """One binomial coefficient and its residue, exactly."""
    (ref,) = prevs
    if claim[0] != "fcoef" or ref[0] != "fint" or claim[1] != ref[1]:
        return False
    n, k, v, r = claim[1:]
    if not 1 <= k <= n - 1:
        return False
    from math import comb
    return v == comb(n, k) and r == v % n


def check_frobenius_conclusion(claim, prevs):
    """Every middle coefficient vanishes mod n: the identity holds
    (each coefficient re-verified, full coverage required)."""
    ref = prevs[0]
    coefs = prevs[1:]
    if claim[0] != "fprime" or ref[0] != "fint" or claim[1] != ref[1]:
        return False
    from math import comb
    n = claim[1]
    seen = set()
    for c in coefs:
        if c[0] != "fcoef" or c[1] != n or c[3] != comb(n, c[2]) \
                or c[4] != c[3] % n or c[4] != 0:
            return False
        seen.add(c[2])
    return seen >= set(range(1, n))


def check_frobenius_refutation(claim, prevs):
    """One nonvanishing coefficient refutes the identity — and with
    it, primality of n."""
    ref, coef = prevs
    if claim[0] != "fref" or ref[0] != "fint" or coef[0] != "fcoef" \
            or claim[1] != ref[1]:
        return False
    from math import comb
    n, k, r = claim[1], claim[2], claim[3]
    return (coef[1] == n and coef[2] == k and coef[4] == r
            and r >= 1 and comb(n, k) % n == r)


# ---------------------------------------------------------------------------
# Reachability statements — Immerman–Szelepcsényi's kernel: certify
# reachable sets layer by layer with counts, close the set, and
# conclude NON-reachability; or exhibit a path for the dual. Forms
# below (directed edges u→v; vertex sets in braces).
# ---------------------------------------------------------------------------

_RE_GRAPH = re.compile(r"^a directed graph on (\d+) vertices has edges "
                       r"((?:\d+→\d+)(?:, \d+→\d+)*); start (\d+), "
                       r"target (\d+)$")
_RE_EDGE = re.compile(r"(\d+)→(\d+)")
_RE_LAYER = re.compile(r"^after step (\d+), the reachable set is "
                       r"\{(\d+(?:, \d+)*)\}, of size (\d+)$")
_RE_CLOSED = re.compile(r"^the set \{(\d+(?:, \d+)*)\} is closed: no "
                        r"edge leaves it$")
_RE_UNREACH = re.compile(r"^vertex (\d+) is not reachable from (\d+): "
                         r"it lies outside a closed set containing "
                         r"(\d+)$")
_RE_PATH = re.compile(r"^the path (\d+(?:→\d+)+) runs from start to "
                      r"target$")
_RE_REACH = re.compile(r"^vertex (\d+) is reachable from (\d+)$")


def render_reach(node):
    kind = node[0]
    if kind == "rgraph":
        edges = ", ".join(f"{u}→{v}" for u, v in node[2])
        return (f"a directed graph on {node[1]} vertices has edges "
                f"{edges}; start {node[3]}, target {node[4]}")
    if kind == "rlayer":
        verts = ", ".join(str(v) for v in node[2])
        return (f"after step {node[1]}, the reachable set is "
                f"{{{verts}}}, of size {len(node[2])}")
    if kind == "rclosed":
        verts = ", ".join(str(v) for v in node[1])
        return f"the set {{{verts}}} is closed: no edge leaves it"
    if kind == "runreach":
        return (f"vertex {node[1]} is not reachable from {node[2]}: it "
                f"lies outside a closed set containing {node[2]}")
    if kind == "rpath":
        return (f"the path {'→'.join(str(v) for v in node[1])} runs "
                f"from start to target")
    return f"vertex {node[1]} is reachable from {node[2]}"


def parse_reach(text):
    """Parses a reachability statement (round-trips)."""
    m = _RE_GRAPH.match(text)
    if m:
        edges = tuple((int(u), int(v))
                      for u, v in _RE_EDGE.findall(m.group(2)))
        return ("rgraph", int(m.group(1)), edges, int(m.group(3)),
                int(m.group(4)))
    m = _RE_LAYER.match(text)
    if m:
        verts = tuple(int(v) for v in m.group(2).split(", "))
        if len(verts) != int(m.group(3)):
            raise ValueError(f"layer count differs: {text!r}")
        return ("rlayer", int(m.group(1)), verts)
    m = _RE_CLOSED.match(text)
    if m:
        return ("rclosed", tuple(int(v) for v in m.group(1).split(", ")))
    m = _RE_UNREACH.match(text)
    if m:
        if m.group(2) != m.group(3):
            raise ValueError(f"start restatement differs: {text!r}")
        return ("runreach", int(m.group(1)), int(m.group(2)))
    m = _RE_PATH.match(text)
    if m:
        return ("rpath", tuple(int(v) for v in m.group(1).split("→")))
    m = _RE_REACH.match(text)
    if m:
        return ("rreach", int(m.group(1)), int(m.group(2)))
    raise ValueError(f"cannot parse reachability statement {text!r}")


def check_reach_layer(claim, prevs):
    """One expansion step: the new layer is the old one plus all
    out-neighbors, with its size certified — inductive counting."""
    graph, prev = prevs
    if claim[0] != "rlayer" or graph[0] != "rgraph":
        return False
    if prev[0] == "rgraph":
        prev_set = {graph[3]}
        want_step = 1
    elif prev[0] == "rlayer":
        prev_set = set(prev[2])
        want_step = prev[1] + 1
    else:
        return False
    if claim[1] != want_step:
        return False
    grown = set(prev_set)
    for u, v in graph[2]:
        if u in prev_set:
            grown.add(v)
    return set(claim[2]) == grown \
        and claim[2] == tuple(sorted(claim[2]))


def check_reach_closure(claim, prevs):
    """No edge leaves the certified set."""
    graph, layer = prevs
    if claim[0] != "rclosed" or graph[0] != "rgraph" \
            or layer[0] != "rlayer" or set(claim[1]) != set(layer[2]):
        return False
    s = set(claim[1])
    return all(v in s for u, v in graph[2] if u in s)


def check_nonreachable_conclusion(claim, prevs):
    """The target sits outside a closed set containing the start —
    so no path can ever leave the set to reach it."""
    graph, closed = prevs
    if claim[0] != "runreach" or graph[0] != "rgraph" \
            or closed[0] != "rclosed":
        return False
    s = set(closed[1])
    if not all(v in s for u, v in graph[2] if u in s):
        return False
    return (claim[1] == graph[4] and claim[2] == graph[3]
            and graph[3] in s and graph[4] not in s)


def check_reach_path(claim, prevs):
    """An explicit start-to-target walk along real edges."""
    (graph,) = prevs
    if claim[0] != "rpath" or graph[0] != "rgraph":
        return False
    path = claim[1]
    if len(path) < 2 or path[0] != graph[3] or path[-1] != graph[4]:
        return False
    edges = set(graph[2])
    return all((path[i], path[i + 1]) in edges
               for i in range(len(path) - 1))


def check_reachable_conclusion(claim, prevs):
    """Reachability from the exhibited path."""
    graph, path = prevs
    if claim[0] != "rreach" or graph[0] != "rgraph" \
            or path[0] != "rpath":
        return False
    return (claim[1] == graph[4] and claim[2] == graph[3]
            and check_reach_path(path, [graph]))


# ---------------------------------------------------------------------------
# Order-finding statements — Shor's classical engine: certify the
# multiplicative order (with minimality via maximal proper divisors)
# and extract factors from an even order. Forms below.
# ---------------------------------------------------------------------------

_OR_NM = re.compile(r"^consider a = (\d+) modulo N = (\d+)$")
_OR_POW = re.compile(r"^(\d+)\^(\d+) ≡ (\d+) \(mod (\d+)\)$")
_OR_ORD = re.compile(r"^the order of (\d+) modulo (\d+) is (\d+)$")
_OR_FACT = re.compile(r"^gcd\((\d+)\^(\d+) - 1, (\d+)\) = (\d+) and "
                      r"gcd\((\d+)\^(\d+) \+ 1, (\d+)\) = (\d+), so "
                      r"(\d+) = (\d+)·(\d+)$")


def render_order(node):
    kind = node[0]
    if kind == "onm":
        return f"consider a = {node[1]} modulo N = {node[2]}"
    if kind == "opow":
        return f"{node[1]}^{node[2]} ≡ {node[3]} (mod {node[4]})"
    if kind == "order":
        return f"the order of {node[1]} modulo {node[2]} is {node[3]}"
    a, h, n, g1, g2 = node[1], node[2], node[3], node[4], node[5]
    return (f"gcd({a}^{h} - 1, {n}) = {g1} and gcd({a}^{h} + 1, {n}) "
            f"= {g2}, so {n} = {g1}·{g2}")


def parse_order(text):
    """Parses an order-finding statement (round-trips)."""
    m = _OR_NM.match(text)
    if m:
        return ("onm", int(m.group(1)), int(m.group(2)))
    m = _OR_POW.match(text)
    if m:
        return ("opow",) + tuple(int(g) for g in m.groups())
    m = _OR_ORD.match(text)
    if m:
        return ("order",) + tuple(int(g) for g in m.groups())
    m = _OR_FACT.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        if g[0] != g[4] or g[1] != g[5] or g[2] != g[6] or g[2] != g[8] \
                or (g[3], g[7]) != (g[9], g[10]):
            raise ValueError(f"extraction restatement differs: {text!r}")
        return ("ofact", g[0], g[1], g[2], g[3], g[7])
    raise ValueError(f"cannot parse order statement {text!r}")


def check_modular_power(claim, prevs):
    """One modular power, exactly."""
    (ref,) = prevs
    if claim[0] != "opow" or ref[0] != "onm":
        return False
    a, k, v, n = claim[1:]
    return (a, n) == (ref[1], ref[2]) and k >= 1 \
        and v == pow(a, k, n)


def check_order_conclusion(claim, prevs):
    """The order is r: a^r ≡ 1, and a^(r/q) ≢ 1 for every maximal
    proper divisor r/q (q a prime factor of r) — minimality certified
    by exactly the right witnesses."""
    ref = prevs[0]
    powers = prevs[1:]
    if claim[0] != "order" or ref[0] != "onm" \
            or (claim[1], claim[2]) != (ref[1], ref[2]):
        return False
    a, n, r = claim[1], claim[2], claim[3]
    if pow(a, r, n) != 1:
        return False
    needed = set()
    q = 2
    rr = r
    while q * q <= rr:
        if rr % q == 0:
            needed.add(r // q)
            while rr % q == 0:
                rr //= q
        q += 1
    if rr > 1:
        needed.add(r // rr)
    seen_one = False
    seen = set()
    for p in powers:
        if p[0] != "opow" or (p[1], p[4]) != (a, n) \
                or p[3] != pow(a, p[2], n):
            return False
        if p[2] == r and p[3] == 1:
            seen_one = True
        elif p[2] in needed and p[3] != 1:
            seen.add(p[2])
    return seen_one and seen >= needed


def check_shor_extraction(claim, prevs):
    """Shor's classical payoff: an even order splits N through the
    gcds of a^(r/2) ± 1 with N — both re-computed exactly."""
    ref, order = prevs
    if claim[0] != "ofact" or ref[0] != "onm" or order[0] != "order":
        return False
    a, n, r = order[1], order[2], order[3]
    if (claim[1], claim[3]) != (a, n) or r % 2 or claim[2] != r // 2:
        return False
    x = pow(a, r // 2, n)
    g1, g2 = gcd(x - 1, n), gcd(x + 1, n)
    return (claim[4], claim[5]) == (g1, g2) and 1 < g1 < n \
        and 1 < g2 < n and g1 * g2 == n


# ---------------------------------------------------------------------------
# Trapdoor statements — RSA round-trips and Diffie-Hellman agreement:
# easy forward, inverted only through the secret. Forms below.
# ---------------------------------------------------------------------------

_TD_KEY = re.compile(r"^let p = (\d+), q = (\d+), and e = (\d+)$")
_TD_N = re.compile(r"^then N = (\d+) and φ\(N\) = (\d+)$")
_TD_D = re.compile(r"^d = (\d+) inverts e: (\d+)·(\d+) ≡ 1 "
                   r"\(mod (\d+)\)$")
_TD_TRIP = re.compile(r"^for m = (\d+): (\d+)\^(\d+) ≡ (\d+) "
                      r"\(mod (\d+)\) and (\d+)\^(\d+) ≡ (\d+) "
                      r"\(mod (\d+)\)$")
_TD_CONC = re.compile(r"^exponentiation by e = (\d+) is a trapdoor: "
                      r"the secret d = (\d+) inverts it modulo (\d+)$")
_TD_DH = re.compile(r"^let p = (\d+) and g = (\d+), with secrets "
                    r"a = (\d+) and b = (\d+)$")
_TD_DHP = re.compile(r"^(\d+)\^(\d+) ≡ (\d+) \(mod (\d+)\)$")
_TD_DHA = re.compile(r"^both parties compute the same shared secret: "
                     r"(\d+)\^(\d+) ≡ (\d+)\^(\d+) ≡ (\d+) "
                     r"\(mod (\d+)\)$")


def render_trapdoor(node):
    kind = node[0]
    if kind == "rsakey":
        return f"let p = {node[1]}, q = {node[2]}, and e = {node[3]}"
    if kind == "rsan":
        return f"then N = {node[1]} and φ(N) = {node[2]}"
    if kind == "rsad":
        return (f"d = {node[1]} inverts e: {node[2]}·{node[1]} ≡ 1 "
                f"(mod {node[3]})")
    if kind == "rsatrip":
        m, e, c, d, n = node[1], node[2], node[3], node[4], node[5]
        return (f"for m = {m}: {m}^{e} ≡ {c} (mod {n}) and {c}^{d} ≡ "
                f"{m} (mod {n})")
    if kind == "rsaconc":
        return (f"exponentiation by e = {node[1]} is a trapdoor: the "
                f"secret d = {node[2]} inverts it modulo {node[3]}")
    if kind == "dhsetup":
        return (f"let p = {node[1]} and g = {node[2]}, with secrets "
                f"a = {node[3]} and b = {node[4]}")
    if kind == "dhpow":
        return f"{node[1]}^{node[2]} ≡ {node[3]} (mod {node[4]})"
    return (f"both parties compute the same shared secret: {node[1]}^"
            f"{node[2]} ≡ {node[3]}^{node[4]} ≡ {node[5]} "
            f"(mod {node[6]})")


def parse_trapdoor(text):
    """Parses a trapdoor statement (round-trips)."""
    m = _TD_KEY.match(text)
    if m:
        return ("rsakey",) + tuple(int(g) for g in m.groups())
    m = _TD_N.match(text)
    if m:
        return ("rsan", int(m.group(1)), int(m.group(2)))
    m = _TD_D.match(text)
    if m:
        if m.group(1) != m.group(3):
            raise ValueError(f"inverse restatement differs: {text!r}")
        return ("rsad", int(m.group(1)), int(m.group(2)),
                int(m.group(4)))
    m = _TD_TRIP.match(text)
    if m:
        g = [int(v) for v in m.groups()]
        if g[0] != g[1] or g[3] != g[5] or g[0] != g[7] or g[4] != g[8]:
            raise ValueError(f"round-trip restatement differs: {text!r}")
        return ("rsatrip", g[0], g[2], g[3], g[6], g[4])
    m = _TD_CONC.match(text)
    if m:
        return ("rsaconc",) + tuple(int(g) for g in m.groups())
    m = _TD_DH.match(text)
    if m:
        return ("dhsetup",) + tuple(int(g) for g in m.groups())
    m = _TD_DHA.match(text)
    if m:
        return ("dhagree",) + tuple(int(g) for g in m.groups())
    m = _TD_DHP.match(text)
    if m:
        return ("dhpow",) + tuple(int(g) for g in m.groups())
    raise ValueError(f"cannot parse trapdoor statement {text!r}")


def check_rsa_setup(claim, prevs):
    """N = pq and φ = (p-1)(q-1), exactly."""
    (key,) = prevs
    if claim[0] != "rsan" or key[0] != "rsakey":
        return False
    p, q = key[1], key[2]
    return claim[1] == p * q and claim[2] == (p - 1) * (q - 1)


def check_modular_inverse(claim, prevs):
    """d·e ≡ 1 (mod φ), exactly."""
    key, setup = prevs
    if claim[0] != "rsad" or key[0] != "rsakey" or setup[0] != "rsan":
        return False
    d, e, phi = claim[1], claim[2], claim[3]
    return e == key[3] and phi == setup[2] and (e * d) % phi == 1


def check_rsa_round_trip(claim, prevs):
    """Encrypt with e, decrypt with the secret d, land on m."""
    key, setup, inv = prevs
    if claim[0] != "rsatrip" or key[0] != "rsakey" \
            or setup[0] != "rsan" or inv[0] != "rsad":
        return False
    m, e, c, d, n = claim[1:]
    if e != key[3] or d != inv[1] or n != setup[1] \
            or not 1 <= m < n:
        return False
    return c == pow(m, e, n) and pow(c, d, n) == m


def check_trapdoor_conclusion(claim, prevs):
    """The trapdoor works: the round trip closed on the cited d."""
    key, inv, trip = prevs
    if claim[0] != "rsaconc" or key[0] != "rsakey" or inv[0] != "rsad" \
            or trip[0] != "rsatrip":
        return False
    return claim[1] == key[3] and claim[2] == inv[1] \
        and claim[3] == trip[5] and trip[2] == key[3] \
        and trip[4] == inv[1]


def check_dh_power(claim, prevs):
    """One public Diffie-Hellman value, exactly."""
    (setup,) = prevs
    if claim[0] != "dhpow" or setup[0] != "dhsetup":
        return False
    base, x, v, p = claim[1:]
    if p != setup[1]:
        return False
    return v == pow(base, x, p)


def check_dh_agreement(claim, prevs):
    """A^b and B^a coincide: the shared secret, verified from the
    cited public values."""
    setup, pa, pb = prevs
    if claim[0] != "dhagree" or setup[0] != "dhsetup" \
            or pa[0] != "dhpow" or pb[0] != "dhpow":
        return False
    p, g, a, b = setup[1], setup[2], setup[3], setup[4]
    if (pa[1], pa[2]) != (g, a) or (pb[1], pb[2]) != (g, b):
        return False
    big_a, big_b = pa[3], pb[3]
    s = pow(big_a, b, p)
    return (claim[1], claim[2], claim[3], claim[4]) \
        == (big_a, b, big_b, a) and claim[5] == s \
        and pow(big_b, a, p) == s and claim[6] == p


# ---------------------------------------------------------------------------
# Critic statements — Phase 6's error-spotting format. The flawed
# derivation lives in the problem text; the record re-derives the
# correct prefix with the host family's own warrants and ends in a
# verdict line "step <k>; <correct claim>". The verdict's parser is
# language-agnostic: it wraps the host claim as a raw string.
# ---------------------------------------------------------------------------

_FLAW = re.compile(r"^step (\d+); (.+)$")


def parse_flaw(text):
    m = _FLAW.match(text)
    if m:
        return ("flaw", int(m.group(1)), m.group(2))
    return ("raw", text)


def check_flaw_verdict(claim, prevs):
    """The verdict's corrected claim equals the cited re-derived line
    (string-for-string; the flawed position is the truth oracle's
    business, since the flawed proof lives in the problem text)."""
    (ref,) = prevs
    return claim[0] == "flaw" and ref[0] == "raw" and claim[2] == ref[1]


def _cited_closure(start, line_refs):
    """Every line reachable from `start` by following refs backward."""
    seen, stack = set(), [start]
    while stack:
        for r in line_refs.get(stack.pop(), ()):
            if r not in seen:
                seen.add(r)
                stack.append(r)
    return seen


def check_combine_congruences(claim, prevs):
    """x ≡ b (mod M·m) from x ≡ a (mod M) and x ≡ r (mod m), coprime.

    A CRT certificate: however b was found, validity is direct — b
    reduces to each cited residue mod its modulus, and the moduli are
    coprime with b a least residue of their product."""
    a_ref, r_ref = prevs
    if claim[0] != "xcong" or a_ref[0] != "xcong" or r_ref[0] != "xcong":
        return False
    _, a, big = a_ref
    _, r, m = r_ref
    _, b, prod = claim
    return (big >= 2 and m >= 2 and gcd(big, m) == 1 and prod == big * m
            and 0 <= a < big and 0 <= r < m
            and 0 <= b < prod and b % big == a and b % m == r)


def _digit_sum(v):
    return sum(int(c) for c in str(v))


def _alt_sum(v):
    total, sign = 0, 1
    for c in reversed(str(v)):
        total += sign * int(c)
        sign = -sign
    return total


def check_digit_sum(claim, prevs):
    """digitsum(v) = s, where v is the cited number or its digit sum."""
    (ref,) = prevs
    if claim[0] != "dsum":
        return False
    _, v, s = claim
    if ref[0] == "int":
        ok = ref[1] == v
    elif ref[0] == "dsum":
        ok = ref[2] == v
    else:
        return False
    return ok and v >= 0 and s == _digit_sum(v)


def check_alternating_sum(claim, prevs):
    """altsum(n) = s (alternating from the units digit), for the cited n."""
    (ref,) = prevs
    return (claim[0] == "asum" and ref[0] == "int" and ref[1] == claim[1]
            and claim[2] == _alt_sum(claim[1]))


def check_last_digits(claim, prevs):
    """last<k>(n) = m, for the cited n and k in 1..3."""
    (ref,) = prevs
    if claim[0] != "tail" or ref[0] != "int":
        return False
    _, n, k, m = claim
    return ref[1] == n and 1 <= k <= 3 and m == n % 10 ** k


def check_digit_sum_rule(claim, prevs):
    """d (does not) divide(s) n, for d in {3, 9}, transferred along a
    cited digit-sum chain from n down to a glanceable terminal (<= 99);
    every link re-verified — the rules are iff, so both verdicts ride
    the same chain."""
    if claim[0] not in ("divides", "ndivides") or claim[1] not in (3, 9):
        return False
    d, n = claim[1], claim[2]
    v = n
    for prev in prevs:
        if prev[0] != "dsum" or prev[1] != v or prev[2] != _digit_sum(v):
            return False
        v = prev[2]
    if v == n or v > 99:
        return False
    return (v % d == 0) == (claim[0] == "divides")


def check_alternating_sum_rule(claim, prevs):
    """11 (does not) divide(s) n, from the cited alternating digit sum."""
    (ref,) = prevs
    if claim[0] not in ("divides", "ndivides") or claim[1] != 11:
        return False
    n = claim[2]
    if ref[0] != "asum" or ref[1] != n or ref[2] != _alt_sum(n) \
            or abs(ref[2]) > 99:
        return False
    return (ref[2] % 11 == 0) == (claim[0] == "divides")


#: Digits of n that decide divisibility by each last-digits modulus.
_TAIL_K = {2: 1, 5: 1, 4: 2, 25: 2, 8: 3}


def check_last_digits_rule(claim, prevs):
    """d (does not) divide(s) n, read off the cited trailing digits."""
    (ref,) = prevs
    if claim[0] not in ("divides", "ndivides") or claim[1] not in _TAIL_K:
        return False
    d, n = claim[1], claim[2]
    k = _TAIL_K[d]
    if ref[0] != "tail" or ref[1] != n or ref[2] != k \
            or ref[3] != n % 10 ** k:
        return False
    return (ref[3] % d == 0) == (claim[0] == "divides")


def check_coprime_factors_rule(claim, prevs):
    """d divides n from a divides n and b divides n, d = a·b coprime."""
    a_ref, b_ref = prevs
    if claim[0] != "divides" or a_ref[0] != "divides" \
            or b_ref[0] != "divides":
        return False
    d, n = claim[1], claim[2]
    a, b = a_ref[1], b_ref[1]
    return (a_ref[2] == n and b_ref[2] == n and a >= 2 and b >= 2
            and a * b == d and gcd(a, b) == 1
            and n % a == 0 and n % b == 0)


def check_factor_fails_rule(claim, prevs):
    """d does not divide n because a cited factor of d already fails."""
    (ref,) = prevs
    if claim[0] != "ndivides" or ref[0] != "ndivides":
        return False
    d, n = claim[1], claim[2]
    a = ref[1]
    return ref[2] == n and a >= 2 and d > a and d % a == 0 and n % a != 0


def check_primality_conclusion(claim, prevs):
    """n is prime, from nonzero-remainder trial divisions of n covering
    every prime p with p^2 <= n (extra clearing divisions are harmless;
    each cited division's arithmetic is re-verified)."""
    if claim[0] != "prime" or claim[1] < 2:
        return False
    n = claim[1]
    cleared = set()
    for prev in prevs:
        if prev[0] != "div":
            return False
        _, n2, q, p, r = prev
        if n2 != n or r < 1 or r >= p or n != q * p + r:
            return False
        cleared.add(p)
    return all(p in cleared for p in _primes_upto(isqrt(n)))


WARRANTS = {
    "expand_product": {
        "apply": apply_expand_product,
        "schema": "c(a + b)(d + e) -> c(ad + ae + bd + be)",
        "description": "FOIL-expand one product of two binomials: every "
                       "term of the first factor multiplies every term of "
                       "the second, in order; the product's coefficient "
                       "stays on the resulting group.",
    },
    "distribute": {
        "apply": apply_distribute,
        "schema": "c(d + e) -> cd + ce",
        "description": "Expand one parenthesized group by multiplying every "
                       "inner term by the group's coefficient "
                       "(distributive property).",
    },
    "combine_like_terms": {
        "apply": apply_combine,
        "schema": "px + qx -> (p+q)x ;  m + n -> (m+n)",
        "description": "Merge one pair of like terms (two x-terms or two "
                       "constants) within the same sum into a single term.",
    },
    "product_of_powers": {
        "apply": apply_product_of_powers,
        "parse": parse_pow,
        "schema": "x^a · x^b -> x^(a+b)",
        "description": "Merge one pair of powers of x within the same "
                       "product by adding their exponents.",
    },
    "power_of_power": {
        "apply": apply_power_of_power,
        "parse": parse_pow,
        "schema": "(x^a)^b -> x^(a·b)",
        "description": "Collapse one power of a power of x by multiplying "
                       "the exponents.",
    },
    "partial_fractions": {
        "apply": apply_partial_fractions,
        "parse": parse_frac,
        "schema": "1/(a·(a+1)) -> 1/a - 1/(a+1)",
        "description": "Split one product-form unit fraction into its "
                       "telescoping difference of unit fractions.",
    },
    "cancel_pair": {
        "apply": apply_cancel_pair,
        "parse": parse_frac,
        "schema": "... + t + ... - t + ... -> ... + ...",
        "description": "Remove one pair of exactly opposite fractions from "
                       "the sum.",
    },
    "add_fractions": {
        "apply": apply_add_fractions,
        "parse": parse_frac,
        "schema": "p1/q1 + p2/q2 -> (reduced exact sum)",
        "description": "Add one pair of fractions exactly, in lowest terms "
                       "(a pair summing to zero is cancel_pair's move).",
    },
    "log_of_product": {
        "apply": apply_log_of_product,
        "parse": parse_log,
        "schema": "log_b(x · y) -> log_b x + log_b y",
        "description": "Split one factor off a log of a product into its "
                       "own log term.",
    },
    "log_of_power": {
        "apply": apply_log_of_power,
        "parse": parse_log,
        "schema": "log_b(m^e) -> e·log_b m",
        "description": "Pull one exponent out of a log as a coefficient "
                       "(multiplying any coefficient already present).",
    },
    "evaluate_log": {
        "apply": apply_evaluate_log,
        "parse": parse_log,
        "schema": "k·log_b(b^j) -> k·j",
        "description": "Evaluate one exact logarithm — legal only when the "
                       "argument is a perfect power of the base.",
    },
    "add_integers": {
        "apply": apply_add_integers,
        "parse": parse_log,
        "schema": "a + b -> (a+b)",
        "description": "Add one pair of integer terms in the sum.",
    },
    # Inverse warrants: the claim is valid when the REFERENCED line is one
    # forward application of the named inverse rule away from the claim —
    # the same relation, replayed backward. No new rule soundness to trust.
    "factor_common": {
        "inverse_of": "distribute",
        "schema": "ab + ac -> a(b + c)",
        "description": "Factor one common integer coefficient out of a run "
                       "of terms (undoes distribute; checked by expanding "
                       "the claim back).",
    },
    "split_middle_term": {
        "inverse_of": "combine_like_terms",
        "schema": "(p+q)x -> px + qx ;  0 -> t - t",
        "description": "Rewrite one term as a sum of two like terms — the "
                       "ac-method split — or insert a canceling pair "
                       "(undoes combine_like_terms; checked by combining "
                       "the claim back).",
    },
    "factor_product": {
        "inverse_of": "expand_product",
        "schema": "c(ad + ae + bd + be) -> c(a + b)(d + e)",
        "description": "Collapse four FOIL-ordered terms into a product of "
                       "two binomials (undoes expand_product; checked by "
                       "expanding the claim back).",
    },
    # Euclid-language warrants (gcd/Bezout certificates). The first two
    # are ordinary rewrites; the last three are judgment warrants —
    # validated by direct arithmetic over the claim and its cited lines,
    # not by rewrite membership (plan §8).
    "euclid_step": {
        "apply": apply_euclid_step,
        "parse": parse_euclid,
        "schema": "gcd(a, b) -> gcd(b, a mod b)",
        "description": "Replace one gcd by the Euclidean descent step: the "
                       "smaller argument, paired with the remainder of "
                       "dividing by it.",
    },
    "gcd_of_zero": {
        "apply": apply_gcd_of_zero,
        "parse": parse_euclid,
        "schema": "gcd(d, 0) -> d",
        "description": "Read off a finished descent: the gcd of d and 0 "
                       "is d.",
    },
    "division_identity": {
        "check": check_division_identity,
        "parse": parse_euclid,
        "schema": "gcd(a, b) => a = q·b + r  (0 <= r < b)",
        "description": "Record the quotient-remainder identity behind one "
                       "descent step of the cited gcd line's pair, verified "
                       "by exact arithmetic.",
    },
    "rearrange_division": {
        "check": check_rearrange_division,
        "parse": parse_euclid,
        "schema": "a = q·b + r  =>  r = 1·a - q·b",
        "description": "Solve one division identity for its remainder, "
                       "opening the Bezout back-substitution.",
    },
    "substitute_remainder": {
        "check": check_substitute_remainder,
        "nrefs": 2,
        "parse": parse_euclid,
        "schema": "g = s·u + t·v ; U = q·u + v  =>  g = t·U + (s - t·q)·u",
        "description": "Back-substitute one remainder: eliminate v from the "
                       "combination using the cited division identity one "
                       "level up (cites two lines: the combination, then "
                       "the division).",
    },
    # Primality-certificate warrants. `primality_conclusion` is the
    # program's first variable-arity warrant (nrefs "any"): a primality
    # certificate is a set of witnesses, so the conclusion's fan-in is
    # as wide as the trial-division cover.
    "trial_division": {
        "check": check_trial_division,
        "parse": parse_euclid,
        "schema": "n  =>  n = q·p + r  (0 <= r < p)",
        "description": "Divide the cited number by a candidate divisor p, "
                       "recording quotient and remainder, verified by "
                       "exact arithmetic.",
    },
    "factorization": {
        "check": check_factorization,
        "parse": parse_euclid,
        "schema": "n = q·p + 0  =>  n = q·p",
        "description": "Read a factorization off an exact trial division; "
                       "both factors must exceed 1.",
    },
    "primality_conclusion": {
        "check": check_primality_conclusion,
        "nrefs": "any",
        "parse": parse_euclid,
        "schema": "n = q·p + r (r >= 1), every prime p^2 <= n  =>  n is prime",
        "description": "Conclude primality from nonzero-remainder trial "
                       "divisions covering every prime whose square is at "
                       "most n — cites all of them at once; extra clearing "
                       "divisions are harmless and every cited remainder "
                       "is re-verified.",
    },
    # Congruence-chain warrants. Deliberately hand-sized: each step is
    # exactly one modular multiplication, so a chain cannot be collapsed
    # into a single unearned jump (an unrestricted j-th-power warrant
    # would let a one-line "proof" restate any answer — a grading hole,
    # not a proof step). Binary addition chains reach every exponent.
    "square_congruence": {
        "check": check_square_congruence,
        "parse": parse_euclid,
        "schema": "n^k ≡ r (mod m)  =>  n^2k ≡ r² mod m",
        "description": "Square one congruence: double the exponent and "
                       "square the residue, reduced mod m (one modular "
                       "multiplication).",
    },
    "multiply_congruences": {
        "check": check_multiply_congruences,
        "nrefs": 2,
        "parse": parse_euclid,
        "schema": "n^j ≡ r ; n^k ≡ s (mod m)  =>  n^(j+k) ≡ r·s mod m",
        "description": "Multiply two congruences with the same base and "
                       "modulus: add the exponents and multiply the "
                       "residues, reduced mod m (cites two lines, which "
                       "may coincide).",
    },
    "combine_congruences": {
        "check": check_combine_congruences,
        "nrefs": 2,
        "parse": parse_euclid,
        "schema": "x ≡ a (mod M) ; x ≡ r (mod m), gcd(M,m)=1  =>  "
                  "x ≡ b (mod M·m)",
        "description": "Fold two congruence conditions with coprime moduli "
                       "into one (CRT): the combined residue must reduce "
                       "to each cited residue mod its modulus — verified "
                       "by direct reduction, however b was found.",
    },
    # Divisibility-rule warrants. The rules are iff, so one warrant per
    # rule carries both verdicts; conclusions require a glanceable
    # terminal, and composite moduli compose branch proofs.
    "digit_sum": {
        "check": check_digit_sum,
        "parse": parse_euclid,
        "schema": "n  =>  digitsum(n) = s",
        "description": "Record one digit sum of the cited number (or of "
                       "the cited digit sum — the chain iterates), "
                       "verified by exact arithmetic.",
    },
    "alternating_sum": {
        "check": check_alternating_sum,
        "parse": parse_euclid,
        "schema": "n  =>  altsum(n) = s",
        "description": "Record the alternating digit sum of the cited "
                       "number, signs alternating from + at the units "
                       "digit, verified by exact arithmetic.",
    },
    "last_digits": {
        "check": check_last_digits,
        "parse": parse_euclid,
        "schema": "n  =>  last<k>(n) = m  (k in 1..3)",
        "description": "Record the trailing k digits of the cited number, "
                       "verified by exact arithmetic.",
    },
    "digit_sum_rule": {
        "check": check_digit_sum_rule,
        "nrefs": "any",
        "parse": parse_euclid,
        "schema": "digitsum chain n -> ... -> s (s <= 99)  =>  "
                  "3 or 9 (does not) divide(s) n",
        "description": "Transfer divisibility by 3 or 9 along the cited "
                       "digit-sum chain — an iff, so both verdicts ride "
                       "it; the terminal must be glanceable (at most two "
                       "digits) and every link is re-verified.",
    },
    "alternating_sum_rule": {
        "check": check_alternating_sum_rule,
        "parse": parse_euclid,
        "schema": "altsum(n) = s  =>  11 (does not) divide(s) n",
        "description": "Transfer divisibility by 11 to or from the cited "
                       "alternating digit sum (an iff; the sum is "
                       "re-verified and must be glanceable).",
    },
    "last_digits_rule": {
        "check": check_last_digits_rule,
        "parse": parse_euclid,
        "schema": "last<k>(n) = m  =>  d (does not) divide(s) n "
                  "(d in 2,5 / 4,25 / 8 for k = 1 / 2 / 3)",
        "description": "Transfer divisibility by 2, 4, 8, 5 or 25 to or "
                       "from the cited trailing digits (an iff; the "
                       "digits are re-verified and k must match d).",
    },
    "coprime_factors_rule": {
        "check": check_coprime_factors_rule,
        "nrefs": 2,
        "parse": parse_euclid,
        "schema": "a divides n ; b divides n, gcd(a,b)=1  =>  a·b divides n",
        "description": "Combine two coprime divisibility branches into "
                       "divisibility by their product (both branches "
                       "re-verified).",
    },
    "factor_fails_rule": {
        "check": check_factor_fails_rule,
        "parse": parse_euclid,
        "schema": "a does not divide n, a proper factor of d  =>  "
                  "d does not divide n",
        "description": "Refute divisibility by d from one failing factor: "
                       "if a divides d but not n, then d cannot divide n.",
    },
    # Induction warrants (sum-formula induction). The IH line opens a
    # scope; these warrants force the two strand roots so the algebra
    # between root and terminal cannot be skipped, and the conclusion
    # discharges the scope (ancestry and closure enforced in
    # check_proof, which holds the refs DAG).
    "base_case": {
        "check": check_base_case,
        "nrefs": 2,
        "parse": parse_induction,
        "schema": "t ; assume S(x) = F  =>  at x = 1, both sides equal v",
        "description": "Verify the base case: the sum's first term t(1) "
                       "and the closed form F(1) both evaluate to the "
                       "stated value (cites the term formula, then "
                       "the IH).",
    },
    "induction_hypothesis": {
        "check": check_induction_hypothesis,
        "nrefs": 2,
        "parse": parse_induction,
        "schema": "t ; assume S(x) = F  =>  F + t(x+1)",
        "description": "Apply the assumption: S(x+1) = S(x) + t(x+1) "
                       "becomes the assumed closed form plus the next "
                       "term, substituted exactly (cites the term "
                       "formula, then the IH).",
    },
    "formula_at_successor": {
        "check": check_formula_at_successor,
        "nrefs": 1,
        "parse": parse_induction,
        "schema": "assume S(x) = F  =>  F(x+1)",
        "description": "Instantiate the assumed closed form at x + 1, "
                       "substituted exactly: c·x² becomes c(x+1)(x+1) "
                       "and c·x becomes c(x+1).",
    },
    "induction_conclusion": {
        "check": check_induction_conclusion,
        "nrefs": 5,
        "closes_scope": True,
        "ancestry": {3: "induction_hypothesis", 4: "formula_at_successor"},
        "parse": parse_induction,
        "schema": "t ; IH ; base ; strands meet  =>  "
                  "S(x) = F for all x >= 1",
        "description": "Discharge the induction: cites the term formula, "
                       "the IH, the verified base case, and the two "
                       "strand terminals, which must be the same "
                       "expression; each terminal must descend from its "
                       "strand's root warrant, and the block closes.",
    },
    # Divisibility-induction warrants (d | a^x - b^x, with d | a - b).
    "base_divides": {
        "check": check_base_divides,
        "nrefs": 2,
        "parse": parse_xind,
        "schema": "a ; b  =>  d divides a - b",
        "description": "Verify d divides a - b for the cited base pair — "
                       "simultaneously the x = 1 case of d | a^x - b^x "
                       "and the lemma the inductive step combines with.",
    },
    "successor_identity": {
        "check": check_successor_identity,
        "nrefs": 2,
        "parse": parse_xind,
        "schema": "a ; b  =>  a^(x+1) - b^(x+1) = a·(a^x - b^x) "
                  "+ b^x·(a - b)",
        "description": "State the successor identity for the cited pair; "
                       "its internal arithmetic is enforced at parse "
                       "time, and the schema holds for every a, b, x.",
    },
    "divisibility_combination": {
        "check": check_divisibility_combination,
        "nrefs": 3,
        "parse": parse_xind,
        "schema": "IH ; successor identity ; d divides a - b  =>  "
                  "d divides a^(x+1) - b^(x+1)",
        "description": "Combine: d divides both addends on the identity's "
                       "right side — the assumed a^x - b^x scaled by a, "
                       "and b^x times the verified a - b (cites the IH, "
                       "the identity, then the divisibility lemma).",
    },
    "exponent_induction_conclusion": {
        "check": check_exponent_induction_conclusion,
        "nrefs": 3,
        "closes_scope": True,
        "ancestry": {2: "divisibility_combination"},
        "parse": parse_xind,
        "schema": "IH ; base ; successor claim  =>  "
                  "d divides a^x - b^x for all x >= 1",
        "description": "Discharge the divisibility induction: cites the "
                       "IH, the verified base line, and the successor "
                       "claim, which must descend from a "
                       "divisibility_combination step; the block closes.",
    },
    # Inequality-induction warrants (a^x >= g(x) for x >= x0, g linear).
    "exponential_base_case": {
        "check": check_exponential_base_case,
        "nrefs": 3,
        "parse": parse_ineq,
        "schema": "a ; g ; x0  =>  at x = x0: a^x0 >= g(x0)",
        "description": "Verify the bound at the threshold by exact "
                       "evaluation of both sides (cites the base, the "
                       "linear bound, then the threshold).",
    },
    "power_successor": {
        "check": check_power_successor,
        "nrefs": 1,
        "parse": parse_ineq,
        "schema": "a  =>  a^(x+1) = a·a^x",
        "description": "State the power-successor identity for the "
                       "cited base.",
    },
    "scale_inequality": {
        "check": check_scale_inequality,
        "nrefs": 2,
        "parse": parse_ineq,
        "schema": "a ; assume a^x >= g  =>  a·a^x >= a(g)",
        "description": "Multiply both sides of the assumed bound by the "
                       "positive base a; the direction is preserved "
                       "(cites the base premise, then the IH).",
    },
    "expand_scaled": {
        "check": check_expand_scaled,
        "nrefs": 2,
        "parse": parse_ineq,
        "schema": "a ; g  =>  a(g) = a·g expanded",
        "description": "Expand the scaled bound: every coefficient of g "
                       "multiplied by a, verified exactly.",
    },
    "linear_gap": {
        "check": check_linear_gap,
        "nrefs": 2,
        "parse": parse_ineq,
        "schema": "g ; x0  =>  h >= g(x+1) whenever x >= x0",
        "description": "The gap lemma: h - g(x+1) is linear with "
                       "nonnegative slope, so its value at the threshold "
                       "settles every later x — both facts verified by "
                       "exact arithmetic.",
    },
    "inequality_chain": {
        "check": check_inequality_chain,
        "nrefs": 4,
        "parse": parse_ineq,
        "schema": "a^(x+1) = a·a^x >= a(g) = h >= g(x+1)  =>  "
                  "a^(x+1) >= g(x+1)",
        "description": "Chain the four links by transitivity — cites the "
                       "power identity, the scaled bound, the expansion "
                       "and the gap lemma, whose endpoints must match "
                       "exactly.",
    },
    "inequality_induction_conclusion": {
        "check": check_inequality_induction_conclusion,
        "nrefs": 4,
        "closes_scope": True,
        "ancestry": {3: "inequality_chain"},
        "parse": parse_ineq,
        "schema": "x0 ; IH ; base ; successor bound  =>  "
                  "a^x >= g for all x >= x0",
        "description": "Discharge the inequality induction: cites the "
                       "threshold, the IH, the verified base line, and "
                       "the successor bound, which must descend from an "
                       "inequality_chain step; the block closes.",
    },
    # Recurrence-induction warrants (a(x+1) = q·a(x) + r, closed form
    # a(x) = A·q^(x-1) - s with r = s(q-1)).
    "recurrence_base_case": {
        "check": check_recurrence_base_case,
        "nrefs": 2,
        "parse": parse_rec,
        "schema": "a(1) = v ; assume closed form  =>  at x = 1: a(1) = v",
        "description": "Verify the closed form at x = 1: A·q^0 - s must "
                       "equal the cited starting value.",
    },
    "apply_recurrence": {
        "check": check_apply_recurrence,
        "nrefs": 2,
        "parse": parse_rec,
        "schema": "recurrence ; assume a(x) = A·q^(x-1) - s  =>  "
                  "a(x+1) = q·(A·q^(x-1) - s) + r",
        "description": "Substitute the assumed closed form for a(x) in "
                       "the cited recurrence, exactly.",
    },
    "distribute_recurrence": {
        "check": check_distribute_recurrence,
        "nrefs": 1,
        "parse": parse_rec,
        "schema": "a(x+1) = q·(A·q^(x-1) - s) + r  =>  "
                  "a(x+1) = A·q^x - q·s + r",
        "description": "Distribute q: the power steps up one and q·s is "
                       "computed exactly.",
    },
    "combine_constants_recurrence": {
        "check": check_combine_constants_recurrence,
        "nrefs": 1,
        "parse": parse_rec,
        "schema": "a(x+1) = A·q^x - q·s + r  =>  a(x+1) = A·q^x - s",
        "description": "Combine the constants: r - q·s = -s, exactly "
                       "(this is where r = s(q-1) earns its keep).",
    },
    "recurrence_conclusion": {
        "check": check_recurrence_conclusion,
        "nrefs": 5,
        "closes_scope": True,
        "ancestry": {4: "combine_constants_recurrence"},
        "parse": parse_rec,
        "schema": "recurrence ; a(1) ; IH ; base ; successor form  =>  "
                  "a(x) = A·q^(x-1) - s for all x >= 1",
        "description": "Discharge the recurrence induction: re-verifies "
                       "the base and r = s(q-1), and the successor claim "
                       "must descend from a combine_constants_recurrence "
                       "step; the block closes.",
    },
    # Invariant-game warrants (Phase 4): unreachability by a mod-m
    # invariant, reachability by an explicit combination certificate.
    "move_residue": {
        "check": check_move_residue,
        "nrefs": 1,
        "parse": parse_inv,
        "schema": "moves  =>  move d ≡ 0 (mod m)",
        "description": "Record that one allowed move's delta is a "
                       "multiple of m, verified by exact arithmetic.",
    },
    "invariant_from_moves": {
        "check": check_invariant_from_moves,
        "nrefs": "any",
        "parse": parse_inv,
        "schema": "moves ; every move ≡ 0 (mod m)  =>  "
                  "value mod m is invariant",
        "description": "Conclude the invariant: cites the move list and "
                       "a ≡ 0 line covering every move (each re-verified "
                       "— an uncovered move sinks the claim).",
    },
    "reduce_value": {
        "check": check_reduce_value,
        "nrefs": 1,
        "parse": parse_inv,
        "schema": "start = v (or target = v)  =>  v ≡ r (mod m)",
        "description": "Reduce the cited start or target value mod m, "
                       "exactly.",
    },
    "invariant_unreachability": {
        "check": check_invariant_unreachability,
        "nrefs": 5,
        "parse": parse_inv,
        "schema": "start ; target ; invariant ; residues differ  =>  "
                  "the target is unreachable",
        "description": "Conclude unreachability: the invariant preserves "
                       "the residue and the start and target residues "
                       "differ — both residue lines re-verified against "
                       "the cited premises.",
    },
    "move_combination": {
        "check": check_move_combination,
        "nrefs": 1,
        "parse": parse_inv,
        "schema": "moves  =>  c1·(d1) + c2·(d2) + ... = total",
        "description": "Exhibit a combination of allowed moves with "
                       "positive counts; the total is verified by exact "
                       "arithmetic.",
    },
    "reachability_conclusion": {
        "check": check_reachability_conclusion,
        "nrefs": 3,
        "parse": parse_inv,
        "schema": "start ; target ; combination  =>  "
                  "the target is reachable",
        "description": "Conclude reachability: the cited combination's "
                       "total carries the start exactly to the target.",
    },
    # Monovariant-termination warrants (Phase 4): a token game halts
    # because an exhibited positive weighting strictly decreases.
    "potential_weights": {
        "check": check_potential_weights,
        "nrefs": 1,
        "parse": parse_term,
        "schema": "moves  =>  assign weight a to red, b to green (a,b >= 1)",
        "description": "Exhibit positive integer weights defining the "
                       "potential Φ = a·red + b·green — the proof's "
                       "creative certificate.",
    },
    "move_decreases": {
        "check": check_move_decreases,
        "nrefs": 2,
        "parse": parse_term,
        "schema": "moves ; weights  =>  move (dr, dg) decreases Φ by k",
        "description": "One allowed move drops the potential by exactly "
                       "k = -(a·dr + b·dg) >= 1, verified by exact "
                       "arithmetic.",
    },
    "monovariant": {
        "check": check_monovariant,
        "nrefs": "any",
        "parse": parse_term,
        "schema": "moves ; weights ; every move decreases  =>  "
                  "Φ strictly decreases on every move",
        "description": "Conclude the monovariant: cites the move list, "
                       "the weights, and a decrease line covering every "
                       "move, each re-verified.",
    },
    "initial_potential": {
        "check": check_initial_potential,
        "nrefs": 2,
        "parse": parse_term,
        "schema": "start ; weights  =>  the initial potential is v",
        "description": "Evaluate the potential at the starting position, "
                       "exactly.",
    },
    "termination_conclusion": {
        "check": check_termination_conclusion,
        "nrefs": 3,
        "parse": parse_term,
        "schema": "weights ; monovariant ; initial potential  =>  "
                  "the game ends within v moves",
        "description": "Conclude termination: a nonnegative integer "
                       "potential that strictly decreases each move can "
                       "fall at most its initial value many times.",
    },
    # Graph-certificate warrants (Phase 5). Non-scoped conclusions use
    # the ancestry key too: a cited "the graph is connected" line must
    # actually descend from a connected_conclusion step, so the fact
    # cannot be smuggled in as a premise.
    "two_coloring": {
        "check": check_two_coloring,
        "nrefs": 1,
        "parse": parse_graph,
        "schema": "graph  =>  coloring: 1→A, 2→B, ...",
        "description": "Propose an A/B coloring of every vertex — the "
                       "bipartiteness certificate; its validity is "
                       "established edge by edge.",
    },
    "edge_bicolored": {
        "check": check_edge_bicolored,
        "nrefs": 2,
        "parse": parse_graph,
        "schema": "graph ; coloring  =>  edge u-v joins the two classes",
        "description": "One edge's endpoints receive different colors "
                       "under the cited map, verified exactly.",
    },
    "bipartite_conclusion": {
        "check": check_bipartite_conclusion,
        "nrefs": "any",
        "parse": parse_graph,
        "schema": "graph ; coloring ; every edge bicolored  =>  bipartite",
        "description": "Conclude bipartiteness: cites the graph, the "
                       "coloring, and a bicolor line covering every edge "
                       "(each re-verified).",
    },
    "odd_cycle": {
        "check": check_odd_cycle,
        "nrefs": 1,
        "parse": parse_graph,
        "schema": "graph  =>  odd cycle: v1-v2-...-v1",
        "description": "Exhibit an odd-length cycle through distinct "
                       "vertices, every link a real edge.",
    },
    "not_bipartite_conclusion": {
        "check": check_not_bipartite_conclusion,
        "nrefs": 2,
        "ancestry": {1: "odd_cycle"},
        "parse": parse_graph,
        "schema": "graph ; odd cycle  =>  not bipartite",
        "description": "Conclude non-bipartiteness from the cited odd "
                       "cycle, fully re-verified: an odd cycle admits "
                       "no proper 2-coloring.",
    },
    "spanning_tree": {
        "check": check_spanning_tree,
        "nrefs": 1,
        "parse": parse_graph,
        "schema": "graph  =>  spanning tree: 2←p2, 3←p3, ...",
        "description": "Exhibit a parent map rooted at vertex 1: every "
                       "other vertex exactly once, every link a real "
                       "edge, and vertex 1 reaches everyone.",
    },
    "connected_conclusion": {
        "check": check_connected_conclusion,
        "nrefs": 2,
        "ancestry": {1: "spanning_tree"},
        "parse": parse_graph,
        "schema": "graph ; spanning tree  =>  connected",
        "description": "Conclude connectivity from the cited spanning "
                       "tree, fully re-verified.",
    },
    "count_edges": {
        "check": check_count_edges,
        "nrefs": 1,
        "parse": parse_graph,
        "schema": "graph  =>  the graph has m edges",
        "description": "Count the edge list, exactly.",
    },
    "tree_conclusion": {
        "check": check_tree_conclusion,
        "nrefs": 3,
        "ancestry": {1: "connected_conclusion"},
        "parse": parse_graph,
        "schema": "graph ; connected ; m = n - 1 edges  =>  a tree",
        "description": "Conclude the graph is a tree: connected with "
                       "exactly n - 1 edges (the count re-verified, the "
                       "connectivity line's descent enforced).",
    },
    "vertex_degree": {
        "check": check_vertex_degree,
        "nrefs": 1,
        "parse": parse_graph,
        "schema": "graph  =>  vertex v has degree d",
        "description": "Count one vertex's incident edges, exactly.",
    },
    "all_degrees_even": {
        "check": check_all_degrees_even,
        "nrefs": "any",
        "parse": parse_graph,
        "schema": "graph ; every vertex's degree even  =>  all even",
        "description": "Conclude all degrees even: cites a re-verified "
                       "even-degree line for every vertex.",
    },
    "eulerian_conclusion": {
        "check": check_eulerian_conclusion,
        "nrefs": 3,
        "ancestry": {1: "connected_conclusion", 2: "all_degrees_even"},
        "parse": parse_graph,
        "schema": "graph ; connected ; all degrees even  =>  "
                  "Eulerian circuit",
        "description": "Euler's theorem: a connected graph with every "
                       "degree even has an Eulerian circuit (both cited "
                       "lines' descents enforced).",
    },
    # Inequality-composition warrants (Phase 5): axiom-instance atoms
    # composed by sampled trees into universally valid quadratic bounds.
    "amgm_instance": {
        "check": check_amgm_instance,
        "nrefs": 1,
        "parse": parse_qineq,
        "schema": "x real  =>  a²x² + c² >= 2acx",
        "description": "An AM-GM instance — the expansion of "
                       "(ax - c)² >= 0 — verified by exact square "
                       "recognition.",
    },
    "square_nonneg": {
        "check": check_square_nonneg,
        "nrefs": 1,
        "parse": parse_qineq,
        "schema": "x real  =>  p²x² + 2pqx + q² >= 0",
        "description": "A perfect square is nonnegative, verified by "
                       "exact square recognition of the coefficients.",
    },
    "add_inequalities": {
        "check": check_add_inequalities,
        "nrefs": 2,
        "parse": parse_qineq,
        "schema": "L1 >= R1 ; L2 >= R2  =>  L1+L2 >= R1+R2",
        "description": "Add two inequalities coefficientwise; both new "
                       "sides verified exactly.",
    },
    "scale_positive": {
        "check": check_scale_positive,
        "nrefs": 1,
        "parse": parse_qineq,
        "schema": "L >= R  =>  kL >= kR  (integer k >= 2)",
        "description": "Multiply both sides by one positive integer, "
                       "verified coefficientwise.",
    },
    "weaken_constant": {
        "check": check_weaken_constant,
        "nrefs": 1,
        "parse": parse_qineq,
        "schema": "L >= R  =>  L >= R - c  (c >= 1)",
        "description": "Weaken the bound by lowering the right side's "
                       "constant term.",
    },
    # Exact-trig warrants (Phase 5g): special-angle values derived via
    # the addition formulas in the exact surd field Q(√2, √3).
    "angle_split": {
        "check": check_angle_split,
        "nrefs": 1,
        "parse": parse_trig,
        "schema": "sin θ°  =>  θ° = α° ± β°  (α, β special angles)",
        "description": "Split the subject angle into two special angles "
                       "(0°, 30°, 45°, 60°, 90°), verified exactly.",
    },
    "sine_addition": {
        "check": check_sine_addition,
        "nrefs": 1,
        "parse": parse_trig,
        "schema": "θ = α ± β  =>  sin θ° = sin α°·cos β° ± cos α°·sin β°",
        "description": "Expand sine by the addition formula for the "
                       "cited split (the formula's shape is enforced by "
                       "the statement grammar).",
    },
    "cosine_addition": {
        "check": check_cosine_addition,
        "nrefs": 1,
        "parse": parse_trig,
        "schema": "θ = α ± β  =>  cos θ° = cos α°·cos β° ∓ sin α°·sin β°",
        "description": "Expand cosine by the addition formula for the "
                       "cited split, with the sign flip the grammar "
                       "enforces.",
    },
    "known_value": {
        "check": check_known_value,
        "nrefs": 1,
        "parse": parse_trig,
        "schema": "subject  =>  sin/cos of a special angle, exactly",
        "description": "Cite one entry of the special-angle table "
                       "(sin/cos of 0°, 30°, 45°, 60°, 90°) in exact "
                       "surd form.",
    },
    "combine_products": {
        "check": check_combine_products,
        "nrefs": 5,
        "parse": parse_trig,
        "schema": "formula ; four known values  =>  "
                  "sin/cos θ° = exact surd",
        "description": "Substitute the four cited known values into the "
                       "cited addition formula, in role order, and "
                       "combine with exact surd arithmetic in Q(√2, √3).",
    },
    "reference_angle": {
        "check": check_reference_angle,
        "nrefs": 1,
        "parse": parse_trig,
        "schema": "sin/cos θ° (θ beyond 90°)  =>  ±(same fn of the "
                  "reference angle)",
        "description": "Relate a quadrant II/III/IV angle to its "
                       "reference angle, with the quadrant's sign for "
                       "the cited function.",
    },
    "cofunction": {
        "check": check_cofunction,
        "nrefs": 1,
        "parse": parse_trig,
        "schema": "sin θ° = cos (90-θ)°  (and vice versa)",
        "description": "The cofunction identity for an acute angle.",
    },
    "evaluate_relation": {
        "check": check_evaluate_relation,
        "nrefs": 2,
        "parse": parse_trig,
        "schema": "relation ; exact value of its right side  =>  exact "
                  "value of its left side",
        "description": "Push a derived exact value through the cited "
                       "reference/cofunction relation, negating exactly "
                       "when the relation says so.",
    },
    "pythagorean_identity": {
        "check": check_pythagorean_identity,
        "nrefs": 2,
        "parse": parse_trig,
        "schema": "sin θ° exact ; cos θ° exact  =>  sin²θ° + cos²θ° = 1",
        "description": "Square and add the two cited exact values in "
                       "Q(√2, √3); the identity closes to exactly 1.",
    },
    # Angle-chase warrants (Phase 5g): integer-degree deduction rules
    # over configuration facts, each verified by exact arithmetic.
    "triangle_sum": {
        "check": check_triangle_sum,
        "nrefs": 3,
        "parse": parse_angle,
        "schema": "triangle fact ; two angle values  =>  the third "
                  "(sums to 180°)",
        "description": "The angles of the cited triangle sum to 180°: "
                       "deduce the third from the two cited values.",
    },
    "straight_line": {
        "check": check_straight_line,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "straight-line fact ; one value  =>  the supplement",
        "description": "Angles on a straight line sum to 180°.",
    },
    "vertical_angles": {
        "check": check_vertical_angles,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "vertical-angles fact ; one value  =>  the equal angle",
        "description": "Vertical angles are equal.",
    },
    "alternate_angles": {
        "check": check_alternate_angles,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "alternate-angles fact ; one value  =>  the equal angle",
        "description": "Alternate angles at parallel lines are equal.",
    },
    "corresponding_angles": {
        "check": check_corresponding_angles,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "corresponding-angles fact ; one value  =>  the equal "
                  "angle",
        "description": "Corresponding angles at parallel lines are equal.",
    },
    "isosceles_base": {
        "check": check_isosceles_base,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "isosceles fact ; one base angle  =>  the other",
        "description": "Base angles of an isosceles triangle are equal.",
    },
    "exterior_angle": {
        "check": check_exterior_angle,
        "nrefs": 3,
        "parse": parse_angle,
        "schema": "exterior-angle fact ; two values  =>  the third "
                  "(exterior = sum of remote interiors)",
        "description": "An exterior angle of a triangle equals the sum "
                       "of the remote interior angles — usable in either "
                       "direction.",
    },
    "complementary_angles": {
        "check": check_complementary_angles,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "complementary fact ; one value  =>  90° minus it",
        "description": "Complementary angles sum to 90°.",
    },
    "cointerior_angles": {
        "check": check_cointerior_angles,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "co-interior fact ; one value  =>  180° minus it",
        "description": "Co-interior angles at parallel lines sum to 180°.",
    },
    "full_turn": {
        "check": check_full_turn,
        "nrefs": "any",
        "parse": parse_angle,
        "schema": "full-turn fact ; all but one value  =>  the last "
                  "(sums to 360°)",
        "description": "Angles making a full turn about a point sum to "
                       "360°: deduce the last from the cited values.",
    },
    "polygon_sum": {
        "check": check_polygon_sum,
        "nrefs": "any",
        "parse": parse_angle,
        "schema": "polygon fact ; all but one value  =>  the last "
                  "(interior angles sum to (n-2)·180°)",
        "description": "The interior angles of an n-gon sum to "
                       "(n-2)·180°: deduce the last from the cited values.",
    },
    "cyclic_opposite_angles": {
        "check": check_cyclic_opposite,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "cyclic-quadrilateral fact ; one value  =>  180° "
                  "minus it",
        "description": "Opposite angles of a cyclic quadrilateral sum "
                       "to 180°.",
    },
    "inscribed_angle": {
        "check": check_inscribed_angle,
        "nrefs": 2,
        "parse": parse_angle,
        "schema": "same-arc fact ; one value  =>  double or half it",
        "description": "The central angle is twice the inscribed angle "
                       "standing on the same arc — deduce either from "
                       "the other.",
    },
    # Triangle-certificate warrants: Pythagorean converse and the
    # triangle inequality, with both verdicts.
    "square_side": {
        "check": check_square_side,
        "nrefs": 1,
        "parse": parse_tri_cert,
        "schema": "sides  =>  s² = v",
        "description": "Square one of the given side lengths, exactly.",
    },
    "add_squares": {
        "check": check_add_squares,
        "nrefs": 2,
        "parse": parse_tri_cert,
        "schema": "x² line ; y² line  =>  x² + y² = s",
        "description": "Add the two cited squared side values, exactly.",
    },
    "pythagorean_converse": {
        "check": check_pythagorean_converse,
        "nrefs": 3,
        "parse": parse_tri_cert,
        "schema": "sides ; sum of shorter squares ; longest square, "
                  "equal  =>  right-angled",
        "description": "Pythagorean converse: the squares of the two "
                       "shorter sides sum to the square of the longest, "
                       "so the triangle is right-angled (all arithmetic "
                       "re-verified against the premise).",
    },
    "pythagorean_refutation": {
        "check": check_pythagorean_refutation,
        "nrefs": 3,
        "parse": parse_tri_cert,
        "schema": "sides ; sum of shorter squares ; longest square, "
                  "unequal  =>  not right-angled",
        "description": "A genuine triangle whose shorter squares do not "
                       "sum to the longest square is not right-angled "
                       "(triangle validity re-verified too).",
    },
    "right_triangle_ratio": {
        "check": check_right_triangle_ratio,
        "nrefs": 2,
        "ancestry": {1: "pythagorean_converse"},
        "parse": parse_tri_cert,
        "schema": "sides ; proven right-angled  =>  sin/cos/tan of an "
                  "acute angle as a reduced fraction",
        "description": "Read an exact trig ratio off a right triangle "
                       "whose right angle was actually proven (the "
                       "cited verdict must descend from the Pythagorean "
                       "converse): sin = opp/hyp, cos = adj/hyp, "
                       "tan = opp/adj, in lowest terms.",
    },
    "side_sum_check": {
        "check": check_side_sum,
        "nrefs": 1,
        "parse": parse_tri_cert,
        "schema": "lengths  =>  a + b > c  (or a + b ≤ c)",
        "description": "Compare one pair-sum of the given lengths with "
                       "the third, exactly.",
    },
    "triangle_inequality_conclusion": {
        "check": check_triangle_formation,
        "nrefs": 2,
        "parse": parse_tri_cert,
        "schema": "lengths ; two shorter out-sum the longest  =>  "
                  "the segments form a triangle",
        "description": "The binding triangle inequality: if the two "
                       "shorter segments out-sum the longest, the other "
                       "two inequalities follow, so a triangle exists.",
    },
    "degenerate_conclusion": {
        "check": check_no_triangle,
        "nrefs": 2,
        "parse": parse_tri_cert,
        "schema": "lengths ; some pair fails to out-sum the third  =>  "
                  "no triangle",
        "description": "A violated triangle inequality: these segments "
                       "cannot close into a triangle.",
    },
    # Algebraic-form warrants (GCSE algebraic proof): universal integer
    # claims via exact linear forms; the remainder form carries every
    # divisibility and parity verdict.
    "odd_form": {
        "check": check_odd_form,
        "nrefs": 1,
        "parse": parse_alg,
        "schema": "integers  =>  any odd number can be written as 2a + 1",
        "description": "Represent an arbitrary odd number with a fresh "
                       "symbol (freshness is enforced where the "
                       "representations combine).",
    },
    "even_form": {
        "check": check_even_form,
        "nrefs": 1,
        "parse": parse_alg,
        "schema": "integers  =>  any even number can be written as 2a",
        "description": "Represent an arbitrary even number with a fresh "
                       "symbol.",
    },
    "multiple_form": {
        "check": check_multiple_form,
        "nrefs": 1,
        "parse": parse_alg,
        "schema": "integers  =>  any multiple of m can be written as ma",
        "description": "Represent an arbitrary multiple of m with a "
                       "fresh symbol.",
    },
    "expand_sum": {
        "check": check_expand_sum,
        "nrefs": "any",
        "parse": parse_alg,
        "schema": "representations (or a consecutive run)  =>  their "
                  "sum, combined coefficientwise",
        "description": "Add the cited represented quantities exactly; "
                       "the addends must be exactly the cited "
                       "representations (distinct symbols) or the cited "
                       "consecutive run.",
    },
    "remainder_form": {
        "check": check_remainder_form,
        "nrefs": 1,
        "parse": parse_alg,
        "schema": "expanded sum  =>  q·(...) + r  (0 <= r < q)",
        "description": "Factor the expansion into quotient form with an "
                       "explicit remainder, verified coefficientwise — "
                       "this line decides every divisibility verdict.",
    },
    "parity_conclusion": {
        "check": check_parity_conclusion,
        "nrefs": 2,
        "parse": parse_alg,
        "schema": "expansion ; remainder form mod 2  =>  the sum of j "
                  "odds and k evens is always odd/even",
        "description": "Read the parity verdict off the remainder mod 2 "
                       "— valid for every integer value of every symbol, "
                       "because the form identity is exact.",
    },
    "consecutive_conclusion": {
        "check": check_consecutive_conclusion,
        "nrefs": 2,
        "parse": parse_alg,
        "schema": "expansion of a consecutive run ; remainder form "
                  "mod n  =>  always/never divisible by n",
        "description": "Read the verdict off the remainder: r = 0 gives "
                       "always divisible, r ≠ 0 gives never (the "
                       "remainder is the same for every starting "
                       "integer).",
    },
    "multiple_sum_conclusion": {
        "check": check_multiple_sum_conclusion,
        "nrefs": 2,
        "parse": parse_alg,
        "schema": "expansion of two multiples ; exact factoring by d  "
                  "=>  always divisible by d",
        "description": "A sum of multiples factors exactly by any "
                       "common divisor of the two coefficients.",
    },
    "square_diff_expand": {
        "check": check_square_diff_expand,
        "nrefs": 1,
        "parse": parse_alg,
        "schema": "integers  =>  (f1)² - (f2)² expanded exactly",
        "description": "Expand a difference of squares of linear forms, "
                       "verified coefficientwise.",
    },
    "square_sum_expand": {
        "check": check_square_sum_expand,
        "nrefs": 1,
        "parse": parse_alg,
        "schema": "integers  =>  (f1)² + (f2)² expanded exactly",
        "description": "Expand a sum of squares of linear forms, "
                       "verified coefficientwise.",
    },
    "product_expand": {
        "check": check_product_expand,
        "nrefs": 1,
        "parse": parse_alg,
        "schema": "integers  =>  (f1)(f2) expanded exactly",
        "description": "Expand a product of linear forms in distinct "
                       "symbols, verified coefficientwise.",
    },
    "quadratic_remainder": {
        "check": check_quadratic_remainder,
        "nrefs": 1,
        "parse": parse_alg,
        "schema": "quadratic expansion  =>  q·(...) + r  (0 <= r < q)",
        "description": "Factor the quadratic expansion into quotient "
                       "form with an explicit remainder, verified "
                       "coefficientwise.",
    },
    "quad_conclusion": {
        "check": check_quad_conclusion,
        "nrefs": 2,
        "parse": parse_alg,
        "schema": "expansion ; quadratic remainder form  =>  the GCSE "
                  "square/product verdict",
        "description": "Read the verdict off the remainder, with the "
                       "expansion's operands checked against the "
                       "verdict's exact schema (consecutive integers, "
                       "odd numbers at a stated gap, or two odds).",
    },
    # Transformation-congruence warrants (8.G.A.2): the rigid motion is
    # the certificate; incongruence goes through the side-length
    # multiset, which covers every correspondence at once.
    "exhibit_motion": {
        "check": check_exhibit_motion,
        "nrefs": 1,
        "parse": parse_txf,
        "schema": "triangle  =>  a rigid motion of 1-2 atomic moves",
        "description": "Propose the rigid motion (translations, origin "
                       "rotations, axis reflections) — the congruence "
                       "certificate; its validity is established vertex "
                       "by vertex.",
    },
    "apply_motion": {
        "check": check_apply_motion,
        "nrefs": 2,
        "parse": parse_txf,
        "schema": "motion ; triangle  =>  the motion sends P to Q",
        "description": "Apply the cited motion to one vertex of the "
                       "cited triangle, computed exactly.",
    },
    "congruence_conclusion": {
        "check": check_congruence_conclusion,
        "nrefs": 6,
        "ancestry": {2: "exhibit_motion"},
        "parse": parse_txf,
        "schema": "ABC ; DEF ; motion ; three vertex maps  =>  congruent",
        "description": "Congruent by rigid motion: the exhibited motion "
                       "carries A→D, B→E, C→F, each application "
                       "re-verified; rigid motions preserve all "
                       "distances and angles.",
    },
    "side_length_sq": {
        "check": check_side_length_sq,
        "nrefs": 1,
        "parse": parse_txf,
        "schema": "triangle  =>  XY² = v",
        "description": "One side's squared length from the cited "
                       "triangle's coordinates, exactly (squares keep "
                       "everything integer).",
    },
    "incongruence_conclusion": {
        "check": check_incongruence_conclusion,
        "nrefs": 8,
        "parse": parse_txf,
        "schema": "ABC ; DEF ; six squared side lengths, multisets "
                  "differ  =>  not congruent",
        "description": "Not congruent under ANY correspondence: rigid "
                       "motions preserve lengths and triangles are "
                       "determined by their sides, so differing "
                       "side-length multisets (all six re-verified) "
                       "rule out congruence outright.",
    },
    # Coordinate-proof warrants (G-GPE.B / G-CO.C block): analytic
    # geometry over integer coordinates, one language for the
    # parallelogram, midsegment, perpendicular-bisector and centroid
    # theorems.
    "midpoint": {
        "check": check_midpoint,
        "nrefs": 1,
        "parse": parse_coord,
        "schema": "figure  =>  the midpoint of two vertices, exactly",
        "description": "Compute one midpoint of premise points "
                       "(coordinates are drawn so it is integral).",
    },
    "slope_between": {
        "check": check_slope,
        "nrefs": 1,
        "parse": parse_coord,
        "schema": "figure  =>  the slope between two vertices, reduced",
        "description": "Compute one slope between premise points as a "
                       "reduced fraction with positive denominator.",
    },
    "coord_distance_sq": {
        "check": check_coord_distance_sq,
        "nrefs": 1,
        "parse": parse_coord,
        "schema": "figure  =>  the squared distance between two "
                  "vertices, exactly",
        "description": "Compute one squared distance between premise "
                       "points (squares keep everything integer).",
    },
    "collinear_check": {
        "check": check_collinear,
        "nrefs": 1,
        "parse": parse_coord,
        "schema": "figure  =>  three points are collinear (zero cross "
                  "product)",
        "description": "Verify three points collinear by the exact "
                       "cross-product test (computed points allowed — "
                       "medians pass through the exhibited centroid).",
    },
    "parallelogram_conclusion": {
        "check": check_parallelogram_conclusion,
        "nrefs": 5,
        "parse": parse_coord,
        "schema": "ABCD ; four slopes, opposite pairs equal  =>  "
                  "a parallelogram",
        "description": "Both pairs of opposite sides are parallel (all "
                       "four cited slopes re-verified), so ABCD is a "
                       "parallelogram.",
    },
    "bisect_conclusion": {
        "check": check_bisect_conclusion,
        "nrefs": 3,
        "parse": parse_coord,
        "schema": "ABCD ; the two diagonal midpoints coincide  =>  "
                  "the diagonals bisect each other",
        "description": "The diagonals' midpoints coincide (both "
                       "re-verified) — the G-CO.C.11 diagonal theorem, "
                       "analytically.",
    },
    "midsegment_conclusion": {
        "check": check_midsegment_conclusion,
        "nrefs": 7,
        "parse": parse_coord,
        "schema": "ABC ; two midpoints ; equal slopes ; quarter squared "
                  "length  =>  the midsegment theorem",
        "description": "The segment joining two side midpoints is "
                       "parallel to the third side (equal reduced "
                       "slopes) with a quarter of its squared length — "
                       "G-CO.C.10, analytically.",
    },
    "perp_bisector_conclusion": {
        "check": check_perp_bisector_conclusion,
        "nrefs": 3,
        "parse": parse_coord,
        "schema": "segment with point ; equal squared distances  =>  "
                  "P on the perpendicular bisector",
        "description": "Equidistance from both endpoints characterizes "
                       "the perpendicular bisector — G-CO.C.9, "
                       "analytically.",
    },
    "centroid_conclusion": {
        "check": check_centroid_conclusion,
        "nrefs": 7,
        "parse": parse_coord,
        "schema": "ABC ; three side midpoints ; one point collinear "
                  "with every vertex-midpoint pair  =>  the medians "
                  "are concurrent",
        "description": "One exhibited point lies on all three medians "
                       "(midpoints re-verified, collinearity by exact "
                       "cross products) — G-CO.C.10's concurrency, "
                       "analytically.",
    },
    # Contradiction-format warrants: ASSUME a solution, derive a
    # divisibility impossibility, discharge the block.
    "isolate_term": {
        "check": check_isolate_term,
        "nrefs": 2,
        "parse": parse_dioph,
        "schema": "equation ; assumed solution  =>  ax = c - b",
        "description": "Under the assumption, subtract the constant "
                       "from both sides, exactly.",
    },
    "remainder_witness": {
        "check": check_remainder_witness,
        "nrefs": 1,
        "parse": parse_dioph,
        "schema": "ax = v  =>  v = q·a + r with 1 <= r < a",
        "description": "Exhibit the division witness showing a does "
                       "not divide the isolated value.",
    },
    "contradiction_conclusion": {
        "check": check_contradiction_conclusion,
        "nrefs": 3,
        "closes_scope": True,
        "ancestry": {1: "isolate_term"},
        "parse": parse_dioph,
        "schema": "equation ; ax = v ; a does not divide v  =>  no "
                  "integer solution",
        "description": "Discharge the assumption by contradiction: an "
                       "integer solution would force a to divide v, "
                       "and the re-verified remainder says it does not; "
                       "the assumption block closes.",
    },
    "exhibit_solution": {
        "check": check_exhibit_solution,
        "nrefs": 1,
        "parse": parse_dioph,
        "schema": "equation  =>  x = k solves it (verified exactly)",
        "description": "The dual direct certificate: substitute the "
                       "exhibited integer and check equality.",
    },
    # Case-analysis warrants: parity cases opened by CASE lines, each
    # closed conditionally, joined by exhaustiveness.
    "case_substitute": {
        "check": check_case_substitute,
        "nrefs": 2,
        "parse": parse_cases,
        "schema": "n² + cn ; case n = 2a (or 2a + 1)  =>  the "
                  "substituted expansion, exactly",
        "description": "Substitute the case's parametric form and "
                       "expand, verified coefficientwise.",
    },
    "case_conclusion": {
        "check": check_case_conclusion,
        "nrefs": 3,
        "closes_scope": True,
        "ancestry": {2: "quadratic_remainder"},
        "parse": parse_cases,
        "schema": "case ; substitution ; factors as 2·(...)  =>  if n "
                  "is even/odd then n² + cn is even",
        "description": "Close one case with a conditional claim: under "
                       "this case's assumption the expression is "
                       "exactly twice an integer; the case block "
                       "closes and the conditional survives.",
    },
    "exhaustive_parity": {
        "check": check_exhaustive_parity,
        "nrefs": 2,
        "parse": parse_cases,
        "schema": "even case closed ; odd case closed  =>  always even",
        "description": "Even and odd exhaust the integers: with both "
                       "conditional case claims in hand, the universal "
                       "verdict follows.",
    },
    # Pigeonhole warrants (Engel ch. 4): more items than classes
    # forces a shared class.
    "remainder_classes": {
        "check": check_remainder_classes,
        "nrefs": 1,
        "parse": parse_pigeon,
        "schema": "n integers  =>  m residue classes mod m",
        "description": "There are exactly m possible remainders mod m.",
    },
    "pigeonhole_step": {
        "check": check_pigeonhole_step,
        "nrefs": 2,
        "parse": parse_pigeon,
        "schema": "n items ; m classes  =>  n > m, counted exactly",
        "description": "Count items against classes; the strict "
                       "inequality is the whole engine.",
    },
    "pigeonhole_conclusion": {
        "check": check_pigeonhole_conclusion,
        "nrefs": 1,
        "parse": parse_pigeon,
        "schema": "n > m classes  =>  two share a class, so their "
                  "difference is a multiple of m",
        "description": "The pigeonhole principle: with more items than "
                       "classes, some class holds two, and same "
                       "remainder means the difference is divisible.",
    },
    "partition_classes": {
        "check": check_partition_classes,
        "nrefs": 1,
        "parse": parse_pigeon,
        "schema": "numbers from 1..2n  =>  n structured classes "
                  "(consecutive pairs, complementary pairs, or "
                  "odd-part chains)",
        "description": "Exhibit the box structure: 1..2n partitioned "
                       "into n classes, the counting verified exactly.",
    },
    "count_vs_classes": {
        "check": check_count_vs_classes,
        "nrefs": 2,
        "parse": parse_pigeon,
        "schema": "items source ; class structure  =>  items > classes, "
                  "counted exactly",
        "description": "The strict count comparison, matched to the "
                       "cited premise and the cited class structure.",
    },
    "consecutive_pair_conclusion": {
        "check": check_consecutive_pair_conclusion,
        "nrefs": 2,
        "parse": parse_pigeon,
        "schema": "consecutive-pair boxes ; more numbers than boxes  "
                  "=>  two chosen numbers are consecutive",
        "description": "Two numbers share one pair {2i-1, 2i}, so they "
                       "are consecutive.",
    },
    "sum_pair_conclusion": {
        "check": check_sum_pair_conclusion,
        "nrefs": 2,
        "parse": parse_pigeon,
        "schema": "complementary-pair boxes ; more numbers than boxes  "
                  "=>  two chosen numbers sum to 2n + 1",
        "description": "Two numbers share one pair {i, 2n+1-i}, so "
                       "they sum to 2n + 1.",
    },
    "divides_pair_conclusion": {
        "check": check_divides_pair_conclusion,
        "nrefs": 2,
        "parse": parse_pigeon,
        "schema": "odd-part boxes ; more numbers than boxes  =>  one "
                  "chosen number divides another",
        "description": "Two numbers share an odd part q, so both are "
                       "q·2^j — and the smaller divides the larger.",
    },
    "degree_exclusion": {
        "check": check_degree_exclusion,
        "nrefs": 1,
        "parse": parse_pigeon,
        "schema": "gathering of n  =>  at most n - 1 possible "
                  "acquaintance counts",
        "description": "The handshake lemma's box count: 0 and n - 1 "
                       "acquaintances cannot both occur.",
    },
    "same_degree_conclusion": {
        "check": check_same_degree_conclusion,
        "nrefs": 2,
        "parse": parse_pigeon,
        "schema": "degree boxes ; n people > n - 1 counts  =>  two "
                  "people share a count",
        "description": "More people than possible counts: two "
                       "acquaintance counts coincide.",
    },
    "ceiling_count": {
        "check": check_ceiling_count,
        "nrefs": 1,
        "parse": parse_pigeon,
        "schema": "n items in m categories  =>  m(k-1) < n, so "
                  "capacity at k - 1 each is too small",
        "description": "The generalized principle's counting core, "
                       "verified by exact multiplication.",
    },
    "at_least_k_conclusion": {
        "check": check_at_least_k_conclusion,
        "nrefs": 2,
        "parse": parse_pigeon,
        "schema": "categories ; the capacity bound  =>  some category "
                  "holds at least k",
        "description": "The generalized pigeonhole verdict: k = "
                       "ceil(n/m), guaranteed by the cited capacity "
                       "count.",
    },
    # Construction warrants (Euclidea / G-CO.D): compass intersections
    # verified in exact surds.
    "circle_intersection": {
        "check": check_circle_intersection,
        "nrefs": 1,
        "parse": parse_constr,
        "schema": "segment AB  =>  the two circles about A and B "
                  "through each other meet at C (verified in Q(√3))",
        "description": "The constructed point lies on both circles: "
                       "|CA|² and |CB|² both equal |AB|², computed "
                       "exactly in the surd field.",
    },
    "equilateral_conclusion": {
        "check": check_equilateral_conclusion,
        "nrefs": 2,
        "ancestry": {1: "circle_intersection"},
        "parse": parse_constr,
        "schema": "segment ; constructed C  =>  ABC is equilateral",
        "description": "Euclid I.1: the constructed apex makes all "
                       "three sides equal |AB|, exactly.",
    },
    "perp_construction_conclusion": {
        "check": check_perp_construction_conclusion,
        "nrefs": 2,
        "ancestry": {1: "circle_intersection"},
        "parse": parse_constr,
        "schema": "segment ; constructed C  =>  the line through C and "
                  "the midpoint is the perpendicular bisector",
        "description": "C and the midpoint are both equidistant from A "
                       "and B (re-verified exactly), and two "
                       "equidistant points determine the perpendicular "
                       "bisector.",
    },
    # Theory-of-computation kernels: diagonalization (Cantor's move
    # on finite tables) and reduction (certificate transport).
    "diagonal_construction": {
        "check": check_diagonal_construction,
        "nrefs": 1,
        "parse": parse_diag,
        "schema": "table of n strings  =>  the diagonal-flip string",
        "description": "Turn the table on itself: flip every diagonal "
                       "bit, verified bit by bit.",
    },
    "row_difference": {
        "check": check_row_difference,
        "nrefs": 2,
        "parse": parse_diag,
        "schema": "table ; flip string  =>  differs from row i at "
                  "position i",
        "description": "The self-referential position: the flip string "
                       "disagrees with row i exactly where row i meets "
                       "the diagonal.",
    },
    "diagonalization_conclusion": {
        "check": check_diagonalization_conclusion,
        "nrefs": "any",
        "parse": parse_diag,
        "schema": "table ; flip string ; a difference line for every "
                  "row  =>  the string is on no row",
        "description": "Cantor's conclusion: with every row covered by "
                       "a re-verified difference, the constructed "
                       "string escapes the enumeration.",
    },
    "vertex_cover_check": {
        "check": check_vertex_cover,
        "nrefs": 1,
        "parse": parse_graph,
        "schema": "graph  =>  the set covers every edge",
        "description": "A vertex-cover certificate, verified edge by "
                       "edge.",
    },
    "independent_set_check": {
        "check": check_independent_set,
        "nrefs": 1,
        "parse": parse_graph,
        "schema": "graph  =>  the set spans no edge",
        "description": "An independent-set certificate, verified edge "
                       "by edge.",
    },
    "complement_transport": {
        "check": check_complement_transport,
        "nrefs": 3,
        "parse": parse_graph,
        "schema": "graph ; cover ; independent set  =>  one is exactly "
                  "the other's complement",
        "description": "The reduction's instance translation: S covers "
                       "every edge exactly when V minus S spans none.",
    },
    "reduction_conclusion": {
        "check": check_reduction_conclusion,
        "nrefs": 4,
        "parse": parse_graph,
        "schema": "graph ; cover ; independent set ; complement  =>  "
                  "yes maps to yes",
        "description": "Karp-style certificate transport: the size-k "
                       "cover certificate became a size-(n-k) "
                       "independent-set certificate under the "
                       "translation, everything re-verified.",
    },
    # Arithmetization kernels (Toda / IP=PSPACE / sum-check spirit).
    "arithmetize": {
        "check": check_arithmetize, "nrefs": 1, "parse": parse_arith,
        "schema": "Boolean formula  =>  its polynomial (¬x -> 1-x, "
                  "∨ -> +, -, ·; ∧ -> product)",
        "description": "The standard arithmetization, clause for "
                       "clause — existence questions become questions "
                       "about polynomial values.",
    },
    "evaluate_arithmetization": {
        "check": check_evaluate_arithmetization, "nrefs": 2,
        "parse": parse_arith,
        "schema": "formula ; polynomial  =>  p(bits) = 0 or 1",
        "description": "The polynomial agrees with the formula on the "
                       "Boolean cube; one point checked exactly.",
    },
    "arithmetization_count": {
        "check": check_arithmetization_count, "nrefs": "any",
        "parse": parse_arith,
        "schema": "formula ; polynomial ; every cube point  =>  the "
                  "sum counts satisfying assignments",
        "description": "Counting by summation: all eight Boolean "
                       "points covered by re-verified evaluations, so "
                       "the sum is the model count.",
    },
    # Low-degree distance kernels (PCP / error-detecting codes).
    "poly_difference": {
        "check": check_poly_difference, "nrefs": 1, "parse": parse_rs,
        "schema": "f, g over F_p  =>  f - g reduced mod p",
        "description": "Subtract coefficientwise mod p; distinctness "
                       "shows up as a nonzero difference.",
    },
    "degree_root_bound": {
        "check": check_degree_root_bound, "nrefs": 1, "parse": parse_rs,
        "schema": "nonzero difference of degree d  =>  at most d "
                  "agreement points",
        "description": "A nonzero degree-d polynomial has at most d "
                       "roots — the error-detecting core: a lie "
                       "anywhere spreads almost everywhere.",
    },
    "agreement_points": {
        "check": check_agreement_points, "nrefs": 1, "parse": parse_rs,
        "schema": "f, g over F_p  =>  their exact agreement set",
        "description": "Exhaustive evaluation over the small field, "
                       "exactly.",
    },
    "distance_conclusion": {
        "check": check_distance_conclusion, "nrefs": 3, "parse": parse_rs,
        "schema": "pair ; root bound ; agreement set  =>  agreement "
                  "within the degree bound",
        "description": "The distance verdict: low-degree encodings "
                       "disagree almost everywhere.",
    },
    # Frobenius/AKS kernels: primality as a polynomial identity.
    "binomial_coefficient": {
        "check": check_binomial_coefficient, "nrefs": 1,
        "parse": parse_frob,
        "schema": "n  =>  C(n, k) and its residue mod n",
        "description": "One binomial coefficient computed exactly with "
                       "its residue.",
    },
    "frobenius_conclusion": {
        "check": check_frobenius_conclusion, "nrefs": "any",
        "parse": parse_frob,
        "schema": "n ; every middle coefficient ≡ 0  =>  "
                  "(x+1)^n ≡ x^n + 1 (mod n)",
        "description": "The child's binomial identity, certified "
                       "coefficient by coefficient — AKS's algebraic "
                       "heart.",
    },
    "frobenius_refutation": {
        "check": check_frobenius_refutation, "nrefs": 2,
        "parse": parse_frob,
        "schema": "n ; one coefficient ≢ 0  =>  the identity fails "
                  "(so n is composite)",
        "description": "A single nonvanishing coefficient refutes the "
                       "identity and with it n's primality.",
    },
    # Inductive-counting kernels (Immerman–Szelepcsényi).
    "reach_layer": {
        "check": check_reach_layer, "nrefs": 2, "parse": parse_reach,
        "schema": "graph ; previous layer  =>  the next certified "
                  "layer with its count",
        "description": "One expansion step of the reachable set, size "
                       "certified — counting made inductive.",
    },
    "reach_closure": {
        "check": check_reach_closure, "nrefs": 2, "parse": parse_reach,
        "schema": "graph ; final layer  =>  no edge leaves the set",
        "description": "The certified set is closed under every edge.",
    },
    "nonreachable_conclusion": {
        "check": check_nonreachable_conclusion, "nrefs": 2,
        "parse": parse_reach,
        "schema": "graph ; closed set with start inside, target "
                  "outside  =>  target unreachable",
        "description": "Certifying a negative: no walk escapes a "
                       "closed set, so the target cannot be reached.",
    },
    "reach_path": {
        "check": check_reach_path, "nrefs": 1, "parse": parse_reach,
        "schema": "graph  =>  an explicit start-to-target walk",
        "description": "The positive certificate: a path along real "
                       "edges.",
    },
    "reachable_conclusion": {
        "check": check_reachable_conclusion, "nrefs": 2,
        "parse": parse_reach,
        "schema": "graph ; path  =>  target reachable",
        "description": "Reachability from the exhibited walk.",
    },
    # Order-finding kernels (Shor's classical engine).
    "modular_power": {
        "check": check_modular_power, "nrefs": 1, "parse": parse_order,
        "schema": "a mod N  =>  a^k ≡ v (mod N)",
        "description": "One modular power, exactly.",
    },
    "order_conclusion": {
        "check": check_order_conclusion, "nrefs": "any",
        "parse": parse_order,
        "schema": "a mod N ; a^r ≡ 1 ; a^(r/q) ≢ 1 for every prime "
                  "q dividing r  =>  the order is r",
        "description": "The period certificate: r works and no maximal "
                       "proper divisor does — minimality from exactly "
                       "the right witnesses, all re-verified.",
    },
    "shor_extraction": {
        "check": check_shor_extraction, "nrefs": 2, "parse": parse_order,
        "schema": "a mod N ; even order r  =>  gcd(a^(r/2) ± 1, N) "
                  "factor N",
        "description": "Shor's classical payoff: the period splits N "
                       "through two gcds, both recomputed exactly.",
    },
    # Trapdoor kernels (one-way functions in action).
    "rsa_setup": {
        "check": check_rsa_setup, "nrefs": 1, "parse": parse_trapdoor,
        "schema": "p, q, e  =>  N = pq and φ = (p-1)(q-1)",
        "description": "The public modulus and its secret totient.",
    },
    "modular_inverse": {
        "check": check_modular_inverse, "nrefs": 2,
        "parse": parse_trapdoor,
        "schema": "key ; N, φ  =>  d with e·d ≡ 1 (mod φ)",
        "description": "The trapdoor itself: the secret exponent "
                       "inverting e, verified exactly.",
    },
    "rsa_round_trip": {
        "check": check_rsa_round_trip, "nrefs": 3,
        "parse": parse_trapdoor,
        "schema": "key ; N, φ ; d  =>  m -> m^e -> (m^e)^d = m",
        "description": "Easy forward, inverted through the secret: the "
                       "full round trip on a concrete message.",
    },
    "trapdoor_conclusion": {
        "check": check_trapdoor_conclusion, "nrefs": 3,
        "parse": parse_trapdoor,
        "schema": "key ; d ; round trip  =>  e is a trapdoor "
                  "permutation exponent",
        "description": "The conclusion ties the exhibited secret to "
                       "the verified round trip.",
    },
    "dh_power": {
        "check": check_dh_power, "nrefs": 1, "parse": parse_trapdoor,
        "schema": "p, g, secrets  =>  one public power g^x mod p",
        "description": "A public Diffie-Hellman value, exactly.",
    },
    "dh_agreement": {
        "check": check_dh_agreement, "nrefs": 3, "parse": parse_trapdoor,
        "schema": "setup ; both public values  =>  A^b ≡ B^a: the "
                  "shared secret",
        "description": "Both parties reach the same secret through "
                       "different exponentiations — commutativity as a "
                       "shared resource.",
    },
    # Critic warrant (Phase 6): close an error-spotting record.
    "flaw_verdict": {
        "check": check_flaw_verdict,
        "nrefs": 1,
        "parse": parse_flaw,
        "schema": "correct re-derived line  =>  step <k>; <correct claim>",
        "description": "Flag the flawed step of the derivation quoted in "
                       "the problem: the verdict's corrected claim must "
                       "equal the cited re-derived line, exactly.",
    },
}


# ---------------------------------------------------------------------------
# The validity oracle.
# ---------------------------------------------------------------------------


def check_proof(example):
    """Replays a proof record's derivation; returns a list of violations.

    An empty list means the derivation is valid: line numbers are strictly
    increasing, every STEP names a registered warrant and cites exactly
    the warrant's arity of earlier lines, and the claim follows from the
    cited lines — by one application of a rewrite warrant (the inverse
    relation replayed forward for ``inverse_of`` entries), or by a
    judgment warrant's direct check; IH blocks are properly scoped —
    opened by an IH line, discharged by an induction_conclusion whose
    strand terminals descend from their root warrants, with the block's
    lines uncitable afterward and no block left open at QED; and the
    final QED payload equals both final_answer (shape contract) and the
    last derived claim's canonical rendering when the record ends on a
    derived expression.
    """
    violations = []
    lines = {}
    line_refs = {}
    line_warrant = {}
    discharged = set()
    scope = None          # line numbers of the open IH block, or None
    last_k = 0
    last_claim = None
    steps = example["steps"]
    for raw in steps[:-1]:
        fields = raw.split(DELIM)
        op = fields[0]
        if op == "PREMISE":
            if len(fields) != 3:
                violations.append(f"malformed PREMISE: {raw!r}")
                continue
            k, statement = fields[1], fields[2]
        elif op in ("IH", "ASSUME", "CASE"):
            if len(fields) != 3:
                violations.append(f"malformed {op}: {raw!r}")
                continue
            if scope is not None:
                violations.append(
                    f"nested assumption blocks are not supported: {raw!r}")
                continue
            k, statement = fields[1], fields[2]
        elif op == "STEP":
            if len(fields) != 5:
                violations.append(f"malformed STEP: {raw!r}")
                continue
            k, statement = fields[1], fields[2]
        else:
            violations.append(f"unknown proof line op-code {op!r}: {raw!r}")
            continue
        if not k.isdigit() or int(k) <= last_k:
            violations.append(f"line numbers must strictly increase: {raw!r}")
            continue
        k = int(k)
        closes_scope = False
        if op == "STEP":
            warrant, refs = fields[3], fields[4]
            if warrant not in WARRANTS:
                violations.append(f"unregistered warrant {warrant!r}: {raw!r}")
                continue
            entry = WARRANTS[warrant]
            forward = WARRANTS[entry["inverse_of"]] if "inverse_of" in entry \
                else entry
            parser = entry.get("parse", forward.get("parse", parse))
            nrefs = entry.get("nrefs", 1)
            ref_list = refs.split(",")
            if nrefs != "any" and len(ref_list) != nrefs:
                violations.append(
                    f"STEP {k} cites {len(ref_list)} line(s); "
                    f"{warrant!r} requires {nrefs}")
                continue
            if any(not r.isdigit() or int(r) not in lines for r in ref_list):
                violations.append(f"STEP {k} references unknown line(s) "
                                  f"{refs!r}")
                continue
            ref_ids = [int(r) for r in ref_list]
            dead = sorted(r for r in ref_ids if r in discharged)
            if dead:
                violations.append(
                    f"STEP {k} cites discharged line(s) {dead}: their IH "
                    f"block is closed and its assumption is gone")
                continue
            try:
                prevs = [parser(lines[r]) for r in ref_ids]
                claim = parser(statement)
            except ValueError as e:
                violations.append(f"unparseable expression at line {k}: {e}")
                continue
            if "check" in entry:
                valid = bool(entry["check"](claim, prevs))
            elif "inverse_of" in entry:
                valid = prevs[0] in forward["apply"](claim)
            else:
                valid = claim in forward["apply"](prevs[0])
            if not valid:
                violations.append(
                    f"STEP {k} claim {statement!r} does not follow from "
                    f"line(s) {refs} by {warrant!r}")
                continue
            if "ancestry" in entry:
                bad_ancestry = False
                for idx, needed in entry["ancestry"].items():
                    rid = ref_ids[idx]
                    if not any(line_warrant.get(a) == needed
                               for a in _cited_closure(rid, line_refs)
                               | {rid}):
                        violations.append(
                            f"STEP {k}: cited line {rid} does not descend "
                            f"from a {needed!r} step")
                        bad_ancestry = True
                        break
                if bad_ancestry:
                    continue
            if entry.get("closes_scope"):
                if scope is None:
                    violations.append(f"STEP {k}: {warrant!r} with no "
                                      f"open IH block")
                    continue
                closes_scope = True
            line_refs[k] = ref_ids
            line_warrant[k] = warrant
        lines[k] = statement
        if op in ("IH", "ASSUME", "CASE"):
            scope = {k}
        elif closes_scope:
            discharged |= scope
            scope = None
        elif scope is not None:
            scope.add(k)
        last_k, last_claim = k, statement
    if scope is not None:
        violations.append(
            "assumption block never discharged by a closing step")
    final = steps[-1].split(DELIM, 1)
    if final[0] != "QED" or len(final) != 2:
        violations.append(f"final step must be QED: {steps[-1]!r}")
    elif final[1] != str(example["final_answer"]):
        violations.append("QED payload differs from final_answer")
    elif last_claim is not None and final[1] != last_claim:
        violations.append(
            f"QED payload {final[1]!r} differs from the last derived "
            f"claim {last_claim!r}")
    return violations