5D Library › Five-Node Cyclic Network Dynamics, Solar-Longitude Ephemeris and Multi-Scale Oscillator Perturbations · 中文

Chapter 5. A Finite Record: Identifiability, the Golden-Ratio Direction and Forecasting the Dates of Extremes

Where the parameters come from

Chapter 4 said that with known parameters future energy extremes are computed. But parameters are never known: they must be estimated from a finite, noisy record. This chapter asks two questions. Which parameter combinations can a record fix, and which can it not? And with uncertain parameters, how reliable are the dates of extremes in future and past windows?

Fisher information and the “sloppy” direction

Calculation

The Fisher information matrix. Only node 0 is observed, monthly, with noise of standard deviation σ=0.05\sigma = 0.05. Let SS be the record’s sensitivity to the parameters θ=(c1,c2,μ)\theta = (c_1, c_2, \mu) (by central differences); the Fisher information is F=S⊤S/σ2F = S^{\top}S/\sigma^2, and its inverse bounds the covariance of the estimates. The directions belonging to FF’s small eigenvalues are parameter combinations the record can hardly tell apart (Raue et al. 2009; Gutenkunst et al. 2007).

Calculation

The direction the symmetry predicts. A circulant ring’s record depends on the parameters only through the eigenvalues λ1\lambda_1 and λ2\lambda_2. Parameter changes that hold λ1\lambda_1 fixed (one condition each on its real and imaginary parts) satisfy dc2=φdc1\mathrm{d}c_2 = \varphi\,\mathrm{d}c_1 and dμ=φdc1\mathrm{d}\mu = \varphi\,\mathrm{d}c_1, with φ=(1+5)/2\varphi = (1 + \sqrt5)/2. Along that direction only the fast-decaying mode 2 still changes, so it should be the direction the record finds hardest to resolve.

Calculation

# Chapter 5. p10: What a finite record can tell about (c1, c2, mu).
# The damped, forced ring of p08 (true c1 = 1, c2 = 0.5, mu = mu_c + 0.1,
# rates x10 per year, forcing = 20-yr square wave + 1-yr sine into node 0,
# out of node 2). Only node 0 is observed, monthly, with noise sd 0.05,
# for T years. The Fisher information F = S^T S / sd^2 uses sensitivities
# S from central differences of the simulated record. Its eigenvalues
# (Jacobi rotations) show which parameter combinations the record pins
# down. Prediction: in a circulant ring the record depends on the
# parameters only through lambda_1 and lambda_2; holding lambda_1 fixed
# leaves the direction (1, phi, phi), phi = 1.618, constrained only by
# the fast-decaying mode 2.
import cmath
import math

W = cmath.exp(2j * math.pi / 5)
SCALE, SD = 10.0, 0.05
TRUE = (1.0, 0.5, math.cos(math.radians(72))
        + 0.5 * math.cos(math.radians(36)) + 0.1)
B = [1.0, 0.0, -1.0, 0.0, 0.0]

