What does Brush Smoothness and Fractal Dimension conclude, in numbers, about “The Fractal Dimension Cannot See the Moving Brush: the Counterintuitive Claim and the Pollock Dispute”?

Answer: Chapter 2 shows that box-counting dimension cannot see the moving brush: one arc written with three timings has dimension 1.2251 each time while smoothness falls from -7.653 to -11.140; in two illustrative groups the effect size for dimension is only -0.36 (95 % interval -0.98 to +0.27) and for smoothness 3.74; a random walk reaches 1.704, close to the 1.72 reported for drip paintings.

Scope of the numbers: Trajectories, paper, ink and scoring parameters are illustrative; all calculations are generated by the book's programs; the book is general analysis, not business, design or medical advice. Marked boxes separate published evidence, runnable Python calculations (21 programs), 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 onlyprinted values that match the answer: -0.36, -0.98, -11.140, -7.653, 0.27, 1.2251

A. one 120 degree arc, three timings (identical ink)
one smooth sweep D1.2251 LDLJ = -7.653
two stops D1.2251 LDLJ = -9.705
three stops D1.2251 LDLJ = -11.140
B. 20 strokes per group mean sd
fluent D1.0956 0.0479
fluent LDLJ-8.3790 0.6695
learner D1.1110 0.0379
learner LDLJ-10.9317 0.6964
Cohen d D-0.36 95% CI -0.98 to +0.27
Cohen d LDLJ +3.7495% CI +2.71 to +4.76
Show the full program
# Chapter 2. p21: box-counting dimension is blind to how a stroke moved
# Model: a stroke is a sum of quintic submovements plus a small
# physiological tremor (x and y each get a sine of amplitude a at
# 9 Hz). Ink is a disc of radius 1.5 px stamped along the path on a
# pixel grid; D is the box-counting slope over boxes of 2 to 32 px.
# Smoothness is LDLJ = -ln(J T^5 / A^2), jerk analytic in part B.
# Part A: one path, three timings. Part B: two illustrative groups of
# 20 strokes, "fluent" (2 strongly overlapping pieces, tremor 0.15 %
# of length) and "learner" (3 or 4 weakly overlapping pieces, tremor
# 0.30 %); tremor amplitude varies by a lognormal factor per stroke.
# Group recipes are invented to show the logic; they are not fitted
# to any calligrapher. Seed fixed.
import math
import random

BOXES = (2, 4, 8, 16, 32)
DISC = [(dx, dy) for dx in (-1, 0, 1) for dy in (-1, 0, 1)]


def q(u):
    if u <= 0.0:
        return 0.0, 0.0, 0.0
    if u >= 1.0:
        return 1.0, 0.0, 0.0
    p = 10 * u ** 3 - 15 * u ** 4 + 6 * u ** 5
    v = 30 * u ** 2 - 60 * u ** 3 + 30 * u ** 4
    return p, v, 60 - 360 * u + 360 * u ** 2


def state(stroke, t):
    subs, amp, f, ph = stroke
    px, py, vx, vy, jx, jy = [], [], [], [], [], []
    for t0, d, dx, dy in subs:
        p, v, j = q((t - t0) / d)
        px.append(dx * p)
        py.append(dy * p)
        vx.append(dx * v / d)
        vy.append(dy * v / d)
        jx.append(dx * j / d ** 3)
        jy.append(dy * j / d ** 3)
    w = 2 * math.pi * f
    px.append(amp * math.sin(w * t + ph))
    py.append(amp * math.sin(w * t + 2 * ph))
    vx.append(amp * w * math.cos(w * t + ph))
    vy.append(amp * w * math.cos(w * t + 2 * ph))
    jx.append(-amp * w ** 3 * math.cos(w * t + ph))
    jy.append(-amp * w ** 3 * math.cos(w * t + 2 * ph))
    f_ = math.fsum
    return f_(px), f_(py), math.hypot(f_(vx), f_(vy)), \
        f_(jx) ** 2 + f_(jy) ** 2


def simpson(vals, h):
    terms = [vals[0], vals[-1]]
    for i in range(1, len(vals) - 1):
        terms.append((4.0 if i % 2 else 2.0) * vals[i])
    return math.fsum(terms) * h / 3.0


def ldlj(stroke, n=3000):
    dur = max(t0 + d for t0, d, _, _ in stroke[0])
    h = dur / n
    sts = [state(stroke, i * h) for i in range(n + 1)]
    length = simpson([s[2] for s in sts], h)
    jcost = simpson([s[3] for s in sts], h)
    return -math.log(jcost * dur ** 5 / length ** 2)


