Datasets:
Tasks:
Other
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
research-artifact
gapped-lie-algebroids
stochastic-stability
completely-positive-maps
matrix-perturbation
| #!/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() | |