Blame for code/verify_bridge.py

#!/usr/bin/env python3
"""Exact rational checks of the inverse-gauge measurement/reconstruction bridge.

Run: python3 code/verify_bridge.py

Matrix inversion and causal response checks are implemented independently of
calibration_core. The optional exact error-decoding integration uses the release
decoder, with the reference algebra checked separately here. These are finite
internal checks, not proof-assistant or external mathematical certification.
"""

from fractions import Fraction as F
from pathlib import Path
import argparse
import json

from calibration_core import decode_column, residual_spaces, jsonable


ROOT = Path(__file__).resolve().parents[1]
COUNTS = {"assertions": 0, "intervention_contexts": 0,
          "decoded_nonzero_space_columns": 0}


def require(condition, message):
    COUNTS["assertions"] += 1
    if not condition:
        raise AssertionError(message)


def mat(rows):
    return [[F(x) for x in row] for row in rows]


def zeros(n, m):
    return [[F(0) for _ in range(m)] for _ in range(n)]


def eye(n):
    return [[F(int(i == j)) for j in range(n)] for i in range(n)]


def add(A, B):
    if len(A) != len(B) or any(len(a) != len(b) for a, b in zip(A, B)):
        raise ValueError("addition dimension mismatch")
    return [[a+b for a, b in zip(x, y)] for x, y in zip(A, B)]


def neg(A):
    return [[-x for x in row] for row in A]


def sub(A, B):
    return add(A, neg(B))


def mul(A, B):
    if not A or not B or len(A[0]) != len(B):
        raise ValueError("multiplication dimension mismatch")
    if any(len(row) != len(A[0]) for row in A):
        raise ValueError("ragged left matrix")
    if any(len(row) != len(B[0]) for row in B):
        raise ValueError("ragged right matrix")
    return [[sum((A[i][k]*B[k][j] for k in range(len(B))), F(0))
             for j in range(len(B[0]))] for i in range(len(A))]


def inverse(A):
    """Independent Gauss-Jordan inversion over Fraction."""
    n = len(A)
    if any(len(row) != n for row in A):
        raise ValueError("inverse needs a square matrix")
    aug = [list(row)+ident for row, ident in zip(A, eye(n))]
    for col in range(n):
        pivot = next((i for i in range(col, n) if aug[i][col]), None)
        if pivot is None:
            raise ValueError("singular matrix")
        aug[col], aug[pivot] = aug[pivot], aug[col]
        scale = aug[col][col]
        aug[col] = [x/scale for x in aug[col]]
        for row in range(n):
            if row != col and aug[row][col]:
                scale = aug[row][col]
                aug[row] = [x-scale*y for x, y in zip(aug[row], aug[col])]
    return [row[n:] for row in aug]


def determinant(A):
    """Separate exact determinant for checking spanning intervention rows."""
    n = len(A)
    if any(len(row) != n for row in A):
        raise ValueError("determinant needs a square matrix")
    B = [list(row) for row in A]
    result = F(1)
    for c in range(n):
        p = next((i for i in range(c, n) if B[i][c]), None)
        if p is None:
            return F(0)
        if p != c:
            B[c], B[p] = B[p], B[c]
            result = -result
        v = B[c][c]
        result *= v
        for i in range(c+1, n):
            scale = B[i][c]/v
            for j in range(c+1, n):
                B[i][j] -= scale*B[c][j]
    return result


def row_support(A):
    return [i for i, row in enumerate(A) if any(row)]


def frobenius_squared(A):
    return sum((x*x for row in A for x in row), F(0))


def complete_reference(n):
    """Complete ordered DAG with all reference edge coefficients equal to one."""
    return [[F(1) if i == j else F(-1) if i > j else F(0)
             for j in range(n)] for i in range(n)]


def assert_complete_strict(B, name):
    n = len(B)
    require(all(B[i][i] == 1 for i in range(n)), name+": diagonal changed")
    require(all(B[i][j] == 0 for i in range(n) for j in range(i+1, n)),
            name+": forbidden graph entry appeared")
    require(all(B[i][j] != 0 for i in range(n) for j in range(i)),
            name+": required causal edge vanished")


def assert_pattern(A, n, name):
    require(all(A[i][j] == 0 for i in range(n) for j in range(i, n)),
            name+": not strictly lower triangular")


