#!/usr/bin/env python3
"""Exact rational and symbolic checks for Avenyra Area Feedback, version 1.0.0.

Requires Python 3 and SymPy (tested with SymPy 1.14.0).
Run from this release directory: python verify_avenyra.py

This script checks a finite family of rational examples and verifies specified
polynomial and differential identities symbolically. Universal reachability,
topological, and limiting arguments are proved in the editable manuscript
Avenyra_Area_Feedback_v1.0.0.tex. These checks do not replace those arguments
and do not establish originality, physical realizability, or computational
advantage.
"""

from __future__ import annotations

from dataclasses import dataclass
from itertools import combinations
from math import comb
from random import Random
import sympy as sp


@dataclass(frozen=True)
class State:
    x: sp.Matrix
    A: sp.Matrix

    @property
    def d(self):
        return self.x.rows


def unit(d, i):
    result = sp.zeros(d, 1)
    result[i] = 1
    return result


def sq(v):
    return sp.expand((v.T * v)[0]) if v.rows else sp.Integer(0)


def wedge(x, a):
    return x * a.T - a * x.T


def null_matrix(A):
    basis = A.nullspace()
    return sp.Matrix.hstack(*basis) if basis else sp.zeros(A.cols, 0)


def projector(columns):
    if not columns.cols:
        return sp.zeros(columns.rows)
    return columns * (columns.T * columns).inv() * columns.T


def split(state):
    K = null_matrix(state.A)
    P = projector(K)
    w = P * state.x
    u = state.x - w
    # A+P is invertible: it restricts to A on im(A) and to I on ker(A).
    h = (state.A + P).inv() * u if state.d else sp.zeros(0, 1)
    return K, P, u, w, h


def rho2(state):
    return sq(split(state)[2])


def energy(A):
    return sp.expand(-sp.Rational(1, 2) * sp.trace(A * A))


def step(state, a):
    assert a.shape == state.x.shape
    assert state.A.T == -state.A
    assert state.A * a == sp.zeros(state.d, 1), "inadmissible input"
    return State(state.x + a, state.A + wedge(state.x, a))


def same_subspace(B, C):
    return B.rows == C.rows and B.rank() == C.rank() == B.row_join(C).rank()


def exterior_wedge(left, right):
    """Coordinate exterior product; keys are increasing index tuples."""
    out = {}
    for I, c in left.items():
        for J, d in right.items():
            if set(I).intersection(J):
                continue
            inversions = sum(i > j for i in I for j in J)
            index = tuple(sorted(I + J))
            out[index] = out.get(index, 0) + (-1) ** inversions * c * d
    return {I: sp.expand(c) for I, c in out.items() if c != 0}


def exterior_vector(x):
    return {(i,): x[i] for i in range(x.rows) if x[i] != 0}


def exterior_bivector(A):
    return {(i, j): A[i, j] for i in range(A.rows)
            for j in range(i + 1, A.cols) if A[i, j] != 0}


def exterior_norm2(form):
    return sp.expand(sum(c * c for c in form.values()))


