framework/src/datacenter_verification/observable_algorithm.py

"""staged observable algorithm for synthetic datacenter scenarios"""

from __future__ import annotations

from copy import deepcopy
from datetime import datetime, timezone
from math import inf
from typing import Any

POLICY_THRESHOLD_OPERATIONS = 1.0e25
ALGORITHM_VERSION = "observable_staged_v0.3"
ELECTRICAL_SERVICE_WATTS_PER_ACCELERATOR = 900.0
ELECTRICAL_SERVICE_COUNT_EPSILON_FRACTION = 1e-6
SUPPORTING_ELECTRICAL_SERVICE_STATES = {
    "active",
    "energized",
    "approved",
    "in_service",
    "connected",
    "commissioned",
}
SCOPED_ELECTRICAL_SERVICE_CLASSES = {
    "synthetic_datacenter_service",
}
NORMALIZED_OPERATION_UNITS = {
    "",
    "synthetic_normalized_operations",
    "normalized_operations_per_second",
    "flop_per_second",
    "flops_per_second",
    "operations_per_second",
}

THRESHOLDS: dict[str, float] = {
    "policy_threshold_operations": POLICY_THRESHOLD_OPERATIONS,
    "min_capacity_ruleout_coverage_fraction": 0.90,
    "min_capacity_clock_alignment_confidence": 0.80,
    "min_capacity_possible_coverage_fraction": 0.60,
    "min_large_compute_coverage_fraction": 0.75,
    "min_primary_B_channel_coverage_fraction": 0.75,
    "min_activity_screen_score": 0.50,
    "min_activity_screen_duration_seconds": 600.0,
    "min_activity_for_fabric_pair": 0.55,
    "min_fabric_cadence_pair_score": 0.60,
    "min_activity_fabric_overlap_fraction": 0.50,
    "min_activity_fabric_duration_seconds": 1800.0,
    "min_activity_for_checkpoint_pair": 0.50,
    "min_checkpoint_pair_score": 0.55,
    "min_checkpoint_activity_adjacency_fraction": 0.50,
    "min_checkpoint_pair_burst_count": 2.0,
    "min_fabric_strong_identity_score": 0.75,
    "min_checkpoint_strong_identity_score": 0.70,
    "min_non_serving_pair_score": 0.60,
    "min_serving_channel_coverage_fraction": 0.80,
    "min_serving_suppression_score": 0.70,
    "min_serving_activity_overlap_fraction": 0.50,
    "min_operation_activity_overlap_fraction": 0.80,
    "min_bytes_explained_fraction": 0.70,
    "min_benchmark_like_cadence_score": 0.75,
    "min_benchmark_regularity_score": 0.90,
    "max_benchmark_duration_seconds": 7200.0,
    "min_sparse_hpc_fabric_cadence_score": 0.60,
    "min_sparse_hpc_activity_score": 0.50,
    "min_sparse_hpc_overlap_fraction": 0.50,
    "min_negative_screen_primary_coverage_fraction": 0.75,
    "min_negative_screen_identity_coverage_fraction": 0.75,
    "min_negative_screen_scope_mapping_coverage_fraction": 0.75,
    "min_negative_screen_clock_alignment_confidence": 0.80,
    "min_unattributed_activity_score": 0.70,
    "min_unattributed_activity_duration_seconds": 600.0,
    "max_attribution_overlap_fraction": 0.05,
    "min_attribution_channel_coverage_fraction": 0.80,
    "benign_attribution_explanation_overlap_fraction": 0.80,
    "max_sparse_achieved_to_capacity_ratio": 1.10,
    "min_sparse_capacity_conflict_coverage_fraction": 0.75,
    "unit_or_hidden_capacity_suppression_score": 0.70,
}

WEBSITE_CONTROL_KEYS = [
    "accelerator_count",
    "peak_rate_ops_per_second",
    "duration_hours",
    "capacity_coverage",
    "activity_score",
    "activity_coverage",
    "achieved_operations",
    "achieved_ops_coverage",
    "fabric_cadence_score",
    "fabric_coverage",
    "participant_count",
    "checkpoint_score",
    "checkpoint_burst_count",
    "storage_coverage",
    "serving_counterevidence_score",
    "serving_coverage",
    "serving_activity_overlap_fraction",
    "storage_operation_explained_fraction",
    "storage_operation_overlap_fraction",
    "storage_operation_coverage",
    "benchmark_regularity_score",
    "benchmark_duration_seconds",
    "hpc_mpi_score",
    "hpc_overlap_fraction",
    "benchmark_hpc_coverage",
    "attribution_coverage",
    "attribution_overlap_fraction",
    "scope_mapping_coverage",
    "clock_alignment_confidence",
    "hidden_or_unmonitored_capacity_possible",
    "physical_timeline_conflict",
    "health_throttle_conflict",
    "topology_route_conflict",
    "power_activity_conflict",
]


def evaluate_sites(sites: list[dict[str, Any]]) -> list[dict[str, Any]]:
    return [evaluate_site(site) for site in sites]


def evaluate_site(site: dict[str, Any]) -> dict[str, Any]:
    scenario = deepcopy(site)
    audit_window = scenario["audit_window"]
    duration_seconds = _window_seconds(audit_window)
    raw_features = scenario.get("raw_features", {})
    coverage = scenario.get("coverage", {})
    signals = scenario.get("normalized_signals", {})

    derived = _derive_signals(scenario, duration_seconds)
    sparse_outputs = _sparse_outputs(scenario, derived)
    stage_a = _capacity_gate(scenario, derived)

    if stage_a["short_circuited"]:
        stage_b = {
            "stage": "B_training_candidate_detection",
            "mode": "skipped_due_to_capacity_ruleout",
            "labels": [],
            "positive_evidence_paths": [],
            "warning_height": "none",
            "notes": ["B was not run because A emitted capacity_ruled_out_for_scope."],
        }
        stage_c = {
            "stage": "C_discrepancy_and_explanation_review",
            "mode": "skipped_due_to_capacity_ruleout",
            "labels": [],
            "suppressors": [],
            "explanations": [],
            "discrepancies": [],
            "missing_channels": [],
            "notes": ["General C was not run after the capacity rule-out short circuit."],
        }
    else:
        stage_b = _candidate_detection(scenario, derived, stage_a)
        stage_c = _targeted_c_review(scenario, derived, stage_a, stage_b)

    final = _final_route(scenario, derived, stage_a, stage_b, stage_c)
    demo_state = _demo_state(scenario, derived)

    discrepancy_findings = list(stage_c["discrepancies"])
    if stage_a.get("ruleout_capacity_claim_conflict") and "capacity_claim_conflict" not in discrepancy_findings:
        discrepancy_findings.append("capacity_claim_conflict")

    return {
        "algorithm_version": ALGORITHM_VERSION,
        "site_id": scenario["site_id"],
        "scenario_key": scenario["scenario_key"],
        "scenario_name": scenario["scenario_name"],
        "scope": scenario["scope"],
        "audit_window": audit_window,
        "duration_seconds": duration_seconds,
        "raw_feature_ids": sorted(raw_features),
        "minimal_sparse_outputs": sparse_outputs,
        "derived_signals": derived,
        "stage_outputs": {
            "A_capacity_gate": stage_a,
            "B_training_candidate_detection": stage_b,
            "C_discrepancy_and_explanation_review": stage_c,
            "final_claim_routing": final,
        },
        "final_route": final["label"],
        "positive_evidence_paths": stage_b["positive_evidence_paths"],
        "suppressors_or_explanations": stage_c["suppressors"] + stage_c["explanations"],
        "discrepancy_findings": discrepancy_findings,
        "missing_channels": stage_c["missing_channels"],
        "caveats": final["caveats"],
        "reader_numbers": final["reader_numbers"],
        "coverage": coverage,
        "normalized_signals": signals,
        "demo_state": demo_state,
    }


