What does Attention Networks and Intrinsic Motivation conclude, in numbers, about “The Working-Memory Bottleneck: Chunks, Schemas and Cognitive Load”?

Answer: Working-memory capacity is not "7 ± 2" but, once rehearsal and chunking are excluded, about 3 to 5 chunks; the difference between chunks and bits is exactly what Miller himself stressed. Experts' advantage comes mainly from schemas in long-term memory, which let them compress many items into a few chunks; when material and schemas do not match, the advantage disappears. Cognitive load theory distinguishes intrinsic from extraneous load; in its later revision, germane load is understood as resources allocated to intrinsic load rather than a third, additive load. The next chapter asks where the costs come from when attention switches back and forth between tasks.

Scope of the numbers: This book is not diagnosis or treatment advice for ADHD, anxiety, depression or any other condition, and deals with no medication or dose. Marked boxes separate published evidence, runnable Python calculations (16 programs, all checked), 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 only

string of 26 letters; working memory holds K4 chunks
novice (letters)26 chunks, overflows; letters recalled about 4 of 26
level-1 acronyms9 chunks, overflows; letters recalled about 12 of 26
level-2 schemas4 chunks, fits; letters recalled about 26 of 26
expert parse: US-AGENCIES | DEGREES | BROADCASTERS | COUNTRIES
raw information 122 bits; the expert stores 4 pointers into a library of 13 schemas, about 15 bits
shuffled string: expert parse has 24 chunks, letters recalled about 6
the advantage vanishes when the material does not match the schemas (cf. random boards)
Show the full program
# Chunking as compression: K = 4 slots, one chunk per slot whatever its size. Greedy parse with a
# schema library (longest chunk first); level-2 schemas bind level-1 chunks. If the parse fits in K
# slots all is recalled, else only K chunks survive. Letters and schemas are illustrative.
import math, random
K = 4
STRING = "FBICIANSAPHDMBABBCCNNUSAUK"
LEVEL1 = {"FBI", "CIA", "NSA", "PHD", "MBA", "BBC", "CNN", "USA", "UK"}
LEVEL2 = {("FBI", "CIA", "NSA"): "US-AGENCIES", ("PHD", "MBA"): "DEGREES",
          ("BBC", "CNN"): "BROADCASTERS", ("USA", "UK"): "COUNTRIES"}

def parse(s, lib):
    out, i = [], 0
    while i < len(s):
        for L in range(min(5, len(s) - i), 0, -1):
            if L == 1 or s[i:i + L] in lib:
                out.append(s[i:i + L]); i += L; break
    return out

def bind(chunks, lib2):
    out, i = [], 0
    while i < len(chunks):
        for key in sorted(lib2, key=len, reverse=True):
            if tuple(chunks[i:i + len(key)]) == key:
                out.append(lib2[key]); i += len(key); break
        else:
            out.append(chunks[i]); i += 1
    return out

def recalled_letters(chunks, level1_of):
    kept = sorted(chunks, key=lambda c: -len(level1_of(c)))[:K]
    return min(len(STRING), sum(len(level1_of(c)) for c in kept))

inv = {v: "".join(k) for k, v in LEVEL2.items()}
size = lambda c: inv.get(c, c)
novice = list(STRING)
inter = parse(STRING, LEVEL1)
expert = bind(inter, LEVEL2)
print(f"string of {len(STRING)} letters; working memory holds K = {K} chunks")
for name, ch in (("novice (letters)", novice), ("level-1 acronyms", inter),
                 ("level-2 schemas", expert)):
    fits = "fits" if len(ch) <= K else "overflows"
    print(f"  {name:17s}: {len(ch):2d} chunks, {fits}; letters recalled about "
          f"{recalled_letters(ch, size):2d} of {len(STRING)}")
print("  expert parse:", " | ".join(expert))
bits = len(STRING) * math.log2(26)
lib = len(LEVEL1) + len(LEVEL2)
print(f"raw information {bits:.0f} bits; the expert stores 4 pointers into a library of "
      f"{lib} schemas, about {4 * math.log2(lib):.0f} bits")
rng = random.Random(4)
rnd = "".join(rng.sample(STRING, len(STRING)))   # same letters, shuffled
r = bind(parse(rnd, LEVEL1), LEVEL2)
print(f"shuffled string: expert parse has {len(r)} chunks, letters recalled about "
      f"{recalled_letters(r, size)}")
print("  the advantage vanishes when the material does not match the schemas (cf. random boards)")

Single source and citation

Fan, Y. (2026). Attention Networks, the Working-Memory Bottleneck and Self-Determination Theory (Version 1.0.0), Chapter 2: The Working-Memory Bottleneck: Chunks, Schemas and Cognitive Load. 5D Library. https://doi.org/10.5281/zenodo.23761341

DOI: 10.5281/zenodo.23761341 · Read the monograph · 5DL-B-024 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026024,
  author    = {Fan, Yafu},
  title     = {Attention Networks, the Working-Memory Bottleneck and Self-Determination Theory},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  doi       = {10.5281/zenodo.23761341},
  url       = {https://doi.org/10.5281/zenodo.23761341}
}

Other chapter answers in this book