16-EFT.WP.Methods.Cleaning v1.0 | Chapter 5 Time Axis and Synchronization Cleaning

Home ／ Docs-Technical WhitePaper ／ 16-EFT.WP.Methods.Cleaning v1.0

Chapter 5 Time Axis and Synchronization Cleaning

One-Sentence Goal
Unify internal sequencing on tau_mono and publish externally on ts; estimate and record offset, skew, J, and within a window Delta_t perform alignment, interpolation, and resampling while preserving monotonicity and causal order.

I. Scope & Objects

1. Applicable targets
   • All time-related fields and derived quantities in D_metric from Chapter 4: tau_mono, ts, offset, skew, J, Delta_t.
   • Clock alignment for multi-source data, drift correction for single-source streams, event alignment, and cadence regularization for publication.
2. Target artifacts
   Produce D_time and manifest.timing = { tau_mono, ts, offset, skew, J, Delta_t, method, quality }, with auditable evidence for anomalies, drift, and jitter encountered during alignment.

II. Terms & Variables (Memory Anchors)

• Baselines & publication: tau_mono (internal evaluation baseline), ts (external publication time).
• Sync parameters: offset (phase shift), skew (clock-rate deviation), J (jitter), Delta_t (window).
• Operators & transforms: map_to_pub( tau_mono ; offset, skew, J ), interp_{method}( x ; ts → grid ), resamp_{Delta_t}^{op}( x ).
• Constraints: non_decreasing(tau_mono), non_decreasing(ts), coverage = 1 - mean(m).

III. Axioms (P105-*)

• P105-01 Monotone-baseline axiom
  tau_mono must be monotone: non_decreasing(tau_mono) = true.
• P105-02 Publication-mapping axiom
  Externally visible time is always given by ts = map_to_pub( tau_mono ; offset, skew, J ); tau_mono is not published.
• P105-03 Windowed-estimation axiom
  Estimate and persist offset, skew, J within a Delta_t window; across windows, allow piecewise change with continuity constraints and boundary records.
• P105-04 Explicit-jitter axiom
  Jitter J must be measured and published explicitly; smoothing must not conceal instantaneous deviations.
• P105-05 Interpolation-with-causality axiom
  Interpolation must not cross gaps > gap_max; any backfill preserves causal event order and the m mask.
• P105-06 Multi-source-consistency axiom
  Align multiple sources to a common reference or consensus method; persist offsets in the manifest and forbid implicit zero-offset assumptions.

IV. Minimal Equations (S105-*)

• S105-01 Linear mapping and parameter definitions
  ts ≈ a * tau_mono + b
  skew = a - 1
  offset = b
• S105-02 Jitter estimation (robust form)
  J = MAD( ts - ( a * tau_mono + b ) )
  or J^2 = Var( ts - ( a * tau_mono + b ) ) (under non-heavy-tail assumptions)
• S105-03 Windowed least squares
  a_w, b_w = argmin_{a,b} sum_{k ∈ window} w_k * ( ts_k - ( a * tau_mono_k + b ) )^2
  skew_w = a_w - 1, offset_w = b_w
• S105-04 Coarse alignment (cross-correlation)
  lag* = argmax_lag corr( x_ref(t), x_i(t + lag) )
  offset_i ← offset_i - lag*
• S105-05 Dimension checks
  dim(ts) = [T], dim(tau_mono) = [T], dim(offset) = [T], dim(skew) = [1], dim(J) = [T]
  check_dim( ts - ( a * tau_mono + b ) ) = true
• S105-06 Resampling and aggregation
  x_grid = interp_{method}( x ; ts → grid )
  agg_{Delta_t}^{op}(x) = op( { x_k | ts_k ∈ bucket(Delta_t) } )

V. Synchronization Problem Classes & Strategies

1. Bias-dominated clocks (low drift)
   • Strategy: estimate a global offset (median or weighted mean), assume skew ≈ 0.
   • Trigger: |skew| ≤ tol_skew_lo and J ≤ tol_J_lo.
2. Slope-deviation dominated (stable drift)
   • Strategy: windowed linear regression for a_w, b_w and publish piecewise segments.
   • Trigger: |skew| > tol_skew_lo with acceptable J.
3. Jitter-dominated (noise/queuing)
   • Strategy: preserve J, cap interpolation and aggregation windows, and publish P50/P95 timing-deviation metrics.
   • Trigger: J > tol_J_lo.