def _derive_signals(site: dict[str, Any], duration_seconds: float) -> dict[str, Any]:
    raw = site.get("raw_features", {})
    coverage = site.get("coverage", {})
    signals = site.get("normalized_signals", {})

    count = _sum(raw.get("accelerator_count_by_family_sku", []), "count")
    has_negative_count = any(
        _number(record.get("count"), 0.0) < 0
        for record in raw.get("accelerator_count_by_family_sku", []) or []
    )
    peak_rate = _max(raw.get("advertised_peak_rate_by_precision", []), "peak_rate")
    capacity_factor = _number(signals.get("capacity_adjustment_factor"), 1.0)
    invalid_capacity_adjustment_factor = capacity_factor < 0
    invalid_audit_window = duration_seconds <= 0
    raw_capacity_upper = count * peak_rate * duration_seconds
    capacity_upper = raw_capacity_upper * capacity_factor

    normalized_raw_rates = [
        _number(record.get("operation_rate"), 0.0)
        for record in raw.get("generic_achieved_operation_rate", []) or []
        if str(record.get("operation_unit", "") or "").lower() in NORMALIZED_OPERATION_UNITS
    ]
    ignored_raw_rate_unit = any(
        _number(record.get("operation_rate"), 0.0) > 0
        and str(record.get("operation_unit", "") or "").lower() not in NORMALIZED_OPERATION_UNITS
        for record in raw.get("generic_achieved_operation_rate", []) or []
    )
    achieved_rate = max(normalized_raw_rates) if normalized_raw_rates else 0.0
    achieved_operations_from_override = "achieved_operations" in signals
    achieved_operations = _number(signals.get("achieved_operations"), achieved_rate * duration_seconds)
    achieved_unit_normalized = bool(signals.get("achieved_operations_unit_normalized", True))
    if not achieved_operations_from_override and ignored_raw_rate_unit and not normalized_raw_rates:
        achieved_unit_normalized = False

    activity_score = max(
        _max(raw.get("accelerator_busy_or_utilization_fraction", []), "value"),
        _max(raw.get("tensor_matrix_mxu_neuron_or_engine_active_fraction", []), "value"),
        _number(signals.get("activity_score"), 0.0),
    )
    fabric_score = _number(signals.get("collective_cadence_score"), _counter(raw, "collective_cadence_score"))
    participant_count = _number(signals.get("participant_count"), _counter(raw, "participant_count"))
    checkpoint_score = _number(signals.get("checkpoint_periodicity_score"), 0.0)
    checkpoint_bursts = _number(
        signals.get("checkpoint_burst_count"),
        float(len(raw.get("storage_write_operation_bytes", []))),
    )
    serving_score_present = "serving_counterevidence_score" in signals
    serving_score = _number(signals.get("serving_counterevidence_score"), 0.0)
    non_serving_default = max(0.0, 1.0 - serving_score) if serving_score_present else 0.0
    non_serving_score = _number(signals.get("non_serving_score"), non_serving_default)
    benchmark_regularity = _number(signals.get("benchmark_regularity_score"), _counter(raw, "regularity_score"))
    benchmark_duration = _number(signals.get("benchmark_duration_seconds"), duration_seconds)
    hpc_score = _number(signals.get("hpc_mpi_score"), 0.0)

    capacity_coverage = _coverage_cert(coverage, "capacity")
    primary_min = min(
        _coverage_cert(coverage, "activity"),
        _coverage_cert(coverage, "achieved_ops"),
    )
    identity_coverage = _coverage(
        coverage,
        "identity_shape",
        min(_coverage(coverage, "fabric"), _coverage(coverage, "storage")),
    )
    suppressor_coverage = min(
        _coverage_cert(coverage, "serving"),
        _coverage_cert(coverage, "storage_operations"),
        _coverage_cert(coverage, "benchmark_hpc"),
    )
    scope_mapping = _coverage_cert(coverage, "scope_mapping")
    clock_alignment = _coverage_cert(coverage, "clock_alignment")

    capacity_ratio = achieved_operations / capacity_upper if capacity_upper > 0 else (inf if achieved_operations > 0 else 0.0)

    return {
        "capacity_segment_window": {
            "start_time": site["audit_window"]["start"],
            "end_time": site["audit_window"]["end"],
            "duration_seconds": duration_seconds,
            "invalid_audit_window": invalid_audit_window,
            "capacity_coverage_fraction": capacity_coverage,
        },
        "capacity_upper_bound_flop": {
            "unit_normalized": bool(signals.get("capacity_unit_normalized", True)),
            "capacity_upper_bound_operations": capacity_upper,
            "unadjusted_capacity_upper_bound_operations": raw_capacity_upper,
            "coverage_fraction": capacity_coverage,
            "hidden_or_unmonitored_capacity_possible": bool(
                signals.get("hidden_or_unmonitored_capacity_possible", False)
            ),
            "missing_required_peak_rate": peak_rate <= 0,
            "has_negative_count": has_negative_count,
            "invalid_audit_window": invalid_audit_window,
            "invalid_capacity_adjustment_factor": invalid_capacity_adjustment_factor,
            "count": count,
            "peak_rate_ops_per_second": peak_rate,
            "capacity_adjustment_factor": capacity_factor,
        },
        "achieved_operation_integral": {
            "operation_count": achieved_operations,
            "coverage_fraction": _coverage_cert(coverage, "achieved_ops"),
            "unit_normalized": achieved_unit_normalized,
            "ignored_raw_rate_unit": ignored_raw_rate_unit,
            "operation_count_to_capacity_upper_bound_ratio": capacity_ratio,
        },
        "accelerator_activity_score": {
            "activity_score": activity_score,
            "duration_seconds": _number(signals.get("activity_duration_seconds"), duration_seconds),
            "coverage_fraction": _coverage_cert(coverage, "activity"),
        },
        "collective_cadence_score": {
            "cadence_score": fabric_score,
            "coverage_fraction": _coverage_cert(coverage, "fabric"),
            "participant_count": participant_count,
            "activity_fabric_overlap_fraction": _number(signals.get("activity_fabric_overlap_fraction"), 0.0),
        },
        "checkpoint_periodicity_score": {
            "checkpoint_score": checkpoint_score,
            "burst_count": checkpoint_bursts,
            "coverage_fraction": _coverage_cert(coverage, "storage"),
            "checkpoint_activity_adjacency_fraction": _number(
                signals.get("checkpoint_activity_adjacency_fraction"),
                0.0,
            ),
        },
        "non_serving_score": {
            "non_serving_score": non_serving_score,
            "serving_counterevidence_score": serving_score,
            "serving_counterevidence_present": serving_score_present,
            "non_serving_score_present": "non_serving_score" in signals,
            "coverage_fraction": _coverage_cert(coverage, "serving"),
            "serving_activity_overlap_fraction": _number(signals.get("serving_activity_overlap_fraction"), 0.0),
        },
        "storage_operation_explanation": {
            "operation_overlap_fraction": _number(signals.get("storage_operation_overlap_fraction"), 0.0),
            "bytes_explained_fraction": _number(signals.get("bytes_explained_fraction"), 0.0),
            "coverage_fraction": _coverage_cert(coverage, "storage_operations"),
        },
        "benchmark_hpc_alternative": {
            "benchmark_regularity_score": benchmark_regularity,
            "benchmark_duration_seconds": benchmark_duration,
            "hpc_mpi_score": hpc_score,
            "hpc_overlap_fraction": _number(signals.get("hpc_overlap_fraction"), 0.0),
            "coverage_fraction": _coverage_cert(coverage, "benchmark_hpc"),
        },
        "negative_screen_required_coverage_state": {
            "primary_activity_coverage_fraction": _coverage_cert(coverage, "activity"),
            "achieved_ops_coverage_fraction": _coverage_cert(coverage, "achieved_ops"),
            "identity_shape_coverage_fraction": identity_coverage,
            "suppressor_channel_coverage_fraction": suppressor_coverage,
            "scope_mapping_coverage_fraction": scope_mapping,
            "clock_alignment_confidence": clock_alignment,
            "decision_blocking_missingness": bool(signals.get("decision_blocking_missingness", False))
            or invalid_audit_window,
            "invalid_audit_window": invalid_audit_window,
        },
        "telemetry_coverage_fraction": {
            "primary_channel_min": primary_min,
            "identity_shape_coverage_fraction": identity_coverage,
            "suppressor_channel_coverage_fraction": suppressor_coverage,
            "scope_mapping_coverage_fraction": scope_mapping,
            "clock_alignment_confidence": clock_alignment,
            "missing_primary_channels": _missing_channels_for_threshold(site, threshold=0.75),
        },
        "clock_aligned_overlap_window": {
            "clock_alignment_confidence": clock_alignment,
        },
    }


