What does Layered Interfaces and Core Fidelity conclude, in numbers, about “Expertise Reversal, Routing Readers and the Limits of Readability”?

Answer: Chapter 5 shows a nine-item routing probe placing 0.679 of readers correctly, and a readability formula giving a passage, its reversal and a shuffled version the same score of 90.1.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (23 programs), classical sources and the author's hypotheses.

中文版

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.679

methodrighttoo hardtoo easyunits per 10,000
self-report0.5830.2490.1683,646
probe M=30.4730.3590.1693,335
probe M=50.6250.1600.2163,766
probe M=90.6790.1320.1893,850
oracle1.0000.0000.0004,183
Show the full program
# Chapter 5. p52: route readers to a layer by self-report or by a probe
# 6,000 simulated readers, ln b ~ N(0, 0.6). Layers as p31 (D = -0.9,
# -0.3, 0.3, 0.8). A reader's right layer is the highest one read with
# probability >= 0.7. Self-report sees ln b plus Normal(0, 0.5) noise.
# A probe of M items (difficulties spread over -1.2 to 1.2, item curve
# logistic((ln b - delta) / 0.4)) estimates ln b by maximum likelihood
# on a grid. All parameters are illustrative.
import math
import random

rng = random.Random(41252)
N, SIG, S = 6000, 0.6, 0.25
LAYERS = [(-0.9, 0.35, 0.97), (-0.3, 0.55, 0.97), (0.3, 0.80, 0.97),
          (0.8, 1.00, 1.00)]
CUT = S * math.log(0.7 / 0.3)
EST = [-2.5 + 0.04 * k for k in range(126)]


def logistic(z):
    return 1.0 / (1.0 + math.exp(-z))


def pick(lb):
    j = 0
    for i, (d, _, _) in enumerate(LAYERS):
        if lb >= d + CUT:
            j = i
    return j


def probe(lb, m):
    deltas = [-1.2 + 2.4 * i / (m - 1) for i in range(m)]
    ans = [rng.random() < logistic((lb - dl) / 0.4) for dl in deltas]

    def ll(x):
        return math.fsum(math.log(logistic((x - dl) / 0.4)) if a else
                         math.log(1 - logistic((x - dl) / 0.4))
                         for dl, a in zip(deltas, ans))
    return max(EST, key=ll)


readers = [rng.gauss(0.0, SIG) for _ in range(N)]
print("method        right  too hard  too easy  units per 10,000")
for name, m in (("self-report", 0), ("probe M=3", 3), ("probe M=5", 5),
                ("probe M=9", 9), ("oracle", -1)):
    right = hard = easy = 0
    units = []
    for lb in readers:
        if m == 0:
            est = lb + rng.gauss(0.0, 0.5)
        elif m < 0:
            est = lb
        else:
            est = probe(lb, m)
        j, k = pick(est), pick(lb)
        right += j == k
        hard += j > k
        easy += j < k
        d, v, a = LAYERS[j]
        units.append(logistic((lb - d) / S) * v * a)
    print("{:<12} {:6.3f} {:9.3f} {:9.3f} {:13,}".format(
        name, right / N, hard / N, easy / N,
        round(10000 * math.fsum(units) / N)))

Single source and citation

Fan, Y. (2026). Impedance Matching for High-Dimensional Systems: Lossless Downward Compatibility without Core Frequency Degradation (Version 1.0.0), Chapter 5: Expertise Reversal, Routing Readers and the Limits of Readability. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-412 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026412,
  author    = {Fan, Yafu},
  title     = {Impedance Matching for High-Dimensional Systems: Lossless Downward Compatibility without Core Frequency Degradation},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book