5D Library › Hundred-Volume Knowledge Hypergraphs, Multimodal Personal Prior Compilation and Autonomous Empire Scaling · 中文

Chapter 5. The Feedback Flywheel: Fisher Information, Privacy Noise and Self-Confirming Routing

How fast the loop learns

The flywheel the library’s websites describe is: diagnostic stations collect anonymized aggregates, the aggregates calibrate the parameters of the books, the books are revised and readers are routed to the right volume. How fast does such a loop learn? For independent yes/no outcomes the Fisher information about a rate grows in proportion to the number of outcomes, and the standard error falls with its square root (Fisher 1925). p09 compares a constant stream of users with one that grows 10% a month.

Calculation

# Chapter 5. p09: How fast does a feedback loop learn? Each user of a
# diagnostic station gives one yes/no outcome about a rate theta = 0.3
# (for example, whether the recommended volume helped). Fisher
# information per user is 1 / (theta (1 - theta)); after n users it is
# n times that, and the standard error is sqrt(theta (1 - theta) / n).
# Two growth paths for 34 stations: a constant 1,000 users a month in
# total, or 1,000 in the first month growing 10% a month.
from math import sqrt

TH = 0.3

if __name__ == "__main__":
    print("   month   constant: users  std error   growing: users  "
          "std error")
    n1 = n2 = 0
    for m in range(1, 37):
        n1 += 1000
        n2 += round(1000 * 1.1 ** (m - 1))
        if m in (1, 3, 6, 12, 24, 36):
            print("   {:5d}  {:16,d}  {:9.5f}  {:15,d}  {:9.5f}".format(
                m, n1, sqrt(TH * (1 - TH) / n1), n2,
                sqrt(TH * (1 - TH) / n2)))
    print("   information per user: {:.3f}, the same in every month".format(
        1 / (TH * (1 - TH))))
    print("   per station after 12 constant months: {:,} users, std error"
          " {:.4f}".format(12000 // 34, sqrt(TH * (1 - TH) / (12000 // 34))))
#    month   constant: users  std error   growing: users  std error
#        1             1,000    0.01449            1,000    0.01449
#        3             3,000    0.00837            3,310    0.00797
#        6             6,000    0.00592            7,716    0.00522
#       12            12,000    0.00418           21,386    0.00313
#       24            24,000    0.00296           88,496    0.00154
#       36            36,000    0.00242          299,125    0.00084
#    information per user: 4.762, the same in every month
#    per station after 12 constant months: 352 users, std error 0.0244

With a constant 1,000 users a month across 34 stations, the standard error is 0.00418 after a year and 0.00242 after three; with users growing 10% a month it is 0.00084 after three years. Information per user stays at 4.762 in every month. A flywheel does not accelerate learning by itself: information grows exponentially only if users do. And spread across 34 stations, a year of constant traffic gives each station only 352 users, a standard error of 0.0244.

Standard error of a rate by month, constant users and users growing 10% a month (p09).

What privacy costs

Releasing only noisy aggregates protects users; differential privacy adds Laplace noise of scale one over a parameter epsilon to each count (Dwork et al. 2006). p10 computes how much information survives.

Calculation

# Chapter 5. p10: What de-identification costs in information. Each
# station releases only weekly bucket counts of "yes" answers from m
# users, with Laplace noise of scale 1 / eps added (differential
# privacy with parameter eps for one user's answer). For a rate of 0.3,
# the variance of a released count is m 0.3 0.7 + 2 / eps^2, so the
# share of the original information kept is m 0.21 / (m 0.21 + 2 /
# eps^2). Buckets below 20 users are suppressed (a k-anonymity rule).
if __name__ == "__main__":
    print("   users per bucket   eps 0.1   eps 0.5   eps 1    eps 2")
    for m in (10, 30, 100, 1000):
        row = []
        for eps in (0.1, 0.5, 1.0, 2.0):
            keep = m * 0.21 / (m * 0.21 + 2 / eps ** 2)
            row.append("suppr." if m < 20 else "{:.3f}".format(keep))
        print("   {:16,d}   {:>7}   {:>7}   {:>6}   {:>6}".format(m, *row))
    print("   users per bucket for 0.9 of the information at eps 0.5: {}"
          .format(round(0.9 / 0.1 * 2 / 0.5 ** 2 / 0.21)))
#    users per bucket   eps 0.1   eps 0.5   eps 1    eps 2
#                  10    suppr.    suppr.   suppr.   suppr.
#                  30     0.031     0.441    0.759    0.926
#                 100     0.095     0.724    0.913    0.977
#               1,000     0.512     0.963    0.991    0.998
#    users per bucket for 0.9 of the information at eps 0.5: 343

With buckets of 30 users and epsilon 0.5, only 0.441 of the information remains; with 100 users 0.724; with 1,000 users 0.963. Buckets below 20 users are suppressed entirely. To keep 0.9 of the information at epsilon 0.5 a bucket needs 343 users. Privacy and learning trade against each other, and small stations pay most.

Routing that confirms itself

Routing readers to the volume the loop currently rates best also decides what the loop sees next. p11 routes 5,000 users between two volumes that help with chance 0.30 and 0.35.

Calculation

# Chapter 5. p11: A feedback loop that routes users by its own estimates.
# Two volumes help a user with chance 0.30 (A) and 0.35 (B). Each of
# 5,000 users is routed to one, and the outcome updates a Beta(1, 1)
# posterior for that volume. Greedy: the higher posterior mean. Explore
# 10%: greedy, but a random volume one time in ten. Thompson: a draw
# from each posterior, the higher draw wins. 400 runs each, seed 100.
import random

TRUE = (0.30, 0.35)

def run(rng, rule):
    s, f = [1, 1], [1, 1]
    to_b = 0
    for _ in range(5000):
        means = [s[i] / (s[i] + f[i]) for i in (0, 1)]
        if rule == "Thompson":
            d = [rng.betavariate(s[i], f[i]) for i in (0, 1)]
            k = 0 if d[0] > d[1] else 1
        elif rule == "explore 10%" and rng.random() < 0.1:
            k = rng.randrange(2)
        else:
            k = 0 if means[0] > means[1] else 1
        to_b += k
        if rng.random() < TRUE[k]:
            s[k] += 1
        else:
            f[k] += 1
    means = [s[i] / (s[i] + f[i]) for i in (0, 1)]
    return to_b / 5000, means[0] > means[1], means[1] - TRUE[1], s[1] + f[1]

if __name__ == "__main__":
    rng = random.Random(100)
    print("   rule          to better  ends favouring A  error on B"
          "  B trials")
    for rule in ("greedy", "explore 10%", "Thompson"):
        res = [run(rng, rule) for _ in range(400)]
        n = len(res)
        print("   {:<12}  {:9.3f}  {:15.3f}  {:+10.4f}  {:8,.0f}".format(
            rule, sum(r[0] for r in res) / n, sum(r[1] for r in res) / n,
            sum(r[2] for r in res) / n, sum(r[3] for r in res) / n))
#    rule          to better  ends favouring A  error on B  B trials
#    greedy            0.614            0.385     -0.0515     3,072
#    explore 10%       0.860            0.018     -0.0011     4,303
#    Thompson          0.910            0.000     +0.0002     4,554

Greedy routing sends only 0.614 of users to the better volume, ends favouring the worse one in 0.385 of runs, and underestimates the better one by 0.0515 on average, because once it stops sending users there it never corrects a bad early estimate. Exploring one time in ten cuts the wrong endings to 0.018; Thompson sampling to 0.000, while sending 0.910 of users to the better volume. A flywheel needs deliberate exploration, or its feedback will confirm its first mistakes.

Hypothesis · not established

The author’s interpretation (not yet tested): on the library’s sites, routing readers by Thompson sampling raises the share who report that the recommended volume helped, compared with routing by the current best estimate. What would show it wrong: in a randomized comparison over at least 5,000 routed readers, the share reporting help under Thompson sampling is not higher than under greedy routing.

Summary

A feedback loop learns in proportion to its users, not exponentially; privacy noise costs most where stations are small; and routing by current estimates confirms early mistakes unless some users are routed at random.

References

Dwork, Cynthia, Frank McSherry, Kobbi Nissim, and Adam Smith. 2006. “Calibrating Noise to Sensitivity in Private Data Analysis.” In Theory of Cryptography, vol. 3876. Lecture Notes in Computer Science. Springer.
Fisher, Ronald A. 1925. “Theory of Statistical Estimation.” Proceedings of the Cambridge Philosophical Society 22 (5): 700 to 725.

Fan, Y. (2026). Hundred-Volume Knowledge Hypergraphs, Multimodal Personal Prior Compilation and Autonomous Empire Scaling: Cross-Disciplinary Isomorphisms, Zero-Marginal-Cost Replication and Century-Scale Knowledge Preservation [百卷知识超图拓扑、多模态个人先验编译与自主知识帝国标度律] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090260 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).