def _sparse_outputs(site: dict[str, Any], derived: dict[str, Any]) -> list[dict[str, str]]:
    outputs: list[dict[str, str]] = []
    cap = derived["capacity_upper_bound_flop"]
    activity = derived["accelerator_activity_score"]
    achieved = derived["achieved_operation_integral"]
    fabric = derived["collective_cadence_score"]
    checkpoint = derived["checkpoint_periodicity_score"]
    non_serving = derived["non_serving_score"]
    storage_op = derived["storage_operation_explanation"]
    alternative = derived["benchmark_hpc_alternative"]

    if cap["count"] > 0:
        outputs.append(_output("accelerator_count_capacity_screen", "accelerator_count_threshold_capacity_screen", "capacity_count_or_shape"))
    if cap["peak_rate_ops_per_second"] > 0:
        outputs.append(_output("peak_rate_capacity_screen", "peak_rate_capacity_screen", "capacity_peak_rate"))
    if cap["capacity_upper_bound_operations"] >= POLICY_THRESHOLD_OPERATIONS:
        outputs.append(_output("capacity_threshold_possible", "threshold_scale_capacity_possible", "capacity_policy_scale"))
    elif cap["coverage_fraction"] >= THRESHOLDS["min_capacity_possible_coverage_fraction"]:
        outputs.append(_output("capacity_threshold_ruled_out", "threshold_scale_capacity_not_supported_sparse", "capacity_policy_scale"))

    if (
        activity["activity_score"] >= THRESHOLDS["min_activity_screen_score"]
        and activity["duration_seconds"] >= THRESHOLDS["min_activity_screen_duration_seconds"]
    ):
        outputs.append(_output("activity_only_screen", "accelerator_activity_screen", "accelerator_activity_run_existence"))
    if (
        achieved["operation_count"] >= POLICY_THRESHOLD_OPERATIONS
        and achieved["coverage_fraction"] >= THRESHOLDS["min_large_compute_coverage_fraction"]
        and achieved["unit_normalized"]
    ):
        outputs.append(_output("large_compute_screen", "large_compute_candidate", "large_compute_scale"))
    if _activity_fabric_pair(derived):
        outputs.append(_output("activity_fabric_cadence_candidate", "collective_like_training_candidate", "fabric_parameter_update_like"))
    if _activity_checkpoint_pair(derived):
        outputs.append(_output("activity_checkpoint_candidate", "checkpoint_like_training_candidate", "storage_checkpoint_state_like"))
    if (
        activity["activity_score"] >= THRESHOLDS["min_activity_for_fabric_pair"]
        and non_serving["non_serving_score"] >= THRESHOLDS["min_non_serving_pair_score"]
        and non_serving["coverage_fraction"] >= THRESHOLDS["min_serving_channel_coverage_fraction"]
    ):
        outputs.append(_output("activity_nonserving_candidate", "non_serving_accelerator_compute_candidate", "non_serving_workload_shape"))
    if non_serving["serving_counterevidence_score"] >= 0.65 and non_serving["coverage_fraction"] >= 0.60:
        outputs.append(_output("serving_like_network_counterevidence_screen", "serving_like_counterevidence_screen", "serving_counterevidence"))
    if (
        storage_op["operation_overlap_fraction"] >= THRESHOLDS["min_operation_activity_overlap_fraction"]
        and storage_op["bytes_explained_fraction"] >= THRESHOLDS["min_bytes_explained_fraction"]
    ):
        outputs.append(_output("storage_operation_explanation_screen", "storage_operation_explanation_screen", "storage_operation_explanation"))
    if (
        alternative["benchmark_regularity_score"] >= 0.85
        or alternative["hpc_mpi_score"] >= THRESHOLDS["min_sparse_hpc_fabric_cadence_score"]
    ):
        outputs.append(_output("benchmark_hpc_alternative_screen", "benchmark_or_hpc_alternative_screen", "benchmark_hpc_alternative"))
    return outputs


def _capacity_gate(site: dict[str, Any], derived: dict[str, Any]) -> dict[str, Any]:
    cap = derived["capacity_upper_bound_flop"]
    coverage = cap["coverage_fraction"]
    clock = derived["clock_aligned_overlap_window"]["clock_alignment_confidence"]
    missing_required = (
        not cap["unit_normalized"]
        or cap["missing_required_peak_rate"]
        or cap["has_negative_count"]
        or cap["invalid_audit_window"]
        or cap["invalid_capacity_adjustment_factor"]
        or cap["count"] <= 0
        or coverage < THRESHOLDS["min_capacity_possible_coverage_fraction"]
        or clock < THRESHOLDS["min_capacity_clock_alignment_confidence"]
    )
    ruleout_eligible = (
        cap["capacity_upper_bound_operations"] < POLICY_THRESHOLD_OPERATIONS
        and cap["count"] > 0
        and coverage >= THRESHOLDS["min_capacity_ruleout_coverage_fraction"]
        and clock >= THRESHOLDS["min_capacity_clock_alignment_confidence"]
        and not cap["hidden_or_unmonitored_capacity_possible"]
        and not cap["missing_required_peak_rate"]
        and not cap["has_negative_count"]
        and not cap["invalid_audit_window"]
        and not cap["invalid_capacity_adjustment_factor"]
        and cap["unit_normalized"]
    )
    ruleout_capacity_claim_conflict = ruleout_eligible and _capacity_claim_contradicted(derived, site)

    if ruleout_eligible and not ruleout_capacity_claim_conflict:
        label = "capacity_ruled_out_for_scope"
        confidence = "conservative_bound"
        short_circuited = True
    elif ruleout_capacity_claim_conflict:
        label = "capacity_claim_conflict_blocks_ruleout"
        confidence = "conflict"
        short_circuited = False
    elif missing_required:
        label = "capacity_unknown_due_to_missing_inputs"
        confidence = "weak"
        short_circuited = False
    elif cap["capacity_upper_bound_operations"] >= POLICY_THRESHOLD_OPERATIONS:
        label = "capacity_possible_for_scope"
        confidence = "screen"
        short_circuited = False
    else:
        label = "capacity_limited_but_not_ruled_out"
        confidence = "weak"
        short_circuited = False

    return {
        "stage": "A_capacity_gate",
        "label": label,
        "labels": [label],
        "confidence": confidence,
        "short_circuited": short_circuited,
        "capacity_upper_bound_operations": cap["capacity_upper_bound_operations"],
        "coverage_fraction": coverage,
        "clock_alignment_confidence": clock,
        "hidden_or_unmonitored_capacity_possible": cap["hidden_or_unmonitored_capacity_possible"],
        "missing_inputs": _capacity_missing_inputs(cap, coverage, clock),
        "ruleout_capacity_claim_conflict": ruleout_capacity_claim_conflict,
        "notes": _capacity_notes(label),
    }


def _candidate_detection(site: dict[str, Any], derived: dict[str, Any], stage_a: dict[str, Any]) -> dict[str, Any]:
    labels: list[str] = []
    evidence_paths: list[str] = []
    notes: list[str] = []

    achieved = derived["achieved_operation_integral"]
    telemetry = derived["telemetry_coverage_fraction"]
    primary_coverage = telemetry["primary_channel_min"]
    suppressor_coverage = telemetry["suppressor_channel_coverage_fraction"]

    if (
        achieved["operation_count"] >= POLICY_THRESHOLD_OPERATIONS
        and achieved["coverage_fraction"] >= THRESHOLDS["min_large_compute_coverage_fraction"]
        and achieved["unit_normalized"]
    ):
        labels.append("large_compute_candidate")
        evidence_paths.append("large_compute_scale")
        notes.append("Achieved-operation integral crosses T_sys; workload identity remains unresolved without independent identity-shape evidence.")

    if _activity_fabric_pair(derived) and primary_coverage >= THRESHOLDS["min_primary_B_channel_coverage_fraction"]:
        labels.append("distributed_training_like_candidate")
        evidence_paths.extend(["accelerator_activity_run_existence", "fabric_parameter_update_like"])

    if _activity_checkpoint_pair(derived) and primary_coverage >= THRESHOLDS["min_primary_B_channel_coverage_fraction"]:
        labels.append("checkpoint_training_like_candidate")
        evidence_paths.extend(["accelerator_activity_run_existence", "storage_checkpoint_state_like"])

    if (
        "large_compute_candidate" in labels
        and ("distributed_training_like_candidate" in labels or "checkpoint_training_like_candidate" in labels)
    ):
        labels.append("sparse_large_compute_training_like_candidate")

    identity_count = _identity_category_count(derived, labels)
    if not labels:
        warning_height = "none"
    elif suppressor_coverage < THRESHOLDS["min_primary_B_channel_coverage_fraction"]:
        warning_height = "weak_training_like_candidate"
        notes.append("Suppressor coverage is incomplete, so B cannot promote medium or high warning.")
    elif identity_count >= 2 and primary_coverage >= 0.85:
        warning_height = "high_training_like_warning"
    elif "distributed_training_like_candidate" in labels or "checkpoint_training_like_candidate" in labels:
        warning_height = "medium_training_like_warning"
    else:
        warning_height = "weak_training_like_candidate"

    return {
        "stage": "B_training_candidate_detection",
        "mode": "candidate_detection",
        "capacity_input_label": stage_a["label"],
        "labels": _unique(labels),
        "positive_evidence_paths": _unique(evidence_paths),
        "identity_category_count": identity_count,
        "warning_height": warning_height,
        "primary_channel_coverage_fraction": primary_coverage,
        "suppressor_channel_coverage_fraction": suppressor_coverage,
        "notes": notes,
    }


