What does Koopman Modes for Audience Turning Points conclude, in numbers, about “Lead Time at the Turning Point: a Mode-Based Warning Every Five Minutes against Moving Averages”?

Answer: Chapter 5 compares three rules over two hundred random illustrative sessions: the mode warning has a median lead of 3.45 minutes, comes on average 13.13 minutes before the moving average and is premature in 0.055 of sessions, against 0.115 for the raw-curve rule.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (19 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.055, 0.115, 13.13, 3.45

rule lead median [25%, 75%] within 5 early>15
DMD every 5 min3.45 [ -1.53, 7.96] 0.485 0.055
MA 12 + 3 falls-9.73 [-11.64, -7.75] 0.090 0.000
raw 3 falls4.38 [ -2.06, 11.33] 0.380 0.115
sessions with a signal: DMD 200, MA 200, raw 200 of 200
DMD warned at or before t*0.675
DMD predicted turn, median |error| 4.71 min, 90th pct 13.73
paired lead gain DMD - MA: mean 13.13, sd 7.58, n 200
Show the full program
# Chapter 5. p51: lead time of a mode-based warning vs moving averages.
# 200 illustrative sessions (fixed seed): arrival and departure time
# constants, a 10-15 minute cycle and noise sd 20-60 drawn at random. The
# slow part turns at t* = ln(t1/t2) / (1/t2 - 1/t1). Rules: (a) DMD every
# 5 minutes on the last 40 minutes (rank 5), warn when the slow part's
# predicted turn is within 10 minutes; (b) a 12-minute trailing average
# that has fallen 3 minutes in a row; (c) the raw count falling 3 minutes
# in a row. Lead = t* minus the minute of the warning (positive = early).


import math
import cmath
import random
import statistics


def random_session(rng, sd=None, n=90):
    # 随机示意场次:进场、离场时间常数,福袋周期与噪声都在示意区间内抽取
    t1, t2 = rng.uniform(45.0, 90.0), rng.uniform(12.0, 25.0)
    amp, base = rng.uniform(3000.0, 6000.0), rng.uniform(500.0, 1200.0)
    per, cyc = rng.uniform(10.0, 15.0), rng.uniform(80.0, 200.0)
    ph = rng.uniform(0.0, 2.0 * math.pi)
    noise = rng.uniform(20.0, 60.0) if sd is None else sd
    x = [base + amp * (math.exp(-t / t1) - math.exp(-t / t2))
         + cyc * math.cos(2.0 * math.pi * t / per + ph)
         + rng.gauss(0.0, noise) for t in range(n)]
    tstar = math.log(t1 / t2) / (1.0 / t2 - 1.0 / t1)
    return x, tstar


def dot(a, b):
    return math.fsum(x * y for x, y in zip(a, b))


def matmul(a, b):
    bt = list(zip(*b))
    return [[dot(r, c) for c in bt] for r in a]


def transpose(a):
    return [list(r) for r in zip(*a)]


def svd(a):
    # 单边 Jacobi(Hestenes):两两旋转列直到正交,A = U S V^T
    m, n = len(a), len(a[0])
    if n > m:
        u, s, v = svd(transpose(a))
        return v, s, u
    cols = [[a[i][j] for i in range(m)] for j in range(n)]
    vc = [[1.0 if i == j else 0.0 for i in range(n)] for j in range(n)]
    for sweep in range(60):
        rotated = False
        for p in range(n - 1):
            for q in range(p + 1, n):
                al = dot(cols[p], cols[p])
                be = dot(cols[q], cols[q])
                ga = dot(cols[p], cols[q])
                if ga == 0.0 or abs(ga) <= 1e-15 * math.sqrt(al * be):
                    continue
                rotated = True
                ze = (be - al) / (2.0 * ga)
                t = math.copysign(1.0, ze) / (
                    abs(ze) + math.sqrt(1.0 + ze * ze))
                c = 1.0 / math.sqrt(1.0 + t * t)
                s = c * t
                cp, cq = cols[p], cols[q]
                cols[p] = [c * x - s * y for x, y in zip(cp, cq)]
                cols[q] = [s * x + c * y for x, y in zip(cp, cq)]
                vp, vq = vc[p], vc[q]
                vc[p] = [c * x - s * y for x, y in zip(vp, vq)]
                vc[q] = [s * x + c * y for x, y in zip(vp, vq)]
        if not rotated:
            break
    sig = [math.sqrt(dot(c_, c_)) for c_ in cols]
    order = sorted(range(n), key=lambda j: (-sig[j], j))
    s = [sig[j] for j in order]
    u = [[cols[j][i] / sig[j] if sig[j] > 0.0 else 0.0 for j in order]
         for i in range(m)]
    v = [[vc[j][i] for j in order] for i in range(n)]
    return u, s, v


def hankel(x, rows):
    # 延迟嵌入:第 i 行是从第 i 分钟起的一段序列
    k = len(x) - rows + 1
    return [[x[i + j] for j in range(k)] for i in range(rows)]


def dmd(x, rows, r):
    # Hankel 上的精确 DMD:X、Y 为错开一列的两块,A~ = U^T Y V S^-1
    h = hankel(x, rows)
    xs = [row[:-1] for row in h]
    ys = [row[1:] for row in h]
    u, s, v = svd(xs)
    ur = [row[:r] for row in u]
    vr = [row[:r] for row in v]
    at = matmul(matmul(transpose(ur), ys), vr)
    at = [[at[i][j] / s[j] for j in range(r)] for i in range(r)]
    return ur, at, s, h


def charpoly(a):
    # Faddeev-LeVerrier:特征多项式 z^n + c1 z^(n-1) + c2 z^(n-2) 直到 cn
    n = len(a)
    m = [[0.0] * n for _ in range(n)]
    coef = [1.0]
    for k in range(1, n + 1):
        m = matmul(a, m)
        for i in range(n):
            m[i][i] += coef[-1]
        am = matmul(a, m)
        coef.append(-math.fsum(am[i][i] for i in range(n)) / k)
    return coef


def roots(coef):
    # Durand-Kerner 同时迭代求全部复根(cmath)
    n = len(coef) - 1
    z = [cmath.rect(0.9, 0.4 + 2.0 * math.pi * k / n) for k in range(n)]

    def p(x):
        r = complex(1.0, 0.0)
        for c in coef[1:]:
            r = r * x + c
        return r
    for _ in range(800):
        new = []
        for i in range(n):
            den = complex(1.0, 0.0)
            for j in range(n):
                if j != i:
                    den *= z[i] - z[j]
            new.append(z[i] - p(z[i]) / den)
        moved = max(abs(a - b) for a, b in zip(new, z))
        z = new
        if moved < 1e-14:
            break
    return z


def eigvals(a):
    z = roots(charpoly(a))
    z = [complex(w.real, 0.0) if abs(w.imag) < 1e-12 else w for w in z]
    return sorted(z, key=lambda w: (-round(abs(w), 9), w.imag))


def csum(zs):
    zs = list(zs)
    return complex(math.fsum(z.real for z in zs),
                   math.fsum(z.imag for z in zs))


def csolve(a, b):
    # 复数高斯消元(部分主元)
    n = len(a)
    m = [list(a[i]) + [b[i]] for i in range(n)]
    for c in range(n):
        p = max(range(c, n), key=lambda i: abs(m[i][c]))
        m[c], m[p] = m[p], m[c]
        for i in range(c + 1, n):
            f = m[i][c] / m[c][c]
            for j in range(c, n + 1):
                m[i][j] -= f * m[c][j]
    xs = [0j] * n
    for i in range(n - 1, -1, -1):
        acc = csum(m[i][j] * xs[j] for j in range(i + 1, n))
        xs[i] = (m[i][n] - acc) / m[i][i]
    return xs


def amplitudes(x, lam):
    # 最小二乘求振幅:x_t = sum_k b_k lam_k^t(t 从窗口起点数)
    n = len(lam)
    vt = [[w ** t for w in lam] for t in range(len(x))]
    g = [[csum(vt[t][i].conjugate() * vt[t][j] for t in range(len(x)))
          for j in range(n)] for i in range(n)]
    rhs = [csum(vt[t][i].conjugate() * x[t] for t in range(len(x)))
           for i in range(n)]
    return csolve(g, rhs)


def slow_part(w, rows, r, min_period=30.0):
    # 拟合模态,只留周期长于 min_period 分钟、|lambda| > 0.6 的慢模态
    ur, at, s, h = dmd(w, rows, r)
    lam = eigvals(at)
    b = amplitudes(w, lam)
    keep = [k for k in range(len(lam)) if abs(lam[k]) > 0.6
            and abs(cmath.phase(lam[k])) < 2.0 * math.pi / min_period]
    return [(lam[k], b[k]) for k in keep]


def slow_value(modes, t):
    return csum(b * lam ** t for lam, b in modes).real


def predicted_peak(w, rows, r, ahead, grid=0.05):
    # 慢分量在 [0, len(w) + ahead] 上的最高点,返回相对窗口末端的分钟数
    modes = slow_part(w, rows, r)
    best, arg = None, 0.0
    steps = int(round((len(w) - 1 + ahead) / grid))
    for i in range(steps + 1):
        t = i * grid
        val = slow_value(modes, t)
        if best is None or val > best:
            best, arg = val, t
    return arg - (len(w) - 1), best, modes


def dmd_warning(x, window=40, rank=5, start=20, every=5, near=10.0,
                ahead=30):
    # 每 every 分钟拟合一次:慢分量的最高点落在未来 near 分钟以内即预警
    for tau in range(start, len(x) + 1, every):
        w = x[max(0, tau - window):tau]
        d, level, modes = predicted_peak(w, len(w) // 2, rank, ahead)
        if d <= near and d < ahead - 0.5:
            return tau, tau - 1 + d
    return None, None


def ma_turn(x, w=12, confirm=3):
    # 滑动平均连续 confirm 分钟下降才算拐头;返回能发出信号的分钟
    # (最后一个数据点的下一分钟,与 DMD 检查点同一口径)
    ma = {}
    for t in range(w - 1, len(x)):
        ma[t] = math.fsum(x[t - w + 1:t + 1]) / w
        if t >= w - 1 + confirm and all(
                ma[t - k] < ma[t - k - 1] for k in range(confirm)):
            return t + 1
    return None


def raw_turn(x, confirm=3, start=5):
    for t in range(start, len(x)):
        if all(x[t - k] < x[t - k - 1] for k in range(confirm)):
            return t + 1
    return None


def q(v, p):
    v = sorted(v)
    return v[min(len(v) - 1, int(p * len(v)))]


rng = random.Random(20261117)
dl, ml, rl, err, pair = [], [], [], [], []
for _ in range(200):
    x, ts = random_session(rng)
    tau, pred = dmd_warning(x)
    t_ma, t_raw = ma_turn(x), raw_turn(x)
    if tau is not None:
        dl.append(ts - tau)
        err.append(abs(pred - ts))
    if t_ma is not None:
        ml.append(ts - t_ma)
    if t_raw is not None:
        rl.append(ts - t_raw)
    if tau is not None and t_ma is not None:
        pair.append((ts - tau) - (ts - t_ma))
print("rule             lead median  [25%, 75%]     within 5  early>15")
for name, v in (("DMD every 5 min", dl), ("MA 12 + 3 falls", ml),
                ("raw 3 falls", rl)):
    early = len([d for d in v if d > 15.0]) / len(v)
    near = len([d for d in v if abs(d) <= 5.0]) / len(v)
    print("%-16s %8.2f    [%6.2f, %6.2f]   %8.3f  %8.3f"
          % (name, statistics.median(v), q(v, 0.25), q(v, 0.75), near,
             early))
print("sessions with a signal: DMD %d, MA %d, raw %d of 200"
      % (len(dl), len(ml), len(rl)))
print("DMD warned at or before t*: %.3f" % (len([d for d in dl if d >= 0])
                                         / len(dl)))
print("DMD predicted turn, median |error| %.2f min, 90th pct %.2f"
      % (statistics.median(err), q(err, 0.9)))
print("paired lead gain DMD - MA: mean %.2f, sd %.2f, n %d"
      % (statistics.mean(pair), statistics.stdev(pair), len(pair)))

Single source and citation

Fan, Y. (2026). Koopman Operators and Dynamic Mode Decomposition: Linearising Nonlinear Cash-Flow Swings and Forecasting Turning Points in Livestream Audience Curves (Version 1.0.0), Chapter 5: Lead Time at the Turning Point: a Mode-Based Warning Every Five Minutes against Moving Averages. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-238 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026238,
  author    = {Fan, Yafu},
  title     = {Koopman Operators and Dynamic Mode Decomposition: Linearising Nonlinear Cash-Flow Swings and Forecasting Turning Points in Livestream Audience Curves},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book