What does The Limits of Guardrail Compression conclude, in numbers, about “From Monograph to Guardrails: Agglomerative Bottlenecks, Five Knee Criteria and Bilingual Redundancy”?
Answer: Chapter 5 uses the agglomerative bottleneck to press forty-eight candidate rules to a knee of five, keeping 0.958; exact bilingual redundancy is the only free lunch, and translation drift pulls the share to 0.948.
Scope of the numbers: Chapter 1 builds an illustrative source of eight kinds of draft and three verdicts and the counting bound: three rules keep 0.960 of the verdict information, two only 0.629. Chapter 4 shows that the critical exchange rate is the reciprocal of the squared maximal correlation, 0.6844 and 1.4610 on the illustrative source while information rises continuously as rules split.
Data table
The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 0.958
| candidates 48, I(X;Y) = 0.4756 bits | |||||
| rules | ratio | I(T;Y) share | accuracy | block recall | over-block |
| 48 | 1.0 | 1.000 | 0.689 | 0.845 | 0.215 |
| 24 | 2.0 | 0.998 | 0.689 | 0.845 | 0.215 |
| 12 | 4.0 | 0.991 | 0.689 | 0.861 | 0.228 |
| 8 | 6.0 | 0.980 | 0.689 | 0.861 | 0.228 |
| 7 | 6.9 | 0.975 | 0.689 | 0.861 | 0.228 |
| 6 | 8.0 | 0.969 | 0.689 | 0.861 | 0.228 |
| 5 | 9.6 | 0.958 | 0.689 | 0.861 | 0.228 |
| 4 | 12.0 | 0.923 | 0.689 | 0.861 | 0.228 |
| 3 | 16.0 | 0.851 | 0.673 | 0.687 | 0.105 |
| 2 | 24.0 | 0.586 | 0.562 | 0.687 | 0.105 |
| 1 | 48.0 | 0.000 | 0.404 | 1.000 | 1.000 |
Show the full program
# Chapter 5. p51: from one monograph's 48 candidate rules to a handful of
# guardrails. Each candidate is a kind of case with a weight p(x) and a
# decision profile p(y|x) over pass / revise / block. The 48 candidates
# are drawn (seeded) around 6 hidden families. Agglomerative information
# bottleneck (Slonim and Tishby 1999): repeatedly merge the two rules
# whose merger loses least I(T;Y), i.e. (p_i + p_j) times their weighted
# Jensen-Shannon divergence. Printed: the compression-recall curve.
# All parameters are illustrative.
import math
import random
FAMILIES = [[0.90, 0.08, 0.02], [0.60, 0.35, 0.05], [0.20, 0.70, 0.10],
[0.10, 0.40, 0.50], [0.05, 0.15, 0.80], [0.01, 0.04, 0.95]]
def make_volume(seed=20261113, per=8, mix=0.15):
rng = random.Random()
rng.seed(seed)
px, pyx = [], []
for fam in FAMILIES:
for _ in range(per):
g = [rng.expovariate(1.0) for _ in range(3)]
tot = math.fsum(g)
pyx.append([(1 - mix) * f + mix * v / tot
for f, v in zip(fam, g)])
px.append(rng.uniform(0.5, 1.5))
tot = math.fsum(px)
return [p / tot for p in px], pyx
def mutual_groups(groups):
py = [math.fsum(g[0] * g[1][y] for g in groups) for y in range(3)]
return math.fsum(g[0] * g[1][y] * math.log2(g[1][y] / py[y])
for g in groups for y in range(3) if g[1][y] > 0)
def js_cost(a, b):
w = a[0] + b[0]
mid = [(a[0] * u + b[0] * v) / w for u, v in zip(a[1], b[1])]
return math.fsum(c[0] * c[1][y] * math.log2(c[1][y] / mid[y])
for c in (a, b) for y in range(3) if c[1][y] > 0)
def agglomerate(px, pyx):
groups = [(p, list(r)) for p, r in zip(px, pyx)]
path = {len(groups): list(groups)}
while len(groups) > 1:
best = None
for i in range(len(groups)):
for j in range(i + 1, len(groups)):
c = js_cost(groups[i], groups[j])
if best is None or c < best[0]:
best = (c, i, j)
_, i, j = best
a, b = groups[i], groups[j]
w = a[0] + b[0]
merged = (w, [(a[0] * u + b[0] * v) / w for u, v in zip(a[1], b[1])])
groups = [g for k, g in enumerate(groups) if k not in (i, j)]
groups.append(merged)
path[len(groups)] = list(groups)
return path
def scores(groups):
pblock = math.fsum(g[0] * g[1][2] for g in groups)
acc = math.fsum(g[0] * max(g[1]) for g in groups)
blocked = [g for g in groups if g[1].index(max(g[1])) == 2]
rec = math.fsum(g[0] * g[1][2] for g in blocked) / pblock
over = math.fsum(g[0] * (1 - g[1][2]) for g in blocked) / (1 - pblock)
return acc, rec, over
px, pyx = make_volume()
path = agglomerate(px, pyx)
full = mutual_groups(path[48])
print("candidates 48, I(X;Y) = %.4f bits" % full)
print(" rules ratio I(T;Y) share accuracy block recall over-block")
for k in [48, 24, 12, 8, 7, 6, 5, 4, 3, 2, 1]:
share = mutual_groups(path[k]) / full
acc, rec, over = scores(path[k])
print(" %4d %5.1f %5.3f %5.3f %5.3f %5.3f"
% (k, 48 / k, share, acc, rec, over))Single source and citation
Fan, Y. (2026). The Information Bottleneck and Rate-Distortion Limits: How Far a Bilingual Monograph Can Be Compressed into Guardrails before Discriminative Power Falls Away (Version 1.0.0), Chapter 5: From Monograph to Guardrails: Agglomerative Bottlenecks, Five Knee Criteria and Bilingual Redundancy. 5D Library. DOI pending
DOI pending · monograph page goes live after publication · 5DL-B-250 · v1.0.0 · CC-BY-NC-ND-4.0
BibTeX
@book{fan2026250,
author = {Fan, Yafu},
title = {The Information Bottleneck and Rate-Distortion Limits: How Far a Bilingual Monograph Can Be Compressed into Guardrails before Discriminative Power Falls Away},
year = {2026},
publisher = {5D Library},
edition = {1.0.0},
note = {DOI pending}
}Other chapter answers in this book
- Chapter 1 · The Guardrail Source: Eight Kinds of Draft, Three Verdicts and the Counting Bound on Rules
- Chapter 2 · The Axis: Cliffs, Concave Curves and the Straight Line under Deterministic Labels
- Chapter 3 · Blahut and Arimoto: Computing the Rate-Distortion Function of a Guardrail in the Standard Library
- Chapter 4 · Phase Transitions: Maximal Correlation, the Critical Exchange Rate and Deterministic Annealing
- Chapter 6 · Opposing Evidence: Finite Samples, Learnt Compression and How Discriminative Power Is Scored
- Chapter 7 · Classical Sources East and West: "Writing Does Not Exhaust Speech, Speech Does Not Exhaust Intent" and Shannon's Suspension of Meaning
- Chapter 8 · Closing the Loop: One Compression-Recall Curve per Volume, a Knee Calculator and a Pre-Registered Protocol