def _targeted_c_review(
    site: dict[str, Any],
    derived: dict[str, Any],
    stage_a: dict[str, Any],
    stage_b: dict[str, Any],
) -> dict[str, Any]:
    labels: list[str] = []
    suppressors: list[str] = []
    explanations: list[str] = []
    discrepancies: list[str] = []
    missing_channels: list[str] = []
    notes: list[str] = []
    candidate_labels = set(stage_b["labels"])
    has_candidate = bool(candidate_labels)

    if not has_candidate:
        neg = derived["negative_screen_required_coverage_state"]
        missing_channels = _negative_screen_missing_channels(neg)
        incoherence_discrepancies = _negative_screen_incoherence(derived, site)
        if missing_channels or neg["decision_blocking_missingness"]:
            labels.extend(["negative_screen_blocked_by_missingness", "inconclusive_due_to_missingness"])
            notes.append("C1 ran only the coverage, scope, and clock checks needed to adjudicate the negative screen.")
        elif incoherence_discrepancies:
            labels.extend(["negative_screen_incoherence_conflict", "integrity_review_required"])
            discrepancies.extend(incoherence_discrepancies)
            notes.append("C1 found strong identity-shape evidence without aligned activity and no benign explanation.")
        else:
            labels.append("negative_screen_coverage_sufficient")
            notes.append("C1 verified primary, identity-shape, scope-mapping, and clock coverage for the no-candidate segment.")
        return {
            "stage": "C_discrepancy_and_explanation_review",
            "mode": "C1_negative_screen_integrity",
            "labels": labels,
            "suppressors": suppressors,
            "explanations": explanations,
            "discrepancies": discrepancies,
            "missing_channels": missing_channels,
            "notes": notes,
        }

    non_serving = derived["non_serving_score"]
    storage_op = derived["storage_operation_explanation"]
    alternative = derived["benchmark_hpc_alternative"]
    activity = derived["accelerator_activity_score"]
    achieved = derived["achieved_operation_integral"]
    cap = derived["capacity_upper_bound_flop"]
    telemetry = derived["telemetry_coverage_fraction"]
    signals = site.get("normalized_signals", {})
    coverage = site.get("coverage", {})

    if (
        non_serving["serving_counterevidence_score"] >= THRESHOLDS["min_serving_suppression_score"]
        and non_serving["serving_activity_overlap_fraction"] >= THRESHOLDS["min_serving_activity_overlap_fraction"]
        and non_serving["coverage_fraction"] >= 0.60
    ):
        labels.append("candidate_explained_by_serving")
        suppressors.append("serving_counterevidence")
        explanations.append("serving-like network shape overlaps the activity window.")

    if (
        ("checkpoint_training_like_candidate" in candidate_labels or "distributed_training_like_candidate" in candidate_labels)
        and storage_op["operation_overlap_fraction"] >= THRESHOLDS["min_operation_activity_overlap_fraction"]
        and storage_op["bytes_explained_fraction"] >= THRESHOLDS["min_bytes_explained_fraction"]
    ):
        labels.append("candidate_explained_by_storage_operation")
        suppressors.append("storage_operation_explanation")
        explanations.append("Explicit storage operation explains most overlapping checkpoint/fabric bytes.")

    if (
        alternative["benchmark_regularity_score"] >= THRESHOLDS["min_benchmark_regularity_score"]
        and alternative["benchmark_duration_seconds"] <= THRESHOLDS["max_benchmark_duration_seconds"]
        and alternative["coverage_fraction"] >= 0.60
    ):
        labels.append("candidate_benchmark_like")
        suppressors.append("benchmark_hpc_alternative")
        explanations.append("Regular short collective cadence is benchmark-like.")

    if (
        alternative["hpc_mpi_score"] >= THRESHOLDS["min_sparse_hpc_fabric_cadence_score"]
        and activity["activity_score"] >= THRESHOLDS["min_sparse_hpc_activity_score"]
        and alternative["hpc_overlap_fraction"] >= THRESHOLDS["min_sparse_hpc_overlap_fraction"]
    ):
        labels.append("candidate_hpc_mpi_alternative")
        suppressors.append("benchmark_hpc_alternative")
        explanations.append("Fabric-heavy activity aligns with an HPC/MPI alternative.")

    if _capacity_claim_conflict(derived, signals):
        labels.append("capacity_claim_conflict")
        discrepancies.append("capacity_claim_conflict")
    if _activity_attribution_conflict(derived, coverage, signals):
        labels.append("activity_attribution_conflict")
        discrepancies.append("activity_attribution_conflict")

    for key, label in [
        ("physical_timeline_conflict", "physical_timeline_conflict"),
        ("health_throttle_conflict", "health_throttle_conflict"),
        ("topology_route_conflict", "topology_route_conflict"),
        ("power_activity_conflict", "power_activity_conflict"),
    ]:
        if signals.get(key):
            labels.append(label)
            discrepancies.append(label)

    for channel in _candidate_missing_channels(derived, candidate_labels):
        if channel not in missing_channels:
            missing_channels.append(channel)
    if missing_channels:
        labels.append("inconclusive_due_to_missingness")

    if discrepancies:
        labels.append("integrity_review_required")
    elif missing_channels:
        labels.append("candidate_requires_manual_review")
    elif not _checked_suppressors(derived):
        labels.append("candidate_demoted_by_unresolved_suppressor")
        suppressors.append("missing_suppressor_coverage")

    if "large_compute_candidate" in candidate_labels and _identity_category_count(derived, list(candidate_labels)) == 0:
        notes.append("Large compute candidate has no independent fabric/checkpoint/non-serving identity support.")

    surviving_identity_pathway = (
        ("serving_counterevidence" in suppressors and _checkpoint_pathway_strong(derived))
        or ("storage_operation_explanation" in suppressors and _fabric_pathway_strong(derived))
    )

    return {
        "stage": "C_discrepancy_and_explanation_review",
        "mode": "C2_candidate_conflict_adjudication",
        "labels": _unique(labels),
        "suppressors": _unique(suppressors),
        "explanations": _unique(explanations),
        "discrepancies": _unique(discrepancies),
        "missing_channels": _unique(missing_channels),
        "notes": notes,
        "surviving_identity_pathway": surviving_identity_pathway,
        "achieved_to_capacity_ratio": achieved["operation_count_to_capacity_upper_bound_ratio"],
        "capacity_upper_bound_operations": cap["capacity_upper_bound_operations"],
        "suppressor_channel_coverage_fraction": telemetry["suppressor_channel_coverage_fraction"],
    }


def _final_route(
    site: dict[str, Any],
    derived: dict[str, Any],
    stage_a: dict[str, Any],
    stage_b: dict[str, Any],
    stage_c: dict[str, Any],
) -> dict[str, Any]:
    c_labels = set(stage_c["labels"])
    b_labels = set(stage_b["labels"])
    caveats: list[str] = []

    if derived["capacity_segment_window"].get("invalid_audit_window"):
        label = "inconclusive_due_to_missingness"
    elif stage_a["label"] == "capacity_ruled_out_for_scope":
        label = "capacity_ruled_out_for_scope"
    elif stage_a.get("ruleout_capacity_claim_conflict"):
        label = "integrity_review_required"
    elif "integrity_review_required" in c_labels:
        label = "integrity_review_required"
    elif "inconclusive_due_to_missingness" in c_labels and not b_labels:
        label = "inconclusive_due_to_missingness"
    elif c_labels.intersection(
        {
            "candidate_explained_by_serving",
            "candidate_explained_by_storage_operation",
            "candidate_benchmark_like",
            "candidate_hpc_mpi_alternative",
            "candidate_demoted_by_unresolved_suppressor",
        }
    ):
        if stage_c.get("surviving_identity_pathway"):
            if _identity_category_count(derived, list(b_labels)) >= 2:
                label = "high_training_like_warning"
            else:
                label = "medium_training_like_warning"
        else:
            label = "candidate_explained_or_demoted"
    elif "inconclusive_due_to_missingness" in c_labels:
        label = "inconclusive_due_to_missingness"
    elif stage_b["warning_height"] == "high_training_like_warning":
        label = "high_training_like_warning"
    elif stage_b["warning_height"] == "medium_training_like_warning":
        label = "medium_training_like_warning"
    elif b_labels:
        label = "weak_training_like_candidate"
    elif "negative_screen_coverage_sufficient" in c_labels:
        label = "no_training_like_candidate_detected_in_covered_live_segment"
    else:
        label = "inconclusive_due_to_missingness"

    if "large_compute_candidate" in b_labels and not (
        {"distributed_training_like_candidate", "checkpoint_training_like_candidate"} & b_labels
    ):
        caveats.append("large_compute_training_identity_unresolved")
    if stage_c["missing_channels"]:
        caveats.append("decision_blocking_missing_channels: " + ", ".join(stage_c["missing_channels"]))
    if stage_c["suppressors"]:
        caveats.append("candidate suppressors/explanations checked: " + ", ".join(stage_c["suppressors"]))
    if stage_a["missing_inputs"]:
        caveats.append("capacity missing inputs: " + ", ".join(stage_a["missing_inputs"]))

    reader_numbers = {
        "capacity_upper_bound_operations": derived["capacity_upper_bound_flop"]["capacity_upper_bound_operations"],
        "achieved_operations": derived["achieved_operation_integral"]["operation_count"],
        "achieved_to_capacity_ratio": derived["achieved_operation_integral"]["operation_count_to_capacity_upper_bound_ratio"],
        "activity_score": derived["accelerator_activity_score"]["activity_score"],
        "fabric_cadence_score": derived["collective_cadence_score"]["cadence_score"],
        "checkpoint_score": derived["checkpoint_periodicity_score"]["checkpoint_score"],
        "serving_counterevidence_score": derived["non_serving_score"]["serving_counterevidence_score"],
        "capacity_coverage": derived["capacity_upper_bound_flop"]["coverage_fraction"],
        "primary_channel_coverage": derived["telemetry_coverage_fraction"]["primary_channel_min"],
        "identity_shape_coverage": derived["telemetry_coverage_fraction"]["identity_shape_coverage_fraction"],
        "scope_mapping_coverage": derived["telemetry_coverage_fraction"]["scope_mapping_coverage_fraction"],
        "clock_alignment_confidence": derived["clock_aligned_overlap_window"]["clock_alignment_confidence"],
    }

    return {
        "stage": "final_claim_routing",
        "label": label,
        "warning_height": label if label.endswith("_warning") or label == "weak_training_like_candidate" else "none",
        "caveats": caveats,
        "reader_numbers": reader_numbers,
        "statement": _final_statement(label),
    }


