verify_support_quotient.py

#!/usr/bin/env python3
"""Exhaustive finite audit for FPRD-T155."""

from __future__ import annotations

import json
from itertools import product
from pathlib import Path


def essential_coordinates(table: tuple[object, ...], n: int) -> frozenset[int]:
    result = set()
    for coordinate in range(n):
        bit = 1 << coordinate
        for source in range(1 << n):
            if table[source] != table[source ^ bit]:
                result.add(coordinate)
                break
    return frozenset(result)


def sufficient(table: tuple[object, ...], n: int, mask: int) -> bool:
    seen: dict[int, object] = {}
    for source, answer in enumerate(table):
        key = source & mask
        if key in seen and seen[key] != answer:
            return False
        seen[key] = answer
    return True


def audit_table(table: tuple[object, ...], n: int) -> tuple[int, int]:
    essential = essential_coordinates(table, n)
    essential_mask = sum(1 << coordinate for coordinate in essential)
    support_checks = 0
    for mask in range(1 << n):
        expected = mask & essential_mask == essential_mask
        assert sufficient(table, n, mask) == expected
        support_checks += 1

    image_size = len(set(table))
    carrier_size = 1 << len(essential)
    assert image_size <= carrier_size

    restricted = {
        table[source]
        for source in range(1 << n)
        if source & ~essential_mask == 0
    }
    assert restricted == set(table)
    assert (image_size == carrier_size) == (len(restricted) == carrier_size)
    return support_checks, 1


def run() -> dict[str, object]:
    scalar_maps = 0
    vector_maps = 0
    support_checks = 0
    carrier_checks = 0
    component_union_checks = 0

    scalar_tables: dict[int, list[tuple[int, ...]]] = {}
    for n in range(5):
        tables = []
        domain_size = 1 << n
        for code in range(1 << domain_size):
            table = tuple((code >> source) & 1 for source in range(domain_size))
            tables.append(table)
            checked_supports, checked_carrier = audit_table(table, n)
            support_checks += checked_supports
            carrier_checks += checked_carrier
            scalar_maps += 1
        scalar_tables[n] = tables

    for n in range(4):
        tables = scalar_tables[n]
        for left, right in product(tables, repeat=2):
            vector = tuple(zip(left, right))
            checked_supports, checked_carrier = audit_table(vector, n)
            support_checks += checked_supports
            carrier_checks += checked_carrier
            assert essential_coordinates(vector, n) == (
                essential_coordinates(left, n) | essential_coordinates(right, n)
            )
            component_union_checks += 1
            vector_maps += 1

    # Three strict calibration families for every positive dimension.
    separation_dimensions = 12
    operational_semantic_gaps = 0
    semantic_quotient_gaps = 0
    tight_identity_cases = 0
    for n in range(1, separation_dimensions + 1):
        domain = range(1 << n)

        first_bit = tuple(source & 1 for source in domain)
        assert len(essential_coordinates(first_bit, n)) == 1
        assert len(set(first_bit)) == 2
        operational_semantic_gaps += 1

        parity = tuple(source.bit_count() & 1 for source in domain)
        assert len(essential_coordinates(parity, n)) == n
        assert len(set(parity)) == 2
        if n > 1:
            semantic_quotient_gaps += 1

        identity = tuple(domain)
        assert len(essential_coordinates(identity, n)) == n
        assert len(set(identity)) == 1 << n
        tight_identity_cases += 1

    return {
        "status": "pass",
        "scalar_maps": scalar_maps,
        "vector_maps": vector_maps,
        "total_maps": scalar_maps + vector_maps,
        "support_subset_checks": support_checks,
        "semantic_carrier_checks": carrier_checks,
        "component_union_checks": component_union_checks,
        "operational_semantic_gap_examples": operational_semantic_gaps,
        "semantic_quotient_gap_examples": semantic_quotient_gaps,
        "tight_identity_examples": tight_identity_cases,
    }


if __name__ == "__main__":
    result = run()
    output = Path(__file__).with_name("checker-output.json")
    output.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
    print(json.dumps(result, indent=2))