| |
| """Independent finite checks for scenario cover and joint failure severity. |
| |
| Only the Python standard library is used. The scalar rank oracle and rational |
| row elimination below are independent of the package's calibration code. |
| These exhaustive finite examples check formulas; they are not formal proofs |
| or evidence that an arbitrary large design is robust. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| from fractions import Fraction |
| from itertools import product |
| from math import comb |
| from pathlib import Path |
| import json |
|
|
|
|
| def rational_rank(rows: list[list[Fraction]]) -> int: |
| if not rows: |
| return 0 |
| a = [list(map(Fraction, row)) for row in rows] |
| ncols = len(a[0]) |
| pivot_row = 0 |
| for col in range(ncols): |
| pivot = next((i for i in range(pivot_row, len(a)) if a[i][col]), None) |
| if pivot is None: |
| continue |
| a[pivot_row], a[pivot] = a[pivot], a[pivot_row] |
| scale = a[pivot_row][col] |
| a[pivot_row] = [x / scale for x in a[pivot_row]] |
| for i in range(pivot_row + 1, len(a)): |
| scale = a[i][col] |
| if scale: |
| a[i] = [x - scale * y for x, y in zip(a[i], a[pivot_row])] |
| pivot_row += 1 |
| if pivot_row == len(a): |
| break |
| return pivot_row |
|
|
|
|
| def members(mask: int, n: int) -> list[int]: |
| return [i for i in range(n) if mask & (1 << i)] |
|
|
|
|
| def frac_string(value: Fraction) -> str: |
| return str(value.numerator) if value.denominator == 1 else str(value) |
|
|
|
|
| def scalar_checks() -> dict: |
| n = 4 |
| full = (1 << n) - 1 |
| |
| |
| visible = [0b1101, 0b1011, 0b1110] |
| masks = list(range(1 << n)) |
| records = [] |
| total_submodular_pairs = total_monotone_pairs = 0 |
| total_target_checks = total_cost_instances = 0 |
| zero_optimum_instances = 0 |
| worst_ratio = Fraction(1) |
| worst_instance = None |
| equal_cost_one_failure = None |
|
|
| for budget in range(3): |
| scenarios = [f for f in masks if f.bit_count() <= budget] |
| target = len(scenarios) * len(visible) |
| values = { |
| s: sum(bool((s & ~f) & v) for f in scenarios for v in visible) |
| for s in masks |
| } |
| assert values[0] == 0 and values[full] == target |
| for s in masks: |
| assert isinstance(values[s], int) and 0 <= values[s] <= target |
| coverage = [(s & v).bit_count() for v in visible] |
| assert (values[s] == target) == all(c >= budget + 1 for c in coverage) |
| total_target_checks += 1 |
| for t in masks: |
| assert values[s] + values[t] >= values[s | t] + values[s & t] |
| total_submodular_pairs += 1 |
| if s & t == s: |
| assert values[s] <= values[t] |
| total_monotone_pairs += 1 |
|
|
| budget_worst = Fraction(1) |
| for costs in product(range(4), repeat=n): |
| initial = sum(1 << a for a, cost in enumerate(costs) if cost == 0) |
| selected = initial |
| initial_deficit = target - values[initial] |
| path = [] |
| while values[selected] < target: |
| options = [] |
| for a, cost in enumerate(costs): |
| if selected & (1 << a): |
| continue |
| gain = values[selected | (1 << a)] - values[selected] |
| if gain > 0: |
| options.append((Fraction(cost, gain), a, gain)) |
| assert options |
| ratio, a, gain = min(options) |
| selected |= 1 << a |
| path.append({"channel": a, "gain": gain, |
| "cost_per_gain": frac_string(ratio)}) |
| greedy_cost = sum(costs[a] for a in members(selected, n)) |
| optimal_cost, optimal_mask = min( |
| (sum(costs[a] for a in members(s, n)), s) |
| for s in masks if values[s] == target |
| ) |
| harmonic = sum((Fraction(1, i) for i in range(1, initial_deficit + 1)), |
| start=Fraction(0)) |
| if initial_deficit == 0: |
| assert greedy_cost == optimal_cost == 0 |
| else: |
| assert greedy_cost <= harmonic * optimal_cost |
| if optimal_cost == 0: |
| zero_optimum_instances += 1 |
| assert greedy_cost == 0 |
| else: |
| ratio = Fraction(greedy_cost, optimal_cost) |
| budget_worst = max(budget_worst, ratio) |
| if ratio > worst_ratio: |
| worst_ratio = ratio |
| worst_instance = { |
| "failure_budget": budget, "costs": list(costs), |
| "initial_zero_cost_channels": members(initial, n), |
| "initial_deficit": initial_deficit, |
| "harmonic_bound_factor": frac_string(harmonic), |
| "greedy_channels": members(selected, n), |
| "greedy_cost": greedy_cost, |
| "optimal_channels": members(optimal_mask, n), |
| "optimal_cost": optimal_cost, |
| "greedy_to_optimal_ratio": frac_string(ratio), |
| "greedy_path": path, |
| } |
| if budget == 1 and costs == (1, 1, 1, 1): |
| assert optimal_cost == greedy_cost == 3 |
| equal_cost_one_failure = { |
| "costs": list(costs), "optimal_cost": optimal_cost, |
| "one_optimal_selection": members(optimal_mask, n), |
| "greedy_selection": members(selected, n), "greedy_path": path, |
| } |
| total_cost_instances += 1 |
|
|
| records.append({ |
| "failure_budget": budget, "scenario_count": len(scenarios), |
| "target": target, "objective_by_selection_mask": values, |
| "cost_vectors_checked": 4 ** n, |
| "worst_greedy_to_optimal_ratio": frac_string(budget_worst), |
| }) |
|
|
| |
| def minimum_surviving_rank(s: int) -> int: |
| return min(int(bool(s & ~f)) for f in range(4) |
| if f & s == f and f.bit_count() <= 1) |
|
|
| g = [minimum_surviving_rank(s) for s in range(4)] |
| assert g == [0, 0, 0, 1] |
| assert g[1] + g[2] < g[0] + g[3] |
|
|
| |
| |
| |
| arbitrary_family_target = 1 |
| arbitrary_family_value = int(bool(1)) |
| one_channel_distance = 1 |
| assert arbitrary_family_value == arbitrary_family_target |
| assert not one_channel_distance > 2 |
|
|
| return { |
| "catalogue_visibility_by_channel": [[0, 1], [1, 2], [0, 2], [0, 1, 2]], |
| "budgets_checked": [0, 1, 2], |
| "submodular_ordered_pairs_checked": total_submodular_pairs, |
| "monotone_ordered_pairs_checked": total_monotone_pairs, |
| "target_equivalence_checks": total_target_checks, |
| "greedy_cost_instances_checked": total_cost_instances, |
| "zero_optimum_cost_instances": zero_optimum_instances, |
| "worst_greedy_to_optimal_ratio": frac_string(worst_ratio), |
| "worst_instance": worst_instance, |
| "equal_cost_one_failure": equal_cost_one_failure, |
| "per_budget": records, |
| "minimum_rank_non_submodularity": { |
| "values_empty_a_b_ab": g, "left_side": g[1] + g[2], |
| "right_side": g[0] + g[3], "strict_violation": True, |
| }, |
| "arbitrary_scenario_scope_regression": { |
| "scenario_family": [[]], "selected_channels": [0], |
| "target_reached": True, "distance": one_channel_distance, |
| "corrects_one_arbitrary_error": False, |
| }, |
| } |
|
|
|
|
| def severity_checks() -> dict: |
| n = 6 |
| full = (1 << n) - 1 |
| sensor_rows = [[Fraction(t) ** j for j in range(4)] for t in range(1, n + 1)] |
| column_coordinate_sets = [[1, 2, 3], [2, 3], [3], []] |
| dimensions = [len(coords) for coords in column_coordinate_sets] |
| failures = [] |
| loss_by_failure_count = {e: set() for e in range(n + 1)} |
| restriction_rank_checks = 0 |
| p = Fraction(1, 10) |
| reliability = Fraction(0) |
| for failed in range(1 << n): |
| retained = full & ~failed |
| ranks = [] |
| for coords in column_coordinate_sets: |
| rows = [[sensor_rows[a][j] for j in coords] for a in members(retained, n)] |
| rank = rational_rank(rows) |
| assert rank == min(retained.bit_count(), len(coords)) |
| ranks.append(rank) |
| restriction_rank_checks += 1 |
| losses = [d - rank for d, rank in zip(dimensions, ranks)] |
| loss = sum(losses) |
| e = failed.bit_count() |
| assert loss == sum(max(0, e - threshold) for threshold in (3, 4, 5)) |
| loss_by_failure_count[e].add(loss) |
| failures.append({"failed_channels": members(failed, n), |
| "surviving_ranks": ranks, "column_nullities": losses, |
| "total_nullity": loss}) |
| if loss == 0: |
| reliability += p ** e * (1 - p) ** (n - e) |
| assert all(len(values) == 1 for values in loss_by_failure_count.values()) |
| loss_profile = [next(iter(loss_by_failure_count[e])) for e in range(n + 1)] |
| assert loss_profile == [0, 0, 0, 0, 1, 3, 6] |
| thresholds = [min(len(row["failed_channels"]) for row in failures |
| if row["total_nullity"] >= k) for k in range(1, 7)] |
| assert thresholds == [4, 5, 5, 6, 6, 6] |
| binomial_reliability = sum( |
| (Fraction(comb(n, e)) * p ** e * (1 - p) ** (n - e) for e in range(4)), |
| start=Fraction(0), |
| ) |
| assert reliability == binomial_reliability |
|
|
| def scalar_severity(visibility: list[int], count: int) -> dict: |
| table = [] |
| all_channels = (1 << count) - 1 |
| for failed in range(1 << count): |
| survivors = all_channels & ~failed |
| loss = sum(not bool(survivors & v) for v in visibility) |
| table.append((failed.bit_count(), loss)) |
| thresholds = [min(e for e, loss in table if loss >= k) |
| for k in range(1, len(visibility) + 1)] |
| return {"individual_distances": [v.bit_count() for v in visibility], |
| "global_thresholds": thresholds} |
|
|
| disjoint = scalar_severity([0b01, 0b10], 2) |
| shared = scalar_severity([0b1, 0b1], 1) |
| assert disjoint["individual_distances"] == shared["individual_distances"] == [1, 1] |
| assert disjoint["global_thresholds"] == [1, 2] |
| assert shared["global_thresholds"] == [1, 1] |
| return { |
| "exact_rational_restriction_ranks_checked": restriction_rank_checks, |
| "failure_sets_checked": 1 << n, |
| "sensor_rows": [[str(x) for x in row] for row in sensor_rows], |
| "column_coordinate_sets": column_coordinate_sets, |
| "column_dimensions": dimensions, |
| "total_nullity_by_erasure_count": loss_profile, |
| "global_thresholds_for_k_1_to_6": thresholds, |
| "independent_failure_probability": frac_string(p), |
| "exact_probability_of_identification": frac_string(reliability), |
| "probability_decimal": float(reliability), |
| "binomial_reliability_cross_check": True, |
| "shared_vs_disjoint_counterexample": {"disjoint": disjoint, "shared": shared}, |
| "full_failure_table": failures, |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--output", type=Path, |
| default=Path(__file__).resolve().parents[1] / "results" / "selection_results.json") |
| args = parser.parse_args() |
| scalar = scalar_checks() |
| severity = severity_checks() |
| result = { |
| "status": "all finite checks passed", |
| "arithmetic": "Python standard library integers and fractions.Fraction", |
| "scope": "Independent finite example checks; not a formal proof or external review.", |
| "scenario_cover": scalar, "global_failure_severity": severity, |
| } |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.output.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") |
| print(json.dumps({ |
| "status": result["status"], |
| "submodular_pairs": scalar["submodular_ordered_pairs_checked"], |
| "monotone_pairs": scalar["monotone_ordered_pairs_checked"], |
| "target_equivalence_checks": scalar["target_equivalence_checks"], |
| "greedy_cost_instances": scalar["greedy_cost_instances_checked"], |
| "exact_rational_restriction_ranks": severity["exact_rational_restriction_ranks_checked"], |
| "failure_sets": severity["failure_sets_checked"], |
| "output": str(args.output), |
| }, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
