The knowledge bottleneck — what you cannot write down

D = load_digits()
IMG, Y = D.images, D.target
record('n_digits', f'{len(Y):,}')
record('img_size', f'{IMG.shape[1]}x{IMG.shape[2]}')
record('n_pixels', IMG.shape[1] * IMG.shape[2])
record('n_classes', len(set(Y)))

from matplotlib.patches import Rectangle
from matplotlib.collections import PatchCollection

picks = [int(np.where(Y == d)[0][1]) for d in range(10)]

def plot(ax):
    # Rectangles, not imshow: imshow embeds a base64 raster and the page's
    # SVG guard refuses <image>. Alpha carries the ink so it reads on either theme.
    rects, alphas = [], []
    for k, idx in enumerate(picks):
        ox = k * 9
        for r in range(8):
            for c in range(8):
                v = IMG[idx][r, c] / 16.0
                if v > 0.02:
                    rects.append(Rectangle((ox + c, r), 1, 1)); alphas.append(v)
    pc = PatchCollection(rects, facecolor=(0.91, 0.41, 0.25), edgecolor='none')
    pc.set_alpha(None); pc.set_facecolors([(0.91, 0.41, 0.25, a) for a in alphas])
    ax.add_collection(pc)
    ax.set_xlim(0, 90); ax.set_ylim(8.6, -0.6); ax.set_aspect('equal')
    ax.set_xticks([]); ax.set_yticks([])
    for s in ax.spines.values(): s.set_visible(False)
save_fig('ten-digits', plot, figsize=(7, 1.5))

def holes(img):
    """Enclosed background regions — the thing that makes 0 and 8 obvious."""
    bg = img < 4; H, W = bg.shape
    seen = np.zeros_like(bg, bool); n = 0
    for sr in range(H):
        for sc in range(W):
            if not bg[sr, sc] or seen[sr, sc]: continue
            stack, cells, touches = [(sr, sc)], [], False
            seen[sr, sc] = True
            while stack:
                r, c = stack.pop(); cells.append((r, c))
                if r in (0, H-1) or c in (0, W-1): touches = True
                for dr, dc in ((1,0),(-1,0),(0,1),(0,-1)):
                    nr, nc = r+dr, c+dc
                    if 0 <= nr < H and 0 <= nc < W and bg[nr, nc] and not seen[nr, nc]:
                        seen[nr, nc] = True; stack.append((nr, nc))
            if not touches: n += 1
    return n

def features(img):
    ink = img.sum()
    return {
        'total ink':        ink,
        'ink in the top':   img[:3].sum(),
        'ink in the middle':img[3:5].sum(),
        'ink at the bottom':img[5:].sum(),
        'ink on the left':  img[:, :4].sum(),
        'ink on the right': img[:, 4:].sum(),
        'left-right symmetry': -abs(img[:, :4].sum() - img[:, 4:][:, ::-1].sum()),
        'how wide it is':   np.count_nonzero(img.sum(axis=0) > 2),
        'how tall it is':   np.count_nonzero(img.sum(axis=1) > 2),
        'holes in it':      holes(img),
    }

NAMES = list(features(IMG[0]))
X = np.array([[features(im)[n] for n in NAMES] for im in IMG], float)
record('n_features', len(NAMES))
record('feature_list', ', '.join(NAMES[:4]) + ', …')

def best_rule(target, k):
    """Best k-condition rule for one digit: pick the k features whose bands
    separate it best, and take the tightest band that keeps 80% of them."""
    is_t = Y == target
    scored = []
    for j in range(X.shape[1]):
        lo, hi = np.percentile(X[is_t, j], [10, 90])
        fires = (X[:, j] >= lo) & (X[:, j] <= hi)
        prec = (fires & is_t).sum() / max(fires.sum(), 1)
        scored.append((prec, j, lo, hi))
    scored.sort(reverse=True)
    return [(j, lo, hi) for _, j, lo, hi in scored[:k]]

def accuracy(k, tally=None):
    rules = {d: best_rule(d, k) for d in range(10)}
    right = 0
    for i in range(len(Y)):
        votes = [d for d, conds in rules.items()
                 if all(lo <= X[i, j] <= hi for j, lo, hi in conds)]
        if tally is not None:
            tally['none' if not votes else 'many' if len(votes) > 1 else 'one'] += 1
        if len(votes) == 1 and votes[0] == Y[i]: right += 1
    return right / len(Y)

# The two failures an expert system actually suffers, counted (OUTLINE L7):
# digits NO rule covers, and digits where rules CONTRADICT each other.
tally = {'none': 0, 'one': 0, 'many': 0}
accuracy(3, tally)
record('no_rule_fires', f"{tally['none']/len(Y):.0%}")
record('rules_contradict', f"{tally['many']/len(Y):.0%}")
record('exactly_one_rule', f"{tally['one']/len(Y):.0%}")

curve = [accuracy(k) for k in range(1, 6)]
for k, a in zip(range(1, 6), curve):
    record(f'acc_{k}cond', f'{a:.1%}')
record('best_rule_acc', f'{max(curve):.1%}')
record('guessing', f'{1/10:.0%}')

def plot(ax):
    ax.plot(range(1, 6), [100*c for c in curve], marker='o', lw=2.2)
    ax.axhline(10, ls=':', lw=1.2)
    ax.text(5, 12, 'guessing', ha='right', fontsize=9)
    ax.axhline(97, ls='--', lw=1.2)
    ax.text(1.05, 92, 'you, just now, in one second', fontsize=9)
    ax.set_xticks(range(1, 6))
    ax.set_xlabel('conditions per rule')
    ax.set_ylabel('digits identified correctly (%)')
    ax.set_ylim(0, 105)
save_fig('rules-vs-you', plot, figsize=(7, 3.8))

def overlap(a, b):
    best = None
    for j in range(X.shape[1]):
        ma, mb = X[Y == a, j], X[Y == b, j]
        lo = max(ma.min(), mb.min()); hi = min(ma.max(), mb.max())
        share = (((ma >= lo) & (ma <= hi)).mean() + ((mb >= lo) & (mb <= hi)).mean()) / 2
        if best is None or share < best[0]: best = (share, j)
    return best

share, j = overlap(1, 7)
record('best_feature_1v7', NAMES[j])
record('overlap_1v7', f'{share:.0%}')

def plot(ax):
    bins = np.linspace(X[:, j].min(), X[:, j].max(), 26)
    ax.hist(X[Y == 1, j], bins=bins, alpha=.75, label='the digit 1')
    ax.hist(X[Y == 7, j], bins=bins, alpha=.75, label='the digit 7')
    ax.set_xlabel(NAMES[j])
    ax.set_ylabel('how many digits')
    ax.legend(frameon=False)
save_fig('the-overlap', plot, figsize=(7, 3.4))