What does Human Go Decisions after AI conclude, in numbers, about “The Contest over Mechanism: Internalisation, Memorisation and Composition”?

Answer: Chapter 5 separates internalisation, memorisation and composition, showing that player fixed effects push a spurious interaction from 0.831 down to -0.053 but cannot touch memorisation.

Scope of the numbers: Apart from the paper's figures, all parameters are illustrative and all calculations are generated by the book's programs; the book is non-personalised business guidance and addresses no individual decision. Chapter 2 demonstrates regression discontinuity in time on simulated data: with a true jump of 0.30 a 12-month bandwidth detects it only 0.685 of the time, while a world with nothing but a ramp is declared significant with probability 0.258 at 36 months.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: -0.053, 0.831

scenariotrue b3pooled b3FE b3FE b1
S10.5+0.415+0.435+0.619
S20.0+0.831-0.053+0.634
S30.0+0.816+0.768+0.578
S3 memorised share x bonus = 0.4 x 1.5 = 0.60
Show the full program
# Chapter 5. p51: what the after x novel interaction can and cannot
# tell apart
# Model (simulated panel, illustrative): 200 players, 150 moves each
# before and after the AI era; DQI = 97 + ability + b1 after + b2 novel
# + b3 after x novel + noise (sd 4); ability ~ N(0, 1). Scenario S1:
# b1 0.6, b2 -0.6, b3 0.5, novelty 0.10 before and 0.20 after for all.
# S2: b3 = 0, but after the AI era only strong players (ability > 0.5)
# play novel moves often (0.35 versus 0.05). S3: b3 = 0 for thinking,
# but 40 % of post-AI novel moves are memorised AI lines worth +1.5.
# Each scenario is fitted by pooled OLS and by player fixed effects
# (within transformation). Seeded; sums by math.fsum.
import math
import random

SEED = 20261112
PLAYERS = 200
MOVES = 150


def solve(a, b):
    n = len(b)
    m = [row[:] + [b[i]] for i, row in enumerate(a)]
    for c in range(n):
        p = max(range(c, n), key=lambda r: abs(m[r][c]))
        m[c], m[p] = m[p], m[c]
        piv = m[c][c]
        m[c] = [v / piv for v in m[c]]
        for r in range(n):
            if r != c:
                f = m[r][c]
                m[r] = [v - f * w for v, w in zip(m[r], m[c])]
    return [m[i][n] for i in range(n)]


def ols(xs, ys):
    k = len(xs[0])
    xtx = [[math.fsum(x[i] * x[j] for x in xs) for j in range(k)]
           for i in range(k)]
    xty = [math.fsum(x[i] * y for x, y in zip(xs, ys)) for i in range(k)]
    return solve(xtx, xty)


def panel(rng, scen):
    rows = []
    for i in range(PLAYERS):
        a = rng.gauss(0.0, 1.0)
        for after in (0, 1):
            if after and scen == "S2":
                q = 0.35 if a > 0.5 else 0.05
            else:
                q = 0.20 if after else 0.10
            for _ in range(MOVES):
                nv = 1 if rng.random() < q else 0
                b3 = 0.5 if scen == "S1" else 0.0
                parts = [97.0, a, 0.6 * after, -0.6 * nv,
                         b3 * after * nv, rng.gauss(0.0, 4.0)]
                if scen == "S3" and after and nv and rng.random() < 0.4:
                    parts.append(1.5)
                rows.append((i, after, nv, math.fsum(parts)))
    return rows


def fit(rows):
    pooled = ols([[1.0, a, n, a * n] for _, a, n, _ in rows],
                 [y for *_, y in rows])
    groups = {}
    for r in rows:
        groups.setdefault(r[0], []).append(r)
    xs, ys = [], []
    for i in sorted(groups):
        g = groups[i]
        cols = [[float(a), float(n), float(a * n), y] for _, a, n, y in g]
        mean = [math.fsum(c[j] for c in cols) / len(cols)
                for j in range(4)]
        for c in cols:
            xs.append([c[j] - mean[j] for j in range(3)])
            ys.append(c[3] - mean[3])
    fe = ols(xs, ys)
    return pooled[3], fe[2], fe[0]


if __name__ == "__main__":
    rng = random.Random(20261112)
    print("scenario  true b3  pooled b3   FE b3    FE b1")
    truth = {"S1": 0.5, "S2": 0.0, "S3": 0.0}
    for scen in ("S1", "S2", "S3"):
        p3, f3, f1 = fit(panel(rng, scen))
        print("  {}       {:.1f}     {:+.3f}     {:+.3f}   {:+.3f}".format(
            scen, truth[scen], p3, f3, f1))
    print("S3 memorised share x bonus = 0.4 x 1.5 = {:.2f}".format(0.6))

Single source and citation

Fan, Y. (2026). Post-AI Leaps in Human Go Decision Quality, Novel-Move Rates and Strategic Entropy in the Thirteen-Chapter Classic of Go (Version 1.0.0), Chapter 5: The Contest over Mechanism: Internalisation, Memorisation and Composition. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-230 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026230,
  author    = {Fan, Yafu},
  title     = {Post-AI Leaps in Human Go Decision Quality, Novel-Move Rates and Strategic Entropy in the Thirteen-Chapter Classic of Go},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book