def box_dim(pixels):
    xs = [math.log(1.0 / s) for s in BOXES]
    ys = [math.log(len({(x // s, y // s) for x, y in pixels}))
          for s in BOXES]
    mx, my = math.fsum(xs) / len(xs), math.fsum(ys) / len(ys)
    sxy = math.fsum((a - mx) * (b - my) for a, b in zip(xs, ys))
    sxx = math.fsum((a - mx) ** 2 for a in xs)
    return sxy / sxx


def ink(points, x0=30.0, y0=128.0):
    pix = set()
    for x, y in points:
        cx, cy = int(round(x0 + x)), int(round(y0 + y))
        for dx, dy in DISC:
            pix.add((cx + dx, cy + dy))
    return pix


def trace(stroke, n=1500):
    dur = max(t0 + d for t0, d, _, _ in stroke[0])
    return [state(stroke, dur * i / n)[:2] for i in range(n + 1)]


def make(rng, pieces, overlap, trem):
    length, dur = 180.0, rng.uniform(0.4, 0.6)
    ang = [rng.uniform(-0.5, 0.5) for _ in range(pieces)]
    share = [rng.uniform(0.8, 1.2) for _ in range(pieces)]
    tot = math.fsum(share)
    lap = overlap * rng.uniform(0.8, 1.2)
    d = dur / (1 + (pieces - 1) * lap)
    subs = []
    for k, (a, s) in enumerate(zip(ang, share)):
        seg = length * s / tot
        subs.append((k * d * lap, d, seg * math.cos(a), seg * math.sin(a)))
    amp = trem * length * math.exp(rng.gauss(0.0, 0.5))
    return subs, amp, 9.0, rng.uniform(0, math.pi)


def arc_stroke(warp, n=1500):
    # one fixed path (a 120 degree arc of radius 80 px), timing warp(u);
    # the ink is laid by the path alone, so it is sampled by angle
    pts, sq = [], []
    h = 1e-3

    def p(u):
        a = 2 * math.pi / 3 * warp(min(max(u, 0.0), 1.0))
        return 80 * math.cos(a), 80 * math.sin(a)
    for i in range(n + 1):
        u = i / n
        g = 2 * math.pi / 3 * u
        pts.append((80 * math.cos(g), 80 * math.sin(g)))
        a, b, c, d = p(u + 2 * h), p(u + h), p(u - h), p(u - 2 * h)
        jx = (a[0] - 2 * b[0] + 2 * c[0] - d[0]) / (2 * h ** 3)
        jy = (a[1] - 2 * b[1] + 2 * c[1] - d[1]) / (2 * h ** 3)
        sq.append(jx * jx + jy * jy)
    jcost = simpson(sq, 1.0 / n)
    length = 80 * 2 * math.pi / 3
    return pts, -math.log(jcost / length ** 2)


def mj(u):
    return 10 * u ** 3 - 15 * u ** 4 + 6 * u ** 5


def halts(k):
    def w(u):
        i = min(int(u * k), k - 1)
        return (i + mj(u * k - i)) / k
    return w


def stats(xs):
    m = math.fsum(xs) / len(xs)
    v = math.fsum((x - m) ** 2 for x in xs) / (len(xs) - 1)
    return m, math.sqrt(v)


def cohen(a, b):
    (ma, sa), (mb, sb) = stats(a), stats(b)
    sp = math.sqrt((sa * sa + sb * sb) / 2)
    d = (ma - mb) / sp
    n1, n2 = len(a), len(b)
    se = math.sqrt((n1 + n2) / (n1 * n2) + d * d / (2 * (n1 + n2)))
    return d, d - 1.96 * se, d + 1.96 * se


if __name__ == "__main__":
    print("A. one 120 degree arc, three timings (identical ink)")
    for name, w in (("one smooth sweep", mj), ("two stops", halts(2)),
                    ("three stops", halts(3))):
        pts, ld = arc_stroke(w)
        print("   {:<17s} D = {:.4f}  LDLJ = {:.3f}".format(
            name, box_dim(ink(pts, 128.0, 40.0)), ld))
    rng = random.Random(20261113)
    grp = {"fluent": [], "learner": []}
    for _ in range(20):
        grp["fluent"].append(make(rng, 2, 0.35, 0.0015))
        grp["learner"].append(make(rng, rng.choice((3, 4)), 0.75, 0.0030))
    res = {}
    for g in ("fluent", "learner"):
        ds = [box_dim(ink(trace(s))) for s in grp[g]]
        ls = [ldlj(s) for s in grp[g]]
        res[g] = (ds, ls)
    print("B. 20 strokes per group     mean     sd")
    for g in ("fluent", "learner"):
        for k, lab in ((0, "D   "), (1, "LDLJ")):
            m, s = stats(res[g][k])
            print("   {:<8s} {}  {:>9.4f}  {:.4f}".format(g, lab, m, s))
    for k, lab in ((0, "D   "), (1, "LDLJ")):
        d, lo, hi = cohen(res["fluent"][k], res["learner"][k])
        print("   Cohen d {}  {:+.2f}  95% CI {:+.2f} to {:+.2f}".format(
            lab, d, lo, hi))

Single source and citation

Fan, Y. (2026). Minimum-Jerk Brush Trajectories, Capillary Ink Flow in Flying-White Strokes and the Fractal Dimension of Stroke Beauty (Version 1.0.0), Chapter 2: The Fractal Dimension Cannot See the Moving Brush: the Counterintuitive Claim and the Pollock Dispute. 5D Library. DOI pending

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

BibTeX
@book{fan2026229,
  author    = {Fan, Yafu},
  title     = {Minimum-Jerk Brush Trajectories, Capillary Ink Flow in Flying-White Strokes and the Fractal Dimension of Stroke Beauty},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book