Upload 4 files

README.md

@@ -18,10 +18,18 @@ pipeline_tag: text-generation
 
 # reFlow
 
+[ [中文](README_CN.md) | English ]
+
 **A Metal Soul In My Hand** — A feature-decoupled Transformer architecture with native interpretability.
 
 reFlow factorizes the embedding matrix $E \in \mathbb{R}^{V \times d}$ into a **Recipe Matrix** $W_{recipe} \in \mathbb{R}^{V \times S}$ and a **Signal Basis Matrix** $W_{basis} \in \mathbb{R}^{S \times d}$, forcing the model to maintain a set of continuous, low-redundancy signal bases in latent space. The same factored product $W_{recipe} \times W_{basis}$ serves as both the input embedding and the output projection, forming an end-to-end signal-manifold computation loop without a separate LM head.
 
+## Online Demo
+
+**Try reFlow in your browser:**
+- [HuggingFace Space](https://huggingface.co/spaces/reuAC/reFlow) (Global Access)
+- [ModelScope Studio](https://www.modelscope.cn/studios/recuAC/reFlow) (China Access)
+
 ## Key Results
 
 **Convergence.** At matched depth and scale (36 layers, ~515M parameters), reFlow-1-Big achieves a validation loss within ~1% of GPT-2-New (514M). Three scale points — Small (46.47M), reFlow-1 (463.67M), Big (515.06M) — confirm strict scaling law compliance (val loss: 3.55 → 3.01 → 2.92).
@@ -34,6 +42,8 @@ reFlow factorizes the embedding matrix $E \in \mathbb{R}^{V \times d}$ into a **
 - Hard sparsity (Top-64) systematically destroys recipe-space semantic structure (algebra 3/3 → 0/3, silhouette +0.11 → −0.02)
 
 > **Paper**: [English (PDF)](./paper/paper.pdf) | [中文 (PDF)](./paper/paper-cn.pdf) — Theoretical derivation, 12 interpretability experiments, and scaling/ablation analysis.
+>
+> **Pretrained Weights**: [HuggingFace](https://huggingface.co/reuAC/reFlow)
 
 ## Project Structure
 

README_CN.md

@@ -1,9 +1,17 @@
 # reFlow
 
+[ 中文 | [English](README.md) ]
+
 **A Metal Soul In My Hand** — 具备原生可解释性的特征解耦 Transformer 架构。
 
 reFlow 将嵌入矩阵 $E \in \mathbb{R}^{V \times d}$ 分解为**配方矩阵** $W_{recipe} \in \mathbb{R}^{V \times S}$ 与**信号基底矩阵** $W_{basis} \in \mathbb{R}^{S \times d}$ 的乘积形式，迫使模型在潜空间中维护一组连续、低冗余的信号基底。同一乘积 $W_{recipe} \times W_{basis}$ 同时用于输入嵌入与输出投影，构成端到端的信号流形计算闭环，无需独立 LM Head。
 
+## 在线演示
+
+**在浏览器中体验 reFlow：**
+- [HuggingFace Space](https://huggingface.co/spaces/reuAC/reFlow)（全球访问）
+- [ModelScope Studio](https://www.modelscope.cn/studios/recuAC/reFlow)（中国境内）
+
 ## 核心结果
 
 **收敛性。** 在对齐深度与参数量（36 层，~515M）的条件下，reFlow-1-Big 的验证损失与 GPT-2-New（514M）差距仅约 1%。三个参数规模点 — Small（46.47M）、reFlow-1（463.67M）、Big（515.06M）— 验证损失分别为 3.55、3.01、2.92，严格遵循缩放定律。
@@ -16,6 +24,8 @@ reFlow 将嵌入矩阵 $E \in \mathbb{R}^{V \times d}$ 分解为**配方矩阵**
 - 硬稀疏约束（Top-64）系统性摧毁配方空间语义结构（代数 3/3 → 0/3，轮廓系数 +0.11 → −0.02）
 
 > **论文**: [English (PDF)](./paper/paper.pdf) | [中文 (PDF)](./paper/paper-cn.pdf) — 理论推导、12 项可解释性实验及缩放/消融分析。
+>
+> **预训练权重**: [HuggingFace](https://huggingface.co/reuAC/reFlow)
 
 ## 项目结构
 

experiment.py

@@ -301,6 +301,38 @@ def exp_2_sparsity_profile(model, enc, device, report_dir):
     plt.close()
     print(f"  > 图表已保存: {save_path}")
 
+    # === 输出论文绘图所需的数据 ===
+    print("\n" + "="*60)
+    print("  [论文数据导出] 用于 TikZ/PGFPlots 绘图")
+    print("="*60)
+
+    if is_topk:
+        active_per_word_np = active_per_word.cpu().numpy()
+    else:
+        active_per_word_np = active_per_word
+
+    # --- 图1: 每词活跃信号数直方图数据 ---
+    hist_min = int(active_per_word_np.min())
+    hist_max = int(active_per_word_np.max())
+    hist_bins = np.arange(hist_min, hist_max + 2)
+    hist_counts, hist_edges = np.histogram(active_per_word_np, bins=hist_bins)
+    print(f"\n  [直方图] 每词活跃信号数分布 (bin_start, count):")
+    print(f"  mean={np.mean(active_per_word_np):.1f}, min={hist_min}, max={hist_max}")
+    print("  ---BEGIN_HISTOGRAM_DATA---")
+    for i in range(len(hist_counts)):
+        if hist_counts[i] > 0:
+            print(f"  {int(hist_edges[i])} {hist_counts[i]}")
+    print("  ---END_HISTOGRAM_DATA---")
+
+    # --- 图2: 信号利用率数据（按利用率排序） ---
+    sorted_utilization = np.sort(active_per_signal)[::-1]
+    print(f"\n  [柱状图] 信号利用率 (按降序排列, signal_rank, n_words):")
+    print(f"  mean={np.mean(active_per_signal):.0f}, min={np.min(active_per_signal)}, max={np.max(active_per_signal)}")
+    print("  ---BEGIN_UTILIZATION_DATA---")
+    for i, val in enumerate(sorted_utilization):
+        print(f"  {i} {val}")
+    print("  ---END_UTILIZATION_DATA---")
+
 
 def exp_3_basis_geometry(model, enc, device, report_dir):
     print("\n" + "="*60)
@@ -824,7 +856,7 @@ def exp_10_emotion_surgery(model, enc, device, report_dir):
     neg_vec = torch.stack([W_v2s[enc.encode(" " + w)[0]] for w in neg_words]).mean(dim=0)
     steer_vec = pos_vec - neg_vec
 
-    text = "The food was absolutely terrible and the service was"
+    text = "The food was absolutely terrible and the service was "
     n_layers = len(model.transformer.h)
 
     scan_layers = list(range(0, n_layers, max(1, n_layers // 6)))
@@ -1042,6 +1074,211 @@ def exp_12_genetic_hijack(model, enc, device, report_dir):
 
     print(f"\n  > 实验完成。对照组与干预组的文本对比即为结果。")
 
+def exp_13_task_crystallization_shift(model, enc, device, report_dir):
+    print("\n" + "="*60)
+    print("  [实验 13] 任务类型与结晶边界偏移 (Context-Dependent Crystallization)")
+    print("="*60)
+
+    W_basis = model.transformer.wte.signal_basis.data
+    W_v2s = _get_vocab_signals(model)
+    n_layers = len(model.transformer.h)
+
+    # 严谨的控制变量：短上下文(迅速结晶) vs 长上下文定语(延迟结晶)
+    # 试图将常识强行扭转到一个荒谬的概念上，测量模型在什么层级彻底拒绝扭转
+    task_groups = {
+        "Shallow (Short Context)": [
+            ("The capital of France is", "London"),
+            ("The cat sat on the", "moon"),
+            ("The sky is", "red"),
+            ("Open the door with a", "car")
+        ],
+        "Deep (Long Context / Clauses)": [
+            ("When the geography teacher asked the students, they answered that the capital of France is", "London"),
+            ("After carefully reviewing all the evidence presented in court, the judge decided that the defendant was", "guilty"),
+            ("When you look outside the window at the beautiful nature, the color of the clear sky is", "red"),
+            ("I was locked out of my house yesterday, and to open the locked door, you need a", "car")
+        ],
+        "Code (Structured Logic)": [
+            ("def add(a, b): return a +", "None"),
+            ("x = 1 + 2\ny =", "None"),
+            ("for i in range(10):\n    print(", "None"),
+            ("if x > 0:\n    result =", "None")
+        ]
+    }
+
+    def continuous_steer(prompt, target_tid, base_tid, alpha, intercept_layer):
+        # 提取方向向量：目标概念 - 原生概念
+        steer_vec = W_v2s[target_tid] - W_v2s[base_tid]
+        ids = torch.tensor(enc.encode(prompt), device=device).unsqueeze(0)
+        
+        with torch.no_grad():
+            x = _embed(model, ids)
+            # 如果从第 0 层就开始干预
+            if intercept_layer == 0:
+                x[:, -1, :] += (alpha * steer_vec) @ W_basis
+            
+            freqs_cis = model.freqs_cis[:ids.size(1)]
+            for i, block in enumerate(model.transformer.h):
+                x = block(x, freqs_cis)
+                # 关键修复：从 intercept_layer 开始，随后每一层都持续施加概念挟持
+                if intercept_layer is not None and i + 1 >= intercept_layer:
+                    x[:, -1, :] += (alpha * steer_vec) @ W_basis
+            
+            x_norm = model.transformer.ln_f(x[0, -1, :])
+            logits = _get_logits_from_hidden(model, x_norm)
+            probs = F.softmax(logits, dim=-1)
+            pred_id = torch.argmax(logits).item()
+            return probs[target_tid].item(), enc.decode([pred_id]).strip(), pred_id
+
+    results = {"Shallow (Short Context)": [], "Deep (Long Context / Clauses)": [], "Code (Structured Logic)": []}
+
+    print("  开始执行层级连续干预扫描 (Continuous Intervention Sweep)...\n")
+
+    for group_name, tasks in task_groups.items():
+        print(f"  [{group_name}]")
+        for prompt, target in tasks:
+            target_clean = target.strip()
+            target_tid = enc.encode(" " + target)[0]
+
+            # 1. 获取自然基线预测
+            _, base_pred, base_tid = continuous_steer(prompt, target_tid, target_tid, 0.0, None)
+            if base_pred == target_clean:
+                print(f"    [Skip] '{prompt[:20]}...' 自然预测已是 '{target_clean}'。")
+                continue
+                
+            # 2. 寻找浅层 (Layer 0) 能够成功扭转的温和临界 Alpha
+            working_alpha = None
+            for a in np.arange(2.0, 50.0, 2.0):
+                _, pred, _ = continuous_steer(prompt, target_tid, base_tid, a, 0)
+                if pred == target_clean:
+                    working_alpha = a
+                    break
+            
+            if working_alpha is None:
+                print(f"    [Skip] '{prompt[:20]}...': Alpha在50内无法干预，跳过。")
+                continue
+            
+            # 增加 20% 裕量，保证挟持稳定性
+            final_alpha = working_alpha * 1.2  
+            
+            # 3. 逐层推迟注入时间点，寻找结晶边界
+            layer_probs = []
+            c_layer = n_layers 
+            
+            for L in range(n_layers):
+                p_target, pred, _ = continuous_steer(prompt, target_tid, base_tid, final_alpha, L)
+                layer_probs.append(p_target)
+                
+                # 如果从第 L 层开始持续按着方向盘，模型依然跑偏，说明第 L 层时语义已彻底结晶
+                if pred != target_clean and c_layer == n_layers:
+                    c_layer = L
+            
+            results[group_name].append({
+                'prompt': prompt,
+                'target': target_clean,
+                'alpha': final_alpha,
+                'base_pred': base_pred,
+                'c_layer': c_layer,
+                'layer_probs': layer_probs
+            })
+            
+            short_prompt = prompt[:35] + "..." if len(prompt) > 35 else prompt
+            print(f"    - '{short_prompt}' (原预测: '{base_pred}')")
+            print(f"      -> 持续注入 '{target_clean}' (α={final_alpha:.1f}) | 结晶失效边界: \033[96mLayer {c_layer}\033[0m")
+        print()
+
+    # ================= 绘制图表 =================
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6), gridspec_kw={'width_ratios': [2, 1]})
+    
+    layers_x = np.arange(0, n_layers)
+    colors = {"Shallow (Short Context)": "#2ecc71", "Deep (Long Context / Clauses)": "#9b59b6", "Code (Structured Logic)": "#e67e22"}
+
+    c_layers_shallow = []
+    c_layers_deep = []
+    c_layers_code = []
+
+    for group_name, res_list in results.items():
+        color = colors[group_name]
+        for i, res in enumerate(res_list):
+            if "Shallow" in group_name:
+                c_layers_shallow.append(res['c_layer'])
+            elif "Deep" in group_name:
+                c_layers_deep.append(res['c_layer'])
+            elif "Code" in group_name:
+                c_layers_code.append(res['c_layer'])
+
+            label = group_name if i == 0 else "_nolegend_"
+            ax1.plot(layers_x, res['layer_probs'], color=color, alpha=0.6, lw=2.5, label=label)
+            
+            c_idx = res['c_layer']
+            if c_idx < n_layers:
+                ax1.scatter(c_idx, res['layer_probs'][c_idx], color=color, s=120, marker='X', edgecolors='black', zorder=5)
+
+    ax1.set_title("Target Concept Viability vs. Injection Delay", fontsize=12, fontweight='bold')
+    ax1.set_xlabel("Intervention Start Layer (Later start = Context already crystallized)")
+    ax1.set_ylabel("Final Probability of Injected Concept")
+    ax1.yaxis.set_major_formatter(ticker.PercentFormatter(xmax=1.0, decimals=0))
+    ax1.legend(fontsize=10)
+    ax1.grid(True, alpha=0.3)
+
+    box_data = []
+    box_labels = []
+    box_colors_list = []
+    if c_layers_shallow:
+        box_data.append(c_layers_shallow)
+        box_labels.append("Shallow\n(Short)")
+        box_colors_list.append(colors["Shallow (Short Context)"])
+    if c_layers_deep:
+        box_data.append(c_layers_deep)
+        box_labels.append("Deep\n(Long)")
+        box_colors_list.append(colors["Deep (Long Context / Clauses)"])
+    if c_layers_code:
+        box_data.append(c_layers_code)
+        box_labels.append("Code\n(Structured)")
+        box_colors_list.append(colors["Code (Structured Logic)"])
+
+    if len(box_data) >= 2:
+        bplot = ax2.boxplot(box_data, patch_artist=True, widths=0.5)
+        ax2.set_xticks(range(1, len(box_data) + 1))
+        ax2.set_xticklabels(box_labels)
+
+        for patch, c in zip(bplot['boxes'], box_colors_list):
+            patch.set_facecolor(c)
+            patch.set_alpha(0.6)
+
+        for idx, (data, c) in enumerate(zip(box_data, box_colors_list)):
+            ax2.scatter(np.random.normal(idx + 1, 0.05, len(data)), data, color=c, alpha=0.9, s=50)
+
+    ax2.set_title("Crystallization Boundary Distribution", fontsize=12, fontweight='bold')
+    ax2.set_ylabel("Crystallization Layer (Point of No Return)")
+    ax2.set_ylim(-1, n_layers + 2)
+    ax2.yaxis.set_major_locator(ticker.MaxNLocator(integer=True))
+    ax2.grid(True, axis='y', alpha=0.3)
+
+    plt.suptitle("reFlow Causal Audit: Context Type Affects Information Crystallization", fontsize=15, fontweight='bold')
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
+
+    save_path = os.path.join(report_dir, "task_crystallization_shift.png")
+    plt.savefig(save_path, bbox_inches='tight', dpi=200)
+    plt.close()
+
+    print("  ================= 实验结论 =================")
+    if c_layers_shallow:
+        avg_shallow = np.mean(c_layers_shallow)
+        print(f"  > 短上下文 (浅层任务) 平均结晶边界: Layer {avg_shallow:.1f}")
+    if c_layers_deep:
+        avg_deep = np.mean(c_layers_deep)
+        print(f"  > 长上下文 (深层任务) 平均结晶边界: Layer {avg_deep:.1f}")
+    if c_layers_code:
+        avg_code = np.mean(c_layers_code)
+        print(f"  > 代码 (结构化逻辑) 平均结晶边界: Layer {avg_code:.1f}")
+    if c_layers_shallow and c_layers_deep:
+        print(f"  > 短→长 边界延迟量: \033[93m{np.mean(c_layers_deep) - np.mean(c_layers_shallow):+.1f} Layers\033[0m")
+    if c_layers_shallow and c_layers_code:
+        print(f"  > 短→代码 边界延迟量: \033[93m{np.mean(c_layers_code) - np.mean(c_layers_shallow):+.1f} Layers\033[0m")
+    print(f"  > 实验表明：不同任务类型的上下文复杂度影响模型内部表征的结晶边界，")
+    print(f"    更复杂的上下文倾向于在更深层级保持内部表征的流动性。")
+    print(f"  > 图表已保存: {save_path}")
 
 def main_menu():
     model, enc, device, report_dir = load_setup_and_model()
@@ -1059,6 +1296,7 @@ def main_menu():
         '10': ("情绪手术 (Emotion Surgery)",             exp_10_emotion_surgery),
         '11': ("概念注入 (Concept Inception)",           exp_11_concept_inception),
         '12': ("基因库篡改 (Genetic Hijack)",            exp_12_genetic_hijack),
+        '13': ("任务结晶边界偏移 (Task Shift)",            exp_13_task_crystallization_shift),
     }
 
     while True:

experiment_en.py

@@ -301,6 +301,38 @@ def exp_2_sparsity_profile(model, enc, device, report_dir):
     plt.close()
     print(f"  > Chart saved: {save_path}")
 
+    # === Export data for paper plotting ===
+    print("\n" + "="*60)
+    print("  [Paper Data Export] For TikZ/PGFPlots")
+    print("="*60)
+
+    if is_topk:
+        active_per_word_np = active_per_word.cpu().numpy()
+    else:
+        active_per_word_np = active_per_word
+
+    # --- Figure 1: Histogram data for active signals per word ---
+    hist_min = int(active_per_word_np.min())
+    hist_max = int(active_per_word_np.max())
+    hist_bins = np.arange(hist_min, hist_max + 2)
+    hist_counts, hist_edges = np.histogram(active_per_word_np, bins=hist_bins)
+    print(f"\n  [Histogram] Active signals per word distribution (bin_start, count):")
+    print(f"  mean={np.mean(active_per_word_np):.1f}, min={hist_min}, max={hist_max}")
+    print("  ---BEGIN_HISTOGRAM_DATA---")
+    for i in range(len(hist_counts)):
+        if hist_counts[i] > 0:
+            print(f"  {int(hist_edges[i])} {hist_counts[i]}")
+    print("  ---END_HISTOGRAM_DATA---")
+
+    # --- Figure 2: Signal utilization data (sorted by utilization) ---
+    sorted_utilization = np.sort(active_per_signal)[::-1]
+    print(f"\n  [Bar chart] Signal utilization (descending order, signal_rank, n_words):")
+    print(f"  mean={np.mean(active_per_signal):.0f}, min={np.min(active_per_signal)}, max={np.max(active_per_signal)}")
+    print("  ---BEGIN_UTILIZATION_DATA---")
+    for i, val in enumerate(sorted_utilization):
+        print(f"  {i} {val}")
+    print("  ---END_UTILIZATION_DATA---")
+
 
 def exp_3_basis_geometry(model, enc, device, report_dir):
     print("\n" + "="*60)
@@ -1043,6 +1075,202 @@ def exp_12_genetic_hijack(model, enc, device, report_dir):
     print(f"\n  > Experiment complete. Compare the control and hijacked texts above.")
 
 
+def exp_13_task_crystallization_shift(model, enc, device, report_dir):
+    print("\n" + "="*60)
+    print("  [Exp 13] Task-Dependent Crystallization Boundary")
+    print("="*60)
+
+    W_basis = model.transformer.wte.signal_basis.data
+    W_v2s = _get_vocab_signals(model)
+    n_layers = len(model.transformer.h)
+
+    task_groups = {
+        "Shallow (Short Context)": [
+            ("The capital of France is", "London"),
+            ("The cat sat on the", "moon"),
+            ("The sky is", "red"),
+            ("Open the door with a", "car")
+        ],
+        "Deep (Long Context / Clauses)": [
+            ("When the geography teacher asked the students, they answered that the capital of France is", "London"),
+            ("After carefully reviewing all the evidence presented in court, the judge decided that the defendant was", "guilty"),
+            ("When you look outside the window at the beautiful nature, the color of the clear sky is", "red"),
+            ("I was locked out of my house yesterday, and to open the locked door, you need a", "car")
+        ],
+        "Code (Structured Logic)": [
+            ("def add(a, b): return a +", "None"),
+            ("x = 1 + 2\ny =", "None"),
+            ("for i in range(10):\n    print(", "None"),
+            ("if x > 0:\n    result =", "None")
+        ]
+    }
+
+    def continuous_steer(prompt, target_tid, base_tid, alpha, intercept_layer):
+        steer_vec = W_v2s[target_tid] - W_v2s[base_tid]
+        ids = torch.tensor(enc.encode(prompt), device=device).unsqueeze(0)
+
+        with torch.no_grad():
+            x = _embed(model, ids)
+            if intercept_layer == 0:
+                x[:, -1, :] += (alpha * steer_vec) @ W_basis
+
+            freqs_cis = model.freqs_cis[:ids.size(1)]
+            for i, block in enumerate(model.transformer.h):
+                x = block(x, freqs_cis)
+                if intercept_layer is not None and i + 1 >= intercept_layer:
+                    x[:, -1, :] += (alpha * steer_vec) @ W_basis
+
+            x_norm = model.transformer.ln_f(x[0, -1, :])
+            logits = _get_logits_from_hidden(model, x_norm)
+            probs = F.softmax(logits, dim=-1)
+            pred_id = torch.argmax(logits).item()
+            return probs[target_tid].item(), enc.decode([pred_id]).strip(), pred_id
+
+    results = {"Shallow (Short Context)": [], "Deep (Long Context / Clauses)": [], "Code (Structured Logic)": []}
+
+    print("  Starting continuous intervention sweep...\n")
+
+    for group_name, tasks in task_groups.items():
+        print(f"  [{group_name}]")
+        for prompt, target in tasks:
+            target_clean = target.strip()
+            target_tid = enc.encode(" " + target)[0]
+
+            _, base_pred, base_tid = continuous_steer(prompt, target_tid, target_tid, 0.0, None)
+            if base_pred == target_clean:
+                print(f"    [Skip] '{prompt[:20]}...' already predicts '{target_clean}'.")
+                continue
+
+            working_alpha = None
+            for a in np.arange(2.0, 50.0, 2.0):
+                _, pred, _ = continuous_steer(prompt, target_tid, base_tid, a, 0)
+                if pred == target_clean:
+                    working_alpha = a
+                    break
+
+            if working_alpha is None:
+                print(f"    [Skip] '{prompt[:20]}...': Cannot steer within alpha<50.")
+                continue
+
+            final_alpha = working_alpha * 1.2
+
+            layer_probs = []
+            c_layer = n_layers
+
+            for L in range(n_layers):
+                p_target, pred, _ = continuous_steer(prompt, target_tid, base_tid, final_alpha, L)
+                layer_probs.append(p_target)
+
+                if pred != target_clean and c_layer == n_layers:
+                    c_layer = L
+
+            results[group_name].append({
+                'prompt': prompt,
+                'target': target_clean,
+                'alpha': final_alpha,
+                'base_pred': base_pred,
+                'c_layer': c_layer,
+                'layer_probs': layer_probs
+            })
+
+            short_prompt = prompt[:35] + "..." if len(prompt) > 35 else prompt
+            print(f"    - '{short_prompt}' (base: '{base_pred}')")
+            print(f"      -> Inject '{target_clean}' (α={final_alpha:.1f}) | Crystallization boundary: \033[96mLayer {c_layer}\033[0m")
+        print()
+
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6), gridspec_kw={'width_ratios': [2, 1]})
+
+    layers_x = np.arange(0, n_layers)
+    colors = {"Shallow (Short Context)": "#2ecc71", "Deep (Long Context / Clauses)": "#9b59b6", "Code (Structured Logic)": "#e67e22"}
+
+    c_layers_shallow = []
+    c_layers_deep = []
+    c_layers_code = []
+
+    for group_name, res_list in results.items():
+        color = colors[group_name]
+        for i, res in enumerate(res_list):
+            if "Shallow" in group_name:
+                c_layers_shallow.append(res['c_layer'])
+            elif "Deep" in group_name:
+                c_layers_deep.append(res['c_layer'])
+            elif "Code" in group_name:
+                c_layers_code.append(res['c_layer'])
+
+            label = group_name if i == 0 else "_nolegend_"
+            ax1.plot(layers_x, res['layer_probs'], color=color, alpha=0.6, lw=2.5, label=label)
+
+            c_idx = res['c_layer']
+            if c_idx < n_layers:
+                ax1.scatter(c_idx, res['layer_probs'][c_idx], color=color, s=120, marker='X', edgecolors='black', zorder=5)
+
+    ax1.set_title("Target Concept Viability vs. Injection Delay", fontsize=12, fontweight='bold')
+    ax1.set_xlabel("Intervention Start Layer (Later start = Context already crystallized)")
+    ax1.set_ylabel("Final Probability of Injected Concept")
+    ax1.yaxis.set_major_formatter(ticker.PercentFormatter(xmax=1.0, decimals=0))
+    ax1.legend(fontsize=10)
+    ax1.grid(True, alpha=0.3)
+
+    box_data = []
+    box_labels = []
+    box_colors_list = []
+    if c_layers_shallow:
+        box_data.append(c_layers_shallow)
+        box_labels.append("Shallow\n(Short)")
+        box_colors_list.append(colors["Shallow (Short Context)"])
+    if c_layers_deep:
+        box_data.append(c_layers_deep)
+        box_labels.append("Deep\n(Long)")
+        box_colors_list.append(colors["Deep (Long Context / Clauses)"])
+    if c_layers_code:
+        box_data.append(c_layers_code)
+        box_labels.append("Code\n(Structured)")
+        box_colors_list.append(colors["Code (Structured Logic)"])
+
+    if len(box_data) >= 2:
+        bplot = ax2.boxplot(box_data, patch_artist=True, widths=0.5)
+        ax2.set_xticks(range(1, len(box_data) + 1))
+        ax2.set_xticklabels(box_labels)
+
+        for patch, c in zip(bplot['boxes'], box_colors_list):
+            patch.set_facecolor(c)
+            patch.set_alpha(0.6)
+
+        for idx, (data, c) in enumerate(zip(box_data, box_colors_list)):
+            ax2.scatter(np.random.normal(idx + 1, 0.05, len(data)), data, color=c, alpha=0.9, s=50)
+
+    ax2.set_title("Crystallization Boundary Distribution", fontsize=12, fontweight='bold')
+    ax2.set_ylabel("Crystallization Layer (Point of No Return)")
+    ax2.set_ylim(-1, n_layers + 2)
+    ax2.yaxis.set_major_locator(ticker.MaxNLocator(integer=True))
+    ax2.grid(True, axis='y', alpha=0.3)
+
+    plt.suptitle("reFlow Causal Audit: Context Type Affects Information Crystallization", fontsize=15, fontweight='bold')
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
+
+    save_path = os.path.join(report_dir, "task_crystallization_shift.png")
+    plt.savefig(save_path, bbox_inches='tight', dpi=200)
+    plt.close()
+
+    print("  ================= Conclusions =================")
+    if c_layers_shallow:
+        avg_shallow = np.mean(c_layers_shallow)
+        print(f"  > Shallow (short context) avg boundary: Layer {avg_shallow:.1f}")
+    if c_layers_deep:
+        avg_deep = np.mean(c_layers_deep)
+        print(f"  > Deep (long context) avg boundary: Layer {avg_deep:.1f}")
+    if c_layers_code:
+        avg_code = np.mean(c_layers_code)
+        print(f"  > Code (structured logic) avg boundary: Layer {avg_code:.1f}")
+    if c_layers_shallow and c_layers_deep:
+        print(f"  > Shallow→Deep boundary shift: \033[93m{np.mean(c_layers_deep) - np.mean(c_layers_shallow):+.1f} Layers\033[0m")
+    if c_layers_shallow and c_layers_code:
+        print(f"  > Shallow→Code boundary shift: \033[93m{np.mean(c_layers_code) - np.mean(c_layers_shallow):+.1f} Layers\033[0m")
+    print(f"  > Results show: Context complexity affects crystallization boundary.")
+    print(f"    More complex contexts tend to maintain representation fluidity at deeper layers.")
+    print(f"  > Chart saved: {save_path}")
+
+
 def main_menu():
     model, enc, device, report_dir = load_setup_and_model()
 
@@ -1059,6 +1287,7 @@ def main_menu():
         '10': ("Emotion Surgery",          exp_10_emotion_surgery),
         '11': ("Concept Inception",        exp_11_concept_inception),
         '12': ("Genetic Hijack",           exp_12_genetic_hijack),
+        '13': ("Task Crystallization Shift", exp_13_task_crystallization_shift),
     }
 
     while True: