Chapter 3 Ashby’s Law of Requisite Variety

Only variety can destroy variety

In An Introduction to Cybernetics (1956) the psychiatrist and cybernetician W. Ross Ashby stated what he called the law of requisite variety. A regulator must keep the outcomes of a system within acceptable bounds despite disturbances from outside. Ashby showed that the variety of outcomes cannot be reduced below the variety of the disturbances minus the variety of the regulator’s responses: “only variety can destroy variety” (Ashby 1956). In the language of information theory,

$H(E) \ge H(D) – H(R),$

where $D$ is the disturbance, $R$ the regulator’s response and $E$ the outcome. A regulator with fewer distinct responses than there are distinct disturbances cannot hold the outcome fixed.

Evidence

Conant and Ashby later proved a related theorem: every good regulator of a system must be a model of that system, in the sense that the simplest optimal regulator maps the system’s states onto its own (Conant and Ashby 1970).

Calculation

A disturbance with 64 equally likely values, and regulators with from 1 to 64 possible responses. The program finds the best regulator for each and compares the outcome entropy with Ashby’s bound.

import math
from collections import Counter

# Ashby's law of requisite variety, in its simplest form.
# Disturbances D take n_d equally likely values; the regulator R chooses one of n_r responses
# after seeing D; the outcome is E = (D − R) mod n_d. The goal is to keep E at 0.
def best_outcome_entropy(n_d, n_r):
    # the best regulator maps each disturbance to the response that cancels it as far as possible
    outcomes = Counter()
    for d in range(n_d):
        r = d % n_r                       # the response that brings E closest to 0
        outcomes[(d - r) % n_d] += 1
    return -sum(c / n_d * math.log2(c / n_d) for c in outcomes.values())

n_d = 64
print(f"disturbance variety: {n_d} states = {math.log2(n_d):.0f} bits")
for n_r in (1, 4, 8, 16, 32, 64):
    he = abs(best_outcome_entropy(n_d, n_r))
    bound = max(0.0, math.log2(n_d) - math.log2(n_r))
    print(f"regulator with {n_r:2d} responses ({math.log2(n_r):.0f} bits): "
          f"best H(E) = {he:.0f} bits, Ashby's bound H(D) − H(R) = {bound:.0f} bits")
# disturbance variety: 64 states = 6 bits
# regulator with  1 responses (0 bits): best H(E) = 6 bits, Ashby's bound H(D) − H(R) = 6 bits
# regulator with  4 responses (2 bits): best H(E) = 4 bits, Ashby's bound H(D) − H(R) = 4 bits
# regulator with  8 responses (3 bits): best H(E) = 3 bits, Ashby's bound H(D) − H(R) = 3 bits
# regulator with 16 responses (4 bits): best H(E) = 2 bits, Ashby's bound H(D) − H(R) = 2 bits
# regulator with 32 responses (5 bits): best H(E) = 1 bits, Ashby's bound H(D) − H(R) = 1 bits
# regulator with 64 responses (6 bits): best H(E) = 0 bits, Ashby's bound H(D) − H(R) = 0 bits

Every bit of variety the regulator lacks reappears as a bit of variety in the outcome.

The user as regulator

Applying the law to a person working with a language model needs care about what plays which role. The model is a generator of candidate answers, many correct and some wrong. The user’s task is to keep what they accept, publish or act on within bounds: to let the correct answers through and stop the wrong ones. For that task the “disturbances” are the many ways an answer can be wrong, and the user’s “responses” are the distinctions they can draw: which claims they can recognise as false, which calculations they can check, which sources they can find.

Calculation

A model of verification: a generator produces claims across twenty fields, 15 % of them wrong. The user catches wrong claims reliably only in fields they know; independent source checks catch some errors elsewhere.

import random

# A model of verification. A generator produces 10,000 claims across 20 fields;
# 15 % are wrong. The operator catches a wrong claim only in fields they can check,
# with probability 0.9 there; a source check (looking each claim up) adds a chance
# to catch errors in other fields.
random.seed(2)
claims = [(random.randrange(20), random.random() < 0.15) for _ in range(10000)]

def accepted_error_rate(known_fields, lookup=0.0):
    accepted, wrong = 0, 0
    for field, is_wrong in claims:
        caught = is_wrong and ((field < known_fields and random.random() < 0.9)
                               or random.random() < lookup)
        if not caught:
            accepted += 1
            wrong += is_wrong
    return wrong / accepted

for k in (1, 5, 10, 20):
    print(f"operator can check {k:2d} of 20 fields: errors among accepted claims "
          f"{accepted_error_rate(k):5.1%} | with independent source checks (50 %) "
          f"{accepted_error_rate(k, 0.5):5.1%}")
# operator can check  1 of 20 fields: errors among accepted claims 14.5% | with independent source checks (50 %)  7.7%
# operator can check  5 of 20 fields: errors among accepted claims 12.0% | with independent source checks (50 %)  6.2%
# operator can check 10 of 20 fields: errors among accepted claims  8.8% | with independent source checks (50 %)  4.6%
# operator can check 20 of 20 fields: errors among accepted claims  1.8% | with independent source checks (50 %)  0.8%

A user who can check one field in twenty accepts almost the full error rate of the generator; one who can check all twenty accepts very few errors. Independent source checks, such as looking claims up, running code and consulting experts, roughly halve the errors at every level. Tools are part of the regulator: what counts is the variety of the whole checking system, not of the person’s memory alone.

Note

Ashby’s law is a theorem about regulation, and the verification model is an analogy built on it, not a consequence of it. The model also simplifies: errors are not spread evenly across fields, and a user who knows a field can still miss a subtle error. The point that survives these simplifications is that unverified output inherits the generator’s error rate.

Hypothesis · not established

Not established. The quality of the knowledge a person can reliably extract from a language model is limited mainly by the range of fields in which they, together with their tools, can check claims, rather than by the model’s capability. The hypothesis predicts that, when the same model is used for the same multi-field research task, the error rate in the final accepted output falls with the number of relevant fields in which the user has demonstrated competence, and falls further when independent checks are required. It would be refuted if, in a study measuring both, error rates did not depend on the users’ checking range once the model and task were held fixed.

References

Ashby, W. Ross. 1956. An Introduction to Cybernetics. Chapman & Hall.

Conant, Roger C., and W. Ross Ashby. 1970. “Every Good Regulator of a System Must Be a Model of That System.” International Journal of Systems Science 1 (2): 89–97.

Fan, Y. (2026). The Algorithmic Mirror: Self-Attention Geometry, Ashby's Requisite Variety and Cognitive Projection in Information Theory and East Asian Philosophy of Mind [算法之镜] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.23723557 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).