def record(th, years, h=0.01):
    c1, c2, mu = th
    def f(y, t):
        u = ((1.0 if int(t // 10) % 2 == 0 else -1.0)
             + math.sin(2 * math.pi * t))
        return [SCALE / 5 * (c1 * y[(i - 1) % 5] - c2 * y[(i - 2) % 5]
                             - mu * y[i]) + B[i] * u for i in range(5)]
    y, out, n = [0.0] * 5, [], 0
    per = int(round(1 / 12 / h))
    while n * h < years - 1e-9:
        t = n * h
        k1 = f(y, t)
        k2 = f([a + h / 2 * b for a, b in zip(y, k1)], t + h / 2)
        k3 = f([a + h / 2 * b for a, b in zip(y, k2)], t + h / 2)
        k4 = f([a + h * b for a, b in zip(y, k3)], t + h)
        y = [a + h / 6 * (b + 2 * c + 2 * d + e)
             for a, b, c, d, e in zip(y, k1, k2, k3, k4)]
        n += 1
        if n % per == 0:
            out.append(y[0])
    return out

def fisher(years, d=1e-4):
    cols = []
    for k in range(3):
        up = list(TRUE)
        dn = list(TRUE)
        up[k] += d
        dn[k] -= d
        a, b = record(up, years), record(dn, years)
        cols.append([(x - y) / (2 * d) for x, y in zip(a, b)])
    return [[sum(p * q for p, q in zip(cols[i], cols[j])) / SD ** 2
             for j in range(3)] for i in range(3)]

def jacobi(m):
    a = [row[:] for row in m]
    v = [[float(i == j) for j in range(3)] for i in range(3)]
    for _ in range(100):
        p, q = max(((i, j) for i in range(3) for j in range(i + 1, 3)),
                   key=lambda ij: abs(a[ij[0]][ij[1]]))
        if abs(a[p][q]) < 1e-14 * (abs(a[p][p]) + abs(a[q][q])):
            break
        th = 0.5 * math.atan2(2 * a[p][q], a[q][q] - a[p][p])
        c, s = math.cos(th), math.sin(th)
        for k in range(3):
            akp, akq = a[k][p], a[k][q]
            a[k][p], a[k][q] = c * akp - s * akq, s * akp + c * akq
        for k in range(3):
            apk, aqk = a[p][k], a[q][k]
            a[p][k], a[q][k] = c * apk - s * aqk, s * apk + c * aqk
        for k in range(3):
            vkp, vkq = v[k][p], v[k][q]
            v[k][p], v[k][q] = c * vkp - s * vkq, s * vkp + c * vkq
    return [a[i][i] for i in range(3)], [[v[r][c] for r in range(3)]
                                         for c in range(3)]

def inv3(m):
    det = (m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
           - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
           + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]))
    cof = [[(m[(i + 1) % 3][(j + 1) % 3] * m[(i + 2) % 3][(j + 2) % 3]
             - m[(i + 1) % 3][(j + 2) % 3] * m[(i + 2) % 3][(j + 1) % 3])
            for i in range(3)] for j in range(3)]
    return [[cof[i][j] / det for j in range(3)] for i in range(3)]

if __name__ == "__main__":
    phi = (1 + math.sqrt(5)) / 2
    nrm = math.sqrt(1 + 2 * phi * phi)
    g = [1 / nrm, phi / nrm, phi / nrm]
    print("predicted sloppy direction (1, phi, phi)/norm = {}".format(
        [round(x, 4) for x in g]))
    for years in (20, 60):
        f = fisher(years)
        ev, vec = jacobi(f)
        order = sorted(range(3), key=lambda i: ev[i])
        cov = inv3(f)
        se = [math.sqrt(cov[i][i]) for i in range(3)]
        lo = vec[order[0]]
        lo = [x if lo[0] >= 0 else -x for x in lo]
        cosang = abs(sum(a * b for a, b in zip(lo, g)))
        print("\nrecord of {} years ({} monthly points)".format(
            years, 12 * years))
        print("   Fisher eigenvalues: {}".format(
            ", ".join("{:.3e}".format(ev[i]) for i in order)))
        print("   condition number {:.1f}".format(
            ev[order[2]] / ev[order[0]]))
        print("   sloppiest direction {}".format([round(x, 4) for x in lo]))
        print("   |cos| with the predicted direction {:.6f}".format(cosang))
        print("   standard errors c1 {:.4f}  c2 {:.4f}  mu {:.4f}"
              .format(*se))
        r = cov[0][1] / (se[0] * se[1])
        print("   correlation of c1 and c2 estimates {:+.4f}".format(r))
    print("\nReading: the record pins down two combinations well and the")
    print("third poorly, and the poorly fixed one is the golden-ratio")
    print("direction the ring's symmetry predicts. Each parameter alone")
    print("has a wide error bar while their combination is sharp - a")
    print("'sloppy' model in the sense of Gutenkunst et al.; a longer")
    print("record narrows every bar but not the imbalance.")
