# 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)")
# string of 26 letters; working memory holds K = 4 chunks
#   novice (letters) : 26 chunks, overflows; letters recalled about  4 of 26
#   level-1 acronyms :  9 chunks, overflows; letters recalled about 12 of 26
#   level-2 schemas  :  4 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)

# Toy load budget after Sweller (2010): load = interacting elements held at once, capacity ~4.
# Intrinsic = elements not yet chunked; extraneous = elements added by the format; germane = the
# share of resources actually devoted to the intrinsic elements (not a third additive load).
CAP = 4.0

def budget(elements, chunked, extraneous):
    intrinsic = max(0, elements - chunked)
    total = intrinsic + extraneous
    over = max(0.0, total - CAP)
    # resources go first to the extraneous demands imposed by the format, the rest to the content
    germane = max(0.0, min(intrinsic, CAP - extraneous))
    return intrinsic, total, over, germane

CASES = [
    ("novice, split-attention format", 7, 0, 3),
    ("novice, integrated format", 7, 0, 0),
    ("novice, integrated, worked in 2 steps", 4, 0, 0),
    ("expert, split-attention format", 7, 6, 3),
]
print("case                                    | intrinsic | +extraneous | over capacity | germane")
for name, e, ch, ex in CASES:
    i, t, o, g = budget(e, ch, ex)
    print(f"{name:39s} | {i:9d} | {t:11.0f} | {o:13.0f} | {g:4.0f} of {i}")
print("reading: removing the split-attention demand frees 3 slots for the content itself; breaking")
print("the material into steps lowers intrinsic load for a novice; for the expert, schemas have")
print("already chunked most elements, so the same format costs little")
# case                                    | intrinsic | +extraneous | over capacity | germane
# novice, split-attention format          |         7 |          10 |             6 |    1 of 7
# novice, integrated format               |         7 |           7 |             3 |    4 of 7
# novice, integrated, worked in 2 steps   |         4 |           4 |             0 |    4 of 4
# expert, split-attention format          |         1 |           4 |             0 |    1 of 1
# reading: removing the split-attention demand frees 3 slots for the content itself; breaking
# the material into steps lowers intrinsic load for a novice; for the expert, schemas have
# already chunked most elements, so the same format costs little