def _demo_state(site: dict[str, Any], derived: dict[str, Any]) -> dict[str, Any]:
    cap = derived["capacity_upper_bound_flop"]
    achieved = derived["achieved_operation_integral"]
    activity = derived["accelerator_activity_score"]
    fabric = derived["collective_cadence_score"]
    checkpoint = derived["checkpoint_periodicity_score"]
    non_serving = derived["non_serving_score"]
    storage_op = derived["storage_operation_explanation"]
    alternative = derived["benchmark_hpc_alternative"]
    negative = derived["negative_screen_required_coverage_state"]
    signals = site.get("normalized_signals", {})
    coverage = site.get("coverage", {})

    return {
        "accelerator_count": cap["count"],
        "peak_rate_ops_per_second": cap["peak_rate_ops_per_second"],
        "duration_hours": derived["capacity_segment_window"]["duration_seconds"] / 3600.0,
        "capacity_coverage": cap["coverage_fraction"],
        "activity_score": activity["activity_score"],
        "activity_coverage": activity["coverage_fraction"],
        "achieved_operations": achieved["operation_count"],
        "achieved_ops_coverage": achieved["coverage_fraction"],
        "fabric_cadence_score": fabric["cadence_score"],
        "fabric_coverage": fabric["coverage_fraction"],
        "participant_count": fabric["participant_count"],
        "checkpoint_score": checkpoint["checkpoint_score"],
        "checkpoint_burst_count": checkpoint["burst_count"],
        "storage_coverage": checkpoint["coverage_fraction"],
        "serving_counterevidence_score": non_serving["serving_counterevidence_score"],
        "serving_coverage": non_serving["coverage_fraction"],
        "serving_activity_overlap_fraction": non_serving["serving_activity_overlap_fraction"],
        "storage_operation_explained_fraction": storage_op["bytes_explained_fraction"],
        "storage_operation_overlap_fraction": storage_op["operation_overlap_fraction"],
        "storage_operation_coverage": storage_op["coverage_fraction"],
        "benchmark_regularity_score": alternative["benchmark_regularity_score"],
        "benchmark_duration_seconds": alternative["benchmark_duration_seconds"],
        "hpc_mpi_score": alternative["hpc_mpi_score"],
        "hpc_overlap_fraction": alternative["hpc_overlap_fraction"],
        "benchmark_hpc_coverage": alternative["coverage_fraction"],
        "attribution_coverage": _coverage(coverage, "attribution"),
        "attribution_overlap_fraction": _number(signals.get("attribution_overlap_fraction"), 1.0),
        "scope_mapping_coverage": negative["scope_mapping_coverage_fraction"],
        "clock_alignment_confidence": negative["clock_alignment_confidence"],
        "hidden_or_unmonitored_capacity_possible": cap["hidden_or_unmonitored_capacity_possible"],
        "physical_timeline_conflict": bool(signals.get("physical_timeline_conflict", False)),
        "health_throttle_conflict": bool(signals.get("health_throttle_conflict", False)),
        "topology_route_conflict": bool(signals.get("topology_route_conflict", False)),
        "power_activity_conflict": bool(signals.get("power_activity_conflict", False)),
    }


def _activity_fabric_pair(derived: dict[str, Any]) -> bool:
    activity = derived["accelerator_activity_score"]
    fabric = derived["collective_cadence_score"]
    return (
        activity["activity_score"] >= THRESHOLDS["min_activity_for_fabric_pair"]
        and fabric["cadence_score"] >= THRESHOLDS["min_fabric_cadence_pair_score"]
        and fabric["activity_fabric_overlap_fraction"] >= THRESHOLDS["min_activity_fabric_overlap_fraction"]
        and activity["duration_seconds"] >= THRESHOLDS["min_activity_fabric_duration_seconds"]
    )


def _activity_checkpoint_pair(derived: dict[str, Any]) -> bool:
    activity = derived["accelerator_activity_score"]
    checkpoint = derived["checkpoint_periodicity_score"]
    return (
        activity["activity_score"] >= THRESHOLDS["min_activity_for_checkpoint_pair"]
        and checkpoint["checkpoint_score"] >= THRESHOLDS["min_checkpoint_pair_score"]
        and checkpoint["checkpoint_activity_adjacency_fraction"] >= THRESHOLDS["min_checkpoint_activity_adjacency_fraction"]
        and checkpoint["burst_count"] >= THRESHOLDS["min_checkpoint_pair_burst_count"]
    )


def _fabric_pathway_strong(derived: dict[str, Any]) -> bool:
    return (
        _activity_fabric_pair(derived)
        and derived["collective_cadence_score"]["coverage_fraction"] >= THRESHOLDS["min_negative_screen_identity_coverage_fraction"]
    )


def _checkpoint_pathway_strong(derived: dict[str, Any]) -> bool:
    return (
        _activity_checkpoint_pair(derived)
        and derived["checkpoint_periodicity_score"]["coverage_fraction"] >= THRESHOLDS["min_negative_screen_identity_coverage_fraction"]
    )


def _benign_identity_explanation(derived: dict[str, Any]) -> bool:
    storage_op = derived["storage_operation_explanation"]
    non_serving = derived["non_serving_score"]
    alternative = derived["benchmark_hpc_alternative"]
    activity = derived["accelerator_activity_score"]
    storage_explained = (
        storage_op["operation_overlap_fraction"] >= THRESHOLDS["min_operation_activity_overlap_fraction"]
        and storage_op["bytes_explained_fraction"] >= THRESHOLDS["min_bytes_explained_fraction"]
    )
    serving_explained = (
        non_serving["serving_counterevidence_score"] >= THRESHOLDS["min_serving_suppression_score"]
        and non_serving["serving_activity_overlap_fraction"] >= THRESHOLDS["min_serving_activity_overlap_fraction"]
        and non_serving["coverage_fraction"] >= 0.60
    )
    benchmark_explained = (
        alternative["benchmark_regularity_score"] >= THRESHOLDS["min_benchmark_regularity_score"]
        and alternative["benchmark_duration_seconds"] <= THRESHOLDS["max_benchmark_duration_seconds"]
        and alternative["coverage_fraction"] >= 0.60
    )
    hpc_explained = (
        alternative["hpc_mpi_score"] >= THRESHOLDS["min_sparse_hpc_fabric_cadence_score"]
        and activity["activity_score"] >= THRESHOLDS["min_sparse_hpc_activity_score"]
        and alternative["hpc_overlap_fraction"] >= THRESHOLDS["min_sparse_hpc_overlap_fraction"]
    )
    return storage_explained or serving_explained or benchmark_explained or hpc_explained


def _negative_screen_incoherence(derived: dict[str, Any], site: dict[str, Any]) -> list[str]:
    fabric = derived["collective_cadence_score"]
    checkpoint = derived["checkpoint_periodicity_score"]
    negative = derived["negative_screen_required_coverage_state"]
    identity_cov = THRESHOLDS["min_negative_screen_identity_coverage_fraction"]
    fabric_coherent = (
        fabric["cadence_score"] >= THRESHOLDS["min_fabric_strong_identity_score"]
        and fabric["coverage_fraction"] >= identity_cov
    )
    checkpoint_coherent = (
        checkpoint["checkpoint_score"] >= THRESHOLDS["min_checkpoint_strong_identity_score"]
        and checkpoint["burst_count"] >= THRESHOLDS["min_checkpoint_pair_burst_count"]
        and checkpoint["coverage_fraction"] >= identity_cov
    )
    activity = derived["accelerator_activity_score"]
    activity_low = activity["activity_score"] < THRESHOLDS["min_activity_for_fabric_pair"]
    primary_covered = negative["primary_activity_coverage_fraction"] >= identity_cov
    alignment_discrepancies = _negative_screen_alignment_incoherence(derived)
    raw_rate_discrepancies = _negative_screen_raw_rate_incoherence(derived, site)
    blocking_discrepancies = alignment_discrepancies + raw_rate_discrepancies
    if not (
        ((fabric_coherent or checkpoint_coherent) and activity_low and primary_covered)
        or blocking_discrepancies
    ):
        return []
    if blocking_discrepancies:
        discrepancies = list(blocking_discrepancies)
    elif _benign_identity_explanation(derived):
        return []
    else:
        discrepancies = []
    if fabric_coherent:
        discrepancies.append("fabric_without_job_or_topology_mapping_conflict")
    if checkpoint_coherent:
        discrepancies.append("checkpoint_writes_without_activity_conflict")
    return discrepancies


