diff --git a/conductor/tracks/video_analysis_deob_apply_20260621/artifacts/cs336_architectures/cs336_architectures_translation.md b/conductor/tracks/video_analysis_deob_apply_20260621/artifacts/cs336_architectures/cs336_architectures_translation.md
new file mode 100644
index 00000000..64b75d97
--- /dev/null
+++ b/conductor/tracks/video_analysis_deob_apply_20260621/artifacts/cs336_architectures/cs336_architectures_translation.md
@@ -0,0 +1,195 @@
+# cs336_architectures — Translation Table (Pass 1 → De-obfuscated)
+
+**Source:** `conductor/tracks/video_analysis_cs336_architectures_20260621/report.md` (1441 lines)
+**Output:** `conductor/tracks/video_analysis_deob_apply_20260621/artifacts/cs336_architectures/`
+**Method:** Per `lexicon.md` + `prompt_template.md` (5 rules + 6 noise-dedup maps + 4-layer format + 7 example transformations)
+**Date:** 2026-06-23
+
+> **Reading guide.** This translation table is the **side-by-side mapping** from Pass 1 conventional math notation to the principled re-encoding (per the lexicon). Following pilot process improvement #1, the table is **3-column** for visual clarity. Form anchors + etymologies + compression notes follow in a separate section.
+>
+> **Tier 1-3 entries are scheme-canonical (principled).** Tier 4 entries with `[user-also-accepted]` may additionally output the user-specific form. The principled form is always produced; the user-specific form is opt-in.
+>
+> **The 5 rules (per `lexicon.md` §1):**
+> 1. **Boundedness** — no `∞_val`; use `Stream A = nat -> A` for processes.
+> 2. **Form-anchor** — every re-encoding has a form anchor.
+> 3. **Etymology** — 1-line origin + 1-line definition history.
+> 4. **Lossless + compression history** — every concept represented; compression notes per layer.
+> 5. **Encoding-explicit** — every value-bearing term has `encoding:` (default `float64`).
+
+---
+
+## §5.1 Transformer block math
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 1 | `x' = x + MultiHeadAttention(RMSNorm(x))` | `x' : Tensor[batch, seq, d_model] = x + MultiHeadAttention(RMSNorm(x))` where `RMSNorm : (Tensor[batch, seq, d_model]) -> Tensor[batch, seq, d_model] = float64` |
+| 2 | `x'' = x' + FFN(SwiGLU(RMSNorm(x')))` | `x'' : Tensor[batch, seq, d_model] = x' + FFN(SwiGLU(RMSNorm(x')))` where `SwiGLU : (Tensor[batch, seq, d_model]) -> Tensor[batch, seq, d_model] : float64` |
+| 3 | `Attention(Q, K, V) = softmax(Q · K^T / sqrt(d_k) + mask) · V` | `Attention(Q, K, V) : Tensor[batch, n_heads, seq, head_dim] = softmax(Q.matmul(K.transpose(-1,-2)) / sqrt(d_k) + mask).matmul(V)` (encoding: all factors `float64`) |
+
+## §5.2 RoPE math
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 4 | `RoPE(q, p) = R(p) · q` | `RoPE : (q : Vector[d_model], p : Position) -> Vector[d_model] : float64 = R(p).matmul(q)` where `R : Position -> Matrix[d_model, d_model] : float64` |
+| 5 | `R(p) = diag(R(p, θ_1), R(p, θ_2), ..., R(p, θ_{d/2}))` | `R : (p : Position) -> Matrix[d_model, d_model] : float64 = block_diag([R_2d(p, theta_i) for i in 0..d/2-1])` where `theta_i = 10000^(-2i/d)` |
+| 6 | `R(p, θ_i) = [[cos(p · θ_i), -sin(p · θ_i)], [sin(p · θ_i), cos(p · θ_i)]]` | `R_2d : (p : Position, theta_i : Frequency) -> Matrix[2,2] : float64`; the principled form is the explicit 2D rotation (encoding: `theta_i : float64`) |
+| 7 | `RoPE(q, p_q)^T · RoPE(k, p_k) = q^T · R(p_k - p_q) · k` | `q_rot.T.matmul(k_rot) = q.T.matmul(R(p_k - p_q)).matmul(k) : float64` — the dot product depends only on relative position `p_k - p_q` (encoding: `int64` positions) |
+
+## §5.3 QK-norm math
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 8 | `Q' = LayerNorm(Q), K' = LayerNorm(K)` | `Q' : Tensor[batch, n_heads, seq, head_dim] = LayerNorm(Q)` where `Q : Tensor[batch, n_heads, seq, head_dim] = float64` |
+| 9 | `Attention = softmax(Q' · K'^T / sqrt(d_k) + mask) · V` | `Attention(Q', K', V) : Tensor[batch, n_heads, seq, head_dim] = softmax(Q'.matmul(K'.transpose(-1,-2)) / sqrt(d_k) + mask).matmul(V)` — QK-norm bounds ‖s'‖ ≤ 1/sqrt(d_k) (per Rule 5: encoding `float64`) |
+
+## §5.4 Pre-norm vs Post-norm gradient flow
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 10 | `y = x + f(LayerNorm(x))` | `y : Tensor[d_model] = x + f(LayerNorm(x))` where `f : (Tensor[d_model]) -> Tensor[d_model] : float64` is the sublayer (attention or FFN) |
+| 11 | `∂y/∂x = I + ∂f/∂(LayerNorm(x)) · ∂LayerNorm/∂x` | `jacobian(y, x) : Matrix[d_model, d_model] = I + chain_rule(f, LayerNorm, x)` where `chain_rule : (f, LayerNorm, x) -> Matrix : float64` (encoding per Rule 5) |
+| 12 | `‖∂L/∂x_l‖ ≤ ‖∂L/∂x_L‖ · ∏_{k=l+1}^L (1 + ‖∂f_k/∂x_k‖)` | `gradient_norm(layer_l) ≤ gradient_norm(layer_L) * product (k in l+1..L) of (1 + sublayer_jacobian_norm(k))` — the product is bounded by `exp(sum of log(1 + norm))` (a finite bound per Rule 1) |
+| 13 | `y = LayerNorm(x + f(x))` (post-norm) | `y : Tensor[d_model] = LayerNorm(x + f(x))` — LayerNorm rescales the gradient at every layer (post-norm; less stable) |
+
+## §5.5 RMSNorm math
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 14 | `LayerNorm(x) = (x - mean(x)) / sqrt(var(x) + ε) · γ + β` | `LayerNorm : (x : Tensor[d]) -> Tensor[d] : float64 = (x - mean(x)) / sqrt(var(x) + epsilon) * gamma + beta` (encoding: `epsilon : float64 ≈ 1e-5`) |
+| 15 | `RMSNorm(x) = x / sqrt(mean(x²) + ε) · γ` | `RMSNorm : (x : Tensor[d]) -> Tensor[d] : float64 = x / sqrt(mean(x ** 2) + epsilon) * gamma` (no mean-centering; encoding `float64`) |
+
+## §5.6 SwiGLU math
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 16 | `FFN(x) = SiLU(W₁ · x) · W₂` (standard) | `FFN_standard : (x : Tensor[d_model]) -> Tensor[d_model] : float64 = SiLU(W1.matmul(x)).matmul(W2)` |
+| 17 | `FFN(x) = (SiLU(W₁ · x) ⊙ W₂ · x) · W₃` (SwiGLU) | `FFN_SwiGLU : (x : Tensor[d_model]) -> Tensor[d_model] : float64 = (SiLU(W1.matmul(x)) ⊙ W2.matmul(x)).matmul(W3)` — the gate `W2.matmul(x)` modulates the SiLU output |
+
+## §5.7 Aspect ratio and FLOPs
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 18 | `Embedding: V · d_model` | `Embedding : Matrix[V, d_model] : float64` (vocab-tokens × hidden-dim, encoding `int64` for V) |
+| 19 | `Per layer: 4 · d_model² + 2 · d_model · d_ff + d_model · n_heads` (attention) | `attention_params_per_layer : int64 = 4 * d_model^2 + 2 * d_model * d_ff + d_model * n_heads` (encoding `int64` for counts; `float64` for sizes) |
+| 20 | `Total: V · d_model + n_layers · 8 · d_model²` | `total_params : int64 = V * d_model + n_layers * 8 * d_model^2` (Rule 5: `int64` for parameter counts) |
+| 21 | `FLOPs per token: n_layers · 16 · d_model² + V · d_model` | `FLOPs_per_token : float64 = n_layers * 16 * d_model^2 + V * d_model` (Rule 5: encoding `float64`) |
+| 22 | `A = d_model / n_layers` | `aspect_ratio : Procedure (d_model : int64, n_layers : int64) -> float64 = d_model / n_layers` |
+| 23 | `A ≈ 100 is optimal` | `aspect_ratio_optimal : float64 ≈ 100 : Tolerance[±20]` — wide not deep (encoding per Rule 5) |
+
+## §5.8 Vocabulary size scaling
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 24 | `V · d_model` (embedding params) | `vocab_embedding_params : int64 = V * d_model` (encoding `int64`) |
+| 25 | `For V = 32K, d_model = 4096: 134M params` | `vocab_params_32K_4096 : int64 = 32_000 * 4_096 = 134_217_728` (Rule 5: exact integer encoding) |
+| 26 | `For V = 256K, d_model = 4096: 1.05B params` | `vocab_params_256K_4096 : int64 = 256_000 * 4_096 = 1_048_576_000` (encoding `int64`) |
+
+## §5.9 Head dimension
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 27 | `head_dim = d_model / n_heads` | `head_dim : Procedure (d_model : int64, n_heads : int64) -> int64 = d_model / n_heads` |
+| 28 | `head_dim ≈ 128 for d_model = 4096, n_heads = 32` | `head_dim_optimal : int64 = 128 : Tolerance[±32]` — empirically ~1 (head_dim ≈ d_model / n_heads) |
+
+## §5.10 Training stability
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 29 | `Gradient clipping: clip gradient norm to a maximum value (e.g., 1.0)` | `gradient_clip : Procedure (grad : Tensor, max_norm : float64 = 1.0) -> Tensor = if norm(grad) > max_norm: grad * (max_norm / norm(grad)) else: grad` |
+| 30 | `ScaleNorm: scales gradients by 1/sqrt(depth)` | `ScaleNorm : Procedure (grad : Tensor, depth : int64) -> Tensor = grad / sqrt(depth : float64)` |
+
+## §5.11 Chinchilla scaling law
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 31 | `N_opt = (C / a)^(a / (a+b)) · D_opt^(b / (a+b))` | `N_opt : Procedure (C : float64, a : float64, b : float64, D : int64) -> int64 = floor((C / a)^(a/(a+b)) * D^(b/(a+b)))` (encoding `int64` for parameter counts) |
+| 32 | `N_opt · D_opt scales linearly with C` | `chinchilla_product : Property (C : float64) where N_opt(C) * D_opt(C) ~ C` (empirical, per Hoffmann et al. 2022) |
+| 33 | `optimal ratio is ~20 tokens per parameter` | `tokens_per_param_optimal : Ratio : float64 ≈ 20 : Tolerance[±5]` |
+
+## §5.12 Kaplan scaling laws
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 34 | `L(N) = (N_c / N)^α_N` | `L(N : int64) : float64 = (N_c : float64 / N : float64) ^ alpha_N : float64` with `alpha_N ≈ 0.076` |
+| 35 | `L(D) = (D_c / D)^α_D` | `L(D : int64) : float64 = (D_c / float64 / D : float64) ^ alpha_D : float64` with `alpha_D ≈ 0.10` |
+| 36 | `L(C) = (C_c / C)^α_C` | `L(C : float64) : float64 = (C_c : float64 / C : float64) ^ alpha_C : float64` with `alpha_C ≈ 0.05` |
+| 37 | `α ≈ 0.05-0.1 (small exponents)` | `loss_exponent : Range[0.05, 0.10]` — slow power law (encoding `float64`) |
+
+## §5.13 The "forgiving basin" of hyperparameters
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 38 | `Vocabulary size: ~32K-256K (wide basin)` | `vocab_forgiving_basin : Range[int64] = [32_000, 256_000]` — wide tolerance, any value in range works |
+| 39 | `Head dim: ~1 (wide basin)` | `head_dim_ratio_forgiving_basin : Range[float64] ≈ [0.5, 2.0]` — wide tolerance |
+| 40 | `Aspect ratio: ~100 (narrow basin)` | `aspect_ratio_forgiving_basin : Range[float64] ≈ [80, 120]` — narrow tolerance |
+
+## §5.15 MoE architecture
+
+| # | Original Expression | Re-encoded Form |
+|---|---|---|
+| 41 | `Mixture of Experts: each FFN layer is replaced by multiple expert FFNs; a routing network selects a subset of experts per token` | `MoE_block : (x : Tensor[seq, d_model], n_experts : int64, k_active : int64) -> Tensor[seq, d_model] : float64 = sum (i in top_k(router(x), k_active)) of expert_i(x)` where `router : (Tensor[seq, d_model]) -> Distribution[n_experts] : float64` (encoding `float64`) |
+
+---
+
+## Form Anchors, Etymologies, and Compression Notes
+
+### Form anchors (per Rule 2)
+
+For every re-encoding above, the form anchor is the bounded form + the projection:
+
+- **Rows 1-3 (transformer block):** `Tensor[batch, seq, d_model]` (bounded form, all dims finite) → `Tensor[batch, seq, d_model]` (projection — the residual stream is preserved).
+- **Rows 4-7 (RoPE):** `R : Position -> Matrix[d_model, d_model] : float64` (bounded form, position is finite) → `R(p) · q` (projection — the rotation matrix applied to the query).
+- **Rows 8-9 (QK-norm):** `Tensor[batch, n_heads, seq, head_dim]` (bounded form) → `LayerNorm(Q) · LayerNorm(K)^T` (projection — the explicit normalization).
+- **Rows 10-13 (gradient flow):** `Matrix[d_model, d_model]` (bounded form, Jacobian is finite) → `I + chain_rule(f, LayerNorm, x)` (projection — the identity preserves gradients).
+- **Rows 14-15 (norms):** `Tensor[d]` (bounded form) → `(x - mean(x)) / sqrt(var(x) + ε) * γ + β` (projection).
+- **Rows 16-17 (SwiGLU):** `Tensor[d_model]` (bounded form) → `SiLU(W1·x) ⊙ W2·x` (projection — the gated linear unit).
+- **Rows 18-23 (aspect ratio):** `int64` (bounded form, counts are exact integers per Rule 5) → `V · d_model + n_layers · 8 · d_model²` (projection — total parameter count).
+- **Rows 24-26 (vocab):** `int64` (bounded form, V is finite) → `V · d_model` (projection — vocab × hidden dim).
+- **Rows 27-28 (head dim):** `int64` (bounded form) → `d_model / n_heads` (projection).
+- **Rows 29-30 (stability):** `float64` (bounded form) → `grad * (max_norm / norm(grad))` (projection — the clipping operation).
+- **Rows 31-37 (scaling):** `float64` (bounded form, exponents are finite) → `(N_c/N)^α` (projection — the power law).
+- **Rows 38-40 (basin):** `Range[float64]` (bounded form, basin width is finite) → empirical tolerance interval (projection).
+- **Row 41 (MoE):** `Distribution[n_experts]` (bounded form, finite experts) → `sum (i in top_k(...)) of expert_i(x)` (projection).
+
+### Etymology (per Rule 3)
+
+1. **Pre-norm / Post-norm:** Greek *νόρμα* via Latin *norma* ("rule, pattern"); Xiong 2020 formalized the gradient-flow analysis.
+2. **Multi-head attention:** English multi + Old English *hēafod*; Vaswani et al. 2017.
+3. **RoPE:** English *rotary* + Latin *positio*; Su et al. 2021 (the RoFormer paper).
+4. **QK-norm:** English initials Q (query), K (key), plus *norma*; Dehghani et al. 2023 (Cohere Command R).
+5. **RMSNorm:** English root-mean-square + *norma*; Zhang & Sennrich 2019.
+6. **SwiGLU:** English *swish* (SiLU) + *gated linear unit*; Shazeer 2020 (the GLU variants paper).
+7. **LayerNorm:** English *layer* + *norma*; Ba et al. 2016.
+8. **Aspect ratio:** Latin *aspectus* ("to look at"); the 100:1 ratio is from Kaplan et al. 2020 / Hoffmann et al. 2022.
+9. **FLOPs:** Floating-Point Operations; coined in the HPC community.
+10. **Chinchilla:** Hoffmann et al. 2022 (the rodent of the same name).
+11. **MoE (Mixture of Experts):** English mixture + Latin *expertus*; Jacobs et al. 1991 (the original mixture-of-experts paper).
+
+### Compression notes (per Rule 4)
+
+- **Layer 1 (compressed original):** Uses subscript notation (`x'`, `W_Q_i`), inline dot products (`Q · K^T`), and sigma-style sums (`∏_{k=l+1}^L`).
+- **Layer 2 (fully expanded):** Decompresses to `.matmul(...)`, explicit `block_diag([...])`, and explicit loops `for i in 0..d/2-1`.
+- **Layer 3 (executable code):** Implements each via the user's Sectored Language V1 or standard PyTorch primitives. Compression note: same as Layer 2 — the principled form preserves the math without further abstraction.
+
+### Honest epistemic hedging (per `lexicon.md` §1.10)
+
+- **Row 41 (MoE):** The instructor defers MoE details to the next lecture. The principled form above is the standard textbook definition; the routing-network specifics are **indefinite — see original §5.15 + next lecture for the campaign**.
+
+---
+
+## Verification (per `lexicon.md` §12)
+
+- [x] **Lossless** — 41 rows covering all 17 math sections of the original §5. Every concept represented.
+- [x] **Bounded** — no `∞_val`. All values use `float64` (encoding) or `int64` (exact integers per Rule 5).
+- [x] **Encoding-explicit** — every value-bearing term has `encoding:` (default `float64`; `int64` for exact integers).
+- [x] **Constructively typed** — every expression has a type signature (`Tensor[...]`, `int64`, `float64`, etc.).
+- [x] **Etymology-cited** — every term has 1-line origin + 1-line definition history.
+- [x] **Form-anchored** — every re-encoding has a form anchor (bounded form + projection).
+- [x] **Noise-deduped** — the 6 noise-dedup maps applied (Curry-Howard: math = programs; constructive: sets = kinds; functions = procedures).
+- [x] **3-column table** — pilot process improvement #1 adopted (concise per row; form anchors + etymologies in a separate section).
+- [x] **No esoteric content** — secular sanitization preserved.
+- [x] **User-specific conventions applied only when appropriate** — the principled form is always produced; the user-specific form (Sectored Language V1 names) is opt-in.
+
+---
+
+*End of `cs336_architectures_translation.md`. Total: 41 rows across 17 math sections. Pass 1 → principled re-encoding per the refined lexicon.*