R and Python for Consensus Telemetry Analysis —
Block-Interval Distributions, Per-Validator Performance Panels, and the Explore-in-R-Enforce-in-Python Discipline

R answers is there something here. Python answers watch for it forever.

Section I§I — Frame

Today's Ops lesson made one claim above all others: normal is a distribution, and the degradation you care about lives in the tail, not the average. That is a data-analysis claim before it is an operations claim. Somebody has to actually compute the quantiles, rank the validators, and decide a rolling p90 has shifted enough to count. This lesson is that somebody's toolkit, and it splits the work across two languages on purpose.

The split is the recurring discipline of this Thursday arc: explore in R, enforce in Python. The two are not competing implementations of one thing. They are two phases of one workflow. R is where you meet the data, where a histogram and a five-number summary are each a single line, where a stretching tail is something the eye catches before any threshold is written. Python is where the finding hardens into a monitor: a frozen baseline artifact, a scheduled job reading the last thousand blocks, a comparison that emits the pre-halt degradation signal. R answers is there something here. Python answers watch for it forever.

Three ideas organize the lesson. The panel is a group-by. The frozen-baseline artifact is the whole point of the enforce phase. And the tail is the signal, which means every reduction keeps the quantiles and throws away the mean.

Section II§II — Language Idiom

R's idiom is the grammar of grouped summaries. Wickham and Grolemund's R for Data Science (Part I, pp. 121–123) frames exploratory data analysis as transform-then-summarise-then-visualise, and the consensus-telemetry read is a textbook instance. Block timestamps come in as a data frame. arrange by height, mutate to difference consecutive timestamps into intervals, summarise to collapse intervals into quantiles. The per-validator panel is the same verbs with one group_by(validator) inserted, which is the entire conceptual content of the panel: it is a group-by over the signer column, and everything else is bookkeeping.

The plotting idiom matters as much as the summarising one. A quantile table tells you the tail moved. A histogram, or better an empirical cumulative distribution, tells you how it moved — whether the whole distribution shifted or only the tail thickened. In R that is one ggplot call, and it is where a human decides whether the shift is real before a line of production code is committed. Exploration is cheap on purpose so enforcement can be expensive and deliberate.

Python's idiom is the opposite virtue: durability. Where R's grouped summary is a throwaway you run in a session, Python's is a function you schedule. The pandas groupby mirrors R's group_by almost verb for verb, and quantile mirrors quantile, but the surrounding code persists. The baseline is computed once and written to disk. The rolling check loads it, computes the same quantiles over the recent window, and returns a verdict. The point of Python is not that it computes anything R cannot; it is that the computation survives the session, runs unattended, and hands its verdict to the next stage with no human in the loop.

Section III§III — Code Worked Example

Start in R. The block table has height and ts per committed block. The interval read differences consecutive timestamps and summarises the intervals into the quantiles the Ops lesson named the baseline.

R — explore

library(dplyr)
library(ggplot2)

intervals <- blocks |>
  arrange(height) |>
  mutate(interval = as.numeric(ts - lag(ts), units = "secs")) |>
  filter(!is.na(interval))

interval_summary <- intervals |>
  summarise(
    p50 = quantile(interval, 0.50),
    p90 = quantile(interval, 0.90),
    p99 = quantile(interval, 0.99),
    n   = n()
  )

The interval_summary row is the block-interval baseline in three numbers plus a count. Reading it against a later window is a visual act first. The empirical cumulative distribution of a healthy window laid over a suspect window shows the tail divergence directly, and the plot is where the real-versus-noise judgement gets made.

R — see the tail

ggplot(intervals, aes(interval)) +
  stat_ecdf(geom = "step") +
  geom_vline(xintercept = c(6.8, 8.0), linetype = "dashed") +
  labs(x = "block interval (s)", y = "cumulative share")

The dashed lines mark the reference p90 and p99. A suspect window whose curve crosses those lines later than the reference is a window whose tail has stretched. The panel is the same grammar with a grouping clause, and the only structural addition is group_by(validator).

R — the panel is a group-by

validator_panel <- votes |>
  group_by(validator) |>
  summarise(
    share       = n() / nrow(votes),
    lat_median  = median(latency_ms),
    lat_p99     = quantile(latency_ms, 0.99),
    .groups = "drop"
  ) |>
  arrange(desc(lat_p99))