def _negative_screen_alignment_incoherence(derived: dict[str, Any]) -> list[str]:
    activity = derived["accelerator_activity_score"]
    fabric = derived["collective_cadence_score"]
    checkpoint = derived["checkpoint_periodicity_score"]
    negative = derived["negative_screen_required_coverage_state"]
    identity_cov = THRESHOLDS["min_negative_screen_identity_coverage_fraction"]
    if negative["primary_activity_coverage_fraction"] < identity_cov:
        return []
    discrepancies: list[str] = []
    if (
        activity["activity_score"] >= THRESHOLDS["min_activity_for_fabric_pair"]
        and fabric["cadence_score"] >= THRESHOLDS["min_fabric_strong_identity_score"]
        and fabric["coverage_fraction"] >= identity_cov
        and fabric["activity_fabric_overlap_fraction"] < THRESHOLDS["min_activity_fabric_overlap_fraction"]
    ):
        discrepancies.append("fabric_activity_alignment_incoherence_conflict")
    if (
        activity["activity_score"] >= THRESHOLDS["min_activity_for_checkpoint_pair"]
        and checkpoint["checkpoint_score"] >= THRESHOLDS["min_checkpoint_strong_identity_score"]
        and checkpoint["burst_count"] >= THRESHOLDS["min_checkpoint_pair_burst_count"]
        and checkpoint["coverage_fraction"] >= identity_cov
        and checkpoint["checkpoint_activity_adjacency_fraction"] < THRESHOLDS[
            "min_checkpoint_activity_adjacency_fraction"
        ]
    ):
        discrepancies.append("checkpoint_activity_alignment_incoherence_conflict")
    return discrepancies


def _negative_screen_raw_rate_incoherence(derived: dict[str, Any], site: dict[str, Any]) -> list[str]:
    raw_integral = _normalized_raw_rate_integral(site.get("raw_features", {}), derived)
    if raw_integral < POLICY_THRESHOLD_OPERATIONS:
        return []
    return ["raw_rate_threshold_compute_without_candidate_conflict"]


def _identity_category_count(derived: dict[str, Any], labels: list[str]) -> int:
    categories = set()
    if "distributed_training_like_candidate" in labels:
        categories.add("fabric_parameter_update_like")
    if "checkpoint_training_like_candidate" in labels:
        categories.add("storage_checkpoint_state_like")
    non_serving = derived["non_serving_score"]
    if (
        non_serving["non_serving_score"] >= THRESHOLDS["min_non_serving_pair_score"]
        and non_serving["coverage_fraction"] >= THRESHOLDS["min_serving_channel_coverage_fraction"]
    ):
        categories.add("non_serving_workload_shape")
    return len(categories)


def _checked_suppressors(derived: dict[str, Any]) -> bool:
    return derived["telemetry_coverage_fraction"]["suppressor_channel_coverage_fraction"] >= THRESHOLDS[
        "min_primary_B_channel_coverage_fraction"
    ]


def _capacity_claim_contradicted(derived: dict[str, Any], site: dict[str, Any]) -> bool:
    """A small claimed capacity is contradicted by independent telemetry.

    Generalizes the F2 achieved-vs-capacity guard to the whole coordinated-forge
    class (F3): under-reporting the accelerator count to drop the capacity bound
    below T_sys while shading achieved-operations down in lockstep keeps the
    achieved/capacity ratio below 1.0, but other, independently reported scale
    signals (the distributed-training participant set, the allocated inventory,
    and billed device-seconds) still exceed the claimed count and are physically
    incoherent with it. It also closes the peak-rate/adjustment deflation variant
    (F4): when the bound is shaded through peak_rate or capacity_adjustment_factor
    while the achieved_operations override is masked down, the raw achieved
    operation-rate witness still integrates above the claimed bound. Finally it
    closes the remaining device-population witnesses the genuine positive emits but
    the four count-comparison sub-checks never read (F5): the running-accelerator
    interval count, the compute-shape accelerator count, the reserved/reservation
    capacity counts, the local-fabric device count, and the scale-out fabric
    node/switch counts (each a physical floor on the accelerator population). Each
    sub-check is gated on PRESENT, usable evidence: an absent signal never fires the
    guard, so honest small-scope rule-outs (which report none of these signals) are
    untouched. Every additive device-population witness is aggregated by its CONCURRENT
    physical meaning (overlap-aware peak for the interval lists, sum across concurrent
    fabric/interconnect domains for the per-domain tables), not by the single largest
    record (F6): an operator who reports a large pool honestly as many concurrent
    sub-pool records each below the claimed count is therefore caught, while genuine
    sequential reuse of the same devices is not over-counted. The forge therefore
    requires coherently suppressing or falsifying EVERY enumerated scale witness at
    once, which is the disclosed irreducible residual.
    """
    return bool(_capacity_claim_contradictions(derived, site))


def _capacity_claim_contradictions(derived: dict[str, Any], site: dict[str, Any]) -> list[str]:
    cap = derived["capacity_upper_bound_flop"]
    achieved = derived["achieved_operation_integral"]
    count = cap["count"]
    raw = site.get("raw_features", {})
    signals = site.get("normalized_signals", {})
    contradictions: list[str] = []

    # (i) achieved-operation integral exceeds the capacity bound (the F2 case).
    if (
        "achieved_operations" in signals
        and bool(signals.get("achieved_operations_unit_normalized", True))
        and cap["capacity_upper_bound_operations"] > 0
        and achieved["operation_count"] > cap["capacity_upper_bound_operations"]
    ):
        contradictions.append("achieved_operations_exceed_capacity_bound")

    # (ii) participant set larger than the claimed accelerator inventory.
    participant_count = max(
        derived["collective_cadence_score"]["participant_count"],
        _counter(raw, "participant_count"),
    )
    if participant_count > 0 and count > 0 and participant_count > count:
        contradictions.append("participant_count_exceeds_capacity_count")

    # (iii) allocated/reserved accelerators exceed the reported inventory.
    allocated_count = _positive_sum(raw.get("allocated_accelerator_count_by_sku", []) or [], "count")
    if allocated_count > 0 and count > 0 and allocated_count > count:
        contradictions.append("allocated_count_exceeds_capacity_count")

    # (iv) billed device-seconds imply more concurrent devices than reported.
    implied, billing_present = _billing_implied_device_count(raw, derived)
    if billing_present and implied > 0 and count > 0 and implied > count:
        contradictions.append("billing_device_hours_exceed_capacity_count")

    # (v) raw achieved operation-rate witness exceeds the bound even when the
    #     achieved_operations override is masked down (the F4 peak/adjust-deflation
    #     variant: the bound is shaded via peak_rate or capacity_adjustment_factor
    #     and the override is reported low, but the independent raw rate integrates
    #     above the claimed bound).
    raw_integral = _normalized_raw_rate_integral(raw, derived)
    bound = cap["capacity_upper_bound_operations"]
    if (
        raw_integral > 0
        and bound > 0
        and raw_integral > bound
    ):
        contradictions.append("raw_achieved_rate_integral_exceeds_capacity_bound")

    if _capacity_adjustment_deflates_threshold_capacity(derived):
        contradictions.append("capacity_adjustment_deflates_raw_threshold_capacity")

    implied_service_devices, service_present = _electrical_service_implied_device_floor(raw)
    count_epsilon = ELECTRICAL_SERVICE_COUNT_EPSILON_FRACTION * max(1.0, count)
    if service_present and count > 0 and implied_service_devices > count + count_epsilon:
        contradictions.append("electrical_service_power_floor_exceeds_capacity_count")

    # (vi)-(xii) every other device-population witness the telemetry emits. Each is a
    #     direct count of accelerators (or a physical floor on the accelerator
    #     population) that an honest large run reports and that the F2/F3 forge leaves
    #     standing while it shades the accelerator_count_by_family_sku down. A witness
    #     fires only when it is actually reported (> 0) and exceeds the claimed count,
    #     so absent evidence never fires and the strict floor (witness > count) flips
    #     none of the legitimate rule-outs (where every emitted population witness is
    #     <= count). This closes the schema rather than any single field: the only way
    #     to forge the rule-out is to suppress ALL of these at once. The fabric-graph
    #     node/switch counts are population FLOORS (each fabric node hosts at least one
    #     accelerator and each switch serves at least one node), so node_count and
    #     switch_count exceeding the claimed count is physically incoherent; link_count
    #     is deliberately NOT a witness because links scale super-linearly with the
    #     accelerator population and exceed an honest count by construction.
    #     Each witness is aggregated by its CONCURRENT physical semantics
    #     (overlap-aware peak for the interval lists, sum across spatial/concurrent
    #     fabric/interconnect domains for the per-domain tables), NOT `_max`: an
    #     operator who reports one large pool HONESTLY as N concurrent sub-pool records
    #     each below the claimed count is therefore caught (F6), while genuine
    #     sequential reuse of the same devices is not over-counted.
    for label, value in _device_population_witnesses(raw):
        if value > 0 and count > 0 and value > count:
            contradictions.append(label)

    return contradictions


def _capacity_adjustment_deflates_threshold_capacity(derived: dict[str, Any]) -> bool:
    cap = derived["capacity_upper_bound_flop"]
    factor = cap["capacity_adjustment_factor"]
    return (
        factor < 1.0
        and cap["unadjusted_capacity_upper_bound_operations"] >= POLICY_THRESHOLD_OPERATIONS
        and cap["capacity_upper_bound_operations"] < POLICY_THRESHOLD_OPERATIONS
    )


