#!/usr/bin/env python3
"""Exact marginality certificate and signed precision frontier for real rational
polynomial matrices. Usage: python3 precision_frontier.py INPUT.json

Matrix entries may be rational numbers/strings or dictionaries mapping
nonnegative polynomial powers to rational coefficients. This implementation
uses only Python's standard library. It certifies the stated finite-dimensional
centered marginal regime before reporting a frontier.
"""
from fractions import Fraction as F
from pathlib import Path
import json
import sys
from verify_cancellation_frontier import eye, phi, ptrace, coeff


def parse_entry(value):
    if isinstance(value, dict):
        result = {}
        for exponent, coefficient in value.items():
            exponent = int(exponent)
            if exponent < 0:
                raise ValueError('Input entries must be polynomials, with nonnegative powers.')
            coefficient = F(coefficient)
            if coefficient:
                result[exponent] = result.get(exponent, F(0)) + coefficient
        return {k: v for k, v in result.items() if v}
    value = F(value)
    return {0: value} if value else {}


def analyze(data):
    raw = data['generators']
    if not raw:
        raise ValueError('At least one generator is required.')
    dimension = len(raw[0])
    if dimension < 1 or any(len(q) != dimension or any(len(row) != dimension for row in q) for q in raw):
        raise ValueError('Generators must be square matrices of one common positive dimension.')
    qs = [[[parse_entry(v) for v in row] for row in q] for q in raw]
    ps = [F(p) for p in data.get('probabilities', [F(1, len(qs))] * len(qs))]
    if len(ps) != len(qs) or any(p <= 0 for p in ps) or sum(ps) != 1:
        raise ValueError('Label probabilities must be positive and sum exactly to one.')
    cs = [eye(dimension)]
    for _ in range(dimension):
        cs.append(phi(cs[-1], qs, ps))
    certified = all(not entry for row in cs[-1] for entry in row)
    result = {'dimension': dimension, 'labels': len(qs), 'regime_certified': certified,
              'certificate': 'C_D(t) is identically zero' if certified else 'C_D(t) is not identically zero'}
    if not certified:
        result['status'] = 'Outside the centered marginal regime near t=0; no frontier asserted.'
        return result
    valuations, leading = [], []
    for c in cs[:-1]:
        trace = ptrace(c)
        order = min(trace) if trace else None
        if order is not None and order % 2:
            raise ArithmeticError('An exact sum of polynomial squares had odd leading order.')
        valuations.append(order // 2 if order is not None else None)
        if order is None:
            leading.append(None)
        else:
            leading.append([[str(entry.get(0, F(0))) for entry in row] for row in coeff(c, order)])
    h = max(k for k, v in enumerate(valuations) if v == 0)
    beta = min((F(2*v, k-h) for k, v in enumerate(valuations) if k > h and v is not None), default=None)
    result.update({'baseline_depth': h, 'word_valuations': valuations,
                   'beta': str(beta) if beta is not None else 'infinity',
                   'precision_power_N': str(1/beta) if beta is not None else None,
                   'leading_psd_matrices': leading,
                   'criterion': 'N*t^beta stays bounded' if beta is not None else 'Baseline bound holds at every horizon'})
    return result


def main():
    if len(sys.argv) != 2:
        raise SystemExit('Usage: python3 precision_frontier.py INPUT.json')
    try:
        result = analyze(json.loads(Path(sys.argv[1]).read_text()))
    except (ValueError, KeyError, TypeError, ZeroDivisionError) as exc:
        raise SystemExit(f'Invalid input: {exc}') from None
    print(json.dumps(result, indent=2))


if __name__ == '__main__':
    main()