v8

improve_gainlora/IDEA_Overall.md

@@ -1,7 +1,7 @@
-# SpecRoute: Định tuyến Phổ thông qua Duality Định tuyến–Bảo vệ trong Học liên tục với LoRA
+# SpecRoute: Định tuyến Phổ Dẫn dắt bởi Dữ liệu trong Học Liên tục với LoRA
 
-> **Tài liệu thiết kế chính thức — V7**
-> Ràng buộc: Zero-replay nghiêm ngặt. Theory-first.
+> **Tài liệu thiết kế chính thức — V8**
+> Ràng buộc: Zero-replay nghiêm ngặt. Theory-first. Tổng hợp sau V2–V7.
 
 ---
 
@@ -66,6 +66,36 @@ trong đó $V_t$ là các right singular vectors của $\Delta W_t$. Tính trự
 - Không cần replay để duy trì routing → tự nhiên tuân thủ zero-replay.
 - Độ chính xác routing được *đảm bảo* bởi chất lượng bảo vệ (được hình thức hoá bên dưới).
 
+### 2.3 GPM–Routing Paradox: Duality sụp đổ với A ngẫu nhiên
+
+**Đây là phát hiện cốt lõi giải thích V2–V6 thất bại (AP ≈ 27–40).**
+
+Routing đo $\alpha_t(h) \propto \|A_t h\|^2$. Để phân biệt task $t^*$ với $s$, cần $A_{t^*}$ align với input $h \sim p_{t^*}$.
+
+**Nghịch lý:** InfLoRA khởi tạo $A_t$ **ngẫu nhiên** (Kaiming) rồi chiếu vào null-space. Kết quả:
+
+1. $\text{rowspace}(B_tA_t) \subseteq \text{rowspace}(A_t)$ — rowspace không mở rộng qua phép nhân trái.
+2. $\text{rowspace}(A_t) = r$ hướng **ngẫu nhiên** trong $d'$-chiều null-space (không encode task identity).
+3. Với same-domain tasks (yelp/amazon/sst2/imdb): input $h$ có variance theo hướng CHUNG → signatures không phân biệt được.
+
+**Empirical:** V6 IMDB (task 8): EM = 0.0 suốt 10 epochs dù training loss giảm — routing inference gán sai expert. V3 RTE, MNLI cũng tương tự. Root cause = không phải null-space exhaustion mà là **routing signal không có trong random $A_t$**.
+
+### 2.4 Lối Thoát: Differential Projection via Data-Informed Init
+
+**Lemma (sẽ chứng minh ở §3.5):** Do InfLoRA constraint $A_t P_{t-1} = 0$:
+$$\|A_t h\|^2 \;=\; \|A_t Q_{t-1} h\|^2 \quad \forall h, \quad Q_{t-1} = I - P_{t-1}$$
+
+Routing $\alpha_t$ **chỉ nhìn thành phần $Q_{t-1}h$** — phần của $h$ NGOÀI span tất cả task cũ. Với $h \sim p_s$ ($s < t$): GPM đã capture $\geq 99.5\%$ variance của $p_s$ → $\|Q_{t-1}h\|^2 \leq 0.005\,\mathrm{tr}(C_s)$ → $\alpha_t(h) \approx 0$ tự nhiên. **Đây là differential projection — task-discriminative theo thiết kế.**
+
+**Vấn đề còn lại:** Random $A_t$ không align với hướng có variance cao nhất của task $t$ trong null-space → $\|A_t Q_{t-1}h\|^2$ nhỏ dù $\|Q_{t-1}h\|^2$ đáng kể.
+
+**Giải pháp — C5:** Khởi tạo $A_t$ = top-$r$ eigenvectors của $\tilde{C}_t = Q_{t-1}C_tQ_{t-1}$. Khi đó:
+$$E_{h \sim p_t}[\|A_t h\|^2] = \sum_{i=1}^r \lambda_i(\tilde{C}_t) \quad \textbf{— GIÁ TRỊ CỰC ĐẠI}$$
+
+**C5 biến random routing key thành optimal routing key — giải quyết GPM–Routing Paradox.**
+
+> **Kết nối C5 ↔ C2:** C5 không chỉ giúp learning (maximize captured variance trong null-space) mà **đồng thời** maximize routing signal. Một initialization, hai mục tiêu. Hai contribution C1/C2 và C5 là bất khả phân.
+
 ---
 
 ## 3. Khung Lý thuyết
@@ -141,11 +171,11 @@ $$w_{t^*}(h) \;\geq\; \frac{1}{1 + (T{-}1)\,\exp\!\bigl(-m/\tau\bigr)}, \qquad m
 
 ---
 
-**Hệ quả 2** *(Capacity Bound — Kết nối Grassmannian).* Số lượng tối đa subspace $r$-chiều trong $\mathbb{R}^d$ với pairwise overlap $\delta \leq \varepsilon$:
+**Hệ quả 2** *(Capacity Bound — Kết nối Grassmannian).* Gọi $k_t$ là **GPM effective rank** của task $t$ — số eigenvectors thực tế được GPM giữ lại (threshold 99.5%). Số lượng tasks tối đa trước khi null-space sụp đổ:
 
-$$T_{\max} \;\leq\; \frac{d}{r\,(1 - \varepsilon)}$$
+$$T_{\max} \;\leq\; \frac{d}{\bar{k}\,(1 - \varepsilon)}, \qquad \bar{k} = \frac{1}{T}\sum_{t=1}^T k_t$$
 
-Với T5-Small ($d = 512$, $r = 8$, $\varepsilon = 0.02$): $T_{\max} \leq 65 \gg 15$ tasks. Điều này kết nối capacity học liên tục với lý thuyết Grassmannian packing.
+**Lưu ý quan trọng:** $\bar{k}$ thực tế $\gg r$. Với T5-small ($d=512$) và NLP tasks phong phú, GPM giữ $k_t \approx 30\text{–}80$ dims/task để đạt 99.5% variance (không phải $r=8$). Ước tính thực tế: 15 tasks × 50 dims = 750 $> d$ → **null-space bão hòa là rủi ro thực**, không phải lý thuyết. Đây là lý do §3.10 thảo luận null-space collapse riêng. Bound Grassmannian vẫn đúng về *số lượng subspace $r$-chiều có thể pack*, nhưng capacity constraint của GPM là $\sum_t k_t \leq d$, chặt hơn $\sum_t r \leq d$.
 
 ### 3.4 Cam kết Trực giao từ Kiến trúc InfLoRA
 
