src/noulith/third.py

"""Exact third-deficit classification and witnesses for m >= 6.

The analytic theorem concerns complex germs q_ij=-exp(theta_ij) at theta=0.
The executable witness routine deliberately accepts only real rational q with
abs(q+1)<1/20, a certified neighborhood where its unique-matching factors
cannot vanish. No floating-point zero threshold is used.
"""
from __future__ import annotations
from dataclasses import dataclass
from itertools import combinations, permutations
from math import comb, ceil
from typing import Mapping, Iterable
import sympy as sp
from .algebra import TwistedAlgebra, bits

Pair = tuple[int, int]
Component = tuple[str, tuple[int, ...]]


def pairs(m: int) -> tuple[Pair, ...]:
    return tuple(combinations(range(m), 2))


def directed_q(q: Mapping[Pair, sp.Expr], i: int, j: int) -> sp.Expr:
    if i == j:
        raise ValueError('distinct channel indices required')
    return q[i, j] if i < j else 1 / q[j, i]


def support_edges(m: int, q: Mapping[Pair, sp.Expr]) -> set[Pair]:
    return {e for e in pairs(m) if sp.simplify(q[e] + 1) != 0}


def all_components(m: int) -> tuple[Component, ...]:
    if m < 6:
        raise ValueError('the third-deficit classification requires m >= 6')
    return (tuple(('star', (v,)) for v in range(m))
            + tuple(('triangle', t) for t in combinations(range(m), 3))
            + tuple(('twin', p) for p in pairs(m)))


def component_membership(m: int, q: Mapping[Pair, sp.Expr]) -> tuple[Component, ...]:
    """Return every component containing a point; intersections are not collapsed."""
    E = support_edges(m, q)
    answer: list[Component] = []
    for kind, labels in all_components(m):
        if kind == 'star':
            valid = all(labels[0] in e for e in E)
        elif kind == 'triangle':
            valid = all(set(e) <= set(labels) for e in E)
        else:
            core = tuple(i for i in range(m) if i not in labels)
            valid = all(e[0] in labels or e[1] in labels for e in E)
            if valid:
                valid = all(sp.simplify(directed_q(q, i, p)
                                        - directed_q(q, core[0], p)) == 0
                            for p in labels for i in core[1:])
        if valid:
            answer.append((kind, labels))
    return tuple(answer)


def component_equations(m: int, component: Component) -> sp.Matrix:
    """Linear equations in ascending theta_ij coordinates over Q."""
    es = pairs(m); index = {e: k for k, e in enumerate(es)}
    n = len(es)
    def row(i: int, j: int) -> sp.Matrix:
        v = sp.zeros(1, n)
        v[0, index[min(i, j), max(i, j)]] = 1 if i < j else -1
        return v
    kind, labels = component
    if component not in all_components(m):
        raise ValueError('unknown component')
    rows = []
    if kind == 'star':
        rows = [row(i, j) for i, j in es if labels[0] not in (i, j)]
    elif kind == 'triangle':
        rows = [row(i, j) for i, j in es if not {i, j} <= set(labels)]
    else:
        core = tuple(i for i in range(m) if i not in labels)
        rows += [row(i, j) for i, j in combinations(core, 2)]
        rows += [row(i, p) - row(core[0], p) for p in labels for i in core[1:]]
    return sp.Matrix.vstack(*rows) if rows else sp.zeros(0, n)


def intersection_dimension(m: int, components: Iterable[Component]) -> int:
    rows = [component_equations(m, c) for c in components]
    return comb(m, 2) - (sp.Matrix.vstack(*rows).rank() if rows else 0)


def _small_shuffle(alg: TwistedAlgebra, vertices: Iterable[int]) -> sp.Expr:
    return alg.shuffle_bruteforce(sum(1 << i for i in vertices))


def complete_multipartite_parts(m: int, E: set[Pair]) -> tuple[tuple[tuple[int, ...], ...], tuple[int, ...]]:
    """Find the single nontrivial complete-multipartite component plus isolates.

    Raises ValueError unless this structure holds. This is a graph routine,
    not a replacement for checking the quartet cancellation hypothesis.
    """
    adj = [set() for _ in range(m)]
    for i, j in E:
        adj[i].add(j); adj[j].add(i)
    active = {i for i in range(m) if adj[i]}
    isolates = tuple(i for i in range(m) if not adj[i])
    if not active:
        return (), isolates
    remaining = set(active); groups = []
    while remaining:
        v = min(remaining)
        group = tuple(sorted(active - adj[v]))
        if v not in group or not set(group) <= remaining:
            raise ValueError('support is not complete multipartite plus isolates')
        groups.append(group); remaining -= set(group)
    part_of = {i: k for k, g in enumerate(groups) for i in g}
    if any(((i, j) in E) != (part_of[i] != part_of[j])
           for i, j in combinations(sorted(active), 2)):
        raise ValueError('support is not complete multipartite plus isolates')
    return tuple(groups), isolates


