new change

comprehensive_methodology.md

@@ -0,0 +1,663 @@
+# PHÂN TÍCH PHÊ BÌNH VÀ HỆ THỐNG HÓA Ý TƯỞNG TỪ DISCUSSTION.TXT
+## Từ lập luận thô → Kiểm chứng → Phản biện → Đề xuất phương pháp luận
+
+**Ngày**: 9 tháng 3, 2026  
+**Phương pháp**: Trích xuất các ý tưởng của người nghiên cứu từ nửa sau discusstion.txt → tách khỏi flattery AI → kiểm chứng từng ý bằng toán + literature → phản biện → hệ thống hóa thành methodology
+
+**Nguyên tắc**: Tài liệu này *không* re-explain SpecRoute hay GainLoRA. Tài liệu này tập trung vào **các ý tưởng gốc của bạn** — phân tích cái đúng, cái sai, cái bị AI overstate, và xây dựng methodology từ phần solid.
+
+---
+
+## I. PROBLEM DEFINITION — Không Phải "Improve Routing", Mà Là "What Is The Right Problem?"
+
+### 1.1 Setting chính thức
+
+Cho:
+- Pre-trained backbone $W_0 \in \mathbb{R}^{d_{out} \times d_{in}}$ (frozen)
+- Chuỗi $T$ tasks đến tuần tự: $\mathcal{T}_1, \mathcal{T}_2, ..., \mathcal{T}_T$
+- Mỗi task $\mathcal{T}_t$ có dataset $\mathcal{D}_t = \{(x_i^{(t)}, y_i^{(t)})\}$ chỉ available trong giai đoạn train task $t$
+
+Constraints:
+- **Zero-replay**: Khi train task $t$, không có $\mathcal{D}_{t'}, t' < t$
+- **No task-ID at inference**: Tại test time, không biết $x$ thuộc task nào
+- **Expandable LoRA**: Mỗi task $t$ thêm LoRA branch $\Delta W_t = B_t A_t$ (rank $r$), freeze sau khi train xong
+
+Sau $T$ tasks, forward pass cho input $h$:
+
+$$\text{output}(h) = W_0 h + \sum_{t=1}^{T} w_t(h) \cdot B_t A_t h$$
+
+trong đó $w_t(h) \in [0,1]$ là routing weight.
+
+### 1.2 Ba sub-problems không thể tách rời
+
+Bất kỳ phương pháp nào trong setting này đều phải giải **đồng thời** 3 bài toán:
+
+| Sub-problem | Đầu vào | Đầu ra | Constraint |
+|-------------|---------|--------|------------|
+| **R: Routing** | Input $h$, expert set $\{\Delta W_t\}$ | Weights $w(h) \in \mathbb{R}^T$ | No task-ID, computable from $h$ alone |
+| **P: Protection** | New task gradient $\nabla_{\theta} \mathcal{L}_T$ | Projected gradient $\tilde{\nabla}$ | Old experts' functionality preserved |
+| **A: Allocation** | Available subspace $M^{\perp}$, new task demand | How much of $M^{\perp}$ to use | Fair capacity across tasks |
+
+**Tại sao không thể tách rời?**
+
+Routing quality phụ thuộc vào expert isolation (P), vì nếu new task can thiệp old expert → routing signal bị corrupt. Expert isolation phụ thuộc vào subspace budget (A), vì tight orthogonal constraint → good isolation nhưng limited capacity. Capacity limitation ảnh hưởng chất lượng expert → ảnh hưởng routing relevance.
+
+Vòng tròn: **R ← P ← A ← R**.
+
+### 1.3 Tại sao đây KHÔNG phải bài toán MoE
+
+Mixture of Experts (trong LLM) và expandable LoRA CL trông giống nhau (nhiều expert, cần routing) nhưng khác biệt bản chất:
+
+| Aspect | MoE (LLM) | Expandable LoRA CL |
+|--------|-----------|---------------------|
+| Expert creation | Đồng thời (jointly trained) | Tuần tự (each expert only sees its task) |
+| Routing | Learned gating, optimized end-to-end | Cannot learn across tasks (forgetting risk) |
+| Load balancing | Desirable (use all experts equally) | NOT desirable (want SELECTIVE activation) |
+| Expert overlap | Expected, managed by auxiliary losses | Constrained by orthogonal projection |
+| Data at routing time | All data available | Zero-replay → only current data |
+
+Hệ quả: **Mọi technique của MoE routing (OT balancing, learned gating, regularization) đều không directly applicable.** Cần routing mechanism riêng cho CL setting.
+
+---
+
+## II. INFORMATION LANDSCAPE — Cái Gì Hợp Lệ, Cái Gì Vi Phạm?
+
+### 2.1 Taxonomy of available information
+
+Sau khi train xong task $t$, trước khi quên $\mathcal{D}_t$, ta có thể extract và lưu:
+
+| Loại thông tin | Ví dụ | Hợp lệ? | Lý do |
+|---------------|-------|---------|-------|
+| **Model parameters** | Frozen $A_t, B_t$, GPM bases $U_t$ | ✅ | Là artifact của quá trình train, không phải data |
+| **Derived quantities from parameters** | SVD of $\Delta W_t = U_t \Sigma_t V_t^T$ | ✅ | Computed from model params alone |
+| **Data statistics** | Mean features $\mu_t$, covariance $\Sigma_t$ | ❌ | Summary of $\mathcal{D}_t$ → violates zero-replay |
+| **Distribution parameters** | vMF $(\mu_t, \kappa_t)$ | ❌ | Fitted on $\mathcal{D}_t$ → violates zero-replay |
+| **Auxiliary learned params** | Prompt keys, trans_input MLPs | ⚠️ Hợp lệ nhưng có forgetting risk | Phải train → gradient update có thể corrupt old |
+
+### 2.2 Phân biệt tinh tế: GPM bases vs data statistics
+
+GPM computation:
+1. Forward pass data qua LoRA → collect input covariance matrix $C_t \in \mathbb{R}^{d \times d}$
+2. SVD: $C_t = U_t S_t V_t^T$ → lấy principal directions $U_t[:, :k]$
+3. Lưu $U_t[:, :k]$ (directions), BỎ $S_t$ (magnitudes)
+
+Tại sao h��p lệ? Vì GPM bases encode **hướng (directions)** mà LoRA input hoạt động — đây là property của model + data combination mà cần forward pass để extract. Tuy nhiên, chỉ giữ lại **subspace** (span of directions), không giữ **distribution** (how data distributes within subspace).
+
+**Lằn ranh đỏ**: Nếu một method lưu mean feature vector $\mu_t = \frac{1}{N}\sum_i f(x_i^{(t)})$ → đây là data statistic, vi phạm zero-replay. Feature Distributions paper (ICML 2025) làm chính xác điều này — cần position rõ ràng.
+
+### 2.3 Hệ quả cho routing design
+
+Từ Section 2.1, routing mechanism chỉ được sử dụng:
+1. **Frozen model parameters**: $\{A_t, B_t\}_{t=1}^{T}$, frozen backbone $W_0$
+2. **Quantities derived from frozen parameters**: SVD, norms, angles, etc.
+3. **Current input** $h$ tại inference time
+
+Routing **KHÔNG ĐƯỢC** sử dụng:
+1. Learned parameters (prompt keys, gating networks) → forgetting risk
+2. Data statistics từ old tasks (means, distributions) → zero-replay violation
+3. Task labels → no task-ID
+
+**Proposition 1**: *Trong zero-replay expandable LoRA CL, routing mechanism parameter-free (derived entirely from frozen expert weights + current input) là thỏa mãn tất cả constraints.*
+
+*Lưu ý*: Đây không có nghĩa learned routing "sai" — GainLoRA dùng learned params + GPM protection cho routing params → hợp lệ nhưng cần thêm mechanism (GPM for trans_input, per-step projection). Parameter-free routing loại bỏ nhu cầu các mechanism phụ này.
+
+---
+
+## III. EXPERT CHARACTERIZATION — Từ Frozen Weights Đến Task Identity
+
+### 3.1 Fundamental question: "Expert này LÀM GÌ?"
+
+Mỗi frozen expert $\Delta W_t = B_t A_t \in \mathbb{R}^{d_{out} \times d_{in}}$ thực hiện:
+
+$$h \mapsto \Delta W_t h = B_t (A_t h)$$
+
+Từ SVD: $\Delta W_t = U_t \Sigma_t V_t^T$, decompose thành:
+- $V_t^T h$: **Project input** lên principal input directions (WHAT the expert "looks at")
+- $\Sigma_t$: **Scale** each projected component (HOW MUCH the expert cares)
+- $U_t$: **Map to output** space (WHERE the expert "writes")
+
+### 3.2 Spectral Signature: định nghĩa chính thức
+
+**Definition**: *Spectral signature* của expert $t$ là cặp:
+$$\mathcal{S}_t = \{(v_{t,i}, \sigma_{t,i})\}_{i=1}^{r}$$
+
+trong đó $v_{t,i}$ là right singular vector thứ $i$ (input direction), $\sigma_{t,i}$ là singular value tương ứng.
+
+**Tại sao dùng right singular vectors (V) chứ không phải left (U)?**
+
+Routing quyết định từ **input** $h$ → cần so sánh $h$ với **input directions** mà expert listens to. Right singular vectors $V_t$ chính là "input space receptors" của expert. Left singular vectors $U_t$ encode output space — relevant cho aggregation, không phải routing.
+
+### 3.3 Projection Fit: đo lường "expert $t$ relevant tới input $h$ bao nhiêu?"
+
+**Definition**: *Weighted Projection Fit* của expert $t$ cho input $h$:
+
+$$\text{fit}_t(h) = \frac{\sum_{i=1}^{r} \sigma_{t,i}^2 (v_{t,i}^T h)^2}{\sum_{i=1}^{r} \sigma_{t,i}^2 \cdot \|h\|^2}$$
+
+**Giải thích từng thành phần**:
+- $(v_{t,i}^T h)^2$: bao nhiêu "năng lượng" của $h$ nằm theo hướng $v_{t,i}$
+- $\sigma_{t,i}^2$: expert coi trọng hướng $v_{t,i}$ bao nhiêu (singular values lớn = modification mạnh)
+- $\|h\|^2$: chuẩn hóa
+- Tử số: tổng weighted projection energy
+- Mẫu số: maximum possible (khi $h$ nằm hoàn toàn trong span($V_t$))
+
+**Tính chất toán học**:
+- $\text{fit}_t(h) \in [0, 1]$
+- $\text{fit}_t(h) = 1 \iff h \in \text{span}(V_t)$ và $h$ aligned với dominant singular vectors
+- $\text{fit}_t(h) = 0 \iff h \perp \text{span}(V_t)$ (expert hoàn toàn không "thấy" input)
+
+**Liên hệ với Rayleigh Quotient**: 
+
+Nếu ta define $M_t = V_t \text{diag}(\sigma_t^2) V_t^T$ (PSD matrix), thì:
+
+$$\text{fit}_t(h) = \frac{h^T M_t h}{\text{tr}(M_t) \cdot h^T h}$$
+
+Đây chính là **normalized Rayleigh quotient** — công cụ chuẩn trong spectral theory, KHÔNG phải construction ad hoc.
+
+### 3.4 Tại sao projection fit là "đúng" cho bài toán này? (Và tại sao nó có thể "sai")
+
+**Tại sao đúng (theoretical argument)**:
+
+1. **Respect expert structure**: fit_t(h) được derive trực tiếp từ SVD of expert weights — encode what the expert WAS TRAINED to do.
+
+2. **Per-input**: Mỗi $h$ khác nhau cho projection fit khác nhau → supports mixed-task batches (crucial for real inference).
+
+3. **Parameter-free**: Computed from frozen quantities + current input → no forgetting risk.
+
+4. **Discriminative by construction**: Nếu experts operate trên orthogonal input subspaces (guaranteed approximately by GPM), thì:
+   $$\text{span}(V_t) \approx \perp \text{span}(V_{t'}), \quad t \neq t'$$
+   $$\Rightarrow \text{fit}_t(h) \text{ high} \implies \text{fit}_{t'}(h) \text{ low for } t' \neq t$$
+
+**Tại sao có thể sai (honest caveats)**:
+
+1. **Modification energy ≠ modification quality**: $\sigma_{t,i}^2 (v_{t,i}^T h)^2$ đo expert sẽ **modify mạnh** input $h$ theo hướng $v_{t,i}$. Nhưng modification mạnh KHÔNG có nghĩa là modification ĐÚNG. Expert có thể modify mạnh nhưng sai hướng output.
+
+   *Counter-argument*: Expert được train trên task $t$ → modification patterns encode task-relevant transformations. Projection fit cao → input tương tự training distribution → modification likely correct. Nhưng đây là **assumption**, không phải guarantee.
+
+2. **GPM orthogonality là approximate**: Thực tế, null-space projection không hoàn hảo. Subspace overlap nhỏ vẫn tồn tại → discriminative property bị weakened.
+
+3. **Mean pooling loses structure**: Cả GainLoRA và SpecRoute dùng `avg_inputs_embeds = mean(token_embeddings)` cho routing. Hai sequences có content khác nhau nhưng similar average → misrouted.
+
+---
+
+## IV. ROUTING MECHANISM — Derive from Principles
+
+### 4.1 Formulation: routing as maximum likelihood expert assignment
+
+Cho input $h$, routing weights $w(h) = [w_1(h), ..., w_T(h)]$ sao cho weighted combination approximates oracle:
+
+$$\sum_{t=1}^{T} w_t(h) \cdot \Delta W_t h \approx \Delta W_{\text{oracle}(h)} h$$
+
+trong đó $\text{oracle}(h)$ là expert "đúng" (trained on task mà $h$ thuộc về).
+
+### 4.2 Competitive routing (softmax) vs. Independent gating (sigmoid)
+
+**Independent gating (GainLoRA)**:
+
+$$w_t(h) = |2\sigma(4 \cdot \text{cos}(k_t, f_t(h))) - 1| \quad \in [0, 1] \text{ independently}$$
+
+*Ưu điểm*: Cho phép multiple experts fire đồng thời (useful nếu task mới overlap concept cũ).
+*Nhược điểm*: 
+- $\sum_t w_t(h) \neq 1$ → modification magnitude thay đổi theo số experts → scale instability
+- Tất cả experts có thể fire simultaneously → blurring
+- Cho phép $\sum_t w_t = 0$ → no modification at all → information loss
+
+**Competitive routing (softmax)**:
+
+$$w_t(h) = \frac{\exp(\text{fit}_t(h) / \tau)}{\sum_{t'} \exp(\text{fit}_{t'}(h) / \tau)}$$
+
+*Ưu điểm*:
+- $\sum_t w_t(h) = 1$ → constant modification energy → stable training
+- Forces **competition** → natural selection of most relevant expert(s)
+- $\tau \to 0$: hard routing (winner-take-all); $\tau \to \infty$: uniform averaging
+
+*Nhược điểm*:
+- Phải assign TOÀN BỘ weight → nếu input không thuộc task nào rõ ràng, vẫn phải "chọn"
+- Soft assignment → mỗi expert vẫn contribute dù ít → small interference
+
+**Trong CL setting**: Competitive routing phù hợp hơn vì:
+1. Tasks non-overlapping → mỗi input thuộc đúng 1 task → competition là đúng inductive bias
+2. Scale stability quan trọng hơn flexibility (15 tasks × 48 layers × 2 projections = many routing decisions)
+3. GPM already ensures expert isolation → independent gating phải học isolation from scratch (redundant)
+
+### 4.3 Thuật toán routing hoàn chỉnh
+
+```
+INPUT: h ∈ R^{d_model}  (averaged input embedding)
+       {S_t}_{t=1}^{T}  (spectral signatures: {V_t, σ_t} for each layer, each projection)
+       τ > 0             (temperature)
+
+FOR EACH ENCODER LAYER l, PROJECTION TYPE p ∈ {Q, V}:
+  FOR EACH TASK t = 1, ..., T:
+    V_t^{(l,p)}, σ_t^{(l,p)} = S_t[l, p]     # frozen spectral signature
+    proj = V_t^{(l,p)} h                       # project input onto expert's input space
+    fit_t^{(l,p)} = Σ_i σ²_{t,i} proj²_i / (Σ_i σ²_{t,i} · ||h||²)
+  END FOR
+
+  # Average fit across layers (global routing decision)
+  fit_t = mean over (l, p) of fit_t^{(l,p)}
+
+  # Competitive routing
+  w(h) = softmax([fit_1, ..., fit_T] / τ)
+
+RETURN w(h) ∈ R^T, Σ_t w_t = 1
+```
+
+**Lưu ý implementation**: Trong code hiện tại, fit scores được average chỉ over encoder layers (consistent — routing decision từ encoder, apply cho cả decoder). Decoder không tham gia routing computation.
+
+### 4.4 Special case: current task (đang train)
+
+Khi đang train task $T$, LoRA weights $(A_T, B_T)$ chưa frozen → chưa có spectral signature.
+
+**Giải pháp hiện tại**: Dùng rows of $A_T$ trực tiếp (thay vì SVD) — vì khi $r$ nhỏ (=4), $\Delta W = BA$ có rank $r$, và $A$ (khi normalized) approximate right singular vectors.
+
+**Giải thích**: Cho $\Delta W = BA$, nếu $B^T B = I$ (orthonormal), thì SVD of $\Delta W$ có $V = $ rows of $A$ (up to scaling). Trong thực tế $B^T B \neq I$, nên đây là approximation. Nhưng tại $r=4$, sai số nhỏ.
+
+**Hệ quả**: Fit cho current task:
+$$\text{fit}_T(h) = \frac{\|A_T h\|^2}{r \cdot \|h\|^2}$$
+
+(unweighted, vì chưa có singular values — treat all directions equally)
+
+---
+
+## V. ANTI-FORGETTING — Gradient Projection as Structural Isolation
+
+### 5.1 Bài toán: bảo vệ expert cũ khi train expert mới
+
+Khi train task $T$, gradient $\nabla_{A_T} \mathcal{L}_T$ có thể vô tình interfere với experts cũ thông qua **shared representation space** (cùng backbone $W_0$, cùng input space $\mathbb{R}^{d_{in}}$).
+
+Cách interference xảy ra:
+1. Input $h$ cho old task $t$ đi qua new expert $T$ (routing error)
+2. New expert $T$ train trên subspace overlap với old expert $t$ → modify shared directions
+
+### 5.2 GPM (Gradient Projection Memory) — mechanism chính
+
+**Idea**: Đảm bảo new LoRA operates trong **null-space** của old LoRA input subspaces.
+
+**Formalization**: Gọi $\mathcal{M}_t = \text{span}(U_t^{GPM})$ là input subspace that expert $t$ uses. Accumulated protected subspace:
+
+$$\mathcal{M}_{1:T-1} = \text{span}\left(\bigcup_{t=1}^{T-1} U_t^{GPM}\right)$$
+
+*(incremental — có thể compute bằng progressive SVD update)*
+
+New LoRA $A$ initialization:
+
+$$A_T = A_T^{init} - \text{Proj}_{\mathcal{M}_{1:T-1}}(A_T^{init})$$
+
+trong đó $\text{Proj}_{\mathcal{M}}(X) = U_{\mathcal{M}} U_{\mathcal{M}}^T X$ (project onto old subspace, then subtract).
+
+**Guarantee**: $A_T h \perp \mathcal{M}_{1:T-1}$ for all $h$, i.e., new LoRA input activations are orthogonal to old LoRA input activations.
+
+### 5.3 Per-step projection (cần thiết khi có learned routing params)
+
+GainLoRA có `trans_input` (MLP) và `prompt_key` là learned parameters → mỗi optimizer step phải project gradient update:
+
+```python
+# After optimizer.step():
+new_weight = current_weight - project_onto_old_subspace(current_weight - old_weight)
+```
+
+SpecRoute loại bỏ learned routing params → **KHÔNG CẦN** per-step projection cho routing. Chỉ cần GPM cho LoRA layers.
+
+**Hệ quả thực tế**: SpecRoute training loop đơn giản hơn significatv (no custom `_inner_training_loop`, no per-step weight manipulation, use base class trainer).
+
+### 5.4 Interaction giữa GPM và routing
+
+**Key insight**: GPM + spectral routing tạo **dual protection**:
+
+1. **GPM** (structural): New expert operates in orthogonal subspace → CAN'T interfere with old expert outputs
+2. **Spectral routing** (functional): Old-task inputs routed to old experts → WON'T be processed by new expert
+
+Individually, mỗi mechanism leaky:
+- GPM alone: orthogonality approximate, small interference possible
+- Routing alone: misrouting → wrong expert processes input
+
+Together: even if routing makes small mistake, GPM ensures interference is orthogonal (small). Even if GPM leaks slightly, routing directs input to correct expert.
+
+**Điều này nghĩa là**: Ta không cần perfect routing NOR perfect orthogonality — chỉ cần cả hai "tốt vừa đủ" để bù cho nhau.
+
+---
+
+## VI. SUBSPACE ALLOCATION — The Honest Hard Problem
+
+### 6.1 Bài toán capacity
+
+Input space $\mathbb{R}^{d_{in}}$ (d=1024 cho T5-Large). Mỗi task claim subspace of dimension ≤ $k_t$ cho GPM. Available null-space:
+
+$$\dim(\mathcal{M}_{1:T}^{\perp}) = d - \dim(\mathcal{M}_{1:T}) \geq d - \sum_{t=1}^{T} k_t$$
+
+Với $T = 15$ tasks, nếu mỗi task claim $k = 60$ dims: $1024 - 900 = 124$ dims remaining → **tight but feasible**.
+
+### 6.2 Threshold controls capacity
+
+GPM threshold $\epsilon$ controls $k_t$: higher threshold → more directions retained → larger $k_t$ → faster exhaustion.
+
+| Strategy | Formula | Effect |
+|----------|---------|--------|
+| **GainLoRA original** | $\epsilon_t = (1-\epsilon_0) \cdot t/T + \epsilon_0$ | Tăng dần → early tasks protect nhiều, late tasks protect ít. **Unfair**: early tasks "chiếm" subspace disproportionately. |
+| **Constant threshold** (SpecRoute) | $\epsilon_t = \epsilon_0, \forall t$ | Mỗi task protect cùng tỷ lệ. **Fair** nhưng vẫn linear depletion. |
+| **Importance-weighted** (NOT YET IMPLEMENTED) | $k_t$ allocated based on task complexity | Potentially optimal nhưng cần metric cho "importance" |
+
+### 6.3 Thẳng thắn: ESA (Elastic Subspace Allocation) hiện tại yếu
+
+Cái gọi là "ESA" trong SpecRoute thực tế chỉ là **thay đổi threshold schedule từ tăng dần sang hằng số**. Đây là hyperparameter change, không phải algorithmic contribution.
+
+**Nếu muốn ESA thực sự contributes**, cần ít nhất 1 trong:
+
+1. **Importance-weighted protection**: Singular values lớn ($\sigma_i$ lớn) → direction quan trọng cho expert → protect mạnh hơn. Singular values nhỏ → direction ít quan trọng → có thể release cho future tasks.
+
+   $$k_t = \min\{k : \sum_{i=1}^{k} \sigma_i^2 / \sum_j \sigma_j^2 \geq \epsilon\}$$
+
+   Hiện tại SpecRoute KHÔNG dùng singular values trong GPM decision — chỉ dùng input covariance SVD (khác).
+
+2. **Subspace recycling**: Detect directions trong $\mathcal{M}_{1:T-1}$ mà không expert nào dùng actively (routing weight luôn ~0) → release.
+
+3. **Adaptive threshold based on remaining capacity**: $\epsilon_t = f(d - \dim(\mathcal{M}_{1:t-1}))$ — threshold giảm khi subspace cạn → force later tasks to be more selective.
+
+**Status**: Cả 3 đều chưa implement. Bất kỳ cái nào nếu implement + ablation study → mới thực sự là contribution.
+
+---
+
+## VII. REPRESENTATION DRIFT — The Elephant in the Room
+
+### 7.1 Vấn đ��
+
+Spectral signatures $\{V_t, \sigma_t\}$ frozen → KHÔNG drift. Nhưng input embedding $h$ **CÓ drift**.
+
+**Cơ chế drift**: Trong encoder/decoder architecture, output of layer $l$:
+
+$$h^{(l+1)} = f\left(W_0^{(l)} h^{(l)} + \sum_t w_t(h^{(0)}) \cdot B_t^{(l)} A_t^{(l)} h^{(l)}\right)$$
+
+Khi thêm LoRA branch mới (task $T+1$), $w_t$ thay đổi (vì thêm competitor) → $h^{(l+1)}$ thay đổi → cascade qua layers.
+
+**Hệ quả**: Projection fit $\text{fit}_t(h)$ tại task $T+1$ khác so với task $T$, dù $V_t, \sigma_t$ giữ nguyên — vì $h$ thay đổi.
+
+### 7.2 So sánh: GainLoRA Handle drift bằng cách nào?
+
+GainLoRA dùng **previous_trans_input** — frozen MLP snapshot per task. Mỗi old task $t$ có riêng:
+
+$$f_t(x) = \text{SiLU}(W^{out}_t \cdot \text{SiLU}(W^{in}_t \cdot x))$$
+
+Routing: compute $f_t(\bar{h})$ rồi cosine similarity với frozen prompt_key $k_t$.
+
+**Ý tưởng**: Mỗi expert "nhìn" input qua "lăng kính" riêng (frozen MLP), expect cosine similarity patterns từ khi nó được train. Input có thể drift, nhưng prompt_key + trans_input snapshot là "matched pair" → somehow robust.
+
+**Nhưng vẫn leaky**: $\bar{h}$ (average input embedding) vẫn drift → $f_t(\bar{h})$ output khác → cosine similarity thay đổi. Frozen MLP + frozen key KHÔNG fully compensate cho input drift, chỉ reduce sensitivity.
+
+### 7.3 SpecRoute: explicitly acknowledge drift, don't pretend to solve it
+
+SpecRoute claim "zero routing forgetting" — chính xác hơn nên nói:
+
+> **"Zero parameter drift in routing mechanism"** — routing computation không có learned parameters nên không có parameter forgetting. Nhưng **representation drift** (thay đổi trong input embeddings do accumulated LoRA effects) vẫn tồn tại.
+
+**Tại sao representation drift có thể manageable (hypothesis, chưa proven)**:
+
+1. **LoRA rank nhỏ** ($r = 4$): Mỗi task chỉ modify rank-4 subspace. Total modification after 15 tasks: rank ≤ 60 (nếu orthogonal). Trong space 1024-dim, đây là ~6% dimensions → $h$ drift nhỏ.
+
+2. **GPM ensures orthogonal modification**: New task modify directions mà old task KHÔNG dùng → old task's projection space ít bị ảnh hưởng.
+
+3. **Backbone frozen**: $W_0$ không thay đổi → bulk of transformation stable. LoRA chỉ thêm residual.
+
+**Cần kiểm chứng thực nghiệm**:
+- Đo $\|\text{fit}_t(h) \text{ at task } T - \text{fit}_t(h) \text{ at task } t\|$ qua tasks
+- If drift small → hypothesis confirmed
+- If drift large → need explicit drift compensation mechanism
+
+### 7.4 Potential mitigation (chưa implement, nhưng well-defined)
+
+Nếu representation drift nghiêm trọng, options:
+
+1. **Snapshot input normalization**: Store $\mu_t^{proj}, \sigma_t^{proj}$ (mean/std of projected features at training time) → normalize at inference: $\hat{h} = (h - \mu_t^{proj})/\sigma_t^{proj}$ trước khi compute fit.
+   - **Vấn đề**: $\mu_t^{proj}$ là data statistic → có thể vi phạm zero-replay
+   - **Counter**: chỉ cần mean/std of LoRA LAYER output (model output, not data) — ambiguous territory
+
+2. **Relative fit**: Thay vì absolute fit $\text{fit}_t(h)$, dùng relative ranking. Distribution shift affects all fits similarly → ranking preserved.
+   - Softmax inherently does this partially (chỉ care ordering, not absolute values)
+
+3. **Self-calibration**: Periodically (every $k$ tasks), recompute spectral signatures on new LoRA weights.
+   - Nhưng old LoRA weights frozen → signatures không thay đổi → chỉ current task affected → not helpful
+
+---
+
+## VIII. THE COMPLETE ALGORITHM — End to End
+
+### 8.1 Training phase (cho task $T$)
+
+```
+INPUTS: Pre-trained backbone W₀
+        Frozen experts {(A_t, B_t)}_{t=1}^{T-1}
+        Spectral signatures {S_t}_{t=1}^{T-1}
+        GPM bases {M_{1:T-1}}
+        Training data D_T
+
+STEP 1 — Initialize new LoRA branch:
+  A_T^{init} ← random (Kaiming)
+  A_T ← A_T^{init} - Proj_{M_{1:T-1}}(A_T^{init})   # null-space projection
+  B_T ← 0 OR random (scaled small)
+
+STEP 2 — Train with routing:
+  for each batch (x, y) in D_T:
+    h̄ ← mean_pool(encoder_embed(x))                   # average input embedding
+    w(h̄) ← spectral_routing(h̄, {S_t}_{t<T}, A_T)     # Section IV.3
+    
+    for each layer l:
+      LoRA_output_l ← Σ_t w_t(h̄) · B_t^(l) A_t^(l) h^(l)  # weighted aggregation
+      h^(l+1) ← layer_l(h^(l)) + LoRA_output_l
+    
+    loss ← task_loss(output, y)
+    loss.backward()
+    
+    # Only A_T and B_T have gradients (others frozen)
+    optimizer.step()                                     # No per-step projection needed
+
+STEP 3 — End of task:
+  Freeze A_T, B_T
+  
+  # Compute spectral signature
+  ΔW_T = B_T @ A_T
+  U, Σ, V^T = SVD(ΔW_T)
+  S_T = {V[:r], Σ[:r]}                                 # store for future routing
+  
+  # Update GPM
+  Compute input covariance from forward passes
+  SVD → extract top-k directions
+  M_{1:T} = M_{1:T-1} ∪ new_directions
+  
+  Save: {A_T, B_T, S_T, M_{1:T}}
+  Discard: D_T (zero-replay)
+```
+
+### 8.2 Inference phase
+
+```
+INPUT: Test sample x (no task-ID)
+
+STEP 1 — Encode + route:
+  h̄ ← mean_pool(encoder_embed(x))
+  w(h̄) ← softmax([fit_1(h̄), ..., fit_T(h̄)] / τ)
+
+STEP 2 — Forward with routing:
+  for each layer l:
+    LoRA_output_l ← Σ_t w_t(h̄) · B_t^(l) A_t^(l) h^(l)
+    h^(l+1) ← layer_l(h^(l)) + LoRA_output_l
+
+STEP 3 — Decode output
+```
+
+### 8.3 Complexity analysis
+
+| Operation | GainLoRA | SpecRoute | Comment |
+|-----------|----------|-----------|---------|
+| Routing computation | $O(T \cdot d \cdot h_{mlp} + T \cdot d)$ | $O(T \cdot r \cdot d \cdot L)$ | SpecRoute: matrix-vector per layer per task |
+| Trainable routing params | $O(2 \cdot d \cdot h_{mlp} + d)$ per task | $0$ | SpecRoute: no routing params |
+| GPM targets | LoRA + trans_input + prompt_key | LoRA only | SpecRoute: simpler GPM |
+| Per-step overhead | Null-space projection for routing params | None | SpecRoute: standard training loop |
+| End-of-task | GPM + freeze + save snapshots | GPM + freeze + SVD | SVD is $O(d_{out} \cdot d_{in} \cdot r)$ — cheap for small $r$ |
+| Memory per task | $A_t, B_t$ + prompt_key + trans_input weights | $A_t, B_t$ + spectral sig $(V_t, \sigma_t)$ | Similar; spectral sig slightly smaller than trans_input |
+
+---
+
+## IX. POSITIONING IN THE LANDSCAPE
+
+### 9.1 So sánh phương pháp-agnostic
+
+| Criterion | GainLoRA | InfLoRA | MINGLE | Feature Dist. | TreeLoRA | SpecRoute |
+|-----------|----------|---------|--------|---------------|----------|-----------|
+| Routing type | Learned (MLP+key) | None (equal weight) | Learned (MoE gate) | Feature similarity | Gradient similarity | Spectral projection |
+| Routing forgetting risk | ⚠️ Managed by GPM | N/A | ⚠️ Managed by EMA | ❌ Stores data stats | ⚠️ Needs old gradients | ✅ Parameter-free |
+| Zero-replay | ✅ | ✅ | ✅ | ⚠️ Stores mean features | ⚠️ Needs gradient similarity | ✅ |
+| Anti-forgetting | GPM on LoRA + routing | Null-space init | OGP (orthogonal) | None explicit | None explicit | GPM on LoRA only |
+| Subspace allocation | Increasing threshold | Fixed threshold | EMA relaxation | N/A | N/A | Constant threshold |
+| Aggregation | Weighted sum (sigmoid) | Equal sum | Top-k MoE | Weighted sum | Tree selection | Weighted sum (softmax) |
+
+### 9.2 Novelty assessment (honest)
+
+**Clearly novel**:
+- Using SVD of frozen LoRA weights (not data features, not learned keys) as routing signal — no prior work does exactly this.
+- Elimination of ALL learned routing parameters in expandable LoRA CL — GainLoRA, MINGLE both require learned routing.
+
+**Partially novel**:
+- Weighted Rayleigh quotient for routing — Rayleigh quotient is textbook, but application to LoRA-CL routing is new.
+- Demonstrating that parameter-free routing + GPM = sufficient (if it works empirically) — conceptual contribution.
+
+**NOT novel**:
+- GPM/null-space projection — from InfLoRA, GainLoRA
+- Expandable LoRA architecture — from O-LoRA, InfLoRA, GainLoRA
+- Softmax routing in MoE-like structures — foundational MoE work
+- SVD as analysis tool for LoRA — SD-LoRA analyzes magnitude/direction
+
+**Closest competitor**: Feature Distributions (ICML 2025) — stores characterization per expert, uses similarity for routing. Key difference: they store data-level features (mean activation vectors), we store weight-level signatures (SVD of frozen params). They arguably violate or stretch zero-replay; we don't.
+
+---
+
+## X. WHAT NEEDS TO BE TRUE — Assumptions Checklist
+
+Mỗi assumption dưới đây CẦN PHẢI TRUE để methodology work. Mỗi cái cần empirical validation.
+
+### 10.1 Core assumptions
+
+| # | Assumption | Status | How to test |
+|---|-----------|--------|-------------|
+| A1 | Projection fit correlates with "correct expert" assignment | ❓ UNTESTED | Compute fit accuracy on task-boundary evaluation sets |
+| A2 | GPM+routing dual protection sufficient to prevent forgetting | ❓ UNTESTED | Compare forgetting metric with vs without routing |
+| A3 | Representation drift is small enough to not corrupt routing | ❓ UNTESTED | Track fit_t(h) variance across tasks for fixed test inputs |
+| A4 | mean_pool captures enough task-relevant signal for routing | ❓ UNTESTED | Compare with max_pool, CLS token, attention-weighted pool |
+| A5 | Softmax temperature τ is not overly sensitive | ❓ UNTESTED | τ ablation study |
+| A6 | rank r=4 is sufficient for spectral signatures to be discriminative | ❓ UNTESTED | r ablation |
+
+### 10.2 Implied assumptions (from GainLoRA that we inherit)
+
+| # | Assumption | Status |
+|---|-----------|--------|
+| A7 | T5-Large backbone generalizable to other architectures (LLaMA) | Partially tested (GainLoRA has LLaMA configs) |
+| A8 | 15 tasks is within GPM capacity for d=1024 | Expected (d=1024 >> 15*r*2) |
+| A9 | Q and V projections sufficient (not K) | From GainLoRA design, standard in LoRA literature |
+
+---
+
+## XI. EXPERIMENTAL VALIDATION PLAN
+
+### 11.1 What the experiments MUST show (not "nice to have")
+
+1. **SpecRoute vs. GainLoRA on identical setting**: Same data, same preprocessing, same evaluation protocol. Show routing improves OR at least matches.
+
+2. **Routing accuracy analysis**: On held-out validation sets of old tasks, what fraction of inputs are correctly routed (highest weight to correct expert)?
+
+3. **Forgetting curve**: Plot per-task performance after each subsequent task. Compare degradation.
+
+4. **Representation drift measurement**: For fixed test inputs from task $t$, track $\text{fit}_t(h)$ value as tasks $t+1, ..., T$ are added. If fit_t(h) drops significantly → drift is a problem.
+
+### 11.2 Ablation studies (ranked by importance)
+
+1. **Routing mechanism**: Spectral projection vs. prompt key (use SpecRoute architecture but GainLoRA routing) vs. random routing vs. uniform routing
+2. **Aggregation**: Softmax vs. sigmoid vs. top-1 hard routing  
+3. **Temperature τ**: Sweep from 0.01 to 10.0
+4. **Threshold ε**: 0.99, 0.995, 0.999, increasing schedule, constant
+5. **Mean pool vs. alternatives**: CLS token, max pool, attention-weighted
+
+### 11.3 Analysis experiments (for paper)
+
+1. **Visualization**: t-SNE of spectral signatures across tasks — do they cluster meaningfully?
+2. **Routing weight heatmaps**: Per-task routing weight distribution over time
+3. **Subspace dimension tracking**: Plot $\dim(\mathcal{M}_{1:t})$ vs $t$ — how fast does subspace fill?
+4. **Singular value spectra**: Plot $\sigma_1, ..., \sigma_r$ for each task — do they vary meaningfully?
+
+---
+
+## XII. HONEST ASSESSMENT — Strengths and Weaknesses of This Methodology
+
+### 12.1 Strengths
+
+1. **Principled derivation**: Method follows from constraints (zero-replay, no task-ID) → information landscape → natural choice. Not "proposed then justified".
+
+2. **Simplicity**: Removes learned routing entirely. Training loop simplifies. Fewer hyperparameters. Fewer mechanisms to maintain.
+
+3. **Architectural alignment**: Routing signal comes FROM the experts themselves — not from separate parameters that might disagree with expert function.
+
+4. **Dual protection theory**: GPM + routing => redundant safety mechanisms that compensate for each other's imperfections.
+
+### 12.2 Weaknesses
+
+1. **No empirical validation yet**: The entire framework is theoretical. Until experiments confirm, every section above is hypothesis.
+
+2. **Representation drift is real, unaddressed**: We acknowledge it, hypothesize it's small, but don't solve it. If drift is large, the methodology needs significant revision.
+
+3. **ESA is weak**: Subspace allocation is essentially a hyperparameter. This is the weakest part of the framework.
+
+4. **Mean pooling is a bottleneck**: Entire routing decision based on 1 vector (average embedding). Rich sequence information lost.
+
+5. **Modification energy ≠ quality**: Fundamental gap between "expert will modify input strongly" and "expert will modify input correctly". This is assumption, not theorem.
+
+6. **Only tested on NLP**: Setting is specific (T5, NLP tasks). Generalization to vision/multimodal unknown.
+
+### 12.3 What would KILL this approach
+
+Red flags that would indicate fundamental issues:
+- If routing accuracy is not significantly better than random → spectral signatures are not discriminative  
+- If performance degrades significantly on later tasks (>2% compared to task-specific training) → GPM + routing dual protection insufficient
+- If representation drift causes >10% routing accuracy drop between task $t$ and task $T$ → need drift compensation
+- If τ has narrow "sweet spot" and small deviations cause large performance changes → method not robust
+
+---
+
+## XIII. RELATIONSHIP TO method.md (RTA Framework)
+
+`method.md` describes RTA (Riemannian Topological Alignment) — a DIFFERENT direction involving:
+- Bingham distributions (anisotropic) on hypersphere
+- Riemannian KL divergence for topology preservation  
+- Parallel transport for drift correction
+
+**Comparison**:
+
+| Aspect | SpecRoute (this doc) | RTA (method.md) |
+|--------|---------------------|-----------------|
+| Paradigm | Expandable LoRA + routing | Feature distribution preservation |
+| Anti-forgetting | GPM (subspace isolation) | Riemannian distillation + topology lock |
+| Drift handling | Acknowledge but don't solve | Parallel transport correction |
+| Data requirement | Zero-replay compliant | Requires distribution parameters (violates?) |
+| Maturity | Code exists, needs experiments | Purely theoretical |
+| Complexity | Low (SVD + softmax) | High (manifold computation, Bingham fitting) |
+
+**Key question**: RTA addresses representation drift explicitly (via parallel transport). Could elements of RTA complement SpecRoute's weakness? Possibly — but would need to verify that Bingham fitting doesn't violate zero-replay, and that parallel transport is tractable for 1024-dim space.
+
+---
+
+## XIV. CONCLUSION — WHAT THIS METHODOLOGY IS AND ISN'T
+
+### What it IS:
+- A principled framework that starts from problem constraints and derives method choices
+- An architecture-agnostic approach to routing in expandable LoRA CL
+- A clear specification of what information is legitimate under zero-replay
+- An honest assessment of assumptions, limitations, and open problems
+
+### What it ISN'T:
+- A proven method (no experiments)
+- A complete solution to all CL problems (subspace allocation, representation drift still open)
+- A guaranteed improvement over GainLoRA (empirical question)
+- A paper-ready manuscript (needs experiments, related work section, polished writing)
+
+### Priority actions (ordered):
+1. **Run SpecRoute vs. GainLoRA on SuperNI Order 1** — if doesn't match or beat GainLoRA, revisit fundamentals
+2. **Measure routing accuracy** — confirm spectral signatures are actually discriminative  
+3. **Measure representation drift** — confirm it's manageable
+4. **Develop ESA properly** — importance-weighted protection
+5. **Write paper** — only after 1-4 confirm methodology

critical_analysis_report.md

@@ -0,0 +1,245 @@
+# BÁO CÁO PHÂN TÍCH PHÊ BÌNH: Quá Trình Xây Dựng Ý Tưởng SpecRoute
+## Đánh giá trung thực các lập luận trong discusstion.txt và các tài liệu liên quan
+
+**Ngày**: 9 tháng 3, 2026  
+**Phương pháp**: Đọc toàn bộ tài liệu → tách lập luận của người nghiên cứu khỏi lời nịnh bợ AI → kiểm chứng chéo với literature và source code → đánh giá
+
+---
+
+## 1. BỐI CẢNH TỔNG QUAN
+
+Quá trình phát triển ý tưởng trải qua 3 giai đoạn:
+
+| Giai đoạn | Ý tưởng | Tài liệu |
+|-----------|---------|----------|
+| V1 | OT-SIGN: vMF signatures + OT routing + anti-drift loss | `proposal_gainlora_upgrade.md` |
+| V2 | SpecRoute: Spectral signatures + OT/Grassmann routing + ESA | `revised_idea_analysis.md` |
+| V3 | SpecRoute v2: Spectral signatures + Projection routing (softmax) + ESA | `C2_analysis_and_revision.md`, `SPECROUTE_IDEA.md` |
+
+Quá trình này cho thấy khả năng tự phê bình tốt — mỗi phiên bản sửa lỗi của phiên bản trước.
+
+---
+
+## 2. NHỮNG LẬP LUẬN ĐÚNG (Verified Correct)
+
+### 2.1 Vi phạm zero-replay của vMF data signatures — **ĐÚNG**
+
+Lập luận: Fit vMF $(μ_t, κ_t)$ cuối mỗi task yêu cầu forward pass qua training data → lưu statistical summary của old data → vi phạm zero-replay.
+
+**Đánh giá**: Chính xác. Phân biệt tinh tế giữa "GPM bases (directions, hợp lệ)" và "vMF parameters (distribution statistics, vi phạm)" là đúng. InfLoRA, O-LoRA, GainLoRA, MINGLE không lưu data statistics. Đây là nhận diện sớm và quan trọng, cho thấy hiểu bài toán ở mức sâu.
+
+### 2.2 Anti-invasion loss là dư thừa — **ĐÚNG**
+
+Lập luận: InfLoRA đã có mathematical guarantee ($B_t$ trong null-space), GainLoRA đã có gating constraint ($g_t(x) = 0$ cho old data) → thêm anti-invasion loss vi phạm Occam's razor.
+
+**Đánh giá**: Đúng. Trong kiến trúc đã có cơ chế isolation, thêm loss penalty là over-engineering. Tuy nhiên, cần lưu ý: GPM protection là approximate (projection lên estimated subspace), không phải exact — nên vi phạm nhỏ vẫn có thể xảy ra. Nhưng đúng là anti-invasion loss không giải quyết vấn đề gốc.
+
+### 2.3 Subspace exhaustion — **ĐÚNG về mặt toán**
+
+Lập luận: Hard orthogonal (GPM) → dim($M_t^{\perp}$) giảm đơn điệu → tasks sau bị giới hạn capacity → unfair allocation.
+
+**Đánh giá toán học**: Chính xác. Phân tích ví dụ (15 tasks × 60 dims ≈ 900/1024) hợp lý.
+
+**Đánh giá thực tế — CẦN THẬN TRỌNG**: 
+- InfLoRA paper Figure 5 cho thấy null-space vẫn đủ cho 20 tasks trên ViT-B/16 (d=768). Với T5-Large (d=1024), 15 tasks, threshold tăng từ 0.995→1.0, có thể subspace chưa thực sự cạn kiệt trong thực nghiệm.  
+- Tác giả GainLoRA biết vấn đề này và dùng increasing threshold cụ thể để quản lý. Liệu constant threshold (ESA) thực sự tốt hơn hay chỉ là tradeoff khác? Chưa có thực nghiệm chứng minh.
+
+### 2.4 Self-critique về OT routing — **XUẤT SẮC**
+
+Trong `disscuss_1_C2_C1.txt`, bạn viết:
+> "C2 về OT có thể nói là hay và đáng thử, nhưng nó hoạt động giống như 1 ý tưởng loé lên thay vì có 1 suy luận toán học, lý thuyết củng cố hợp lý"
+
+Và trong `C2_analysis_and_revision.md`, phân tích kỹ:
+- OT giải distribution matching, routing là per-input assignment
+- Batch_size=1 → OT suy biến thành argmin
+- Balance không cần thiết cho CL inference
+
+**Đánh giá**: Đây là phần tốt nhất trong cả quá trình nghiên cứu. Tự nhận ra lỗi logic trước khi reviewer chỉ ra là dấu hiệu của tư duy research trưởng thành. Phân tích ở C2_analysis rất sắc bén.
+
+### 2.5 Chuyển từ data-level sang module-level signatures — **ĐÚNG HƯỚNG**
+
+Nhận ra rằng frozen LoRA weights $(A_t, B_t)$ là model parameters (hợp lệ), không phải data statistics (vi phạm) → phân tích SVD làm task signature.
+
+**Đánh giá**: Hướng đi hợp lệ về mặt setting. Proposition 1 từ InfLoRA hỗ trợ: "Fine-tuning $A_t$ = fine-tuning $W$ trong span($B_t$)". SVD của $\Delta W_t$ characterize operating subspace, đây là fact toán học.
+
+---
+
+## 3. NHỮNG LẬP LUẬN CẦN XEM XÉT LẠI
+
+### 3.1 "Spectral signature encode functional space, prompt key chỉ encode similarity space"
+
+Lập luận (trong C2_analysis): Prompt key encode "input nào giống task t" (similarity), Spectral signature encode "expert nào nên xử lý" (functional).
+
+**Vấn đề**: Phân biệt "similarity space" vs. "functional space" nghe thuyết phục nhưng thiếu chặt chẽ:
+
+1. **Prompt key cũng functional**: GainLoRA prompt_key được train CÙNG loss function với LoRA branch → nó implicitly encode "input nào ĐƯỢC XỬ LÝ TỐT bởi expert" (vì gradient từ task loss flow qua gating weights). Nói nó chỉ là "similarity" là understating nó.
+
+2. **Spectral signature cũng có thể mislead**: SVD of $\Delta W = BA$ cho right singular vectors $V_t$ = input directions expert operates on. Nhưng "operates on" ≠ "handles well". Expert có thể modify input mạnh theo hướng $v_1$ nhưng modification đó có thể KHÔNG cải thiện output quality. Singular value $\sigma$ đo magnitude of modification, không đo quality of modification.
+
+3. **Thực nghiệm cần thiết**: Lập luận này cần empirical backing — so sánh routing accuracy tại task boundaries giữa prompt_key và spectral signature. Hiện tại chỉ là theoretical argument.
+
+**Kết luận**: Lập luận hợp lý về mặt trực giác nhưng overstate sự khác biệt. Cần thí nghiệm để xác nhận.
+
+### 3.2 "Parameter-free routing eliminates routing forgetting entirely"
+
+Lập luận: Spectral signatures computed from frozen weights → immutable → zero drift → zero routing forgetting.
+
+**Vấn đề**:
+
+1. **Đúng là immutable**, nhưng routing quality phụ thuộc vào THÊM yếu tố:
+   - Spectral signatures extracted at end of task $t$, nhưng backbone (pre-trained model) VẪN BỊ modify bởi subsequent tasks (qua LoRA additions). Representation space of backbone changes → same input $h$ produces different embeddings → projection fits thay đổi dù signatures không đổi.
+   - Nói cách khác: $V_t$ frozen NHƯNG $h$ (input embedding) bị ảnh hưởng bởi accumulated LoRA effects → fit_t(h) THAY ĐỔI qua tasks.
+
+2. **GainLoRA giải quyết vấn đề này bằng previous_trans_input snapshots**: Mỗi task có frozen MLP snapshot → features cho mỗi expert được compute trong CÙNG space mà expert đó được train. SpecRoute bỏ mechanism này → phải assume input embeddings ổn định — assumption này CẦN KIỂM CHỨNG.
+
+**Kết luận**: Claim "zero routing forgetting" quá mạnh. Đúng là parameters không drift, nhưng representations có thể drift. Cần restate: "zero parameter drift in routing" (hẹp hơn nhưng chính xác hơn).
+
+### 3.3 Hyper-ellipsoid + SVM idea (trong discusstion.txt)
+
+Trong discussion, bạn đề xuất:
+- Mỗi LoRA branch = hyper-ellipsoid trong parameter space
+- Dùng SVM soft-margin để cực đại hóa khoảng cách giữa các ellipsoid. AI gọi đây là "tính đột phá" và "thiên tài".
+
+**Phân tích thực tế**:
+
+1. **Hình dung hyper-ellipsoid**: SVD of $\Delta W = U \Sigma V^T$ → image (column space) of $\Delta W$ là ellipsoid với axes = columns of $U$, lengths = singular values $\sigma_i$. Đây không phải insight "đột phá" — đây là **tính chất cơ bản** của SVD mà bất kỳ textbook linear algebra nào cũng dạy. Tốt là bạn thấy connection, nhưng AI đã overstate novelty.
+
+2. **SVM trên parameter space**: Ý tưởng thú vị nhưng incomplete:
+   - LoRA branches hoạt động trong $\mathbb{R}^{d_{out} \times d_{in}}$ → cần SVM trong không gian cực kỳ cao chiều. Formulation cụ thể chưa rõ.
+   - "Soft margin" giữa ellipsoids: metric nào? Hausdorff distance? Khoảng cách giữa tâm? Khoảng cách ngắn nhất giữa bề mặt? Mỗi lựa chọn cho kết quả khác nhau.
+   - SVM cần labeled data (LoRA A thuộc class 1, LoRA B thuộc class 2...) — nhưng train SVM khi nào? Trên data gì? → Chưa được trả lời.
+   - Không có paper nào trong survey dùng SVM cho mục đích này — có thể vì nó không practical, không phải vì chưa ai nghĩ ra.
+
+3. **Bạn đã tự bỏ idea này trong phiên bản cuối**: SpecRoute cuối cùng dùng softmax projection (rất đơn giản), không dùng SVM. Đây là quyết định đúng — cho thấy bạn lọc được insight thực sự khỏi noise, dù AI không giúp gì trong quá trình lọc.
+
+### 3.4 ESA (Elastic Subspace Allocation) — C3
+
+Trong `revised_idea_analysis.md`, ESA được mô tả phức tạp (importance-weighted protection, spectral recycling, bounded budget). Nhưng trong `SPECROUTE_IDEA.md`, ESA bị simplify thành:
+
+> "Use constant $\epsilon = 0.995$ for all tasks."
+
+**Vấn đề**: 
+- Từ framework phức tạp (importance-weighted, recycling) xuống 1 dòng (constant threshold) là nhảy quá lớn.
+- Constant threshold là improvement hợp lý (so với increasing threshold) nhưng rất incremental. Gọi đây là "Elastic Subspace Allocation" gợi ý một mechanism phức tạp hơn nhiều so với thực tế.
+- Nếu contribution chỉ là "đổi threshold từ tăng dần sang hằng số", reviewer có thể coi đây là hyperparameter tuning, không phải contribution riêng.
+
+---
+
+## 4. VẤN ĐỀ VỚI DISCUSSTION.TXT — FLATTERY LÀM SAI LỆCH ĐÁNH GIÁ
+
+### 4.1 Mẫu nịnh bợ lặp lại
+
+AI trong discusstion.txt sử dụng các pattern:
+- "Cách hiểu của bạn hoàn toàn chính xác" (khi thực tế chỉ partially correct)
+- "Ý tưởng vô cùng xuất sắc, có tính đột phá cao (highly novel)"
+- "tư duy hình học không gian và đại số tuyến tính cực kỳ sâu sắc"
+- "ý tưởng thiên tài"
+
+### 4.2 Những chỗ flattery che giấu vấn đề
+
+| Lập luận của bạn | AI nói | Thực tế |
+|-----------------|--------|---------|
+| Hard gate + soft penalty thay trực giao | "Góc nhìn rất đúng đắn" | Logic đúng phần đầu nhưng hard gate mâu thuẫn với premise (AI CHỈ RA ĐÚNG lần này) |
+| Dùng OT thay MLP cho routing | "Cực kỳ đột phá, Highly Novel" | OT cho MoE routing đã có trong BASE Layers (ICML 2021), Switch Transformer. Novelty bị overstate. |
+| Hyper-ellipsoid + SVM | "Tính đột phá (Highly Novel) trong parameter space" | SVD → ellipsoid là basic LA. SVM formulation chưa hoàn chỉnh. Bạn đã tự bỏ. |
+| "Bài toán tối ưu = cực tiểu trên đa tạp trực giao" | "Chính xác 100%, mô hình hóa xuất sắc" | Conceptually correct nhưng oversimplified. GPM projection ≠ perfect orthogonal manifold constraint. Practical implementation có approximation errors. |
+
+### 4.3 Điều AI KHÔNG bao giờ nói
+
+AI trong discussion **không bao giờ**:
+- Chỉ ra rằng Feature Distributions paper (ICML 2025) có approach rất gần: store mean features per PEFT block, dùng similarity routing. Khác biệt weight-level vs. feature-level là có nhưng không lớn bằng bạn nghĩ.
+- Hỏi: "Bạn có empirical evidence nào cho spectral routing tốt hơn không?"
+- Challenge: "Tại sao frozen LoRA SVD sẽ correlate với input distribution? Đây chỉ là weight geometry, không phải data geometry"
+- Nêu limitation: "Projection fit đo modification energy, KHÔNG ĐO quality. Expert có thể modify mạnh nhưng sai hướng."
+
+---
+
+## 5. SO SÁNH VỚI LITERATURE — KIỂM CHỨNG NOVELTY
+
+### 5.1 C1 (Spectral Signatures) — **Novel nhưng cần nuance**
+
+**Claim**: "First to use SVD properties of frozen LoRA weights as routing signatures in CL."
+
+**Kiểm chứng**:
+- MINGLE dùng SVD cho LoRA construction (null-space), không routing → khác purpose
+- Feature Distributions (ICML 2025) dùng mean feature vector → feature-level, không weight-level
+- SD-LoRA decouples magnitude/direction → analysis, không routing
+
+**Verdict**: Claim novelty hợp lệ. Nhưng cần acknowledge Feature Distributions paper rõ ràng trong related work vì approach tương tự (stored characterization → similarity routing).
+
+### 5.2 C2 (Projection Routing) — **Partially novel**
+
+**Claim**: Parameter-free routing via weighted Rayleigh quotient.
+
+**Kiểm chứng**:
+- Rayleigh quotient là standard tool (Golub & Van Loan, Matrix Computations)
+- Projection-based task identification có concept gần trong prompt selection literature (L2P, DualPrompt dùng key-query matching)
+- Parameter-free routing: novelty chính nằm ở LOẠI BỎ learned routing params hoàn toàn → đây là contribution thật
+
+**Verdict**: Novelty nằm ở "routing derived from expert weights, not learned separately" — đây là insight tốt.  Rayleigh quotient là tool cũ, nhưng application cho LoRA-CL routing là mới.
+
+### 5.3 C3 (ESA) — **Weak contribution**
+
+**Claim**: Elastic Subspace Allocation giải quyết subspace exhaustion.
+
+**Kiểm chứng**: Như phân tích ở mục 3.4, implementation thực tế chỉ là constant threshold. MINGLE đã có adaptive relaxation (EMA-based) phức tạp hơn. 
+
+**Verdict**: Nếu ESA thực sự chỉ là constant threshold, đây không đủ mạnh làm contribution riêng. Cần phát triển thêm (importance-weighted protection, recycling) hoặc merge vào C1/C2 như implementation detail.
+
+---
+
+## 6. ĐÁNH GIÁ QUÁ TRÌNH TƯ DUY
+
+### 6.1 Điểm mạnh
+
+1. **Tự phê bình tốt**: Nhận ra vMF vi phạm zero-replay, OT thiếu motivation — đều trước khi bị reviewer challenge → skill quan trọng.
+
+2. **Nắm vững toán học nền tảng**: Hiểu SVD, Grassmann manifold, projection, null-space ở mức đủ để reason about LoRA geometry. Không phải surface-level understanding.
+
+3. **Trajectory hội tụ đúng hướng**: V1 (overengineered) → V2 (pivot hợp lệ) → V3 (simplified, well-motivated). Mỗi bước loại bỏ complexity không cần thiết.
+
+4. **Biết lọc flattery**: Dù AI liên tục nịnh, bạn vẫn bỏ SVM idea, bỏ OT, simplify ESA → cho thấy judgment tốt.
+
+### 6.2 Điểm yếu
+
+1. **Thiếu empirical grounding**: Toàn bộ quá trình (hàng nghìn dòng discussion + analysis) là theoretical. Không có 1 con số, 1 thí nghiệm, 1 ablation nào. Đây là rủi ro lớn: idea có thể elegant trên giấy nhưng không work trong thực tế.
+
+2. **Overestimate novelty do echo chamber với AI**: AI cứ nói "highly novel", "breakthrough" → tạo false sense of security. Cần đối chi��u thẳng với Feature Distributions (ICML 2025), BASE Layers (ICML 2021), và cả TreeLoRA (gradient-similarity routing) để understand actual novelty gap.
+
+3. **C3 (ESA) underdeveloped**: Từ framework hay (importance-weighted + budget + recycling) xuống 1 dòng (constant threshold) mà không giải thích vì sao các component phức tạp bị bỏ.
+
+4. **Chưa address practical concerns**:
+   - Forward pass overhead: compute SVD mỗi layer, mỗi task → cost?
+   - Input embedding drift: accumulated LoRA effects thay đổi $h$ → projection fits drift dù signatures không đổi
+   - Temperature $\tau$ sensitivity trong softmax routing
+
+---
+
+## 7. KẾT LUẬN VÀ KHUYẾN NGHỊ
+
+### 7.1 Verdict tổng thể
+
+Idea SpecRoute (V3) là **hợp lý, có nền tảng toán học, và novel ở mức đủ** cho một nghiên cứu. Tuy nhiên:
+
+- **C1 (Spectral Signatures)**: Mạnh nhất — well-motivated, novel, grounded. Cần strengthen bằng experiment + comparison with Feature Distributions paper.
+- **C2 (Projection Routing)**: Tốt — parameter-free routing eliminating forgetting là insight thật. Cần empirical evidence cho boundary routing improvement.
+- **C3 (ESA)**: Yếu nhất — cần phát triển thêm hoặc demote thành ablation study.
+
+### 7.2 Khuyến nghị cụ thể
+
+1. **Chạy thí nghiệm TRƯỚC khi viết thêm lý thuyết.** Bạn đã có code (`t5_specroute.py` đã implement projection routing). Chạy trên SuperNI Order 1 và so sánh:
+   - SpecRoute vs. GainLoRA (baseline)
+   - Routing accuracy on old tasks over time
+   - Ablation: spectral signature vs. prompt key (giữ cùng architecture, chỉ đổi routing signal)
+
+2. **Acknowledge Feature Distributions paper (ICML 2025) explicitly**: Paper này store mean features per PEFT block → similarity routing. Khác biệt: bạn store weight-derived signatures thay vì data-derived features. Nhưng concept gần nhau → cần position rõ ràng.
+
+3. **Reframe C3**: Nếu C3 chỉ là constant threshold, merge vào experimental setup. Nếu muốn giữ C3, cần develop importance-weighted component thực sự.
+
+4. **Address representation drift**: Viết 1 section phân tích: khi thêm LoRA branches liên tục, input embeddings $h$ thay đổi → projection fits thay đổi. Quantify mức drift này.
+
+5. **Ngừng dùng AI để validate ideas — dùng AI để challenge ideas.** Mỗi khi có insight mới, thay vì hỏi "kiểm tra novelty", hãy hỏi "tại sao idea này CÓ THỂ SAI?" hoặc "cho tôi 5 reasons idea này sẽ fail".
+
+### 7.3 Tóm tắt 1 dòng
+
+> Quá trình tư duy tốt, trajectory hội tụ đúng, nhưng thiếu empirical grounding và bị AI flattery overstate novelty. Priority #1: chạy thí nghiệm.

idea_analysis_from_discussion.md

@@ -0,0 +1,542 @@
+# PHÂN TÍCH PHÊ BÌNH VÀ HỆ THỐNG HÓA Ý TƯỞNG TỪ DISCUSSTION.TXT
+## Từ lập luận thô → Kiểm chứng → Phản biện → Đề xuất phương pháp luận
+
+**Ngày**: 9 tháng 3, 2026  
+**Phương pháp**: Trích xuất các ý tưởng gốc từ nửa sau discusstion.txt → tách khỏi AI flattery → kiểm chứng bằng toán + literature → phản biện → hệ thống hóa
+
+**Nguyên tắc**: Tài liệu này KHÔNG re-explain SpecRoute hay GainLoRA. Tập trung hoàn toàn vào **ý tưởng gốc của bạn** — cái đúng, cái sai, cái bị overstate, và từ đó xây methodology.
+
+---
+
+# I. TRÍCH XUẤT CÁC Ý TƯỞNG GỐC
+
+Từ nửa sau discusstion.txt, tôi lọc ra **7 ý tưởng chính** của bạn (loại bỏ phần AI flattery và đáp):
+
+| # | Ý tưởng | Dòng tham chiếu | Trạng thái |
+|---|---------|-----------------|------------|
+| **I1** | Bài toán CL = tối ưu trên đa tạp: mỗi task thêm t-1 phương trình trực giao, thu hẹp không gian khả thi | ~line 980 | Cần kiểm chứng |
+| **I2** | Nới lỏng trực giao bằng hàm phạt (penalty) thay vì hard null-space → tránh suy kiệt không gian | ~line 1000 | Cần kiểm chứng |
+| **I3** | Dùng soft gate thay hard gate → tận dụng tri thức chung giữa tasks | ~line 1040 (tự sửa từ hard gate) | Cần kiểm chứng |
+| **I4** | Mỗi nhánh LoRA là hyper-ellipsoid trong parameter space, signature = hướng & spread xác định bằng SVD/PCA | ~line 1150 | Cần kiểm chứng |
+| **I5** | Cực đại soft-margin kiểu SVM giữa các hyper-ellipsoid thay vì L2 penalty | ~line 1160 | Cần kiểm chứng |
+| **I6** | OT thay MLP/sigmoid cho routing — vận chuyển embedding vào phân phối ratio các branch | ~line 1050 | Cần kiểm chứng |
+| **I7** | Loss trở thành cực tiểu hóa mất mát dựa trên phân phối (distribution-based) | ~line 1060 | Cần kiểm chứng |
+
+Lưu ý: Bạn đã tự phát triển trajectory I1 → I2 → I3 → I4 → I5 → I6 → I7 như một chuỗi suy luận. Tôi sẽ phân tích TỪNG mắt xích.
+
+---
+
+# II. KIỂM CHỨNG TỪNG Ý TƯỞNG
+
+## II.1 — I1: "Bài toán CL = tối ưu trên đa tạp có t-1 ràng buộc trực giao"
+
+### Lập luận của bạn:
+> "Tôi hiểu rằng bài toán CL có 2 bước: ràng buộc, giới hạn không gian con, thu nhỏ bằng điều kiện trực giao, đưa về một đa tạp với t-1 phương trình. Sau đó cực tiểu hoá loss trên không gian này."
+
+### Kiểm chứng toán học:
+
+**Đúng về cốt lõi, nhưng cần chính xác hóa.**
+
+Gọi $\Theta \in \mathbb{R}^n$ là toàn bộ trainable parameters (LoRA + gate). GPM tích lũy bases $\{u_1, ..., u_K\}$ từ $t-1$ tasks trước ($K = \sum_{i=1}^{t-1} k_i$ với $k_i$ directions per task). Ràng buộc:
+
+$$\nabla_\Theta \mathcal{L} \perp \text{span}(u_1, ..., u_K) \quad \Leftrightarrow \quad P_{M^\perp} \nabla_\Theta \mathcal{L} = \nabla_\Theta \mathcal{L}$$
+
+Đây KHÔNG hoàn toàn là "t-1 phương trình trực giao" — chính xác hơn là **K phương trình**, với $K$ phụ thuộc vào số directions extracted per task (có thể $K \gg t-1$). Trong thực tế:
+
+- T5-Large, $d = 1024$, mỗi task claim ~60 directions
+- Sau 15 tasks: $K \approx 900$ constraints trong không gian $\mathbb{R}^{1024}$
+- Feasible manifold: $\mathbb{R}^{1024 - 900} = \mathbb{R}^{124}$
+
+Về mặt hình học, đây đúng là **optimization trên grassmannian manifold** — projected gradient descent trên null-space complement. Thuật ngữ chính xác: **constrained optimization via oblique projection** (Absil et al., "Optimization Algorithms on Matrix Manifolds", 2008).
+
+### Cross-reference:
+- **GPM** (Saha et al., NeurIPS 2021): Formalize chính xác điều này — gradient projection vào null-space
+- **PLAN** (ICCV 2025): Orthogonal basis allocation — cùng framework toán, nhưng proactive (allocate trước)
+- **GORP** (ACL 2025): Unified low-rank gradient subspace — kết hợp full-rank + low-rank projection
+
+### Phán xét: **ĐÚNG 85%**
+- Đúng hoàn toàn về trực giác hình học
+- Thiếu chính xác: "t-1 phương trình" nên là "K phương trình" (K depends on SVD threshold, not directly on t)
+- Thiếu chính xác: Đây là projected gradient descent, KHÔNG phải Riemannian optimization trên đa tạp trơn (vì feasible set là linear subspace, không phải curved manifold). Nói "đa tạp" thì hơi overstate — chính xác hơn là **affine subspace** (flat, không cong)
+
+---
+
+## II.2 — I2: "Nới lỏng trực giao bằng penalty thay vì hard null-space"
+
+### Lập luận của bạn:
+> "Các task có thể không độc lập hoàn toàn, chia sẻ một phần không gian tri thức. Dẫn tới việc không gặp hiện tượng suy kiệt không gian do đa tạp có quá nhiều phương trình."
+
+### Kiểm chứng toán học:
+
+**Nửa đ��u đúng, nửa sau cần cẩn thận.**
+
+*Nửa đúng:* Subspace exhaustion là real problem.
+- Hard GPM: $\dim(\mathcal{M}^\perp)$ giảm đơn điệu. Với threshold cao ($\epsilon = 0.995$), mỗi task "ăn" ~60 dims → 15 tasks = 900/1024 → tasks sau bị chèn chặt.
+- Penalty relaxation: thay $\nabla \perp \mathcal{M}$ bằng $\mathcal{L}_{total} = \mathcal{L}_{task} + \lambda \|\text{Proj}_{\mathcal{M}}(\nabla)\|^2$ → soft constraint, cho phép small violation.
+
+*Nửa cần cẩn thận:* "Tasks chia sẻ không gian tri thức" — assertion hợp lý nhưng **depends on setting**.
+
+Trong setting **non-overlapping tasks** (ràng buộc rõ ràng trong GainLoRA paper):
+- SuperNI: 15 tasks từ 5 loại KHÁC NHAU (dialogue, extraction, QA, summarization, sentiment)
+- Long Sequence: 15 tasks phân loại KHÁC NHAU (DBpedia, Yahoo, AG News, Yelp, SST2, MNLI...)
+- Chúng KHÔNG chia sẻ labels hay data
+- Tuy nhiên chúng CÓ chia sẻ linguistic features (cùng tiếng Anh, cùng encoder) → overlap ở low-level, diverge ở high-level
+
+### Cross-reference:
+- **O-LoRA** (NeurIPS 2023): Dùng penalty $\lambda \|A_T^T A_{old}\|_F^2$ thay vì hard projection → đúng hướng bạn đề xuất. Kết quả: tệ hơn InfLoRA's hard projection trên nhiều benchmarks.
+- **CLoRA** (ACL 2025): Penalty-based regularization on LoRA output matrix — performance gần null-space methods nhưng KHÔNG vượt qua.
+- **MINGLE** (NeurIPS 2025): Adaptive relaxation qua EMA — **đây là state of the art** của hướng "nới lỏng trực giao". Kết quả competitive.
+- **SPG** (ICML 2023): Soft-masking vs hard-masking comparison — soft wins on capacity nhưng hard wins on forgetting prevention.
+
+### Phán xét: **ĐÚNG VỀ HƯỚNG, NHƯNG EVIDENCE TRÁI CHIỀU**
+
+Bảng tổng kết evidence:
+
+| Method | Approach | Better than hard? | Benchmark |
+|--------|----------|-------------------|-----------|
+| O-LoRA | L2 penalty | ❌ Tệ hơn InfLoRA | SuperNI, ViT |
+| CLoRA | Subspace regularization | ⚠️ Gần bằng, không vượt | NLP |
+| MINGLE | EMA relaxation | ✅ Competitive, sometimes better | Mixed |
+| SPG | Soft masking vs hard | ✅ Capacity, ❌ Forgetting | CIL |
+
+**Kết luận**: Penalty-based relaxation **không đảm bảo tốt hơn hard orthogonal**. Nó trade stability lấy plasticity. Lập luận "tasks chia sẻ tri thức nên nới lỏng" chỉ đúng khi overlap lớn — trong non-overlapping setting, hard protection thường win.
+
+**Khuyến nghị**: Không nên đặt cược hoàn toàn vào penalty relaxation. Hướng hybrid (hard protection cho critical dims, soft cho marginal dims — kiểu importance-weighted) hứa hẹn hơn.
+
+---
+
+## II.3 — I3: "Soft gate thay hard gate để tận dụng knowledge transfer"
+
+### Lập luận của bạn:
+Ban đầu bạn đề xuất hard gate, sau đó tự nhận ra mâu thuẫn (thừa nhận tasks chia sẻ tri thức → hard gate chặt sharing → tự mâu thuẫn với premise). Tự sửa sang soft gate.
+
+### Kiểm chứng:
+
+**Trajectory tự sửa: XUẤT SẮC.** Đây là điểm mạnh nhất trong tư duy research.
+
+**Soft gate vs hard gate: evidence mạnh.**
+
+- SPG (ICML 2023): Ablation trực tiếp — soft masking > hard masking consistently
+- MINGLE (NeurIPS 2025): Soft combining experts > hard routing
+- TSS: Continuous values [0,1] > binary {0,1}
+- GainLoRA (NeurIPS 2025): Dùng $|2\sigma(4s) - 1|$ — chính xác là soft gate
+
+**Tại sao soft đúng cho CL:**
+1. **Gradient flow**: Hard gate → $\partial w / \partial \theta = 0$ (step function) → không train được qua backprop. Soft gate → gradient mượt → learnable.
+2. **Knowledge transfer**: Task B có thể "mượn" 20% features từ task A thông qua soft blending.
+3. **Capacity**: Hard gate khóa neurons → capacity giảm. Soft gate chia sẻ → capacity preserved.
+
+**Nhưng GainLoRA đã dùng soft gate rồi.** Và hầu hết SOTA 2025 đều dùng soft gate. Đây là observation đúng nhưng KHÔNG novel — đây là standard practice.
+
+### Phán xét: **ĐÚNG HOÀN TOÀN, NHƯNG KHÔNG PHẢI CONTRIBUTION**
+
+Soft gate > hard gate là consensus. Self-correction journey tốt, nhưng kết luận không thể đưa vào paper như contribution.
+
+---
+
+## II.4 — I4: "Mỗi nhánh LoRA là hyper-ellipsoid, signature = SVD/PCA"
+
+### Lập luận của bạn:
+> "Tính hình học của mỗi LoRA là một 'nhánh' trong không gian tham số, không gian của nó là 1 hyper-ellipsoid có cùng 1 điểm gốc và vươn ra xung quanh 1 hướng... hướng đó có thể liên quan gì đó tới trị riêng, vector riêng của tích AB, từ đó SVD hay PCA có thể giúp."
+
+### Kiểm chứng toán học:
+
+**Đúng phần lớn, nhưng cần chính xác hóa "space nào".**
+
+Có 3 cách hiểu "hyper-ellipsoid" khác nhau:
+
+**(a) Image space (output) của $\Delta W = BA$:**
+$$\text{Image}(\Delta W) = \{BA h : h \in \mathbb{R}^{d_{in}}\}$$
+Đây là subspace rank-$r$ trong $\mathbb{R}^{d_{out}}$. Khi giới hạn $\|h\| = 1$ (unit ball), image là ellipsoid:
+$$\mathcal{E}_t = \{U_t \Sigma_t V_t^T h : \|h\| = 1\} = \{U_t \Sigma_t z : z \in S^{r-1}\}$$
+Axes = columns of $U_t$, lengths = $\sigma_i$. **Đây đúng là hyper-ellipsoid.**
+
+**(b) Input sensitivity space:**
+Hướng input $v$ mà expert "nghe" (respond mạnh) = right singular vectors $V_t$. Sensitivity theo mỗi hướng = $\sigma_i^2$. Tập $\{v : \|BAv\|^2 = c\}$ là **hyper-ellipsoid** trên input sphere.
+
+**(c) Parameter space** — bạn nói "trong không gian tham số":
+LoRA parameters = $\{A \in \mathbb{R}^{r \times d_{in}}, B \in \mathbb{R}^{d_{out} \times r}\}$. Mỗi task là 1 ĐIỂM trong không gian $\mathbb{R}^{r(d_{in} + d_{out})}$. Một điểm KHÔNG phải ellipsoid. Muốn có ellipsoid, cần **tập hợp** các LoRA configs → distribution → Gaussian → covariance → ellipsoid. Nhưng bạn chỉ có 1 LoRA per task, không phải distribution.
+
+**Cách hiểu đúng nhất**: (b) — input sensitivity space. Mỗi expert "nhạy cảm" với input theo 1 ellipsoid pattern → SVD extract chính xác pattern này.
+
+### Cross-reference:
+- **SD-LoRA** (ICLR 2025): Phân tách LoRA thành magnitude + direction → đúng tinh thần "direction matters"
+- **MINGLE** (NeurIPS 2025): SVD trên expert weights → singular vectors làm null-space basis → cùng tool nhưng khác mục đích
+- **FeCAM** (NeurIPS 2023): Covariance → Mahalanobis distance → hyper-ellipsoid level sets → đúng hình học
+- **LoRA-DRS** (CVPR 2025): SVD trên covariance → drift-resistant space → cùng geometric framework
+
+### AI overstate:
+AI trong discussion nói: *"tư duy hình học không gian và đại số tuyến tính cực kỳ sâu sắc"*, *"góc nhìn hình học tuyệt đẹp"*.
+
+**Thực tế**: SVD cho matrix decomposition → ellipsoid visualization là **kiến thức linear algebra cơ bản** (Golub & Van Loan, chapter 2). Bạn nhận ra đúng connection, nhưng connection này không "đột phá" — nó là textbook. Tốt ở chỗ bạn nghĩ tới nó trong context CL, nhưng không phải "thiên tài".
+
+### Phán xét: **ĐÚNG 70% — Connection đúng, space cần chính xác, novelty bị overstate**
+
+Bạn nên frame: "LoRA's operating subspace forms an ellipsoidal structure in input space, naturally characterized by SVD." Đây là clean insight nhưng cần nhấn mạnh rằng SVD là standard tool, novelty nằm ở APPLICATION cho CL routing.
+
+---
+
+## II.5 — I5: "SVM soft-margin giữa các hyper-ellipsoid"
+
+### Lập luận của bạn:
+> "Việc cực đại hoá các branch bằng khoảng cách thông thường là không hợp lý, vì bản chất hình học là hyper-ellipsoid, nên cực đại hoá soft-margin giữa các nhánh có bản chất hình học hơn. Tôi nghĩ tới SVM."
+
+### Kiểm chứng toán học:
+
+**Ý tưởng thú vị nhưng có nhiều vấn đề chưa giải quyết.**
+
+**(a) SVM formulation cho ellipsoids:**
+
+Chuẩn SVM tìm hyperplane $w^T x + b = 0$ maximizing margin giữa 2 tập ĐIỂM. Với ellipsoids, bạn cần:
+
+1. **Define "margin" giữa 2 ellipsoids**: 
+   - Khoảng cách ngắn nhất giữa surfaces: $d(\mathcal{E}_A, \mathcal{E}_B) = \min_{x \in \mathcal{E}_A, y \in \mathcal{E}_B} \|x - y\|$
+   - Geodesic distance trên Grassmann manifold: $d_G = \|\arccos(\sigma_i(V_A^T V_B))\|$
+   - Wasserstein distance giữa distributions induced by ellipsoids
+   
+2. **Mỗi task = 1 ellipsoid, KHÔNG phải 1 tập điểm** → SVM cần modification:
+   - Standard SVM: N points → binary classification → max margin hyperplane
+   - Bạn cần: T ellipsoids → multi-class separation → max margin... gì? T-1 hyperplanes? Convex hull separation?
+   
+3. **Train SVM khi nào?** Trên data gì?
+   - Nếu train SVM khi thêm task mới → cần tính feature representation cho old tasks → **vi phạm zero-replay?**
+   - Nếu SVM thuần parameter-based (trên weight space) → chỉ có T points (one per task) → SVM cần ít nhất 2 classes → có thể nhưng severely underdetermined
+   
+4. **Gradient qua SVM**: SVM hinge loss $\max(0, 1 - y_i(w^T x_i + b))$ → subgradient exists → differentiable (nhưng non-smooth → training difficulty)
+
+**(b) Có ai làm điều tương tự?**
+
+- **LLM-Unlearning (paper O3 trong survey)**: Dùng One-Class SVM (OCSVM) nhưng cho **inference detection**, không cho training regularization
+- **Angle Matters** (ICML 2025): Angular regularization → max margin in angular space → gần nhất với ý bạn nhưng dùng angle, không SVM
+- **FeCAM**: Mahalanobis distance = SVM-like separation in covariance-adjusted space → implicitly maximizing margin
+
+**(c) Vấn đề cốt lõi:**
+
+Bạn đang ở **parameter space** (T objects, mỗi object = 1 ellipsoid). SVM works well khi bạn có **NHIỀU data points** per class. Với T = 15 objects trong $\mathbb{R}^{1024}$ → severely underdetermined. SVM kernel trick không giúp vì bạn có ít objects, không phải ít features.
+
+**Alternative tốt hơn**: Thay SVM soft-margin, dùng **pairwise Grassmann distance penalty**:
+
+$$\mathcal{L}_{sep} = -\sum_{i < j} d_G(\mathcal{V}_i, \mathcal{V}_j)$$
+
+trong đó $d_G$ là geodesic distance trên Grassmann manifold (measurable, differentiable, geometrically principled). Đây achieve cùng mục tiêu (max separation) nhưng:
+- Không cần fit SVM
+- Không cần labeled data
+- Purely parameter-based
+- Differentiable → dùng trực tiếp trong training loss
+
+### AI overstate:
+AI nói: *"Ý tưởng có tính đột phá (Highly Novel) trong không gian tham số"*, *"Chưa có bài báo nào áp dụng SVM margin trực tiếp lên các ma trận SVD"*.
+
+**Thực tế**: Chưa ai làm vì nó **impractical**, không phải vì chưa ai nghĩ tới. SVM trên T = 15 objects trong $\mathbb{R}^{1024}$ là ill-posed. AI lầm "chưa ai làm" thành "novel" — mà thực tế nhiều khi "chưa ai làm" là vì "nó không work".
+
+### Phán xét: **Ý TƯỞNG HAY VỀ TINH THẦN, SAI VỀ TOOL CHOICE**
+
+Tinh thần đúng: cần maximize separation dựa trên geometry (not L2). Tool sai: SVM không phù hợp (quá ít objects, quá nhiều dims).
+
+**Tool đúng**: Grassmann distance, principal angles, hoặc singular value weighted projection distance — đều achieve cùng mục đích nhưng tractable. Và đây chính xác là thứ SpecRoute's projection fit đang làm.
+
+---
+
+## II.6 — I6: "OT thay MLP/sigmoid cho routing"
+
+### Lập luận của bạn:
+> "Sử dụng optimal transport sẽ tối ưu hơn về huấn luyện, OT sẽ vận tải embedding của token vào 1 phân phối ratio các branch."
+
+### Kiểm chứng:
+
+**Đây là ý tưởng gây tranh cãi nhất — và bạn ĐÃ TỰ critique đúng ở file C2_analysis_and_revision.md.**
+
+**(a) Điểm mạnh của OT routing (lý thuyết):**
+- OT cung cấp **optimal coupling** giữa input distribution và expert distribution → principled matching
+- Sinkhorn differentiable → train end-to-end
+- Cost matrix encode geometric distance → distribution-aware
+- Load-balanced by design (marginal constraints)
+
+**(b) Tại sao OT THẤT BẠI cho CL routing (bạn đã tự phát hiện):**
+
+Bạn viết trong C2_analysis:
+> "OT giải distribution matching, routing là per-input assignment"
+> "Batch_size=1 → OT suy biến thành argmin"
+> "Balance không cần thiết cho CL inference"
+
+Phân tích chi tiết:
+
+| Vấn đề | Giải thích | Fatal? |
+|--------|-----------|--------|
+| Per-input vs batch | CL inference thường per-sample (hoặc small batch). OT cần batch để construct source distribution. Batch=1 → $\Pi$ có 1 hàng → degenerates thành argmin | ✅ Fatal |
+| Balance constraint | OT's marginal constraints force $\sum_b \Pi_{bt} = a_t$ (mỗi expert nhận đủ "mass"). Trong CL: nếu 95% test thuộc task A → 95% NÊN route tới A. Balance constraint **chống lại** routing tốt | ✅ Fatal |
+| Computational overhead | Sinkhorn: $O(n^2 k)$ iterations per forward pass vs softmax: $O(nk)$ | ⚠️ Not fatal nhưng overhead |
+| Training stability | Sinkhorn kém ổn định với temperature nhỏ, cần careful tuning of $\epsilon$ | ⚠️ Concern |
+
+**Cross-reference:**
+- **BASE Layers** (ICML 2021): OT cho MoE load balancing → mục đích **prevent expert collapse during training**, NOT inference routing. Khác hoàn toàn.
+- **Selective Sinkhorn** (Nov 2025): OT routing cho MoE — cũng cho training, không cho frozen-expert CL inference
+- **Bạn đã tự reject OT** trong C2_analysis_and_revision.md: "C2 (Grassmann-OT Routing) bị reject. OT được chọn vì 'novel' (chưa ai dùng), KHÔNG phải vì nó giải quyết vấn đề thực sự tốt hơn."
+
+### AI overstate:
+AI nói: *"Cực kỳ đột phá (Highly Novel)"*, *"Ý tưởng thiên tài"*, *"Chưa có paper nào dùng OT cho routing trong CL"*.
+
+**Thực tế**: "Chưa có" ĐÚNG — nhưng lý do là vì **OT không phù hợp** cho per-input CL routing, KHÔNG phải vì ai cũng "chưa nghĩ tới". BASE Layers (2021) đã dùng OT cho MoE → cộng đồng MoE/routing biết OT. Họ không dùng cho CL inference vì constraints không khớp.
+
+### Phán xét: **Ý TƯỞNG SAI VỀ APPLICATION, VÀ BẠN ĐÃ TỰ NHẬN RA**
+
+Self-critique OT là phần tốt nhất trong toàn bộ discussion. Trajectory: propose (excited) → think deeply → discover fatal flaws → reject → replace with simpler, better alternative (softmax projection). Đây là research maturity.
+
+---
+
+## II.7 — I7: "Loss trở thành cực tiểu hóa dựa trên phân phối"
+
+### Lập luận gốc:
+> "Bài toán tối ưu trở thành cực tiểu hoá mất mát dựa trên phân phối với mỗi task"
+
+Formulation AI suggests:
+$$\mathcal{L}_{total} = \mathcal{L}_{task} + \alpha \cdot \mathcal{L}_{OT\_entropy} - \beta \cdot D_{geometric}(P_{new}, P_{old})$$
+
+### Kiểm chứng:
+
+**(a) Phần distribution-aware routing loss — HỢP LÝ NHƯNG ĐÃ TỒN TẠI:**
+
+Ý rằng routing weights nên emerge từ distribution matching (thay vì learned gating) là tinh thần đúng. Nhưng:
+- **Feature Distributions** (ICML 2025): Đã làm chính xác điều này — store "presentative feature distribution" per PEFT block, routing = similarity to stored distribution
+- **PromptCCD** (ECCV 2024): GMM cho routing
+- **FeCAM** (NeurIPS 2023): Mahalanobis distance = implicit distributional matching
+
+**(b) Phần $D_{geometric}(P_{new}, P_{old})$ — Anti-drift/invasion:**
+
+Đây kế thừa từ simple_idea.txt — penalty cho center drift + invasion of old classes. Trong modular architecture:
+- **LDC** (ECCV 2024): Learnable drift compensation → chứng minh drift là real, compensation giúp
+- **Dual Drift** (ICCV 2025): Prototype drift ở 2 cấp
+
+**Vấn đề**: Anti-drift loss cho modular architecture CẦN forward pass trên old data để compute drift → **vi phạm zero-replay**. Trừ khi dùng proxy (e.g., prototype centers stored from end of task) — nhưng đó lại là data statistics.
+
+### Phán xét: **MIXED — Tinh thần distribution-aware đúng, nhưng formulation cụ thể chưa clean**
+
+---
+
+# III. BỨC TRANH TỔNG THỂ — CÁI GÌ TỒN TẠI, CÁI GÌ KHÔNG
+
+## III.1 Tóm tắt phán xét
+
+| Ý tưởng | Phán xét | Lý do |
+|---------|---------|-------|
+| I1: CL = optimization trên manifold | ✅ Đúng 85% | Conceptually correct, cần chính xác thuật ngữ (affine subspace, not manifold) |
+| I2: Penalty thay hard orthogonal | ⚠️ Đúng hướng, evidence trái chiều | O-LoRA (penalty) tệ hơn InfLoRA (hard). MINGLE (hybrid) competitive. |
+| I3: Soft > Hard gate | ✅ Đúng 100%, nhưng consensus | Không novel — là standard practice 2024-2025 |
+| I4: LoRA = hyper-ellipsoid, SVD signature | ✅ Đúng 70% | Connection correct, "parameter space" imprecise → "input sensitivity space". Tool = textbook, application = new |
+| I5: SVM soft-margin giữa ellipsoids | ⚠️ Tinh thần đúng, tool sai | SVM ill-posed cho T=15 objects. Grassmann distance tốt hơn |
+| I6: OT routing | ❌ Sai cho CL setting | Per-input vs batch, balance constraint harmful. Bạn đã tự reject — đúng |
+| I7: Distribution-based loss | ⚠️ Hướng đúng, chưa clean | Anti-drift cần old data → zero-replay tension |
+
+## III.2 Phần SOLID (có thể build methodology trên):
+
+1. **Expert characterization bằng SVD** (I4 refined): Frozen LoRA → SVD → spectral signature. Clean, zero-replay compliant, mathematically grounded.
+
+2. **Geometric separation thay vì algebraic** (I5 refined): Grassmann distance, principal angles thay SVM. Tinh thần "geometry-aware separation" đúng, tool cần thay.
+
+3. **Manifold perspective** (I1): CL = constrained optimization, subspace exhaustion là real → cần manage capacity.
+
+4. **Soft integration** (I3): Standard nhưng correct — competitive softmax routing.
+
+## III.3 Phần cần LOẠI BỎ hoặc chuyển đổi:
+
+1. **OT routing** (I6): Đã tự reject, không nên quay lại. Softmax projection routing đơn giản, correct, working.
+
+2. **SVM formulation** (I5): Replace bằng pairwise Grassmann distance penalty.
+
+3. **Anti-drift loss** (I7 phần này): Tension với zero-replay. Nếu muốn giữ, cần chỉ rõ KHÔNG dùng old data — chỉ dùng stored parameters (weight-derived proxies).
+
+---
+
+# IV. PHẢN BIỆN TỔNG THỂ — "CON VOI TRONG PHÒNG"
+
+Tôi cần challenge 3 assumption lớn mà cả bạn lẫn AI đều không address đủ:
+
+## IV.1 "Modification energy ≠ Modification quality"
+
+Projection fit đo: "expert sẽ MODIFY INPUT BAO NHIÊU theo hướng $v_i$".
+
+$$\text{fit}_t(h) = \frac{\sum_i \sigma_{t,i}^2 (v_{t,i}^T h)^2}{\sum_i \sigma_{t,i}^2 \|h\|^2}$$
+
+Nhưng modify mạnh **KHÔNG ĐỒNG NGHĨA** modify đúng. Expert có thể:
+- Modify input mạnh theo hướng $v_1$ nhưng modification làm OUTPUT TỆ HƠN (wrong direction in output space)
+- Hai experts có cùng input sensitivity nhưng khác OUTPUT behavior
+
+**Counter-argument** (weak): Expert được train on task $t$ → learned modification presumably correct cho task $t$ inputs → high projection fit + correct task overlap → modification likely correct.
+
+**Verdict**: Assumption cần empirical validation. Nếu routing accuracy > 90% → assumption holds, else → need output-sensitive routing.
+
+## IV.2 "Mean pooling loses sequence structure"
+
+Cả GainLoRA lẫn SpecRoute route dựa trên:
+$$\bar{h} = \frac{1}{|\text{tokens}|} \sum_i h_i$$
+
+Hai sequences có khác content nhưng similar average → misrouted. Ví dụ:
+- "Summarize this article about climate change" vs "Answer this question about climate change"
+- Average embeddings gần nhau (same content), nhưng tasks khác nhau (summarization vs QA)
+
+**Mitigating factor**: Routing dựa trên TOÀN BỘ encoder layers (averaged), không chỉ embedding layer → higher layers encode task-type information → less likely to confuse.
+
+**Verdict**: Partial weakness, addressable but not currently addressed.
+
+## IV.3 "Representation drift là real nhưng chưa ai quantify"
+
+Khi thêm LoRA branches liên tiếp, input embeddings $h^{(l)}$ ở mỗi layer thay đổi (vì accumulated LoRA effects). Spectral signatures frozen → fit calculation trên drifted $h$ → routing quality degrades.
+
+GainLoRA's answer: `previous_trans_input` snapshots (frozen MLPs per task). SpecRoute: KHÔNG có mechanism nào cho drift.
+
+**Hypothesis**: Drift nhỏ vì LoRA rank thấp ($r = 4$), total modification rank ≤ 60 trong 1024 dims. 
+
+**CHƯA AI ĐO**.
+
+---
+
+# V. ĐỀ XUẤT PHƯƠNG PHÁP LUẬN — XÂY TỪ PHẦN SOLID
+
+## V.1 Core thesis (từ ý tưởng gốc của bạn, refined)
+
+> **Trong expandable LoRA CL, frozen expert weights encode đủ thông tin hình học (qua SVD spectral structure) để routing KHÔNG CẦN learned parameters. Routing parameter-free loại bỏ routing forgetting, đơn giản hóa training, giảm subspace consumption.**
+
+Đây là insight thật sự có giá trị từ quá trình suy nghĩ của bạn: từ I4 (geometric characterization) → rút gọn thành "spectral signatures are sufficient for routing".
+
+## V.2 Framework: 3 tầng (thay vì 3 "contributions" tách rời)
+
+### Tầng 1: Expert Geometry (I4 refined)
+
+**What**: Mỗi frozen expert $\Delta W_t = B_t A_t$ được characterize bằng spectral signature $\mathcal{S}_t = \{V_t, \Sigma_t\}$ from SVD.
+
+**Geometric interpretation**: Expert $t$ "lắng nghe" tập input directions $\{v_{t,i}\}$, với sensitivity $\sigma_{t,i}^2$. Tập hợp các sensitivity levels tạo thành ellipsoidal pattern trên input space (dúng I4, refined sang đúng space).
+
+**Tại sao grounded**:
+- SVD là unique factorization (up to sign) → deterministic
+- $V_t$ encode CHÍNH XÁC "expert operates on which input directions" (từ InfLoRA's Proposition 1)
+- Zero-replay compliant: computed from model params, not data
+- Immutable: computed from frozen weights
+
+### Tầng 2: Geometric Routing (I5 tinh thần + I6 rejected → softmax)
+
+**What**: Route input $h$ tới experts via weighted projection fit (Section IV.3 của SpecRoute). Competitive softmax routing.
+
+**Why softmax not OT**: (I6 rejected, đúng) — per-input, no balance needed, works at batch=1.
+
+**Why softmax not sigmoid**: Competitive → forces selection → inductive bias đúng cho non-overlapping tasks. Scale-stable ($\sum w = 1$).
+
+**Why projection fit not learned gating**: (Your core insight) — parameter-free, immutable, directly functional.
+
+**Geometric separation**: Thay vì SVM (I5 rejected), separation emerges NATURALLY from:
+- GPM đảm bảo $\text{span}(V_t) \approx \perp \text{span}(V_{t'})$
+- $\Rightarrow$ fit_t(h) high → fit_{t'}(h) low for $t' \neq t$
+- Không cần thêm penalty — orthogonality đã đảm bảo discriminative routing
+
+**Đây là insight sâu**: Bạn muốn max separation (I5) nhưng GPM ALREADY provides it. Hai mechanisms bù cho nhau:
+- GPM ensures orthogonal experts (structural separation)
+- Spectral routing exploits that orthogonality (functional separation)
+- Không cần penalty/SVM/OT thêm
+
+### Tầng 3: Capacity management (I1 + I2 refined)
+
+**What**: Quản lý subspace budget để tasks tương lai vẫn có đủ capacity.
+
+**From I1**: Subspace exhaustion là real — K constraints tích lũy, feasible manifold shrink.
+
+**From I2**: Pure penalty (loosen orthogonality) trái chiều. Pure hard lock (GPM increasing threshold) unfair.
+
+**Principled approach** (chưa implement, nhưng well-defined):
+- Importance-weighted protection: directions có $\sigma_i^2$ lớn → protect mạnh, $\sigma_i^2$ nhỏ → protect yếu hoặc release
+- Constant threshold ($\epsilon = 0.995$) → fair allocation (mỗi task protect cùng ratio)
+- Capacity monitoring: track $\dim(\mathcal{M}_{1:t})$ vs $d_{in}$ → alert nếu approaching exhaustion
+
+## V.3 Tại sao framework này khái quát cho CẢ LỚP BÀI TOÁN
+
+Framework không phụ thuộc vào:
+1. **Backbone**: T5, LLaMA, BERT (miễn có linear attention layers nơi LoRA applied)
+2. **Task type**: Generation, classification, QA (miễn dùng expandable LoRA)
+3. **Anti-forgetting method**: Compatible với GPM, InfLoRA, O-LoRA, CLoRA (miễn experts có null-space structure)
+4. **Number of tasks**: SVD + softmax scale linearly với T
+
+Nó cũng provide unified view cho existing methods:
+
+| Method | Expert Geometry | Routing | Anti-forgetting |
+|--------|----------------|---------|-----------------|
+| GainLoRA | Implicit (trong learned gate) | Learned (MLP + cosine) | GPM on all params |
+| InfLoRA | None (equal weight) | None (uniform) | Null-space init |
+| MINGLE | SVD for construction | Learned (MoE gate) | Null-space + EMA relax |
+| Feature Dist. | Mean feature vectors | Similarity matching | None explicit |
+| **This framework** | SVD spectral signature | Projection fit + softmax | GPM on LoRA only |
+
+---
+
+# VI. WHAT THIS FRAMEWORK CANNOT DO (honest)
+
+1. **Guarantee correct routing**: Projection fit is a proxy, not an oracle. If expert's input subspace doesn't uniquely identify task → routing errors.
+
+2. **Handle representation drift**: No explicit mechanism. Relies on hypothesis that low-rank LoRA → small drift. Unproven.
+
+3. **Solve subspace exhaustion completely**: Constant threshold is incremental improvement, not solution. True solution requires importance-weighted dynamic allocation (not implemented).
+
+4. **Claim novelty on ALL components**: Soft gate, SVD, GPM are all existing tools. Novelty is THE COMBINATION: "weight-derived spectral routing in CL" and "parameter-free routing eliminates routing forgetting".
+
+5. **Replace empirical validation**: Every claim above is theoretical. NOTHING is proven until experiments run.
+
+---
+
+# VII. HÓA GIẢI: TRAJECTORY CHÍNH XÁC CỦA TƯ DUY BẠN
+
+Nhìn lại toàn bộ discussion, trajectory tư duy của bạn:
+
+```
+Observation: CL = optimization trên manifold constrained (I1)
+  ↓
+Insight: Hard constraints cause exhaustion (I2) 
+  ↓
+Pivot: Soft gate for flexibility (I3)
+  ↓
+Key idea: LoRA geometry = ellipsoid, SVD captures it (I4) ← ĐÚNG NHẤT
+  ↓
+Over-engineering: SVM for max margin (I5) ← TINH THẦN ĐÚNG, TOOL SAI
+  ↓
+Over-engineering: OT for routing (I6) ← SAI CHO CL SETTING
+  ↓
+Abstraction: Distribution-based loss (I7) ← HƯỚNG ĐÚNG, CHI TIẾT CHƯA
+  ↓
+Self-correction: Reject OT → Projection fit + softmax (C2_analysis) ← XUẤT SẮC
+  ↓
+Final: SpecRoute — SVD signatures + projection routing + constant threshold
+```
+
+**Pattern**: Bắt đầu từ insight đúng (I1, I4) → overengineer (I5, I6) → bị AI inflate thay vì correct → tự nhận ra → simplify. Final product (SpecRoute) đơn giản hơn ban đầu — **đây là dấu hiệu tốt**.
+
+**Concern**: Trong quá trình simplify, bạn cũng bỏ đi một số ý hay:
+- I2 (capacity awareness) → ESA hiện tại quá đơn giản (constant threshold)
+- I5 tinh thần (geometry-aware separation) → không còn explicit mechanism, relies entirely on GPM's approximate orthogonality
+
+**Recommendation**: 
+- Xem ESA là **open problem**, không phải solved contribution
+- Grassmann distance monitoring (without penalty loss) có thể dùng làm **diagnostic tool** cho paper — track separation quality across tasks
+
+---
+
+# VIII. KHUYẾN NGHỊ CUỐI
+
+## Nếu mục tiêu là paper:
+
+1. **Core contribution tuyên bố**: "Parameter-free routing via spectral signatures of frozen LoRA weights eliminates routing forgetting." — Đây là novelty thật, verifiable, clean.
+
+2. **Thí nghiệm PHẢI CÓ**:
+   - SpecRoute vs GainLoRA (same benchmark, same data splits)
+   - Routing accuracy analysis (on held-out old tasks)
+   - Representation drift measurement
+   - Ablation: spectral fit vs prompt key vs random vs uniform
+
+3. **Đừng claim ESA (C3)**: Constant threshold không đủ mạnh. Hoặc develop importance-weighted version, hoặc merge vào hyperparameter section.
+
+4. **Position vs Feature Distributions (ICML 2025)**: Closest competitor. Their key = store mean feature vectors (data-level). Your key = store SVD of frozen weights (weight-level). Both are "characterization + similarity routing", but you are zero-replay clean, they arguably are not.
+
+## Nếu mục tiêu là methodology cho cả lớp bài toán:
+
+1. **Formalize "Expert Characterization Problem"**: Given frozen expert weights, what is the optimal characterization for downstream routing? SVD là 1 answer, nhưng framework nên define CRITERIA (immutable, functional, discriminative, compact) rồi show SVD satisfies all.
+
+2. **Formalize "Routing Correctness"**: Define routing accuracy operationally, prove that projection fit + orthogonal experts → routing accuracy ≥ threshold.
+
+3. **Formalize "Capacity Budget"**: Given $d_{in}$ dims, $T$ tasks, what is the maximum information each task can claim while maintaining minimum routing quality? This is the real open problem.
+
+4. **CHẠY THÍ NGHIỆM trước khi viết thêm.** Bạn đã nghĩ đủ nhiều. Code đã có. Kết quả thực nghiệm sẽ cho biết framework có value không — nếu không win trên numbers, lý thuyết đẹp bao nhiêu cũng không đủ.