def divided_powers(A):
    alpha = exterior_bivector(A)
    powers = [{(): sp.Integer(1)}]
    for j in range(1, A.rows // 2 + 1):
        power = exterior_wedge(powers[-1], alpha)
        powers.append({I: sp.cancel(c / j) for I, c in power.items()})
    return powers


def check_exterior(before, a, after):
    t = sp.Symbol("t")
    p = sp.Poly(before.A.charpoly(t).as_expr(), t)
    q = sp.Poly(after.A.charpoly(t).as_expr(), t)
    old_powers = divided_powers(before.A)
    new_powers = divided_powers(after.A)
    xa = exterior_wedge(exterior_vector(before.x), exterior_vector(a))
    for j, (old, new) in enumerate(zip(old_powers, new_powers)):
        old_norm = exterior_norm2(old)
        new_norm = exterior_norm2(new)
        assert p.coeff_monomial(t ** (before.d - 2 * j)) == old_norm
        assert q.coeff_monomial(t ** (before.d - 2 * j)) == new_norm
        if j:
            added = exterior_wedge(old_powers[j - 1], xa)
            assert new_norm == old_norm + exterior_norm2(added)


def check_move(before, a, include_exterior=True):
    after = step(before, a)
    K, P, u, w, h = split(before)
    K_after = null_matrix(after.A)
    independent = sp.Matrix.hstack(w, a).rank() == 2

    # Exact kernel formula, with no floating-point nullspace thresholds.
    gate_matrix = wedge(w, a) * K
    coefficient_kernel = null_matrix(gate_matrix)
    Z = K * coefficient_kernel
    predicted_kernel = (sp.eye(before.d) - h * a.T) * Z
    assert same_subspace(K_after, predicted_kernel)
    assert after.A.rank() == before.A.rank() + (2 if independent else 0)

    old_rho = sq(u)
    if independent:
        predicted_rho = old_rho + sq(w + a)
        assert K_after.T * after.x == sp.zeros(K_after.cols, 1)
    else:
        dot = (a.T * (w + a))[0] if before.d else sp.Integer(0)
        predicted_rho = old_rho + sq(h) * dot ** 2 / (1 + sq(h) * sq(a))
    assert sp.cancel(rho2(after) - predicted_rho) == 0
    assert rho2(after) >= old_rho

    # Attainment of the exact future floor by the projection-canceling move.
    attaining = step(before, -w)
    assert attaining.x == u
    assert rho2(attaining) == old_rho
    assert sq(attaining.x) == old_rho

    c = (before.x.T * a)[0] if before.d else sp.Integer(0)
    D = sq(before.x) * sq(a) - c * c
    assert energy(after.A) == energy(before.A) + D
    assert sq(after.A * after.x) == sq(before.A * before.x) + sq(after.x) * D

    # Algebraic inversion exists, but is legal exactly for a zero wedge.
    reverse_legal = after.A * (-a) == sp.zeros(before.d, 1)
    assert reverse_legal == (D == 0)
    if reverse_legal:
        recovered = step(after, -a)
        assert recovered.x == before.x and recovered.A == before.A
    if include_exterior:
        check_exterior(before, a, after)
    return after


def check_orthogonal_launch(max_d=8):
    cases = 0
    for d in range(max_d + 1):
        state = State(sp.zeros(d, 1), sp.zeros(d))
        for n in range(d + 1):
            expected_A = sp.zeros(d)
            for i in range(n):
                for j in range(i + 1, n):
                    expected_A[i, j] = 1
                    expected_A[j, i] = -1
            assert state.A == expected_A
            assert state.A.rank() == 2 * (n // 2)
            expected_rho = 0 if n == 0 else (
                sp.Integer(n) if n % 2 == 0 else sp.Integer(n) - sp.Rational(1, n)
            )
            assert rho2(state) == expected_rho
            powers = divided_powers(state.A)
            for j, power in enumerate(powers):
                assert exterior_norm2(power) == (comb(n, 2*j) if 2*j <= n else 0)
            t = sp.Symbol("t")
            reduced = sp.expand(((t + 1)**n + (t - 1)**n) / 2)
            assert sp.expand(state.A.charpoly(t).as_expr() - t**(d-n) * reduced) == 0
            cases += 1
            if n < d:
                state = check_move(state, unit(d, n), include_exterior=False)
    return cases


def check_general_cases():
    rng = Random(741103)
    count = 0
    for d in range(7):
        for r in range(0, d + 1, 2):
            for repetition in range(3):
                A = sp.zeros(d)
                for j in range(r // 2):
                    A[2*j, 2*j+1] = j + 1
                    A[2*j+1, 2*j] = -(j + 1)
                S = sp.eye(d)
                if d >= 2:
                    for _ in range(3):
                        i, j = rng.sample(range(d), 2)
                        shear = sp.eye(d)
                        shear[i, j] = rng.choice([-1, 1])
                        S = shear * S
                A = S * A * S.T
                x = sp.Matrix([rng.randint(-2, 2) for _ in range(d)]) if d else sp.zeros(0, 1)
                state = State(x, A)
                K = null_matrix(A)
                coefficients = sp.Matrix([rng.randint(-2, 2) for _ in range(K.cols)]) if K.cols else sp.zeros(0, 1)
                a = K * coefficients
                check_move(state, a)
                count += 1
    return count


def maximal_rank_history(d, initially_charged):
    x = unit(d, 0) if initially_charged and d else sp.zeros(d, 1)
    state = State(x, sp.zeros(d))
    move_count = 0
    while state.A.rank() < 2 * (d // 2):
        K, _, _, w, _ = split(state)
        basis = [K[:, j] for j in range(K.cols)]
        if w == sp.zeros(d, 1):
            a = basis[0]
        else:
            a = next(b for b in basis if sp.Matrix.hstack(w, b).rank() == 2)
        state = check_move(state, a, include_exterior=False)
        move_count += 1
    m = d // 2
    expected = 0 if m == 0 else 2*m - int(initially_charged)
    assert move_count == expected
    assert state.A.rank() == 2*m
    return move_count


def check_examples():
    # Two-dimensional halt.
    s = State(sp.zeros(2, 1), sp.zeros(2))
    s = check_move(s, unit(2, 0))
    s = check_move(s, unit(2, 1))
    assert s.A.det() == 1 and rho2(s) == 2
    assert null_matrix(s.A).cols == 0

    # Same current x and gate, different next gate.
    results = []
    for order in [(0, 1), (1, 0)]:
        s = State(sp.zeros(3, 1), sp.zeros(3))
        for i in order:
            s = check_move(s, unit(3, i))
        assert s.x == sp.Matrix([1, 1, 0])
        assert same_subspace(null_matrix(s.A), unit(3, 2))
        results.append(check_move(s, unit(3, 2)))
    assert same_subspace(null_matrix(results[0].A), sp.Matrix([1, -1, 1]))
    assert same_subspace(null_matrix(results[1].A), sp.Matrix([-1, 1, 1]))
    assert not same_subspace(null_matrix(results[0].A), null_matrix(results[1].A))
    assert rho2(results[0]) == sp.Rational(8, 3)
    attaining = check_move(results[0], -sp.Rational(1, 3) * sp.Matrix([1, -1, 1]))
    assert attaining.x == sp.Matrix([sp.Rational(2, 3), sp.Rational(4, 3), sp.Rational(2, 3)])
    assert sq(attaining.x) == sp.Rational(8, 3)

    # Different memory magnitudes, equal current x, gate, and distance floor.
    for lam in [sp.Integer(-1), sp.Integer(1), sp.Integer(2)]:
        s = State(sp.zeros(3, 1), sp.zeros(3))
        s = check_move(s, lam * unit(3, 0))
        s = check_move(s, (1-lam) * unit(3, 0) + unit(3, 1))
        assert s.x == sp.Matrix([1, 1, 0]) and rho2(s) == 2
        assert same_subspace(null_matrix(s.A), unit(3, 2))
        s = check_move(s, unit(3, 2))
        assert same_subspace(null_matrix(s.A), sp.Matrix([1, -1, lam]))
        assert rho2(s) == 2 + sp.Rational(2, lam**2 + 2)

    # Dormant blocks with different spectra produce the same future behavior.
    d = 5
    x = unit(d, 0) + unit(d, 1)
    active = wedge(unit(d, 0), unit(d, 1))
    dormant = wedge(unit(d, 3), unit(d, 4))
    left = State(x, active + dormant)
    right = State(x, active + 7*dormant)
    for _ in range(4):
        KL, KR = null_matrix(left.A), null_matrix(right.A)
        assert same_subspace(KL, KR)
        a = KL[:, 0]
        assert a[3] == a[4] == 0
        left = check_move(left, a, include_exterior=False)
        right = check_move(right, a, include_exterior=False)
        assert left.x == right.x
        assert right.A - left.A == 6*dormant
        assert same_subspace(null_matrix(left.A), null_matrix(right.A))


def check_failure_modes():
    # Removing the admissibility condition allows complete cancellation.
    e1, e2 = unit(2, 0), unit(2, 1)
    A, x, a = wedge(e1, e2), e1, -e2
    assert A*a != sp.zeros(2, 1)
    assert A + wedge(x, a) == sp.zeros(2)

    # Legal finite jumps need not remain legal under uniform subdivision.
    s = State(e1, sp.zeros(2))
    halfway = step(s, e2/2)
    assert halfway.A * (e2/2) != sp.zeros(2, 1)

    # Indefinite metric counterexample: a legal update drops rank 2 to 0.
    G = sp.diag(-1, 1, 1)
    a, x = sp.Matrix([1, 1, 0]), sp.Matrix([0, 0, 1])
    signed_wedge = x * a.T * G - a * x.T * G
    A = -signed_wedge
    assert A.T * G + G * A == sp.zeros(3)
    assert A.rank() == 2 and A*a == sp.zeros(3, 1)
    assert A + signed_wedge == sp.zeros(3)


def check_spectral_reduction():
    t = sp.Symbol("t")
    # Canonical rank-preserving example: two nonzero skew blocks and one kernel direction.
    for birth in [False, True]:
        d = 6 if birth else 5
        A = sp.zeros(d)
        A[0, 1], A[1, 0] = 2, -2
        A[2, 3], A[3, 2] = 3, -3
        x = 3*unit(d, 0) + 4*unit(d, 2)
        a = 2*unit(d, 4)
        if birth:
            x += 5*unit(d, 5)
            diagonal = sp.diag(4, 9, 0)
            v = sp.Matrix([6, 8, 10])
            zero_power = d-6
        else:
            x += 5*unit(d, 4)
            diagonal = sp.diag(4, 9)
            v = sp.Matrix([6, 8])
            zero_power = d-4
        result = check_move(State(x, A), a)
        H = diagonal + v*v.T
        expected = t**zero_power * (t*t*sp.eye(H.rows) + H).det()
        assert sp.expand(result.A.charpoly(t).as_expr() - expected) == 0


def check_three_step_accessibility():
    p, q, r = sp.symbols("p q r", real=True)
    x, k = sp.Matrix([1, 1, 0]), sp.Matrix([0, 0, 1])
    for parameter in [p, q, r]:
        next_x = x + parameter*k
        next_k = k + parameter*x.cross(k)
        x, k = next_x.applyfunc(sp.expand), next_k.applyfunc(sp.expand)
    expected = sp.Matrix([
        1+p*q+p*r+q*r+p*p*q*r,
        1-p*q-p*r-q*r+p*p*q*r,
        p+q+r-2*p*q*r,
    ])
    assert x == expected
    jacobian = x.jacobian([p, q, r])
    expected_det = 2*p*(q-r)*(2*p*p*q*r+p*p-p*q-p*r+2*q*r)
    assert sp.expand(jacobian.det()-expected_det) == 0
    witness = {p: 1, q: 1, r: 2}
    assert x.subs(witness) == sp.Matrix([8, -2, 0])
    assert jacobian.det().subs(witness) == -12
    assert jacobian.subs(witness) == sp.Matrix([[7, 5, 3], [1, -1, -1], [-3, -3, -1]])


def check_general_three_dimensional_accessibility():
    """Check the exact polynomial identities used by the 3D classification.

    The inverse function theorem and the invariant-line induction are arguments
    in the manuscript. The code verifies their algebraic premises, including
    the general canonical state with arbitrary axial displacement z.
    """
    b, c = sp.symbols("b c", positive=True)
    z, p, q, r = sp.symbols("z p q r", real=True)
    x, k = sp.Matrix([b, 0, z]), sp.Matrix([0, 0, c])
    states = [(x, k)]
    for parameter in [p, q, r]:
        next_x = x + parameter*k
        next_k = k + parameter*x.cross(k)
        x, k = next_x.applyfunc(sp.expand), next_k.applyfunc(sp.expand)
        states.append((x, k))
    expected = sp.Matrix([
        b + b*c*c*p*p*q*r + b*c*z*p*q*r,
        -b*c*(p*q+p*r+q*r),
        z + c*(p+q+r-b*b*p*q*r),
    ]).applyfunc(sp.expand)
    assert x == expected
    assert states[2][0] == sp.Matrix([b, -b*c*p*q, z+c*(p+q)]).applyfunc(sp.expand)
    assert all(position[0] == b for position, _ in states[:3])
    jacobian = x.jacobian([p, q, r])
    witness = {p: 1, q: 1, r: 2}
    expected_jacobian = sp.Matrix([
        [2*b*c*(2*c+z), 2*b*c*(c+z), b*c*(c+z)],
        [-3*b*c, -3*b*c, -2*b*c],
        [c*(1-2*b*b), c*(1-2*b*b), c*(1-b*b)],
    ])
    assert (jacobian.subs(witness)-expected_jacobian).applyfunc(sp.expand) == sp.zeros(3)
    assert sp.factor(jacobian.det().subs(witness)) == -2*b*b*c**4*(1+b*b)
    # Degenerate b=0: the position stays on the fixed kernel line.
    for position, axial in states:
        assert position.subs(b, 0)[0:2, 0] == sp.zeros(2, 1)
        assert axial.subs(b, 0) == sp.Matrix([0, 0, c])


def check_ode_boundary_identities():
    """Symbolic differential checks used in the nonclosed-Reach example.

    This verifies conserved quantities and the local Taylor derivative.
    It does not numerically approximate the ODE, prove existence/convergence,
    or replace the finite-versus-limiting reachability proof.
    """
    X = sp.Matrix(sp.symbols("x1:4", real=True))
    K = sp.Matrix(sp.symbols("k1:4", real=True))
    t = sp.Symbol("t", real=True)
    variables = list(X) + list(K)
    field = list(K) + list(X.cross(K))

    def lie(expression):
        return sp.expand(sum(sp.diff(expression, variable)*velocity
                             for variable, velocity in zip(variables, field)))

    assert lie(sq(K)) == 0
    assert sp.expand(lie((X.T*K)[0]) - sq(K)) == 0
    assert sp.expand(lie(sq(X)) - 2*(X.T*K)[0]) == 0
    U = X-t*K
    first = U.applyfunc(lambda expression: sp.expand(sp.diff(expression, t)+lie(expression)))
    second = first.applyfunc(lambda expression: sp.expand(sp.diff(expression, t)+lie(expression)))
    initial = dict(zip(variables, [1, 1, 0, 0, 0, 1]))
    initial[t] = 0
    assert first.subs(initial) == sp.zeros(3, 1)
    assert second.subs(initial) == sp.Matrix([-1, 1, 0])
    # Substitution of the ODE's proved scalar identities gives ||U(t)||^2=2.
    assert sp.expand((2+t*t)-2*t*t+t*t) == 2


def main():
    general = check_general_cases()
    launch = check_orthogonal_launch()
    schedule_counts = {}
    for d in range(9):
        schedule_counts[d] = (
            maximal_rank_history(d, False),
            maximal_rank_history(d, True),
        )
    check_examples()
    check_failure_modes()
    check_spectral_reduction()
    check_three_step_accessibility()
    check_general_three_dimensional_accessibility()
    check_ode_boundary_identities()
    print("PASS: exact kernel, rank, rho, reverse, balance, and exterior identities")
    print(f"PASS: {general} arbitrary rational state/input cases")
    print(f"PASS: {launch} orthogonal-launch states in dimensions 0 through 8")
    print("PASS: exact minimum rank-birth schedules (uncharged, charged):")
    print(schedule_counts)
    print("PASS: d=2 halt; d=3 hidden histories; scaled memory; sharp floor attainment")
    print("PASS: four common moves with distinct dormant invertible blocks")
    print("PASS: ungated cancellation, indefinite-metric failure, subdivision obstruction")
    print("PASS: reduced rank-one PSD spectral formulas in two canonical cases")
    print("PASS: symbolic three-step endpoint formula and Jacobian determinant -12")
    print("PASS: general 3D endpoint classification identities; determinant -2*b^2*c^4*(1+b^2)")
    print("PASS: symbolic ODE balances and boundary derivative u''(0)=(-1,1,0)")
    print("SCOPE: finite exact examples and stated symbolic identities only")
    print("PROOFS: Avenyra_Area_Feedback_v1.0.0.tex")


if __name__ == "__main__":
    main()