def multipartite_matching(groups: Iterable[Iterable[int]]) -> tuple[Pair, ...]:
    """Maximum matching: repeatedly take vertices from two largest parts."""
    work = [list(g) for g in groups if g]; out = []
    while len(work) >= 2:
        work.sort(key=lambda g: (-len(g), tuple(g)))
        a, b = work[0].pop(), work[1].pop()
        out.append(tuple(sorted((a, b))))
        work = [g for g in work if g]
    return tuple(out)


@dataclass(frozen=True)
class VisibilityCertificate:
    visible: bool
    motif: tuple[tuple[int, ...], ...] = ()
    normalized_response: sp.Expr = sp.S.Zero
    components: tuple[Component, ...] = ()

    def full_partition(self, m: int) -> tuple[int, ...]:
        if not self.visible:
            raise ValueError('an invisible point has no nonzero witness')
        used = {i for block in self.motif for i in block}
        blocks = tuple(sum(1 << i for i in block) for block in self.motif)
        return blocks + tuple(1 << i for i in range(m) if i not in used)


def certify_scalar(m: int, q: Mapping[Pair, sp.Expr]) -> VisibilityCertificate:
    """O(m^4) rational ring operations; excludes coefficient bit complexity.

    Returns a nonzero raw algebraic word coefficient up to its known crossing unit,
    or all containing components of the proved reduced resonance arrangement.
    """
    if m < 6:
        raise ValueError('m must be >= 6')
    alg = TwistedAlgebra(m, q)
    if any(not v.is_Rational or abs(v + 1) >= sp.Rational(1, 20) for v in alg.q.values()):
        raise ValueError('certified implementation requires rational |q_ij+1| < 1/20')
    q = alg.q
    for four in combinations(range(m), 4):
        value = _small_shuffle(alg, four)
        if value != 0:
            return VisibilityCertificate(True, (four,), value)
    E = support_edges(m, q)
    groups, isolates = complete_multipartite_parts(m, E)
    matching = multipartite_matching(groups)
    if len(matching) <= 1:
        memberships = component_membership(m, q)
        if not memberships:
            raise AssertionError('proved matching-one classification was violated')
        return VisibilityCertificate(False, components=memberships)
    if isolates:
        edge, other = matching[:2]
        triple = tuple(sorted((*other, isolates[0])))
        value = sp.expand((1 + q[edge]) * _small_shuffle(alg, triple))
        if value == 0:
            raise AssertionError('single-edge triple coefficient unexpectedly vanished')
        return VisibilityCertificate(True, (edge, triple), value)
    if len(matching) >= 3:
        motif = matching[:3]
        value = sp.prod(1 + q[e] for e in motif)
        return VisibilityCertificate(True, motif, value)
    core = max(groups, key=len)
    if len(core) != m - 2:
        raise AssertionError('multipartite matching bound failed')
    outliers = tuple(i for i in range(m) if i not in core)
    for p in outliers:
        other = next(v for v in outliers if v != p)
        for i, j in combinations(core, 2):
            if sp.simplify(directed_q(q, i, p) - directed_q(q, j, p)) != 0:
                k = next(v for v in core if v not in (i, j))
                triple = tuple(sorted((i, j, p)))
                edge = tuple(sorted((other, k)))
                value = sp.expand(_small_shuffle(alg, triple) * (1 + q[edge]))
                if value == 0:
                    raise AssertionError('nonuniform twin coefficient unexpectedly vanished')
                return VisibilityCertificate(True, (triple, edge), value)
    memberships = component_membership(m, q)
    if not memberships:
        raise AssertionError('proved twin classification was violated')
    return VisibilityCertificate(False, components=memberships)


def scalar_second_on_subset(q: Mapping[Pair, sp.Expr], vertices: Iterable[int]) -> bool:
    vertices = tuple(vertices)
    for p in vertices:
        core = tuple(i for i in vertices if i != p)
        if all(q[min(i,j), max(i,j)] == -1 for i,j in combinations(core, 2)):
            if all(sp.simplify(directed_q(q, i, p) - directed_q(q, core[0], p)) == 0
                   for i in core[1:]):
                return True
    return False