def test_model(n, N, F0, C, trusted=None):
    B0 = complete_reference(n)
    T0 = inverse(B0)
    U = add(eye(n), N)
    Uinv = inverse(U)
    Q = sub(Uinv, eye(n))
    Btrue = mul(B0, U)
    Ftrue = mul(F0, U)
    Ttrue = inverse(Btrue)
    A0 = mul(F0, T0)
    D = mul(C, Ttrue)
    Y = sub(mul(D, B0), C)
    N2 = mul(N, N)

    require(mul(U, Uinv) == eye(n), "independent inverse check failed")
    require(mul(Uinv, U) == eye(n), "independent inverse reverse check failed")
    require(mul(B0, T0) == eye(n), "reference inverse check failed")
    require(mul(Ftrue, Ttrue) == A0, "baseline aligned mixing not preserved")
    require(all(any(A0[i][k] for i in range(len(A0))) for k in range(n)),
            "aligned operator has an invisible innovation column")
    require(Y == mul(C, Q), "inverse-gauge linear observation identity failed")
    require(Y != mul(C, N), "example failed to reject forward-gauge substitution")
    require(Q != neg(N), "example has no nonzero higher-order inverse term")
    require(Y != mul(C, neg(N)), "measurement failed to expose quadratic inverse term")
    require(sub(inverse(add(eye(n), Q)), eye(n)) == N,
            "inverse-gauge involution failed")
    require(mul(B0, inverse(add(eye(n), Q))) == Btrue,
            "causal coefficient reconstruction failed")
    require(mul(F0, inverse(add(eye(n), Q))) == Ftrue,
            "observation-map reconstruction failed")
    assert_pattern(N, n, "N")
    assert_pattern(Q, n, "Q")
    assert_pattern(N2, n, "N squared")
    require(any(any(row) for row in N2), "quadratic witness is zero")
    assert_complete_strict(B0, "reference")
    assert_complete_strict(Btrue, "true")

    power = eye(n)
    polynomial_inverse = eye(n)
    for exponent in range(1, n):
        power = mul(power, N)
        polynomial_inverse = add(polynomial_inverse,
                                 power if exponent % 2 == 0 else neg(power))
    require(mul(power, N) == zeros(n, n), "nilpotence bound failed")
    require(polynomial_inverse == Uinv, "finite inverse polynomial failed")

    if trusted is not None:
        require(mul(trusted, N) == zeros(len(trusted), n), "M N nonzero")
        require(mul(trusted, Q) == zeros(len(trusted), n), "inverse lost trusted constraints")
        require(mul(trusted, N2) == zeros(len(trusted), n), "product lost trusted constraints")
        require(mul(trusted, U) == trusted, "trusted rows not fixed by forward gauge")
        require(mul(trusted, Uinv) == trusted, "trusted rows not fixed by inverse gauge")
        require(mul(trusted, T0) == mul(trusted, Ttrue),
                "trusted calibrated readout baseline responses differ")

    context_records = []
    for k in range(1, n):
        rows = [[F(t)**j/F(10) for j in range(k)] for t in range(1, k+1)]
        require(determinant(rows) != 0, "incoming intervention family not rich")
        for local in rows:
            delta0 = local+[F(0)]*(n-k)
            delta = mul([delta0], U)[0]
            require(all(delta[j] == 0 for j in range(k, n)),
                    "transported intervention left parent space")
            require(all(delta[j] != 0 for j in range(k)),
                    "transported dense incoming change lost strict support")
            original = [list(row) for row in B0]
            original[k] = [x-y for x, y in zip(original[k], delta0)]
            candidate = [list(row) for row in Btrue]
            candidate[k] = [x-y for x, y in zip(candidate[k], delta)]
            require(candidate == mul(original, U), "intervened gauge identity failed")
            assert_complete_strict(original, "reference intervention")
            assert_complete_strict(candidate, "true intervention")
            original_inverse = inverse(original)
            candidate_inverse = inverse(candidate)
            require(mul(F0, original_inverse) == mul(Ftrue, candidate_inverse),
                    "aligned intervention responses differ")
            require(mul([delta0], inverse(add(eye(n), Q)))[0] == delta,
                    "control reconstructed from Q differs")
            if trusted is not None:
                require(mul(trusted, original_inverse) == mul(trusted, candidate_inverse),
                        "trusted readout intervention responses differ")
            COUNTS["intervention_contexts"] += 1
            context_records.append({"target": k, "reference_change": delta0,
                                    "true_change": delta, "response_equality": True})

    return {"vertices": n, "baseline_B0": B0, "reference_F0": F0,
            "aligned_A0": A0, "forward_N": N, "N_squared": N2,
            "inverse_Q": Q, "true_B": Btrue, "true_F": Ftrue,
            "new_C": C, "aligned_new_D": D, "observed_Y": Y,
            "trusted_M": trusted, "interventions": context_records}


def three_node_example():
    a, b, c = F(1, 10), F(1, 7), F(1, 9)
    N = mat([[0, 0, 0], [a, 0, 0], [b, c, 0]])
    record = test_model(3, N, mat([[1, 2, 3]]), mat([[1, 2, 3], [2, 1, 4]]))
    Q = record["inverse_Q"]
    require(Q == mat([[0, 0, 0], [-a, 0, 0], [-b+c*a, -c, 0]]),
            "three-node explicit inverse formula failed")
    require(-Q[2][0]+Q[2][1]*Q[1][0] == b,
            "three-node quadratic parameter recovery failed")
    require(-Q[2][0] != b, "first-order-only reconstruction unexpectedly exact")
    record["quadratic_correction"] = c*a
    record["first_order_b_estimate"] = -Q[2][0]
    record["exact_b"] = b
    return record


