关于「分形维数看不见运笔:反常识命题与波洛克之争」,《书法运笔平滑度与分形维数》给出的定量结论是什么?
结论:第二章证明盒计数维数看不见运笔:同一条弧线以三种时序写出,维数都是 1.2251,平滑度却从 -7.653 落到 -11.140;示意的两组笔迹中,维数的效应量只有 -0.36(95 % 区间 -0.98 到 +0.27),平滑度的效应量是 3.74;随机游走的维数 1.704 已接近滴画研究报告的 1.72。
数据口径:书中轨迹、纸墨与评分参数均为示意;全部计算由书中程序生成;本书是非个人化的分析,不构成经营、设计或医疗建议。 第二章证明盒计数维数看不见运笔:同一条弧线以三种时序写出,维数都是 1.2251,平滑度却从 -7.653 落到 -11.140;示意的两组笔迹中,维数的效应量只有 -0.36(95 % 区间 -0.98 到 +0.27),平滑度的效应量是 3.74;随机游走的维数 1.704 已接近滴画研究报告的 1.72。
对照数据表
下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库与结论吻合的打印值: -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 |
查看完整验算程序
# 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))唯一数据源与引用
范雅福(Fan, Y.). (2026). 《书法运笔最小加加速度轨迹、飞白墨量毛细流与笔势美感分形维数母典》第 2 章「分形维数看不见运笔:反常识命题与波洛克之争」(版本 1.0.0). 5D Library. DOI 待发布
DOI 待发布 · 专著页正式发布后上线(本站暂无专著页) · 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}
}