def predicted_rank(m: int, q: Mapping[Pair, sp.Expr]) -> int:
    """Exact full-state formula at deficit three, in the theorem's neighborhood."""
    if m < 6:
        raise ValueError('m must be >=6')
    E = support_edges(m, q)
    pair_losses = sum(all(i in cover or j in cover for i,j in E) for cover in pairs(m))
    singleton_losses = sum(scalar_second_on_subset(q, (i for i in range(m) if i != v))
                           for v in range(m))
    scalar_loss = bool(component_membership(m, q))
    return 2**m - pair_losses - singleton_losses - int(scalar_loss)


def direct_block_rank(m: int, q: Mapping[Pair, sp.Expr], r: int) -> int:
    """Independent all-subset shuffle DP, not the component classification."""
    if not 0 <= r <= m:
        raise ValueError('invalid block budget')
    P = TwistedAlgebra(m, q).shuffle_table()
    cost = [m+1] * (1 << m); cost[0] = 0
    for S in range(1, 1 << m):
        pivot = S & -S; B = S
        while B:
            if B & pivot and P[B] != 0:
                cost[S] = min(cost[S], 1 + cost[S ^ B])
            B = (B - 1) & S
    return sum(c <= r for c in cost)


def calibration_classes(m: int, selected_twins: Iterable[Pair]) -> tuple[tuple[Pair, ...], ...]:
    """Connected classes of edge rescalings forced equal by selected twins."""
    es = pairs(m); parent = {e: e for e in es}
    def root(e):
        while parent[e] != e:
            parent[e] = parent[parent[e]]; e = parent[e]
        return e
    def union(a,b):
        a,b = root(a),root(b)
        if a != b: parent[b] = a
    for pair in selected_twins:
        if pair not in es:
            raise ValueError('selected outlier pairs must be ascending valid pairs')
        for p in pair:
            group = [tuple(sorted((p, i))) for i in range(m) if i not in pair]
            for e in group[1:]: union(group[0], e)
    result: dict[Pair, list[Pair]] = {}
    for e in es: result.setdefault(root(e), []).append(e)
    return tuple(sorted((tuple(v) for v in result.values()), key=lambda v: v[0]))


def optimal_calibration_subfamily(m: int) -> tuple[Pair, ...]:
    """Attains ceil(2(m-1)/3); counts component constraints, not detector outputs."""
    if m < 6:
        raise ValueError('the proved sharp bound requires m >= 6')
    n = m - 1
    sizes = ([] if n % 3 == 0 else [4 if n % 3 == 1 else 5])
    sizes += [3] * ((n - sum(sizes)) // 3)
    start = 0; answer = []
    for size in sizes:
        group = range(start, start + size)
        answer.extend((i, i+1) for i in list(group)[:-1])
        start += size
    assert start == n and len(answer) == ceil(2*n/3)
    return tuple(answer)


def q_from_exponents(exponents: Iterable[Iterable[int]], base=sp.Rational(1001,1000)) -> dict[Pair, sp.Expr]:
    d = [list(row) for row in exponents]; m=len(d)
    if any(len(row) != m for row in d) or any(d[i][j] != -d[j][i] for i in range(m) for j in range(m)):
        raise ValueError('a square antisymmetric exponent array is required')
    return {(i,j): -sp.sympify(base)**d[i][j] for i,j in pairs(m)}


def example_point(m: int, kind: str, permutation: Iterable[int] | None = None) -> dict[Pair, sp.Expr]:
    d = [[0]*m for _ in range(m)]
    def put(i,j,v): d[i][j]=v;d[j][i]=-v
    if kind in ('star','uniform_star','star_twin'):
        for j in range(1,m):
            put(0,j,j if kind=='star' else (3 if kind=='star_twin' and j==m-1 else 2))
    elif kind=='triangle':
        for e,v in zip([(0,1),(0,2),(1,2)],[1,3,4]): put(*e,v)
    elif kind=='twin':
        for i in range(m-2): put(i,m-2,2);put(i,m-1,3)
        put(m-2,m-1,4)
    elif kind=='edge': put(0,1,2)
    elif kind=='double_star':
        for j in range(2,m): put(0,j,j);put(1,j,j+1)
        put(0,1,4)
    elif kind=='generic':
        for i,j in pairs(m): put(i,j,(3*i+2*j)%7+1)
    elif kind!='origin': raise ValueError('unknown example kind')
    if permutation is not None:
        p=tuple(permutation)
        if sorted(p)!=list(range(m)):raise ValueError('invalid permutation')
        d=[[d[p[i]][p[j]] for j in range(m)] for i in range(m)]
    return q_from_exponents(d)