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 D | 1.2251 LDLJ = -7.653 |
| two stops D | 1.2251 LDLJ = -9.705 |
| three stops D | 1.2251 LDLJ = -11.140 |
| B. 20 strokes per group mean sd | |
| fluent D | 1.0956 0.0479 |
| fluent LDLJ | -8.3790 0.6695 |
| learner D | 1.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.74 | 95% 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
- Chapter 1 · Minimum Jerk: the Quintic Stroke and a Dimensionless Jerk
- Chapter 3 · The Structure of Pauses: Planned Stops, Hesitations and the Two-Thirds Power Law
- Chapter 4 · The Capillary Physics of Flying White: Washburn's Equation and the Drying Brush
- Chapter 5 · The Metrology of Box Counting: What a Dimension Actually Measures
- Chapter 6 · Testing Beauty: Judge Reliability, Statistical Power and Forking Paths
- Chapter 7 · Classics East and West: Sun Guoting's Treatise on Calligraphy and Hogarth's Analysis of Beauty
- Chapter 8 · Closing the Loop: Handwritten Brand Marks, Writing-Practice Speed Logs and a Falsification Plan