关于「分形维数看不见运笔:反常识命题与波洛克之争」,《书法运笔平滑度与分形维数》给出的定量结论是什么?

结论:第二章证明盒计数维数看不见运笔:同一条弧线以三种时序写出,维数都是 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。

English version

对照数据表

下表数字由本章 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 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
查看完整验算程序
# 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}
}

本书其他章节结论