08-EFT.WP.Core.Sea v1.0 | Chapter 3 — Synchronization and Time Bases

Home ／ Docs-Technical WhitePaper ／ 08-EFT.WP.Core.Sea v1.0

Chapter 3 — Synchronization and Time Bases

I. Objectives and Scope

• Align the semantics of tau_mono and ts, and establish a measurable, controllable, and auditable framework for offset/skew/J.
• Provide postulates P83-, minimal equations S83-, and the synchronization workflow Mx-3; ensure consistency with the happens-before relation (hb) in Core.Threads Chapter 4 and the T_arr calibration in Core.Sea Chapter 8.

II. Fundamentals and Model

1. Time bases
   • tau_mono: the local monotonic timebase for measuring latency, jitter, and timeouts.
   • ts: UTC wall-clock time for publication and audit.
   • sync_ref: the synchronization reference source, drawn from {"ptp","ntp","gnss_pps","hw_fanout"}.
   • clock_id: a clock identifier bound to a sid or host domain.
2. Linear clock model
   ts_i(t) = alpha_i * tau_mono + beta_i + epsilon_i(t)
   where alpha_i is the skew (dimensionless), beta_i the offset (seconds), and epsilon_i(t) a zero-mean noise term.For each clock i relative to the reference tau_mono:
3. Derived quantities
   • Relative to reference r:
     offset_{i->r}(t) = ( alpha_i - alpha_r ) * tau_mono + ( beta_i - beta_r ).
   • Relative frequency offset (ppm):
     skew_ppm(i->r) = 1e6 * ( alpha_i / alpha_r - 1 ).
   • Jitter: J_i = rms( epsilon_i(t) ) (seconds).

III. Postulates P83- (Synchronization and Time Semantics)*

• P83-1 Monotonic-first. Use tau_mono for all latency, jitter, and timeout measurements; reserve ts for publication and audit.
• P83-2 Reference anchoring. The system must declare a unique sync_ref and reference clock r; all offset/skew/J are measured against r as the zero and unit baseline.
• P83-3 Causality fidelity. For cross-device event comparisons requiring hb, map each timeline to tau_mono before comparison; never compare raw ts_i directly.
• P83-4 Uncertainty explicitness. Reports of alpha_i and beta_i must include u(alpha_i), u(beta_i), and the evaluation window Delta_t.
• P83-5 Arrival-time consistency. If T_arr is used for timing calibration, you must also provide gamma(ell), d ell, c_ref, n_eff, and the dual-form difference
  delta_form = | ( 1 / c_ref ) * ( ∫ n_eff d ell ) - ( ∫ ( n_eff / c_ref ) d ell ) |.

IV. Minimal Equations S83- (Estimation and Bounds)*

1. S83-1 OLS estimates for alpha_i and beta_i
   Given samples { ( t_k, s_k ) } with t_k = tau_mono(k) and s_k = ts_i(k):
   • alpha_hat = cov(t,s) / var(t); beta_hat = mean(s) - alpha_hat * mean(t).
   • Residual variance:
     sigma_eps^2 = ( 1 / (K - 2) ) * ∑ ( s_k - ( alpha_hat * t_k + beta_hat ) )^2.
   • Approximate uncertainties:
     u(alpha_i)^2 ≈ sigma_eps^2 / ∑ ( t_k - mean(t) )^2;
     u(beta_i)^2 ≈ sigma_eps^2 * ( 1/K + mean(t)^2 / ∑ ( t_k - mean(t) )^2 ).
2. S83-2 Relative offset and frequency offset
   With reference r, compute offset_{i->r}(t) and skew_ppm(i->r) as defined above; for online use, substitute t = tau_mono_now.
3. S83-3 Jitter impact on coherence
   Phase standard deviation: sigma_phi ≈ 2 * pi * f_in * J_i; coherence attenuation:
   • coh ≈ exp( -0.5 * sigma_phi^2 ).
   • Jitter-limited SNR (dB): SNR_jitter_dB ≈ -20 * log10( 2 * pi * f_in * J_i ) (consistent with S82-4).
4. S83-4 Sample alignment error
   Delta_t_n(i->r) = offset_{i->r}(t_n) + ( fs_i_err / fs_i ) * t_n, where fs_i_err ≈ skew(i->r) * fs_i.For device i, ideal time at sample n: t_n = n / fs_i. Relative to reference:
5. S83-5 Projecting arrival time onto a common base
   • If T_arr_i is measured, map it to the reference base:
     T_arr_i_ref = alpha_r^{-1} * ( alpha_i * T_arr_i + beta_i - beta_r ).
   • Linearized propagation of uncertainty:
     u(T_arr_i_ref)^2 ≈ ( ∂T/∂alpha_i )^2 u(alpha_i)^2 + ( ∂T/∂beta_i )^2 u(beta_i)^2 + ....

