From 1b6be0fdb46700f3b9e9dfb1e19b1fbeedec6626 Mon Sep 17 00:00:00 2001
From: YurenHao0426 <Blackhao0426@gmail.com>
Date: Wed, 22 Jul 2026 14:36:39 -0500
Subject: theory: expose intermittent feedback tracking lag

---
 THEORY.md                    | 35 +++++++++++++++++++++++++++++++++++
 experiments/verify_theory.py | 26 ++++++++++++++++++++++++++
 2 files changed, 61 insertions(+)

diff --git a/THEORY.md b/THEORY.md
index c64eb46..d82e171 100644
--- a/THEORY.md
+++ b/THEORY.md
@@ -470,6 +470,41 @@ The relevant timescale is therefore the product of learning rate and number of
 neutral updates. Too few neutral updates leave traffic; task-period updates
 converge to the wrong coefficient regardless of speed.
 
+### Intermittent feedback tracking can hide behind a final cosine
+
+An idealized mirror event every `k` task updates uses
+
+```text
+Q_m^+ = Q_m + eta_M (W_m - Q_m).
+```
+
+Let `E_m=Q_m-W_m` immediately before that event and let
+`U_m=W_(m+1)-W_m` be the sum of the following `k` forward-weight changes.
+The tracking error obeys the exact recurrence
+
+```text
+E_(m+1) = (1 - eta_M) E_m - U_m.
+```
+
+If every task update has norm at most `d`, then `||U_m|| <= k d` and
+
+```text
+limsup_m ||E_m|| <= k d / eta_M.
+```
+
+The bound is attained in the scalar or constant-collinear case. Thus reducing
+the mirror cadence or increasing its learning rate only controls lag relative
+to how fast the task weights move; a high feedback cosine is not automatic.
+For the frozen RRM setting `k=16, eta_M=0.1`, the ideal worst-case lag scale is
+`160` single-task-update norms before stochastic finite-probe error is added.
+
+Conversely, after the task updates stop (`U_m=0`), the endpoint error decays as
+`(1-eta_M)^m`. A learning-rate drop or quiet tail can therefore produce an
+excellent final cosine even when the feedback was badly out of date during
+the loss-producing part of training. Endpoint alignment must be reported with
+the alignment trajectory and task loss. This is a standard tracking fact used
+to audit the mirror baseline, not an SDIL novelty claim.
+
 ## 4. Hardware-independent complexity
 
 Let `H` be the number of hidden layers, `K` the perturbation directions per
diff --git a/experiments/verify_theory.py b/experiments/verify_theory.py
index ba07487..8054b0d 100644
--- a/experiments/verify_theory.py
+++ b/experiments/verify_theory.py
@@ -196,6 +196,31 @@ def check_innovation_identification():
     assert abs(retained_fraction - (1.0 - predictable_fraction)) < 0.01
 
 
+def check_intermittent_feedback_tracking():
+    eta_m = 0.1
+    cadence = 16
+    per_step_change = 0.002
+    block_change = cadence * per_step_change
+
+    # Constant collinear forward-weight motion attains the norm bound.
+    error = 0.0
+    for _ in range(1000):
+        error = (1.0 - eta_m) * error - block_change
+    steady_state = -block_change / eta_m
+    assert abs(error - steady_state) < 1e-14
+
+    # Once forward motion stops, endpoint tracking can look excellent despite
+    # the large error accumulated during the task-active trajectory.
+    error_before_quiet_tail = abs(error)
+    for _ in range(80):
+        error *= 1.0 - eta_m
+    expected_endpoint = error_before_quiet_tail * (1.0 - eta_m) ** 80
+    print("\nINTERMITTENT FEEDBACK TRACKING")
+    print(f"steady_error={abs(steady_state):.6f} bound={cadence * per_step_change / eta_m:.6f} "
+          f"endpoint_after_quiet_tail={abs(error):.9e}")
+    assert abs(abs(error) - expected_endpoint) < 1e-15
+
+
 def main():
     check_simultaneous_variance()
     check_sigma_bias()
@@ -203,6 +228,7 @@ def main():
     check_conditional_projection()
     check_predictor_timescale()
     check_innovation_identification()
+    check_intermittent_feedback_tracking()
     print("\nALL THEORY CHECKS PASSED")
 
 
-- 
cgit v1.2.3