Datasets:

PureOne
/

EVE-AITHRAEL-Robust-Causal-Calibration

#!/usr/bin/env python3
"""Exact adversarial regression suite for the calibration release.
Uses only Python's standard library. Exhaustive assertions concern the finite
families explicitly enumerated here; they do not replace the general proofs.
Run from any working directory: python3 code/verify_robust.py
"""
from fractions import Fraction as F
from itertools import product, combinations
from pathlib import Path
import argparse
import json
import time

from calibration_core import (
    rank, null_basis, restrict_rows, residual_spaces, generic_profile,
    numerical_profile, numerical_table, common_generic_design,
    dense_completion, decode_column, dot, linear_combination, jsonable,
)
from plan_robust_calibration import plan

ROOT = Path(__file__).resolve().parents[1]


def require(condition, message):
    if not condition:
        raise AssertionError(message)


def expect_value_error(thunk, message):
    try:
        thunk()
    except ValueError as exc:
        return str(exc)
    raise AssertionError(message)


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


def reference_rank_2(rows):
    """Independent rank oracle in R^2: no elimination or core rank routine."""
    nonzero = [row for row in rows if row[0] or row[1]]
    if not nonzero:
        return 0
    first = nonzero[0]
    if any(first[0]*v[1] != first[1]*v[0] for v in nonzero[1:]):
        return 2
    return 1


def reference_profile_from_ranks(ranks, dimension, m):
    return [min(m-mask.bit_count() for mask, value in enumerate(ranks)
                if value <= dimension-k) for k in range(1, dimension+1)]


def test_architecture_exhaustion():
    e1, e2, ep, em = [F(1), F(0)], [F(0), F(1)], [F(1), F(1)], [F(1), F(-1)]
    E = [e1, e2]
    names = ["zero", "e1", "e2", "e1_plus_e2", "e1_minus_e2", "full_R2"]
    allowed = [[], [e1], [e2], [ep], [em], [e1, e2]]
    choices = [[[F(0), F(0)]], [e1], [e2], [ep], [em], [e1, e2, ep, em]]
    # Extra scalar spaces force the common design to satisfy several different
    # restrictions, not just all subsets of one two-dimensional restriction.
    family = [E, [e1], [e2], [ep], [em]]
    records = []
    assignments = 0
    exact_subset_checks = 0
    attaining_assignments = 0
    common_rank_checks = 0
    max_search_attempts = 0
    for arch_number, architecture in enumerate(product(range(6), repeat=3)):
        Hs = [allowed[a] for a in architecture]
        theory = generic_profile(E, Hs)
        best_ranks = [0]*8
        best_profile = [0, 0]
        jointly_attaining = []
        n_assign = 0
        for rows in product(*(choices[a] for a in architecture)):
            C = [list(row) for row in rows]
            rr = [reference_rank_2([C[a] for a in range(3) if mask & (1 << a)])
                  for mask in range(8)]
            direct = reference_profile_from_ranks(rr, 2, 3)
            got = numerical_profile(E, C)
            require(got["ranks"] == rr, "numerical ranks differ from determinant oracle")
            require(got["profile"] == direct, "numerical profile differs from deletion oracle")
            require(all(a <= b for a, b in zip(rr, theory["generic_ranks"])),
                    "assignment exceeds claimed generic rank")
            require(all(a <= b for a, b in zip(direct, theory["profile"])),
                    "assignment exceeds claimed profile optimum")
            best_ranks = [max(a, b) for a, b in zip(best_ranks, rr)]
            best_profile = [max(a, b) for a, b in zip(best_profile, direct)]
            if rr == theory["generic_ranks"]:
                require(direct == theory["profile"], "attaining ranks fail profile optimum")
                jointly_attaining.append(C)
            n_assign += 1
            assignments += 1
            exact_subset_checks += 8
        require(best_ranks == theory["generic_ranks"], "finite rank maximum does not attain Rado")
        require(best_profile == theory["profile"], "finite profile maximum does not attain cut")
        require(bool(jointly_attaining), "no assignment jointly attains every subset rank")
        attaining_assignments += len(jointly_attaining)
        selected = common_generic_design(family, Hs, seed=13371337+arch_number,
                                         max_attempts=2000)
        require(selected["status"] == "certified", "common search failed on small exhaustive family")
        max_search_attempts = max(max_search_attempts, selected["attempts"])
        for space in family:
            expected = generic_profile(space, Hs)
            actual = numerical_profile(space, selected["rows"])
            require(actual["ranks"] == expected["generic_ranks"],
                    "common design fails a second subspace's rank profile")
            require(actual["profile"] == expected["profile"],
                    "common design fails a second subspace's deletion profile")
            common_rank_checks += 8
        records.append({"architecture": [names[a] for a in architecture],
                        "candidate_assignments": n_assign,
                        "simultaneous_attainers": len(jointly_attaining),
                        "generic_ranks": theory["generic_ranks"],
                        "generic_profile": theory["profile"],
                        "attaining_matrix": jointly_attaining[0],
                        "common_five_space_matrix": selected["rows"],
                        "common_search_attempts": selected["attempts"]})
    require(len(records) == 216, "wrong architecture count")
    require(assignments == 729, "wrong total finite assignment count")
    return {"status": "passed", "architectures": len(records),
            "finite_assignments": assignments,
            "independent_subset_rank_checks": exact_subset_checks,
            "assignments_attaining_all_subset_ranks": attaining_assignments,
            "common_five_space_designs": len(records),
            "common_design_subset_rank_checks": common_rank_checks,
            "largest_common_search_attempt_count": max_search_attempts,
            "records": records}


def dense_spec(n, r):
    return {"n": n, "edges": [[i, j] for i in range(n) for j in range(i+1, n)],
            "trusted_rows": [], "sensor_spaces": [identity(n) for _ in range(r)],
            "erasures": 1, "errors": 1, "seed": 13371337}


def test_dense_faults():
    spec = dense_spec(4, 6)
    supports, spaces = residual_spaces(4, spec["edges"], [])
    require(list(map(len, spaces)) == [3, 2, 1, 0], "complete-DAG dimensions wrong")
    C, search = dense_completion(spaces, 6)
    profiles = [numerical_profile(E, C) for E in spaces]
    require([p["profile"] for p in profiles] == [[4, 5, 6], [5, 6], [6], []],
            "dense MDS deletion profile wrong")
    coeffs = [[F(1, 3), F(-2), F(5, 7)], [F(2), F(-1, 2)], [F(-3, 5)]]
    vectors = [linear_combination(z, E, 4) for z, E in zip(coeffs, spaces)]
    errors = [F(-7, 3), F(1), F(5, 2)]
    scenarios = 0
    decodes = 0
    for erased in [()] + [(a,) for a in range(6)]:
        available = [a for a in range(6) if a not in erased]
        corruptions = [(None, F(0))] + [(a, value) for a in available for value in errors]
        for bad, value in corruptions:
            scenarios += 1
            for j, (E, vector) in enumerate(zip(spaces, vectors)):
                y = [dot(row, vector) for row in C]
                if bad is not None:
                    y[bad] += (j+1)*value
                for a in erased:
                    y[a] = None
                decoded = decode_column(E, C, y, erased=erased, max_errors=1)
                require(decoded == vector, "dense erased/corrupted recovery failed")
                decodes += 1
    require(scenarios == 115 and decodes == 345, "wrong dense fault test count")
    # The data at one fewer channel have two exact explanations under the same
    # erasure/error budgets. This checks the lower bound, not only success.
    C5, _ = dense_completion(spaces, 5)
    cert5 = numerical_profile(spaces[0], C5)
    require(cert5["distance"] == 3, "below-threshold distance should be three")
    witness = cert5["witnesses"][0]
    vector = witness["surviving_kernel_basis"][0]
    encoded = [dot(row, vector) for row in C5]
    support = [a for a, value in enumerate(encoded) if value]
    require(len(support) == 3, "lower-bound witness is not minimum support")
    erased, bad0, bad1 = support
    y = [F(0)]*5
    y[bad0] = encoded[bad0]
    y[erased] = None
    require(sum(y[a] != 0 for a in range(5) if a != erased) == 1,
            "zero model needs more than one error")
    require(sum(y[a] != encoded[a] for a in range(5) if a != erased) == 1,
            "alternative model needs more than one error")
    reject = expect_value_error(
        lambda: decode_column(spaces[0], C5, y, erased=(erased,), max_errors=1),
        "decoder accepted nonunique below-threshold data")
    return {"status": "passed", "residual_dimensions": list(map(len, spaces)),
            "six_channel_matrix": C, "construction_steps": search,
            "profiles": [p["profile"] for p in profiles],
            "tested_error_amplitudes": errors, "fault_scenarios": scenarios,
            "successful_column_decodes": decodes,
            "below_threshold": {"channels": 5, "matrix": C5,
                                "distance": 3, "alternative_vector": vector,
                                "encoded_difference": encoded,
                                "erased": [erased], "attack_for_zero": [bad0],
                                "attack_for_alternative": [bad1], "common_data": y,
                                "decoder_rejection": reject}}


