framework/observables/rules/README.md

# Observable Rule Layer

These files are algorithm-facing rule specifications derived from
`observables/observables.yaml`.

`observables/observables.yaml` remains the raw feature inventory. The files in
this directory define how those source-emitted values can be combined into
capacity bounds, training evidence, support/counterevidence, and discrepancy
checks.

## Evidence Split

- `capacity`: capability rules for whether a threshold-scale run was physically
  or computationally possible in a monitored scope and window.
- `training_core`: narrow training-evidence rules that can drive an algorithmic
  candidate label. These rules focus on aligned allocation/running context,
  sustained accelerator activity, collective-like fabric cadence, checkpoint
  signatures, achieved-operation counters, and serving counterevidence.
- `training_support`: weaker or contextual training signals. These can
  strengthen, weaken, explain, or route review of a core finding but should not
  be treated as primary training evidence by themselves.
- `discrepancy`: cross-layer checks for missing telemetry, manipulated or
  inconsistent records, incorrect attribution, or benign operational
  explanations such as maintenance, storage rebuilds, throttling, or topology
  changes.

Sparse rules are the operational entry point when only one, two, or three raw
features exist for a scope/window. They emit narrow facts, screens, support,
suppressors, explanations, missingness warnings, or contradictions.
`aggregation_rules.yaml` is the default staged operational layer above those
sparse outputs.

Training evidence is intentionally modeled as multiple pathways rather than one
universal detector. Large compute and high fabric bandwidth are not sufficient
by themselves; strong evidence comes from time-aligned capacity, accelerator
activity, workload-shape signals, and false-positive checks.

## Concrete Defaults And Portability

The rule layer now contains executable trigger defaults. Treat them as initial
review defaults for unseen datacenters, not final operational thresholds. Exact
positive training-identity thresholds are not portable across accelerator
families, topology generations, framework parallelism, telemetry aggregation,
storage systems, and local workload mixes.

Each concrete trigger default records an `evidence_status`:

- `source_backed`: directly supported by a cited source or policy value.
- `source_informed`: source-backed mechanism or measurement surface, but the
  numeric threshold is still an implementation choice.
- `mechanism_inferred`: derived from distributed-training, telemetry, or
  physical mechanism rather than an exact source threshold.
- `calibration_default`: executable starting point that must be replaced with
  local data before strong operational use.
- `project_assumption`: verification-design choice used to keep the algorithm
  runnable when no portable source threshold exists.

Normalized scores are preferred over raw thresholds: fractions of peak/capacity,
per-participant fabric volumes, overlap windows, coverage fractions, local
baseline percentiles, and topology-aware participant sets. Raw bytes, advertised
peak rates, allocation size, and power alone do not classify training.

`capacity_upper_bound_flop` is an upper-bound calculation. It can rule out a
threshold-scale run for a monitored scope/window when coverage is sufficient,
and it can flag claimed/achieved compute above capacity. It does not prove
training occurred. Similarly, `achieved_operation_integral >= 1e25` creates a
large-compute candidate; a training label still requires independent
training-identity support such as collective cadence, checkpoint signatures, or
non-serving model-development shape.

## Staged Aggregation Flow

`aggregation_rules.yaml` implements the algorithm-facing staged workflow:

1. `A_capacity_gate`: split the selected audit window into capacity-validity
   segments and evaluate capacity first.
2. `B_training_candidate_detection`: run only for capacity-possible,
   capacity-limited, or capacity-unknown segments. Promote warning-height
   candidates only from aligned accelerator activity plus independent
   identity-shape evidence.
3. `C_discrepancy_and_explanation_review`: run targeted discrepancy,
   suppressor, and missingness checks only when a live candidate, capacity
   conflict, or decision-blocking gap requires adjudication.
4. `final_claim_routing`: emit one final route per monitored scope/window
   segment, including warning height and caveats.

C has two targeted modes. The negative-screen integrity mode runs when B emits
no candidate in a live capacity segment and checks whether primary activity,
identity-shape, scope-mapping, and clock-alignment coverage are sufficient to
trust the absence of evidence. Candidate adjudication mode runs when B emits a
candidate, conflict, suppressor, explanation, or decision-blocking missingness.
Neither mode is a full global discrepancy sweep after a clean capacity rule-out
or a quiet, well-covered segment.

Candidate-window derived signals are stage-specific. B rules consume
`aggregation_candidate_seed_window`; C rules consume
`aggregation_candidate_review_window`, which contains B/support candidate state
but no C outcomes; final routing consumes `aggregation_candidate_final_window`,
which contains C suppressor, explanation, discrepancy, and missingness outcomes.

The capacity gate can short-circuit a segment only when a conservative
high-coverage upper bound emits `capacity_ruled_out_for_scope`. In that case B
candidate detection and general C review do not run for the ruled-out segment.
Capacity-unknown, capacity-limited, and sparse capacity-possible outputs remain
live.

Aggregation rules normally consume sparse rule categories, labels, and derived
signals rather than raw features. They therefore are not listed under every raw
feature in `feature_rule_index.yaml`; the index maps raw features to the rules
that interpret the raw values.

Before production use, replace calibration defaults with local distributions
from known training, inference, HPC/MPI, NCCL benchmark, burn-in, storage
maintenance, ETL, backup/restore, and serving workloads. Also calibrate
telemetry coverage, sampling intervals, clock drift, source delivery delays,
operation-unit normalization, and hardware-specific peak/cap/power behavior.

## Files

- `feature_rule_index.yaml`: coverage map from every feature ID in
  `observables/observables.yaml` to rule IDs.
- `aggregation_rules.yaml`: staged A/B/C/final aggregation over sparse rule
  outputs, including capacity short-circuiting, B warning-height promotion,
  suppressor/explanation demotion, targeted C routing, and final claim routing.
- `capability_rules.yaml`: sparse capacity screens for accelerator
  count/shape, peak rate, memory, topology, availability, power service,
  installation, quota, reservation, running, health, and maintenance features.
- `training_core_rules.yaml`: sparse-telemetry rule families that make
  the strongest honest candidate, weak-evidence, capacity, or suppression
  statement possible from one to three raw observable features.
- `training_support_rules.yaml`: sparse support, counterevidence, and
  explanation screens for physical load, memory residency, data lifecycle,
  topology, serving-like traffic, storage operations, benchmark/HPC
  alternatives, and lifecycle context.
- `discrepancy_rules.yaml`: sparse pair/triplet conflicts and
  missingness checks for activity attribution, capacity claims, physical
  timelines, power/activity, fabric mapping, storage/activity, telemetry gaps,
  health/throttle states, and route/topology changes.
- `derived_signals.yaml`: reusable computations referenced by multiple rule
  files.
- `source_ledger.yaml`: public source ledger for `Sxx` source references used by
  the rule files.