# predicted sloppy direction (1, phi, phi)/norm = [0.4004, 0.6479, 0.6479]
#
# record of 20 years (240 monthly points)
#    Fisher eigenvalues: 6.110e+01, 4.518e+05, 6.942e+05
#    condition number 11361.2
#    sloppiest direction [0.3982, 0.6476, 0.6496]
#    |cos| with the predicted direction 0.999996
#    standard errors c1 0.0510  c2 0.0829  mu 0.0831
#    correlation of c1 and c2 estimates +0.9994
#
# record of 60 years (720 monthly points)
#    Fisher eigenvalues: 1.898e+02, 1.355e+06, 2.064e+06
#    condition number 10874.8
#    sloppiest direction [0.3976, 0.6476, 0.65]
#    |cos| with the predicted direction 0.999994
#    standard errors c1 0.0289  c2 0.0470  mu 0.0472
#    correlation of c1 and c2 estimates +0.9994
#
# Reading: the record pins down two combinations well and the
# third poorly, and the poorly fixed one is the golden-ratio
# direction the ring's symmetry predicts. Each parameter alone
# has a wide error bar while their combination is sharp - a
# 'sloppy' model in the sense of Gutenkunst et al.; a longer
# record narrows every bar but not the imbalance.

The predicted direction is (0.4004, 0.6479, 0.6479). For a twenty-year record (240 monthly points) the Fisher matrix’s smallest eigenvalue is 6.110e+01 and its largest 6.942e+05, a condition number of 11361.2; the sloppiest direction is (0.3982, 0.6476, 0.6496), whose cosine with the predicted direction is 0.999996. The symmetry told us in advance which direction the record would fail to resolve — the golden ratio again.

The consequence: taken one at a time, c1c_1, c2c_2 and μ\mu have standard errors of 0.0510, 0.0829 and 0.0831, but the estimates of c1c_1 and c2c_2 are correlated at +0.9994: each parameter is blurred while their combination is sharp. This is what Gutenkunst and colleagues call a “sloppy” model. Lengthening the record to sixty years shrinks every standard error (0.0289, 0.0470, 0.0472) but leaves the condition number almost unchanged (10874.8): a longer record narrows every error bar but does not change the imbalance between them.

Dates of extremes: locked to the forcing, or drifting freely

Calculation

# Chapter 5. p11: How sure are the dates of future and past energy peaks?
# Parameter uncertainty from a 20-year record (the Fisher information of
# p10, recomputed here), 100 parameter draws from N(theta, F^-1).
# A. Forced, damped ring (as p08): for each draw, the time and height of
#    the largest energy peak in a past window (60-80 yr) and two future
#    windows (120-140, 140-160 yr).
# B. A free oscillation instead (no forcing, just past its Hopf point):
#    the period near threshold is 2 pi 5 / (10 |Im lambda_1|) years, and
#    a peak H years ahead is uncertain by about H sd(period) / period.
import cmath
import math
import random

W = cmath.exp(2j * math.pi / 5)
SCALE, SD = 10.0, 0.05
TRUE = (1.0, 0.5, math.cos(math.radians(72))
        + 0.5 * math.cos(math.radians(36)) + 0.1)
B = [1.0, 0.0, -1.0, 0.0, 0.0]