def spark_exact(A):
    """Enumerate dependent column sets; n+1 denotes full column rank."""
    n = len(A[0]) if A else 0
    for size in range(1, n+1):
        for S in combinations(range(n), size):
            sub = [[row[a] for a in S] for row in A]
            if rank(sub, size) < size:
                local = null_basis(sub, size)[0]
                vector = [F(0)]*n
                for a, value in zip(S, local):
                    vector[a] = value
                require(any(vector), "zero spark witness")
                require(all(dot(row, vector) == 0 for row in A), "invalid spark witness")
                return size, vector
    return n+1, None


def star_spec(A, erasures=0, errors=0):
    leaves = len(A[0])
    n = leaves+1
    return {"n": n, "edges": [[0, i] for i in range(1, n)],
            "trusted_rows": [[F(0)]+list(row) for row in A],
            "sensor_spaces": [[[F(0)]+row] for row in identity(leaves)],
            "erasures": erasures, "errors": errors, "seed": 13371337}


def star_report(A):
    spec = star_spec(A)
    supports, spaces = residual_spaces(spec["n"], spec["edges"], spec["trusted_rows"])
    C = [H[0] for H in spec["sensor_spaces"]]
    require(all(not E for E in spaces[1:]), "star has unexpected non-root ambiguity")
    actual = numerical_profile(spaces[0], C)
    spark, witness = spark_exact(A)
    require(actual["distance"] == spark, "causal star distance differs from spark")
    require(generic_profile(spaces[0], spec["sensor_spaces"])["profile"] == actual["profile"],
            "fixed coordinate architecture profile mismatch")
    return {"parity_matrix": A, "spark": spark, "spark_witness": witness,
            "causal_vertices": spec["n"], "residual_dimension": len(spaces[0]),
            "causal_distance": actual["distance"], "profile": actual["profile"]}


def test_stars_and_coefficients():
    A = [[F(1), F(0), F(1), F(1)], [F(0), F(1), F(1), F(-1)]]
    n = 4
    dup = [row+[F(0)]*n for row in A]
    dup += [row+[-x for x in row] for row in identity(n)]
    first, second = star_report(A), star_report(dup)
    require(first["spark"] == 3 and second["spark"] == 6, "spark doubling wrong")
    require(first["profile"] == [3, 4] and second["profile"] == [6, 8],
            "duplicated generalized weights wrong")
    original_kernel = null_basis(A, 4)
    expected_dup = [v+v for v in original_kernel]
    duplicate_kernel = null_basis(dup, 8)
    require(rank(expected_dup+duplicate_kernel, 8) == len(original_kernel),
            "duplicated parity kernel is not diagonal copy of original")
    generic = [[F(1)]*4, [F(1), F(2), F(3), F(4)]]
    exceptional = [[F(1)]*4, [F(1), F(1), F(3), F(4)]]
    require([[bool(x) for x in row] for row in generic] ==
            [[bool(x) for x in row] for row in exceptional], "patterns differ")
    third, fourth = star_report(generic), star_report(exceptional)
    require(third["causal_distance"] == 3 and fourth["causal_distance"] == 2,
            "same-pattern exceptional cancellation was not detected")
    return {"status": "passed", "spark_three": first, "duplicated_spark_six": second,
            "same_pattern_generic": third, "same_pattern_exceptional": fourth}