4. Multi-source alignment (no shared clock)
   • Strategy: select a reference stream, perform cross-correlation coarse alignment, then local linear refinement; persist offsets in the manifest.
   • Trigger: sources exhibit correlated structure or common pulses.

VI. Cleaning Process (M10-5 Time Axis & Synchronization)

• Baseline verification
  Validate non_decreasing(tau_mono); on failure, roll back to Chapter 3 for ordering/segregation.
• Initial coarse alignment
  If a reference stream exists, estimate lag* and correct initial offset per source.
• Windowed parameter estimation
  Within Delta_t, solve for a_w, b_w, derive skew_w and offset_w, and compute J_w with confidence bounds.
• Quality gating and segmentation
  If |skew_w| > tol_skew or J_w > tol_J, refine by splitting windows or switching to robust regression (e.g., Huber loss).
• Publication mapping
  Produce ts_pub = a_w * tau_mono + b_w; retain tau_mono for internal causality and back-tracing.
• Interpolation & resampling (optional)
  Apply interp_{method} and agg_{Delta_t}^{op} for metric/model cadence needs; keep m consistent for missingness.
• Contract checks
  Assert non_decreasing(ts_pub), check_dim( ts_pub - ( a_w * tau_mono + b_w ) ), and verify coverage.
• Manifest persistence
  Write manifest.timing: { Delta_t, a_w, b_w, offset_w, skew_w, J_w, method, quality } and generate auditable residual statistics.
• Artifacts
  Output D_time and set ts ← ts_pub for downstream chapters.

VII. Contracts & Assertions (Chapter Must-Pass)

• Monotonicity: non_decreasing(ts) = true
• Dimension conservation: check_dim( ts - ( a * tau_mono + b ) ) = true
• Jitter ceiling (per window): J ≤ tol_J
• Slope ceiling (per window): |skew| ≤ tol_skew
• Coarse-alignment coherence (multi-source): |offset_ref - median(offset_i)| ≤ tol_offset
• Coverage & interpolation: coverage ≥ q_min_coverage and gap_inserted ≤ gap_max
• Manifest completeness: exists(manifest.timing) with all fields present

VIII. Implementation Binding (I10-5)

1. Interface prototypes
   • align_timebase(ds, sync_ref) -> ds'
   • estimate_clock_linear(ds, window) -> { a_w, b_w, J_w, quality }
   • coarse_align_by_xcorr(sig_ref, sig_i) -> lag*
   • publish_map(tau_mono, a_w, b_w) -> ts_pub
   • resample(ds, grid, method, op) -> ds'
2. Invariants & postconditions
   • ts_pub is monotone and passes dimension checks; manifest.timing is reproducible; multi-source offsets are traceable.
   • Any interpolation/resampling preserves m and source labels, avoiding implicit data fabrication.
3. Failure semantics
   E_NON_MONOTONIC, E_REGRESS_FAIL, E_XCORR_WEAK, E_JITTER_EXCESS; each must localize the offending window/time span.

IX. High-Frequency Operational Playbooks

1. Device clock leaps
   • Diagnosis: |Δ( ts - a * tau_mono )| > theta_leap.
   • Action: segment the series, estimate a_w, b_w independently before/after, and annotate leap_event in the manifest.
2. Multi-source merges
   Choose a reference stream (lowest noise or widest coverage), perform cross-correlation coarse alignment, refine with windowed linear fitting, and publish on unified ts_pub.
3. High-jitter streams
   Do not smooth or reorder; publish P50/P95 of J and shrink Delta_t to control local model error.

X. Audit & Panel Fields

• Minimal panel
  skew_w, offset_w, J_w, R2_w (or a robust alternative), leap_events, gap_stats, coverage
• Alert suggestions
  |skew_w| > tol_skew, J_w > tol_J, leap_events > 0, coverage < q_min_coverage

XI. Cross-References

• Units & dimensions (dimension checks and unit conventions): Chapter 4.
• Path & arrival time (two forms and path measures): Chapter 6.
• Deduplication & referential integrity (time-ordering aspects): Chapter 9.
• Contracts & release freeze: Chapter 10.
• Quality scoring & audit: Chapter 14.
• Interfaces & policy summaries: Appendices A, B, C.

Summary
This chapter defines the unified mapping from tau_mono to ts, windowed parameter estimation, and jitter measurement, yielding a reproducible manifest.timing and a monotone publication time axis. With these in place, the data have a reliable temporal foundation for Chapter 6’s path and arrival-time handling and for Chapter 10’s release-freeze and audit pipeline.