def run(th, years, h, sample=None):
    c1, c2, mu = th
    def f(y, t):
        u = ((1.0 if int(t // 10) % 2 == 0 else -1.0)
             + math.sin(2 * math.pi * t))
        return [SCALE / 5 * (c1 * y[(i - 1) % 5] - c2 * y[(i - 2) % 5]
                             - mu * y[i]) + B[i] * u for i in range(5)]
    y, out, n = [0.0] * 5, [], 0
    while n * h < years - 1e-9:
        t = n * h
        k1 = f(y, t)
        k2 = f([a + h / 2 * b for a, b in zip(y, k1)], t + h / 2)
        k3 = f([a + h / 2 * b for a, b in zip(y, k2)], t + h / 2)
        k4 = f([a + h * b for a, b in zip(y, k3)], t + h)
        y = [a + h / 6 * (b + 2 * c + 2 * d + e)
             for a, b, c, d, e in zip(y, k1, k2, k3, k4)]
        n += 1
        if sample is None:
            out.append(((n * h), sum(v * v for v in y)))
        elif n % sample == 0:
            out.append(y[0])
    return out

def fisher(years=20, d=1e-4):
    cols = []
    for k in range(3):
        up, dn = list(TRUE), list(TRUE)
        up[k] += d
        dn[k] -= d
        a, b = run(up, years, 0.01, 8), run(dn, years, 0.01, 8)
        cols.append([(x - y) / (2 * d) for x, y in zip(a, b)])
    return [[sum(p * q for p, q in zip(cols[i], cols[j])) / SD ** 2
             for j in range(3)] for i in range(3)]

def chol_of_inverse(f):
    det = (f[0][0] * (f[1][1] * f[2][2] - f[1][2] * f[2][1])
           - f[0][1] * (f[1][0] * f[2][2] - f[1][2] * f[2][0])
           + f[0][2] * (f[1][0] * f[2][1] - f[1][1] * f[2][0]))
    c = [[(f[(j + 1) % 3][(i + 1) % 3] * f[(j + 2) % 3][(i + 2) % 3]
           - f[(j + 1) % 3][(i + 2) % 3] * f[(j + 2) % 3][(i + 1) % 3]) / det
          for j in range(3)] for i in range(3)]
    l = [[0.0] * 3 for _ in range(3)]
    for i in range(3):
        for j in range(i + 1):
            s = c[i][j] - sum(l[i][k] * l[j][k] for k in range(j))
            l[i][j] = math.sqrt(s) if i == j else s / l[j][j]
    return l

def sd(v):
    m = sum(v) / len(v)
    return math.sqrt(sum((x - m) ** 2 for x in v) / (len(v) - 1))

if __name__ == "__main__":
    rng = random.Random(60011)
    l = chol_of_inverse(fisher())
    draws = []
    for _ in range(100):
        z = [rng.gauss(0, 1) for _ in range(3)]
        draws.append(tuple(TRUE[i] + sum(l[i][k] * z[k] for k in range(3))
                           for i in range(3)))
    wins = ((60, 80), (120, 140), (140, 160))
    times = {w: [] for w in wins}
    highs = {w: [] for w in wins}
    for th in draws:
        e = run(th, 160, 0.02)
        for lo, hi in wins:
            t, v = max(((t, v) for t, v in e if lo <= t <= hi),
                       key=lambda r: r[1])
            times[(lo, hi)].append(t)
            highs[(lo, hi)].append(v)
    print("A. forced, damped ring: largest energy peak per window")
    print("   window (yr)   mean time   sd time (yr)   mean height  sd")
    for w in wins:
        print("   {:3d}-{:3d}       {:8.2f}      {:7.3f}       {:7.3f}"
              "   {:.3f}".format(w[0], w[1], sum(times[w]) / 100,
                                sd(times[w]), sum(highs[w]) / 100,
                                sd(highs[w])))
    pers = [2 * math.pi * 5 / (SCALE * abs((c1 * W ** -1
                                             - c2 * W ** -2).imag))
            for c1, c2, _ in draws]
    mp, sp = sum(pers) / 100, sd(pers)
    print("\nB. free oscillation: period {:.3f} +- {:.3f} yr".format(mp, sp))
    for hz in (20, 50, 100):
        print("   peak {:3d} yr ahead: timing sd about {:.2f} yr".format(
            hz, hz * sp / mp))
    print("\nReading: a forced, damped ring keeps time with its forcing, so")
    print("a peak 140 years out is dated as well as one 60 years back -")
    print("every draw puts it on the same 0.02-yr time step - and only")
    print("its height is uncertain. A free oscillation keeps its own")
    print("time, and its timing error grows in proportion to the horizon.")
    print("Which kind of system one has is the first question.")
# A. forced, damped ring: largest energy peak per window
#    window (yr)   mean time   sd time (yr)   mean height  sd
#     60- 80          72.04        0.000         4.130   0.022
#    120-140         132.04        0.000         4.130   0.022
#    140-160         152.04        0.000         4.130   0.022
#
# B. free oscillation: period 4.782 +- 0.011 yr
#    peak  20 yr ahead: timing sd about 0.05 yr
#    peak  50 yr ahead: timing sd about 0.12 yr
#    peak 100 yr ahead: timing sd about 0.23 yr
#
# Reading: a forced, damped ring keeps time with its forcing, so
# a peak 140 years out is dated as well as one 60 years back -
# every draw puts it on the same 0.02-yr time step - and only
# its height is uncertain. A free oscillation keeps its own
# time, and its timing error grows in proportion to the horizon.
# Which kind of system one has is the first question.

Part A draws 100 parameter sets from the uncertainty of a twenty-year record, simulates the forced, damped ring for each, and finds the time of the largest energy peak in three windows. The past window’s peak (60 to 80 years) falls at 72.04 years and the future windows’ at 132.04 and 152.04 years; in every draw all three fall on the same 0.02-year time step, a timing standard deviation of 0.000. Only the height is uncertain (4.130, standard deviation 0.022). A forced, damped system keeps time with its forcing, and a peak 140 years ahead can be dated as well as one 60 years back.

Part B replaces it with a free oscillation (no forcing, just past its Hopf point). It keeps its own time, with an estimated period of 4.782 ± 0.011 years; a peak 20 years ahead is dated to a standard deviation of about 0.05 years, 50 years ahead about 0.12, 100 years ahead about 0.23 — an error proportional to the forecast distance.

This is the honest answer to the outline’s “predicting energy peaks and troughs in future and past windows”: whether the dates of extremes can be forecast depends first on whether the system is a damped one locked to an external rhythm or a free oscillation keeping its own. The first’s dates barely feel parameter uncertainty; the second’s errors grow linearly with distance. For an unknown system one must first decide from the data which kind it is, and that itself needs a test registered in advance, like the one in Chapter 8.

The direction of the Fisher matrix’s smallest eigenvalue almost coincides with the golden-ratio direction the symmetry predicts; left: twenty-year record, right: sixty-year record.

Note

“Hindcast” and “forecast” are symmetric here. For a forced, damped system the extremes of past and future windows are both fixed by the forcing period, so this chapter gives them the same precision. That holds only if the model is exactly right; with real data the past window has observations to check against and the future window does not.

Hypothesis · not established

The author’s hypothesis (not yet tested): observing two neighbouring nodes instead of one raises the Fisher eigenvalue of the sloppiest direction by more than an order of magnitude, because the second node carries mode 2’s phase. What would show it wrong: adding the second observed node raises the smallest eigenvalue by less than tenfold.

Summary

Observing one node, a record fixes two parameter combinations precisely and hardly resolves the third; that sloppy direction is exactly the golden-ratio direction the ring’s symmetry predicts, and a longer record does not remove the imbalance. In a forced, damped system the dates of energy extremes are locked to the forcing, so a peak 140 years ahead is dated as well as one 60 years back; in a free oscillation the dating error grows in proportion to the forecast distance.

References

Gutenkunst, Ryan N., Joshua J. Waterfall, Fergal P. Casey, Kevin S. Brown, Christopher R. Myers, and James P. Sethna. 2007. “Universally Sloppy Parameter Sensitivities in Systems Biology Models.” PLoS Computational Biology 3 (10): e189.
Raue, Andreas, Clemens Kreutz, Thomas Maiwald, et al. 2009. “Structural and Practical Identifiability Analysis of Partially Observed Dynamical Models by Exploiting the Profile Likelihood.” Bioinformatics 25 (15): 1923–29.

Fan, Y. (2026). Five-Node Cyclic Network Dynamics, Solar-Longitude Ephemeris and Multi-Scale Oscillator Perturbations: Rock-Paper-Scissors-Lizard-Spock Lotka-Volterra Graphs, Equation-of-Time Keplerian Mechanics and Jacobian Sensitivity Bounds [五节点循环网络动力学、黄经历表与多尺度振子扰动] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090168 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).