What does Brush Smoothness and Fractal Dimension conclude, in numbers, about “Closing the Loop: Handwritten Brand Marks, Writing-Practice Speed Logs and a Falsification Plan”?

Answer: Chapter 8 gives a specification for handwritten brand marks, a closed loop for speed logs in writing practice, a pre-registered protocol and the distilled Stroke Smoothness Scorer. Marked boxes separate published evidence, runnable Python calculations (21 programs), classical sources and the author's hypotheses.

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: 21

rate Hzwnoise 00.02 mm0.05 mm0.1 mm
1001100.081.659.942.7
1005100.099.999.598.3
1009100.0100.099.999.9
10021100.0100.0100.099.9
2001100.033.221.312.2
2005100.096.482.566.9
2009100.099.697.592.2
20021100.0100.099.999.5
5001100.08.12.91.9
5005100.039.124.617.5
5009100.066.343.631.9
50021100.097.085.569.1
cost of smoothing: a real 9 Hz tremor of 0.4 mm at 200 Hz
w =1 (5 ms)score 65.4
w =5 ( 25 ms)score 69.5
w =9 ( 45 ms)score 81.9
w = 21 (105 ms)score 100.0
Show the full program
# Chapter 8. p83: sensor noise, sampling rate and the smoothing window
# Model: a finite-difference jerk multiplies position noise of size
# sigma by about sigma / h^3, so a cheap tablet can make a fluent
# stroke look shaky. One quintic sweep (150 mm in 0.5 s) is logged at
# 100, 200 and 500 Hz with Gaussian noise of 0 to 0.1 mm, smoothed by
# two passes of a moving average of w samples (w = 1 means none), and
# scored as in p81 against a reference put through the same pipeline.
# Each cell is the mean score of 20 noisy logs. Last block: how much
# smoothing hides a real tremor laid along the stroke. Noise levels
# and rates are illustrative; seed fixed.
import math
import random


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 smooth(v, w):
    out = v
    for _ in range(2):
        half, src = w // 2, out
        out = []
        for i in range(len(src)):
            lo, hi = max(0, i - half), min(len(src), i + half + 1)
            out.append(math.fsum(src[lo:hi]) / (hi - lo))
    return out


def dj(xs, h, w):
    xs = smooth(xs, w)
    n = len(xs)
    sp = [0.0] * n
    for i in range(1, n - 1):
        sp[i] = abs(xs[i + 1] - xs[i - 1]) / (2 * h)
    vmax = max(sp)
    mov = [k for k in range(2, n - 2) if sp[k] >= 0.05 * vmax]
    a, b = mov[0], mov[-1]
    jj = [((xs[k + 2] - 2 * xs[k + 1] + 2 * xs[k - 1] - xs[k - 2])
           / (2 * h ** 3)) ** 2 for k in range(a, b + 1)]
    dur, amp = (b - a + 1) * h, math.fsum(sp[a:b + 1]) * h
    return math.fsum(jj) * h * dur ** 5 / amp ** 2


def log(rate, noise, rng):
    n = int(0.7 * rate) + 1
    return [150.0 * q((i / rate - 0.1) / 0.5) +
            (rng.gauss(0, noise) if noise else 0.0) for i in range(n)]


if __name__ == "__main__":
    rng = random.Random(20261113)
    print("rate Hz  w   noise 0   0.02 mm   0.05 mm   0.1 mm")
    for rate in (100, 200, 500):
        for w in (1, 5, 9, 21):
            ref = dj(log(rate, 0.0, rng), 1.0 / rate, w)
            row = []
            for noise in (0.0, 0.02, 0.05, 0.1):
                reps = 1 if noise == 0.0 else 20
                sc = [min(100.0, 100.0 * (ref / dj(log(rate, noise, rng),
                                                   1.0 / rate, w)) ** 0.25)
                      for _ in range(reps)]
                row.append(math.fsum(sc) / reps)
            print("{:>6d}  {:>2d}  ".format(rate, w) + "".join(
                "{:>9.1f}".format(s) for s in row))
    print("cost of smoothing: a real 9 Hz tremor of 0.4 mm at 200 Hz")
    for w in (1, 5, 9, 21):
        h = 1.0 / 200
        ref = dj(log(200, 0.0, rng), h, w)
        xs = log(200, 0.0, rng)
        ts = [0.4 * math.sin(2 * math.pi * 9.0 * i * h)
              for i in range(len(xs))]
        xs = [a + b for a, b in zip(xs, ts)]
        print("   w = {:>2d} ({:>3.0f} ms)  score {:.1f}".format(
            w, w * h * 1000, min(100.0, 100.0 * (ref / dj(xs, h, w))
                                 ** 0.25)))

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 8: Closing the Loop: Handwritten Brand Marks, Writing-Practice Speed Logs and a Falsification Plan. 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