56-Report-Level Methods Appendix Template v1.0 | Chapter 6 Mathematical Formulation & Pseudocode

Home ／ Docs-Technical WhitePaper ／ 56-Report-Level Methods Appendix Template v1.0

Chapter 6 Mathematical Formulation & Pseudocode

I. Chapter Goals & Scope (Mandatory)

• Describe the method with a minimal yet complete mathematical formulation and execution-grade pseudocode, ensuring consistent, reviewable symbols—units—dimensions—path/measure—complexity—numerical stability.
• Aligned with Ch.4 (S/P), Ch.5 (Data & Experimental Design), Ch.7 (Metrology & Calibration), and Ch.8 (Evaluation Protocol).

II. Main Statements & Symbol Table (Mandatory)

1. Main equations (inline with backticks):
   • General form: T_arr = ( ∫ ( n_eff / c_ref ) d ell )
   • Factored form: T_arr = ( 1 / c_ref ) * ( ∫ n_eff d ell )
2. Path & measure: gamma(ell); d ell.
3. Symbols—units—dimensions:
   n_eff: unit 1, dim=1; c_ref: unit m·s^-1, dim=L T^-1; T_arr: unit s, dim=T.
4. Dimensional check: check_dim=true; all expressions with division/integral/composite operators must use parentheses.

III. Constraints & Assumptions (Mandatory)

• Measurability & boundedness: n_eff≥0, c_ref>0, gamma(ell) continuously differentiable.
• Equivalence condition (optional): if ∂_ell c_ref = 0 a.e., the two forms are equivalent; otherwise use the factored form only as an exception.
• Numerical domain: ell ∈ [ell_0, ell_1], step Δell>0; state integral error cap ε_int.

IV. Pseudocode (Mandatory)

FUNCTION EstimateArrivalTime(gamma, n_eff, c_ref, mode, Δell, ε_int):

# Inputs:

# gamma(ell): path parameterization on [ell0, ell1]

# n_eff(ell): effective refractive index along gamma

# c_ref(ell or const): reference propagation limit

# mode ∈ {"general","factored"}

# Δell > 0: step size; ε_int ≥ 0: integral tolerance

# Output: T_arr (scalar, unit: s)

ASSERT Δell > 0

ell_grid ← Discretize([ell0, ell1], step=Δell)

IF mode == "general":

acc ← 0

FOR k FROM 1 TO len(ell_grid)-1:

mid ← Midpoint(ell_grid[k-1], ell_grid[k])

acc ← acc + ( n_eff(mid) / c_ref(mid) ) * (ell_grid[k] - ell_grid[k-1])

T_arr ← acc

ELSE IF mode == "factored":

c0 ← RefValue(c_ref) # require piecewise-constant or validated bound

ASSERT IsApproximatelyConstant(c_ref, ell_grid, tol=τ_c)

acc ← 0

FOR k FROM 1 TO len(ell_grid)-1:

mid ← Midpoint(ell_grid[k-1], ell_grid[k])

acc ← acc + n_eff(mid) * (ell_grid[k] - ell_grid[k-1])

T_arr ← (1 / c0) * acc

ENDIF

# Optional: RichardsonExtrapolation / SimpsonComposite if ε_int is tight

IF ε_int > 0:

T_arr ← RefineIntegral(T_arr, gamma, n_eff, c_ref, mode, Δell, ε_int)

RETURN T_arr

V. Complexity & Numerical Stability (Mandatory)

1. Time complexity: O(N) with N = ⌈(ell_1-ell_0)/Δell⌉; space complexity: O(1) (streaming sum).
2. Stability notes:
   • Step size: Δell ≤ min{ℓ_c/10, ℓ_var/10} (one-tenth of medium-variation and curvature scales).
   • Factoring check: require max_ell |c_ref(ell)-c0| / c0 ≤ τ_c before using factored.
   • Integration error: ε_int governs Simpson/adaptive quadrature; record final grid and error estimate.

VI. Alignment with Evaluation Protocol (Mandatory)

1. Gates alignment:
   • gate_accuracy>=0.99@7d: compare to high-fidelity baseline (finer Δell or analytic value).
   • gate_latency<=2h@7d: runtime limit for batch path integration.
   • compat_rate>=0.995@replay: replay consistency.
2. Experiment log: store Δell/ε_int/τ_c and result hashes.

VII. Machine Structure (YAML; JSON-equivalent, Mandatory)

math:

statements:

- "T_arr = ( ∫ ( n_eff / c_ref ) d ell )"

- "T_arr = ( 1 / c_ref ) * ( ∫ n_eff d ell )"

path: "gamma(ell)"

measure: "d ell"

symbols:

- { name: "T_arr", unit: "s", dim: "T" }

- { name: "n_eff", unit: "1", dim: "1" }

- { name: "c_ref", unit: "m·s^-1", dim: "L T^-1" }

check_dim: true

assumptions:

measurable: true

positivity: { n_eff: ">=0", c_ref: ">0" }

equivalence_cond: "∂_ell c_ref = 0 a.e."

algo:

pseudocode_ref: "EstimateArrivalTime"

inputs: ["gamma","n_eff","c_ref","mode","Δell","ε_int"]

outputs: ["T_arr"]

complexity: { time: "O(N)", space: "O(1)" }

stability:

step_rule: "Δell <= min{ℓ_c/10, ℓ_var/10}"

factored_tol: "τ_c"

integral_tol: "ε_int"

evaluation_links:

gates_hard: ["gate_accuracy>=0.99@7d"]

gates_soft: ["unit_cost<=1.0x@30d"]

metrics: ["gate_latency<=2h@7d","compat_rate>=0.995@replay"]

arrival_time:

delta_form: "general|factored"

record:

Δell: 0.001

ε_int: 1e-6

τ_c: 0.01

VIII. Human × Machine Mapping (Mandatory)

IX. Minimal Sample (human abstract × machine snippet, Mandatory)

• Human abstract: use the general form T_arr = ( ∫ ( n_eff / c_ref ) d ell ); Δell=1e-3, ε_int=1e-6; declare gamma(ell) and d ell in the same paragraph; check_dim=true.
• Machine snippet:

math:

statements: ["T_arr = ( ∫ ( n_eff / c_ref ) d ell )"]

path: "gamma(ell)"

measure: "d ell"

symbols:

- { name: "T_arr", unit: "s", dim: "T" }

- { name: "n_eff", unit: "1", dim: "1" }

- { name: "c_ref", unit: "m·s^-1", dim: "L T^-1" }

check_dim: true

algo:

inputs: ["gamma","n_eff","c_ref","mode","Δell","ε_int"]

complexity: { time: "O(N)", space: "O(1)" }

arrival_time:

delta_form: "general"

record: { Δell: 0.001, ε_int: 1e-6, τ_c: 0.01 }

X. Validation Rules (regex/consistency, Mandatory)

• Equations: inline backticks; if T_arr appears, math.path and math.measure are required.
• Pseudocode: must specify IO and error checks; complexity declaration must match implementation.
• Dimensions: math.check_dim=true; math.symbols[*].unit/dim non-empty.
• Gates: gate_<metric>(>=|<=)[^@]+@[^ ]+$; consistent with Ch.8.

XI. Citation & Cross-Reference Style (Mandatory)