def four_node_trusted_example():
    a, b, c = F(1, 20), F(1, 30), F(1, 40)
    N = mat([[0, 0, 0, 0], [a, 0, 0, 0],
             [b, c, 0, 0], [-a-b, -c, 0, 0]])
    M = mat([[1, 1, 1, 1]])
    C = [[F(t)**j for j in range(4)] for t in range(2, 7)]
    record = test_model(4, N, mat([[1, 2, 3, 4], [2, -1, 1, 1]]), C, M)
    B0, D, Q = record["baseline_B0"], record["aligned_new_D"], record["inverse_Q"]
    T0 = inverse(B0)
    H = zeros(5, 4)
    H[1] = [F(3, 7), F(-2, 5), F(1, 11), F(4, 9)]
    W = mat([[F(1, 1000), F(-1, 900), 0, F(1, 700)],
             [0, 0, 0, 0],
             [F(-1, 1100), 0, F(1, 1300), 0],
             [0, F(1, 1400), F(-1, 1500), F(1, 1600)],
             [0, 0, 0, 0]])
    transformed_H, transformed_W = mul(H, B0), mul(W, B0)
    Ytilde = sub(mul(add(add(D, H), W), B0), C)
    require(Ytilde == add(add(mul(C, Q), transformed_H), transformed_W),
            "corrupted/noisy mixing-to-discrepancy identity failed")
    require(row_support(transformed_H) == row_support(H) == [1],
            "invertible right multiplication changed attack row support")
    require(row_support(transformed_W) == row_support(W),
            "invertible right multiplication changed noise row support")
    require(mul(transformed_H, T0) == H, "attack pullback identity failed")
    require(mul(transformed_W, T0) == W, "noise pullback identity failed")
    noise_sq = frobenius_squared(W)
    transformed_sq = frobenius_squared(transformed_W)
    conservative_upper_sq = noise_sq*frobenius_squared(B0)
    require(transformed_sq <= conservative_upper_sq,
            "conservative exact Frobenius amplification bound failed")

    edges = [(i, j) for i in range(4) for j in range(i+1, 4)]
    supports, spaces = residual_spaces(4, edges, M)
    require(list(map(len, spaces)) == [2, 1, 0, 0],
            "trusted residual dimensions differ from independent expectation")
    require(supports == [[1, 2, 3], [2, 3], [3], []],
            "complete-four surrounded pattern differs")
    exact_corrupted = sub(mul(add(D, H), B0), C)
    erased = (4,)
    decoded = zeros(4, 4)
    for j, E in enumerate(spaces):
        if E:
            observations = [exact_corrupted[a][j] if a not in erased else None
                            for a in range(5)]
            value = decode_column(E, C, observations, erased=erased, max_errors=1)
            require(value == [Q[i][j] for i in range(4)],
                    "operator-bridge sparse-error decode failed")
            for i in range(4):
                decoded[i][j] = value[i]
            COUNTS["decoded_nonzero_space_columns"] += 1
        else:
            require(all(Q[i][j] == 0 for i in range(4)),
                    "known-zero ambiguity column is not zero")
    require(decoded == Q, "decoded full inverse gauge differs from truth")
    require(mul(B0, inverse(add(eye(4), decoded))) == record["true_B"],
            "decoded causal coefficient reconstruction failed")
    residual = sub(exact_corrupted, mul(C, decoded))
    require([a for a in row_support(residual) if a not in erased] == [1],
            "decoded explanation lacks the stipulated shared error support")
    record["row_fault_mapping"] = {
        "attack_in_D": H, "attack_in_Y": transformed_H,
        "bounded_noise_in_D": W, "bounded_noise_in_Y": transformed_W,
        "attack_rows_before_and_after": [1],
        "noise_rows_before_and_after": row_support(W),
        "noise_frobenius_squared": noise_sq,
        "transformed_noise_frobenius_squared": transformed_sq,
        "conservative_upper_squared_using_B0_Frobenius": conservative_upper_sq,
        "note": "This exact rational inequality uses ||B0||_F as a conservative upper bound on ||B0||_op."
    }
    record["exact_decode"] = {
        "erasures": list(erased), "corrupted_rows": [1],
        "bounded_noise_for_this_decode": 0,
        "residual_dimensions": list(map(len, spaces)),
        "decoded_Q": decoded,
        "causal_reconstruction_exact": True
    }
    return record


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--output", type=Path, default=ROOT / "results" / "bridge_results.json")
    args = parser.parse_args()
    report = {"status": "passed", "arithmetic": "fractions.Fraction",
              "scope": "finite internal exact checks; no external or proof-assistant certification",
              "three_node_quadratic": three_node_example(),
              "complete_four_trusted": four_node_trusted_example()}
    report["counts"] = dict(COUNTS)
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(json.dumps(jsonable(report), indent=2)+"\n")
    print(json.dumps({"status": "passed", **COUNTS, "output": str(args.output)}, indent=2))


if __name__ == "__main__":
    main()