def _normalized_raw_rate_integral(raw: dict[str, Any], derived: dict[str, Any]) -> float:
    duration = derived["capacity_segment_window"]["duration_seconds"]
    rates = []
    for record in raw.get("generic_achieved_operation_rate", []) or []:
        unit = str(record.get("operation_unit", "") or "").lower()
        if unit not in NORMALIZED_OPERATION_UNITS:
            continue
        rates.append(_number(record.get("operation_rate"), 0.0))
    return (max(rates) if rates else 0.0) * duration


def _electrical_service_implied_device_floor(raw: dict[str, Any]) -> tuple[float, bool]:
    service_intervals: list[dict[str, Any]] = []
    present = False
    for record in raw.get("electrical_service_status_intervals", []) or []:
        status = str(record.get("service_status", "") or "").lower()
        service_class = str(record.get("service_class", "") or "").lower()
        if status not in SUPPORTING_ELECTRICAL_SERVICE_STATES:
            continue
        if service_class not in SCOPED_ELECTRICAL_SERVICE_CLASSES:
            continue
        values = [
            _number(record.get(key), 0.0)
            for key in ("service_capacity_mw", "power_mw", "mean_power_mw", "max_power_mw")
        ]
        record_mw = max(values) if values else 0.0
        if record_mw > 0:
            present = True
            service_intervals.append(
                {
                    "start_time": record.get("start_time"),
                    "end_time": record.get("end_time"),
                    "service_mw": record_mw,
                }
            )
    peak_mw = _concurrent_peak(service_intervals, "service_mw")
    implied = peak_mw * 1_000_000.0 / ELECTRICAL_SERVICE_WATTS_PER_ACCELERATOR
    return implied, present


def _device_population_witnesses(raw: dict[str, Any]) -> list[tuple[str, float]]:
    """Every reported device-population/training-scale count not covered by sub-checks
    (i)-(v), paired with its conflict label. Each value is either a direct accelerator
    count or a physical floor on the accelerator population (a fabric node hosts at
    least one accelerator, a switch serves at least one node). Only PRESENT records are
    summarized so the caller stays evidence-present-gated. link_count is excluded on
    purpose: it is not a device population and scales above an honest count.

    Each witness is aggregated by its CORRECT physical (concurrent) semantics, not by
    `_max`. `_max` reads only the single largest record, so an operator who reports one
    large pool HONESTLY as N concurrent sub-pool records each below the claimed count
    defeats it while the true concurrent population stands far above the claim (F6).
    The aggregation per witness is:

      - compute_running_intervals / capacity_reservation_intervals /
        reservation_state_intervals are interval_lists (each carries start_time and
        end_time): overlap-aware concurrent PEAK (max over time of the sum of the count
        across temporally overlapping intervals). Concurrent sub-pools add up to the
        true population, but sequential reuse of the same devices does NOT over-count.
      - scaleout_fabric_domain_graph node_count / switch_count and
        local_accelerator_interconnect_domain local_fabric_device_count are per-domain
        capability records (one record PER spatial/concurrent fabric or interconnect
        domain): SUM across domains. A multi-domain cluster honestly emits one record
        per domain, and the domains coexist, so the device population is the sum.
      - instance_type_shape_machine_type already uses `_sum` (a labeled inventory table
        whose rows are additive); it is immune and kept as-is.
    """
    fabric_graph = raw.get("scaleout_fabric_domain_graph", []) or []
    return [
        # direct accelerator counts the operator reports elsewhere in inventory.
        # The interval lists use the overlap-aware concurrent peak so split-pool
        # concurrent sub-records sum, while genuine sequential reuse does not.
        ("running_accelerator_count_exceeds_capacity_count", _concurrent_peak(raw.get("compute_running_intervals", []) or [], "accelerator_count")),
        ("instance_shape_accelerator_count_exceeds_capacity_count", _positive_sum(raw.get("instance_type_shape_machine_type", []) or [], "accelerator_count")),
        ("reserved_accelerator_count_exceeds_capacity_count", _concurrent_peak(raw.get("capacity_reservation_intervals", []) or [], "reserved_accelerator_count")),
        ("reservation_capacity_count_exceeds_capacity_count", _concurrent_peak(raw.get("reservation_state_intervals", []) or [], "reservation_capacity_count")),
        # per-domain interconnect records are spatial/concurrent: sum across domains.
        ("local_fabric_device_count_exceeds_capacity_count", _positive_sum(raw.get("local_accelerator_interconnect_domain", []) or [], "local_fabric_device_count")),
        # fabric-topology floors on the accelerator population. One graph record per
        # fabric domain, so node/switch counts sum across distinct concurrent domains.
        ("fabric_node_count_exceeds_capacity_count", _positive_sum(fabric_graph, "node_count")),
        ("fabric_switch_count_exceeds_capacity_count", _positive_sum(fabric_graph, "switch_count")),
    ]


def _billing_implied_device_count(
    raw: dict[str, Any], derived: dict[str, Any]
) -> tuple[float, bool]:
    """Device-seconds billed over the window / window seconds = implied concurrent
    device count. Only counts intervals reported in accelerator_seconds (the unit
    the synthetic feed and the provider-account billing analogue both use); any other unit is
    treated as not-usable evidence so the sub-check stays evidence-present-gated."""
    intervals = raw.get("accelerator_compute_billing_usage_intervals") or []
    duration = derived["capacity_segment_window"]["duration_seconds"]
    total_device_seconds = 0.0
    present = False
    for interval in intervals:
        if interval.get("usage_unit") == "accelerator_seconds":
                quantity = _number(interval.get("usage_quantity"), 0.0)
                if quantity > 0:
                    total_device_seconds += quantity
                    present = True
    implied = total_device_seconds / duration if duration > 0 else 0.0
    return implied, present


def _capacity_claim_conflict(derived: dict[str, Any], signals: dict[str, Any]) -> bool:
    achieved = derived["achieved_operation_integral"]
    cap = derived["capacity_upper_bound_flop"]
    suppression = _number(signals.get("unit_mismatch_or_hidden_capacity_explanation_score"), 0.0)
    return (
        achieved["unit_normalized"]
        and achieved["operation_count_to_capacity_upper_bound_ratio"] > THRESHOLDS["max_sparse_achieved_to_capacity_ratio"]
        and cap["coverage_fraction"] >= THRESHOLDS["min_sparse_capacity_conflict_coverage_fraction"]
        and suppression < THRESHOLDS["unit_or_hidden_capacity_suppression_score"]
    )


def _activity_attribution_conflict(
    derived: dict[str, Any],
    coverage: dict[str, Any],
    signals: dict[str, Any],
) -> bool:
    activity = derived["accelerator_activity_score"]
    return (
        activity["activity_score"] >= THRESHOLDS["min_unattributed_activity_score"]
        and activity["duration_seconds"] >= THRESHOLDS["min_unattributed_activity_duration_seconds"]
        and _number(signals.get("attribution_overlap_fraction"), 1.0) <= THRESHOLDS["max_attribution_overlap_fraction"]
        and _coverage(coverage, "attribution") >= THRESHOLDS["min_attribution_channel_coverage_fraction"]
        and _number(signals.get("benign_attribution_explanation_overlap_fraction"), 0.0)
        < THRESHOLDS["benign_attribution_explanation_overlap_fraction"]
    )


def _candidate_missing_channels(derived: dict[str, Any], labels: set[str]) -> list[str]:
    missing = []
    telemetry = derived["telemetry_coverage_fraction"]
    if telemetry["primary_channel_min"] < THRESHOLDS["min_primary_B_channel_coverage_fraction"]:
        missing.append("primary_activity_or_achieved_ops")
    if (
        {"distributed_training_like_candidate", "checkpoint_training_like_candidate", "sparse_large_compute_training_like_candidate"}
        & labels
        and telemetry["identity_shape_coverage_fraction"] < THRESHOLDS["min_primary_B_channel_coverage_fraction"]
    ):
        missing.append("identity_shape")
    if telemetry["scope_mapping_coverage_fraction"] < THRESHOLDS["min_negative_screen_scope_mapping_coverage_fraction"]:
        missing.append("scope_mapping")
    if telemetry["clock_alignment_confidence"] < THRESHOLDS["min_negative_screen_clock_alignment_confidence"]:
        missing.append("clock_alignment")
    if telemetry["suppressor_channel_coverage_fraction"] < THRESHOLDS["min_primary_B_channel_coverage_fraction"]:
        missing.append("suppressor_channels")
    return missing


