#!/usr/bin/env python3 """Fail-closed cross-task validator for the matched ImageNet spectral audit. The eight GPU tasks are intentionally not trusted to validate one another. This program consumes their row-level artifacts, checks the frozen protocol across tasks, and deterministically rebuilds the root tables. It never writes the root ``COMPLETE`` marker; the launch wrapper may do that only after this command returns zero and verifies the emitted artifact hashes. """ from __future__ import annotations import argparse import csv import hashlib import html import importlib.metadata import io import json import math import os import re import shutil import sys import tempfile import warnings import zipfile from collections import Counter from dataclasses import dataclass from datetime import UTC, datetime from pathlib import Path from typing import Any, Iterable, Mapping, Sequence import numpy as np AUDIT_ROOT = Path("/nfs/ywang29/GmNet/e4_spectral_audit") DEFAULT_INPUT_MANIFEST = AUDIT_ROOT / "input_manifest.json" DEFAULT_RUNNER = AUDIT_ROOT / "code" / "run_e4_imagenet_spectral_audit.py" PROTOCOL_ID = "gmnet-e4-imagenet-matched-spectral-v1" TASK_ORDER = ("B", "D", "S", "C", "SC", "D_order1", "D_order2", "B_order1") CANONICAL_ARMS = ("B", "D", "S", "C", "SC") EXPECTED_TASK = { "B": ("B", "canonical"), "D": ("D", "canonical"), "S": ("S", "canonical"), "C": ("C", "canonical"), "SC": ("SC", "canonical"), "D_order1": ("D", "salt1"), "D_order2": ("D", "salt2"), "B_order1": ("B", "salt1"), } ORDER_SALTS = { "canonical": None, "salt1": "gmnet-e4-order-sensitivity-1", "salt2": "gmnet-e4-order-sensitivity-2", } EXPECTED_CONDITIONS = ( "unfiltered", "lowpass_0.125", "lowpass_0.25", "lowpass_0.5", "lowpass_0.75", ) SIGNAL_NAMES = ( "carrier", "gate_input", "gate_value", "gated_product", "residual_delta", ) COHERENCE_NAMES = ("rho_used", "rho_response") BASES = ("fft", "dct") STAGE_DEPTHS = (3, 3, 8, 3) EXPECTED_STAGES = tuple( stage for stage, depth in enumerate(STAGE_DEPTHS, start=1) for _ in range(depth) ) EXPECTED_STAGE_BLOCKS = tuple( local for depth in STAGE_DEPTHS for local in range(1, depth + 1) ) EXPANDED_CHANNELS_BY_STAGE = (192, 384, 768, 1536) RESIDUAL_CHANNELS_BY_STAGE = (48, 96, 192, 384) FROZEN_CHANNEL_PERMUTATION_SHA256 = ( "0219d0a289ae2e3c2bde90568af4b05d23ca629522f1b19b6a1d09473d87fb8b" ) FORMAL_TORCH = "2.9.0+cu130" FORMAL_TORCHVISION = "0.24.0+cu130" FORMAL_CUDA = "13.0" EXPECTED_INPUT_MANIFEST_SHA256 = ( "8b32da7c33f6b578dd2b5359d727afe313462be0c0040212a2640755ad2fadf7" ) EXPECTED_AUDIT_TRAINING_CODE_SHA256 = ( "f6bd434a2ac86c772f2e23683431f3bb7ccb06f539558682a3bea6464bacebf9" ) EXPECTED_ALIGNMENT_TRAINING_CODE_SHA256 = ( "4a62bc48370247d882196cd9afc1a0f1629a5bbfd522c3f599ffaf0c1187641f" ) NUM_IMAGES = 50_000 NUM_SPECTRAL_IMAGES = 4_096 NUM_BLOCKS = 17 NUM_CLASSES = 1_000 NUM_BANDS = 4 BOOTSTRAP_REPLICATES = 10_000 BOOTSTRAP_SEED = 20_260_718 ARBITRARY_INDEPENDENT_GATE_GENERALIZATION_PERMITTED = False LOWPASS_CAUSAL_CAVEAT = ( "Low-pass curves can show task-frequency sensitivity, but they cannot prove " "that a specific internal gate produced that dependence." ) HASH_RE = frozenset("0123456789abcdef") REQUIRED_TASK_FILES = ( "results.json", "protocol.json", "environment.json", "checkpoint_manifest.json", "subset_manifest.jsonl", "accuracy_by_condition.csv", "per_image_accuracy.npz", "per_image_spectral.npz", "spectral_by_block.csv", "spectral_by_stage.csv", "transfer_matrices.npz", "batch_pairing_manifest.json", "data_manifest.json", "source_provenance.json", "source_artifacts.sha256", "artifacts.json", "COMPLETE", ) ACCURACY_COLUMNS = ( "task_id", "arm", "order", "condition", "cutoff", "samples", "top1_correct", "top5_correct", "top1", "top5", "nll", "ece", "top1_drop", "top5_drop", ) ACCURACY_BOOTSTRAP_COLUMNS = ( "contrast_id", "left_task_id", "left_condition", "right_task_id", "right_condition", "metric", "unit", "samples", "point_difference", "bootstrap_ci95_low", "bootstrap_ci95_high", "bootstrap_replicates", "bootstrap_seed", ) SPECTRAL_COLUMNS = ( "task_id", "arm", "order", "basis", "global_block_index", "stage", "block", "signal", "psd_high_fraction", "psd_centroid", "psd_entropy", "valid", "invalid", "centered_rms", "log10_centered_energy", "log10_centered_energy_valid", "log10_centered_energy_invalid", "noncentered_rms", "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", "rho_used", "rho_response", "jsd", "jsd_valid_channels", "m_res", "m_res_conditional", "m_res_conditional_valid_channels", "suppressed_fraction", "constant_gate_fraction", "constant_gate_count", "output_minus_carrier_high_fraction", "output_minus_carrier_centroid", "output_minus_carrier_valid_channels", "m_off", "m_disp", "source_valid", "source_suppressed", "source_valid_fraction", "source_suppressed_fraction", ) BLOCK_SUMMARY_GATED_EXTRA_FIELDS = { "transfer_primary", "transfer_conditional", "transfer_source_valid", "transfer_source_suppressed", } STAGE_COLUMNS = ( "task_id", "arm", "order", "basis", "stage", "signal", "aggregation", "block_count", "psd_high_fraction", "psd_centroid", "psd_entropy", "centered_rms", "noncentered_rms", "rho_used", "rho_response", "jsd", "m_res", "suppressed_fraction", "m_off", "m_disp", ) RAW_AMPLITUDE_COLUMNS = ( "task_id", "arm", "order", "global_block_index", "stage", "block", "signal", "metric", "dataset_median", "q25", "q75", "bootstrap_ci95_low", "bootstrap_ci95_high", "bootstrap_replicates", "valid_receivers", "invalid_receivers", ) GATE_OPERATING_COLUMNS = ( "task_id", "arm", "order", "basis", "global_block_index", "stage", "block", "metric", "aggregation", "point", "dataset_median", "q25", "q75", "median_bootstrap_ci95_low", "median_bootstrap_ci95_high", "block_stage_min", "block_stage_max", "bootstrap_ci95_low", "bootstrap_ci95_high", "bootstrap_replicates", "valid_receivers", "invalid_receivers", ) TRANSFER_BOOTSTRAP_COLUMNS = ( "task_id", "arm", "basis", "global_block_index", "stage", "block", "summary", "source_band", "target_band", "point", "bootstrap_q025", "bootstrap_q50", "bootstrap_q975", "defined", "bootstrap_defined_replicates", "bootstrap_replicates", "bootstrap_seed", ) ROOT_SIGNAL_PREFIXES = { "carrier": "x", "gate_value": "q", "gated_product": "y", } ROOT_SIGNAL_POINT_METRICS = ( "psd_high_fraction", "psd_centroid", "psd_entropy", "centered_rms", "log10_centered_energy", "noncentered_rms", ) ROOT_SIGNAL_BOOTSTRAP_METRICS = ( "psd_high_fraction", "psd_centroid", "psd_entropy", ) ROOT_OPERATOR_METRICS = ( "rho_used", "rho_response", "jsd", "m_res", "m_res_conditional", "suppressed_fraction", "constant_gate_fraction", "m_off", "m_disp", "source_valid_fraction", "source_suppressed_fraction", "output_minus_carrier_high_fraction", "output_minus_carrier_centroid", ) ROOT_SPECTRAL_COLUMNS = ( "task_id", "arm", "basis", "global_block_index", "stage", "block", *tuple( field for prefix in ROOT_SIGNAL_PREFIXES.values() for metric in ROOT_SIGNAL_POINT_METRICS for field in ( ( f"{prefix}_{metric}", f"{prefix}_{metric}_ci95_low", f"{prefix}_{metric}_ci95_high", f"{prefix}_{metric}_defined", f"{prefix}_{metric}_valid_receivers", ) if metric in ROOT_SIGNAL_BOOTSTRAP_METRICS else (f"{prefix}_{metric}",) ) ), *tuple( field for prefix in ROOT_SIGNAL_PREFIXES.values() for field in ( f"{prefix}_valid", f"{prefix}_invalid", f"{prefix}_log10_centered_energy_valid", f"{prefix}_log10_centered_energy_invalid", ) ), "q_gate_mean", "q_gate_cv", "q_gate_zero_fraction", "q_gate_active_fraction", "q_gate_clip_crossing_fraction", *tuple( field for metric in ROOT_OPERATOR_METRICS for field in ( metric, f"{metric}_ci95_low", f"{metric}_ci95_high", f"{metric}_defined", f"{metric}_valid_receivers", ) ), "m_res_conditional_valid_channels", "constant_gate_count", "source_valid", "source_suppressed", "jsd_valid_channels", "jsd_invalid_channels", "output_minus_carrier_valid_channels", "output_minus_carrier_invalid_channels", ) ROOT_STAGE_METRICS = ( *ROOT_SIGNAL_BOOTSTRAP_METRICS, *ROOT_OPERATOR_METRICS, ) ROOT_STAGE_COLUMNS = ( "task_id", "arm", "basis", "stage", "signal", "aggregation", "block_count", *tuple( field for metric in ROOT_STAGE_METRICS for field in ( f"{metric}_mean", f"{metric}_block_min", f"{metric}_block_max", f"{metric}_ci95_low", f"{metric}_ci95_high", f"{metric}_defined", f"{metric}_valid_block_count", ) ), ) ORDER_PROBE_SPECTRAL_COLUMNS = ( "task_id", "arm", "order", *tuple( field for field in ROOT_SPECTRAL_COLUMNS[2:] if not field.endswith(("_ci95_low", "_ci95_high")) ), ) D_ORDER_TASKS = ("D", "D_order1", "D_order2") D_ORDER_RANGE_POINT_METRICS = tuple( field for field in ROOT_SPECTRAL_COLUMNS if field not in {"task_id", "arm", "basis", "global_block_index", "stage", "block"} and not field.endswith(("_ci95_low", "_ci95_high")) ) D_ORDER_TRANSFER_METRICS = tuple( f"transfer_{kind}_s{source}_t{target}" for kind in ("primary", "conditional") for source in range(NUM_BANDS) for target in range(NUM_BANDS) ) D_ORDER_RAW_DIAGNOSTIC_METRICS = tuple( f"raw_{prefix}_{metric}_{statistic}" for prefix in ROOT_SIGNAL_PREFIXES.values() for metric in ("centered_rms", "log10_centered_energy", "noncentered_rms") for statistic in ("dataset_median", "q25", "q75") ) + tuple( f"raw_q_{metric}_{statistic}" for metric in ( "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", ) for statistic in ("dataset_median", "q25", "q75") ) D_ORDER_RANGE_METRICS = ( D_ORDER_RANGE_POINT_METRICS + D_ORDER_RAW_DIAGNOSTIC_METRICS + D_ORDER_TRANSFER_METRICS ) D_ORDER_SENSITIVITY_COLUMNS = ( "basis", "global_block_index", "stage", "block", "registered_task_count", *tuple( field for metric in D_ORDER_RANGE_METRICS for field in ( *( field for task_id in D_ORDER_TASKS for field in ( f"{metric}_{task_id}", f"{metric}_{task_id}_defined", ) ), f"{metric}_min", f"{metric}_max", f"{metric}_alternate_min", f"{metric}_alternate_max", f"{metric}_alternate_range_defined", f"{metric}_defined_count", ) ), ) COHERENCE_COLUMNS = ( "task_id", "arm", "order", "global_block_index", "stage", "block", "coherence", "class_equal_mean", "receiver_mean_sd", "receiver_mean_q05", "receiver_mean_q50", "receiver_mean_q95", "valid_channels", "invalid_channels", "valid_receivers", "invalid_receivers", ) class ValidationFailure(RuntimeError): """Raised after all available fail-closed checks have been recorded.""" class DuplicateKeyError(ValueError): pass def _reject_constant(value: str) -> None: raise ValueError(f"non-finite JSON number is forbidden: {value}") def _object_no_duplicates(pairs: list[tuple[str, Any]]) -> dict[str, Any]: result: dict[str, Any] = {} for key, value in pairs: if key in result: raise DuplicateKeyError(f"duplicate JSON key: {key}") result[key] = value return result def load_json(path: Path) -> dict[str, Any]: with path.open("r", encoding="utf-8") as handle: value = json.load( handle, parse_constant=_reject_constant, object_pairs_hook=_object_no_duplicates, ) if not isinstance(value, dict): raise ValueError(f"JSON root must be an object: {path}") return value def stable_json(value: Any) -> bytes: return ( json.dumps( value, indent=2, sort_keys=True, ensure_ascii=True, allow_nan=False, ) + "\n" ).encode("utf-8") def file_sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def bytes_sha256(value: bytes) -> str: return hashlib.sha256(value).hexdigest() def int64_sha256(values: np.ndarray) -> str: return bytes_sha256(np.asarray(values, dtype=" bool: return ( isinstance(value, str) and len(value) == 64 and set(value).issubset(HASH_RE) ) def deterministic_npz_bytes(arrays: Mapping[str, np.ndarray]) -> bytes: """Return an NPZ whose member order, timestamps, and permissions are fixed.""" output = io.BytesIO() with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_STORED) as archive: for name in sorted(arrays): if not name or "/" in name or "\\" in name: raise ValueError(f"invalid NPZ member name: {name!r}") array = np.asarray(arrays[name]) if array.dtype.hasobject: raise ValueError(f"object dtype is forbidden in NPZ member {name}") member = io.BytesIO() np.lib.format.write_array(member, array, allow_pickle=False) info = zipfile.ZipInfo(f"{name}.npy", date_time=(1980, 1, 1, 0, 0, 0)) info.compress_type = zipfile.ZIP_STORED info.external_attr = 0o100644 << 16 info.create_system = 3 archive.writestr(info, member.getvalue()) return output.getvalue() def csv_bytes(fieldnames: Sequence[str], rows: Iterable[Mapping[str, Any]]) -> bytes: stream = io.StringIO(newline="") writer = csv.DictWriter(stream, fieldnames=list(fieldnames), lineterminator="\n") writer.writeheader() for row in rows: writer.writerow({name: format_cell(row.get(name, "")) for name in fieldnames}) return stream.getvalue().encode("utf-8") def format_cell(value: Any) -> str: if value is None: return "" if isinstance(value, (float, np.floating)): number = float(value) if not math.isfinite(number): return "" return format(number, ".17g") if isinstance(value, (bool, np.bool_)): return "true" if bool(value) else "false" if isinstance(value, np.integer): return str(int(value)) return str(value) def read_csv(path: Path, required_columns: Sequence[str]) -> list[dict[str, str]]: with path.open("r", encoding="utf-8", newline="") as handle: reader = csv.DictReader(handle) if reader.fieldnames is None: raise ValueError(f"CSV has no header: {path}") if tuple(reader.fieldnames) != tuple(required_columns): raise ValueError( f"CSV {path} header {tuple(reader.fieldnames)} != {tuple(required_columns)}" ) return list(reader) def load_npz(path: Path, required: Sequence[str]) -> dict[str, np.ndarray]: with np.load(path, allow_pickle=False) as archive: missing = sorted(set(required) - set(archive.files)) if missing: raise ValueError(f"NPZ {path} is missing fields: {missing}") result = {name: np.array(archive[name], copy=True) for name in archive.files} for name, array in result.items(): if array.dtype.hasobject: raise ValueError(f"object dtype is forbidden: {path}:{name}") return result def require_dtype(array: np.ndarray, dtype: str, name: str) -> None: if array.dtype != np.dtype(dtype): raise ValueError(f"{name} dtype {array.dtype} != {np.dtype(dtype)}") def require_shape(array: np.ndarray, shape: tuple[int, ...], name: str) -> None: if array.shape != shape: raise ValueError(f"{name} shape {array.shape} != {shape}") def unicode_tuple(array: np.ndarray, name: str) -> tuple[str, ...]: if array.ndim != 1 or array.dtype.kind != "U": raise ValueError(f"{name} must be a one-dimensional Unicode array") return tuple(str(item) for item in array.tolist()) def canonical_order(order: str) -> np.ndarray: if order == "canonical": return np.arange(NUM_IMAGES, dtype=np.int64) salt = ORDER_SALTS[order] assert salt is not None prefix = salt.encode("utf-8") + b"\0" keyed = [ (hashlib.sha256(prefix + int(index).to_bytes(8, "little", signed=False)).digest(), index) for index in range(NUM_IMAGES) ] keyed.sort(key=lambda row: (row[0], row[1])) return np.asarray([index for _, index in keyed], dtype=np.int64) def class_equal_mean(values: np.ndarray, class_ids: np.ndarray) -> float: values = np.asarray(values, dtype=np.float64) class_ids = np.asarray(class_ids) means: list[float] = [] for class_id in range(NUM_CLASSES): selected = values[class_ids == class_id] finite = selected[np.isfinite(selected)] means.append( float(finite.mean(dtype=np.float64)) if finite.size else float("nan") ) result = float(np.nanmean(np.asarray(means, dtype=np.float64))) if not math.isfinite(result): raise ValueError("class-equal statistic has no valid class observations") return result def optional_class_equal_mean( values: np.ndarray, class_ids: np.ndarray ) -> float | None: values = np.asarray(values, dtype=np.float64) if not np.isfinite(values).any(): return None return class_equal_mean(values, class_ids) def class_equal_array(values: np.ndarray, class_ids: np.ndarray) -> np.ndarray: values = np.asarray(values, dtype=np.float64) tail = values.shape[1:] result = np.empty((NUM_CLASSES,) + tail, dtype=np.float64) for class_id in range(NUM_CLASSES): selected = values[class_ids == class_id] with np.errstate(invalid="ignore"): result[class_id] = np.nanmean(selected, axis=0, dtype=np.float64) with np.errstate(invalid="ignore"): aggregate = np.nanmean(result, axis=0, dtype=np.float64) if not np.all(np.isfinite(aggregate)): raise ValueError("class-equal array has cells with no valid class observations") return aggregate def optional_class_equal_array(values: np.ndarray, class_ids: np.ndarray) -> np.ndarray: values = np.asarray(values, dtype=np.float64) tail = values.shape[1:] per_class = np.full((NUM_CLASSES,) + tail, np.nan, dtype=np.float64) for class_id in range(NUM_CLASSES): selected = values[class_ids == class_id] with np.errstate(invalid="ignore"): per_class[class_id] = np.nanmean(selected, axis=0, dtype=np.float64) with np.errstate(invalid="ignore"): return np.nanmean(per_class, axis=0, dtype=np.float64) def image_equal_mean(values: np.ndarray) -> float: values = np.asarray(values, dtype=np.float64) finite = values[np.isfinite(values)] if finite.size == 0: raise ValueError("image-equal statistic has no valid receiver observations") return float(finite.mean(dtype=np.float64)) def optional_image_equal_mean(values: np.ndarray) -> float | None: values = np.asarray(values, dtype=np.float64) finite = values[np.isfinite(values)] return float(finite.mean(dtype=np.float64)) if finite.size else None def image_equal_array(values: np.ndarray) -> np.ndarray: values = np.asarray(values, dtype=np.float64) with np.errstate(invalid="ignore"): aggregate = np.nanmean(values, axis=0, dtype=np.float64) if not np.all(np.isfinite(aggregate)): raise ValueError("image-equal array has cells with no valid receiver observations") return aggregate def finite_or_none(value: Any) -> float | None: if value is None: return None try: result = float(value) except (TypeError, ValueError): return None return result if math.isfinite(result) else None def finite_values(values: Iterable[Any]) -> list[float] | None: result = [finite_or_none(value) for value in values] if any(value is None for value in result): return None return [float(value) for value in result] def compare_aggregate_values(left: Any, right: Any) -> tuple[bool, float, int]: """Compare aggregate values with strict definedness and NaN-mask equality.""" if left is None or right is None: return (left is None and right is None, 0.0, 1) left_array = np.asarray(left) right_array = np.asarray(right) if left_array.shape != right_array.shape: return (False, math.inf, 0) if left_array.dtype.kind in "biu" and right_array.dtype.kind in "biu": return ( bool(np.array_equal(left_array, right_array)), 0.0 if np.array_equal(left_array, right_array) else math.inf, int(left_array.size), ) if left_array.dtype.kind in "fci" and right_array.dtype.kind in "fci": left_finite = np.isfinite(left_array) right_finite = np.isfinite(right_array) if not np.array_equal(left_finite, right_finite): return (False, math.inf, int(left_array.size)) if not left_finite.any(): return (True, 0.0, int(left_array.size)) maximum = float( np.max( np.abs( left_array[left_finite].astype(np.complex128) - right_array[right_finite].astype(np.complex128) ) ) ) return (math.isfinite(maximum), maximum, int(left_array.size)) equal = bool(np.array_equal(left_array, right_array)) return (equal, 0.0 if equal else math.inf, int(left_array.size)) def compare_block_summary_registries( left_summary: Mapping[Any, Mapping[str, Any]], right_summary: Mapping[Any, Mapping[str, Any]], ) -> dict[str, Any]: """Compare B summaries while allowing only task/order identity to differ.""" ignored_identity = {"task_id", "order"} registry_equal = set(left_summary) == set(right_summary) definedness_equal = True maximum = 0.0 compared_values = 0 covered_fields: set[str] = set() for key in sorted(set(left_summary) & set(right_summary)): left = left_summary[key] right = right_summary[key] if set(left) != set(right): registry_equal = False for field in sorted((set(left) & set(right)) - ignored_identity): equal, difference, count = compare_aggregate_values(left[field], right[field]) covered_fields.add(field) compared_values += count definedness_equal = definedness_equal and equal maximum = max(maximum, difference) return { "field_registry_identical": registry_equal, "definedness_equal": definedness_equal, "maximum_absolute_metric_difference": maximum, "compared_values": compared_values, "covered_fields": covered_fields, } def complete_nonnegative_rms(values: Any) -> bool: array = np.asarray(values, dtype=np.float64) return bool(np.all(np.isfinite(array)) and np.all(array >= 0.0)) def section_11_3_joint_decline( accuracy_declines: bool, raw_energy_declines: bool, normalized_psd_declines: bool, conditional_transfer_declines: bool, ) -> bool: return bool( accuracy_declines and raw_energy_declines and normalized_psd_declines and conditional_transfer_declines ) def registered_decline_state(left: Any, right: Any) -> str: values = finite_values((left, right)) if values is None: return "undefined" return "decline" if values[0] < values[1] else "not_decline" def complete_alternate_range(values: Sequence[Any]) -> tuple[float | None, float | None, bool]: converted = [finite_or_none(value) for value in values] if len(converted) != 2 or any(value is None for value in converted): return None, None, False finite = [float(value) for value in converted] return min(finite), max(finite), True def ece_15(confidence: np.ndarray, correct: np.ndarray) -> float: confidence = np.asarray(confidence, dtype=np.float64) correct = np.asarray(correct, dtype=np.float64) edges = np.linspace(0.0, 1.0, 16, dtype=np.float64) bins = np.minimum(np.searchsorted(edges, confidence, side="right") - 1, 14) bins = np.maximum(bins, 0) result = 0.0 for bin_id in range(15): mask = bins == bin_id if mask.any(): result += float(mask.mean()) * abs(float(confidence[mask].mean()) - float(correct[mask].mean())) return 100.0 * result @dataclass class TaskData: task_id: str arm: str order: str root: Path results: dict[str, Any] accuracy: dict[str, np.ndarray] spectral: dict[str, np.ndarray] accuracy_rows: list[dict[str, Any]] spectral_rows: list[dict[str, Any]] block_summary: dict[tuple[str, int, str], dict[str, Any]] pairing: dict[str, Any] class AuditValidator: def __init__(self, root: Path, manifest_path: Path, runner_path: Path) -> None: self.root = root.resolve() self.manifest_path = manifest_path.resolve() self.runner_path = runner_path.resolve() self.errors: list[str] = [] self.checks: dict[str, dict[str, Any]] = {} self.manifest: dict[str, Any] = {} self.tasks: dict[str, TaskData] = {} def check(self, check_id: str, condition: bool, message: str, **details: Any) -> None: if check_id in self.checks: raise RuntimeError(f"duplicate validation check ID: {check_id}") item: dict[str, Any] = {"passed": bool(condition), "message": message} if details: item["details"] = details self.checks[check_id] = item if not condition: self.errors.append(f"{check_id}: {message}") def attempt(self, check_id: str, function: Any) -> Any: try: value = function() except Exception as error: # Validation must leave a machine-readable reason. self.check(check_id, False, f"{type(error).__name__}: {error}") return None self.check(check_id, True, "passed") return value def validate_manifest_and_root(self) -> None: manifest_digest = file_sha256(self.manifest_path) self.check( "manifest.independent_frozen_sha256", manifest_digest == EXPECTED_INPUT_MANIFEST_SHA256, "input manifest bytes differ from the independently frozen validator constant", actual_sha256=manifest_digest, expected_sha256=EXPECTED_INPUT_MANIFEST_SHA256, ) if manifest_digest != EXPECTED_INPUT_MANIFEST_SHA256: raise ValidationFailure("refusing to trust an input manifest with changed bytes") manifest = load_json(self.manifest_path) self.manifest = manifest self.check( "manifest.protocol_id", manifest.get("protocol_id") == PROTOCOL_ID, "input manifest protocol_id must match the frozen protocol", ) protocol = manifest.get("protocol", {}) protocol_path = Path(str(protocol.get("path", ""))).resolve() protocol_hash = protocol.get("sha256") self.check( "manifest.protocol_hash_format", valid_sha256(protocol_hash), "input manifest protocol SHA256 must be lowercase hex", ) self.check( "manifest.protocol_file", protocol_path.is_file() and file_sha256(protocol_path) == protocol_hash, "protocol path/hash does not match the frozen input manifest", path=str(protocol_path), expected_sha256=protocol_hash, ) runtime = manifest.get("runtime", {}) expected_runtime = { "torch": FORMAL_TORCH, "torchvision": FORMAL_TORCHVISION, "canonical_batch_size": 256, "spectral_samples": NUM_SPECTRAL_IMAGES, "max_eval_samples": NUM_IMAGES, "parallel_tasks": 8, } self.check( "manifest.runtime_contract", all(runtime.get(key) == value for key, value in expected_runtime.items()), "input manifest runtime contract changed", expected=expected_runtime, ) self.check( "manifest.task_contract", tuple(arm.get("arm") for arm in manifest.get("arms", [])) == CANONICAL_ARMS and {probe.get("task_id") for probe in manifest.get("order_probes", [])} == {"D_order1", "D_order2", "B_order1"}, "input manifest must register five canonical arms and three order probes", ) provenance = manifest.get("code_provenance", {}) self.check( "manifest.independent_training_code_boundaries", provenance.get("audit_runtime_code_sha256") == EXPECTED_AUDIT_TRAINING_CODE_SHA256 and provenance.get("alignment_training_code_sha256") == EXPECTED_ALIGNMENT_TRAINING_CODE_SHA256, "training code boundaries differ from hardcoded validator constants", ) provenance_files = { "audit_runtime_manifest": provenance.get("audit_runtime_manifest"), "alignment_training_manifest": provenance.get("alignment_training_manifest"), "alignment_source_snapshot_manifest": provenance.get( "alignment_source_snapshot_manifest" ), } provenance_hash_keys = { "audit_runtime_manifest": "audit_runtime_manifest_sha256", "alignment_training_manifest": "alignment_training_manifest_sha256", "alignment_source_snapshot_manifest": "alignment_source_snapshot_manifest_sha256", } provenance_passed = True provenance_details: dict[str, Any] = {} for name, path_value in provenance_files.items(): path = Path(str(path_value)).resolve() expected_hash = provenance.get(provenance_hash_keys[name]) actual_hash = file_sha256(path) if path.is_file() else None provenance_details[name] = { "path": str(path), "expected_sha256": expected_hash, "actual_sha256": actual_hash, } provenance_passed = provenance_passed and actual_hash == expected_hash source_paths = { "alignment_source_gmnet_sha256": AUDIT_ROOT / "source_snapshots/alignment_4a62/gmnet/models/gmnet.py", "audit_runtime_gmnet_sha256": Path( "/nfs/ywang29/GmNet/journal_exp/gmnet/models/gmnet.py" ), } for hash_key, path in source_paths.items(): actual_hash = file_sha256(path) if path.is_file() else None provenance_details[hash_key] = { "path": str(path), "expected_sha256": provenance.get(hash_key), "actual_sha256": actual_hash, } provenance_passed = provenance_passed and actual_hash == provenance.get(hash_key) expected_training_codes = { "B": provenance.get("audit_runtime_code_sha256"), "D": provenance.get("audit_runtime_code_sha256"), "S": provenance.get("alignment_training_code_sha256"), "C": provenance.get("alignment_training_code_sha256"), "SC": provenance.get("audit_runtime_code_sha256"), } actual_training_codes = { row.get("arm"): row.get("training_code_sha256") for row in manifest.get("arms", []) } provenance_passed = provenance_passed and actual_training_codes == expected_training_codes provenance_details["arm_training_code_sha256"] = actual_training_codes self.check( "manifest.code_provenance", provenance_passed, "training/runtime code manifests or source hashes no longer match", evidence=provenance_details, ) actual_dirs = {path.name for path in self.root.iterdir() if path.is_dir()} if self.root.is_dir() else set() self.check( "root.task_directories", set(TASK_ORDER).issubset(actual_dirs), "one or more required task directories are absent", missing=sorted(set(TASK_ORDER) - actual_dirs), ) self.validate_source_equivalence() def validate_source_equivalence(self) -> None: path = self.root / "alignment_source_equivalence.json" if not path.is_file(): self.check( "root.source_equivalence", False, "alignment_source_equivalence.json is required at the audit root", ) return try: evidence = load_json(path) provenance = self.manifest["code_provenance"] arms = evidence["arms"] by_arm = {row["arm"]: row for row in arms} passed = ( evidence.get("status") == "passed" and evidence.get("runtime", {}).get("torch") == FORMAL_TORCH and evidence.get("old_source", {}).get("sha256") == provenance["alignment_source_gmnet_sha256"] and evidence.get("new_source", {}).get("sha256") == provenance["audit_runtime_gmnet_sha256"] and set(by_arm) == {"B", "S", "C"} ) for arm in by_arm.values(): passed = passed and all( arm.get(field) is True for field in ( "forward_bitwise_equal", "input_gradient_bitwise_equal", "parameter_gradients_bitwise_equal", ) ) passed = passed and all(float(value) == 0.0 for value in arm["maximum_abs"].values()) passed = passed and arm.get("parameter_count") == 7_791_544 passed = passed and arm.get("state_tensor_count") == 365 semantics = evidence.get("explicit_stop_gradient_semantics", {}) passed = passed and all( semantics.get(key) is True for key in ( "baseline_matches_full_formula", "stop_gradient_matches_detached_formula", "stop_vs_baseline_derivative_differs", ) ) and float(semantics.get("maximum_abs_error", math.inf)) == 0.0 except Exception as error: self.check("root.source_equivalence", False, f"invalid source-equivalence evidence: {error}") return self.check( "root.source_equivalence", bool(passed), "formal torch-2.9 old/new source equivalence did not pass exactly", sha256=file_sha256(path), ) def validate_all_tasks(self) -> None: for task_id in TASK_ORDER: task = self.attempt( f"task.{task_id}.artifacts", lambda task_id=task_id: self.validate_task(task_id), ) if task is not None: self.tasks[task_id] = task def validate_task(self, task_id: str) -> TaskData: root = self.root / task_id arm, order = EXPECTED_TASK[task_id] missing = [name for name in REQUIRED_TASK_FILES if not (root / name).is_file()] if missing: raise ValueError(f"missing required task artifacts: {missing}") if (root / "COMPLETE").read_text(encoding="ascii") != "complete\n": raise ValueError("task COMPLETE marker is not canonical") self.verify_source_hashes(root) results = load_json(root / "results.json") required_result_keys = { "schema_version", "protocol_id", "task_id", "arm", "order", "status", "formal", "task_contract", "paths", "hashes", "checks", "accuracy", "spectral", "batch_pairing", "timestamps", "official_replay", "lowpass_fixtures", "numerical_self_tests", "task_frequency_summary", } missing_results = sorted(required_result_keys - set(results)) if missing_results: raise ValueError(f"results.json missing fields: {missing_results}") if ( results["schema_version"] != 1 or results["protocol_id"] != PROTOCOL_ID or results["task_id"] != task_id or results["arm"] != arm or results["order"] != order or results["status"] != "complete" or results["formal"] is not True ): raise ValueError("results.json task identity/status/formal contract mismatch") self.validate_task_hashes(task_id, root, results) self.validate_task_metadata(task_id, root, results) self.validate_environment(task_id, root, results) self.validate_task_checks(task_id, results) self.validate_numerical_evidence(task_id, results) self.validate_intervention(task_id, results) subset_rows, subset_hash = self.validate_subset(root / "subset_manifest.jsonl") if results["hashes"]["subset_manifest_sha256"] != subset_hash: raise ValueError("results subset_manifest_sha256 mismatch") accuracy = self.validate_accuracy_npz(task_id, root, results) spectral = self.validate_spectral_npz(task_id, root, subset_rows) accuracy_rows = self.validate_accuracy_csv(task_id, root, accuracy, results) block_summary = self.summarize_task_spectral(task_id, spectral) spectral_rows = self.validate_spectral_csv(task_id, root, block_summary) self.validate_stage_csv(task_id, root, block_summary) self.validate_task_transfer_npz(root, block_summary) pairing = self.validate_pairing(task_id, root, accuracy, results) return TaskData( task_id=task_id, arm=arm, order=order, root=root, results=results, accuracy=accuracy, spectral=spectral, accuracy_rows=accuracy_rows, spectral_rows=spectral_rows, block_summary=block_summary, pairing=pairing, ) def verify_source_hashes(self, task_root: Path) -> None: path = task_root / "source_artifacts.sha256" entries: dict[str, str] = {} for line_number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1): if not line or " " not in line: raise ValueError(f"malformed source_artifacts.sha256 line {line_number}") digest, relative = line.split(" ", 1) if not valid_sha256(digest) or not relative or relative in entries: raise ValueError(f"invalid or duplicate hash entry on line {line_number}") relative_path = Path(relative) if relative_path.is_absolute() or ".." in relative_path.parts: raise ValueError(f"unsafe artifact path: {relative}") target = (task_root / relative_path).resolve() if task_root.resolve() not in target.parents: raise ValueError(f"artifact hash escapes task root: {relative}") if not target.is_file() or file_sha256(target) != digest: raise ValueError(f"artifact hash mismatch: {relative}") entries[relative] = digest required_hashed = set(REQUIRED_TASK_FILES) - {"source_artifacts.sha256", "COMPLETE"} missing = sorted(required_hashed - set(entries)) if missing: raise ValueError(f"source_artifacts.sha256 omits required files: {missing}") def manifest_arm(self, arm: str) -> dict[str, Any]: rows = [row for row in self.manifest["arms"] if row["arm"] == arm] if len(rows) != 1: raise ValueError(f"manifest arm lookup is not unique: {arm}") return rows[0] def validate_task_hashes(self, task_id: str, root: Path, results: dict[str, Any]) -> None: arm, _ = EXPECTED_TASK[task_id] manifest_arm = self.manifest_arm(arm) hashes = results["hashes"] required = { "input_manifest_sha256", "protocol_sha256", "runner_sha256", "checkpoint_sha256", "config_source_sha256", "data_manifest_sha256", "subset_manifest_sha256", "order_indices_sha256", "per_image_accuracy_sha256", "per_image_spectral_sha256", } missing = sorted(required - set(hashes)) if missing: raise ValueError(f"results hashes missing fields: {missing}") if not all(valid_sha256(hashes[key]) for key in required): raise ValueError("results contains malformed SHA256 values") expected = { "input_manifest_sha256": file_sha256(self.manifest_path), "protocol_sha256": self.manifest["protocol"]["sha256"], "runner_sha256": file_sha256(self.runner_path), "checkpoint_sha256": manifest_arm["checkpoint_sha256"], "config_source_sha256": manifest_arm["config_source_sha256"], "data_manifest_sha256": self.manifest["dataset"]["evaluation_manifest_sha256"], "per_image_accuracy_sha256": file_sha256(root / "per_image_accuracy.npz"), "per_image_spectral_sha256": file_sha256(root / "per_image_spectral.npz"), } mismatches = { key: {"actual": hashes[key], "expected": value} for key, value in expected.items() if hashes[key] != value } if mismatches: raise ValueError(f"results hash contract mismatch: {mismatches}") def validate_environment(self, task_id: str, root: Path, results: dict[str, Any]) -> None: environment = load_json(root / "environment.json") required = { "schema_version", "protocol_id", "task_id", "python", "torch", "torchvision", "cuda", "cuda_available", "gpu_name", "device_count", "container_image", "deterministic_algorithms", "cudnn_benchmark", "cudnn_deterministic", "packages", "package_lock", "source_hashes", } missing = sorted(required - set(environment)) if missing: raise ValueError(f"environment.json missing fields: {missing}") expected_image = self.manifest["runtime"]["docker_image"] if not ( environment["schema_version"] == 1 and environment["protocol_id"] == PROTOCOL_ID and environment["task_id"] == task_id and environment["torch"] == FORMAL_TORCH and environment["torchvision"] == FORMAL_TORCHVISION and environment["cuda"] == FORMAL_CUDA and environment["cuda_available"] is True and environment["device_count"] == 1 and "A100" in str(environment["gpu_name"]) and environment["container_image"] == expected_image ): raise ValueError("formal environment identity mismatch") if results["checks"].get("environment_exact") is not True: raise ValueError("task did not assert environment_exact") package_lock = environment["package_lock"] if not isinstance(package_lock, dict) or set(package_lock) != { "format", "entry_count", "entries", "sha256", }: raise ValueError("environment package_lock schema changed") entries = package_lock["entries"] if ( package_lock["format"] != "pep503-normalized-project==version; UTF-8; LF; sorted" or not isinstance(entries, list) or not entries or not all(isinstance(entry, str) for entry in entries) or entries != sorted(set(entries)) or package_lock["entry_count"] != len(entries) ): raise ValueError("environment package_lock ordering/count contract failed") entry_pattern = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*==[^=\r\n]+$") if not all(entry_pattern.fullmatch(entry) for entry in entries): raise ValueError("environment package_lock has a non-PEP503 entry") serialization = "".join(f"{entry}\n" for entry in entries).encode("utf-8") if package_lock["sha256"] != bytes_sha256(serialization): raise ValueError("environment package_lock SHA256 mismatch") def validate_task_metadata( self, task_id: str, root: Path, results: dict[str, Any] ) -> None: arm, _ = EXPECTED_TASK[task_id] contract = self.manifest_arm(arm) protocol = load_json(root / "protocol.json") constants = protocol.get("constants", {}) if not ( protocol.get("schema_version") == 1 and protocol.get("protocol_id") == PROTOCOL_ID and protocol.get("protocol_path") == self.manifest["protocol"]["path"] and protocol.get("protocol_sha256") == self.manifest["protocol"]["sha256"] and protocol.get("input_manifest_sha256") == file_sha256(self.manifest_path) and constants.get("batch_size") == 256 and constants.get("high_frequency_split") == 0.5 and constants.get("lowpass_order") == 4 and constants.get("max_eval_samples") == NUM_IMAGES and constants.get("spectral_samples") == NUM_SPECTRAL_IMAGES and constants.get("radial_band_edges") == [0.0, 0.25, 0.5, 0.75, 1.0] and constants.get("lowpass_cutoffs") == self.manifest["runtime"]["lowpass_cutoffs"] ): raise ValueError( "task protocol.json differs from the frozen protocol binding or numerical constants" ) checkpoint = load_json(root / "checkpoint_manifest.json") expected_checkpoint = { "schema_version": 1, "protocol_id": PROTOCOL_ID, "task_id": task_id, "arm": arm, "checkpoint_sha256": contract["checkpoint_sha256"], "config_source_sha256": contract["config_source_sha256"], "official_results_sha256": contract["official_results_sha256"], "official_checks_sha256": contract["official_checks_sha256"], "official_per_sample_sha256": contract["official_per_sample_sha256"], } mismatches = { key: {"actual": checkpoint.get(key), "expected": value} for key, value in expected_checkpoint.items() if checkpoint.get(key) != value } if mismatches: raise ValueError(f"checkpoint manifest identity mismatch: {mismatches}") topology = checkpoint.get("topology", {}) if not ( topology.get("parameter_count") == self.manifest["topology"]["parameter_count"] and topology.get("state_tensor_count") == self.manifest["topology"]["state_tensor_count"] and topology.get("model_state_schema_sha256") == self.manifest["topology"]["model_state_schema_sha256"] ): raise ValueError("checkpoint topology/state schema mismatch") artifacts = load_json(root / "artifacts.json") hashes = artifacts.get("sha256") if artifacts.get("schema_version") != 1 or not isinstance(hashes, dict): raise ValueError("artifacts.json schema is invalid") for name, digest in hashes.items(): if not isinstance(name, str) or not valid_sha256(digest): raise ValueError("artifacts.json contains malformed entries") path = root / name if not path.is_file() or file_sha256(path) != digest: raise ValueError(f"artifacts.json hash mismatch: {name}") data = load_json(root / "data_manifest.json") dataset_contract = self.manifest["dataset"] expected_data = { "samples": NUM_IMAGES, "num_classes": NUM_CLASSES, "class_to_idx_sha256": dataset_contract["class_to_idx_sha256"], "sample_index_sha256": dataset_contract["val_sample_index_sha256"], "sampled_content_sha256": dataset_contract["val_sampled_content_sha256"], "sampled_content_samples": dataset_contract["val_sampled_content_samples"], "evaluation_manifest_sha256": dataset_contract["evaluation_manifest_sha256"], } data_mismatches = { key: {"actual": data.get(key), "expected": value} for key, value in expected_data.items() if data.get(key) != value } if data_mismatches: raise ValueError(f"data_manifest.json identity mismatch: {data_mismatches}") provenance = load_json(root / "source_provenance.json") required_provenance = { "runner", "protocol", "input_manifest", "checkpoint", "config_source", "official_results", "official_checks", "official_per_sample", "gmnet_model", } if set(provenance) != required_provenance: raise ValueError("source_provenance.json key set changed") for name, row in provenance.items(): if not isinstance(row, dict) or not valid_sha256(row.get("sha256")): raise ValueError(f"source provenance entry {name} is malformed") source = Path(str(row.get("path", ""))).resolve() if not source.is_file() or file_sha256(source) != row["sha256"]: raise ValueError(f"source provenance entry {name} no longer verifies") @staticmethod def validate_task_checks(task_id: str, results: dict[str, Any]) -> None: required_true = ( "environment_exact", "subset_valid", "blocks_complete", "fft_dct_self_tests_passed", "gate_reconstruction_passed", "mapping_passed", ) missing = [key for key in required_true if results["checks"].get(key) is not True] if missing: raise ValueError(f"task checks are absent or false: {missing}") replay = results["checks"].get("official_replay_discrete_exact") if task_id in {"D_order1", "D_order2"}: if not isinstance(replay, bool): raise ValueError("D order probes must record a boolean replay comparison") elif replay is not True: raise ValueError("canonical arms and B_order1 must exactly replay official discrete outputs") @staticmethod def validate_numerical_evidence(task_id: str, results: dict[str, Any]) -> None: tests = results["numerical_self_tests"] if tests.get("passed") is not True: raise ValueError("registered numerical self-tests did not pass") for basis in BASES: row = tests.get(basis, {}) if not ( row.get("passed") is True and float(row.get("constant_gate_m_off", math.inf)) <= 1e-6 and float(row.get("parseval_relative_error", math.inf)) <= 1e-10 and float(row.get("reconstruction_relative_l2", math.inf)) <= 1e-10 ): raise ValueError(f"{basis} numerical transform self-test exceeded tolerance") lowpass = tests.get("lowpass", {}) if not ( lowpass.get("passed") is True and float(lowpass.get("relative_imaginary_l2", math.inf)) <= 1e-10 and valid_sha256(lowpass.get("fixture_sha256")) ): raise ValueError("low-pass numerical self-test failed") spectral_tests = results["spectral"].get("self_tests", {}) if int(spectral_tests.get("gate_reconstruction_batches_min", 0)) <= 0: raise ValueError("gate reconstruction was not checked on every block") for basis in BASES: if not ( float( spectral_tests.get(f"{basis}_reconstruction_relative_l2_max", math.inf) ) <= 1e-10 and float( spectral_tests.get(f"{basis}_parseval_relative_error_max", math.inf) ) <= 1e-10 ): raise ValueError(f"{basis} observed-feature transform checks exceeded tolerance") fixtures = results["lowpass_fixtures"] expected_fixture_names = set(EXPECTED_CONDITIONS[1:]) if task_id in CANONICAL_ARMS else set() if set(fixtures) != expected_fixture_names: raise ValueError("low-pass fixture condition coverage mismatch") for name, row in fixtures.items(): if not ( float(row.get("relative_imaginary_l2", math.inf)) <= 1e-10 and valid_sha256(row.get("first_image_sha256")) ): raise ValueError(f"low-pass fixture {name} failed") def validate_intervention(self, task_id: str, results: dict[str, Any]) -> None: arm, _ = EXPECTED_TASK[task_id] intervention = results["task_contract"].get("intervention") if not isinstance(intervention, dict): raise ValueError("task_contract.intervention must be an object") required = {"name", "channel_permutation_manifest_sha256", "gate_input_semantics"} if not required.issubset(intervention): raise ValueError("task_contract.intervention is missing frozen fields") if intervention["name"] != self.manifest_arm(arm)["gate_intervention"]: raise ValueError("intervention name mismatch") expected_perm = FROZEN_CHANNEL_PERMUTATION_SHA256 if arm in {"C", "SC"} else None if intervention["channel_permutation_manifest_sha256"] != expected_perm: raise ValueError("channel permutation manifest mismatch") if not isinstance(intervention["gate_input_semantics"], str) or not intervention["gate_input_semantics"]: raise ValueError("gate_input_semantics must be nonempty") def validate_subset(self, path: Path) -> tuple[list[dict[str, Any]], str]: rows: list[dict[str, Any]] = [] for line_number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1): try: row = json.loads( line, parse_constant=_reject_constant, object_pairs_hook=_object_no_duplicates, ) except Exception as error: raise ValueError(f"invalid subset JSONL line {line_number}: {error}") from error required = { "canonical_index", "relative_path", "class_id", "selection_sha256", "within_class_rank", "selection_kind", } if not isinstance(row, dict) or not required.issubset(row): raise ValueError(f"subset line {line_number} is missing fields") rows.append(row) if len(rows) != NUM_SPECTRAL_IMAGES: raise ValueError(f"spectral subset has {len(rows)} rows") indices = [row["canonical_index"] for row in rows] if len(set(indices)) != NUM_SPECTRAL_IMAGES or not all( isinstance(index, int) and 0 <= index < NUM_IMAGES for index in indices ): raise ValueError("spectral subset canonical indices are invalid or duplicated") histogram = Counter(row["class_id"] for row in rows) if set(histogram) != set(range(NUM_CLASSES)): raise ValueError("spectral subset does not cover all ImageNet classes") count_histogram = Counter(histogram.values()) if count_histogram != Counter({4: 904, 5: 96}): raise ValueError(f"spectral subset class balance mismatch: {count_histogram}") prefix = b"gmnet-e4-spectral-v1\0" paths: set[str] = set() ranks_by_class: dict[int, set[int]] = {class_id: set() for class_id in range(NUM_CLASSES)} extra_classes: set[int] = set() for row in rows: relative_path = row["relative_path"] if not isinstance(relative_path, str) or not relative_path or relative_path in paths: raise ValueError("spectral subset relative paths are invalid or duplicated") paths.add(relative_path) expected_hash = hashlib.sha256(prefix + relative_path.encode("utf-8")).hexdigest() if row["selection_sha256"] != expected_hash: raise ValueError("spectral subset selection hash mismatch") rank = row["within_class_rank"] if not isinstance(rank, int) or rank not in range(1, 6): raise ValueError("spectral subset rank is outside 1..5") expected_kind = "base_four" if rank <= 4 else "extra_fifth" if row["selection_kind"] != expected_kind: raise ValueError("spectral subset selection_kind disagrees with rank") ranks_by_class[int(row["class_id"])].add(rank) if rank == 5: extra_classes.add(int(row["class_id"])) if any(ranks_by_class[class_id] != set(range(1, histogram[class_id] + 1)) for class_id in range(NUM_CLASSES)): raise ValueError("spectral subset within-class ranks are incomplete or duplicated") extra_prefix = b"gmnet-e4-spectral-extra-v1\0" expected_extra = set( sorted( range(NUM_CLASSES), key=lambda class_id: ( hashlib.sha256(extra_prefix + f"{class_id:04d}".encode("ascii")).digest(), class_id, ), )[:96] ) if extra_classes != expected_extra: raise ValueError("spectral subset extra-fifth class selection changed") actual_hash = file_sha256(path) frozen = self.manifest["spectral_subset"] frozen_path = Path(frozen["artifact_path"]).resolve() if actual_hash != frozen["sha256"] or file_sha256(frozen_path) != frozen["sha256"]: raise ValueError("task subset differs from the input-manifest frozen subset") if path.read_bytes() != frozen_path.read_bytes(): raise ValueError("task subset bytes differ from the frozen shared artifact") return rows, actual_hash def validate_accuracy_npz( self, task_id: str, root: Path, results: dict[str, Any] ) -> dict[str, np.ndarray]: required = ( "evaluation_position", "canonical_index", "target", "condition_names", "top1_correct", "top5_correct", "nll", "prediction", "confidence", ) arrays = load_npz(root / "per_image_accuracy.npz", required) conditions = unicode_tuple(arrays["condition_names"], "condition_names") expected_conditions = EXPECTED_CONDITIONS if task_id in CANONICAL_ARMS else ("unfiltered",) if conditions != expected_conditions: raise ValueError(f"condition_names {conditions} != {expected_conditions}") condition_count = len(conditions) vector_fields = { "evaluation_position": "int64", "canonical_index": "int64", "target": "int16", } for name, dtype in vector_fields.items(): require_shape(arrays[name], (NUM_IMAGES,), name) require_dtype(arrays[name], dtype, name) matrix_fields = { "top1_correct": "bool", "top5_correct": "bool", "nll": "float32", "prediction": "int16", "confidence": "float32", } for name, dtype in matrix_fields.items(): require_shape(arrays[name], (condition_count, NUM_IMAGES), name) require_dtype(arrays[name], dtype, name) if not np.array_equal(arrays["evaluation_position"], np.arange(NUM_IMAGES, dtype=np.int64)): raise ValueError("evaluation_position is not exactly 0..49999") expected_order = canonical_order(EXPECTED_TASK[task_id][1]) if not np.array_equal(arrays["canonical_index"], expected_order): raise ValueError("canonical_index does not match the registered dataset order") if results["hashes"]["order_indices_sha256"] != int64_sha256(expected_order): raise ValueError("order_indices_sha256 does not bind the registered order") if not np.array_equal(np.sort(arrays["canonical_index"]), np.arange(NUM_IMAGES)): raise ValueError("accuracy artifact is not a permutation of 50,000 canonical indices") if np.any(arrays["target"] < 0) or np.any(arrays["target"] >= NUM_CLASSES): raise ValueError("accuracy targets are outside 0..999") if np.any(arrays["prediction"] < 0) or np.any(arrays["prediction"] >= NUM_CLASSES): raise ValueError("accuracy predictions are outside 0..999") if not np.all(np.isfinite(arrays["nll"])) or np.any(arrays["nll"] < 0): raise ValueError("accuracy NLL contains invalid values") if not np.all(np.isfinite(arrays["confidence"])) or np.any(arrays["confidence"] < 0) or np.any(arrays["confidence"] > 1): raise ValueError("accuracy confidence contains invalid values") arm, order = EXPECTED_TASK[task_id] if order == "canonical" or task_id == "B_order1": self.validate_official_per_sample(task_id, arrays) manifest_arm = self.manifest_arm(arm) if int(arrays["top1_correct"][0].sum()) != manifest_arm["official_top1_correct"]: raise ValueError("unfiltered Top-1 integer count differs from the official certificate") if int(arrays["top5_correct"][0].sum()) != manifest_arm["official_top5_correct"]: raise ValueError("unfiltered Top-5 integer count differs from the official certificate") return arrays def validate_official_per_sample( self, task_id: str, arrays: dict[str, np.ndarray] ) -> None: arm, _ = EXPECTED_TASK[task_id] contract = self.manifest_arm(arm) official_path = Path(contract["official_per_sample"]).resolve() if file_sha256(official_path) != contract["official_per_sample_sha256"]: raise ValueError("official per-sample artifact hash mismatch") order = np.argsort(arrays["canonical_index"]) exact = { "sample_index": arrays["canonical_index"][order], "target": arrays["target"][order], "prediction": arrays["prediction"][0, order], "correct": arrays["top1_correct"][0, order], "top5_correct": arrays["top5_correct"][0, order], } with np.load(official_path, allow_pickle=False) as official: for field, current in exact.items(): if not np.array_equal(official[field], current): raise ValueError(f"official per-sample discrete replay differs in {field}") confidence_max_abs = float( np.max( np.abs( official["confidence"].astype(np.float64) - arrays["confidence"][0, order].astype(np.float64) ) ) ) nll_max_abs = float( np.max( np.abs( official["nll"].astype(np.float64) - arrays["nll"][0, order].astype(np.float64) ) ) ) self.checks[f"task.{task_id}.official_float_drift"] = { "passed": True, "message": "recorded; discrete replay is exact", "details": { "confidence_max_abs": confidence_max_abs, "nll_max_abs": nll_max_abs, }, } def recompute_accuracy_rows( self, task_id: str, arrays: dict[str, np.ndarray] ) -> list[dict[str, Any]]: arm, order = EXPECTED_TASK[task_id] clean_top1 = float(arrays["top1_correct"][0].mean(dtype=np.float64) * 100.0) clean_top5 = float(arrays["top5_correct"][0].mean(dtype=np.float64) * 100.0) rows: list[dict[str, Any]] = [] for condition_index, condition in enumerate(arrays["condition_names"].tolist()): correct = arrays["top1_correct"][condition_index] top5_correct = arrays["top5_correct"][condition_index] top1 = float(correct.mean(dtype=np.float64) * 100.0) top5 = float(top5_correct.mean(dtype=np.float64) * 100.0) cutoff = "" if condition == "unfiltered" else float(condition.removeprefix("lowpass_")) rows.append( { "task_id": task_id, "arm": arm, "order": order, "condition": str(condition), "cutoff": cutoff, "samples": NUM_IMAGES, "top1_correct": int(correct.sum()), "top5_correct": int(top5_correct.sum()), "top1": top1, "top5": top5, "nll": float(arrays["nll"][condition_index].mean(dtype=np.float64)), "ece": ece_15(arrays["confidence"][condition_index], correct), "top1_drop": clean_top1 - top1, "top5_drop": clean_top5 - top5, } ) return rows def validate_accuracy_csv( self, task_id: str, root: Path, arrays: dict[str, np.ndarray], results: dict[str, Any], ) -> list[dict[str, Any]]: observed = read_csv(root / "accuracy_by_condition.csv", ACCURACY_COLUMNS) expected = self.recompute_accuracy_rows(task_id, arrays) if len(observed) != len(expected): raise ValueError("accuracy CSV row count mismatch") for row_index, (actual, target) in enumerate(zip(observed, expected, strict=True)): for key in ("task_id", "arm", "order", "condition"): if actual[key] != str(target[key]): raise ValueError(f"accuracy CSV row {row_index} differs in {key}") for key in ("samples", "top1_correct", "top5_correct"): if int(actual[key]) != int(target[key]): raise ValueError(f"accuracy CSV row {row_index} differs in {key}") for key in ("top1", "top5", "nll", "ece", "top1_drop", "top5_drop"): if not math.isclose(float(actual[key]), float(target[key]), rel_tol=1e-10, abs_tol=1e-10): raise ValueError(f"accuracy CSV row {row_index} differs in {key}") expected_cutoff = target["cutoff"] if expected_cutoff == "": if actual["cutoff"] != "": raise ValueError("unfiltered cutoff cell must be empty") elif not math.isclose(float(actual["cutoff"]), float(expected_cutoff), abs_tol=1e-15): raise ValueError("accuracy CSV cutoff mismatch") summary = results["accuracy"] if set(summary) != set(arrays["condition_names"].tolist()): raise ValueError("results.accuracy condition coverage mismatch") key_map = { "samples": "samples", "top1_correct": "top1_correct", "top5_correct_count": "top5_correct", "top1": "top1", "top5": "top5", "nll": "nll", "ece": "ece", "top1_drop_from_unfiltered": "top1_drop", "top5_drop_from_unfiltered": "top5_drop", } by_condition = {row["condition"]: row for row in expected} for condition, row in summary.items(): target = by_condition[condition] for source_key, target_key in key_map.items(): if source_key not in row: raise ValueError(f"results.accuracy.{condition} misses {source_key}") left = row[source_key] right = target[target_key] if isinstance(right, int): if int(left) != right: raise ValueError(f"results.accuracy.{condition}.{source_key} mismatch") elif not math.isclose(float(left), float(right), rel_tol=1e-10, abs_tol=1e-10): raise ValueError(f"results.accuracy.{condition}.{source_key} mismatch") frequency = results["task_frequency_summary"] if task_id not in CANONICAL_ARMS: if frequency is not None: raise ValueError("order probes must not emit a low-pass task-frequency AUC") else: if not isinstance(frequency, dict): raise ValueError("canonical arm is missing task_frequency_summary") cutoffs = np.asarray(self.manifest["runtime"]["lowpass_cutoffs"], dtype=np.float64) log_cutoffs = np.log2(cutoffs) top1_values = np.asarray( [by_condition[f"lowpass_{cutoff:g}"]["top1"] for cutoff in cutoffs], dtype=np.float64, ) top5_values = np.asarray( [by_condition[f"lowpass_{cutoff:g}"]["top5"] for cutoff in cutoffs], dtype=np.float64, ) span = float(log_cutoffs[-1] - log_cutoffs[0]) top1_auc = float(np.trapezoid(top1_values, log_cutoffs)) top5_auc = float(np.trapezoid(top5_values, log_cutoffs)) expected_frequency: dict[str, Any] = { "abscissa": "log2_cutoff", "cutoffs": cutoffs.tolist(), "top1_trapezoidal_auc": top1_auc, "top5_trapezoidal_auc": top5_auc, "top1_auc_normalized_by_log_span": top1_auc / span, "top5_auc_normalized_by_log_span": top5_auc / span, } if frequency.get("abscissa") != expected_frequency["abscissa"] or frequency.get( "cutoffs" ) != expected_frequency["cutoffs"]: raise ValueError("task-frequency abscissa/cutoff grid mismatch") for key in ( "top1_trapezoidal_auc", "top5_trapezoidal_auc", "top1_auc_normalized_by_log_span", "top5_auc_normalized_by_log_span", ): if not math.isclose( float(frequency.get(key, math.nan)), float(expected_frequency[key]), rel_tol=1e-12, abs_tol=1e-12, ): raise ValueError(f"task-frequency summary differs in {key}") return expected def validate_spectral_npz( self, task_id: str, root: Path, subset_rows: list[dict[str, Any]] ) -> dict[str, np.ndarray]: required = [ "canonical_index", "class_id", "signal_names", "coherence_names", "block_global_index", "block_stage", "block_within_stage", "signal_centered_rms", "signal_log10_centered_energy", "signal_log10_centered_energy_valid_channels", "signal_noncentered_rms", "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", "coherence_mean", "coherence_valid_channels", "projection_residual", "projection_residual_conditional", "projection_residual_conditional_valid_channels", "projection_suppressed_fraction", "constant_gate_fraction", "constant_gate_count", ] for basis in BASES: required.extend( [ f"{basis}_psd_high_fraction", f"{basis}_psd_centroid", f"{basis}_psd_entropy", f"{basis}_psd_valid_channels", f"{basis}_jsd_xy", f"{basis}_jsd_valid_channels", f"{basis}_transfer_primary", f"{basis}_transfer_conditional", f"{basis}_transfer_source_valid", f"{basis}_transfer_source_suppressed", f"{basis}_output_minus_carrier_high_fraction", f"{basis}_output_minus_carrier_centroid", f"{basis}_output_minus_carrier_valid_channels", ] ) arrays = load_npz(root / "per_image_spectral.npz", required) if unicode_tuple(arrays["signal_names"], "signal_names") != SIGNAL_NAMES: raise ValueError("spectral signal_names changed") if unicode_tuple(arrays["coherence_names"], "coherence_names") != COHERENCE_NAMES: raise ValueError("spectral coherence_names changed") metadata = { "canonical_index": ((NUM_SPECTRAL_IMAGES,), "int64"), "class_id": ((NUM_SPECTRAL_IMAGES,), "int16"), "block_global_index": ((NUM_BLOCKS,), "int8"), "block_stage": ((NUM_BLOCKS,), "int8"), "block_within_stage": ((NUM_BLOCKS,), "int8"), } for name, (shape, dtype) in metadata.items(): require_shape(arrays[name], shape, name) require_dtype(arrays[name], dtype, name) expected_subset_indices = np.asarray( [row["canonical_index"] for row in subset_rows], dtype=np.int64 ) expected_subset_classes = np.asarray([row["class_id"] for row in subset_rows], dtype=np.int16) if not np.array_equal(arrays["canonical_index"], expected_subset_indices): raise ValueError("spectral canonical indices differ from subset_manifest.jsonl") if not np.array_equal(arrays["class_id"], expected_subset_classes): raise ValueError("spectral class IDs differ from subset_manifest.jsonl") if not np.array_equal(arrays["block_global_index"], np.arange(NUM_BLOCKS, dtype=np.int8)): raise ValueError("spectral global block sequence changed") if tuple(arrays["block_stage"].tolist()) != EXPECTED_STAGES: raise ValueError("spectral 1-based stage sequence changed") if tuple(arrays["block_within_stage"].tolist()) != EXPECTED_STAGE_BLOCKS: raise ValueError("spectral 1-based block-within-stage sequence changed") signal_shape = (NUM_SPECTRAL_IMAGES, NUM_BLOCKS, len(SIGNAL_NAMES)) block_shape = (NUM_SPECTRAL_IMAGES, NUM_BLOCKS) for name in ( "signal_centered_rms", "signal_log10_centered_energy", "signal_noncentered_rms", ): require_shape(arrays[name], signal_shape, name) require_dtype(arrays[name], "float64", name) require_shape( arrays["signal_log10_centered_energy_valid_channels"], signal_shape, "signal_log10_centered_energy_valid_channels", ) require_dtype( arrays["signal_log10_centered_energy_valid_channels"], "int32", "signal_log10_centered_energy_valid_channels", ) for name in ( "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", "projection_residual", "projection_residual_conditional", "projection_suppressed_fraction", "constant_gate_fraction", ): require_shape(arrays[name], block_shape, name) require_dtype(arrays[name], "float64", name) for name in ( "projection_residual_conditional_valid_channels", "constant_gate_count", ): require_shape(arrays[name], block_shape, name) require_dtype(arrays[name], "int32", name) require_shape(arrays["coherence_mean"], block_shape + (2,), "coherence_mean") require_dtype(arrays["coherence_mean"], "float64", "coherence_mean") require_shape(arrays["coherence_valid_channels"], block_shape + (2,), "coherence_valid_channels") require_dtype(arrays["coherence_valid_channels"], "int32", "coherence_valid_channels") for basis in BASES: for metric in ("high_fraction", "centroid", "entropy"): name = f"{basis}_psd_{metric}" require_shape(arrays[name], signal_shape, name) require_dtype(arrays[name], "float64", name) valid_name = f"{basis}_psd_valid_channels" require_shape(arrays[valid_name], signal_shape, valid_name) require_dtype(arrays[valid_name], "int32", valid_name) jsd_name = f"{basis}_jsd_xy" require_shape(arrays[jsd_name], block_shape, jsd_name) require_dtype(arrays[jsd_name], "float64", jsd_name) jsd_valid_name = f"{basis}_jsd_valid_channels" require_shape(arrays[jsd_valid_name], block_shape, jsd_valid_name) require_dtype(arrays[jsd_valid_name], "int32", jsd_valid_name) for kind in ("primary", "conditional"): name = f"{basis}_transfer_{kind}" require_shape(arrays[name], block_shape + (NUM_BANDS, NUM_BANDS), name) require_dtype(arrays[name], "float64", name) for kind in ("valid", "suppressed"): name = f"{basis}_transfer_source_{kind}" require_shape(arrays[name], block_shape + (NUM_BANDS,), name) require_dtype(arrays[name], "int32", name) for metric in ("high_fraction", "centroid"): name = f"{basis}_output_minus_carrier_{metric}" require_shape(arrays[name], block_shape, name) require_dtype(arrays[name], "float64", name) paired_valid_name = f"{basis}_output_minus_carrier_valid_channels" require_shape(arrays[paired_valid_name], block_shape, paired_valid_name) require_dtype(arrays[paired_valid_name], "int32", paired_valid_name) self.validate_spectral_values(task_id, arrays) return arrays def validate_spectral_values(self, task_id: str, arrays: dict[str, np.ndarray]) -> None: class_ids = arrays["class_id"] if set(class_ids.tolist()) != set(range(NUM_CLASSES)): raise ValueError("spectral class IDs do not cover 0..999") for name, array in arrays.items(): if array.dtype.kind == "f" and np.any(np.isinf(array)): raise ValueError(f"spectral array {name} contains Inf") for name in ("signal_centered_rms", "signal_noncentered_rms"): values = arrays[name] if not complete_nonnegative_rms(values): raise ValueError(f"{name} must be complete, finite, and nonnegative") channels = np.asarray( [EXPANDED_CHANNELS_BY_STAGE[stage - 1] for stage in arrays["block_stage"]], dtype=np.int32, ) signal_channels = np.stack( [ channels, channels, channels, channels, np.asarray( [RESIDUAL_CHANNELS_BY_STAGE[stage - 1] for stage in arrays["block_stage"]], dtype=np.int32, ), ], axis=1, ) log_valid = arrays["signal_log10_centered_energy_valid_channels"] log_values = arrays["signal_log10_centered_energy"] if np.any(log_valid < 0) or np.any(log_valid > signal_channels[None, :, :]): raise ValueError("raw log-energy valid-channel counts are impossible") if np.any(~np.isfinite(log_values[log_valid > 0])) or np.any( ~np.isnan(log_values[log_valid == 0]) ): raise ValueError("raw log-energy NaN/count convention violated") for basis in BASES: valid = arrays[f"{basis}_psd_valid_channels"] if np.any(valid < 0) or np.any(valid > signal_channels[None, :, :]): raise ValueError(f"{basis} PSD valid-channel counts are impossible") for metric in ("high_fraction", "centroid", "entropy"): values = arrays[f"{basis}_psd_{metric}"] if np.any(~np.isfinite(values[valid > 0])) or np.any(~np.isnan(values[valid == 0])): raise ValueError(f"{basis} PSD {metric} NaN/count convention violated") if np.any(values[valid > 0] < -1e-12) or np.any(values[valid > 0] > 1.0 + 1e-12): raise ValueError(f"{basis} PSD {metric} outside normalized bounds") carrier_valid = valid[:, :, SIGNAL_NAMES.index("carrier")] output_valid = valid[:, :, SIGNAL_NAMES.index("gated_product")] paired_valid = arrays[f"{basis}_output_minus_carrier_valid_channels"] if np.any(paired_valid < 0) or np.any(paired_valid > carrier_valid) or np.any( paired_valid > output_valid ): raise ValueError(f"{basis} paired output-minus-carrier counts are impossible") for name in ( f"{basis}_output_minus_carrier_high_fraction", f"{basis}_output_minus_carrier_centroid", ): values = arrays[name] if np.any(~np.isfinite(values[paired_valid > 0])) or np.any( ~np.isnan(values[paired_valid == 0]) ): raise ValueError(f"{name} paired-valid NaN/count convention violated") jsd_valid = arrays[f"{basis}_jsd_valid_channels"] if np.any(jsd_valid < 0) or np.any(jsd_valid > carrier_valid) or np.any( jsd_valid > output_valid ): raise ValueError(f"{basis} JSD valid-channel counts are impossible") jsd = arrays[f"{basis}_jsd_xy"] if np.any(~np.isfinite(jsd[jsd_valid > 0])) or np.any( ~np.isnan(jsd[jsd_valid == 0]) ): raise ValueError(f"{basis} JSD NaN/count convention violated") invalid_fraction = 1.0 - carrier_valid.sum(axis=0, dtype=np.float64) / ( NUM_SPECTRAL_IMAGES * channels ) if np.any(invalid_fraction >= 0.01): raise ValueError(f"{basis} carrier invalid fraction is not below 1%") source_valid = arrays[f"{basis}_transfer_source_valid"] source_suppressed = arrays[f"{basis}_transfer_source_suppressed"] if np.any(source_valid < 0) or np.any(source_valid > channels[None, :, None]): raise ValueError(f"{basis} source-valid counts are impossible") if np.any(source_suppressed < 0) or np.any(source_suppressed > source_valid): raise ValueError(f"{basis} source-suppressed counts are impossible") source_invalid_fraction = 1.0 - source_valid.sum(axis=0, dtype=np.float64) / ( NUM_SPECTRAL_IMAGES * channels[:, None] ) if np.any(source_invalid_fraction >= 0.01): raise ValueError(f"{basis} source invalid fraction is not below 1%") primary = arrays[f"{basis}_transfer_primary"] conditional = arrays[f"{basis}_transfer_conditional"] for image in range(NUM_SPECTRAL_IMAGES): for block in range(NUM_BLOCKS): for source in range(NUM_BANDS): count = int(source_valid[image, block, source]) suppressed = int(source_suppressed[image, block, source]) p_row = primary[image, block, source] c_row = conditional[image, block, source] if count == 0: if not np.all(np.isnan(p_row)) or not np.all(np.isnan(c_row)): raise ValueError(f"{basis} undefined transfer row is not NaN") continue if not np.all(np.isfinite(p_row)) or np.any(p_row < -1e-12) or np.any(p_row > 1 + 1e-12): raise ValueError(f"{basis} primary transfer row is invalid") expected_primary_sum = (count - suppressed) / count if not math.isclose(float(p_row.sum()), expected_primary_sum, abs_tol=1e-9): raise ValueError(f"{basis} primary transfer row normalization failed") if count == suppressed: if not np.all(np.isnan(c_row)): raise ValueError(f"{basis} suppressed conditional row is not NaN") elif not np.all(np.isfinite(c_row)) or not math.isclose(float(c_row.sum()), 1.0, abs_tol=1e-9): raise ValueError(f"{basis} conditional transfer row normalization failed") for name in ("gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction"): if not np.all(np.isfinite(arrays[name])): raise ValueError(f"{name} contains undefined values") for name in ( "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", "constant_gate_fraction", ): if np.any(arrays[name] < -1e-12) or np.any(arrays[name] > 1 + 1e-12): raise ValueError(f"{name} is outside [0,1]") if np.any(arrays["gate_cv"] < 0): raise ValueError("gate_cv is negative") if np.any(arrays["gate_mean"] < 0): raise ValueError("gate_mean is negative") coherence_valid = arrays["coherence_valid_channels"] coherence = arrays["coherence_mean"] if np.any(coherence_valid < 0) or np.any(coherence_valid > channels[None, :, None]): raise ValueError("coherence valid counts are impossible") if np.any(~np.isfinite(coherence[coherence_valid > 0])) or np.any(~np.isnan(coherence[coherence_valid == 0])): raise ValueError("coherence NaN/count convention violated") if np.any(np.abs(coherence[coherence_valid > 0]) > 1 + 1e-10): raise ValueError("coherence is outside [-1,1]") arm, _ = EXPECTED_TASK[task_id] if arm in {"B", "S"}: for block in range(NUM_BLOCKS): rho = class_equal_mean(coherence[:, block, 0], class_ids) if abs(rho - 1.0) > 1e-7: raise ValueError(f"{arm} rho_used differs from one at block {block}") projection_valid = arrays["fft_psd_valid_channels"][ :, :, SIGNAL_NAMES.index("carrier") ] for name in ("projection_residual", "projection_suppressed_fraction"): values = arrays[name] if ( np.any(~np.isfinite(values[projection_valid > 0])) or np.any(~np.isnan(values[projection_valid == 0])) or np.any(values[projection_valid > 0] < -1e-12) or np.any(values[projection_valid > 0] > 1 + 1e-12) ): raise ValueError(f"{name} NaN/count/bound convention is invalid") conditional_valid = arrays["projection_residual_conditional_valid_channels"] conditional = arrays["projection_residual_conditional"] if np.any(conditional_valid < 0) or np.any(conditional_valid > projection_valid): raise ValueError("conditional M_res valid-channel counts are impossible") if ( np.any(~np.isfinite(conditional[conditional_valid > 0])) or np.any(~np.isnan(conditional[conditional_valid == 0])) or np.any(conditional[conditional_valid > 0] < -1e-12) or np.any(conditional[conditional_valid > 0] > 1 + 1e-12) ): raise ValueError("conditional M_res NaN/count/bound convention is invalid") constant_count = arrays["constant_gate_count"] if np.any(constant_count < 0) or np.any(constant_count > channels[None, :]): raise ValueError("constant-gate counts are impossible") expected_constant_fraction = constant_count.astype(np.float64) / channels[None, :] if not np.allclose( arrays["constant_gate_fraction"], expected_constant_fraction, rtol=0.0, atol=1e-12, ): raise ValueError("constant-gate fractions differ from counts/channel totals") def summarize_task_spectral( self, task_id: str, arrays: dict[str, np.ndarray] ) -> dict[tuple[str, int, str], dict[str, Any]]: arm, order = EXPECTED_TASK[task_id] class_ids = arrays["class_id"] distance = np.abs( np.asarray([0.125, 0.375, 0.625, 0.875])[:, None] - np.asarray([0.125, 0.375, 0.625, 0.875])[None, :] ) result: dict[tuple[str, int, str], dict[str, Any]] = {} for basis in BASES: primary = arrays[f"{basis}_transfer_primary"] source_valid = arrays[f"{basis}_transfer_source_valid"] source_suppressed = arrays[f"{basis}_transfer_source_suppressed"] for block_index in range(NUM_BLOCKS): primary_mean = class_equal_array(primary[:, block_index], class_ids) offdiag = primary_mean.copy() np.fill_diagonal(offdiag, 0.0) source_valid_per_image = source_valid[:, block_index].sum( axis=1, dtype=np.float64 ) source_suppressed_per_image = source_suppressed[:, block_index].sum( axis=1, dtype=np.float64 ) channel_count = EXPANDED_CHANNELS_BY_STAGE[ int(arrays["block_stage"][block_index]) - 1 ] source_valid_fraction_per_image = source_valid_per_image / ( NUM_BANDS * channel_count ) with np.errstate(divide="ignore", invalid="ignore"): source_suppressed_fraction_per_image = np.where( source_valid_per_image > 0, source_suppressed_per_image / source_valid_per_image, np.nan, ) operator = { "rho_used": optional_class_equal_mean( arrays["coherence_mean"][:, block_index, 0], class_ids ), "rho_response": optional_class_equal_mean( arrays["coherence_mean"][:, block_index, 1], class_ids ), "jsd": optional_image_equal_mean( arrays[f"{basis}_jsd_xy"][:, block_index] ), "jsd_valid_channels": int( arrays[f"{basis}_jsd_valid_channels"][:, block_index].sum( dtype=np.int64 ) ), "m_res": image_equal_mean(arrays["projection_residual"][:, block_index]), "m_res_conditional": optional_image_equal_mean( arrays["projection_residual_conditional"][:, block_index] ), "m_res_conditional_valid_channels": int( arrays["projection_residual_conditional_valid_channels"][ :, block_index ].sum(dtype=np.int64) ), "suppressed_fraction": image_equal_mean( arrays["projection_suppressed_fraction"][:, block_index] ), "m_off": float(offdiag.sum(dtype=np.float64) / NUM_BANDS), "m_disp": float((primary_mean * distance).sum(dtype=np.float64) / NUM_BANDS), "source_valid": int(source_valid[:, block_index].sum(dtype=np.int64)), "source_suppressed": int( source_suppressed[:, block_index].sum(dtype=np.int64) ), "transfer_primary": primary_mean, "transfer_conditional": optional_class_equal_array( arrays[f"{basis}_transfer_conditional"][:, block_index], class_ids ), "transfer_source_valid": source_valid[:, block_index].sum( axis=0, dtype=np.int64 ), "transfer_source_suppressed": source_suppressed[:, block_index].sum( axis=0, dtype=np.int64 ), "source_valid_fraction": class_equal_mean( source_valid_fraction_per_image, class_ids ), "source_suppressed_fraction": class_equal_mean( source_suppressed_fraction_per_image, class_ids ), "output_minus_carrier_high_fraction": optional_image_equal_mean( arrays[f"{basis}_output_minus_carrier_high_fraction"][:, block_index] ), "output_minus_carrier_centroid": optional_image_equal_mean( arrays[f"{basis}_output_minus_carrier_centroid"][:, block_index] ), "output_minus_carrier_valid_channels": int( arrays[f"{basis}_output_minus_carrier_valid_channels"][ :, block_index ].sum(dtype=np.int64) ), } for signal_index, signal in enumerate(SIGNAL_NAMES): valid = arrays[f"{basis}_psd_valid_channels"][:, block_index, signal_index] log_valid = arrays["signal_log10_centered_energy_valid_channels"][ :, block_index, signal_index ] signal_channel_count = ( RESIDUAL_CHANNELS_BY_STAGE[ int(arrays["block_stage"][block_index]) - 1 ] if signal == "residual_delta" else EXPANDED_CHANNELS_BY_STAGE[ int(arrays["block_stage"][block_index]) - 1 ] ) summary: dict[str, Any] = { "task_id": task_id, "arm": arm, "order": order, "basis": basis, "global_block_index": block_index, "stage": int(arrays["block_stage"][block_index]), "block": int(arrays["block_within_stage"][block_index]), "signal": signal, "psd_high_fraction": optional_image_equal_mean( arrays[f"{basis}_psd_high_fraction"][:, block_index, signal_index] ), "psd_centroid": optional_image_equal_mean( arrays[f"{basis}_psd_centroid"][:, block_index, signal_index] ), "psd_entropy": optional_image_equal_mean( arrays[f"{basis}_psd_entropy"][:, block_index, signal_index] ), "valid": int(valid.sum(dtype=np.int64)), "invalid": int( NUM_SPECTRAL_IMAGES * signal_channel_count - valid.sum(dtype=np.int64) ), "centered_rms": optional_image_equal_mean( arrays["signal_centered_rms"][:, block_index, signal_index] ), "log10_centered_energy": optional_image_equal_mean( arrays["signal_log10_centered_energy"][:, block_index, signal_index] ), "log10_centered_energy_valid": int( log_valid.sum(dtype=np.int64) ), "log10_centered_energy_invalid": int( NUM_SPECTRAL_IMAGES * signal_channel_count - log_valid.sum(dtype=np.int64) ), "noncentered_rms": optional_image_equal_mean( arrays["signal_noncentered_rms"][:, block_index, signal_index] ), "gate_mean": None, "gate_cv": None, "gate_zero_fraction": None, "gate_active_fraction": None, "gate_clip_crossing_fraction": None, "rho_used": None, "rho_response": None, "jsd": None, "jsd_valid_channels": None, "m_res": None, "m_res_conditional": None, "m_res_conditional_valid_channels": None, "suppressed_fraction": None, "constant_gate_fraction": None, "constant_gate_count": None, "m_off": None, "m_disp": None, "output_minus_carrier_high_fraction": None, "output_minus_carrier_centroid": None, "output_minus_carrier_valid_channels": None, "source_valid": None, "source_suppressed": None, "source_valid_fraction": None, "source_suppressed_fraction": None, } if signal == "gate_value": for name in ( "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", ): summary[name] = image_equal_mean(arrays[name][:, block_index]) summary["constant_gate_fraction"] = image_equal_mean( arrays["constant_gate_fraction"][:, block_index] ) summary["constant_gate_count"] = int( arrays["constant_gate_count"][:, block_index].sum(dtype=np.int64) ) if signal == "gated_product": summary.update(operator) result[(basis, block_index, signal)] = summary expected_keys = { (basis, block, signal) for basis in BASES for block in range(NUM_BLOCKS) for signal in SIGNAL_NAMES } if set(result) != expected_keys: raise AssertionError("internal spectral block summary coverage error") return result def validate_spectral_csv( self, task_id: str, root: Path, summary: dict[tuple[str, int, str], dict[str, Any]], ) -> list[dict[str, Any]]: observed = read_csv(root / "spectral_by_block.csv", SPECTRAL_COLUMNS) expected = [summary[key] for key in sorted(summary)] if len(observed) != NUM_BLOCKS * len(BASES) * len(SIGNAL_NAMES): raise ValueError("spectral_by_block.csv must contain 170 rows per task") by_key: dict[tuple[str, int, str], dict[str, str]] = {} for row in observed: key = (row["basis"], int(row["global_block_index"]), row["signal"]) if key in by_key: raise ValueError(f"duplicate spectral CSV key: {key}") by_key[key] = row if set(by_key) != set(summary): raise ValueError("spectral CSV block/basis/signal coverage mismatch") string_fields = ("task_id", "arm", "order", "basis", "signal") integer_fields = ("global_block_index", "stage", "block", "valid", "invalid") numeric_fields = ( "psd_high_fraction", "psd_centroid", "psd_entropy", "centered_rms", "log10_centered_energy", "log10_centered_energy_valid", "log10_centered_energy_invalid", "noncentered_rms", "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", "rho_used", "rho_response", "jsd", "jsd_valid_channels", "m_res", "m_res_conditional", "m_res_conditional_valid_channels", "suppressed_fraction", "constant_gate_fraction", "constant_gate_count", "m_off", "m_disp", "output_minus_carrier_high_fraction", "output_minus_carrier_centroid", "output_minus_carrier_valid_channels", "source_valid", "source_suppressed", "source_valid_fraction", "source_suppressed_fraction", ) for key, target in summary.items(): actual = by_key[key] for field in string_fields: if actual[field] != str(target[field]): raise ValueError(f"spectral CSV {key} differs in {field}") for field in integer_fields: if int(actual[field]) != int(target[field]): raise ValueError(f"spectral CSV {key} differs in {field}") for field in numeric_fields: expected_value = target[field] if expected_value is None: if actual[field] != "": raise ValueError(f"spectral CSV {key} must leave {field} empty") elif not math.isclose( float(actual[field]), float(expected_value), rel_tol=1e-10, abs_tol=1e-10 ): raise ValueError(f"spectral CSV {key} differs in {field}") return expected def validate_task_transfer_npz( self, root: Path, summary: dict[tuple[str, int, str], dict[str, Any]], ) -> None: required = ["block_global_index", "block_stage", "block_within_stage"] for basis in BASES: required.extend( [ f"{basis}_primary", f"{basis}_conditional", f"{basis}_source_valid", f"{basis}_source_suppressed", ] ) arrays = load_npz(root / "transfer_matrices.npz", required) metadata_expected = { "block_global_index": np.arange(NUM_BLOCKS, dtype=np.int8), "block_stage": np.asarray(EXPECTED_STAGES, dtype=np.int8), "block_within_stage": np.asarray(EXPECTED_STAGE_BLOCKS, dtype=np.int8), } for name, expected in metadata_expected.items(): if not np.array_equal(arrays[name], expected): raise ValueError(f"transfer_matrices.npz metadata differs in {name}") for basis in BASES: expected_primary = np.stack( [summary[(basis, block, "gated_product")]["transfer_primary"] for block in range(NUM_BLOCKS)] ) expected_conditional = np.stack( [summary[(basis, block, "gated_product")]["transfer_conditional"] for block in range(NUM_BLOCKS)] ) expected_valid = np.stack( [summary[(basis, block, "gated_product")]["transfer_source_valid"] for block in range(NUM_BLOCKS)] ) expected_suppressed = np.stack( [summary[(basis, block, "gated_product")]["transfer_source_suppressed"] for block in range(NUM_BLOCKS)] ) require_shape(arrays[f"{basis}_primary"], (NUM_BLOCKS, 4, 4), f"{basis}_primary") require_dtype(arrays[f"{basis}_primary"], "float64", f"{basis}_primary") require_shape(arrays[f"{basis}_conditional"], (NUM_BLOCKS, 4, 4), f"{basis}_conditional") require_dtype(arrays[f"{basis}_conditional"], "float64", f"{basis}_conditional") require_shape(arrays[f"{basis}_source_valid"], (NUM_BLOCKS, 4), f"{basis}_source_valid") require_dtype(arrays[f"{basis}_source_valid"], "int64", f"{basis}_source_valid") require_shape(arrays[f"{basis}_source_suppressed"], (NUM_BLOCKS, 4), f"{basis}_source_suppressed") require_dtype(arrays[f"{basis}_source_suppressed"], "int64", f"{basis}_source_suppressed") if not np.allclose(arrays[f"{basis}_primary"], expected_primary, rtol=0, atol=1e-12): raise ValueError(f"{basis} primary transfer aggregate differs from per-image evidence") if not np.allclose( arrays[f"{basis}_conditional"], expected_conditional, rtol=0, atol=1e-12, equal_nan=True, ): raise ValueError(f"{basis} conditional transfer aggregate differs from per-image evidence") if not np.array_equal(arrays[f"{basis}_source_valid"], expected_valid): raise ValueError(f"{basis} source-valid aggregate mismatch") if not np.array_equal(arrays[f"{basis}_source_suppressed"], expected_suppressed): raise ValueError(f"{basis} source-suppressed aggregate mismatch") def task_stage_rows( self, task_id: str, summary: dict[tuple[str, int, str], dict[str, Any]], ) -> list[dict[str, Any]]: arm, order = EXPECTED_TASK[task_id] rows: list[dict[str, Any]] = [] simple_metrics = ( "psd_high_fraction", "psd_centroid", "psd_entropy", "centered_rms", "noncentered_rms", ) operator_metrics = ( "rho_used", "rho_response", "jsd", "m_res", "suppressed_fraction", "m_off", "m_disp", ) for basis in BASES: for stage in range(1, 5): block_indices = [ index for index, value in enumerate(EXPECTED_STAGES) if value == stage ] for signal in SIGNAL_NAMES: selected = [summary[(basis, index, signal)] for index in block_indices] row: dict[str, Any] = { "task_id": task_id, "arm": arm, "order": order, "basis": basis, "stage": stage, "signal": signal, "aggregation": "block_equal", "block_count": len(selected), } for metric in simple_metrics: values = np.asarray( [ float(item[metric]) if item[metric] is not None else np.nan for item in selected ], dtype=np.float64, ) row[metric] = optional_image_equal_mean(values) for metric in operator_metrics: if signal == "gated_product": values = np.asarray( [ float(item[metric]) if item[metric] is not None else np.nan for item in selected ], dtype=np.float64, ) row[metric] = optional_image_equal_mean(values) else: row[metric] = None rows.append(row) return rows def validate_stage_csv( self, task_id: str, root: Path, summary: dict[tuple[str, int, str], dict[str, Any]], ) -> None: observed = read_csv(root / "spectral_by_stage.csv", STAGE_COLUMNS) expected = self.task_stage_rows(task_id, summary) if len(observed) != len(BASES) * 4 * len(SIGNAL_NAMES): raise ValueError("spectral_by_stage.csv must contain 40 block-equal rows") key_fields = ("basis", "stage", "signal", "aggregation") by_key: dict[tuple[str, int, str, str], dict[str, str]] = {} for row in observed: key = (row["basis"], int(row["stage"]), row["signal"], row["aggregation"]) if key in by_key: raise ValueError(f"duplicate stage CSV key: {key}") by_key[key] = row for target in expected: key = tuple(target[field] for field in key_fields) actual = by_key.get(key) # type: ignore[arg-type] if actual is None: raise ValueError(f"stage CSV is missing {key}") for field in ("task_id", "arm", "order", "basis", "signal", "aggregation"): if actual[field] != str(target[field]): raise ValueError(f"stage CSV {key} differs in {field}") for field in ("stage", "block_count"): if int(actual[field]) != int(target[field]): raise ValueError(f"stage CSV {key} differs in {field}") for field in STAGE_COLUMNS[8:]: expected_value = target[field] if expected_value is None: if actual[field] != "": raise ValueError(f"stage CSV {key} must leave {field} empty") elif not math.isclose( float(actual[field]), float(expected_value), rel_tol=1e-10, abs_tol=1e-10 ): raise ValueError(f"stage CSV {key} differs in {field}") def validate_pairing( self, task_id: str, root: Path, accuracy: dict[str, np.ndarray], results: dict[str, Any], ) -> dict[str, Any]: pairing = load_json(root / "batch_pairing_manifest.json") arm, order = EXPECTED_TASK[task_id] required = { "schema_version", "protocol_id", "task_id", "arm", "order", "applies", "batch_size", "tail_batch_size", "num_batches", "blocks", } missing = sorted(required - set(pairing)) if missing: raise ValueError(f"batch pairing manifest missing fields: {missing}") if not ( pairing["schema_version"] == 1 and pairing["protocol_id"] == PROTOCOL_ID and pairing["task_id"] == task_id and pairing["arm"] == arm and pairing["order"] == order and pairing["batch_size"] == 256 and pairing["tail_batch_size"] == 80 and pairing["num_batches"] == 196 ): raise ValueError("batch pairing root contract mismatch") if arm != "D": if pairing["applies"] is not False or pairing["blocks"] != []: raise ValueError("non-D task must emit applies=false and no pairing blocks") return pairing if pairing["applies"] is not True or len(pairing["blocks"]) != NUM_BLOCKS: raise ValueError("D task must emit exactly 17 pairing blocks") order_hash = int64_sha256(accuracy["canonical_index"]) for global_index, row in enumerate(pairing["blocks"]): required_block = { "block_global_index", "stage", "block", "receiver_count", "donor_count", "batch_count", "bijection", "fixed_points", "mapping_sha256", "receiver_index_sha256", "donor_index_sha256", "batch_sizes_sha256", "by_local_batch_size", } if not required_block.issubset(row): raise ValueError(f"D pairing block {global_index} is missing fields") if not ( row["block_global_index"] == global_index and row["stage"] == EXPECTED_STAGES[global_index] and row["block"] == EXPECTED_STAGE_BLOCKS[global_index] and row["receiver_count"] == NUM_IMAGES and row["donor_count"] == NUM_IMAGES and row["batch_count"] == 196 and row["bijection"] is True and row["fixed_points"] == 0 and row["receiver_index_sha256"] == order_hash ): raise ValueError(f"D pairing block {global_index} mapping contract failed") for hash_field in ( "mapping_sha256", "receiver_index_sha256", "donor_index_sha256", "batch_sizes_sha256", ): if not valid_sha256(row[hash_field]): raise ValueError(f"D pairing block {global_index} malformed {hash_field}") by_size = {entry["local_batch_size"]: entry for entry in row["by_local_batch_size"]} if set(by_size) != {80, 256}: raise ValueError(f"D pairing block {global_index} batch-size coverage failed") expected_counts = {80: (1, 80), 256: (195, 49_920)} for size, (batches, receivers) in expected_counts.items(): entry = by_size[size] required_size = { "local_batch_size", "shift", "source_position_sha256", "is_bijection", "fixed_points", "batches", "receiver_count", } if not required_size.issubset(entry): raise ValueError("D by_local_batch_size entry is missing fields") if not ( 0 < int(entry["shift"]) < size and valid_sha256(entry["source_position_sha256"]) and entry["is_bijection"] is True and entry["fixed_points"] == 0 and entry["batches"] == batches and entry["receiver_count"] == receivers ): raise ValueError(f"D local batch-size {size} proof failed") batch_summary = results["batch_pairing"] if not isinstance(batch_summary, dict) or batch_summary.get("passed") is not True: raise ValueError("results.batch_pairing does not assert passed") if batch_summary.get("covered_receivers") != NUM_IMAGES: raise ValueError("results.batch_pairing receiver coverage mismatch") return pairing def validate_cross_task_contract(self) -> None: if set(self.tasks) != set(TASK_ORDER): self.check( "cross.all_eight_tasks", False, "cross-task validation requires all eight valid tasks", valid_tasks=sorted(self.tasks), ) return subset_hashes = { task.results["hashes"]["subset_manifest_sha256"] for task in self.tasks.values() } self.check( "cross.common_subset", subset_hashes == {self.manifest["spectral_subset"]["sha256"]}, "all eight tasks must use the one frozen 4,096-image subset", hashes=sorted(subset_hashes), ) runner_hashes = {task.results["hashes"]["runner_sha256"] for task in self.tasks.values()} self.check( "cross.common_runner", runner_hashes == {file_sha256(self.runner_path)}, "all eight tasks must use the same frozen runner", hashes=sorted(runner_hashes), ) data_hashes = {task.results["hashes"]["data_manifest_sha256"] for task in self.tasks.values()} self.check( "cross.common_data", data_hashes == {self.manifest["dataset"]["evaluation_manifest_sha256"]}, "all eight tasks must bind the canonical ImageNet validation evaluation manifest", hashes=sorted(data_hashes), ) task_packages = { stable_json(load_json(task.root / "environment.json")["packages"]) for task in self.tasks.values() } task_package_locks = { load_json(task.root / "environment.json")["package_lock"]["sha256"] for task in self.tasks.values() } self.check( "cross.common_package_versions", len(task_packages) == 1 and len(task_package_locks) == 1, "task-level package versions or full package locks differ across processes", package_lock_sha256=sorted(task_package_locks), ) reference_indices = self.tasks["B"].spectral["canonical_index"] reference_classes = self.tasks["B"].spectral["class_id"] self.check( "cross.spectral_receiver_alignment", all( np.array_equal(task.spectral["canonical_index"], reference_indices) and np.array_equal(task.spectral["class_id"], reference_classes) for task in self.tasks.values() ), "per-image spectral arrays are not receiver-aligned across tasks", ) c_perm = self.tasks["C"].results["task_contract"]["intervention"][ "channel_permutation_manifest_sha256" ] sc_perm = self.tasks["SC"].results["task_contract"]["intervention"][ "channel_permutation_manifest_sha256" ] self.check( "cross.channel_permutation", c_perm == sc_perm == FROZEN_CHANNEL_PERMUTATION_SHA256, "C and SC must share the exact frozen 17-block permutation manifest", ) d_order_hashes = { self.tasks[task_id].results["hashes"]["order_indices_sha256"] for task_id in ("D", "D_order1", "D_order2") } self.check( "cross.d_registered_orders", len(d_order_hashes) == 3, "D canonical/salt1/salt2 order hashes must be distinct", hashes=sorted(d_order_hashes), ) self.validate_b_order_invariance() def validate_b_order_invariance(self) -> None: baseline = self.tasks["B"] control = self.tasks["B_order1"] accuracy_equal = ( int(baseline.accuracy["top1_correct"][0].sum()) == int(control.accuracy["top1_correct"][0].sum()) and int(baseline.accuracy["top5_correct"][0].sum()) == int(control.accuracy["top5_correct"][0].sum()) ) comparison = compare_block_summary_registries( baseline.block_summary, control.block_summary ) row_level_equal = True row_level_maximum = 0.0 row_level_coverage: list[str] = [] baseline_order = np.argsort(baseline.accuracy["canonical_index"], kind="stable") control_order = np.argsort(control.accuracy["canonical_index"], kind="stable") for field in ( "target", "top1_correct", "top5_correct", "nll", "prediction", "confidence", ): left = baseline.accuracy[field] right = control.accuracy[field] left = left[baseline_order] if left.ndim == 1 else left[0, baseline_order] right = right[control_order] if right.ndim == 1 else right[0, control_order] equal, difference, _ = compare_aggregate_values(left, right) row_level_equal = row_level_equal and equal and difference <= 1e-6 row_level_maximum = max(row_level_maximum, difference) row_level_coverage.append(f"accuracy.{field}") spectral_registry_equal = set(baseline.spectral) == set(control.spectral) for field in sorted(set(baseline.spectral) & set(control.spectral)): equal, difference, _ = compare_aggregate_values( baseline.spectral[field], control.spectral[field] ) row_level_equal = row_level_equal and equal and difference <= 1e-6 row_level_maximum = max(row_level_maximum, difference) row_level_coverage.append(f"spectral.{field}") baseline_accuracy_row = next( row for row in baseline.accuracy_rows if row["condition"] == "unfiltered" ) control_accuracy_row = next( row for row in control.accuracy_rows if row["condition"] == "unfiltered" ) aggregate_accuracy_equal = True for field in ("top1_correct", "top5_correct", "top1", "top5", "nll", "ece"): equal, difference, _ = compare_aggregate_values( baseline_accuracy_row[field], control_accuracy_row[field] ) aggregate_accuracy_equal = ( aggregate_accuracy_equal and equal and difference <= 1e-6 ) row_level_maximum = max(row_level_maximum, difference) expected_registry = True identity_contract = True for task_id, task in (("B", baseline), ("B_order1", control)): expected_arm, expected_order = EXPECTED_TASK[task_id] for (basis, block, signal), row in task.block_summary.items(): expected_fields = set(SPECTRAL_COLUMNS) if signal == "gated_product": expected_fields |= BLOCK_SUMMARY_GATED_EXTRA_FIELDS expected_registry = expected_registry and set(row) == expected_fields identity_contract = identity_contract and ( row["task_id"] == task_id and row["arm"] == expected_arm and row["order"] == expected_order and row["basis"] == basis and row["global_block_index"] == block and row["stage"] == EXPECTED_STAGES[block] and row["block"] == EXPECTED_STAGE_BLOCKS[block] and row["signal"] == signal ) required_fields = { "m_res_conditional", "output_minus_carrier_high_fraction", "output_minus_carrier_centroid", "source_valid_fraction", "source_suppressed_fraction", "constant_gate_fraction", "transfer_primary", "transfer_conditional", "transfer_source_valid", "transfer_source_suppressed", } required_coverage = required_fields <= comparison["covered_fields"] self.check( "cross.b_order_invariance", accuracy_equal and aggregate_accuracy_equal and spectral_registry_equal and row_level_equal and comparison["field_registry_identical"] and expected_registry and identity_contract and required_coverage and comparison["definedness_equal"] and comparison["maximum_absolute_metric_difference"] <= 1e-6, "B salt1 must preserve every aggregate field, definedness mask, count, and transfer cell within 1e-6", integer_counts_identical=accuracy_equal, aggregate_unfiltered_accuracy_identical=aggregate_accuracy_equal, row_level_evidence_identical=row_level_equal, row_level_array_coverage=sorted(row_level_coverage), row_level_artifact_sha256={ task_id: { "per_image_accuracy.npz": file_sha256( task.root / "per_image_accuracy.npz" ), "per_image_spectral.npz": file_sha256( task.root / "per_image_spectral.npz" ), } for task_id, task in (("B", baseline), ("B_order1", control)) }, row_level_maximum_absolute_difference=row_level_maximum, spectral_array_registry_identical=spectral_registry_equal, field_registry_identical=comparison["field_registry_identical"], expected_aggregate_registry_complete=expected_registry, identity_contract_valid=identity_contract, required_field_coverage=required_coverage, compared_values=comparison["compared_values"], maximum_absolute_metric_difference=comparison[ "maximum_absolute_metric_difference" ], ) @staticmethod def task_global_metrics(task: TaskData) -> dict[str, float | None]: output: dict[str, float | None] = {} for basis in BASES: rows = [ task.block_summary[(basis, block, "gated_product")] for block in range(NUM_BLOCKS) ] for metric in ( "m_off", "m_res", "m_res_conditional", "suppressed_fraction", "constant_gate_fraction", "source_valid_fraction", "source_suppressed_fraction", "jsd", "rho_used", "rho_response", "psd_high_fraction", "psd_centroid", "output_minus_carrier_high_fraction", "output_minus_carrier_centroid", "centered_rms", ): metric_rows = ( [ task.block_summary[(basis, block, "gate_value")] for block in range(NUM_BLOCKS) ] if metric == "constant_gate_fraction" else rows ) values = np.asarray( [ float(row[metric]) if row[metric] is not None else np.nan for row in metric_rows ], dtype=np.float64, ) output[f"{basis}_{metric}"] = optional_image_equal_mean(values) output["top1"] = float(task.accuracy["top1_correct"][0].mean(dtype=np.float64) * 100.0) output["top5"] = float(task.accuracy["top5_correct"][0].mean(dtype=np.float64) * 100.0) return output @staticmethod def task_global_image_metrics(task: TaskData) -> dict[str, np.ndarray]: """Return receiver-first inputs without imputing invalid source rows. M_off keeps its source-band axis so the registered class-equal estimator can exclude a missing source row before applying equal source weights. Other metrics keep their block axis so their valid receiver masks remain available to the image-equal estimator. """ arrays = task.spectral result: dict[str, np.ndarray] = {} for basis in BASES: primary = arrays[f"{basis}_transfer_primary"].copy() diagonal = np.arange(NUM_BANDS) primary[:, :, diagonal, diagonal] = 0.0 source_valid = arrays[f"{basis}_transfer_source_valid"] > 0 row_off = np.sum( np.where(np.isfinite(primary), primary, 0.0), axis=-1, dtype=np.float64 ) row_off[~source_valid] = np.nan result[f"{basis}_m_off"] = row_off result[f"{basis}_m_res"] = arrays["projection_residual"].astype( np.float64, copy=False ) result[f"{basis}_m_res_conditional"] = arrays[ "projection_residual_conditional" ].astype(np.float64, copy=False) result[f"{basis}_suppressed_fraction"] = arrays[ "projection_suppressed_fraction" ].astype(np.float64, copy=False) result[f"{basis}_psd_high_fraction"] = arrays[ f"{basis}_psd_high_fraction" ][:, :, SIGNAL_NAMES.index("gated_product")].astype(np.float64, copy=False) result[f"{basis}_output_minus_carrier_high_fraction"] = arrays[ f"{basis}_output_minus_carrier_high_fraction" ].astype(np.float64, copy=False) return result @staticmethod def bootstrap_weights(class_ids: np.ndarray) -> np.ndarray: class_ids = np.asarray(class_ids) indices_by_class = [ np.flatnonzero(class_ids == class_id) for class_id in range(NUM_CLASSES) ] histogram = Counter(len(indices) for indices in indices_by_class) formal_balance = Counter({4: 904, 5: 96}) if ( NUM_SPECTRAL_IMAGES == 4096 and NUM_CLASSES == 1000 and histogram != formal_balance ) or any(len(indices) == 0 for indices in indices_by_class): raise ValueError("bootstrap class balance differs from the frozen subset") weights = np.zeros( (BOOTSTRAP_REPLICATES, NUM_SPECTRAL_IMAGES), dtype=np.uint8 ) rng = np.random.default_rng(BOOTSTRAP_SEED) for indices in indices_by_class: draws = rng.integers( 0, len(indices), size=(BOOTSTRAP_REPLICATES, len(indices)), endpoint=False, ) for local_position, canonical_slot in enumerate(indices): weights[:, canonical_slot] = np.count_nonzero( draws == local_position, axis=1 ).astype(np.uint8, copy=False) if not np.all(weights.sum(axis=1, dtype=np.int64) == NUM_SPECTRAL_IMAGES): raise AssertionError("bootstrap replicate size changed") return weights def accuracy_bootstrap(self) -> dict[str, Any]: series: dict[tuple[str, str, str], np.ndarray] = {} reference_target: np.ndarray | None = None for task_id in TASK_ORDER: task = self.tasks[task_id] canonical_index = task.accuracy["canonical_index"] order = np.argsort(canonical_index, kind="stable") if not np.array_equal(canonical_index[order], np.arange(NUM_IMAGES, dtype=np.int64)): raise ValueError(f"{task_id} accuracy receivers cannot be canonically aligned") target = task.accuracy["target"][order] if reference_target is None: reference_target = target elif not np.array_equal(target, reference_target): raise ValueError("accuracy targets differ after canonical receiver alignment") conditions = tuple(str(item) for item in task.accuracy["condition_names"].tolist()) for local_index, condition in enumerate(conditions): series[(task_id, condition, "top1")] = task.accuracy["top1_correct"][ local_index, order ].astype(np.float64) series[(task_id, condition, "top5")] = task.accuracy["top5_correct"][ local_index, order ].astype(np.float64) series[(task_id, condition, "nll")] = task.accuracy["nll"][ local_index, order ].astype(np.float64) assert reference_target is not None class_indices = [ np.flatnonzero(reference_target == class_id) for class_id in range(NUM_CLASSES) ] if any(indices.size != 50 for indices in class_indices): raise ValueError("full ImageNet accuracy bootstrap requires exactly 50 images/class") series_keys = tuple(sorted(series)) value_matrix = np.stack([series[key] for key in series_keys], axis=1) if not np.all(np.isfinite(value_matrix)): raise ValueError("accuracy bootstrap input contains non-finite observations") bootstrap_values = np.zeros( (BOOTSTRAP_REPLICATES, len(series_keys)), dtype=np.float64 ) rng = np.random.default_rng(BOOTSTRAP_SEED) probability = np.full(50, 1.0 / 50.0, dtype=np.float64) for indices in class_indices: counts = rng.multinomial( 50, probability, size=BOOTSTRAP_REPLICATES ).astype(np.float64, copy=False) bootstrap_values += counts @ value_matrix[indices] bootstrap_values /= NUM_IMAGES key_to_column = {key: index for index, key in enumerate(series_keys)} specs: list[tuple[str, str, str, str]] = [] for task_id in CANONICAL_ARMS: for condition in EXPECTED_CONDITIONS[1:]: specs.append((task_id, condition, task_id, "unfiltered")) for left_index in range(1, len(CANONICAL_ARMS)): for right_index in range(left_index): left_task = CANONICAL_ARMS[left_index] right_task = CANONICAL_ARMS[right_index] for condition in EXPECTED_CONDITIONS: specs.append((left_task, condition, right_task, condition)) specs.extend( [ ("D_order1", "unfiltered", "D", "unfiltered"), ("D_order2", "unfiltered", "D", "unfiltered"), ("D_order1", "unfiltered", "B", "unfiltered"), ("D_order2", "unfiltered", "B", "unfiltered"), ("B_order1", "unfiltered", "B", "unfiltered"), ] ) if len(specs) != len(set(specs)): raise AssertionError("accuracy bootstrap contrast registry contains duplicates") rows: list[dict[str, Any]] = [] for left_task, left_condition, right_task, right_condition in specs: for metric in ("top1", "top5", "nll"): left_key = (left_task, left_condition, metric) right_key = (right_task, right_condition, metric) multiplier = 100.0 if metric in {"top1", "top5"} else 1.0 differences = multiplier * ( bootstrap_values[:, key_to_column[left_key]] - bootstrap_values[:, key_to_column[right_key]] ) point = multiplier * float( series[left_key].mean(dtype=np.float64) - series[right_key].mean(dtype=np.float64) ) rows.append( { "contrast_id": ( f"{left_task}:{left_condition}-" f"{right_task}:{right_condition}" ), "left_task_id": left_task, "left_condition": left_condition, "right_task_id": right_task, "right_condition": right_condition, "metric": metric, "unit": "percentage_points" if multiplier == 100.0 else "nats_per_image", "samples": NUM_IMAGES, "point_difference": point, "bootstrap_ci95_low": float(np.percentile(differences, 2.5)), "bootstrap_ci95_high": float(np.percentile(differences, 97.5)), "bootstrap_replicates": BOOTSTRAP_REPLICATES, "bootstrap_seed": BOOTSTRAP_SEED, } ) series_summaries: list[dict[str, Any]] = [] for key in series_keys: task_id, condition, metric = key multiplier = 100.0 if metric in {"top1", "top5"} else 1.0 estimates = multiplier * bootstrap_values[:, key_to_column[key]] series_summaries.append( { "task_id": task_id, "condition": condition, "metric": metric, "unit": "percentage_points" if multiplier == 100.0 else "nats_per_image", "point": multiplier * float(series[key].mean(dtype=np.float64)), "bootstrap_ci95_low": float(np.percentile(estimates, 2.5)), "bootstrap_ci95_high": float(np.percentile(estimates, 97.5)), } ) return { "schema_version": 1, "replicates": BOOTSTRAP_REPLICATES, "seed": BOOTSTRAP_SEED, "scheme": ( "one shared ImageNet receiver resample: 50 draws with replacement " "within each of 1000 ground-truth classes" ), "independent_unit": "validation image", "series_summaries": series_summaries, "rows": rows, } def paired_bootstrap( self, weights_all: np.ndarray | None = None, transfer: dict[str, Any] | None = None, ) -> dict[str, Any]: """Compute the registered mixing contrasts from valid-aware block estimates. `transfer_bootstrap` applies the class-equal estimator to each source row with its source-valid mask and the image-equal estimator to M_res. Reusing those paired draws here prevents a sparse, legitimate invalid receiver from being either imputed as zero or promoted to a mechanical failure. """ class_ids = self.tasks["B"].spectral["class_id"] if weights_all is None: weights_all = self.bootstrap_weights(class_ids) if weights_all.shape != (BOOTSTRAP_REPLICATES, NUM_SPECTRAL_IMAGES): raise ValueError("bootstrap weight matrix has the wrong shape") if transfer is None: transfer = self.transfer_bootstrap(weights_all) task_names = tuple(str(value) for value in transfer["task_names"].tolist()) scalar_names = tuple(str(value) for value in transfer["scalar_names"].tolist()) if task_names != CANONICAL_ARMS: raise ValueError("paired bootstrap task registry differs from canonical arms") scalar_bootstrap = np.asarray(transfer["_scalar_bootstrap"], dtype=np.float64) expected_shape = ( BOOTSTRAP_REPLICATES, len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, len(scalar_names), ) if scalar_bootstrap.shape != expected_shape: raise ValueError("paired bootstrap scalar tensor has the wrong shape") metric_names = tuple( f"{basis}_{metric}" for basis in BASES for metric in ("m_off", "m_res") ) bootstrap_values: dict[str, dict[str, np.ndarray]] = { task_id: {} for task_id in CANONICAL_ARMS } for task_index, task_id in enumerate(CANONICAL_ARMS): for basis_index, basis in enumerate(BASES): for metric in ("m_off", "m_res"): metric_index = scalar_names.index(metric) # All 17 blocks are registered equal-depth units. Undefined # block estimates propagate to an undefined replicate. bootstrap_values[task_id][f"{basis}_{metric}"] = np.mean( scalar_bootstrap[:, task_index, basis_index, :, metric_index], axis=1, dtype=np.float64, ) points = { task_id: self.task_global_metrics(self.tasks[task_id]) for task_id in CANONICAL_ARMS } contrasts: dict[str, Any] = {} for task_id in CANONICAL_ARMS[1:]: task_contrasts: dict[str, Any] = {} for metric in metric_names: baseline_point = finite_or_none(points["B"].get(metric)) task_point = finite_or_none(points[task_id].get(metric)) common = { "baseline_point": baseline_point, "task_point": task_point, "bootstrap_replicates": BOOTSTRAP_REPLICATES, } if baseline_point is None or task_point is None: task_contrasts[metric] = { **common, "relative_difference_defined": False, "reason": "point estimator is undefined", "bootstrap_defined_replicates": 0, "relative_difference_point": None, "relative_difference_ci90": None, "relative_difference_ci95": None, } continue if baseline_point < 1e-6: task_contrasts[metric] = { **common, "relative_difference_defined": False, "reason": "B denominator is below the registered 1e-6 floor", "bootstrap_defined_replicates": 0, "relative_difference_point": None, "relative_difference_ci90": None, "relative_difference_ci95": None, } continue numerator = bootstrap_values[task_id][metric] - bootstrap_values["B"][metric] denominator = bootstrap_values["B"][metric] valid = ( np.isfinite(numerator) & np.isfinite(denominator) & (np.abs(denominator) >= 1e-12) ) defined_count = int(valid.sum(dtype=np.int64)) if defined_count: relative = numerator[valid] / denominator[valid] ci90 = [ float(np.percentile(relative, 5.0)), float(np.percentile(relative, 95.0)), ] ci95 = [ float(np.percentile(relative, 2.5)), float(np.percentile(relative, 97.5)), ] else: ci90 = None ci95 = None complete = defined_count == BOOTSTRAP_REPLICATES task_contrasts[metric] = { **common, "relative_difference_defined": complete, "reason": ( None if complete else "not all registered paired-bootstrap replicates are defined" ), "bootstrap_defined_replicates": defined_count, "relative_difference_point": ( (task_point - baseline_point) / baseline_point if complete else None ), "relative_difference_ci90": ci90, "relative_difference_ci95": ci95, } contrasts[task_id] = task_contrasts return { "replicates": BOOTSTRAP_REPLICATES, "seed": BOOTSTRAP_SEED, "scheme": ( "one shared class-stratified receiver resample; source-valid class-equal " "M_off and receiver-valid image-equal M_res, block-equal over 17 blocks" ), "contrasts_vs_B": contrasts, } @staticmethod def bootstrap_estimates( values: np.ndarray, class_ids: np.ndarray, weights: np.ndarray, *, estimator: str, chunk_size: int = 64, ) -> np.ndarray: values = np.asarray(values, dtype=np.float64) if values.shape[0] != NUM_SPECTRAL_IMAGES: raise ValueError("spectral bootstrap values must be receiver-first") if weights.shape != (BOOTSTRAP_REPLICATES, NUM_SPECTRAL_IMAGES): raise ValueError("spectral bootstrap weights have the wrong shape") if estimator not in {"image_equal", "class_equal"}: raise ValueError(f"unknown bootstrap estimator: {estimator}") tail = values.shape[1:] flat = values.reshape(NUM_SPECTRAL_IMAGES, -1) output = np.empty((BOOTSTRAP_REPLICATES, flat.shape[1]), dtype=np.float64) classes = [ np.flatnonzero(class_ids == class_id) for class_id in range(NUM_CLASSES) ] histogram = Counter(len(indices) for indices in classes) if ( NUM_SPECTRAL_IMAGES == 4096 and NUM_CLASSES == 1000 and histogram != Counter({4: 904, 5: 96}) ) or any(len(indices) == 0 for indices in classes): raise ValueError("spectral bootstrap class balance changed") class_scale = np.asarray( [1.0 / (NUM_CLASSES * len(classes[int(class_id)])) for class_id in class_ids], dtype=np.float64, ) for start in range(0, flat.shape[1], chunk_size): stop = min(start + chunk_size, flat.shape[1]) selected = flat[:, start:stop] finite = np.isfinite(selected) if estimator == "image_equal": numerator = weights @ np.where(finite, selected, 0.0) if finite.all(): output[:, start:stop] = numerator / NUM_SPECTRAL_IMAGES else: denominator = weights @ finite.astype(np.float64) output[:, start:stop] = np.divide( numerator, denominator, out=np.full_like(numerator, np.nan), where=denominator > 0, ) continue if finite.all(): output[:, start:stop] = weights @ (selected * class_scale[:, None]) continue accumulator = np.zeros( (BOOTSTRAP_REPLICATES, stop - start), dtype=np.float64 ) class_count = np.zeros_like(accumulator, dtype=np.uint16) for indices in classes: local_weights = weights[:, indices] local_values = selected[indices] local_finite = finite[indices] numerator = local_weights @ np.where(local_finite, local_values, 0.0) denominator = local_weights @ local_finite.astype(np.float64) defined = denominator > 0 accumulator[defined] += (numerator[defined] / denominator[defined]) class_count += defined.astype(np.uint16) output[:, start:stop] = np.divide( accumulator, class_count, out=np.full_like(accumulator, np.nan), where=class_count > 0, ) if np.any(np.isinf(output)): raise ValueError("bootstrap estimator emitted Inf") return output.reshape((BOOTSTRAP_REPLICATES,) + tail) @staticmethod def bootstrap_quantiles(estimates: np.ndarray) -> np.ndarray: with warnings.catch_warnings(), np.errstate(invalid="ignore"): warnings.simplefilter("ignore", category=RuntimeWarning) quantiles = np.nanpercentile( np.asarray(estimates, dtype=np.float64), [2.5, 50.0, 97.5], axis=0 ) return np.moveaxis(quantiles, 0, -1).astype(np.float64, copy=False) def transfer_bootstrap(self, weights: np.ndarray) -> dict[str, Any]: class_ids = self.tasks["B"].spectral["class_id"] primary_values = np.stack( [ np.stack( [self.tasks[task_id].spectral[f"{basis}_transfer_primary"] for basis in BASES], axis=1, ) for task_id in CANONICAL_ARMS ], axis=1, ) conditional_values = np.stack( [ np.stack( [ self.tasks[task_id].spectral[f"{basis}_transfer_conditional"] for basis in BASES ], axis=1, ) for task_id in CANONICAL_ARMS ], axis=1, ) # Shapes are receiver, task, basis, block, source band, target band. expected_shape = ( NUM_SPECTRAL_IMAGES, len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, NUM_BANDS, NUM_BANDS, ) if primary_values.shape != expected_shape or conditional_values.shape != expected_shape: raise AssertionError("transfer bootstrap stacking order changed") primary_bootstrap = self.bootstrap_estimates( primary_values, class_ids, weights, estimator="class_equal", chunk_size=32 ) primary_quantiles = self.bootstrap_quantiles(primary_bootstrap) primary_defined_replicates = np.isfinite(primary_bootstrap).sum( axis=0, dtype=np.int64 ) diagonal = np.arange(NUM_BANDS) offdiag_bootstrap = primary_bootstrap.copy() offdiag_bootstrap[..., diagonal, diagonal] = 0.0 m_off_bootstrap = offdiag_bootstrap.sum(axis=(-1, -2), dtype=np.float64) / NUM_BANDS midpoints = np.asarray([0.125, 0.375, 0.625, 0.875], dtype=np.float64) distance = np.abs(midpoints[:, None] - midpoints[None, :]) m_disp_bootstrap = ( (primary_bootstrap * distance).sum(axis=(-1, -2), dtype=np.float64) / NUM_BANDS ) del offdiag_bootstrap del primary_bootstrap conditional_bootstrap = self.bootstrap_estimates( conditional_values, class_ids, weights, estimator="class_equal", chunk_size=32 ) conditional_quantiles = self.bootstrap_quantiles(conditional_bootstrap) conditional_defined_replicates = np.isfinite(conditional_bootstrap).sum( axis=0, dtype=np.int64 ) del conditional_bootstrap image_scalar_names = ( "m_res", "m_res_conditional", "suppressed_fraction", "constant_gate_fraction", ) image_scalar_values = np.empty( ( NUM_SPECTRAL_IMAGES, len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, len(image_scalar_names), ), dtype=np.float64, ) for task_index, task_id in enumerate(CANONICAL_ARMS): arrays = self.tasks[task_id].spectral fields = ( arrays["projection_residual"], arrays["projection_residual_conditional"], arrays["projection_suppressed_fraction"], arrays["constant_gate_fraction"], ) for metric_index, field in enumerate(fields): image_scalar_values[:, task_index, :, :, metric_index] = field[:, None, :] image_scalar_bootstrap = self.bootstrap_estimates( image_scalar_values, class_ids, weights, estimator="image_equal" ) transfer_fraction_names = ("source_valid_fraction", "source_suppressed_fraction") transfer_fraction_values = np.empty( ( NUM_SPECTRAL_IMAGES, len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, len(transfer_fraction_names), ), dtype=np.float64, ) channel_counts = np.asarray( [EXPANDED_CHANNELS_BY_STAGE[stage - 1] for stage in EXPECTED_STAGES], dtype=np.float64, ) for task_index, task_id in enumerate(CANONICAL_ARMS): arrays = self.tasks[task_id].spectral for basis_index, basis in enumerate(BASES): valid = arrays[f"{basis}_transfer_source_valid"].sum( axis=-1, dtype=np.float64 ) suppressed = arrays[f"{basis}_transfer_source_suppressed"].sum( axis=-1, dtype=np.float64 ) transfer_fraction_values[:, task_index, basis_index, :, 0] = valid / ( NUM_BANDS * channel_counts[None, :] ) with np.errstate(divide="ignore", invalid="ignore"): transfer_fraction_values[:, task_index, basis_index, :, 1] = np.where( valid > 0, suppressed / valid, np.nan ) transfer_fraction_bootstrap = self.bootstrap_estimates( transfer_fraction_values, class_ids, weights, estimator="class_equal" ) scalar_names = ( "m_off", "m_disp", *image_scalar_names, *transfer_fraction_names, ) scalar_bootstrap = np.concatenate( [ m_off_bootstrap[..., None], m_disp_bootstrap[..., None], image_scalar_bootstrap, transfer_fraction_bootstrap, ], axis=-1, ) scalar_quantiles = self.bootstrap_quantiles(scalar_bootstrap) scalar_defined_replicates = np.isfinite(scalar_bootstrap).sum( axis=0, dtype=np.int64 ) with np.errstate(invalid="ignore"): global_scalar_estimates = np.nanmean( scalar_bootstrap, axis=3, dtype=np.float64 ) global_scalar_quantiles = self.bootstrap_quantiles(global_scalar_estimates) del image_scalar_bootstrap del transfer_fraction_bootstrap primary_point = np.stack( [ np.stack( [ np.stack( [ self.tasks[task_id].block_summary[ (basis, block, "gated_product") ]["transfer_primary"] for block in range(NUM_BLOCKS) ] ) for basis in BASES ] ) for task_id in CANONICAL_ARMS ] ) conditional_point = np.stack( [ np.stack( [ np.stack( [ self.tasks[task_id].block_summary[ (basis, block, "gated_product") ]["transfer_conditional"] for block in range(NUM_BLOCKS) ] ) for basis in BASES ] ) for task_id in CANONICAL_ARMS ] ) scalar_point = np.empty( ( len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, len(scalar_names), ), dtype=np.float64, ) for task_index, task_id in enumerate(CANONICAL_ARMS): for basis_index, basis in enumerate(BASES): for block in range(NUM_BLOCKS): row = self.tasks[task_id].block_summary[(basis, block, "gated_product")] scalar_point[task_index, basis_index, block] = [ ( float(value) if ( value := ( self.tasks[task_id].block_summary[ (basis, block, "gate_value") ][name] if name == "constant_gate_fraction" else row[name] ) ) is not None else np.nan ) for name in scalar_names ] if not np.allclose( primary_point, class_equal_array(primary_values.reshape(NUM_SPECTRAL_IMAGES, -1), class_ids).reshape( primary_point.shape ), rtol=0.0, atol=1e-12, equal_nan=True, ): raise AssertionError("transfer bootstrap primary point estimator disagrees") rows: list[dict[str, Any]] = [] for task_index, task_id in enumerate(CANONICAL_ARMS): for basis_index, basis in enumerate(BASES): for block in range(NUM_BLOCKS): common = { "task_id": task_id, "arm": task_id, "basis": basis, "global_block_index": block, "stage": EXPECTED_STAGES[block], "block": EXPECTED_STAGE_BLOCKS[block], "bootstrap_replicates": BOOTSTRAP_REPLICATES, "bootstrap_seed": BOOTSTRAP_SEED, } for kind, point_array, quantile_array in ( ("primary_cell", primary_point, primary_quantiles), ("conditional_cell", conditional_point, conditional_quantiles), ): for source in range(NUM_BANDS): for target in range(NUM_BANDS): quantile = quantile_array[ task_index, basis_index, block, source, target ] rows.append( { **common, "summary": kind, "source_band": source, "target_band": target, "point": finite_or_none( point_array[ task_index, basis_index, block, source, target ] ), "bootstrap_q025": finite_or_none(quantile[0]), "bootstrap_q50": finite_or_none(quantile[1]), "bootstrap_q975": finite_or_none(quantile[2]), "defined": bool( np.isfinite( point_array[ task_index, basis_index, block, source, target, ] ) ), "bootstrap_defined_replicates": int( ( primary_defined_replicates if kind == "primary_cell" else conditional_defined_replicates )[ task_index, basis_index, block, source, target, ] ), } ) for metric_index, metric in enumerate(scalar_names): quantile = scalar_quantiles[ task_index, basis_index, block, metric_index ] rows.append( { **common, "summary": metric, "source_band": "", "target_band": "", "point": finite_or_none( scalar_point[task_index, basis_index, block, metric_index] ), "bootstrap_q025": finite_or_none(quantile[0]), "bootstrap_q50": finite_or_none(quantile[1]), "bootstrap_q975": finite_or_none(quantile[2]), "defined": bool( np.isfinite( scalar_point[ task_index, basis_index, block, metric_index ] ) ), "bootstrap_defined_replicates": int( scalar_defined_replicates[ task_index, basis_index, block, metric_index ] ), } ) return { "task_names": np.asarray(CANONICAL_ARMS), "quantile_levels": np.asarray([0.025, 0.5, 0.975], dtype=np.float64), "primary_point": primary_point.astype(np.float64, copy=False), "primary_quantiles": primary_quantiles, "primary_defined": np.isfinite(primary_point), "primary_defined_replicates": primary_defined_replicates, "conditional_point": conditional_point.astype(np.float64, copy=False), "conditional_quantiles": conditional_quantiles, "conditional_defined": np.isfinite(conditional_point), "conditional_defined_replicates": conditional_defined_replicates, "scalar_names": np.asarray(scalar_names), "scalar_point": scalar_point, "scalar_quantiles": scalar_quantiles, "scalar_defined": np.isfinite(scalar_point), "scalar_defined_replicates": scalar_defined_replicates, "global_scalar_quantiles": global_scalar_quantiles, "_scalar_bootstrap": scalar_bootstrap, "rows": rows, } def spectral_block_bootstrap( self, weights: np.ndarray, transfer: dict[str, Any] ) -> dict[str, Any]: class_ids = self.tasks["B"].spectral["class_id"] signals = tuple(ROOT_SIGNAL_PREFIXES) normalized_metrics = ROOT_SIGNAL_BOOTSTRAP_METRICS normalized_values = np.empty( ( NUM_SPECTRAL_IMAGES, len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, len(signals), len(normalized_metrics), ), dtype=np.float64, ) normalized_point = np.empty(normalized_values.shape[1:], dtype=np.float64) for task_index, task_id in enumerate(CANONICAL_ARMS): arrays = self.tasks[task_id].spectral for basis_index, basis in enumerate(BASES): for signal_index, signal in enumerate(signals): source_signal_index = SIGNAL_NAMES.index(signal) for metric_index, metric in enumerate(normalized_metrics): field = arrays[f"{basis}_psd_{metric.replace('psd_', '')}"] normalized_values[ :, task_index, basis_index, :, signal_index, metric_index ] = field[:, :, source_signal_index] normalized_point[ task_index, basis_index, :, signal_index, metric_index ] = [ ( self.tasks[task_id].block_summary[(basis, block, signal)][ metric ] if self.tasks[task_id].block_summary[ (basis, block, signal) ][metric] is not None else np.nan ) for block in range(NUM_BLOCKS) ] normalized_bootstrap = self.bootstrap_estimates( normalized_values, class_ids, weights, estimator="image_equal" ) normalized_quantiles = self.bootstrap_quantiles(normalized_bootstrap) normalized_stage_quantiles = np.empty( ( len(CANONICAL_ARMS), len(BASES), 4, len(signals), len(normalized_metrics), 3, ), dtype=np.float64, ) for stage in range(1, 5): block_indices = [ index for index, block_stage in enumerate(EXPECTED_STAGES) if block_stage == stage ] with np.errstate(invalid="ignore"): stage_estimates = np.nanmean( normalized_bootstrap[:, :, :, block_indices], axis=3, dtype=np.float64, ) normalized_stage_quantiles[:, :, stage - 1] = self.bootstrap_quantiles( stage_estimates ) del normalized_bootstrap transfer_scalar_names = tuple(str(item) for item in transfer["scalar_names"].tolist()) transfer_scalar_index = { name: index for index, name in enumerate(transfer_scalar_names) } transfer_scalar_bootstrap = transfer["_scalar_bootstrap"] extra_names = ( "jsd", "output_minus_carrier_high_fraction", "output_minus_carrier_centroid", ) extra_values = np.empty( ( NUM_SPECTRAL_IMAGES, len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, len(extra_names), ), dtype=np.float64, ) coherence_values = np.empty( ( NUM_SPECTRAL_IMAGES, len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, len(COHERENCE_NAMES), ), dtype=np.float64, ) for task_index, task_id in enumerate(CANONICAL_ARMS): arrays = self.tasks[task_id].spectral for basis_index, basis in enumerate(BASES): extra_values[:, task_index, basis_index, :, 0] = arrays[f"{basis}_jsd_xy"] extra_values[:, task_index, basis_index, :, 1] = arrays[ f"{basis}_output_minus_carrier_high_fraction" ] extra_values[:, task_index, basis_index, :, 2] = arrays[ f"{basis}_output_minus_carrier_centroid" ] coherence_values[:, task_index, basis_index] = arrays["coherence_mean"] extra_bootstrap = self.bootstrap_estimates( extra_values, class_ids, weights, estimator="image_equal" ) coherence_bootstrap = self.bootstrap_estimates( coherence_values, class_ids, weights, estimator="class_equal" ) extra_index = {name: index for index, name in enumerate(extra_names)} coherence_index = {name: index for index, name in enumerate(COHERENCE_NAMES)} operator_point = np.empty( (len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, len(ROOT_OPERATOR_METRICS)), dtype=np.float64, ) operator_quantiles = np.empty(operator_point.shape + (3,), dtype=np.float64) operator_stage_quantiles = np.empty( (len(CANONICAL_ARMS), len(BASES), 4, len(ROOT_OPERATOR_METRICS), 3), dtype=np.float64, ) for metric_index, metric in enumerate(ROOT_OPERATOR_METRICS): if metric in transfer_scalar_index: estimates = transfer_scalar_bootstrap[..., transfer_scalar_index[metric]] elif metric in extra_index: estimates = extra_bootstrap[..., extra_index[metric]] elif metric in coherence_index: estimates = coherence_bootstrap[..., coherence_index[metric]] else: raise AssertionError(f"operator bootstrap metric has no estimator: {metric}") operator_quantiles[..., metric_index, :] = self.bootstrap_quantiles(estimates) for stage in range(1, 5): block_indices = [ index for index, block_stage in enumerate(EXPECTED_STAGES) if block_stage == stage ] with np.errstate(invalid="ignore"): stage_estimates = np.nanmean( estimates[:, :, :, block_indices], axis=3, dtype=np.float64 ) operator_stage_quantiles[:, :, stage - 1, metric_index] = ( self.bootstrap_quantiles(stage_estimates) ) for task_index, task_id in enumerate(CANONICAL_ARMS): for basis_index, basis in enumerate(BASES): for block in range(NUM_BLOCKS): signal = "gate_value" if metric == "constant_gate_fraction" else "gated_product" value = self.tasks[task_id].block_summary[(basis, block, signal)][metric] operator_point[task_index, basis_index, block, metric_index] = ( float(value) if value is not None else np.nan ) del extra_bootstrap del coherence_bootstrap del transfer["_scalar_bootstrap"] gate_metric_names = ( "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", ) gate_values = np.stack( [ np.stack( [self.tasks[task_id].spectral[name] for name in gate_metric_names], axis=-1, ) for task_id in CANONICAL_ARMS ], axis=1, ) gate_bootstrap = self.bootstrap_estimates( gate_values, class_ids, weights, estimator="image_equal" ) gate_quantiles = self.bootstrap_quantiles(gate_bootstrap) del gate_bootstrap gate_point = image_equal_array(gate_values.reshape(NUM_SPECTRAL_IMAGES, -1)).reshape( len(CANONICAL_ARMS), NUM_BLOCKS, len(gate_metric_names) ) return { "signal_names": signals, "normalized_metric_names": normalized_metrics, "normalized_point": normalized_point, "normalized_quantiles": normalized_quantiles, "normalized_stage_quantiles": normalized_stage_quantiles, "operator_metric_names": ROOT_OPERATOR_METRICS, "operator_point": operator_point, "operator_quantiles": operator_quantiles, "operator_stage_quantiles": operator_stage_quantiles, "gate_metric_names": gate_metric_names, "gate_point": gate_point, "gate_quantiles": gate_quantiles, } def wide_spectral_point_fields( self, task_id: str, basis: str, block: int ) -> dict[str, Any]: task = self.tasks[task_id] fields: dict[str, Any] = {} for signal, prefix in ROOT_SIGNAL_PREFIXES.items(): row = task.block_summary[(basis, block, signal)] for metric in ROOT_SIGNAL_POINT_METRICS: fields[f"{prefix}_{metric}"] = row[metric] if metric in ROOT_SIGNAL_BOOTSTRAP_METRICS: values = task.spectral[f"{basis}_psd_{metric.replace('psd_', '')}"][ :, block, SIGNAL_NAMES.index(signal) ] fields[f"{prefix}_{metric}_defined"] = row[metric] is not None fields[f"{prefix}_{metric}_valid_receivers"] = int( np.isfinite(values).sum() ) fields[f"{prefix}_valid"] = row["valid"] fields[f"{prefix}_invalid"] = row["invalid"] fields[f"{prefix}_log10_centered_energy_valid"] = row[ "log10_centered_energy_valid" ] fields[f"{prefix}_log10_centered_energy_invalid"] = row[ "log10_centered_energy_invalid" ] gate_row = task.block_summary[(basis, block, "gate_value")] for metric in ( "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", ): fields[f"q_{metric}"] = gate_row[metric] operator = task.block_summary[(basis, block, "gated_product")] for metric in ROOT_OPERATOR_METRICS: fields[metric] = ( gate_row[metric] if metric == "constant_gate_fraction" else operator[metric] ) receiver_values = self._operator_receiver_values(task_id, basis, block, metric) fields[f"{metric}_defined"] = fields[metric] is not None fields[f"{metric}_valid_receivers"] = int(np.isfinite(receiver_values).sum()) fields.update( { "m_res_conditional_valid_channels": operator[ "m_res_conditional_valid_channels" ], "constant_gate_count": gate_row["constant_gate_count"], "source_valid": operator["source_valid"], "source_suppressed": operator["source_suppressed"], "jsd_valid_channels": operator["jsd_valid_channels"], "jsd_invalid_channels": ( NUM_SPECTRAL_IMAGES * EXPANDED_CHANNELS_BY_STAGE[EXPECTED_STAGES[block] - 1] - operator["jsd_valid_channels"] ), "output_minus_carrier_valid_channels": operator[ "output_minus_carrier_valid_channels" ], "output_minus_carrier_invalid_channels": ( NUM_SPECTRAL_IMAGES * EXPANDED_CHANNELS_BY_STAGE[EXPECTED_STAGES[block] - 1] - operator["output_minus_carrier_valid_channels"] ), } ) return fields def canonical_spectral_rows(self, statistics: dict[str, Any]) -> list[dict[str, Any]]: signal_index = { name: index for index, name in enumerate(statistics["signal_names"]) } normalized_index = { name: index for index, name in enumerate(statistics["normalized_metric_names"]) } operator_index = { name: index for index, name in enumerate(statistics["operator_metric_names"]) } rows: list[dict[str, Any]] = [] for task_index, task_id in enumerate(CANONICAL_ARMS): for basis_index, basis in enumerate(BASES): for block in range(NUM_BLOCKS): row: dict[str, Any] = { "task_id": task_id, "arm": task_id, "basis": basis, "global_block_index": block, "stage": EXPECTED_STAGES[block], "block": EXPECTED_STAGE_BLOCKS[block], **self.wide_spectral_point_fields(task_id, basis, block), } for signal, prefix in ROOT_SIGNAL_PREFIXES.items(): for metric in ROOT_SIGNAL_BOOTSTRAP_METRICS: quantile = statistics["normalized_quantiles"][ task_index, basis_index, block, signal_index[signal], normalized_index[metric], ] row[f"{prefix}_{metric}_ci95_low"] = finite_or_none(quantile[0]) row[f"{prefix}_{metric}_ci95_high"] = finite_or_none(quantile[2]) for metric in ROOT_OPERATOR_METRICS: quantile = statistics["operator_quantiles"][ task_index, basis_index, block, operator_index[metric] ] row[f"{metric}_ci95_low"] = finite_or_none(quantile[0]) row[f"{metric}_ci95_high"] = finite_or_none(quantile[2]) rows.append(row) if len(rows) != len(CANONICAL_ARMS) * len(BASES) * NUM_BLOCKS: raise AssertionError("canonical wide spectral table does not have 170 rows") return rows def order_probe_spectral_rows(self) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] for task_id in ("D_order1", "D_order2", "B_order1"): arm, order = EXPECTED_TASK[task_id] for basis in BASES: for block in range(NUM_BLOCKS): rows.append( { "task_id": task_id, "arm": arm, "order": order, "basis": basis, "global_block_index": block, "stage": EXPECTED_STAGES[block], "block": EXPECTED_STAGE_BLOCKS[block], **self.wide_spectral_point_fields(task_id, basis, block), } ) return rows def d_order_sensitivity_rows( self, raw_rows: Sequence[dict[str, Any]] ) -> list[dict[str, Any]]: raw_lookup = { ( row["task_id"], row["global_block_index"], row["signal"], row["metric"], ): row for row in raw_rows } rows: list[dict[str, Any]] = [] for basis in BASES: for block in range(NUM_BLOCKS): task_fields = { task_id: self.wide_spectral_point_fields(task_id, basis, block) for task_id in D_ORDER_TASKS } row: dict[str, Any] = { "basis": basis, "global_block_index": block, "stage": EXPECTED_STAGES[block], "block": EXPECTED_STAGE_BLOCKS[block], "registered_task_count": len(D_ORDER_TASKS), } def add_range(metric: str, values: Sequence[Any]) -> None: converted = [finite_or_none(value) for value in values] for task_id, value in zip(D_ORDER_TASKS, converted, strict=True): row[f"{metric}_{task_id}"] = value row[f"{metric}_{task_id}_defined"] = value is not None finite = [value for value in converted if value is not None] alternate_min, alternate_max, alternate_defined = ( complete_alternate_range(converted[1:]) ) row[f"{metric}_min"] = min(finite) if finite else None row[f"{metric}_max"] = max(finite) if finite else None row[f"{metric}_alternate_min"] = alternate_min row[f"{metric}_alternate_max"] = alternate_max row[f"{metric}_alternate_range_defined"] = alternate_defined row[f"{metric}_defined_count"] = len(finite) for metric in D_ORDER_RANGE_POINT_METRICS: add_range( metric, [task_fields[task_id].get(metric) for task_id in D_ORDER_TASKS], ) for signal, prefix in ROOT_SIGNAL_PREFIXES.items(): for metric in ( "centered_rms", "log10_centered_energy", "noncentered_rms", ): for statistic in ("dataset_median", "q25", "q75"): name = f"raw_{prefix}_{metric}_{statistic}" add_range( name, [ raw_lookup[(task_id, block, signal, metric)][statistic] for task_id in D_ORDER_TASKS ], ) for metric in ( "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", ): for statistic in ("dataset_median", "q25", "q75"): name = f"raw_q_{metric}_{statistic}" add_range( name, [ raw_lookup[ (task_id, block, "gate_value", metric) ][statistic] for task_id in D_ORDER_TASKS ], ) for kind in ("primary", "conditional"): matrices = { task_id: self.tasks[task_id].block_summary[ (basis, block, "gated_product") ][f"transfer_{kind}"] for task_id in D_ORDER_TASKS } for source in range(NUM_BANDS): for target in range(NUM_BANDS): metric = f"transfer_{kind}_s{source}_t{target}" add_range( metric, [ matrices[task_id][source, target] for task_id in D_ORDER_TASKS ], ) rows.append(row) if len(rows) != len(BASES) * NUM_BLOCKS: raise AssertionError("D registered-order range table must contain 34 rows") return rows def canonical_stage_rows(self, statistics: dict[str, Any]) -> list[dict[str, Any]]: signal_index = { name: index for index, name in enumerate(statistics["signal_names"]) } normalized_index = { name: index for index, name in enumerate(statistics["normalized_metric_names"]) } operator_index = { name: index for index, name in enumerate(statistics["operator_metric_names"]) } rows: list[dict[str, Any]] = [] for task_index, task_id in enumerate(CANONICAL_ARMS): for basis_index, basis in enumerate(BASES): for stage in range(1, 5): block_indices = [ index for index, block_stage in enumerate(EXPECTED_STAGES) if block_stage == stage ] for signal in ROOT_SIGNAL_PREFIXES: row: dict[str, Any] = { "task_id": task_id, "arm": task_id, "basis": basis, "stage": stage, "signal": signal, "aggregation": "block_equal", "block_count": len(block_indices), } for metric in ROOT_STAGE_METRICS: keys = ( f"{metric}_mean", f"{metric}_block_min", f"{metric}_block_max", f"{metric}_ci95_low", f"{metric}_ci95_high", f"{metric}_defined", f"{metric}_valid_block_count", ) if metric in normalized_index: points = statistics["normalized_point"][ task_index, basis_index, block_indices, signal_index[signal], normalized_index[metric], ] quantile = statistics["normalized_stage_quantiles"][ task_index, basis_index, stage - 1, signal_index[signal], normalized_index[metric], ] finite_points = points[np.isfinite(points)] values = ( image_equal_mean(finite_points) if finite_points.size else None, float(finite_points.min()) if finite_points.size else None, float(finite_points.max()) if finite_points.size else None, finite_or_none(quantile[0]), finite_or_none(quantile[2]), bool(finite_points.size), int(finite_points.size), ) elif signal == "gated_product" and metric in operator_index: points = statistics["operator_point"][ task_index, basis_index, block_indices, operator_index[metric], ] quantile = statistics["operator_stage_quantiles"][ task_index, basis_index, stage - 1, operator_index[metric], ] finite_points = points[np.isfinite(points)] values = ( image_equal_mean(finite_points) if finite_points.size else None, float(finite_points.min()) if finite_points.size else None, float(finite_points.max()) if finite_points.size else None, finite_or_none(quantile[0]), finite_or_none(quantile[2]), bool(finite_points.size), int(finite_points.size), ) else: values = (None, None, None, None, None, False, 0) row.update(dict(zip(keys, values, strict=True))) rows.append(row) expected = len(CANONICAL_ARMS) * len(BASES) * 4 * len(ROOT_SIGNAL_PREFIXES) if len(rows) != expected: raise AssertionError("canonical stage table coverage changed") return rows def gate_operating_rows( self, statistics: dict[str, Any], weights: np.ndarray ) -> list[dict[str, Any]]: operator_index = { name: index for index, name in enumerate(statistics["operator_metric_names"]) } gate_index = { name: index for index, name in enumerate(statistics["gate_metric_names"]) } rows: list[dict[str, Any]] = [] for task_id in TASK_ORDER: arm, order = EXPECTED_TASK[task_id] canonical = task_id in CANONICAL_ARMS task_index = CANONICAL_ARMS.index(task_id) if canonical else None for block in range(NUM_BLOCKS): stage = EXPECTED_STAGES[block] stage_blocks = [ index for index, value in enumerate(EXPECTED_STAGES) if value == stage ] for metric in statistics["gate_metric_names"]: points = np.asarray( [ self.tasks[task_id].block_summary[ ("fft", index, "gate_value") ][metric] for index in stage_blocks ], dtype=np.float64, ) quantile = ( statistics["gate_quantiles"][task_index, block, gate_index[metric]] if canonical else None ) receiver_values = self.tasks[task_id].spectral[metric][:, block] finite_values = receiver_values[np.isfinite(receiver_values)] if finite_values.size != NUM_SPECTRAL_IMAGES: raise ValueError( f"gate operating row {task_id}/block{block}/{metric} is incomplete" ) median_ci = ( self.weighted_bootstrap_median_ci(receiver_values, weights) if canonical else (None, None) ) rows.append( { "task_id": task_id, "arm": arm, "order": order, "basis": "", "global_block_index": block, "stage": stage, "block": EXPECTED_STAGE_BLOCKS[block], "metric": metric, "aggregation": "receiver_image_equal_mean", "point": self.tasks[task_id].block_summary[ ("fft", block, "gate_value") ][metric], "dataset_median": float(np.median(finite_values)), "q25": float(np.percentile(finite_values, 25.0)), "q75": float(np.percentile(finite_values, 75.0)), "median_bootstrap_ci95_low": median_ci[0], "median_bootstrap_ci95_high": median_ci[1], "block_stage_min": float(points.min()), "block_stage_max": float(points.max()), "bootstrap_ci95_low": float(quantile[0]) if quantile is not None else None, "bootstrap_ci95_high": float(quantile[2]) if quantile is not None else None, "bootstrap_replicates": BOOTSTRAP_REPLICATES if canonical else None, "valid_receivers": int(finite_values.size), "invalid_receivers": int( NUM_SPECTRAL_IMAGES - finite_values.size ), } ) for basis_index, basis in enumerate(BASES): for metric in ROOT_OPERATOR_METRICS: signal = "gate_value" if metric == "constant_gate_fraction" else "gated_product" stage_points = np.asarray( [ ( self.tasks[task_id].block_summary[ (basis, index, signal) ][metric] if self.tasks[task_id].block_summary[ (basis, index, signal) ][metric] is not None else np.nan ) for index in stage_blocks ], dtype=np.float64, ) finite_stage_points = stage_points[np.isfinite(stage_points)] quantile = ( statistics["operator_quantiles"][ task_index, basis_index, block, operator_index[metric] ] if canonical else None ) receiver_values = self._operator_receiver_values(task_id, basis, block, metric) valid_receivers = int(np.isfinite(receiver_values).sum()) rows.append( { "task_id": task_id, "arm": arm, "order": order, "basis": basis, "global_block_index": block, "stage": stage, "block": EXPECTED_STAGE_BLOCKS[block], "metric": metric, "aggregation": ( "receiver_class_equal_mean" if metric in { "rho_used", "rho_response", "m_off", "m_disp", "source_valid_fraction", "source_suppressed_fraction", } else "receiver_image_equal_mean" ), "point": self.tasks[task_id].block_summary[ (basis, block, signal) ][metric], "dataset_median": None, "q25": None, "q75": None, "median_bootstrap_ci95_low": None, "median_bootstrap_ci95_high": None, "block_stage_min": ( float(finite_stage_points.min()) if finite_stage_points.size else None ), "block_stage_max": ( float(finite_stage_points.max()) if finite_stage_points.size else None ), "bootstrap_ci95_low": ( finite_or_none(quantile[0]) if quantile is not None else None ), "bootstrap_ci95_high": ( finite_or_none(quantile[2]) if quantile is not None else None ), "bootstrap_replicates": ( BOOTSTRAP_REPLICATES if canonical else None ), "valid_receivers": valid_receivers, "invalid_receivers": NUM_SPECTRAL_IMAGES - valid_receivers, } ) return rows def _operator_receiver_values( self, task_id: str, basis: str, block: int, metric: str ) -> np.ndarray: arrays = self.tasks[task_id].spectral direct = { "rho_used": ("coherence_mean", 0), "rho_response": ("coherence_mean", 1), } if metric in direct: field, index = direct[metric] return arrays[field][:, block, index] simple_fields = { "jsd": f"{basis}_jsd_xy", "m_res": "projection_residual", "m_res_conditional": "projection_residual_conditional", "suppressed_fraction": "projection_suppressed_fraction", "constant_gate_fraction": "constant_gate_fraction", "output_minus_carrier_high_fraction": ( f"{basis}_output_minus_carrier_high_fraction" ), "output_minus_carrier_centroid": f"{basis}_output_minus_carrier_centroid", } if metric in simple_fields: return arrays[simple_fields[metric]][:, block] valid = arrays[f"{basis}_transfer_source_valid"][:, block].sum( axis=-1, dtype=np.float64 ) if metric == "source_valid_fraction": channels = EXPANDED_CHANNELS_BY_STAGE[EXPECTED_STAGES[block] - 1] return valid / (NUM_BANDS * channels) if metric == "source_suppressed_fraction": suppressed = arrays[f"{basis}_transfer_source_suppressed"][:, block].sum( axis=-1, dtype=np.float64 ) with np.errstate(divide="ignore", invalid="ignore"): return np.where(valid > 0, suppressed / valid, np.nan) if metric in {"m_off", "m_disp"}: matrix = arrays[f"{basis}_transfer_primary"][:, block].copy() if metric == "m_off": diagonal = np.arange(NUM_BANDS) matrix[:, diagonal, diagonal] = 0.0 return np.nansum(matrix, axis=(-1, -2), dtype=np.float64) / NUM_BANDS midpoints = np.asarray([0.125, 0.375, 0.625, 0.875], dtype=np.float64) distance = np.abs(midpoints[:, None] - midpoints[None, :]) return np.nansum(matrix * distance, axis=(-1, -2), dtype=np.float64) / NUM_BANDS raise AssertionError(f"unknown operator receiver metric: {metric}") @staticmethod def weighted_bootstrap_median_ci( values: np.ndarray, weights: np.ndarray ) -> tuple[float, float]: values = np.asarray(values, dtype=np.float64) if values.shape != (NUM_SPECTRAL_IMAGES,): raise ValueError("bootstrap median input must have 4,096 receiver values") finite = np.isfinite(values) if not finite.any(): raise ValueError("bootstrap median input has no finite receiver values") order = np.argsort(values, kind="stable") ordered_values = values[order] ordered_finite = finite[order] ordered_weights = weights[:, order] cumulative = np.cumsum(ordered_weights, axis=1, dtype=np.uint16) valid_total = ordered_weights[:, ordered_finite].sum(axis=1, dtype=np.uint16) if np.any(valid_total == 0): raise ValueError("a stratified bootstrap replicate has no valid receiver values") lower_rank = (valid_total.astype(np.int64) + 1) // 2 upper_rank = (valid_total.astype(np.int64) + 2) // 2 lower_index = np.argmax(cumulative >= lower_rank[:, None], axis=1) upper_index = np.argmax(cumulative >= upper_rank[:, None], axis=1) medians = 0.5 * (ordered_values[lower_index] + ordered_values[upper_index]) if not np.all(np.isfinite(medians)): raise ValueError("bootstrap median calculation selected undefined values") return ( float(np.percentile(medians, 2.5)), float(np.percentile(medians, 97.5)), ) def raw_amplitude_diagnostics( self, weights: np.ndarray ) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] signals = ("carrier", "gate_value", "gated_product") metrics = { "centered_rms": "signal_centered_rms", "log10_centered_energy": "signal_log10_centered_energy", "noncentered_rms": "signal_noncentered_rms", } for task_id in TASK_ORDER: task = self.tasks[task_id] arm, order = EXPECTED_TASK[task_id] for block in range(NUM_BLOCKS): for signal in signals: signal_index = SIGNAL_NAMES.index(signal) for metric, field in metrics.items(): values = task.spectral[field][:, block, signal_index] finite_values = values[np.isfinite(values)] if finite_values.size == 0: ci_low = ci_high = None replicates = ( BOOTSTRAP_REPLICATES if task_id in CANONICAL_ARMS else None ) dataset_median = q25 = q75 = None elif task_id in CANONICAL_ARMS: ci_low, ci_high = self.weighted_bootstrap_median_ci( values, weights ) replicates: int | None = BOOTSTRAP_REPLICATES dataset_median = float(np.median(finite_values)) q25 = float(np.percentile(finite_values, 25.0)) q75 = float(np.percentile(finite_values, 75.0)) else: ci_low, ci_high, replicates = None, None, None dataset_median = float(np.median(finite_values)) q25 = float(np.percentile(finite_values, 25.0)) q75 = float(np.percentile(finite_values, 75.0)) rows.append( { "task_id": task_id, "arm": arm, "order": order, "global_block_index": block, "stage": int(task.spectral["block_stage"][block]), "block": int(task.spectral["block_within_stage"][block]), "signal": signal, "metric": metric, "dataset_median": dataset_median, "q25": q25, "q75": q75, "bootstrap_ci95_low": ci_low, "bootstrap_ci95_high": ci_high, "bootstrap_replicates": replicates, "valid_receivers": int(finite_values.size), "invalid_receivers": int(NUM_SPECTRAL_IMAGES - finite_values.size), } ) for metric in ( "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", ): values = task.spectral[metric][:, block] finite_values = values[np.isfinite(values)] if finite_values.size != NUM_SPECTRAL_IMAGES: raise ValueError( f"gate operating metric {task_id}/block{block}/{metric} is incomplete" ) if task_id in CANONICAL_ARMS: ci_low, ci_high = self.weighted_bootstrap_median_ci(values, weights) replicates = BOOTSTRAP_REPLICATES else: ci_low, ci_high, replicates = None, None, None rows.append( { "task_id": task_id, "arm": arm, "order": order, "global_block_index": block, "stage": int(task.spectral["block_stage"][block]), "block": int(task.spectral["block_within_stage"][block]), "signal": "gate_value", "metric": metric, "dataset_median": float(np.median(finite_values)), "q25": float(np.percentile(finite_values, 25.0)), "q75": float(np.percentile(finite_values, 75.0)), "bootstrap_ci95_low": ci_low, "bootstrap_ci95_high": ci_high, "bootstrap_replicates": replicates, "valid_receivers": int(finite_values.size), "invalid_receivers": int(NUM_SPECTRAL_IMAGES - finite_values.size), } ) return rows def coherence_diagnostics(self) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] for task_id in TASK_ORDER: task = self.tasks[task_id] arm, order = EXPECTED_TASK[task_id] for block in range(NUM_BLOCKS): channel_count = EXPANDED_CHANNELS_BY_STAGE[ int(task.spectral["block_stage"][block]) - 1 ] for coherence_index, coherence_name in enumerate(COHERENCE_NAMES): values = task.spectral["coherence_mean"][:, block, coherence_index] valid_channels = task.spectral["coherence_valid_channels"][ :, block, coherence_index ] finite = values[np.isfinite(values)] rows.append( { "task_id": task_id, "arm": arm, "order": order, "global_block_index": block, "stage": int(task.spectral["block_stage"][block]), "block": int(task.spectral["block_within_stage"][block]), "coherence": coherence_name, "class_equal_mean": optional_class_equal_mean( values, task.spectral["class_id"] ), "receiver_mean_sd": ( float(finite.std(ddof=0, dtype=np.float64)) if finite.size else None ), "receiver_mean_q05": ( float(np.percentile(finite, 5.0)) if finite.size else None ), "receiver_mean_q50": ( float(np.percentile(finite, 50.0)) if finite.size else None ), "receiver_mean_q95": ( float(np.percentile(finite, 95.0)) if finite.size else None ), "valid_channels": int(valid_channels.sum(dtype=np.int64)), "invalid_channels": int( NUM_SPECTRAL_IMAGES * channel_count - valid_channels.sum(dtype=np.int64) ), "valid_receivers": int(finite.size), "invalid_receivers": int(NUM_SPECTRAL_IMAGES - finite.size), } ) return rows def claim_decision( self, bootstrap: dict[str, Any], raw_amplitude_rows: Sequence[dict[str, Any]] | None = None, ) -> tuple[dict[str, Any], dict[str, dict[str, float]]]: points = { task_id: self.task_global_metrics(self.tasks[task_id]) for task_id in TASK_ORDER } def at_least(left: Any, right: Any) -> bool: values = finite_values((left, right)) return values is not None and values[0] >= values[1] def difference_at_least(left: Any, right: Any, margin: float) -> bool: values = finite_values((left, right)) return values is not None and values[0] - values[1] >= margin def difference_at_most(left: Any, right: Any, margin: float) -> bool: values = finite_values((left, right)) return values is not None and values[0] - values[1] <= margin def stage_metric_mean( task_id: str, basis: str, metric: str, block_indices: Sequence[int] ) -> float | None: values = finite_values( self.tasks[task_id].block_summary[ (basis, index, "gated_product") ].get(metric) for index in block_indices ) return ( float(np.mean(np.asarray(values, dtype=np.float64), dtype=np.float64)) if values is not None else None ) def global_conditional_m_off(task_id: str, basis: str) -> float | None: block_values: list[float] = [] diagonal = np.arange(NUM_BANDS) for block in range(NUM_BLOCKS): matrix = np.asarray( self.tasks[task_id].block_summary[ (basis, block, "gated_product") ]["transfer_conditional"], dtype=np.float64, ) if matrix.shape != (NUM_BANDS, NUM_BANDS) or not np.all( np.isfinite(matrix) ): return None offdiag = matrix.copy() offdiag[diagonal, diagonal] = 0.0 block_values.append( float(offdiag.sum(dtype=np.float64) / NUM_BANDS) ) return float(np.mean(np.asarray(block_values), dtype=np.float64)) def protocol_raw_global(task_id: str) -> float | None: if raw_amplitude_rows is None: return None values = finite_values( row["dataset_median"] for row in raw_amplitude_rows if row["task_id"] == task_id and row["signal"] == "gated_product" and row["metric"] == "centered_rms" ) return ( float(np.mean(np.asarray(values), dtype=np.float64)) if values is not None and len(values) == NUM_BLOCKS else None ) contrasts = bootstrap["contrasts_vs_B"] comparable: dict[str, bool] = {} comparable_details: dict[str, Any] = {} for task_id in ("D", "S", "C", "SC"): fft_ok = True dct_ok = True metric_details: dict[str, Any] = {} for metric in ("m_off", "m_res"): fft = contrasts[task_id][f"fft_{metric}"] dct = contrasts[task_id][f"dct_{metric}"] fft_point = finite_or_none(fft.get("relative_difference_point")) dct_point = finite_or_none(dct.get("relative_difference_point")) fft_ci90 = finite_values(fft.get("relative_difference_ci90") or ()) bootstrap_defined = bool(fft.get("relative_difference_defined")) and bool( dct.get("relative_difference_defined") ) if ( not bootstrap_defined or fft_point is None or dct_point is None or fft_ci90 is None or len(fft_ci90) != 2 ): fft_ok = False dct_ok = False metric_details[metric] = { "fft_relative_difference_defined": bool( fft.get("relative_difference_defined") ), "dct_relative_difference_defined": bool( dct.get("relative_difference_defined") ), "fft_bootstrap_defined_replicates": int( finite_or_none(fft.get("bootstrap_defined_replicates")) or 0 ), "dct_bootstrap_defined_replicates": int( finite_or_none(dct.get("bootstrap_defined_replicates")) or 0 ), "equivalence_forbidden": True, } continue this_fft = ( abs(fft_point) <= 0.10 and fft_ci90[0] >= -0.10 and fft_ci90[1] <= 0.10 ) direction_agrees = ( abs(fft_point) <= 1e-15 or abs(dct_point) <= 1e-15 or math.copysign(1.0, fft_point) == math.copysign(1.0, dct_point) ) this_dct = abs(dct_point) <= 0.15 and direction_agrees fft_ok = fft_ok and this_fft dct_ok = dct_ok and this_dct metric_details[metric] = { "fft_relative_difference": fft_point, "fft_ci90": fft_ci90, "fft_equivalent": this_fft, "dct_relative_difference": dct_point, "dct_robustness_passed": this_dct, } suppression_values = finite_values( ( points[task_id]["fft_source_suppressed_fraction"], points["B"]["fft_source_suppressed_fraction"], ) ) suppression_difference = ( abs(suppression_values[0] - suppression_values[1]) if suppression_values is not None else None ) comparable[task_id] = bool( fft_ok and dct_ok and suppression_difference is not None and suppression_difference <= 0.05 ) comparable_details[task_id] = { "supported": comparable[task_id], "metrics": metric_details, "suppressed_fraction_absolute_difference": suppression_difference, "suppressed_fraction_defined": suppression_difference is not None, "suppressed_fraction_metric": "fft_source_suppressed_fraction", } accuracy_values = finite_values( ( points["D"]["top1"], points["B"]["top1"], points["S"]["top1"], points["C"]["top1"], points["SC"]["top1"], ) ) accuracy_direction = bool( accuracy_values is not None and accuracy_values[0] < accuracy_values[1] and accuracy_values[2] < accuracy_values[1] and accuracy_values[3] < accuracy_values[1] and accuracy_values[4] < accuracy_values[3] ) baseline_mixing_defined = all( ( value := finite_or_none(points["B"][f"{basis}_{metric}"]) ) is not None and value >= 1e-6 for basis in BASES for metric in ("m_off", "m_res") ) d_tasks = ("D", "D_order1", "D_order2") d_substantial = baseline_mixing_defined and all( at_least( points[task_id][f"{basis}_{metric}"], 0.5 * float(points["B"][f"{basis}_{metric}"]), ) for task_id in d_tasks for basis in BASES for metric in ("m_off", "m_res") ) d_accuracy_gap = all( difference_at_least(points["B"]["top1"], points[task_id]["top1"], 10.0) for task_id in d_tasks ) conditional_transfer_pairs = { basis: ( global_conditional_m_off("D", basis), global_conditional_m_off("B", basis), ) for basis in BASES } raw_energy_pair = (protocol_raw_global("D"), protocol_raw_global("B")) normalized_psd_pair = ( stage_metric_mean("D", "fft", "psd_high_fraction", range(NUM_BLOCKS)), stage_metric_mean("B", "fft", "psd_high_fraction", range(NUM_BLOCKS)), ) d_energy_not_lower = bool( at_least(raw_energy_pair[0], raw_energy_pair[1]) or at_least(normalized_psd_pair[0], normalized_psd_pair[1]) ) conditional_transfer_pair = conditional_transfer_pairs["fft"] d_accuracy_pair = (points["D"]["top1"], points["B"]["top1"]) section_states = { "accuracy": registered_decline_state(*d_accuracy_pair), "raw_energy": registered_decline_state(*raw_energy_pair), "normalized_psd": registered_decline_state(*normalized_psd_pair), "conditional_transfer": registered_decline_state( *conditional_transfer_pair ), } d_accuracy_defined = section_states["accuracy"] != "undefined" raw_energy_defined = section_states["raw_energy"] != "undefined" normalized_psd_defined = section_states["normalized_psd"] != "undefined" conditional_transfer_defined = ( section_states["conditional_transfer"] != "undefined" ) d_accuracy_declines = section_states["accuracy"] == "decline" raw_energy_declines = section_states["raw_energy"] == "decline" normalized_psd_declines = section_states["normalized_psd"] == "decline" conditional_transfer_declines = ( section_states["conditional_transfer"] == "decline" ) section_11_3_inputs_defined = bool( d_accuracy_defined and raw_energy_defined and normalized_psd_defined and conditional_transfer_defined ) section_11_3_joint_decline_observed = section_11_3_joint_decline( d_accuracy_declines, raw_energy_declines, normalized_psd_declines, conditional_transfer_declines, ) section_11_3_correlational_caveat = bool( section_11_3_joint_decline_observed or not section_11_3_inputs_defined ) indiscriminate_exclusion = bool( (comparable["D"] or d_energy_not_lower) and not section_11_3_correlational_caveat ) c_adaptation = baseline_mixing_defined and ( difference_at_most(points["B"]["top1"], points["C"]["top1"], 2.0) and all( at_least( points["C"][f"{basis}_{metric}"], 0.8 * float(points["B"][f"{basis}_{metric}"]), ) for basis in BASES for metric in ("m_off", "m_res") ) ) sc_gradient_gap = difference_at_least( points["C"]["top1"], points["SC"]["top1"], 3.0 ) stage_consistency = True stage_details: dict[str, Any] = {} for stage in range(1, 5): block_indices = [index for index, value in enumerate(EXPECTED_STAGES) if value == stage] row: dict[str, Any] = {} for basis in BASES: for metric, threshold in (("m_off", 0.5), ("m_res", 0.5)): d_value = stage_metric_mean("D", basis, metric, block_indices) b_value = stage_metric_mean("B", basis, metric, block_indices) ratio_defined = bool( d_value is not None and b_value is not None and b_value >= 1e-6 ) passed = bool( ratio_defined and d_value >= threshold * b_value ) stage_consistency = stage_consistency and passed row[f"{basis}_D_over_B_{metric}"] = ( d_value / b_value if ratio_defined else None ) row[f"{basis}_D_over_B_{metric}_defined"] = ratio_defined for metric in ("m_off", "m_res"): c_value = stage_metric_mean("C", basis, metric, block_indices) b_value = stage_metric_mean("B", basis, metric, block_indices) ratio_defined = bool( c_value is not None and b_value is not None and b_value >= 1e-6 ) passed = bool(ratio_defined and c_value >= 0.8 * b_value) stage_consistency = stage_consistency and passed row[f"{basis}_C_over_B_{metric}"] = ( c_value / b_value if ratio_defined else None ) row[f"{basis}_C_over_B_{metric}_defined"] = ratio_defined stage_details[str(stage)] = row direction_tolerance = 1e-8 direction_registry = ( ("D", "B", ("m_off", "m_res", "psd_high_fraction")), ("S", "B", ("m_off", "m_res")), ("C", "B", ("m_off", "m_res")), ("SC", "C", ("m_off", "m_res")), ) fft_dct_direction = True direction_details: dict[str, Any] = {} for left_task, right_task, metrics in direction_registry: for metric in metrics: key = f"{left_task}_vs_{right_task}:{metric}" fft_left = points[left_task][f"fft_{metric}"] fft_right = points[right_task][f"fft_{metric}"] dct_left = points[left_task][f"dct_{metric}"] dct_right = points[right_task][f"dct_{metric}"] global_values = finite_values( (fft_left, fft_right, dct_left, dct_right) ) global_defined = global_values is not None fft_delta = ( float(global_values[0] - global_values[1]) if global_values is not None else None ) dct_delta = ( float(global_values[2] - global_values[3]) if global_values is not None else None ) global_agrees = global_defined and (( abs(fft_delta) <= direction_tolerance and abs(dct_delta) <= direction_tolerance ) or ( abs(fft_delta) > direction_tolerance and abs(dct_delta) > direction_tolerance and math.copysign(1.0, fft_delta) == math.copysign(1.0, dct_delta) )) stage_agreement: dict[str, bool] = {} for stage in range(1, 5): block_indices = [ index for index, value in enumerate(EXPECTED_STAGES) if value == stage ] stage_delta: dict[str, float | None] = {} for basis in BASES: left = stage_metric_mean( left_task, basis, metric, block_indices ) right = stage_metric_mean( right_task, basis, metric, block_indices ) stage_delta[basis] = ( float(left - right) if left is not None and right is not None else None ) stage_defined = all(value is not None for value in stage_delta.values()) stage_agreement[str(stage)] = stage_defined and (( abs(stage_delta["fft"]) <= direction_tolerance and abs(stage_delta["dct"]) <= direction_tolerance ) or ( abs(stage_delta["fft"]) > direction_tolerance and abs(stage_delta["dct"]) > direction_tolerance and math.copysign(1.0, stage_delta["fft"]) == math.copysign(1.0, stage_delta["dct"]) )) passed = global_agrees and all(stage_agreement.values()) fft_dct_direction = fft_dct_direction and passed direction_details[key] = { "fft_global_delta": fft_delta, "dct_global_delta": dct_delta, "global_agreement": global_agrees, "stage_agreement": stage_agreement, "passed": passed, } conditions = { "B_mixing_denominators_defined": baseline_mixing_defined, "registered_accuracy_directions": accuracy_direction, "D_substantial_mixing_all_orders": d_substantial, "D_top1_gap_at_least_10_all_orders": d_accuracy_gap, "D_quantity_only_explanation_excluded": indiscriminate_exclusion, "C_preserves_80pct_mixing_and_within_2_top1": c_adaptation, "SC_at_least_3_top1_below_C": sc_gradient_gap, "stage_consistency": stage_consistency, "fft_dct_direction_agreement": fft_dct_direction, } strong_supported = all(conditions.values()) d_top1_values = finite_values( points[task_id]["top1"] for task_id in d_tasks[1:] ) d_moff_values = finite_values( stage_metric_mean(task_id, "fft", "m_off", range(NUM_BLOCKS)) for task_id in d_tasks[1:] ) d_moff_denominator = stage_metric_mean( "D", "fft", "m_off", range(NUM_BLOCKS) ) d_moff_relative_range = ( (max(d_moff_values) - min(d_moff_values)) / d_moff_denominator if d_moff_values is not None and d_moff_denominator is not None and d_moff_denominator >= 1e-6 else None ) d_order_inputs_defined = ( d_top1_values is not None and d_moff_relative_range is not None ) d_order_specific = bool( d_order_inputs_defined and ( max(d_top1_values) - min(d_top1_values) > 2.0 or d_moff_relative_range > 0.20 ) ) stable_across_registered_orders = bool( d_order_inputs_defined and not d_order_specific ) if strong_supported: permitted = ( "The trained gate performs input-conditioned multiplicative spectral mixing. " "Its task value is not determined by raw high-frequency energy or total mixing " "strength alone; it depends on sample-conditioned carrier-gate coupling and an " "optimizable gate-gradient path. Exact channel correspondence is helpful but " "partly adaptable." ) else: permitted = ( "The pre-registered strong mechanism statement is not fully supported for these " "checkpoints; report the measured input-conditioned mixing effects with the " "outcome-dependent limitations below." ) narrowing: list[str] = [] if not d_order_inputs_defined: narrowing.append( "Stability across the two alternate registered D orders is undefined because one or " "more registered order metrics are unavailable; no independent-gate " "generalization is permitted." ) elif d_order_specific: narrowing.append( "The derangement effect is batch/order-specific in the registered probes and " "must not be generalized to arbitrary independent gates." ) else: narrowing.append( "The derangement effect is stable across the two alternate registered orders; this " "does not establish generalization to arbitrary independent gates." ) if not baseline_mixing_defined: narrowing.append( "One or more registered B mixing denominators are undefined or below the " "registered floor, so relative mixing claims are forbidden." ) if not d_substantial: narrowing.append( "D changed both sample conditioning and total mixing magnitude, so those effects " "cannot be separated." ) if not c_adaptation: narrowing.append( "The fixed channel-permutation result does not support an adaptable channel-mismatch claim." ) if not sc_gradient_gap: narrowing.append( "The strong channel-mismatch by gate-gradient interaction is not supported; retain " "only the standalone S-versus-B result." ) if section_11_3_joint_decline_observed: narrowing.append( "Raw output energy, normalized high-frequency PSD, and conditional transfer " "decline together with D accuracy; under Section 11.3 the spectral audit is " "correlational and does not exclude an energy or mixing-quantity explanation." ) elif not section_11_3_inputs_defined: narrowing.append( "One or more Section 11.3 raw-energy, normalized-PSD, or conditional-transfer " "inputs are undefined; the joint-decline rule cannot be adjudicated and the " "audit must retain the correlational caveat." ) elif not indiscriminate_exclusion: narrowing.append( "The spectral audit remains correlational and does not exclude an energy or total-mixing explanation." ) if narrowing: permitted = f"{permitted} " + " ".join(narrowing) decision = { "strong_mechanism_claim_supported": strong_supported, "conditions": conditions, "matched_total_mixing_supported": comparable, "matched_total_mixing_details": comparable_details, "D_order_sensitivity": { "alternate_order_tasks": list(D_ORDER_TASKS[1:]), "range_excludes_canonical_D": True, "canonical_top1": finite_or_none(points["D"]["top1"]), "top1_range": ( [min(d_top1_values), max(d_top1_values)] if d_top1_values is not None else [None, None] ), "canonical_fft_m_off": d_moff_denominator, "fft_m_off_range": ( [min(d_moff_values), max(d_moff_values)] if d_moff_values is not None else [None, None] ), "fft_m_off_relative_range": d_moff_relative_range, "fft_m_off_relative_range_defined": d_moff_relative_range is not None, "registered_order_inputs_defined": d_order_inputs_defined, "stable_across_registered_orders": stable_across_registered_orders, "batch_order_specific_narrowing_required": d_order_specific, "generalizes_to_arbitrary_independent_gates": ( ARBITRARY_INDEPENDENT_GATE_GENERALIZATION_PERMITTED ), "top1_absolute_narrowing_threshold": 2.0, "m_off_relative_narrowing_threshold": 0.20, }, "stage_details": stage_details, "fft_dct_direction_details": direction_details, "section_11_3_correlational_caveat": { "required": section_11_3_correlational_caveat, "inputs_defined": section_11_3_inputs_defined, "joint_decline_observed": section_11_3_joint_decline_observed, "states": section_states, "primary_basis": "fft", "D_accuracy_declines": d_accuracy_declines, "D_accuracy_decline_defined": d_accuracy_defined, "raw_energy_declines": raw_energy_declines, "raw_energy_decline_defined": raw_energy_defined, "raw_energy_estimator": ( "block-equal mean of per-image channel-median dataset medians" ), "raw_centered_rms_D_vs_B": { "D": raw_energy_pair[0], "B": raw_energy_pair[1], }, "normalized_psd_declines": normalized_psd_declines, "normalized_psd_decline_defined": normalized_psd_defined, "normalized_psd_high_fraction_D_vs_B": { "D": normalized_psd_pair[0], "B": normalized_psd_pair[1], }, "conditional_transfer_declines": conditional_transfer_declines, "conditional_transfer_decline_defined": conditional_transfer_defined, "conditional_m_off_D_vs_B": { basis: { "D": conditional_transfer_pairs[basis][0], "B": conditional_transfer_pairs[basis][1], "state": registered_decline_state( *conditional_transfer_pairs[basis] ), } for basis in BASES }, "dct_robustness": { "normalized_psd_state": registered_decline_state( stage_metric_mean( "D", "dct", "psd_high_fraction", range(NUM_BLOCKS) ), stage_metric_mean( "B", "dct", "psd_high_fraction", range(NUM_BLOCKS) ), ), "conditional_transfer_state": registered_decline_state( *conditional_transfer_pairs["dct"] ), }, }, "fft_dct_zero_direction_tolerance": direction_tolerance, "outcome_dependent_narrowing": narrowing, "unrestricted_strong_wording_permitted": strong_supported and stable_across_registered_orders, "permitted_wording": permitted, } return decision, points def aggregate_accuracy_npz(self) -> dict[str, np.ndarray]: task_count = len(TASK_ORDER) condition_count = len(EXPECTED_CONDITIONS) arrays: dict[str, np.ndarray] = { "task_names": np.asarray(TASK_ORDER), "condition_names": np.asarray(EXPECTED_CONDITIONS), "condition_present": np.zeros((task_count, condition_count), dtype=np.bool_), "evaluation_position": np.empty((task_count, NUM_IMAGES), dtype=np.int64), "canonical_index": np.empty((task_count, NUM_IMAGES), dtype=np.int64), "target": np.empty((task_count, NUM_IMAGES), dtype=np.int16), "top1_correct": np.zeros((task_count, condition_count, NUM_IMAGES), dtype=np.bool_), "top5_correct": np.zeros((task_count, condition_count, NUM_IMAGES), dtype=np.bool_), "nll": np.full((task_count, condition_count, NUM_IMAGES), np.nan, dtype=np.float32), "prediction": np.full((task_count, condition_count, NUM_IMAGES), -1, dtype=np.int16), "confidence": np.full((task_count, condition_count, NUM_IMAGES), np.nan, dtype=np.float32), } for task_index, task_id in enumerate(TASK_ORDER): task = self.tasks[task_id] arrays["evaluation_position"][task_index] = task.accuracy["evaluation_position"] arrays["canonical_index"][task_index] = task.accuracy["canonical_index"] arrays["target"][task_index] = task.accuracy["target"] task_conditions = tuple(task.accuracy["condition_names"].tolist()) for local_index, condition in enumerate(task_conditions): condition_index = EXPECTED_CONDITIONS.index(str(condition)) arrays["condition_present"][task_index, condition_index] = True for field in ("top1_correct", "top5_correct", "nll", "prediction", "confidence"): arrays[field][task_index, condition_index] = task.accuracy[field][local_index] return arrays def aggregate_spectral_npz(self) -> dict[str, np.ndarray]: reference = self.tasks["B"].spectral metadata = { "task_names": np.asarray(TASK_ORDER), "canonical_index": reference["canonical_index"], "class_id": reference["class_id"], "signal_names": reference["signal_names"], "coherence_names": reference["coherence_names"], "block_global_index": reference["block_global_index"], "block_stage": reference["block_stage"], "block_within_stage": reference["block_within_stage"], } per_task_fields = [ name for name in reference if name not in { "canonical_index", "class_id", "signal_names", "coherence_names", "block_global_index", "block_stage", "block_within_stage", } ] for field in per_task_fields: metadata[field] = np.stack([self.tasks[task_id].spectral[field] for task_id in TASK_ORDER]) return metadata def aggregate_transfer_npz( self, bootstrap: dict[str, Any], transfer: dict[str, Any] ) -> dict[str, np.ndarray]: output: dict[str, np.ndarray] = { "task_names": np.asarray(TASK_ORDER), "basis_names": np.asarray(BASES), "block_global_index": np.arange(NUM_BLOCKS, dtype=np.int8), "block_stage": np.asarray(EXPECTED_STAGES, dtype=np.int8), "block_within_stage": np.asarray(EXPECTED_STAGE_BLOCKS, dtype=np.int8), } for kind in ("primary", "conditional"): output[kind] = np.stack( [ np.stack( [ np.stack( [ self.tasks[task_id].block_summary[(basis, block, "gated_product")][ f"transfer_{kind}" ] for block in range(NUM_BLOCKS) ] ) for basis in BASES ] ) for task_id in TASK_ORDER ] ).astype(np.float64, copy=False) for kind in ("valid", "suppressed"): output[f"source_{kind}"] = np.stack( [ np.stack( [ np.stack( [ self.tasks[task_id].block_summary[(basis, block, "gated_product")][ f"transfer_source_{kind}" ] for block in range(NUM_BLOCKS) ] ) for basis in BASES ] ) for task_id in TASK_ORDER ] ).astype(np.int64, copy=False) contrasts = bootstrap["contrasts_vs_B"] contrast_tasks = tuple(task_id for task_id in TASK_ORDER if task_id in contrasts) metric_names = tuple(contrasts[contrast_tasks[0]]) shape = (len(contrast_tasks), len(metric_names)) defined = np.zeros(shape, dtype=np.bool_) point = np.full(shape, np.nan, dtype=np.float64) ci90 = np.full(shape + (2,), np.nan, dtype=np.float64) ci95 = np.full(shape + (2,), np.nan, dtype=np.float64) for task_index, task_id in enumerate(contrast_tasks): if tuple(contrasts[task_id]) != metric_names: raise AssertionError("bootstrap contrast metric order changed across tasks") for metric_index, metric in enumerate(metric_names): row = contrasts[task_id][metric] if row["relative_difference_defined"]: defined[task_index, metric_index] = True point[task_index, metric_index] = row["relative_difference_point"] ci90[task_index, metric_index] = row["relative_difference_ci90"] ci95[task_index, metric_index] = row["relative_difference_ci95"] output.update( { "bootstrap_contrast_task_names": np.asarray(contrast_tasks), "bootstrap_metric_names": np.asarray(metric_names), "bootstrap_relative_difference_defined": defined, "bootstrap_relative_difference_point": point, "bootstrap_relative_difference_ci90": ci90, "bootstrap_relative_difference_ci95": ci95, "bootstrap_replicates": np.asarray(bootstrap["replicates"], dtype=np.int64), "bootstrap_seed": np.asarray(bootstrap["seed"], dtype=np.int64), } ) output.update( { "per_block_bootstrap_task_names": transfer["task_names"], "per_block_bootstrap_quantile_levels": transfer["quantile_levels"], "per_block_primary_point": transfer["primary_point"], "per_block_primary_quantiles": transfer["primary_quantiles"], "per_block_primary_defined": transfer["primary_defined"], "per_block_primary_defined_replicates": transfer[ "primary_defined_replicates" ], "per_block_conditional_point": transfer["conditional_point"], "per_block_conditional_quantiles": transfer["conditional_quantiles"], "per_block_conditional_defined": transfer["conditional_defined"], "per_block_conditional_defined_replicates": transfer[ "conditional_defined_replicates" ], "per_block_scalar_names": transfer["scalar_names"], "per_block_scalar_point": transfer["scalar_point"], "per_block_scalar_quantiles": transfer["scalar_quantiles"], "per_block_scalar_defined": transfer["scalar_defined"], "per_block_scalar_defined_replicates": transfer[ "scalar_defined_replicates" ], "global_scalar_quantiles": transfer["global_scalar_quantiles"], } ) return output @staticmethod def svg_line_chart( title: str, x_labels: Sequence[str], series: Sequence[dict[str, Any]], *, y_label: str, ) -> bytes: width, height = 1280, 720 left, right, top, bottom = 92.0, 34.0, 68.0, 112.0 plot_width = width - left - right plot_height = height - top - bottom finite_values: list[float] = [] for item in series: for field in ("values", "low", "high"): finite_values.extend( float(value) for value in item.get(field, []) if value is not None and math.isfinite(float(value)) ) if not finite_values: raise ValueError(f"figure {title} has no defined values") y_min, y_max = min(finite_values), max(finite_values) padding = max((y_max - y_min) * 0.08, max(abs(y_min), abs(y_max), 1.0) * 0.01) y_min -= padding y_max += padding colors = ("#1b5e8a", "#c43c35", "#18875b", "#7b4a9e", "#d47b16", "#52606d") def sx(index: int) -> float: return left + (plot_width * index / max(1, len(x_labels) - 1)) def sy(value: float) -> float: return top + (y_max - value) * plot_height / (y_max - y_min) parts = [ '', f'', '', f'{html.escape(title)}', f'', f'', f'{html.escape(y_label)}', ] for tick in range(6): value = y_min + (y_max - y_min) * tick / 5 y = sy(value) parts.extend( [ f'', f'{value:.4g}', ] ) for index, label in enumerate(x_labels): x = sx(index) parts.append( f'{html.escape(str(label))}' ) for series_index, item in enumerate(series): color = colors[series_index % len(colors)] values = item["values"] low = item.get("low", values) high = item.get("high", values) segments: list[list[str]] = [] current: list[str] = [] for index, value in enumerate(values): if value is None or not math.isfinite(float(value)): if current: segments.append(current) current = [] continue x, y = sx(index), sy(float(value)) current.append(f"{x:.2f},{y:.2f}") lo = low[index] if index < len(low) else value hi = high[index] if index < len(high) else value if lo is not None and hi is not None and math.isfinite(float(lo)) and math.isfinite(float(hi)): parts.append( f'' ) parts.append( f'' ) if current: segments.append(current) for segment in segments: if len(segment) >= 2: parts.append( f'' ) legend_x = left + (series_index % 4) * 270 legend_y = height - 30 - (series_index // 4) * 22 parts.extend( [ f'', f'{html.escape(str(item["name"]))}', ] ) parts.append("\n") return "\n".join(parts).encode("utf-8") def build_figures( self, accuracy_bootstrap: dict[str, Any], statistics: dict[str, Any], transfer: dict[str, Any], raw_amplitude: list[dict[str, Any]], points: dict[str, dict[str, float | None]], d_order_rows: Sequence[dict[str, Any]], ) -> dict[str, bytes]: accuracy_map = { (row["task_id"], row["condition"], row["metric"]): row for row in accuracy_bootstrap["series_summaries"] } accuracy_series = [] for task_id in CANONICAL_ARMS: rows = [accuracy_map[(task_id, condition, "top1")] for condition in EXPECTED_CONDITIONS] accuracy_series.append( { "name": task_id, "values": [row["point"] for row in rows], "low": [row["bootstrap_ci95_low"] for row in rows], "high": [row["bootstrap_ci95_high"] for row in rows], } ) d_top1_alternates = finite_values( points[task_id]["top1"] for task_id in D_ORDER_TASKS[1:] ) accuracy_series.append( { "name": "D registered-order range (unfiltered; low-pass NA)", "values": [points["D"]["top1"], None, None, None, None], "low": [ min(d_top1_alternates) if d_top1_alternates is not None else None, None, None, None, None, ], "high": [ max(d_top1_alternates) if d_top1_alternates is not None else None, None, None, None, None, ], } ) figures = { "figures/accuracy_lowpass.svg": self.svg_line_chart( "ImageNet Top-1 under registered low-pass conditions", EXPECTED_CONDITIONS, accuracy_series, y_label="Top-1 (%) with receiver-bootstrap 95% CI", ) } operator_index = { name: index for index, name in enumerate(statistics["operator_metric_names"]) } d_order_lookup = { (row["basis"], row["global_block_index"]): row for row in d_order_rows } mixing_series: list[dict[str, Any]] = [] for task_index, task_id in enumerate(CANONICAL_ARMS): for metric in ("m_off", "m_res"): index = operator_index[metric] quantiles = statistics["operator_quantiles"][task_index, 0, :, index] mixing_series.append( { "name": f"{task_id} {metric}", "values": statistics["operator_point"][task_index, 0, :, index].tolist(), "low": quantiles[:, 0].tolist(), "high": quantiles[:, 2].tolist(), } ) for metric in ("m_off", "m_res"): rows = [d_order_lookup[("fft", block)] for block in range(NUM_BLOCKS)] mixing_series.append( { "name": f"D registered-order envelope {metric}", "values": [row[f"{metric}_D"] for row in rows], "low": [row[f"{metric}_alternate_min"] for row in rows], "high": [row[f"{metric}_alternate_max"] for row in rows], } ) figures["figures/mixing_depth_profile.svg"] = self.svg_line_chart( "FFT scale-free mixing across all 17 blocks", [f"b{index + 1}" for index in range(NUM_BLOCKS)], mixing_series, y_label="M_off / M_res (95% CI)", ) normalized_index = { name: index for index, name in enumerate(statistics["normalized_metric_names"]) } signal_index = { name: index for index, name in enumerate(statistics["signal_names"]) } spectral_labels = [ f"S{stage}:{ROOT_SIGNAL_PREFIXES[signal]}" for stage in range(1, 5) for signal in ROOT_SIGNAL_PREFIXES ] spectral_series = [] metric_index = normalized_index["psd_high_fraction"] for task_index, task_id in enumerate(CANONICAL_ARMS): values: list[float | None] = [] lows: list[float | None] = [] highs: list[float | None] = [] for stage in range(1, 5): block_indices = [ index for index, value in enumerate(EXPECTED_STAGES) if value == stage ] for signal in ROOT_SIGNAL_PREFIXES: block_values = statistics["normalized_point"][ task_index, 0, block_indices, signal_index[signal], metric_index ] values.append(finite_or_none(np.nanmean(block_values))) quantile = statistics["normalized_stage_quantiles"][ task_index, 0, stage - 1, signal_index[signal], metric_index ] lows.append(finite_or_none(quantile[0])) highs.append(finite_or_none(quantile[2])) spectral_series.append( {"name": task_id, "values": values, "low": lows, "high": highs} ) d_values: list[float | None] = [] d_lows: list[float | None] = [] d_highs: list[float | None] = [] for stage in range(1, 5): stage_blocks = [ index for index, value in enumerate(EXPECTED_STAGES) if value == stage ] for signal, prefix in ROOT_SIGNAL_PREFIXES.items(): task_means: list[float | None] = [] for task_id in D_ORDER_TASKS: values = finite_values( d_order_lookup[("fft", block)].get( f"{prefix}_psd_high_fraction_{task_id}" ) for block in stage_blocks ) task_means.append( float(np.mean(np.asarray(values), dtype=np.float64)) if values is not None else None ) defined = [value for value in task_means if value is not None] d_values.append(task_means[0]) alternate = [value for value in task_means[1:] if value is not None] d_lows.append(min(alternate) if len(alternate) == 2 else None) d_highs.append(max(alternate) if len(alternate) == 2 else None) spectral_series.append( { "name": "D registered-order envelope", "values": d_values, "low": d_lows, "high": d_highs, } ) figures["figures/spectral_stage_profile.svg"] = self.svg_line_chart( "Four-stage FFT normalized high-frequency profile for x, q, and y", spectral_labels, spectral_series, y_label="High-frequency fraction (95% CI)", ) rho_index = operator_index["rho_used"] coherence_series = [] for task_index, task_id in enumerate(CANONICAL_ARMS): quantiles = statistics["operator_quantiles"][task_index, 0, :, rho_index] coherence_series.append( { "name": task_id, "values": statistics["operator_point"][task_index, 0, :, rho_index].tolist(), "low": quantiles[:, 0].tolist(), "high": quantiles[:, 2].tolist(), } ) coherence_series.append( { "name": "D registered-order envelope", "values": [ d_order_lookup[("fft", block)]["rho_used_D"] for block in range(NUM_BLOCKS) ], "low": [ d_order_lookup[("fft", block)]["rho_used_alternate_min"] for block in range(NUM_BLOCKS) ], "high": [ d_order_lookup[("fft", block)]["rho_used_alternate_max"] for block in range(NUM_BLOCKS) ], } ) figures["figures/coherence_depth_profile.svg"] = self.svg_line_chart( "Carrier to used-gate coherence across depth", [f"b{index + 1}" for index in range(NUM_BLOCKS)], coherence_series, y_label="rho_used class-equal mean (95% CI)", ) figures["figures/transfer_heatmaps.svg"] = self.transfer_heatmap_svg( transfer, d_order_rows ) figures["figures/accuracy_mixing_raw.svg"] = self.accuracy_mixing_svg( accuracy_map, transfer, raw_amplitude, points, d_order_rows ) return figures @staticmethod def transfer_heatmap_svg( transfer: dict[str, Any], d_order_rows: Sequence[dict[str, Any]] ) -> bytes: width, height = 1560, 1120 cell = 52 block = 8 tasks = ("B", "D", "C") panels = [ (task, basis, kind) for task in tasks for basis in BASES for kind in ("primary", "conditional") ] parts = [ '', f'', '', 'Block-9 transfer: canonical point; D shows registered-order range', ] task_index = {task: index for index, task in enumerate(CANONICAL_ARMS)} d_order_lookup = { (row["basis"], row["global_block_index"]): row for row in d_order_rows } def compact(value: Any) -> str: number = finite_or_none(value) return f"{number:.3f}" if number is not None else "NA" for panel_index, (task, basis, kind) in enumerate(panels): column = panel_index % 4 row = panel_index // 4 x0 = 45 + column * 380 y0 = 86 + row * 330 basis_index = BASES.index(basis) point = transfer[f"{kind}_point"][task_index[task], basis_index, block] quantile = transfer[f"{kind}_quantiles"][task_index[task], basis_index, block] parts.append( f'{task} {basis.upper()} {kind}' ) for source in range(NUM_BANDS): for target in range(NUM_BANDS): value = point[source, target] defined = math.isfinite(float(value)) shade = int(round(248 - 150 * min(max(float(value), 0.0), 1.0))) if defined else 235 fill = f"rgb({shade},{min(250, shade + 18)},{min(255, shade + 35)})" x = x0 + target * cell y = y0 + source * cell parts.append( f'' ) if defined: bootstrap_lo = quantile[source, target, 0] bootstrap_hi = quantile[source, target, 2] if task == "D": metric = f"transfer_{kind}_s{source}_t{target}" range_row = d_order_lookup[(basis, block)] order_lo = range_row[f"{metric}_alternate_min"] order_hi = range_row[f"{metric}_alternate_max"] labels = [ f'{value:.3f}', f'CI {bootstrap_lo:.3f},{bootstrap_hi:.3f}', f'alt {compact(order_lo)},{compact(order_hi)}', ] else: labels = [ f'{value:.3f}', f'CI {bootstrap_lo:.3f},{bootstrap_hi:.3f}', ] parts.extend(labels) else: if task == "D": metric = f"transfer_{kind}_s{source}_t{target}" range_row = d_order_lookup[(basis, block)] parts.extend( [ f'canonical NA', f'CI NA', f'alt {compact(range_row[f"{metric}_alternate_min"])},{compact(range_row[f"{metric}_alternate_max"])}', ] ) else: parts.append( f'undefined' ) parts.append( f'target band 0..3; rows are source bands' ) parts.append("\n") return "\n".join(parts).encode("utf-8") @staticmethod def accuracy_mixing_svg( accuracy_map: Mapping[tuple[str, str, str], dict[str, Any]], transfer: dict[str, Any], raw_amplitude: Sequence[dict[str, Any]], points: Mapping[str, Mapping[str, float | None]], d_order_rows: Sequence[dict[str, Any]], ) -> bytes: width, height = 1120, 720 left, top, plot_width, plot_height = 100.0, 72.0, 900.0, 530.0 scalar_names = tuple(str(item) for item in transfer["scalar_names"].tolist()) m_off_index = scalar_names.index("m_off") xs = [float(points[task]["fft_m_off"]) for task in CANONICAL_ARMS] ys = [float(points[task]["top1"]) for task in CANONICAL_ARMS] x_quantiles = transfer["global_scalar_quantiles"][:, 0, m_off_index] y_rows = [accuracy_map[(task, "unfiltered", "top1")] for task in CANONICAL_ARMS] x_min = min(float(x_quantiles[:, 0].min()), min(xs)) x_max = max(float(x_quantiles[:, 2].max()), max(xs)) y_min = min(row["bootstrap_ci95_low"] for row in y_rows) y_max = max(row["bootstrap_ci95_high"] for row in y_rows) x_pad = max((x_max - x_min) * 0.12, 1e-4) y_pad = max((y_max - y_min) * 0.12, 0.5) x_min, x_max = x_min - x_pad, x_max + x_pad y_min, y_max = y_min - y_pad, y_max + y_pad d_fft_rows = sorted( (row for row in d_order_rows if row["basis"] == "fft"), key=lambda row: row["global_block_index"], ) d_global_x = { task_id: float( np.mean( np.asarray([row[f"m_off_{task_id}"] for row in d_fft_rows]), dtype=np.float64, ) ) for task_id in D_ORDER_TASKS } d_x_alternates = [d_global_x[task_id] for task_id in D_ORDER_TASKS[1:]] d_x_low, d_x_high = min(d_x_alternates), max(d_x_alternates) d_y_values = [float(points[task_id]["top1"]) for task_id in D_ORDER_TASKS[1:]] d_y_low, d_y_high = min(d_y_values), max(d_y_values) d_raw = { task_id: float( np.mean( np.asarray( [ row[f"raw_y_centered_rms_dataset_median_{task_id}"] for row in d_fft_rows ] ), dtype=np.float64, ) ) for task_id in D_ORDER_TASKS } d_raw_alternates = [d_raw[task_id] for task_id in D_ORDER_TASKS[1:]] d_raw_low, d_raw_high = min(d_raw_alternates), max(d_raw_alternates) x_min, x_max = min(x_min, d_x_low - x_pad), max(x_max, d_x_high + x_pad) y_min, y_max = min(y_min, d_y_low - y_pad), max(y_max, d_y_high + y_pad) def sx(value: float) -> float: return left + (value - x_min) * plot_width / (x_max - x_min) def sy(value: float) -> float: return top + (y_max - value) * plot_height / (y_max - y_min) raw_lookup: dict[str, float | None] = {} for task in CANONICAL_ARMS: values = [ row["dataset_median"] for row in raw_amplitude if row["task_id"] == task and row["signal"] == "gated_product" and row["metric"] == "centered_rms" and row["dataset_median"] is not None ] raw_lookup[task] = float(np.mean(values, dtype=np.float64)) if values else None colors = ("#1b5e8a", "#c43c35", "#18875b", "#7b4a9e", "#d47b16") parts = [ '', f'', '', 'Accuracy, scale-free mixing, and raw output energy', f'', f'', f'Global FFT M_off (95% CI)', f'ImageNet Top-1 % (95% CI)', f'', f'D registered-order x/y range', f'D raw y RMS alternate-order range [{d_raw_low:.4g}, {d_raw_high:.4g}]', ] for index, task in enumerate(CANONICAL_ARMS): x, y = xs[index], ys[index] xlo, _, xhi = x_quantiles[index] ylo, yhi = y_rows[index]["bootstrap_ci95_low"], y_rows[index]["bootstrap_ci95_high"] color = colors[index] parts.extend( [ f'', f'', f'', f'{task}; median y RMS={raw_lookup[task]:.4g}', ] ) parts.append("\n") return "\n".join(parts).encode("utf-8") def root_report( self, points: dict[str, dict[str, float | None]], decision: dict[str, Any], accuracy_rows: list[dict[str, Any]], accuracy_bootstrap: dict[str, Any], spectral_rows: list[dict[str, Any]], stage_rows: list[dict[str, Any]], coherence_rows: list[dict[str, Any]], raw_amplitude_rows: list[dict[str, Any]], d_order_rows: Sequence[dict[str, Any]], ) -> bytes: def fmt(value: Any, digits: int = 4) -> str: if value is None: return "undefined" number = float(value) return f"{number:.{digits}f}" if math.isfinite(number) else "undefined" accuracy_ci = { (row["task_id"], row["condition"], row["metric"]): row for row in accuracy_bootstrap["series_summaries"] } spectral_by_key = { (row["task_id"], row["basis"], row["global_block_index"]): row for row in spectral_rows } stage_by_key = { (row["task_id"], row["basis"], row["stage"], row["signal"]): row for row in stage_rows } d_order_by_key = { (row["basis"], row["global_block_index"]): row for row in d_order_rows } lines = [ "# Matched ImageNet Spectral Audit Report", "", f"Protocol: `{PROTOCOL_ID}`", "", "All eight registered tasks passed the mechanical cross-task validator. This is a " "single-training-seed descriptive audit; receiver-bootstrap intervals describe " "validation-set sampling and not training-run uncertainty.", "The B/B_order1 control passed a stronger row-level invariance check after canonical " "receiver alignment across accuracy and every spectral NPZ array; this directly " "covers raw median/IQR, gate, coherence, and transfer aggregates.", "", "## Required figures", "", "![Accuracy low-pass profile](figures/accuracy_lowpass.svg)", "", "![Mixing depth profile](figures/mixing_depth_profile.svg)", "", "![Spectral stage profile](figures/spectral_stage_profile.svg)", "", "![Coherence depth profile](figures/coherence_depth_profile.svg)", "", "![Representative transfer heatmaps](figures/transfer_heatmaps.svg)", "", "![Accuracy, mixing, and raw energy](figures/accuracy_mixing_raw.svg)", "", "## Five-arm clean and low-pass accuracy", "", "| Arm | Condition | Top-1 count | Top-1 [95% CI] | Top-5 count | Top-5 | NLL | ECE |", "|---|---|---:|---:|---:|---:|---:|---:|", ] for row in accuracy_rows: ci = accuracy_ci[(row["task_id"], row["condition"], "top1")] lines.append( f"| {row['task_id']} | {row['condition']} | {row['top1_correct']} | " f"{fmt(row['top1'], 3)} [{fmt(ci['bootstrap_ci95_low'], 3)}, " f"{fmt(ci['bootstrap_ci95_high'], 3)}] | {row['top5_correct']} | " f"{fmt(row['top5'], 3)} | {fmt(row['nll'])} | {fmt(row['ece'])} |" ) lines.extend( [ "", "All 50,000 images contribute to every point. The exact shared, class-stratified " "paired contrast intervals are in `accuracy_bootstrap.csv`.", LOWPASS_CAUSAL_CAVEAT, "", "## Accuracy and global-depth mixing", "", "| Task | Top-1 | FFT M_off | FFT M_res | DCT M_off | DCT M_res |", "|---|---:|---:|---:|---:|---:|", ] ) for task_id in TASK_ORDER: row = points[task_id] lines.append( f"| {task_id} | {fmt(row['top1'], 3)} | {fmt(row['fft_m_off'], 6)} | " f"{fmt(row['fft_m_res'], 6)} | {fmt(row['dct_m_off'], 6)} | " f"{fmt(row['dct_m_res'], 6)} |" ) lines.extend( [ "", "## Seventeen-block FFT M_off and M_res profile", "", "| Arm | Block | Stage | M_off [95% CI] | M_res [95% CI] | Suppressed | Constant q |", "|---|---:|---:|---:|---:|---:|---:|", ] ) for task_id in CANONICAL_ARMS: for block in range(NUM_BLOCKS): row = spectral_by_key[(task_id, "fft", block)] lines.append( f"| {task_id} | {block + 1} | {row['stage']} | {fmt(row['m_off'], 5)} " f"[{fmt(row['m_off_ci95_low'], 5)}, {fmt(row['m_off_ci95_high'], 5)}] | " f"{fmt(row['m_res'], 5)} [{fmt(row['m_res_ci95_low'], 5)}, " f"{fmt(row['m_res_ci95_high'], 5)}] | {fmt(row['suppressed_fraction'], 5)} | " f"{fmt(row['constant_gate_fraction'], 5)} |" ) lines.extend( [ "", "## D registered-order ranges by block", "", "Each entry reports the D canonical value followed by the range across the two " "alternate registered orders (D_order1 and D_order2). " "`d_order_sensitivity_by_block.csv` contains every normalized x/q/y point, " "raw-amplitude and gate field, coherence/JSD/paired-delta/operator metric, " "source-valid/suppressed quantity, and every primary/conditional transfer cell.", "In that table, `raw_*_dataset_median/q25/q75` are the registered per-image " "channel-median raw estimators; the unsuffixed wide RMS fields remain the " "separately labeled image-equal aggregate means.", "", "| Block | Stage | FFT M_off: D; alt range | FFT M_res: D; alt range | conditional M_res: D; alt range | y HF: D; alt range | raw y RMS median: D; alt range | rho_used: D; alt range | source-suppressed: D; alt range |", "|---:|---:|---:|---:|---:|---:|---:|---:|---:|", ] ) for block in range(NUM_BLOCKS): row = d_order_by_key[("fft", block)] lines.append( f"| {block + 1} | {row['stage']} | " f"{fmt(row['m_off_D'], 6)}; [{fmt(row['m_off_alternate_min'], 6)}, {fmt(row['m_off_alternate_max'], 6)}] | " f"{fmt(row['m_res_D'], 6)}; [{fmt(row['m_res_alternate_min'], 6)}, {fmt(row['m_res_alternate_max'], 6)}] | " f"{fmt(row['m_res_conditional_D'], 6)}; [{fmt(row['m_res_conditional_alternate_min'], 6)}, {fmt(row['m_res_conditional_alternate_max'], 6)}] | " f"{fmt(row['y_psd_high_fraction_D'], 6)}; [{fmt(row['y_psd_high_fraction_alternate_min'], 6)}, {fmt(row['y_psd_high_fraction_alternate_max'], 6)}] | " f"{fmt(row['raw_y_centered_rms_dataset_median_D'], 6)}; [{fmt(row['raw_y_centered_rms_dataset_median_alternate_min'], 6)}, {fmt(row['raw_y_centered_rms_dataset_median_alternate_max'], 6)}] | " f"{fmt(row['rho_used_D'], 6)}; [{fmt(row['rho_used_alternate_min'], 6)}, {fmt(row['rho_used_alternate_max'], 6)}] | " f"{fmt(row['source_suppressed_fraction_D'], 6)}; " f"[{fmt(row['source_suppressed_fraction_alternate_min'], 6)}, " f"{fmt(row['source_suppressed_fraction_alternate_max'], 6)}] |" ) lines.extend( [ "", "## Four-stage carrier, gate, and output spectral profile", "", "| Arm | Signal | Stage | FFT HF mean [block min,max] (95% CI) | FFT centroid mean [block min,max] |", "|---|---|---:|---:|---:|", ] ) for task_id in CANONICAL_ARMS: for signal in ROOT_SIGNAL_PREFIXES: for stage in range(1, 5): row = stage_by_key[(task_id, "fft", stage, signal)] lines.append( f"| {task_id} | {signal} | {stage} | " f"{fmt(row['psd_high_fraction_mean'], 5)} " f"[{fmt(row['psd_high_fraction_block_min'], 5)}, " f"{fmt(row['psd_high_fraction_block_max'], 5)}] " f"([{fmt(row['psd_high_fraction_ci95_low'], 5)}, " f"{fmt(row['psd_high_fraction_ci95_high'], 5)}]) | " f"{fmt(row['psd_centroid_mean'], 5)} " f"[{fmt(row['psd_centroid_block_min'], 5)}, " f"{fmt(row['psd_centroid_block_max'], 5)}] |" ) lines.extend( [ "", "## rho_used depth profile", "", "| Arm | Block | Stage | Class-equal mean | Receiver q05/q50/q95 | Valid/invalid channels |", "|---|---:|---:|---:|---:|---:|", ] ) for row in coherence_rows: if row["task_id"] in CANONICAL_ARMS and row["coherence"] == "rho_used": lines.append( f"| {row['task_id']} | {row['global_block_index'] + 1} | {row['stage']} | " f"{fmt(row['class_equal_mean'], 6)} | {fmt(row['receiver_mean_q05'], 5)} / " f"{fmt(row['receiver_mean_q50'], 5)} / {fmt(row['receiver_mean_q95'], 5)} | " f"{row['valid_channels']}/{row['invalid_channels']} |" ) raw_lookup: dict[str, float | None] = {} for task_id in CANONICAL_ARMS: values = [ row["dataset_median"] for row in raw_amplitude_rows if row["task_id"] == task_id and row["signal"] == "gated_product" and row["metric"] == "centered_rms" and row["dataset_median"] is not None ] raw_lookup[task_id] = float(np.mean(values, dtype=np.float64)) if values else None lines.extend( [ "", "## Accuracy, mixing, and raw output energy", "", "| Arm | Top-1 | Loss from B | FFT M_off | FFT M_res | Median y centered RMS, block mean |", "|---|---:|---:|---:|---:|---:|", ] ) for task_id in CANONICAL_ARMS: loss = float(points["B"]["top1"] - points[task_id]["top1"]) lines.append( f"| {task_id} | {fmt(points[task_id]['top1'], 3)} | {fmt(loss, 3)} | " f"{fmt(points[task_id]['fft_m_off'], 6)} | {fmt(points[task_id]['fft_m_res'], 6)} | " f"{fmt(raw_lookup[task_id], 6)} |" ) sensitivity = decision["D_order_sensitivity"] correlational = decision["section_11_3_correlational_caveat"] lines.extend( [ "", "## Representative transfer heatmaps and uncertainty", "", "The transfer figure contains primary and conditional 4x4 FFT/DCT matrices at " "block 9 for B, D, and C. Every cell prints its point and 95% interval. All " "canonical arm/basis/block cells and M_off/M_disp/M_res summaries are in " "`transfer_bootstrap_by_block.csv` and `transfer_matrices.npz`.", "", "## D order-sensitivity range", "", f"Canonical D Top-1: {fmt(sensitivity['canonical_top1'], 3)}; alternate-order " f"range: {fmt(sensitivity['top1_range'][0], 3)} to " f"{fmt(sensitivity['top1_range'][1], 3)}. Canonical D FFT M_off: " f"{fmt(sensitivity['canonical_fft_m_off'], 6)}; alternate-order range: " f"{fmt(sensitivity['fft_m_off_range'][0], 6)} to " f"{fmt(sensitivity['fft_m_off_range'][1], 6)}; relative range " f"{fmt(sensitivity['fft_m_off_relative_range'], 4)}.", "", f"Batch/order-specific narrowing required: " f"**{str(sensitivity['batch_order_specific_narrowing_required']).lower()}**. " f"Stable across registered orders: " f"**{str(sensitivity['stable_across_registered_orders']).lower()}**. " f"Generalizes to arbitrary independent gates: " f"**{str(sensitivity['generalizes_to_arbitrary_independent_gates']).lower()}**.", "", f"Section 11.3 joint-decline correlational caveat required: " f"**{str(correlational['required']).lower()}** " f"(inputs defined={str(correlational['inputs_defined']).lower()}, " f"joint decline observed={str(correlational['joint_decline_observed']).lower()}, " f"accuracy={str(correlational['D_accuracy_declines']).lower()}, " f"raw={str(correlational['raw_energy_declines']).lower()}, " f"normalized PSD={str(correlational['normalized_psd_declines']).lower()}, " f"conditional transfer={str(correlational['conditional_transfer_declines']).lower()}).", f"Section 11.3 primary basis: FFT. DCT robustness states: normalized PSD=" f"{correlational['dct_robustness']['normalized_psd_state']}, conditional transfer=" f"{correlational['dct_robustness']['conditional_transfer_state']}.", "When required, the audit is correlational and does not exclude an energy or " "mixing-quantity explanation, even if a separate practical-equivalence test passes.", "", "## Failure and validity disclosures", "", ] ) undefined = sum( not bool(row[f"{metric}_defined"]) for row in spectral_rows for metric in ROOT_OPERATOR_METRICS ) lines.extend( [ f"- Undefined canonical operator block cells: `{undefined}`. Undefined constant " "or suppressed states remain blank with explicit counts; they are never imputed " "as numeric zero evidence.", "- `raw_amplitude_by_block.csv` and `gate_operating_diagnostics.csv` contain " "receiver channel-median dataset median/IQR/bootstrap intervals.", "- The wide block table reports conditional M_res, constant q, source-valid and " "source-suppressed fractions, JSD-valid counts, and paired output-delta counts.", "- Clipping is not adjudicated here. Clip crossing is an operating diagnostic, " "not evidence that clipping uniquely improves ImageNet accuracy.", "", "## Registered decision", "", f"Strong mechanism statement supported: " f"**{str(decision['strong_mechanism_claim_supported']).lower()}**.", "", ] ) for key, value in decision["conditions"].items(): lines.append(f"- `{key}`: `{str(bool(value)).lower()}`") lines.extend( [ "", decision["permitted_wording"], "", "Order probes are isolated in `order_probe_accuracy.csv` and " "`order_probe_spectral_by_block.csv`; they are never averaged into canonical results.", "", ] ) return "\n".join(lines).encode("utf-8") def deterministic_finished_time(self) -> str: candidates: list[str] = [] for task in self.tasks.values(): value = task.results.get("timestamps", {}).get("finished_at_utc") if isinstance(value, str): candidates.append(value) if len(candidates) != len(TASK_ORDER): raise ValueError("task timestamps.finished_at_utc is missing") return max(candidates) @staticmethod def package_lock_payload() -> dict[str, Any]: rows: list[dict[str, str]] = [] for distribution in importlib.metadata.distributions(): name = distribution.metadata.get("Name") if not name: continue rows.append({"name": str(name), "version": str(distribution.version)}) rows.sort(key=lambda row: (row["name"].casefold(), row["name"], row["version"])) content = stable_json(rows) return { "format": "sorted importlib.metadata distributions", "distributions": rows, "sha256": bytes_sha256(content), } @staticmethod def array_schema( arrays: Mapping[str, np.ndarray], *, family: str ) -> dict[str, dict[str, Any]]: schema: dict[str, dict[str, Any]] = {} for name, array in arrays.items(): if family == "accuracy": if name == "task_names": axes = ["task"] elif name == "condition_names": axes = ["condition"] elif name == "condition_present": axes = ["task", "condition"] elif name in {"evaluation_position", "canonical_index", "target"}: axes = ["task", "receiver"] else: axes = ["task", "condition", "receiver"] else: if name == "task_names": axes = ["task"] elif name in {"canonical_index", "class_id"}: axes = ["receiver"] elif name == "signal_names": axes = ["signal"] elif name == "coherence_names": axes = ["coherence"] elif name.startswith("block_"): axes = ["block"] elif "transfer_primary" in name or "transfer_conditional" in name: axes = ["task", "receiver", "block", "source_band", "target_band"] elif "transfer_source" in name: axes = ["task", "receiver", "block", "source_band"] elif name.startswith("coherence_"): axes = ["task", "receiver", "block", "coherence"] elif name.startswith("signal_") or "_psd_" in name: axes = ["task", "receiver", "block", "signal"] else: axes = ["task", "receiver", "block"] if len(axes) != array.ndim: raise AssertionError(f"schema axes for {family}.{name} do not match rank") schema[name] = { "dtype": str(array.dtype), "shape": list(array.shape), "axes": axes, } return schema def validate_publishable_outputs( self, *, accuracy_rows: list[dict[str, Any]], order_accuracy_rows: list[dict[str, Any]], accuracy_bootstrap: dict[str, Any], spectral_rows: list[dict[str, Any]], order_spectral_rows: list[dict[str, Any]], d_order_rows: list[dict[str, Any]], stage_rows: list[dict[str, Any]], transfer: dict[str, Any], transfer_rows: list[dict[str, Any]], raw_rows: list[dict[str, Any]], gate_rows: list[dict[str, Any]], figures: Mapping[str, bytes], report: bytes, ) -> dict[str, bool]: expected_figures = { "figures/accuracy_lowpass.svg", "figures/mixing_depth_profile.svg", "figures/spectral_stage_profile.svg", "figures/coherence_depth_profile.svg", "figures/transfer_heatmaps.svg", "figures/accuracy_mixing_raw.svg", } scalar_count = len(transfer["scalar_names"]) raw_metric_names = { "centered_rms", "log10_centered_energy", "noncentered_rms", "gate_mean", "gate_cv", "gate_zero_fraction", "gate_active_fraction", "gate_clip_crossing_fraction", } expected_raw_count = len(TASK_ORDER) * NUM_BLOCKS * (3 * 3 + 5) raw_keys = { (row["task_id"], row["global_block_index"], row["signal"], row["metric"]) for row in raw_rows } raw_complete = len(raw_rows) == expected_raw_count and len(raw_keys) == len(raw_rows) for row in raw_rows: metric = row["metric"] valid = int(row["valid_receivers"]) invalid = int(row["invalid_receivers"]) canonical = row["task_id"] in CANONICAL_ARMS summary = finite_values((row["dataset_median"], row["q25"], row["q75"])) row_ok = metric in raw_metric_names and valid + invalid == NUM_SPECTRAL_IMAGES if metric in {"centered_rms", "noncentered_rms"} or metric.startswith("gate_"): row_ok = row_ok and valid == NUM_SPECTRAL_IMAGES and invalid == 0 row_ok = row_ok and summary is not None if metric in {"centered_rms", "noncentered_rms"} and summary is not None: row_ok = row_ok and min(summary) >= 0.0 elif metric == "log10_centered_energy": row_ok = row_ok and ((valid > 0 and summary is not None) or (valid == 0 and summary is None)) if canonical: row_ok = row_ok and row["bootstrap_replicates"] == BOOTSTRAP_REPLICATES if valid > 0: row_ok = row_ok and finite_values( (row["bootstrap_ci95_low"], row["bootstrap_ci95_high"]) ) is not None else: row_ok = row_ok and row["bootstrap_ci95_low"] is None row_ok = row_ok and row["bootstrap_ci95_high"] is None else: row_ok = row_ok and row["bootstrap_ci95_low"] is None row_ok = row_ok and row["bootstrap_ci95_high"] is None row_ok = row_ok and row["bootstrap_replicates"] is None raw_complete = raw_complete and bool(row_ok) expected_gate_count = len(TASK_ORDER) * NUM_BLOCKS * ( 5 + len(BASES) * len(ROOT_OPERATOR_METRICS) ) gate_keys = { (row["task_id"], row["basis"], row["global_block_index"], row["metric"]) for row in gate_rows } gate_complete = len(gate_rows) == expected_gate_count and len(gate_keys) == len(gate_rows) for row in gate_rows: valid = int(row["valid_receivers"]) invalid = int(row["invalid_receivers"]) point_defined = finite_or_none(row["point"]) is not None canonical = row["task_id"] in CANONICAL_ARMS row_ok = valid + invalid == NUM_SPECTRAL_IMAGES row_ok = row_ok and point_defined == (valid > 0) if row["basis"] == "": row_ok = row_ok and valid == NUM_SPECTRAL_IMAGES row_ok = row_ok and finite_values( (row["dataset_median"], row["q25"], row["q75"]) ) is not None if canonical: row_ok = row_ok and row["bootstrap_replicates"] == BOOTSTRAP_REPLICATES if point_defined: row_ok = row_ok and finite_values( (row["bootstrap_ci95_low"], row["bootstrap_ci95_high"]) ) is not None else: row_ok = row_ok and row["bootstrap_ci95_low"] is None row_ok = row_ok and row["bootstrap_ci95_high"] is None else: row_ok = row_ok and row["bootstrap_ci95_low"] is None row_ok = row_ok and row["bootstrap_ci95_high"] is None row_ok = row_ok and row["bootstrap_replicates"] is None gate_complete = gate_complete and bool(row_ok) d_order_complete = ( len(d_order_rows) == len(BASES) * NUM_BLOCKS and len( { (row["basis"], row["global_block_index"]) for row in d_order_rows } ) == len(d_order_rows) and all(set(row) == set(D_ORDER_SENSITIVITY_COLUMNS) for row in d_order_rows) ) for row in d_order_rows: d_order_complete = d_order_complete and row["registered_task_count"] == 3 for metric in D_ORDER_RANGE_METRICS: values = [ finite_or_none(row[f"{metric}_{task_id}"]) for task_id in D_ORDER_TASKS ] task_defined_flags_match = all( bool(row[f"{metric}_{task_id}_defined"]) == (values[index] is not None) for index, task_id in enumerate(D_ORDER_TASKS) ) finite = [value for value in values if value is not None] expected_alternate_min, expected_alternate_max, expected_alternate_defined = ( complete_alternate_range(values[1:]) ) expected_min = min(finite) if finite else None expected_max = max(finite) if finite else None d_order_complete = d_order_complete and ( task_defined_flags_match and int(row[f"{metric}_defined_count"]) == len(finite) and finite_or_none(row[f"{metric}_min"]) == expected_min and finite_or_none(row[f"{metric}_max"]) == expected_max and finite_or_none(row[f"{metric}_alternate_min"]) == expected_alternate_min and finite_or_none(row[f"{metric}_alternate_max"]) == expected_alternate_max and bool(row[f"{metric}_alternate_range_defined"]) == expected_alternate_defined ) checks = { "canonical_accuracy_25_rows": len(accuracy_rows) == 25 and { (row["task_id"], row["condition"]) for row in accuracy_rows } == set((task, condition) for task in CANONICAL_ARMS for condition in EXPECTED_CONDITIONS), "order_accuracy_3_rows": len(order_accuracy_rows) == 3, "accuracy_bootstrap_10k_and_complete": accuracy_bootstrap["replicates"] == BOOTSTRAP_REPLICATES and len(accuracy_bootstrap["rows"]) == 225, "canonical_spectral_170_rows": len(spectral_rows) == len(CANONICAL_ARMS) * len(BASES) * NUM_BLOCKS, "order_spectral_102_rows": len(order_spectral_rows) == 3 * len(BASES) * NUM_BLOCKS, "D_registered_order_ranges_34_complete_rows": d_order_complete, "canonical_stage_120_rows": len(stage_rows) == len(CANONICAL_ARMS) * len(BASES) * 4 * len(ROOT_SIGNAL_PREFIXES), "transfer_bootstrap_full_coverage": len(transfer_rows) == len(CANONICAL_ARMS) * len(BASES) * NUM_BLOCKS * (2 * NUM_BANDS * NUM_BANDS + scalar_count) and transfer["primary_quantiles"].shape == (len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, 4, 4, 3) and transfer["scalar_quantiles"].shape == (len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, scalar_count, 3), "raw_diagnostics_complete_and_defined": raw_complete, "gate_diagnostics_complete_and_defined": gate_complete, "six_deterministic_svg_assets": set(figures) == expected_figures and all( content.startswith(b'\n") for content in figures.values() ), "report_links_every_required_asset": all( name.encode("utf-8") in report for name in sorted(expected_figures) ) and all( heading in report for heading in ( b"Five-arm clean and low-pass accuracy", b"Seventeen-block FFT M_off and M_res profile", b"Four-stage carrier, gate, and output spectral profile", b"rho_used depth profile", b"D order-sensitivity range", b"D registered-order ranges by block", b"Failure and validity disclosures", ) ) and b"d_order_sensitivity_by_block.csv" in report and b"cannot prove that a specific internal gate" in report and all(b"registered-order" in figures[name] for name in expected_figures), } if not all(checks.values()): failed = sorted(key for key, passed in checks.items() if not passed) raise ValidationFailure(f"publishable-output checklist failed: {failed}") return checks def build_root_artifacts(self) -> dict[str, bytes]: bootstrap_weights = self.bootstrap_weights(self.tasks["B"].spectral["class_id"]) accuracy_bootstrap = self.accuracy_bootstrap() transfer = self.transfer_bootstrap(bootstrap_weights) bootstrap = self.paired_bootstrap(bootstrap_weights, transfer) statistics = self.spectral_block_bootstrap(bootstrap_weights, transfer) raw_amplitude = self.raw_amplitude_diagnostics(bootstrap_weights) coherence = self.coherence_diagnostics() decision, points = self.claim_decision(bootstrap, raw_amplitude) accuracy_rows = [ row for task_id in CANONICAL_ARMS for row in self.tasks[task_id].accuracy_rows ] order_accuracy_rows = [ row for task_id in ("D_order1", "D_order2", "B_order1") for row in self.tasks[task_id].accuracy_rows ] spectral_rows = self.canonical_spectral_rows(statistics) order_spectral_rows = self.order_probe_spectral_rows() d_order_rows = self.d_order_sensitivity_rows(raw_amplitude) stage_rows = self.canonical_stage_rows(statistics) gate_rows = self.gate_operating_rows(statistics, bootstrap_weights) transfer_rows = transfer["rows"] figures = self.build_figures( accuracy_bootstrap, statistics, transfer, raw_amplitude, points, d_order_rows, ) report = self.root_report( points, decision, accuracy_rows, accuracy_bootstrap, spectral_rows, stage_rows, coherence, raw_amplitude, d_order_rows, ) publishable_checks = self.validate_publishable_outputs( accuracy_rows=accuracy_rows, order_accuracy_rows=order_accuracy_rows, accuracy_bootstrap=accuracy_bootstrap, spectral_rows=spectral_rows, order_spectral_rows=order_spectral_rows, d_order_rows=d_order_rows, stage_rows=stage_rows, transfer=transfer, transfer_rows=transfer_rows, raw_rows=raw_amplitude, gate_rows=gate_rows, figures=figures, report=report, ) self.check( "root.publishable_output_checklist", all(publishable_checks.values()), "all required machine-readable tables and deterministic figures must be complete", checklist=publishable_checks, ) formal_complete = all(publishable_checks.values()) and all( row["passed"] for row in self.checks.values() ) if not formal_complete: raise ValidationFailure("formal completion checklist did not pass") accuracy_npz = self.aggregate_accuracy_npz() spectral_npz = self.aggregate_spectral_npz() transfer_npz = self.aggregate_transfer_npz(bootstrap, transfer) finished_at = self.deterministic_finished_time() global_summary = {task_id: points[task_id] for task_id in TASK_ORDER} root_results = { "schema_version": 1, "protocol_id": PROTOCOL_ID, "execution_id": self.manifest["execution_id"], "status": "validated", "formal_complete": formal_complete, "order_audit_complete": True, "matched_total_mixing_supported": decision["matched_total_mixing_supported"], "claim_decision": decision, "global_depth": global_summary, "task_frequency_summary": { task_id: self.tasks[task_id].results["task_frequency_summary"] for task_id in CANONICAL_ARMS }, "bootstrap": bootstrap, "accuracy_bootstrap": accuracy_bootstrap, "per_image_accuracy_schema": self.array_schema( accuracy_npz, family="accuracy" ), "per_image_spectral_schema": self.array_schema( spectral_npz, family="spectral" ), "publishable_output_checklist": publishable_checks, "canonical_table_rows": { "accuracy_by_condition": len(accuracy_rows), "spectral_by_block": len(spectral_rows), "spectral_by_stage": len(stage_rows), "order_probe_accuracy": len(order_accuracy_rows), "order_probe_spectral_by_block": len(order_spectral_rows), "d_order_sensitivity_by_block": len(d_order_rows), "transfer_bootstrap_by_block": len(transfer_rows), }, "raw_amplitude_diagnostics": { "estimator": "per-receiver channel median; observed dataset median/IQR", "bootstrap": { "replicates": BOOTSTRAP_REPLICATES, "seed": BOOTSTRAP_SEED, "scheme": "class-stratified receiver resampling shared across arms and blocks", "canonical_arms_only": True, }, "rows": raw_amplitude, }, "coherence_diagnostics": { "estimator": "HW-centered Pearson per channel, then receiver and class-equal summaries", "rows": coherence, }, "gate_operating_diagnostics": { "primary_q_estimator": ( "runner per-image channel median, then dataset median/IQR and " "class-stratified bootstrap interval of the median" ), "rows": len(gate_rows), }, "task_order": list(TASK_ORDER), "source_hashes": { "input_manifest_sha256": file_sha256(self.manifest_path), "protocol_sha256": self.manifest["protocol"]["sha256"], "runner_sha256": file_sha256(self.runner_path), "aggregator_sha256": file_sha256(Path(__file__).resolve()), "shared_subset_sha256": self.manifest["spectral_subset"]["sha256"], "alignment_source_equivalence_sha256": file_sha256( self.root / "alignment_source_equivalence.json" ), }, "finished_at_utc": finished_at, "complete_marker_written_by_aggregator": False, } validation = { "schema_version": 1, "protocol_id": PROTOCOL_ID, "status": "passed", "formal_complete": formal_complete, "validator_sha256": file_sha256(Path(__file__).resolve()), "input_manifest_sha256": file_sha256(self.manifest_path), "protocol_sha256": self.manifest["protocol"]["sha256"], "tasks": list(TASK_ORDER), "checks": self.checks, "publishable_output_checklist": publishable_checks, "errors": [], "validated_at_utc": finished_at, "writes_complete_marker": False, } frozen_protocol_bytes = Path(self.manifest["protocol"]["path"]).read_bytes() frozen_protocol_text = frozen_protocol_bytes.decode("utf-8") protocol_payload = { "schema_version": 1, "protocol_id": PROTOCOL_ID, "protocol_path": self.manifest["protocol"]["path"], "protocol_sha256": self.manifest["protocol"]["sha256"], "frozen_protocol_markdown_utf8": frozen_protocol_text, "input_manifest": str(self.manifest_path), "input_manifest_sha256": file_sha256(self.manifest_path), "input_manifest_artifact": "input_manifest.json", "frozen_input_manifest": self.manifest, "aggregation_constants": { "task_order": list(TASK_ORDER), "canonical_arms": list(CANONICAL_ARMS), "bases": list(BASES), "signals": list(SIGNAL_NAMES), "coherence_names": list(COHERENCE_NAMES), "stage_depths": list(STAGE_DEPTHS), "num_images": NUM_IMAGES, "num_spectral_images": NUM_SPECTRAL_IMAGES, "num_blocks": NUM_BLOCKS, "num_classes": NUM_CLASSES, "num_bands": NUM_BANDS, "bootstrap_replicates": BOOTSTRAP_REPLICATES, "bootstrap_seed": BOOTSTRAP_SEED, "measurement_constants": { "radial_band_edges": [0.0, 0.25, 0.5, 0.75, 1.0], "high_frequency_split": 0.5, "fft_normalization": "orthonormal 2D FFT; centered maps; no window", "dct_normalization": "orthonormal 2D DCT-II; centered maps; no window", "per_image_channel_normalization": True, "lowpass_order": 4, "lowpass_cutoffs": list( self.manifest["runtime"]["lowpass_cutoffs"] ), "centered_energy_threshold": ( "32 * finfo(float64).eps * max(H*W,1) * " "sum(noncentered_map^2)" ), "conditional_undefined_policy": ( "blank with explicit defined/valid counts; never numeric-zero imputation" ), "primary_suppressed_transfer_policy": "valid suppressed rows are all-zero", }, "mechanical_tolerances": { "gate_reconstruction_rtol": 1e-6, "gate_reconstruction_atol": 1e-7, "transform_reconstruction_relative_l2_max": 1e-10, "parseval_relative_error_max": 1e-10, "constant_gate_m_off_max": 1e-6, "identity_coherence_absolute_error_max": 1e-7, "invalid_fraction_strict_upper_bound": 0.01, "B_order_normalized_metric_absolute_max": 1e-6, "mixing_denominator_floor": 1e-6, }, "interpretation_thresholds": { "comparable_fft_relative_margin": 0.10, "comparable_dct_relative_margin": 0.15, "comparable_suppression_absolute_margin": 0.05, "D_minimum_B_mixing_fraction": 0.50, "D_minimum_top1_gap": 10.0, "C_minimum_B_mixing_fraction": 0.80, "C_maximum_top1_gap": 2.0, "SC_minimum_top1_gap_below_C": 3.0, "D_order_m_off_relative_narrowing": 0.20, "D_order_top1_absolute_narrowing": 2.0, }, }, "task_count": 8, } package_lock = self.package_lock_payload() provenance = self.manifest["code_provenance"] environment_payload = { "schema_version": 1, "protocol_id": PROTOCOL_ID, "package_lock": package_lock, "formal_task_package_lock": load_json( self.tasks["B"].root / "environment.json" )["package_lock"], "code_manifest_identity": { "audit_runtime": { "code_sha256": provenance["audit_runtime_code_sha256"], "manifest": provenance["audit_runtime_manifest"], "manifest_sha256": provenance["audit_runtime_manifest_sha256"], "gmnet_source_sha256": provenance["audit_runtime_gmnet_sha256"], }, "alignment_training": { "code_sha256": provenance["alignment_training_code_sha256"], "manifest": provenance["alignment_training_manifest"], "manifest_sha256": provenance["alignment_training_manifest_sha256"], "source_snapshot_manifest": provenance[ "alignment_source_snapshot_manifest" ], "source_snapshot_manifest_sha256": provenance[ "alignment_source_snapshot_manifest_sha256" ], "gmnet_source_sha256": provenance["alignment_source_gmnet_sha256"], }, "runner_sha256": file_sha256(self.runner_path), "aggregator_sha256": file_sha256(Path(__file__).resolve()), }, "task_environments": { task_id: load_json(self.tasks[task_id].root / "environment.json") for task_id in TASK_ORDER }, } checkpoint_payload = { "schema_version": 1, "protocol_id": PROTOCOL_ID, "training_code_boundaries": { "audit_runtime_code_sha256": provenance["audit_runtime_code_sha256"], "alignment_training_code_sha256": provenance[ "alignment_training_code_sha256" ], "task_training_code_sha256": { task_id: self.manifest_arm(EXPECTED_TASK[task_id][0])[ "training_code_sha256" ] for task_id in TASK_ORDER }, }, "tasks": { task_id: load_json(self.tasks[task_id].root / "checkpoint_manifest.json") for task_id in TASK_ORDER }, } pairing_payload = { "schema_version": 1, "protocol_id": PROTOCOL_ID, "tasks": {task_id: self.tasks[task_id].pairing for task_id in TASK_ORDER}, } artifacts: dict[str, bytes] = { "protocol.json": stable_json(protocol_payload), "frozen_protocol.md": frozen_protocol_bytes, "input_manifest.json": self.manifest_path.read_bytes(), "environment.json": stable_json(environment_payload), "checkpoint_manifest.json": stable_json(checkpoint_payload), "subset_manifest.jsonl": Path( self.manifest["spectral_subset"]["artifact_path"] ).read_bytes(), "accuracy_by_condition.csv": csv_bytes(ACCURACY_COLUMNS, accuracy_rows), "accuracy_bootstrap.csv": csv_bytes( ACCURACY_BOOTSTRAP_COLUMNS, accuracy_bootstrap["rows"] ), "order_probe_accuracy.csv": csv_bytes( ACCURACY_COLUMNS, order_accuracy_rows ), "per_image_accuracy.npz": deterministic_npz_bytes(accuracy_npz), "per_image_spectral.npz": deterministic_npz_bytes(spectral_npz), "spectral_by_block.csv": csv_bytes(ROOT_SPECTRAL_COLUMNS, spectral_rows), "order_probe_spectral_by_block.csv": csv_bytes( ORDER_PROBE_SPECTRAL_COLUMNS, order_spectral_rows ), "d_order_sensitivity_by_block.csv": csv_bytes( D_ORDER_SENSITIVITY_COLUMNS, d_order_rows ), "spectral_by_stage.csv": csv_bytes(ROOT_STAGE_COLUMNS, stage_rows), "raw_amplitude_by_block.csv": csv_bytes( RAW_AMPLITUDE_COLUMNS, raw_amplitude ), "coherence_by_block.csv": csv_bytes(COHERENCE_COLUMNS, coherence), "gate_operating_diagnostics.csv": csv_bytes( GATE_OPERATING_COLUMNS, gate_rows ), "transfer_bootstrap_by_block.csv": csv_bytes( TRANSFER_BOOTSTRAP_COLUMNS, transfer_rows ), "transfer_matrices.npz": deterministic_npz_bytes(transfer_npz), "batch_pairing_manifest.json": stable_json(pairing_payload), "results.json": stable_json(root_results), "REPORT.md": report, "validation.json": stable_json(validation), } artifacts.update(figures) return artifacts @staticmethod def install_artifacts_atomically(root: Path, artifacts: Mapping[str, bytes]) -> None: temporary = Path(tempfile.mkdtemp(prefix=".aggregate.", dir=root)) try: for name, content in artifacts.items(): path = temporary / name path.parent.mkdir(parents=True, exist_ok=True) path.write_bytes(content) for name in artifacts: (root / name).parent.mkdir(parents=True, exist_ok=True) os.replace(temporary / name, root / name) finally: shutil.rmtree(temporary, ignore_errors=True) def write_or_check_root_artifacts( self, artifacts: dict[str, bytes], *, check_only: bool ) -> None: evidence_paths = [ self.root / "alignment_source_equivalence.json", *[ self.tasks[task_id].root / name for task_id in TASK_ORDER for name in REQUIRED_TASK_FILES ], ] hash_lines: list[str] = [] for path in sorted(evidence_paths, key=lambda item: item.relative_to(self.root).as_posix()): relative = path.relative_to(self.root).as_posix() hash_lines.append(f"{file_sha256(path)} {relative}\n") for name in sorted(artifacts): if name != "validation.json": hash_lines.append(f"{bytes_sha256(artifacts[name])} {name}\n") # validation.json is source evidence too; it does not contain artifact hashes. hash_lines.append( f"{bytes_sha256(artifacts['validation.json'])} validation.json\n" ) artifacts["source_artifacts.sha256"] = "".join(hash_lines).encode("utf-8") if check_only: mismatches = [ name for name, content in artifacts.items() if not (self.root / name).is_file() or (self.root / name).read_bytes() != content ] if mismatches: raise ValidationFailure( f"deterministic aggregate differs from existing root artifacts: {mismatches}" ) return if (self.root / "COMPLETE").exists(): raise ValidationFailure("refusing to regenerate a root that already has COMPLETE") existing = [name for name in artifacts if (self.root / name).exists()] if existing: raise ValidationFailure(f"refusing to overwrite existing aggregate files: {existing}") self.install_artifacts_atomically(self.root, artifacts) def failed_validation_payload(self) -> bytes: return stable_json( { "schema_version": 1, "protocol_id": PROTOCOL_ID, "status": "failed", "formal_complete": False, "validator_sha256": file_sha256(Path(__file__).resolve()), "input_manifest": str(self.manifest_path), "input_manifest_sha256": ( file_sha256(self.manifest_path) if self.manifest_path.is_file() else None ), "checks": self.checks, "errors": self.errors, "writes_complete_marker": False, } ) def run_self_test() -> dict[str, Any]: global BOOTSTRAP_REPLICATES, NUM_CLASSES, NUM_IMAGES, NUM_SPECTRAL_IMAGES checks: dict[str, bool] = {} arrays = { "z": np.arange(12, dtype=np.int16).reshape(3, 4), "a": np.asarray(["fft", "dct"]), } first = deterministic_npz_bytes(arrays) second = deterministic_npz_bytes(arrays) checks["deterministic_npz_bytes"] = first == second with tempfile.TemporaryDirectory(prefix="e4_aggregator_selftest_") as directory: root = Path(directory) npz = root / "fixture.npz" npz.write_bytes(first) with np.load(npz, allow_pickle=False) as loaded: checks["deterministic_npz_roundtrip"] = np.array_equal(loaded["z"], arrays["z"]) duplicate = root / "duplicate.json" duplicate.write_text('{"x": 1, "x": 2}\n', encoding="utf-8") try: load_json(duplicate) except DuplicateKeyError: checks["duplicate_json_rejected"] = True else: checks["duplicate_json_rejected"] = False artifact = root / "artifact.bin" artifact.write_bytes(b"frozen") line = f"{file_sha256(artifact)} artifact.bin\n" checks["sha256_line_format"] = len(line.split(" ", 1)[0]) == 64 nested = b"nested\n" AuditValidator.install_artifacts_atomically( root, {"figures/nested/test.svg": nested} ) checks["nested_artifact_atomic_write"] = ( root / "figures/nested/test.svg" ).read_bytes() == nested confidence = np.asarray([0.9, 0.8, 0.2], dtype=np.float64) correct = np.asarray([True, False, True]) checks["ece_percentage_points"] = math.isclose( ece_15(confidence, correct), 56.666666666666664, abs_tol=1e-12 ) class_ids = np.arange(NUM_CLASSES, dtype=np.int16) values = np.arange(NUM_CLASSES, dtype=np.float64) checks["class_equal_reduction"] = math.isclose( class_equal_mean(values, class_ids), 499.5, abs_tol=0.0 ) imbalanced_class_ids = np.concatenate( [ np.repeat(np.arange(904, dtype=np.int16), 4), np.repeat(np.arange(904, 1000, dtype=np.int16), 5), ] ) imbalanced_values = np.zeros(4096, dtype=np.float64) cursor = 904 * 4 for _ in range(96): imbalanced_values[cursor + 4] = 100.0 cursor += 5 image_estimate = image_equal_mean(imbalanced_values) class_estimate = class_equal_mean(imbalanced_values, imbalanced_class_ids) checks["image_equal_differs_from_class_equal"] = ( not math.isclose(image_estimate, class_estimate, rel_tol=0.0, abs_tol=1e-12) and math.isclose(image_estimate, 9600.0 / 4096.0, abs_tol=1e-12) and math.isclose(class_estimate, 1.92, abs_tol=1e-12) ) summary_key = ("fft", 0, "gated_product") left_summary = { summary_key: { "task_id": "B", "order": "canonical", "arm": "B", "m_res_conditional": None, "transfer_primary": np.eye(4, dtype=np.float64), } } right_summary = { summary_key: { "task_id": "B_order1", "order": "salt1", "arm": "B", "m_res_conditional": None, "transfer_primary": np.eye(4, dtype=np.float64), } } identity_comparison = compare_block_summary_registries(left_summary, right_summary) checks["B_order_identity_difference_allowed"] = bool( identity_comparison["field_registry_identical"] and identity_comparison["definedness_equal"] and identity_comparison["maximum_absolute_metric_difference"] == 0.0 ) changed_definedness = { summary_key: {**right_summary[summary_key], "m_res_conditional": 0.0} } changed_matrix = { summary_key: { **right_summary[summary_key], "transfer_primary": np.eye(4, dtype=np.float64), } } changed_matrix[summary_key]["transfer_primary"][0, 1] = 0.1 checks["B_order_definedness_and_matrix_changes_rejected"] = bool( not compare_block_summary_registries( left_summary, changed_definedness )["definedness_equal"] and compare_block_summary_registries( left_summary, changed_matrix )["maximum_absolute_metric_difference"] > 1e-6 ) checks["raw_rms_completion_guard"] = bool( complete_nonnegative_rms(np.asarray([0.0, 1.0])) and not complete_nonnegative_rms(np.asarray([0.0, np.nan])) and not complete_nonnegative_rms(np.asarray([0.0, -1.0])) ) checks["section_11_3_joint_decline_truth_table"] = bool( section_11_3_joint_decline(True, True, True, True) and not section_11_3_joint_decline(True, True, True, False) and registered_decline_state(0.5, 1.0) == "decline" and registered_decline_state(1.0, 1.0) == "not_decline" and registered_decline_state(None, 1.0) == "undefined" ) saved_globals = (BOOTSTRAP_REPLICATES, NUM_CLASSES, NUM_SPECTRAL_IMAGES) try: BOOTSTRAP_REPLICATES = 3 NUM_CLASSES = 2 NUM_SPECTRAL_IMAGES = 4 tiny_class_ids = np.asarray([0, 0, 1, 1], dtype=np.int16) tiny_weights = np.asarray( [[1, 1, 1, 1], [2, 0, 2, 0], [0, 2, 0, 2]], dtype=np.uint8 ) tiny_values = np.asarray( [[1.0, np.nan], [3.0, np.nan], [10.0, np.nan], [14.0, np.nan]], dtype=np.float64, ) tiny_image = AuditValidator.bootstrap_estimates( tiny_values, tiny_class_ids, tiny_weights, estimator="image_equal", chunk_size=1, ) tiny_class = AuditValidator.bootstrap_estimates( tiny_values, tiny_class_ids, tiny_weights, estimator="class_equal", chunk_size=1, ) tiny_quantiles = AuditValidator.bootstrap_quantiles(tiny_image) repeated = AuditValidator.bootstrap_estimates( tiny_values, tiny_class_ids, tiny_weights, estimator="image_equal", chunk_size=1, ) checks["shared_bootstrap_shape_and_determinism"] = ( tiny_image.shape == (3, 2) and tiny_class.shape == (3, 2) and tiny_quantiles.shape == (2, 3) and np.array_equal(tiny_image, repeated, equal_nan=True) and np.all(np.isnan(tiny_image[:, 1])) and np.all(np.isnan(tiny_quantiles[1])) ) checks["all_constant_suppressed_defined_mask"] = bool( not np.isfinite(tiny_quantiles[1]).any() and np.isfinite(tiny_quantiles[0]).all() ) finally: BOOTSTRAP_REPLICATES, NUM_CLASSES, NUM_SPECTRAL_IMAGES = saved_globals saved_accuracy_globals = (BOOTSTRAP_REPLICATES, NUM_CLASSES, NUM_IMAGES) try: BOOTSTRAP_REPLICATES = 3 NUM_CLASSES = 2 NUM_IMAGES = 100 validator = object.__new__(AuditValidator) validator.tasks = {} target = np.repeat(np.arange(2, dtype=np.int16), 50) canonical_index = np.arange(100, dtype=np.int64) for task_index, task_id in enumerate(TASK_ORDER): conditions = EXPECTED_CONDITIONS if task_id in CANONICAL_ARMS else ("unfiltered",) condition_count = len(conditions) top1 = np.ones((condition_count, 100), dtype=np.bool_) top5 = np.ones_like(top1) if task_id in CANONICAL_ARMS: for condition_index in range(1, condition_count): top1[condition_index, : condition_index + task_index + 1] = False accuracy = { "canonical_index": canonical_index, "target": target, "condition_names": np.asarray(conditions), "top1_correct": top1, "top5_correct": top5, "nll": np.full((condition_count, 100), 0.5 + 0.01 * task_index, dtype=np.float32), } arm, order = EXPECTED_TASK[task_id] validator.tasks[task_id] = TaskData( task_id, arm, order, Path("."), {}, accuracy, {}, [], [], {}, {} ) accuracy_first = AuditValidator.accuracy_bootstrap(validator) accuracy_second = AuditValidator.accuracy_bootstrap(validator) first_contrast = accuracy_first["rows"][0] checks["accuracy_bootstrap_shape_sign_and_determinism"] = ( len(accuracy_first["rows"]) == 225 and stable_json(accuracy_first) == stable_json(accuracy_second) and first_contrast["metric"] == "top1" and first_contrast["unit"] == "percentage_points" and first_contrast["point_difference"] < 0 ) finally: BOOTSTRAP_REPLICATES, NUM_CLASSES, NUM_IMAGES = saved_accuracy_globals known_left = np.asarray([True, False], dtype=np.float64) known_right = np.asarray([False, False], dtype=np.float64) checks["accuracy_contrast_sign_and_unit"] = math.isclose( 100.0 * float((known_left - known_right).mean()), 50.0, abs_tol=0.0 ) checks["formal_table_row_contracts"] = ( len(CANONICAL_ARMS) * len(EXPECTED_CONDITIONS) == 25 and len(CANONICAL_ARMS) * len(BASES) * NUM_BLOCKS == 170 and 3 * len(BASES) * NUM_BLOCKS == 102 and len(CANONICAL_ARMS) * len(BASES) * 4 * len(ROOT_SIGNAL_PREFIXES) == 120 and len(set(ROOT_SPECTRAL_COLUMNS)) == len(ROOT_SPECTRAL_COLUMNS) and len(set(ROOT_STAGE_COLUMNS)) == len(ROOT_STAGE_COLUMNS) ) checks["D_order_range_schema_complete"] = ( len(set(D_ORDER_SENSITIVITY_COLUMNS)) == len(D_ORDER_SENSITIVITY_COLUMNS) and "m_off_D" in D_ORDER_SENSITIVITY_COLUMNS and "m_off_alternate_min" in D_ORDER_SENSITIVITY_COLUMNS and "m_off_D_order1_defined" in D_ORDER_SENSITIVITY_COLUMNS and "m_off_alternate_range_defined" in D_ORDER_SENSITIVITY_COLUMNS and "raw_y_centered_rms_dataset_median_D_order1" in D_ORDER_SENSITIVITY_COLUMNS and "transfer_primary_s0_t1_alternate_max" in D_ORDER_SENSITIVITY_COLUMNS and "transfer_conditional_s3_t3_defined_count" in D_ORDER_SENSITIVITY_COLUMNS ) complete_alt = complete_alternate_range((0.2, 0.4)) incomplete_alt = complete_alternate_range((0.2, None)) checks["D_order_range_fail_closed_definedness"] = ( complete_alt == (0.2, 0.4, True) and incomplete_alt == (None, None, False) ) checks["frozen_manifest_and_training_boundaries"] = ( DEFAULT_INPUT_MANIFEST.is_file() and file_sha256(DEFAULT_INPUT_MANIFEST) == EXPECTED_INPUT_MANIFEST_SHA256 and EXPECTED_AUDIT_TRAINING_CODE_SHA256.startswith("f6bd434a") and EXPECTED_ALIGNMENT_TRAINING_CODE_SHA256.startswith("4a62bc48") ) lock_entries = ["numpy==2.5.0", "torch==2.9.0+cu130"] lock_bytes = "".join(f"{entry}\n" for entry in lock_entries).encode("utf-8") checks["package_lock_serialization_binding"] = ( bytes_sha256(lock_bytes) == hashlib.sha256(b"numpy==2.5.0\ntorch==2.9.0+cu130\n").hexdigest() ) figure_names = ( "accuracy_lowpass", "mixing_depth_profile", "spectral_stage_profile", "coherence_depth_profile", "transfer_heatmaps", "accuracy_mixing_raw", ) first_figures = { name: AuditValidator.svg_line_chart( name, ("a", "b"), ({"name": "fixture", "values": [0.0, 1.0], "low": [0.0, 0.9], "high": [0.1, 1.0]},), y_label="fixture", ) for name in figure_names } second_figures = { name: AuditValidator.svg_line_chart( name, ("a", "b"), ({"name": "fixture", "values": [0.0, 1.0], "low": [0.0, 0.9], "high": [0.1, 1.0]},), y_label="fixture", ) for name in figure_names } checks["six_svg_assets_byte_deterministic"] = ( first_figures == second_figures and len(first_figures) == 6 and all(value.endswith(b"\n") for value in first_figures.values()) ) figure_d_rows: list[dict[str, Any]] = [] for basis in BASES: for block in range(NUM_BLOCKS): row: dict[str, Any] = { "basis": basis, "global_block_index": block, "m_off_D": 0.2, "m_off_D_order1": 0.18, "m_off_D_order2": 0.22, "raw_y_centered_rms_dataset_median_D": 1.0, "raw_y_centered_rms_dataset_median_D_order1": 0.9, "raw_y_centered_rms_dataset_median_D_order2": 1.1, } for kind in ("primary", "conditional"): for source in range(NUM_BANDS): for target in range(NUM_BANDS): metric = f"transfer_{kind}_s{source}_t{target}" row[f"{metric}_alternate_min"] = 0.2 row[f"{metric}_alternate_max"] = 0.3 figure_d_rows.append(row) heat_point = np.full( (len(CANONICAL_ARMS), len(BASES), NUM_BLOCKS, NUM_BANDS, NUM_BANDS), 0.25, dtype=np.float64, ) heat_quantiles = np.stack( (heat_point - 0.01, heat_point, heat_point + 0.01), axis=-1 ) conditional_heat_point = heat_point.copy() conditional_heat_point[CANONICAL_ARMS.index("D"), 0, 8, 0, 0] = np.nan heatmap_fixture = { "primary_point": heat_point, "conditional_point": conditional_heat_point, "primary_quantiles": heat_quantiles, "conditional_quantiles": heat_quantiles, } heatmap_bytes = AuditValidator.transfer_heatmap_svg( heatmap_fixture, figure_d_rows ) scatter_points = { task_id: { "fft_m_off": 0.2 + 0.01 * index, "top1": 70.0 + index, } for index, task_id in enumerate(TASK_ORDER) } scatter_accuracy = { (task_id, "unfiltered", "top1"): { "bootstrap_ci95_low": 69.0 + index, "bootstrap_ci95_high": 71.0 + index, } for index, task_id in enumerate(CANONICAL_ARMS) } scatter_transfer = { "scalar_names": np.asarray(["m_off"]), "global_scalar_quantiles": np.tile( np.asarray([[[0.19, 0.2, 0.21]], [[0.19, 0.2, 0.21]]]), (len(CANONICAL_ARMS), 1, 1), ).reshape(len(CANONICAL_ARMS), len(BASES), 1, 3), } scatter_raw = [ { "task_id": task_id, "signal": "gated_product", "metric": "centered_rms", "dataset_median": 1.0, } for task_id in CANONICAL_ARMS ] scatter_bytes = AuditValidator.accuracy_mixing_svg( scatter_accuracy, scatter_transfer, scatter_raw, scatter_points, figure_d_rows, ) lowpass_na_bytes = AuditValidator.svg_line_chart( "fixture", EXPECTED_CONDITIONS, ( { "name": "D registered-order range (unfiltered; low-pass NA)", "values": [1.0, None, None, None, None], "low": [0.9, None, None, None, None], "high": [1.1, None, None, None, None], }, ), y_label="fixture", ) source_text = Path(__file__).read_text(encoding="utf-8") checks["D_order_figure_and_report_sentinels"] = ( b"CI " in heatmap_bytes and b"alt " in heatmap_bytes and b"canonical NA" in heatmap_bytes and b"raw y RMS alternate-order range" in scatter_bytes and b"low-pass NA" in lowpass_na_bytes and "Section 11.3 primary basis: FFT" in source_text and "inputs defined=" in source_text and "cannot prove that a specific internal gate" in LOWPASS_CAUSAL_CAVEAT ) checks["one_based_block_schema"] = ( EXPECTED_STAGES[:3] == (1, 1, 1) and EXPECTED_STAGES[-3:] == (4, 4, 4) and EXPECTED_STAGE_BLOCKS[:3] == (1, 2, 3) and EXPECTED_STAGE_BLOCKS[-3:] == (1, 2, 3) and len(EXPECTED_STAGES) == NUM_BLOCKS ) primary = np.eye(4, dtype=np.float64) offdiag = primary.copy() np.fill_diagonal(offdiag, 0.0) checks["constant_gate_m_off"] = float(offdiag.sum() / 4.0) <= 1e-6 checks["task_contract"] = set(TASK_ORDER) == set(EXPECTED_TASK) and len(TASK_ORDER) == 8 checks["registered_bootstrap_replicates"] = BOOTSTRAP_REPLICATES == 10_000 checks["arbitrary_independent_gate_generalization_forbidden"] = ( ARBITRARY_INDEPENDENT_GATE_GENERALIZATION_PERMITTED is False ) checks["optional_finite_guard"] = ( finite_or_none(None) is None and finite_or_none(float("nan")) is None and finite_values((1.0, None)) is None and finite_values((1.0, 2.0)) == [1.0, 2.0] ) checks["aggregator_has_no_complete_write"] = "write_text(\"complete" not in Path( __file__ ).read_text(encoding="utf-8") checks = {name: bool(value) for name, value in checks.items()} if not all(checks.values()): failed = sorted(name for name, passed in checks.items() if not passed) raise AssertionError(f"aggregator self-test failed: {failed}") return { "schema_version": 1, "status": "passed", "checks": checks, "validator_sha256": file_sha256(Path(__file__).resolve()), } def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--root", type=Path, help="root containing the eight task directories") parser.add_argument("--input-manifest", type=Path, default=DEFAULT_INPUT_MANIFEST) parser.add_argument("--runner", type=Path, default=DEFAULT_RUNNER) parser.add_argument( "--check-only", action="store_true", help="rebuild in memory and require every existing root aggregate byte to match", ) parser.add_argument("--self-test", action="store_true") return parser.parse_args() def main() -> int: args = parse_args() if args.self_test: print(stable_json(run_self_test()).decode("utf-8"), end="") return 0 if args.root is None: raise SystemExit("--root is required unless --self-test is used") root = args.root.expanduser().resolve() if not root.is_dir(): raise SystemExit(f"audit root does not exist: {root}") validator = AuditValidator(root, args.input_manifest, args.runner) try: validator.validate_manifest_and_root() validator.validate_all_tasks() validator.validate_cross_task_contract() if validator.errors or set(validator.tasks) != set(TASK_ORDER): raise ValidationFailure("; ".join(validator.errors) or "not all tasks validated") if not all(item["passed"] for item in validator.checks.values()): raise ValidationFailure("one or more recorded checks did not pass") artifacts = validator.build_root_artifacts() validator.write_or_check_root_artifacts(artifacts, check_only=args.check_only) except Exception as error: if not validator.errors: validator.errors.append(f"{type(error).__name__}: {error}") failure_path = root / "validation.json" if not args.check_only and not failure_path.exists() and not (root / "COMPLETE").exists(): temporary = root / f".validation.failed.{os.getpid()}.tmp" temporary.write_bytes(validator.failed_validation_payload()) os.replace(temporary, failure_path) print(f"E4 spectral aggregation denied: {error}", file=sys.stderr) return 1 print( json.dumps( { "status": "passed", "root": str(root), "check_only": args.check_only, "complete_written": False, }, sort_keys=True, ) ) return 0 if __name__ == "__main__": raise SystemExit(main())