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
rulesratioI(T;Y) shareaccuracyblock recallover-block
481.01.0000.6890.8450.215
242.00.9980.6890.8450.215
124.00.9910.6890.8610.228
86.00.9800.6890.8610.228
76.90.9750.6890.8610.228
68.00.9690.6890.8610.228
59.60.9580.6890.8610.228
412.00.9230.6890.8610.228
316.00.8510.6730.6870.105
224.00.5860.5620.6870.105
148.00.0000.4041.0001.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