Sorted worst-first by tail latency, validator_panel is the per-validator performance panel exactly as the Ops lesson described it: a comparative table where relative position, not absolute latency, is the read.

Now cross to Python for the enforce phase. The baseline is computed once and persisted. Writing it to disk is what makes it the frozen-baseline artifact rather than a number that vanishes when the session ends.

Python — freeze the baseline

import json
import pandas as pd

def compute_interval_baseline(blocks: pd.DataFrame) -> dict:
    ordered = blocks.sort_values("height")
    interval = ordered["ts"].diff().dt.total_seconds().dropna()
    return {
        "p50": float(interval.quantile(0.50)),
        "p90": float(interval.quantile(0.90)),
        "p99": float(interval.quantile(0.99)),
        "n": int(interval.size),
    }

def freeze_baseline(blocks: pd.DataFrame, path: str) -> None:
    baseline = compute_interval_baseline(blocks)
    with open(path, "w") as f:
        json.dump(baseline, f)

The scheduled check loads the frozen artifact, computes the same quantiles over the rolling window, and returns the degradation verdict. The verdict keeps the two shapes the Ops lesson demanded: a sustained tail-shift is necessary, and the per-validator concentration decides whether the cause is a nameable operator or a diffuse network drift.

Python — enforce the signal

def evaluate_window(recent_blocks, recent_votes, baseline_path, tail_factor=1.25):
    with open(baseline_path) as f:
        base = json.load(f)
    rolling = compute_interval_baseline(recent_blocks)
    tail_shifted = rolling["p99"] > base["p99"] * tail_factor

    panel = (recent_votes.groupby("validator")["latency_ms"]
             .quantile(0.99).sort_values(ascending=False))
    top_share = panel.head(3).sum() / panel.sum()
    concentrated = top_share > 0.5

    if not tail_shifted:
        return {"signal": None, "rolling": rolling}
    shape = "concentrated" if concentrated else "diffuse"
    culprits = list(panel.head(3).index) if concentrated else []
    return {"signal": shape, "culprits": culprits, "rolling": rolling}

The function returns None when the tail is steady, a concentrated verdict with named validators when a small group carries the slow tail, and a diffuse verdict when no group dominates. That return value is the pre-halt degradation signal in data form, ready for the alerting stage to route by shape exactly as the Ops lesson prescribed.

Section IV§IV — Connection to Today's Ops Lesson

The Ops lesson is the specification; this lesson is the reference implementation. Normal is a distribution is the quantile summary rather than a mean. The tail is where degradation lives is why every reduction keeps p90 and p99 and never returns an average. The performance panel ranks signers against each other is the group_by(validator) that turns a flat vote log into a comparative table. And the signal must distinguish concentrated from diffuse is the top_share computation that reads whether three validators carry the slow tail or thirty share it. The Ops lesson could describe the signal in prose because a lesson like this one guarantees the prose has an executable twin.

Section V§V — Prior-Lesson Reach

This is the fifth R-and-Python lesson and the telemetry sub-arc's clearest instance. The 2026-06-18 operational-telemetry lesson established the explore-in-R-enforce-in-Python split on SLI time series and drift; today applies the identical split to consensus telemetry, a different substrate under the same discipline. The 2026-06-25 security-telemetry lesson introduced baseline profiling with control charts, and the frozen-baseline artifact here is that idea hardened: compute the healthy shape once, persist it, compare live readings against it. And the 2026-07-02 cross-sectional dispersion lesson built the group-by-and-rank panel over asset cohorts; the per-validator performance panel is that construct pointed at signers instead of securities. The substrate keeps changing. The two-language contract does not: R to see it, Python to watch it.

Section VI§VI — Closing

The reason this work splits across two languages is that seeing and watching are different jobs with different virtues. Seeing wants a language where a distribution is one plot and a grouped summary is one clause, where cheap exploration lets a human make the real-versus-noise call with their own eyes. Watching wants a language where the finding hardens into a scheduled function reading a frozen artifact and emitting a verdict no human has to be awake for. Write the panel as a group-by, freeze the baseline as an artifact, and keep the tail in every reduction, and the pipeline that results is the running form of the Ops lesson's entire claim.

Open your own telemetry in R first. If the summary you reach for is a mean, rewrite it as a quantile before you write a single line of the monitor. The monitor can only enforce what the exploration first taught it to see.