def _negative_screen_missing_channels(negative: dict[str, Any]) -> list[str]:
    missing = []
    if negative.get("invalid_audit_window"):
        missing.append("audit_window")
    if negative["primary_activity_coverage_fraction"] < THRESHOLDS["min_negative_screen_primary_coverage_fraction"]:
        missing.append("primary_activity")
    if negative["achieved_ops_coverage_fraction"] < THRESHOLDS["min_negative_screen_primary_coverage_fraction"]:
        missing.append("achieved_ops")
    if negative["identity_shape_coverage_fraction"] < THRESHOLDS["min_negative_screen_identity_coverage_fraction"]:
        missing.append("identity_shape")
    if negative["scope_mapping_coverage_fraction"] < THRESHOLDS["min_negative_screen_scope_mapping_coverage_fraction"]:
        missing.append("scope_mapping")
    if negative["clock_alignment_confidence"] < THRESHOLDS["min_negative_screen_clock_alignment_confidence"]:
        missing.append("clock_alignment")
    return missing


def _missing_channels_for_threshold(site: dict[str, Any], threshold: float) -> list[str]:
    coverage = site.get("coverage", {})
    return sorted(key for key, value in coverage.items() if isinstance(value, (int, float)) and value < threshold)


def _capacity_missing_inputs(cap: dict[str, Any], coverage: float, clock: float) -> list[str]:
    missing = []
    if cap.get("invalid_audit_window"):
        missing.append("audit_window")
    if cap["count"] <= 0 or cap["has_negative_count"]:
        missing.append("accelerator_count_by_family_sku")
    if cap["missing_required_peak_rate"]:
        missing.append("advertised_peak_rate_by_precision")
    if cap.get("invalid_capacity_adjustment_factor"):
        missing.append("capacity_adjustment_factor")
    if coverage < THRESHOLDS["min_capacity_possible_coverage_fraction"]:
        missing.append("capacity_coverage")
    if clock < THRESHOLDS["min_capacity_clock_alignment_confidence"]:
        missing.append("clock_alignment")
    if cap["hidden_or_unmonitored_capacity_possible"]:
        missing.append("hidden_or_unmonitored_capacity_possible")
    if not cap["unit_normalized"]:
        missing.append("capacity_unit_normalization")
    return missing


def _capacity_notes(label: str) -> list[str]:
    if label == "capacity_ruled_out_for_scope":
        return ["Conservative capacity upper bound is below T_sys with high coverage; B and C are skipped."]
    if label == "capacity_claim_conflict_blocks_ruleout":
        return [
            "Independent capacity-scale witnesses contradict the reported capacity inputs; the rule-out is "
            "withheld and routed to integrity review.",
        ]
    if label == "capacity_possible_for_scope":
        return ["Capacity remains live; A does not imply workload identity."]
    if label == "capacity_limited_but_not_ruled_out":
        return ["Capacity is below T_sys under current inputs, but coverage is not strong enough for a rule-out."]
    return ["Capacity inputs are missing or insufficiently aligned; B/C remain live with missingness caveats."]


def _final_statement(label: str) -> str:
    statements = {
        "capacity_ruled_out_for_scope": "Threshold-scale compute is conservatively ruled out for this monitored scope/window.",
        "no_training_like_candidate_detected_in_covered_live_segment": "No training-like candidate was detected and C1 coverage is sufficient to trust the negative screen.",
        "weak_training_like_candidate": "A sparse candidate remains, but evidence is too incomplete or underdetermined for medium/high warning.",
        "medium_training_like_warning": "Aligned activity and one training-like identity pathway survive targeted C review.",
        "high_training_like_warning": "Multiple independent aligned identity/support pathways survive targeted C review.",
        "candidate_explained_or_demoted": "Candidate evidence is explained or demoted by serving, storage-operation, benchmark, or HPC counterevidence.",
        "integrity_review_required": "Targeted C found an unresolved discrepancy that blocks ordinary warning routing.",
        "inconclusive_due_to_missingness": "Decision-blocking telemetry, scope, or clock coverage prevents a trusted positive or negative route.",
    }
    return statements.get(label, label)


def _output(rule_id: str, label: str, category: str) -> dict[str, str]:
    return {"rule_id": rule_id, "label": label, "category": category}


def _sum(records: list[dict[str, Any]], key: str) -> float:
    return sum(_number(record.get(key), 0.0) for record in records)


def _positive_sum(records: list[dict[str, Any]], key: str) -> float:
    return sum(max(0.0, _number(record.get(key), 0.0)) for record in records)


def _max(records: list[dict[str, Any]], key: str) -> float:
    values = [_number(record.get(key), 0.0) for record in records]
    return max(values) if values else 0.0


def _concurrent_peak(records: list[dict[str, Any]], key: str) -> float:
    """Overlap-aware concurrent peak of an additive interval-list witness.

    Returns the maximum over time of the SUM of `key` across temporally
    OVERLAPPING intervals. Concurrent sub-pools (each its own interval-list
    record over the same or overlapping windows) therefore add up to the true
    concurrent device population, while SEQUENTIAL reuse of the same devices
    (back-to-back, non-overlapping intervals) does NOT over-count: at any
    instant only the records active then contribute. This is the correct
    aggregation for `compute_running_intervals` and the reservation interval
    lists, which are physically additive across concurrent records (the guard's
    old `_max` read only the single largest record and was defeated by an
    operator who reported one large pool as N concurrent sub-pool records each
    below the claimed count).

    If a record is missing start/end timestamps it is treated as active over
    the whole window (it overlaps everything), so its value always contributes
    to the peak. With every record fully concurrent (identical windows, the
    honest representation of a single large run split into sub-pools) this
    reduces to plain `_sum`. Endpoints are treated as half-open so that an
    interval ending exactly when another begins (genuine sequential reuse) does
    NOT count as overlapping.
    """
    open_events: list[tuple[tuple[int, datetime], float]] = []
    close_events: list[tuple[tuple[int, datetime], float]] = []
    for record in records:
        value = _number(record.get(key), 0.0)
        if value <= 0:
            continue
        start_key, start_parsed = _interval_endpoint_key(record.get("start_time"), is_start=True)
        end_key, end_parsed = _interval_endpoint_key(record.get("end_time"), is_start=False)
        if start_parsed is not None and end_parsed is not None and end_parsed <= start_parsed:
            continue
        open_events.append((start_key, value))
        close_events.append((end_key, value))
    if not open_events:
        return 0.0
    open_events.sort(key=lambda item: item[0])
    close_events.sort(key=lambda item: item[0])
    current = 0.0
    peak = 0.0
    oi = 0
    ci = 0
    n = len(open_events)
    # Sweep: process all closes that occur at-or-before the next open BEFORE the
    # open (half-open intervals), so touching intervals do not count as
    # concurrent, but genuinely overlapping ones do.
    while oi < n:
        if ci < n and close_events[ci][0] <= open_events[oi][0]:
            current -= close_events[ci][1]
            ci += 1
            continue
        current += open_events[oi][1]
        oi += 1
        if current > peak:
            peak = current
    return peak


def _interval_endpoint_key(value: Any, *, is_start: bool) -> tuple[tuple[int, datetime], datetime | None]:
    parsed = _parse_iso_datetime(value)
    if parsed is None:
        sentinel = datetime.min.replace(tzinfo=timezone.utc) if is_start else datetime.max.replace(tzinfo=timezone.utc)
        return ((0 if is_start else 2), sentinel), None
    return (1, parsed), parsed


def _parse_iso_datetime(value: Any) -> datetime | None:
    if not isinstance(value, str) or not value:
        return None
    text = value[:-1] + "+00:00" if value.endswith("Z") else value
    try:
        parsed = datetime.fromisoformat(text)
    except ValueError:
        return None
    if parsed.tzinfo is None:
        return parsed.replace(tzinfo=timezone.utc)
    return parsed.astimezone(timezone.utc)


def _counter(raw_features: dict[str, Any], counter_name: str) -> float:
    values = []
    for record in raw_features.get("fabric_port_device_sample_counters", []):
        if record.get("counter_name") == counter_name:
            values.append(_number(record.get("counter_value"), 0.0))
    return max(values) if values else 0.0


def _coverage(coverage: dict[str, Any], key: str, default: float = 1.0) -> float:
    return _clamp(_number(coverage.get(key), default))


def _coverage_present(coverage: dict[str, Any], key: str) -> bool:
    value = coverage.get(key)
    return isinstance(value, (int, float)) and value == value


def _coverage_cert(coverage: dict[str, Any], key: str) -> float:
    if not _coverage_present(coverage, key):
        return 0.0
    return _clamp(_number(coverage.get(key), 0.0))


def _number(value: Any, default: float = 0.0) -> float:
    try:
        number = float(value)
    except (TypeError, ValueError):
        return default
    if number != number:
        return default
    return number


def _clamp(value: float, low: float = 0.0, high: float = 1.0) -> float:
    return min(high, max(low, value))


def _window_seconds(window: dict[str, str]) -> float:
    start = _parse_time(window["start"])
    end = _parse_time(window["end"])
    return (end - start).total_seconds()


def _parse_time(value: str) -> datetime:
    if value.endswith("Z"):
        value = value[:-1] + "+00:00"
    parsed = datetime.fromisoformat(value)
    if parsed.tzinfo is None:
        parsed = parsed.replace(tzinfo=timezone.utc)
    return parsed


def _unique(values: list[str]) -> list[str]:
    out: list[str] = []
    for value in values:
        if value not in out:
            out.append(value)
    return out