What does Brush Smoothness and Fractal Dimension conclude, in numbers, about “The Structure of Pauses: Planned Stops, Hesitations and the Two-Thirds Power Law”?

Answer: Chapter 3 separates planned stops from hesitations: a stroke with a planned stop scores 100.0 once segmented, a four-piece hesitant stroke 25.0.

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: 100.0, 25.0

reference DJ0 of a quintic cut at 5 % of peak: 225.9
logwhole N_eqpausesshareseg N_eqscore
one sweep1.02100.0001.02198.0
press-pause-sweep3.40510.2440.991100.0
hesitant sweep3.99600.0003.99625.0
tremor sweep1.49000.0001.49067.1
Show the full program
# Chapter 3. p31: a deliberate pause is not a hesitation
# Model: a pen-tip log (t, x, y) sampled at 200 Hz is cut at pauses,
# runs where speed stays below 5 % of the peak for at least 40 ms.
# Each moving segment gets DJ = J T^5 / A^2 from finite differences,
# divided by DJ0, the value for an ideal quintic cut at the same 5 %
# threshold, so N_eq = (DJ / DJ0)^(1/4) and a perfect segment scores
# 100 / N_eq = 100. The whole-stroke N_eq treats the log as one piece.
# Strokes: one sweep, a press-pause-sweep (a dun, a planned stop),
# a hesitant sweep of 4 weakly overlapping pieces, and a sweep with a
# 9 Hz tremor of 0.4 px. All four are synthetic and illustrative.
import math

RATE = 200.0
THR, MIN_PAUSE = 0.05, 0.04


def q(u):
    if u <= 0.0:
        return 0.0
    if u >= 1.0:
        return 1.0
    return 10 * u ** 3 - 15 * u ** 4 + 6 * u ** 5


def sample(pieces, total, trem=0.0):
    n = int(total * RATE) + 1
    ts, xs, ys = [], [], []
    for i in range(n):
        t = i / RATE
        xs.append(math.fsum(dx * q((t - t0) / d)
                            for t0, d, dx, dy in pieces))
        yv = [dy * q((t - t0) / d) for t0, d, dx, dy in pieces]
        yv.append(trem * math.sin(2 * math.pi * 9.0 * t))
        ys.append(math.fsum(yv))
        ts.append(t)
    return ts, xs, ys


def dj0():
    k = 0
    while 30 * (k * 1e-5) ** 2 * (1 - k * 1e-5) ** 2 < THR * 1.875:
        k += 1
    lo = k * 1e-5
    n = 20000
    h = (1 - 2 * lo) / n
    js = [(60 - 360 * u + 360 * u ** 2) ** 2
          for u in (lo + (k + 0.5) * h for k in range(n))]
    a = q(1 - lo) - q(lo)
    return math.fsum(js) * h * (1 - 2 * lo) ** 5 / a ** 2


def segments(xs, ys, h):
    n = len(xs)
    sp = [0.0] * n
    for i in range(1, n - 1):
        sp[i] = math.hypot(xs[i + 1] - xs[i - 1],
                           ys[i + 1] - ys[i - 1]) / (2 * h)
    vmax = max(sp)
    mov = [s >= THR * vmax for s in sp]
    first = mov.index(True)
    last = n - 1 - mov[::-1].index(True)
    segs, pauses, a, i = [], [], first, first
    while i <= last:
        if not mov[i]:
            j = i
            while j <= last and not mov[j]:
                j += 1
            if (j - i) * h >= MIN_PAUSE:
                segs.append((a, i - 1))
                pauses.append((j - i) * h)
                a = j
            i = j
        else:
            i += 1
    segs.append((a, last))
    return segs, pauses, sp, (last - first + 1) * h


def seg_dj(xs, ys, sp, h, a, b):
    jj = []
    for i in range(max(a, 2), min(b, len(xs) - 3) + 1):
        jx = (xs[i + 2] - 2 * xs[i + 1] + 2 * xs[i - 1] - xs[i - 2])
        jy = (ys[i + 2] - 2 * ys[i + 1] + 2 * ys[i - 1] - ys[i - 2])
        jj.append((jx * jx + jy * jy) / (4 * h ** 6))
    dur = (b - a + 1) * h
    amp = math.fsum(sp[a:b + 1]) * h
    return math.fsum(jj) * h * dur ** 5 / amp ** 2, amp


def analyse(ts, xs, ys):
    h = 1.0 / RATE
    ref = dj0()
    segs, pauses, sp, active = segments(xs, ys, h)
    whole, _ = seg_dj(xs, ys, sp, h, segs[0][0], segs[-1][1])
    parts = [seg_dj(xs, ys, sp, h, a, b) for a, b in segs]
    tot = math.fsum(amp for _, amp in parts)
    neq = math.fsum((d / ref) ** 0.25 * amp / tot for d, amp in parts)
    return {"whole": (whole / ref) ** 0.25, "pauses": len(pauses),
            "share": math.fsum(pauses) / active, "neq": neq,
            "score": min(100.0, 100.0 / neq)}


if __name__ == "__main__":
    logs = {
        "one sweep": sample([(0.1, 0.5, 150.0, 0.0)], 0.7),
        "press-pause-sweep": sample([(0.1, 0.15, 30.0, 0.0),
                                     (0.37, 0.4, 120.0, 0.0)], 0.87),
        "hesitant sweep": sample([(0.1 + 0.14 * k, 0.18, 37.5, 0.0)
                                  for k in range(4)], 0.8),
        "tremor sweep": sample([(0.1, 0.5, 150.0, 0.0)], 0.7, 0.4),
    }
    print("reference DJ0 of a quintic cut at 5 % of peak: {:.1f}".format(
        dj0()))
    print("log                 whole N_eq  pauses  share  seg N_eq  score")
    for name, (ts, xs, ys) in logs.items():
        r = analyse(ts, xs, ys)
        print("{:<18s}  {:>9.3f}  {:>6d}  {:.3f}  {:>8.3f}  {:>5.1f}".format(
            name, r["whole"], r["pauses"], r["share"], r["neq"],
            r["score"]))

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 3: The Structure of Pauses: Planned Stops, Hesitations and the Two-Thirds Power Law. 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