V. Estimators and Calibration Methods

1. Coarse-to-fine estimation
   • Coarse: align via gnss_pps or frame markers to initialize beta_i (sub-ms).
   • Fine: sliding-window OLS or RLS to update alpha_i/beta_i; for broadband data, use cross-correlation (xcorr) to refine fractional offset.
2. Online RLS (recommended)
   Recursive update for theta_k = [ alpha, beta ]^T:
   theta_k = theta_{k-1} + K_k * ( s_k - phi_k^T * theta_{k-1} );
   with phi_k = [ t_k, 1 ]^T,
   K_k = P_{k-1} * phi_k / ( lambda + phi_k^T * P_{k-1} * phi_k ),
   P_k = ( P_{k-1} - K_k * phi_k^T * P_{k-1} ) / lambda;
   forgetting factor lambda ∈ (0,1] governs responsiveness to drift.
3. Uncertainty reporting
   For OLS, use u(alpha_i), u(beta_i) from S83-1; for RLS, use sqrt(diag(P_k)) as confidence radii. Always include Delta_t and sample count K.
4. Jitter measurement
   For PPS or zero-crossing streams, compute RMS of time-of-arrival jitter; for waveforms, band-pass, xcorr to extract TOA series, then compute J_i.

VI. Protocol and Reference Source Guidance

• ptp (layer-2 / layer-1 transparent clocks preferred)
  Require hardware timestamps; record path_delay and announce priorities; include ptp_domain in the manifest.
• ntp
  Use as a backup; limit high-frequency applications; report P99 of alignment offset.
• gnss_pps
  UTC via PPS and time-of-day; strong cross-site consistency; model antenna delay and multipath.
• hw_fanout
  Distribute a central reference clock in hardware; preferred over software distribution; document topology and cable delay compensation.

VII. Quality Thresholds and Fallback

1. Suggested thresholds (relative to r):
   • | offset_{i->r}(now) | ≤ 100 us (general sensing); ≤ 1 us (high-coherence acoustic/RF).
   • | skew_ppm(i->r) | ≤ 5 ppm (general); ≤ 0.1 ppm (precision).
   • J_i such that SNR_jitter_dB is within 3 dB of the target (per Chapter 2 objectives).
2. Fallback
   On violation: switch sync_ref to the secondary source; raise RLS weight for fast correction; if necessary, downsample or narrow bandwidth to preserve coherence. Log the event and raise_alert(kind="sync_fault").

VIII. Synchronization and Arrival Time (Cross-chapter Alignment)

IX. Configuration and Execution — Workflow Mx-3 (Sync Baseline)

• Select sync_ref and reference clock r; initialize manifest {sync_ref, r, topology}.
• Collect sliding-window samples { ( tau_mono, ts_i ) }; run OLS to obtain alpha_hat/beta_hat and uncertainties; generate the initial mapping.
• Verify jitter: measure J_i, evaluate SNR_jitter_dB via S83-3; if insufficient, improve timing hardware or narrow bandwidth.
• Refine: for waveforms, use xcorr to get fractional offset and update beta_hat; start RLS if needed (lambda in 0.98~0.999).
• Validate: on independent markers (e.g., PPS or frame sync), ensure P50/P95 of offset_{i->r} meet thresholds.
• Solidify: write to manifest {alpha_i, beta_i, u(alpha_i), u(beta_i), J_i, Delta_t, K, method}.
• Publish: expose ts externally under the UTC semantics of r, retaining the traceable tau_mono mapping.

X. Implementation Bindings and Interface Hints (I80-2 and I80-6)

• sync_clocks(sids:list[str], method:str="ptp", ref:str|None=None) -> SyncRef
  method ∈ {"ptp","ntp","gnss_pps","hw_fanout"}; ref selects the reference clock_id. Returns a handle carrying alpha_hat/beta_hat/J.
• measure_skew_offset(sids:list[str], window:float) -> dict
  Produces {"sid": {"alpha":val,"beta":val,"u_alpha":val,"u_beta":val,"J":val,"K":int}}; suggest window >= 60 s. Use RLS for fast-drift cases.
• enforce_arrival_time_convention(trace:any) -> None (I80-6)
  Must run before writing or consuming T_arr; verifies both formulations, delta_form, and the presence of the reference timebase mapping.

XI. Provenance and Manifest — Minimal Fields

• {sync_ref, clock_id, r, method, window, K, alpha, beta, u_alpha, u_beta, J, skew_ppm, topology, pps_delay, ptp_domain, note}.
• Any cross-device comparison must cite this manifest version and the acquisition interval Delta_t.