def test_decoder_regression():
    E = identity(2)
    C = identity(2)
    # Before the fix, the zero-error branch supplied zero and all one-error
    # branches were silently skipped for lack of rank. The decoder returned
    # zero despite whole affine families of other feasible explanations.
    message = expect_value_error(
        lambda: decode_column(E, C, [0, 0], max_errors=1),
        "rank-deficient feasible families must cause non-identifiability")
    require("non-identifiable feasible family" in message,
            "regression did not exercise the rank-deficient-family branch")
    require(decode_column(E, C, [F(3, 2), F(-7, 4)], max_errors=0) == [F(3, 2), F(-7, 4)],
            "ordinary exact decoding was broken")
    messages = {
        "negative_error_budget": expect_value_error(
            lambda: decode_column(E, C, [0, 0], max_errors=-1), "negative errors accepted"),
        "wrong_observation_length": expect_value_error(
            lambda: decode_column(E, C, [0]), "wrong observation count accepted"),
        "erasure_out_of_range": expect_value_error(
            lambda: decode_column(E, C, [0, 0], erased=(2,)), "invalid erasure accepted"),
    }
    return {"status": "passed", "nonidentifiability_regression": message,
            "input_validation": messages, "checks": 5}


def write_examples():
    folder = ROOT / "examples"
    folder.mkdir(exist_ok=True)
    A = [[F(1), F(0), F(1), F(1)], [F(0), F(1), F(1), F(-1)]]
    dup = [row+[F(0)]*4 for row in A]
    dup += [row+[-x for x in row] for row in identity(4)]
    specs = {
        "dense_complete_four": dense_spec(4, 6),
        "dense_complete_four_below_threshold": dense_spec(4, 5),
        "star_spark_three": star_spec(A, errors=1),
        "star_spark_six": star_spec(dup, erasures=1, errors=2),
        "same_pattern_generic": star_spec([[F(1)]*4, [F(1), F(2), F(3), F(4)]], errors=1),
        "same_pattern_exceptional": star_spec([[F(1)]*4, [F(1), F(1), F(3), F(4)]], errors=1),
    }
    reports = []
    expected = [True, False, True, True, True, False]
    for (name, spec), should_work in zip(specs.items(), expected):
        (folder / (name+".json")).write_text(json.dumps(jsonable(spec), indent=2)+"\n")
        certificate = plan(jsonable(spec))
        require(certificate["requested_tolerance_possible"] is should_work,
                "planner returns wrong feasibility on "+name)
        require(certificate["design"]["status"] == "certified", "planner design search failed")
        (folder / (name+"_certificate.json")).write_text(json.dumps(certificate, indent=2)+"\n")
        reports.append({"input": name+".json", "certificate": name+"_certificate.json",
                        "requested_tolerance_possible": should_work,
                        "optimal_distance": certificate["optimal_architecture_distance"]})
    return reports


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--output", type=Path, default=ROOT / "results" / "robust_results.json")
    args = parser.parse_args()
    started = time.monotonic()
    result = {"status": "passed", "arithmetic": "fractions.Fraction; exact rational checks",
              "seed": 13371337,
              "scope": "finite exhaustive regression and witness checks, not formal proof-assistant certification",
              "architecture_exhaustion": test_architecture_exhaustion(),
              "dense_fault_recovery": test_dense_faults(),
              "causal_stars": test_stars_and_coefficients(),
              "decoder_regression": test_decoder_regression(),
              "planner_examples": write_examples()}
    result["elapsed_seconds"] = round(time.monotonic()-started, 3)
    args.output.parent.mkdir(exist_ok=True, parents=True)
    args.output.write_text(json.dumps(jsonable(result), indent=2)+"\n")
    summary = {"status": result["status"], "architectures": 216, "candidate_assignments": 729,
               "independent_subset_rank_checks": result["architecture_exhaustion"]["independent_subset_rank_checks"],
               "common_design_subset_rank_checks": result["architecture_exhaustion"]["common_design_subset_rank_checks"],
               "fault_scenarios": result["dense_fault_recovery"]["fault_scenarios"],
               "successful_column_decodes": result["dense_fault_recovery"]["successful_column_decodes"],
               "planner_examples": len(result["planner_examples"]),
               "elapsed_seconds": result["elapsed_seconds"], "output": str(args.output)}
    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Exact adversarial regression suite for the calibration release.

	Uses only Python's standard library. Exhaustive assertions concern the finite
	families explicitly enumerated here; they do not replace the general proofs.
	Run from any working directory: python3 code/verify_robust.py
	"""
	from fractions import Fraction as F
	from itertools import product, combinations
	from pathlib import Path
	import argparse
	import json
	import time

	from calibration_core import (
	rank, null_basis, restrict_rows, residual_spaces, generic_profile,
	numerical_profile, numerical_table, common_generic_design,
	dense_completion, decode_column, dot, linear_combination, jsonable,
	)
	from plan_robust_calibration import plan

	ROOT = Path(__file__).resolve().parents[1]


	def require(condition, message):
	if not condition:
	raise AssertionError(message)


	def expect_value_error(thunk, message):
	try:
	thunk()
	except ValueError as exc:
	return str(exc)
	raise AssertionError(message)


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


	def reference_rank_2(rows):
	"""Independent rank oracle in R^2: no elimination or core rank routine."""
	nonzero = [row for row in rows if row[0] or row[1]]
	if not nonzero:
	return 0
	first = nonzero[0]
	if any(first[0]v[1] != first[1]v[0] for v in nonzero[1:]):
	return 2
	return 1


	def reference_profile_from_ranks(ranks, dimension, m):
	return [min(m-mask.bit_count() for mask, value in enumerate(ranks)
	if value <= dimension-k) for k in range(1, dimension+1)]


	def test_architecture_exhaustion():
	e1, e2, ep, em = [F(1), F(0)], [F(0), F(1)], [F(1), F(1)], [F(1), F(-1)]
	E = [e1, e2]
	names = ["zero", "e1", "e2", "e1_plus_e2", "e1_minus_e2", "full_R2"]
	allowed = [[], [e1], [e2], [ep], [em], [e1, e2]]
	choices = [[[F(0), F(0)]], [e1], [e2], [ep], [em], [e1, e2, ep, em]]
	# Extra scalar spaces force the common design to satisfy several different
	# restrictions, not just all subsets of one two-dimensional restriction.
	family = [E, [e1], [e2], [ep], [em]]
	records = []
	assignments = 0
	exact_subset_checks = 0
	attaining_assignments = 0
	common_rank_checks = 0
	max_search_attempts = 0
	for arch_number, architecture in enumerate(product(range(6), repeat=3)):
	Hs = [allowed[a] for a in architecture]
	theory = generic_profile(E, Hs)
	best_ranks = [0]*8
	best_profile = [0, 0]
	jointly_attaining = []
	n_assign = 0
	for rows in product(*(choices[a] for a in architecture)):
	C = [list(row) for row in rows]
	rr = [reference_rank_2([C[a] for a in range(3) if mask & (1 << a)])
	for mask in range(8)]
	direct = reference_profile_from_ranks(rr, 2, 3)
	got = numerical_profile(E, C)
	require(got["ranks"] == rr, "numerical ranks differ from determinant oracle")
	require(got["profile"] == direct, "numerical profile differs from deletion oracle")
	require(all(a <= b for a, b in zip(rr, theory["generic_ranks"])),
	"assignment exceeds claimed generic rank")
	require(all(a <= b for a, b in zip(direct, theory["profile"])),
	"assignment exceeds claimed profile optimum")
	best_ranks = [max(a, b) for a, b in zip(best_ranks, rr)]
	best_profile = [max(a, b) for a, b in zip(best_profile, direct)]
	if rr == theory["generic_ranks"]:
	require(direct == theory["profile"], "attaining ranks fail profile optimum")
	jointly_attaining.append(C)
	n_assign += 1
	assignments += 1
	exact_subset_checks += 8
	require(best_ranks == theory["generic_ranks"], "finite rank maximum does not attain Rado")
	require(best_profile == theory["profile"], "finite profile maximum does not attain cut")
	require(bool(jointly_attaining), "no assignment jointly attains every subset rank")
	attaining_assignments += len(jointly_attaining)
	selected = common_generic_design(family, Hs, seed=13371337+arch_number,
	max_attempts=2000)
	require(selected["status"] == "certified", "common search failed on small exhaustive family")
	max_search_attempts = max(max_search_attempts, selected["attempts"])
	for space in family:
	expected = generic_profile(space, Hs)
	actual = numerical_profile(space, selected["rows"])
	require(actual["ranks"] == expected["generic_ranks"],
	"common design fails a second subspace's rank profile")
	require(actual["profile"] == expected["profile"],
	"common design fails a second subspace's deletion profile")
	common_rank_checks += 8
	records.append({"architecture": [names[a] for a in architecture],
	"candidate_assignments": n_assign,
	"simultaneous_attainers": len(jointly_attaining),
	"generic_ranks": theory["generic_ranks"],
	"generic_profile": theory["profile"],
	"attaining_matrix": jointly_attaining[0],
	"common_five_space_matrix": selected["rows"],
	"common_search_attempts": selected["attempts"]})
	require(len(records) == 216, "wrong architecture count")
	require(assignments == 729, "wrong total finite assignment count")
	return {"status": "passed", "architectures": len(records),
	"finite_assignments": assignments,
	"independent_subset_rank_checks": exact_subset_checks,
	"assignments_attaining_all_subset_ranks": attaining_assignments,
	"common_five_space_designs": len(records),
	"common_design_subset_rank_checks": common_rank_checks,
	"largest_common_search_attempt_count": max_search_attempts,
	"records": records}


	def dense_spec(n, r):
	return {"n": n, "edges": [[i, j] for i in range(n) for j in range(i+1, n)],
	"trusted_rows": [], "sensor_spaces": [identity(n) for _ in range(r)],
	"erasures": 1, "errors": 1, "seed": 13371337}


	def test_dense_faults():
	spec = dense_spec(4, 6)
	supports, spaces = residual_spaces(4, spec["edges"], [])
	require(list(map(len, spaces)) == [3, 2, 1, 0], "complete-DAG dimensions wrong")
	C, search = dense_completion(spaces, 6)
	profiles = [numerical_profile(E, C) for E in spaces]
	require([p["profile"] for p in profiles] == [[4, 5, 6], [5, 6], [6], []],
	"dense MDS deletion profile wrong")
	coeffs = [[F(1, 3), F(-2), F(5, 7)], [F(2), F(-1, 2)], [F(-3, 5)]]
	vectors = [linear_combination(z, E, 4) for z, E in zip(coeffs, spaces)]
	errors = [F(-7, 3), F(1), F(5, 2)]
	scenarios = 0
	decodes = 0
	for erased in [()] + [(a,) for a in range(6)]:
	available = [a for a in range(6) if a not in erased]
	corruptions = [(None, F(0))] + [(a, value) for a in available for value in errors]
	for bad, value in corruptions:
	scenarios += 1
	for j, (E, vector) in enumerate(zip(spaces, vectors)):
	y = [dot(row, vector) for row in C]
	if bad is not None:
	y[bad] += (j+1)*value
	for a in erased:
	y[a] = None
	decoded = decode_column(E, C, y, erased=erased, max_errors=1)
	require(decoded == vector, "dense erased/corrupted recovery failed")
	decodes += 1
	require(scenarios == 115 and decodes == 345, "wrong dense fault test count")
	# The data at one fewer channel have two exact explanations under the same
	# erasure/error budgets. This checks the lower bound, not only success.
	C5, _ = dense_completion(spaces, 5)
	cert5 = numerical_profile(spaces[0], C5)
	require(cert5["distance"] == 3, "below-threshold distance should be three")
	witness = cert5["witnesses"][0]
	vector = witness["surviving_kernel_basis"][0]
	encoded = [dot(row, vector) for row in C5]
	support = [a for a, value in enumerate(encoded) if value]
	require(len(support) == 3, "lower-bound witness is not minimum support")
	erased, bad0, bad1 = support
	y = [F(0)]*5
	y[bad0] = encoded[bad0]
	y[erased] = None
	require(sum(y[a] != 0 for a in range(5) if a != erased) == 1,
	"zero model needs more than one error")
	require(sum(y[a] != encoded[a] for a in range(5) if a != erased) == 1,
	"alternative model needs more than one error")
	reject = expect_value_error(
	lambda: decode_column(spaces[0], C5, y, erased=(erased,), max_errors=1),
	"decoder accepted nonunique below-threshold data")
	return {"status": "passed", "residual_dimensions": list(map(len, spaces)),
	"six_channel_matrix": C, "construction_steps": search,
	"profiles": [p["profile"] for p in profiles],
	"tested_error_amplitudes": errors, "fault_scenarios": scenarios,
	"successful_column_decodes": decodes,
	"below_threshold": {"channels": 5, "matrix": C5,
	"distance": 3, "alternative_vector": vector,
	"encoded_difference": encoded,
	"erased": [erased], "attack_for_zero": [bad0],
	"attack_for_alternative": [bad1], "common_data": y,
	"decoder_rejection": reject}}


	def spark_exact(A):
	"""Enumerate dependent column sets; n+1 denotes full column rank."""
	n = len(A[0]) if A else 0
	for size in range(1, n+1):
	for S in combinations(range(n), size):
	sub = [[row[a] for a in S] for row in A]
	if rank(sub, size) < size:
	local = null_basis(sub, size)[0]
	vector = [F(0)]*n
	for a, value in zip(S, local):
	vector[a] = value
	require(any(vector), "zero spark witness")
	require(all(dot(row, vector) == 0 for row in A), "invalid spark witness")
	return size, vector
	return n+1, None


	def star_spec(A, erasures=0, errors=0):
	leaves = len(A[0])
	n = leaves+1
	return {"n": n, "edges": [[0, i] for i in range(1, n)],
	"trusted_rows": [[F(0)]+list(row) for row in A],
	"sensor_spaces": [[[F(0)]+row] for row in identity(leaves)],
	"erasures": erasures, "errors": errors, "seed": 13371337}


	def star_report(A):
	spec = star_spec(A)
	supports, spaces = residual_spaces(spec["n"], spec["edges"], spec["trusted_rows"])
	C = [H[0] for H in spec["sensor_spaces"]]
	require(all(not E for E in spaces[1:]), "star has unexpected non-root ambiguity")
	actual = numerical_profile(spaces[0], C)
	spark, witness = spark_exact(A)
	require(actual["distance"] == spark, "causal star distance differs from spark")
	require(generic_profile(spaces[0], spec["sensor_spaces"])["profile"] == actual["profile"],
	"fixed coordinate architecture profile mismatch")
	return {"parity_matrix": A, "spark": spark, "spark_witness": witness,
	"causal_vertices": spec["n"], "residual_dimension": len(spaces[0]),
	"causal_distance": actual["distance"], "profile": actual["profile"]}


	def test_stars_and_coefficients():
	A = [[F(1), F(0), F(1), F(1)], [F(0), F(1), F(1), F(-1)]]
	n = 4
	dup = [row+[F(0)]*n for row in A]
	dup += [row+[-x for x in row] for row in identity(n)]
	first, second = star_report(A), star_report(dup)
	require(first["spark"] == 3 and second["spark"] == 6, "spark doubling wrong")
	require(first["profile"] == [3, 4] and second["profile"] == [6, 8],
	"duplicated generalized weights wrong")
	original_kernel = null_basis(A, 4)
	expected_dup = [v+v for v in original_kernel]
	duplicate_kernel = null_basis(dup, 8)
	require(rank(expected_dup+duplicate_kernel, 8) == len(original_kernel),
	"duplicated parity kernel is not diagonal copy of original")
	generic = [[F(1)]*4, [F(1), F(2), F(3), F(4)]]
	exceptional = [[F(1)]*4, [F(1), F(1), F(3), F(4)]]
	require([[bool(x) for x in row] for row in generic] ==
	[[bool(x) for x in row] for row in exceptional], "patterns differ")
	third, fourth = star_report(generic), star_report(exceptional)
	require(third["causal_distance"] == 3 and fourth["causal_distance"] == 2,
	"same-pattern exceptional cancellation was not detected")
	return {"status": "passed", "spark_three": first, "duplicated_spark_six": second,
	"same_pattern_generic": third, "same_pattern_exceptional": fourth}


	def test_decoder_regression():
	E = identity(2)
	C = identity(2)
	# Before the fix, the zero-error branch supplied zero and all one-error
	# branches were silently skipped for lack of rank. The decoder returned
	# zero despite whole affine families of other feasible explanations.
	message = expect_value_error(
	lambda: decode_column(E, C, [0, 0], max_errors=1),
	"rank-deficient feasible families must cause non-identifiability")
	require("non-identifiable feasible family" in message,
	"regression did not exercise the rank-deficient-family branch")
	require(decode_column(E, C, [F(3, 2), F(-7, 4)], max_errors=0) == [F(3, 2), F(-7, 4)],
	"ordinary exact decoding was broken")
	messages = {
	"negative_error_budget": expect_value_error(
	lambda: decode_column(E, C, [0, 0], max_errors=-1), "negative errors accepted"),
	"wrong_observation_length": expect_value_error(
	lambda: decode_column(E, C, [0]), "wrong observation count accepted"),
	"erasure_out_of_range": expect_value_error(
	lambda: decode_column(E, C, [0, 0], erased=(2,)), "invalid erasure accepted"),
	}
	return {"status": "passed", "nonidentifiability_regression": message,
	"input_validation": messages, "checks": 5}


	def write_examples():
	folder = ROOT / "examples"
	folder.mkdir(exist_ok=True)
	A = [[F(1), F(0), F(1), F(1)], [F(0), F(1), F(1), F(-1)]]
	dup = [row+[F(0)]*4 for row in A]
	dup += [row+[-x for x in row] for row in identity(4)]
	specs = {
	"dense_complete_four": dense_spec(4, 6),
	"dense_complete_four_below_threshold": dense_spec(4, 5),
	"star_spark_three": star_spec(A, errors=1),
	"star_spark_six": star_spec(dup, erasures=1, errors=2),
	"same_pattern_generic": star_spec([[F(1)]*4, [F(1), F(2), F(3), F(4)]], errors=1),
	"same_pattern_exceptional": star_spec([[F(1)]*4, [F(1), F(1), F(3), F(4)]], errors=1),
	}
	reports = []
	expected = [True, False, True, True, True, False]
	for (name, spec), should_work in zip(specs.items(), expected):
	(folder / (name+".json")).write_text(json.dumps(jsonable(spec), indent=2)+"\n")
	certificate = plan(jsonable(spec))
	require(certificate["requested_tolerance_possible"] is should_work,
	"planner returns wrong feasibility on "+name)
	require(certificate["design"]["status"] == "certified", "planner design search failed")
	(folder / (name+"_certificate.json")).write_text(json.dumps(certificate, indent=2)+"\n")
	reports.append({"input": name+".json", "certificate": name+"_certificate.json",
	"requested_tolerance_possible": should_work,
	"optimal_distance": certificate["optimal_architecture_distance"]})
	return reports


	def main():
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("--output", type=Path, default=ROOT / "results" / "robust_results.json")
	args = parser.parse_args()
	started = time.monotonic()
	result = {"status": "passed", "arithmetic": "fractions.Fraction; exact rational checks",
	"seed": 13371337,
	"scope": "finite exhaustive regression and witness checks, not formal proof-assistant certification",
	"architecture_exhaustion": test_architecture_exhaustion(),
	"dense_fault_recovery": test_dense_faults(),
	"causal_stars": test_stars_and_coefficients(),
	"decoder_regression": test_decoder_regression(),
	"planner_examples": write_examples()}
	result["elapsed_seconds"] = round(time.monotonic()-started, 3)
	args.output.parent.mkdir(exist_ok=True, parents=True)
	args.output.write_text(json.dumps(jsonable(result), indent=2)+"\n")
	summary = {"status": result["status"], "architectures": 216, "candidate_assignments": 729,
	"independent_subset_rank_checks": result["architecture_exhaustion"]["independent_subset_rank_checks"],
	"common_design_subset_rank_checks": result["architecture_exhaustion"]["common_design_subset_rank_checks"],
	"fault_scenarios": result["dense_fault_recovery"]["fault_scenarios"],
	"successful_column_decodes": result["dense_fault_recovery"]["successful_column_decodes"],
	"planner_examples": len(result["planner_examples"]),
	"elapsed_seconds": result["elapsed_seconds"], "output": str(args.output)}
	print(json.dumps(summary, indent=2))


	if __name__ == "__main__":
	main()