@@ -165,29 +195,110 @@ $$\text{span}(V_t) \;=\; \text{rowspace}(\Delta W_t) \;\subseteq\; \text{rowspac
 - GPM bases $\mathcal{B}$ span xấp xỉ $\text{rowspace}(A_s)$ cho các task $s < t$ (vì GPM tích lũy principal input directions, mà activation của task $s$ chủ yếu kích hoạt theo hướng $A_s$).
 - Do đó: $\text{span}(V_t) \subseteq \text{null}(P_{\text{old}}) \approx \perp \text{span}(V_s)$ với mọi $s < t$. $\square$
 
-**Chất lượng xấp xỉ:** Với GPM threshold $\varepsilon_0 = 0.995$ (capture ≥ 99.5% variance), $\delta_{t,s} \leq 1 - 0.995 = 0.005 \ll \kappa_{\min}(t^*)$ trong thực tế.
+**Chất lượng xấp xỉ:** Với GPM threshold $\varepsilon_0 = 0.995$ (capture ≥ 99.5% variance), $\delta_{t,s} \leq 0.005 \ll \kappa_{\min}(t^*)$ trong thực tế.
 
-**Sửa reviewer:** Reviewer nói "GPM không đảm bảo orthogonality của $\Delta W_t$" — *đúng* với GPM gradient projection. Nhưng cơ chế bảo đảm orthogonality là **InfLoRA A-projection** (bước khởi tạo), không phải gradient projection. Theorem 1 không cần giả định — nó là hệ quả tất yếu của kiến trúc InfLoRA đã có sẵn.
+
+**Phân tích độ nhạy GPM (Davis–Kahan perturbation).** GPM trong thực tế chỉ capture *xấp xỉ* principal directions nên có sai số $\Delta P_{t-1}$ so với GPM lý tưởng. Theo Davis–Kahan theorem, perturbation trong subspace angle bị chặn bởi:
+$$\sin\!\bigl(\Theta(\hat{V}_s, V_s)\bigr) \leq \frac{\|\hat{C}_s - C_s\|_2}{\delta_{\text{gap}}(C_s)}$$
+trong đó $\hat{C}_s$ là sample covariance (200 batches), $\delta_{\text{gap}}$ là eigenvalue gap. Với batch size 200 và T5-small $d=512$, sai số này nhỏ khi $\delta_{\text{gap}}$ đủ lớn (task distributions phân kỳ). Kết quả thực tế: margin trong Định lý 1 bị giảm thêm $O(\|\Delta P\|_F / \delta_{\text{gap}})$ — nhỏ với tasks có spectrum phân kỳ, lớn hơn với same-domain tasks (expected). Xẩy ra same-domain routing failure vẫn là giới hạn của *mọi* zero-replay CL method, không phải đặc thù SpecRoute.
+
+### 3.5 Lemma về Differential Projection
+
+**Lemma 1** *(Differential Projection — Exact).* Với $A_t$ thoả mãn InfLoRA constraint $A_t P_{t-1} = 0$, với **mọi** $h \in \mathbb{R}^d$:
+$$\|A_t h\|^2 \;=\; \|A_t Q_{t-1} h\|^2, \quad Q_{t-1} = I - P_{t-1}$$
+
+**Chứng minh.** Viết $h = P_{t-1} h + Q_{t-1} h$. Vì $A_t P_{t-1} = 0$ (các hàng $A_t$ trực giao với colspace của $P_{t-1}$):
+$$A_t h = A_t P_{t-1} h + A_t Q_{t-1} h = 0 + A_t Q_{t-1} h \qquad \square$$
+
+**Hệ quả A (Current expert trên old data — from Lemma 1):** Với $h \sim p_s$ ($s < t$):
+$$E_{h \sim p_s}\!\left[\alpha_t(h)\right] = \frac{E[\|A_t Q_{t-1} h\|^2]}{r\,\|h\|^2} \leq \frac{\mathrm{tr}(Q_{t-1} C_s)}{r} \leq \frac{(1-\tau_\text{GPM})\,\mathrm{tr}(C_s)}{r} \leq \frac{0.005\,\mathrm{tr}(C_s)}{r}$$
+
+**Hệ quả B (Old expert trên new data — GPM-capture argument):** Với $h \sim p_t$ ($t > s$). Vì GPM sau task $s$ tích lũy principal directions của task $s$'s activations, trong đó $A_s$'s rowspace (= top-$r$ directions của $\tilde{C}_s$) được capture vào $P_s \subseteq P_{t-1}$. Do đó:
+$$\text{rowspace}(A_s) \subseteq \text{range}(P_{t-1}) \quad\Rightarrow\quad A_s Q_{t-1} = 0$$
+Suy ra $A_s h_t = A_s P_{t-1} h_t$ và:
+$$E_{h \sim p_t}[\alpha_s(h)] = \frac{E[\|A_s P_{t-1} h_t\|^2]}{r\,\|h_t\|^2} \leq \frac{\mathrm{tr}(P_{t-1} C_t)}{r\,\mathrm{tr}(C_t)} \cdot \frac{\mathrm{tr}(C_t)}{r}$$
+Với task $t$ có domain mới (khác task cũ): $\mathrm{tr}(P_{t-1} C_t) / \mathrm{tr}(C_t) = \text{PEV}_{t,\text{old}} \ll 1$ — fraction variance của task $t$ được giải thích bởi các cơ sở cũ. Với same-domain tasks: $\text{PEV}_{t,\text{old}}$ lớn hơn, đây là giới hạn cơ bản của mọi zero-replay CL method, không phải lỗ hổng đặc thù của SpecRoute.
 
 ---
 
-### 3.5 Drift Invariance
+### 3.6 Định lý C5 Routing Optimality (Đóng góp Lý thuyết Chính)
 
-**Mệnh đề 1** *(Drift-Free Routing).* Hàm routing $h \mapsto \alpha_t(h)$ hoàn toàn ổn định qua tất cả các task.
+**Định nghĩa 4** *(Restricted Stiefel Manifold).*
+$$\mathcal{A}_t = \{A \in \mathbb{R}^{r \times d} : A P_{t-1} = 0,\; A A^\top = I_r\}$$
+
+**Định lý 2** *(C5 Routing Optimality).* Với $C_t = E_{h \sim p_t}[hh^\top]$ và $\tilde{C}_t = Q_{t-1} C_t Q_{t-1}$:
+$$\operatorname{argmax}_{A_t \in \mathcal{A}_t} E_{h \sim p_t}[\alpha_t(h)] \;=\; \text{top-}r\text{ eigenvectors của } \tilde{C}_t$$
+Giá trị cực đại: $\displaystyle\frac{1}{r}\sum_{i=1}^r \lambda_i(\tilde{C}_t)$
+
+**Chứng minh.** Từ Lemma 1:
+$$E_{h \sim p_t}[\alpha_t(h)] = \frac{E[\|A_t Q_{t-1} h\|^2]}{r\,E[\|h\|^2]} = \frac{\mathrm{tr}(A_t\,\tilde{C}_t\,A_t^\top)}{r}$$
+Với ràng buộc $A_t A_t^\top = I_r$, đây là **Constrained PCA** tiêu chuẩn trên $\tilde{C}_t$: lời giải là eigenvectors ứng với eigenvalues lớn nhất. Đây chính xác là C5. $\square$
+
+**Ý nghĩa:** C5 **đồng thời** tối ưu:
+1. **Learning quality:** maximize $\mathrm{tr}(A_t \tilde{C}_t A_t^\top)$ = variance captured trong null-space → $B_t$ học được hiệu quả.
+2. **Routing signal:** maximize $E[\alpha_t(h)]$ → routing phân biệt task $t$ tốt hơn mọi init khác.
+
+*Đây là lý do C5 và C2 là bất khả phân: C5 biến random routing key thành optimal routing key.*
+
+---
 
-**Chứng minh.** Routing input được tính từ frozen embedding table, *trước* bất kỳ transformer block nào. LoRA chỉ tồn tại trong các attention layer sâu hơn → $h$ độc lập với mọi tham số LoRA. Kết hợp với $\mathcal{S}_t$ đóng băng, $\alpha_t(h)$ bất biến với mọi thay đổi tích luỹ. $\square$
+### 3.7 Định lý Routing Margin với GPM + C5
 
-### 3.6 Vấn đề then chốt: Null-Space Collapse
+**Định lý 3** *(Explicit Routing Margin).* Gọi $\lambda_t^\min = \lambda_r(\tilde{C}_t)$ (r-th eigenvalue của projected covariance). Với C5 init và A-row routing ($\tau_\text{GPM} = 0.995$):
+$$\boxed{E_{h \sim p_t}[\alpha_t(h)] - \max_{s < t}\,E_{h \sim p_s}[\alpha_t(h)] \;\geq\; \frac{\lambda_t^\min}{r} - \frac{0.005\,\bar{\sigma}^2}{r}}$$
 
-Định lý 1 giả định $h \in \mathrm{span}(V_{t^*})$. Trong thực tế điều này đòi hỏi hai điều kiện:
+với $\bar{\sigma}^2 = \max_s \mathrm{tr}(C_s)$.
 
-**(A) Expert phải học được:** $A_t$ phải nằm trong subspace có liên quan đến task $t$ để $B_t$ có thể học các biến đổi có ý nghĩa, tạo ra $\sigma_{t,i} > 0$ đáng kể.
+**Hệ quả (GPM–Routing Paradox Formalized):** Với random $A_t$ (không có C5), routing signal:
+$$E_{h \sim p_t}[\alpha_t^\text{rand}(h)] \approx \frac{\mathrm{tr}(\tilde{C}_t)}{d'}$$
 
-**(B) Input phải có projection:** Inputs thực tế của task $t$ phải chiếu có năng lượng lên $\text{span}(V_t)$.
+Tỷ lệ lợi thế C5 over random:
+$$\frac{E[\alpha_t^\text{C5}(h)]}{E[\alpha_t^\text{rand}(h)]} \;=\; \underbrace{\frac{d'}{r}}_{\text{null-space factor}} \cdot \underbrace{\text{PEV}_r(\tilde{C}_t)}_{\text{task concentration}}$$
+
+**Quan sát quan trọng:** Factor $d'/r$ và $\text{PEV}_r$ đều **tăng ý nghĩa về mặt routing khi null-space shrinks** (later tasks). C5 quan trọng nhất chính khi routing khó nhất.
+
+Với T5-small task 8 ($d' \approx 351$, $r=8$): tỷ lệ $\approx 44\times \cdot \text{PEV}_8 \gg 1$.
+
+---
+
+### 3.8 Training–Inference Symmetry
+
+**Mệnh đề 2** *(Routing Symmetry).* V8 training và inference dùng cùng formula:
+
+| Phase | Formula |
+|-------|---------|
+| Training (task $t$) | $\alpha_t^\text{train}(h) = \dfrac{\|A_t h\|^2}{r\|h\|^2} + \beta(n)$ |
+| Inference | $\alpha_t^\text{inf}(h) = \dfrac{\|A_t h\|^2}{r\|h\|^2}$ |
+
+**Không có metric asymmetry.** V2–V7 dùng A-row proxy khi train nhưng SVD Rayleigh quotient khi inference — đây là nguồn gốc mismatch vì hai formula sống trong *hai metric space khác nhau*. V8 dùng A-row cho cả hai: đây là "symmetry" về mặt metric formula.
+
+$\beta(n) = \tau\ln\!\bigl(\alpha_\text{target} \cdot n / (1-\alpha_\text{target})\bigr)$ — **cold-start mechanism** cho gradient flow khi $B_t = 0$ lúc đầu training. Nó không phải "fake routing quality"; expert $B_t$ học để transform task $t$'s features trong null-space, và những features đó (C5 A-row directions) vẫn có tín hiệu tại inference dù không còn β. β giải quyết vấn đề *gradient starvation*, không phải routing quality. Loại bỏ β khi inference là *có chủ đích* — không có task ID, không thể biết n để tính β, và không cần: $A_t$ đã align với task $t$'s null-space variance.
+
+> **Về asymmetry β tạo ra:** Expert $B_t$ được train với score tổng $\alpha_t + \beta$ nhưng deploy không có β. Điều này CÓ ảnh hưởng nếu $\alpha_t$ lúc inference quá nhỏ để win softmax. Đây là lý do Phản biện 1 (asymmetric capacity giữa old vs new experts) là concern thực — và lý do mục tiêu của C5 maximize $\alpha_t$ là cần thiết: đảm bảo $\|A_t Q_{t-1} h\|^2$ đủ lớn kể cả không có β.
+
+**Điều kiện α-sufficiency (để inference không cần β):** Routing của expert $t$ thắng tại inference nếu:
+$$E[\alpha_t(h) \mid h \sim p_t] - \max_{s \neq t} E[\alpha_s(h) \mid h \sim p_t] > 0$$
+Điều kiện này được hụ bởi Định lý 3: margin là $\lambda_t^\min/r - 0.005\bar{\sigma}^2/r$, dương khi $\lambda_t^\min > 0.005\bar{\sigma}^2$. C5 maximize $\lambda_t^\min = \lambda_r(\tilde{C}_t)$ (r-th eigenvalue của projected covariance), đây cũng chính là largest feasible $\lambda_r$ trong $\mathcal{A}_t$. Nếu $\lambda_r(\tilde{C}_t)$ quá nhỏ (null-space collapse hoặc task tương đồng domain), margin bị nhiễu — đây là giới hạn của setting, được thảo luận trong §3.10.
+
+---
+
+### 3.9 Drift Invariance
+
+**Mệnh đề 3** *(Drift-Free Routing).* Hàm routing $h \mapsto \alpha_t(h)$ bất biến qua tất cả tasks: $h$ từ frozen embedding table trước mọi attention layer; $A_t$ đóng băng sau C5 init. $\square$
+
+**Làm rõ về layer routing:** Routing được tính *một lần* tại input (token embedding, trước block transformer đầu tiên) — không phải routing riêng biệt tại mỗi transformer layer. Vector $h$ = mean-pool của token embeddings (frozen `embed_tokens`), không thay đổi qua training. Điều này đảm bảo routing hoàn toàn frozen và không drift. C5 initialization per-layer (mỗi attention layer có $A_t^{(l)}$ riêng) phục vụ *learning quality* chứ không phải routing — routing chỉ dùng encoder layers để aggregate signal.
+
+---
+
+### 3.10 Vấn đề Null-Space Collapse (Còn tồn tại, được giải một phần)
+
+Định lý 1 giả định $h \in \text{span}(V_{t^*})$. Điều kiện này:
+- **(A) Expert phải học được:** $A_t$ phải align với task-relevant directions. C5 giải quyết bằng data-informed init.
+- **(B) Input phải co projection:** Inputs thực phải có energy trên $\text{span}(V_t)$.
+
+C5 giải (A). (B) được đảm bảo khi null-space ($d'$) còn đủ rộng để capture task-t variance. Với $d=512$, $r=8$, 15 tasks: null-space vẫn đủ theo Hệ quả 2.
 
-**InfLoRA gốc vi phạm (A):** $A_t$ được khởi tạo ngẫu nhiên (Kaiming) rồi chiếu vào null-space của GPM:
 
-$$A_t \leftarrow A_t - A_t P_{\text{old}}, \quad \text{normalize}$$
 
 Null-space (sau $t-1$ tasks) là một không gian $d - N_{\text{protected}}$ chiều. Kaiming random trong không gian này KHÔNG ĐẢM BẢO alignment với các hướng có liên quan đến task $t$. Khi null-space thu hẹp dần (Layer 7: 8/512 → 161/512 → 344/512 qua 13 tasks), xác suất random init bắt được đúng hướng task-relevant giảm theo.
 
@@ -197,40 +308,47 @@ Null-space (sau $t-1$ tasks) là một không gian $d - N_{\text{protected}}$ ch
 
 ## 4. Các Thành phần Framework
 
-### C1 — Spectral Expert Signatures
+### C1 — Spectral Expert Signatures (V8: A_t as Signature)
 
-Sau khi train task $t$, tính $\mathcal{S}_t = (V_t, \boldsymbol{\sigma}_t)$ qua **thin SVD**:
+**V8 thay đổi từ V7:** Signature là $\mathcal{S}_t = A_t$ (model parameter), **không cần thin SVD post-training**. Lý do từ Định lý 2: rowspace của $V_t$ (từ SVD của $B_tA_t$) = rowspace của $A_t$ (phép nhân trái không mở rộng rowspace) — SVD chỉ thêm $\sigma$-weighting gây noise. Với C5 init, $A_t$ rows **đã là** task-discriminative directions.
 
-$$B_t,\, A_t \;\xrightarrow[\text{QR + SVD}]{O(dr^2)}\; (V_t,\, \boldsymbol{\sigma}_t)$$
+- **Không cần `prepare_inference_routing()`** — loại bỏ $O(dr^2)$ overhead per task per layer.
+- **Không tham số bổ sung** — $A_t$ là model parameter đã có.
+- **Bất biến** — $A_t$ đóng băng sau C5 init (Mệnh đề 3).
 
-- QR decomposition của $B$ và $A^\top$, sau đó SVD của $r \times r$ core → chính xác, $O(dr^2)$ so với $O(d^2 r)$.
-- Lưu trên mỗi LoRA layer (encoder Q, V; decoder self/cross Q, V).
-- **Bất biến** theo cấu trúc: weights đóng băng → signatures đóng băng → không trôi dạt.
+### C2 — Data-Informed Differential Routing (V8)
 
-### C2 — Spectral Affinity Routing
+**V8 thay đổi từ V7:** Cả training lẫn inference đều dùng **A-row formula** — loại bỏ hoàn toàn `prepare_inference_routing()` và SVD inference mismatch. Lý do từ Lemma 1 + Định lý 2: $A_t$ rows với C5 init đã là routing optimal directions; SVD của $B_tA_t$ chỉ thêm $\sigma^2$-weighting từ B optimization artifact, không có đảm bảo lý thuyết.
 
-**Inference** (tất cả task, routing SVD đối xứng):
+**Routing formula (Training và Inference):**
 
 $$w(h) = \mathrm{softmax}\!\left(\frac{[\alpha_1(h),\; \ldots,\; \alpha_T(h)]}{\tau}\right)$$
 
-Mọi task đều dùng cùng công thức $\sigma^2$-weighted spectral affinity (Định nghĩa 2). Sau khi train task $t$, tính $\mathcal{S}_t$ một lần qua `prepare_inference_routing()` và sử dụng cùng signatures của task cũ.
+$$\alpha_t(h) = \frac{\|A_t\, h\|^2}{r\,\|h\|^2}, \qquad \text{(A-row affinity — cả train lẫn inference)}$$
 
-**Training** (task $t$, SVD cuối chưa biết vì $B_t$ đang train):
+**Training** (task $t$ thêm adaptive bias):
 
 $$\alpha_t^{\mathrm{train}}(h) = \frac{\|A_t\, h\|^2}{r\,\|h\|^2} + \beta(n), \qquad \beta(n) = \tau \cdot \ln\!\left(\frac{\alpha_{\mathrm{target}} \cdot n}{1 - \alpha_{\mathrm{target}}}\right)$$
 
 trong đó $n = |\{\text{task cũ}\}|$ và $\alpha_{\mathrm{target}} \in (0,1)$ là routing weight mục tiêu cho task hiện tại (mặc định 0.8).
 
-**Lý giải proxy A-row:** Với $B_t$ full-rank bất kỳ, column span của $V_t$ (từ SVD của $B_t A_t$) bằng $\mathrm{range}(A_t^\top)$. Vì vậy các hàng $A$ span *cùng* subspace input mà $V_t$ hội tụ sẽ capture. Proxy đo alignment input với subspace này dùng weighting đồng đều (chưa có $\sigma$).
+**Lý giải A-row routing (từ Lemma 1 + Định lý 2):**
 
-**Lý giải adaptive $\beta(n)$:** Bias hằng số gây routing weight của task hiện tại giảm $O(1/n)$ theo số task (softmax dilution). Công thức adaptive chuẩn hoá điều này: giải $w_t = \alpha_{\mathrm{target}}$ trong phương trình softmax cho ra closed-form trên. Đảm bảo task hiện tại nhận được routing weight $\approx \alpha_{\mathrm{target}}$ bất kể $n$.
+- **Exact decomposition (Lemma 1):** $\|A_t h\|^2 = \|A_t Q_{t-1} h\|^2$ — routing chỉ nhìn null-space component, không bị ảnh hưởng bởi task cũ.
+- **Optimality với C5 (Định lý 2):** C5 init chọn $A_t$ = argmax $E[\|A_t h\|^2]$ trên tất cả $A_t \in \mathcal{A}_t$ — A-row affinity là tốt nhất có thể trong constraint.
+- **Margin bound (Định lý 3):** $E[\alpha_t|h \sim p_t] - \max_s E[\alpha_t|h \sim p_s] \geq \lambda_t^\min/r - 0.005\bar{\sigma}^2/r > 0$.
+- **Loại bỏ `prepare_inference_routing()`:** $A_t$ đóng băng sau C5 init — là signature không cần tái tính SVD của $B_tA_t$.
 
-**Lý giải symmetric inference:** Tại inference, $B_t$ đóng băng và $\Delta W_t = B_t A_t$ có SVD xác định. Dùng cùng $\sigma^2$-weighted Rayleigh quotient cho tất cả task đảm bảo *đối xứng đo lường* — mọi affinity đều sống trên cùng metric space, và Định lý 1 áp dụng thống nhất.
+**Lý giải adaptive $\beta(n)$:** Giải $w_t = \alpha_{\mathrm{target}}$ trong softmax → closed-form $\beta(n) = \tau\ln(\alpha_\text{target} \cdot n/(1-\alpha_\text{target}))$. Tránh $O(1/n)$ softmax dilution khi số task tăng.
 
-| Phase | Cơ chế routing | Nhiệt độ | Lý do |
-|-------|----------------|----------|-------|
-| Training (task $t$) | A-row fit + adaptive $\beta(n)$ | $\tau = 1.0$ | $B=0$ cold-start; β bù softmax dilution |
-| Inference (mọi task) | SVD spectral affinity (đối xứng) | $\tau = 1.0$ | Mọi task dùng σ²-weighted Rayleigh quotient |
+**Lợi thế C5 so với random A-row (Hệ quả Định lý 3):**
+$$\frac{E[\alpha_t^\text{C5}(h)]}{E[\alpha_t^\text{rand}(h)]} = \frac{d'}{r} \cdot \text{PEV}_r(\tilde{C}_t) \approx 44\times \text{ tại task 8 (T5-small)}$$
+
+| Phase | Cơ chế routing | Notes |
+|-------|----------------|-------|
+| Training (task $t$) | $\|A_t h\|^2/(r\|h\|^2) + \beta(n)$ | $\beta$ bù softmax dilution |
+| **Inference (mọi task)** | **$\|A_t h\|^2/(r\|h\|^2)$** | **V8: không SVD, không $\sigma^2$-weighting** |
+| Đảm bảo lý thuyết | Định lý 3 margin bound + C5 advantage $44\times$ | Cả hai phase đều dùng cùng metric space |
 
 ### C3 — Capacity-Aware Subspace Allocation
 
@@ -318,6 +436,10 @@ A_t = A_t / norm(A_t, dim=1, keepdim=True) * sqrt(3)  # normalize như InfLoRA g
 
 **Điều kiện fallback:** Nếu `max_eigenvalue(C_tilde) < 1e-6`, null-space quá hẹp hoặc activation không có signal đủ mạnh. Trong trường hợp này, C5 nhường cho Kaiming init + InfLoRA projection tiêu chuẩn — không làm tệ hơn V6, chỉ không cải thiện. Điều kiện này chỉ xảy ra khi null-space gần như bão hoà, tức là ESA đã tiêu thụ gần hết capacity.
 
+**C5 per-layer:** Mỗi LoRA layer (encoder Q, V; decoder self/cross Q, V) có $C_t$ riêng thu thập từ activation tương ứng của layer đó. GPM cũng lưu $P_{\text{old}}^{(l)}$ riêng theo layer $l$. Do đó eigenvector decomposition được thực hiện độc lập cho từng layer — mỗi $A_t^{(l)}$ chỉ capture variance task-relevant trong null-space của layer $l$.
+
+**Hệ kết với Routing:** Routing sử dụng input embedding (frozen embedding table output, trước tất cả transformer layers) và A-row của các encoder layers — không phải per-layer routing riêng biệt. C5 per-layer cải thiện **học hiệu quả** của $B_t$ tại mỗi layer, còn routing signal (§3.2) được aggregate qua các encoder layers.
+
 #### Ý nghĩa Lý thuyết Thông tin
 
 Theo Data Processing Inequality, với bất kỳ ma trận $A_t$ nào:
@@ -349,6 +471,8 @@ $C_t$ được tính từ **dữ liệu training của task hiện tại** (task
 | `previous_trans_input` | Frozen MLP copies | ❌ Loại bỏ | Signatures bất biến theo cấu trúc |
 | KL distillation | Replay-based routing loss | ❌ Loại bỏ | Không learned routing → không cần distill |
 | GPM trên routing params | Subspace cho routing | ❌ Loại bỏ | Không có routing parameters để bảo vệ |
+| **`prepare_inference_routing()`** | **SVD của $B_tA_t$ post-training** | **❌ Loại bỏ (V8)** | **$A_t$ là signature, kh\u00f4ng c\u1ea7n t\u00e1i t\u00ednh SVD; lo\u1ea1i b\u1ecf $O(dr^2)$ overhead** |
+| **SVD $\sigma^2$-weighted inference** | **Rayleigh quotient khác train formula** | **❌ Loại bỏ (V8)** | **Train-inference mismatch; A-row đủ từ Lemma 1 + Định lý 2** |
 
 **Hiệu ứng tổng thể:** Toàn bộ subspace và compute budget mà GainLoRA dành cho routing infrastructure được *thu hồi* cho task learning.
 
@@ -371,7 +495,7 @@ $C_t$ được tính từ **dữ liệu training của task hiện tại** (task
 **Đảm bảo lý thuyết:**
 - Routing margin $\geq \kappa_{\min}(t^*) - \varepsilon\, \kappa_{\max}$ — tỷ lệ thuận với chất lượng bảo vệ (Định lý 1).
 - Routing weight $w_{t^*} \geq 1-\delta$ với nhiệt độ $\tau \leq m/\ln\!\bigl((T-1)/\delta\bigr)$ (Hệ quả 1).
-- Capacity bound $T_{\max} \leq d/r(1-\varepsilon)$ qua lý thuyết Grassmannian packing (Hệ quả 2).
+- Capacity bound $T_{\max} \leq d/(\bar{k}(1-\varepsilon))$ qua lý thuyết Grassmannian packing (Hệ quả 2), trong đó $\bar{k}$ là GPM effective rank ($\approx 30$–$80$ dims/task), không phải LoRA rank $r=8$.
 - Routing hoàn toàn bất biến qua thời gian: $h$ từ frozen embedding table, $\mathcal{S}_t$ đóng băng sau training (Mệnh đề 1).
 
 **Tại sao không phải đơn giản hoá mà là tiến bộ lý thuyết:** Kết quả này cho thấy các kiến trúc như GainLoRA đang giải quyết một bài toán không tồn tại (routing parameter learning). Chúng tôi chứng minh rằng bảo vệ tốt ↔ routing tốt — hai bài toán hóa ra là *một*.
@@ -403,18 +527,18 @@ $A_t$ này đảm bảo capture **variance task-relevant tối đa** trong null-
 ### Task 1 (`--run_single True`)
 1. Load pretrained model + fresh LoRA ($A$: Kaiming, $B$: zeros).
 2. Huấn luyện chuẩn (chỉ `lora_B`) — single expert, không routing.
-3. Sau training: tính $\mathcal{S}_1$ (thin SVD) + GPM bases (ESA threshold).
-4. Lưu: LoRA weights, spectral signatures, GPM reg files.
+3. Sau training: cập nhật GPM bases (ESA threshold). **Không cần tính SVD hay `prepare_inference_routing()`** — $A_t$ là signature.
+4. Lưu: LoRA weights, GPM reg files.
 
 ### Task $t \geq 2$
-1. Load model + fresh LoRA; load LoRA weights và spectral signatures cũ.
+1. Load model + fresh LoRA; load LoRA weights cũ.
 2. **[C5 — MỚI]** Pre-task forward pass (200 batch, no grad):
    - Thu thập activation covariance $C_t$ của inputs task $t$
    - Tính projected covariance: $\tilde{C}_t = Q C_t Q$ ($Q = I - P_{\text{old}}$)
    - Eigenvectors của $\tilde{C}_t$ → khởi tạo $A_t$ (thay thế random Kaiming)
 3. InfLoRA: chuẩn hoá $A_t$ (đã nằm trong null-space từ eigenvector decomposition).
-4. Huấn luyện `lora_B` với spectral affinity routing + adaptive bias $\beta(n)$ + gradient preconditioning (C4.1).
-5. Sau training: tính $\mathcal{S}_t$ (cả inference routing và storage) + cập nhật GPM bases (200 batches, đủ cho SVD ổn định).
+4. Huấn luyện `lora_B` với A-row routing + adaptive bias $\beta(n)$ + gradient preconditioning (C4.1).
+5. Sau training: cập nhật GPM bases (200 batches). **Không gọi `prepare_inference_routing()`** — $A_t$ đóng băng từ bước 2 là signature đủ dùng.
 6. Lưu tất cả artifacts cho task tiếp theo.
 
 ---
@@ -423,10 +547,10 @@ $A_t$ này đảm bảo capture **variance task-relevant tối đa** trong null-
 
 | Lý thuyết | Implementation | File |
 |-----------|---------------|------|
-| Spectral signature $\mathcal{S}_t$ | `compute_spectral_signatures()` (thin QR+SVD) | `t5_specroute.py` |
-| Spectral affinity $\alpha_t(h)$ (inference) | σ²-weighted Rayleigh quotient | `compute_spectral_routing()` |
+| Spectral signature $\mathcal{S}_t = A_t$ | `lora_A` weights (frozen after C5 init) — **không cần SVD** | `t5_specroute.py` |
+| Spectral affinity $\alpha_t(h)$ (inference) | A-row fit: `(proj**2).sum(-1) / (r * h_norm_sq)` | `compute_spectral_routing()` |
 | A-row proxy $\alpha_t^{\mathrm{train}}$ (training) | A-row fit + adaptive bias $\beta(n)$ | `compute_spectral_routing()` |
-| Symmetric inference SVD | `prepare_inference_routing()` → SVD của $B_t A_t$ | `t5_specroute.py` |
+| ~~Symmetric inference SVD~~ | ~~`prepare_inference_routing()` → SVD của $B_t A_t$~~ | **❌ Loại bỏ hoàn toàn (V8)** |
 | Routing $w = \mathrm{softmax}(\alpha / \tau)$ | `torch.softmax(fit_scores / temp)` | `compute_spectral_routing()` |
 | Drift-free input $h$ | `inputs_embeds = embed_tokens(input_ids)` → mean-pool | `T5Stack.forward()` |
 | GPM + InfLoRA null-space | `get_reg_matrix()` | `cl_trainer_specroute.py` |
@@ -445,11 +569,12 @@ $A_t$ này đảm bảo capture **variance task-relevant tối đa** trong null-
 | Benchmarks | SuperNI (15 tasks, 2 orderings), Long (15 tasks, 2 orderings) |
 | Metrics | AP (Average Performance, ↑), FT (Forgetting, ↓) |
 | LoRA | $r = 8$, target=Q+V, InfLoRA (chỉ B trained, A đóng băng) |
-| Routing | $\tau = 1.0$, $\alpha_{\mathrm{target}} = 0.8$, adaptive $\beta(n)$ (train); SVD đối xứng (inference) |
+| Routing | $\tau = 1.0$, $\alpha_{\mathrm{target}} = 0.8$, adaptive $\beta(n)$ (train); **A-row formula (inference, V8 — không SVD)** |
 | ESA | $\varepsilon_0 = 0.995$ (dynamic) |
 | C4 | Gradient preconditioning bật (`--use_preconditioning True`), $\epsilon = 10^{-6}$; entropy reg đã loại bỏ V7 |
 | **C5** | **N_batch = 100, `torch.linalg.eigh` trên projected covariance, fallback nếu max_eigval < 1e-6** |
 | GPM repr. | 200 batches (giảm từ 1000 — SVD ổn định sau 200) |
+| **Scalability note** | **C5 per-layer eigdecomp: $O(d^2)$ per layer per task. Với T5-small ($d=512$) tất cả layers: chấp nhận được. Với flan-t5-large ($d=1024$): 4× đắt hơn nhưng vẫn chỉ tuyến tính theo tasks. Với LLaMA-7B ($d=4096$): sử dụng randomized SVD hoặc Lanczos (top-$r$ eigenvecs không cần full decomp) giảm xuống $O(dr)$ per layer.** |
 | Precision | fp32 + gradient_checkpointing (T5 + P100: fp16 có risk NaN overflow với large softmax) |
 | P100 BSZ | BSZ=8, GA=4 (effective 32); T4: BSZ=2, GA=8 |
 | Thời gian (P100 16GB) | SuperNI T5-Small ≈ 2-3h; Long benchmark ≈ 3-4h — thoải mái trong 12h Kaggle |

improve_gainlora/src/cl_trainer_specroute.py

@@ -11,6 +11,7 @@ Key differences from GainLoRA_InfLoRA_Trainer:
 """
 
 import gc
+import math
 import torch
 from torch.utils.data import DataLoader
 from torch.utils.data.distributed import DistributedSampler
@@ -89,7 +90,7 @@ class SpecRoute_Trainer(Seq2SeqTrainer):
                  compute_metrics=None, callbacks=None,
                  lambda_entropy=0.0, use_preconditioning=False,
                  precond_eps=1e-6, entropy_warmup_ratio=0.1,
-                 n_batches_c5=200):
+                 n_batches_c5=100):
         super().__init__(
             model=model, args=args, train_dataset=train_dataset,
             eval_dataset=eval_dataset, tokenizer=tokenizer,
@@ -350,8 +351,11 @@ class SpecRoute_Trainer(Seq2SeqTrainer):
                             feature_mat[index]
                         )
                     )
-                module.lora_q.lora_A.data /= (math.sqrt(3) * module.lora_q.lora_A.data.norm(dim=1, keepdim=True))
-                module.lora_v.lora_A.data /= (math.sqrt(3) * module.lora_v.lora_A.data.norm(dim=1, keepdim=True))
+                # V8 C5 normalization: scale rows to have norm = sqrt(3) (matching InfLoRA convention)
+                # Eigenvectors from C5 are already orthonormal unit vectors in null-space.
+                # We scale magnitude to sqrt(3) to match InfLoRA's Kaiming-like initialization scale.
+                module.lora_q.lora_A.data *= (math.sqrt(3) / module.lora_q.lora_A.data.norm(dim=1, keepdim=True).clamp(min=1e-8))
+                module.lora_v.lora_A.data *= (math.sqrt(3) / module.lora_v.lora_A.data.norm(dim=1, keepdim=True).clamp(min=1e-8))
                 i += 1
 
         # Free GPM bases — no longer needed after projection
@@ -390,7 +394,7 @@ class SpecRoute_Trainer(Seq2SeqTrainer):
                 else:
                     labels = None
                 outputs = self.model(**inputs)
-                if step > 100:  # 100 batches sufficient for stable SVD
+                if step >= 200:  # 200 batches for stable GPM SVD (IDEA §9)
                     break
         print('end get representation')
 

improve_gainlora/src/run_t5.py

@@ -191,7 +191,7 @@ class ModelArguments:
         metadata={"help": "Fraction of training steps before enabling entropy loss (C4, disabled in V7)."},
     )
     n_batches_c5: Optional[int] = field(
-        default=200,
+        default=100,
         metadata={"help": "Number of training batches for C5 activation covariance collection."},
     )
 
@@ -1070,9 +1070,8 @@ def main():
 
         trainer.model.encoder.is_inference = True
 
-        # SpecRoute V3: precompute SVD of current task's LoRA for symmetric inference routing
-        if training_args.model_name == 'specroute' and hasattr(trainer.model.encoder, 'prepare_inference_routing'):
-            trainer.model.encoder.prepare_inference_routing()
+        # V8: prepare_inference_routing() removed — A_t rows are the routing signatures.
+        # No SVD post-training needed (Lemma 1 + Theorem 2 in IDEA_Overall.md).
 
         # Collect attention weights for GainLoRA KL replay (not needed for SpecRoute)
         if training_args.model_name != 'specroute':

improve_gainlora/src/t5_specroute.py

@@ -1,14 +1,17 @@
 # coding=utf-8
 """
-SpecRoute: T5 model with Spectral-Geometric Routing for Continual LoRA Learning.
-
-Replaces GainLoRA's learned gating (Trans_input + prompt_key) with spectral
-projection-based routing using SVD signatures from frozen LoRA weights.
-
-Key changes from t5_gainlora_inflora.py:
-- Removed: Trans_input, prompt_key, previous_trans_input, previous_prompts_keys
-- Added: Spectral signatures + projection-based routing (softmax over weighted projection fits)
-- Removed: memory_replay (no KL loss on gating since routing is parameter-based)
+SpecRoute V8: T5 model with Spectral-Geometric Routing for Continual LoRA Learning.
+
+Core insight (Routing-Protection Duality): orthogonal subspace protection (GPM)
+and task-discriminative routing are dual manifestations of the same spectral structure.
+Solving one automatically solves the other.
+
+V8 key design choices (from IDEA_Overall.md):
+- C1: A_t rows ARE the spectral signatures — no SVD of B_t A_t needed
+- C2: A-row affinity for BOTH training and inference (symmetric metric space)
+- C5: Data-informed init via Constrained PCA in null-space (Q C_t Q eigenvectors)
+- Removed: Trans_input, prompt_key, memory_replay, prepare_inference_routing()
+- Removed: SVD sigma^2-weighted inference (train-inference mismatch source)
 """
 
 import copy
@@ -61,56 +64,22 @@ logger = logging.get_logger(__name__)
 
 # ===================== Spectral Routing Functions =====================
 
-def _thin_svd_low_rank(B, A, device=None):
-    """
-    Compute SVD of delta_W = B @ A efficiently using QR decomposition.
-
-    Since delta_W = B(m×r) @ A(r×n) has rank ≤ r (typically 8), full SVD
-    of the m×n matrix is wasteful. Instead, we decompose via two small QR
-    factorizations and one tiny r×r SVD:
-      1. QR(B) → Q_B(m×r), R_B(r×r)
-      2. QR(A^T) → Q_A(n×r), R_A(r×r)
-      3. delta_W = Q_B @ (R_B @ R_A^T) @ Q_A^T
-      4. SVD(R_B @ R_A^T) → U_s, S, Vh_s   (all r×r)
-      5. Vt = Vh_s @ Q_A^T   (r×n)
-
-    Mathematically identical to full SVD, ~2000× faster for r=8, m=n=512.
-
-    Args:
-        B: (m, r) float tensor — lora_B weights
-        A: (r, n) float tensor — lora_A weights
-        device: target device for output (None = same as input)
-
-    Returns:
-        S:  (r,)    singular values (descending)
-        Vt: (r, n)  right singular vectors transposed
-    """
-    try:
-        Q_B, R_B = torch.linalg.qr(B)       # Q_B: (m, r), R_B: (r, r)
-        Q_A, R_A = torch.linalg.qr(A.T)     # Q_A: (n, r), R_A: (r, r)
-        small = R_B @ R_A.T                  # (r, r) — tiny matrix
-        _, S, Vh_s = torch.linalg.svd(small, full_matrices=False)
-        Vt = Vh_s @ Q_A.T                   # (r, n)
-    except RuntimeError:
-        # GPU linalg failure → CPU fallback
-        B_cpu, A_cpu = B.cpu(), A.cpu()
-        Q_B, R_B = torch.linalg.qr(B_cpu)
-        Q_A, R_A = torch.linalg.qr(A_cpu.T)
-        small = R_B @ R_A.T
-        _, S, Vh_s = torch.linalg.svd(small, full_matrices=False)
-        Vt = Vh_s @ Q_A.T
-        target = device if device is not None else B.device
-        S, Vt = S.to(target), Vt.to(target)
-    return S, Vt
+# NOTE: _thin_svd_low_rank() was REMOVED in V8.
+# Theorem 2 (C5 Routing Optimality) proves A_t rows with C5 init are already
+# the optimal routing directions. SVD of B_t A_t only adds sigma^2-weighting
+# from B optimization artifacts with no theoretical guarantee. See IDEA §3.6.
 
 
 def compute_spectral_signatures(model, config):
     """
-    Compute spectral signatures from all LoRA branches after training.
-    For each LoRA layer, computes exact SVD of B@A and stores top-r right
-    singular vectors (input directions) and singular values (importance).
+    V8: Store frozen A-row matrices as routing signatures (no SVD needed).
+
+    Theorem 2 (C5 Routing Optimality) proves that A_t rows with C5 init are
+    already the optimal routing directions in the null-space. SVD of B_t A_t
+    only adds sigma^2-weighting from B optimization artifacts (no theoretical
+    guarantee). A-row routing is exact, symmetric, and eliminates prepare_inference_routing().
 
-    Returns dict mapping layer keys to {'V': tensor, 'sigma': tensor}.
+    Returns dict mapping layer keys to {'A': tensor (r, d_model)}.
     """
     signatures = {}
     with torch.no_grad():
@@ -119,36 +88,20 @@ def compute_spectral_signatures(model, config):
             attn = model.encoder.block[j].layer[0].SelfAttention
             for name, lora in [('q', attn.lora_q), ('v', attn.lora_v)]:
                 A = lora.lora_A.data.float()
-                B = lora.lora_B.data.float()
-                r = lora.r
-                S, Vt = _thin_svd_low_rank(B, A)
                 signatures[f'enc.{j}.{name}'] = {
-                    'V': Vt[:r].cpu(),    # (r, d_model)
-                    'sigma': S[:r].cpu()  # (r,)
+                    'A': A.cpu(),  # (r, d_model) — frozen routing directions
                 }
         # Decoder self-attention layers
         for j in range(config.num_decoder_layers):
             attn = model.decoder.block[j].layer[0].SelfAttention
             for name, lora in [('q', attn.lora_q), ('v', attn.lora_v)]:
                 A = lora.lora_A.data.float()
-                B = lora.lora_B.data.float()
-                r = lora.r
-                S, Vt = _thin_svd_low_rank(B, A)
-                signatures[f'dec.{j}.self.{name}'] = {
-                    'V': Vt[:r].cpu(),
-                    'sigma': S[:r].cpu()
-                }
+                signatures[f'dec.{j}.self.{name}'] = {'A': A.cpu()}
             # Decoder cross-attention layers
             attn_cross = model.decoder.block[j].layer[1].EncDecAttention
             for name, lora in [('q', attn_cross.lora_q), ('v', attn_cross.lora_v)]:
                 A = lora.lora_A.data.float()
-                B = lora.lora_B.data.float()
-                r = lora.r
-                S, Vt = _thin_svd_low_rank(B, A)
-                signatures[f'dec.{j}.cross.{name}'] = {
-                    'V': Vt[:r].cpu(),
-                    'sigma': S[:r].cpu()
-                }
+                signatures[f'dec.{j}.cross.{name}'] = {'A': A.cpu()}
     return signatures
 
 
@@ -159,8 +112,8 @@ class T5Stack(T5PreTrainedModel):
     T5Stack with spectral routing instead of learned gating.
 
     Instead of Trans_input + prompt_key (GainLoRA), routing weights are computed
-    from projection fits between input embeddings and spectral signatures
-    (SVD of frozen LoRA weights from previous tasks).
+    from A-row affinity between input embeddings and spectral signatures
+    (A-row matrices of frozen LoRA A from previous tasks — V8, no SVD needed).
     """
 
     def __init__(self, config, embed_tokens=None, prompt_config=None):
@@ -184,16 +137,12 @@ class T5Stack(T5PreTrainedModel):
             self.spectral_signatures = []  # List[dict] — one dict per old task
             self.routing_temperature = prompt_config.get('attn_temperature', 1.0)
 
-            # Adaptive training bias: β = T·ln(α·n_old/(1−α))
-            # Ensures current task gets consistent routing weight ~α regardless
+            # Adaptive training bias: beta = T * ln(alpha * n_old / (1 - alpha))
+            # Ensures current task gets consistent routing weight ~alpha regardless
             # of total number of tasks (fixes softmax dilution with constant bias).
-            # At inference, uses symmetric SVD-based routing instead (no bias needed).
+            # At inference, same A-row formula without bias (V8 symmetric routing).
             self._target_routing_alpha = prompt_config.get('target_routing_alpha', 0.8)
 
-            # Precomputed SVD of current task's LoRA for symmetric inference routing.
-            # Populated by prepare_inference_routing() before prediction.
-            self._current_task_svd = None
-
             # For inference logging
             self.all_attn_weights = []
             self.key_attention_weights = None
@@ -214,15 +163,22 @@ class T5Stack(T5PreTrainedModel):
 
     def compute_spectral_routing(self, avg_inputs_embeds):
         """
-        Compute routing weights using spectral projection fits.
-
-        Training mode: A-row fit + adaptive bias for current task (cold-start safe).
-        Inference mode: SVD-based fit for ALL tasks (symmetric, no bias needed).
-
-        The adaptive bias β = T·ln(α·n_old/(1−α)) ensures the current task gets
-        routing weight ≈ α regardless of the number of previous tasks, compensating
-        for softmax dilution. At inference, all tasks use the same σ²-weighted
-        Rayleigh quotient (SVD fit), eliminating the train-test asymmetry.
+        V8: A-row routing for ALL tasks (training and inference).
+
+        Theory (IDEA_Overall.md §3):
+        - Lemma 1 (Differential Projection): ||A_t h||^2 = ||A_t Q_{t-1} h||^2
+          → routing only sees null-space component, cross-task leakage <= 0.005*tr(C_s)/r
+        - Corollary B (Reverse direction): alpha_s(h_t) = ||A_s P_{t-1} h_t||^2/(r||h_t||^2)
+          → small when task t has most variance in null-space (different domain)
+          → same-domain difficulty is a fundamental limit of ALL task-free CL methods
+        - Theorem 2 (C5 Routing Optimality): C5 init maximizes E[alpha_t(h)]
+          over all A_t in the restricted Stiefel manifold
+        - C5 advantage over random: d'/r * PEV_r(C_tilde) ≈ 44x at task 8 (T5-small)
+
+        Training: A-row fit + adaptive bias β(n) for current task.
+          β(n) is a cold-start mechanism (B_t=0 initially, gradient needs routing).
+          NOT a routing quality booster. Symmetry = same metric formula, not same distribution.
+        Inference: A-row fit for ALL tasks. No prepare_inference_routing().
 
         Args:
             avg_inputs_embeds: (B, 1, d_model) — averaged input token embeddings
@@ -235,75 +191,41 @@ class T5Stack(T5PreTrainedModel):
 
         fits = []
 
+        # === CURRENT TASK: A-row fit (+ adaptive bias during training) ===
+        current_fits_layers = []
+        for block in self.block:
+            attn = block.layer[0].SelfAttention
+            for lora in [attn.lora_q, attn.lora_v]:
+                A = lora.lora_A.data.float()  # (r, d_model) — frozen after C5 init
+                r = lora.r
+                A_h = A.to(h.device, dtype=h.dtype)
+                proj = torch.matmul(h, A_h.T)  # (B, 1, r)
+                fit = (proj ** 2).sum(dim=-1) / (r * h_norm_sq)  # (B, 1)
+                current_fits_layers.append(fit)
+        current_fit = torch.stack(current_fits_layers).mean(dim=0)  # (B, 1)
+
         if self.training:
-            # === TRAINING MODE: A-row fit + adaptive bias for current task ===
-            # A rows give stable non-zero signal even when B=0 (cold-start).
-            current_fits_layers = []
-            for block in self.block:
-                attn = block.layer[0].SelfAttention
-                for lora in [attn.lora_q, attn.lora_v]:
-                    A = lora.lora_A.data.float()  # (r, d_model) — frozen
-                    r = lora.r
-                    A_h = A.to(h.device, dtype=h.dtype)
-                    proj = torch.matmul(h, A_h.T)  # (B, 1, r)
-                    fit = (proj ** 2).sum(dim=-1) / (r * h_norm_sq)  # (B, 1)
-                    current_fits_layers.append(fit)
-            current_fit = torch.stack(current_fits_layers).mean(dim=0)  # (B, 1)
-
-            # Adaptive training bias: β = T·ln(α·n_old/(1−α))
+            # Adaptive training bias: beta = T * ln(alpha * n_old / (1 - alpha))
+            # Compensates for softmax dilution as task count grows.
             n_old = len(self.spectral_signatures)
             if n_old > 0:
                 alpha = self._target_routing_alpha
                 beta = self.routing_temperature * math.log(alpha * n_old / (1.0 - alpha))
                 current_fit = current_fit + beta
-            fits.append(current_fit)
-        else:
-            # === INFERENCE MODE: SVD-based spectral routing (symmetric) ===
-            if self._current_task_svd is not None:
-                cur_fits = []
-                for key, sig_data in self._current_task_svd.items():
-                    if not key.startswith('enc.'):
-                        continue
-                    V = sig_data['V'].to(h.device, dtype=h.dtype)
-                    sigma = sig_data['sigma'].to(h.device, dtype=h.dtype)
-                    proj = torch.matmul(h, V.T)
-                    sigma_sq = sigma ** 2
-                    sigma_sq_sum = sigma_sq.sum() + 1e-8
-                    weighted_proj = (proj ** 2 * sigma_sq.unsqueeze(0).unsqueeze(0)).sum(dim=-1)
-                    fit = weighted_proj / (sigma_sq_sum * h_norm_sq)
-                    cur_fits.append(fit)
-                if cur_fits:
-                    current_fit = torch.stack(cur_fits).mean(dim=0)
-                else:
-                    current_fit = torch.zeros(h.shape[0], 1, device=h.device, dtype=h.dtype)
-            else:
-                # Fallback: A-row fit (before prepare_inference_routing() is called)
-                current_fits_layers = []
-                for block in self.block:
-                    attn = block.layer[0].SelfAttention
-                    for lora in [attn.lora_q, attn.lora_v]:
-                        A = lora.lora_A.data.float()
-                        r = lora.r
-                        A_h = A.to(h.device, dtype=h.dtype)
-                        proj = torch.matmul(h, A_h.T)
-                        fit = (proj ** 2).sum(dim=-1) / (r * h_norm_sq)
-                        current_fits_layers.append(fit)
-                current_fit = torch.stack(current_fits_layers).mean(dim=0)
-            fits.append(current_fit)
-
-        # Old tasks: σ²-weighted spectral affinity (Rayleigh quotient)
+        fits.append(current_fit)
+
+        # === OLD TASKS: A-row fit using saved A matrices ===
+        # Lemma 1 (Differential Projection): ||A_t h||^2 = ||A_t Q_{t-1} h||^2
+        # Cross-task leakage <= 0.005 * tr(C_s)/r with tau_GPM = 0.995
         for sig_dict in self.spectral_signatures:
             task_fits = []
             for key, sig_data in sig_dict.items():
                 if not key.startswith('enc.'):
                     continue
-                V = sig_data['V'].to(h.device, dtype=h.dtype)
-                sigma = sig_data['sigma'].to(h.device, dtype=h.dtype)
-                proj = torch.matmul(h, V.T)
-                sigma_sq = sigma ** 2
-                sigma_sq_sum = sigma_sq.sum() + 1e-8
-                weighted_proj = (proj ** 2 * sigma_sq.unsqueeze(0).unsqueeze(0)).sum(dim=-1)
-                fit = weighted_proj / (sigma_sq_sum * h_norm_sq)
+                A = sig_data['A'].to(h.device, dtype=h.dtype)  # (r, d_model)
+                r = A.shape[0]
+                proj = torch.matmul(h, A.T)  # (B, 1, r)
+                fit = (proj ** 2).sum(dim=-1) / (r * h_norm_sq)
                 task_fits.append(fit)
             if task_fits:
                 task_fit = torch.stack(task_fits).mean(dim=0)
@@ -311,38 +233,17 @@ class T5Stack(T5PreTrainedModel):
                 task_fit = torch.zeros(h.shape[0], 1, device=h.device, dtype=h.dtype)
             fits.append(task_fit)
 
-        # Stack: (B, n_tasks)
+        # Stack: (B, n_tasks) — all tasks use same A-row metric space
         fit_scores = torch.cat(fits, dim=1)  # (B, n_tasks)
-
-        # Softmax routing with temperature
         weights = torch.softmax(fit_scores / self.routing_temperature, dim=1)  # (B, n_tasks)
 
         return weights.unsqueeze(2)  # (B, n_tasks, 1)
 
-    def prepare_inference_routing(self):
-        """
-        Precompute SVD of current task's LoRA for symmetric inference routing.
-
-        Must be called after training (B≠0) and before prediction. Computes
-        spectral signatures from the current (most recently trained) task's
-        LoRA weights, enabling the same σ²-weighted Rayleigh quotient formula
-        for all tasks during inference.
-        """
-        sigs = {}
-        with torch.no_grad():
-            for j, block in enumerate(self.block):
-                attn = block.layer[0].SelfAttention
-                for name, lora in [('q', attn.lora_q), ('v', attn.lora_v)]:
-                    A = lora.lora_A.data.float()
-                    B = lora.lora_B.data.float()
-                    r = lora.r
-                    S, Vt = _thin_svd_low_rank(B, A)
-                    sigs[f'enc.{j}.{name}'] = {
-                        'V': Vt[:r].cpu(),
-                        'sigma': S[:r].cpu()
-                    }
-        self._current_task_svd = sigs
-        print(f"[SpecRoute] Prepared inference routing: {len(sigs)} encoder SVD signatures for current task")
+    # prepare_inference_routing() REMOVED in V8.
+    # Reasoning: Lemma 1 + Theorem 2 prove A_t rows (with C5 init) are already the
+    # optimal routing directions. SVD of B_t A_t only adds sigma^2-weighting from
+    # B optimization artifacts, causing train-inference mismatch. A_t is the signature.
+    # Eliminates O(d*r^2) SVD overhead per task per layer after training.
 
     def parallelize(self, device_map=None):
         self.device_map = (