Add files using upload-large-folder tool

Phase 1/01_benchmark_qgan

@@ -0,0 +1,249 @@
+# --- STEP 0: IMPORTS & "HEADLESS" MODE ---
+import matplotlib
+matplotlib.use('Agg')
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.metrics import roc_curve, auc
+import torch
+import torch.nn as nn
+from torch.optim import Adam
+from qiskit import QuantumCircuit
+from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
+from qiskit.primitives import Sampler
+from qiskit_machine_learning.neural_networks import SamplerQNN
+from qiskit_machine_learning.connectors import TorchConnector
+import warnings
+warnings.filterwarnings("ignore")
+
+# Critical for reproducibility and stability
+torch.manual_seed(42)
+np.random.seed(42)
+print("All libraries imported. Running in headless mode.")
+
+# --- Create plots directory ---
+if not os.path.exists('plots_benchmark'):
+    os.makedirs('plots_benchmark')
+print("Plots will be saved to 'plots_benchmark/' directory.")
+
+# --- MOST REALISTIC SYNTHETIC TOKAMAK DATA (2025 physics-faithful) ---
+np.random.seed(42)
+n_features = 50
+n_healthy = 8000
+n_disruptive = 600
+
+mean_healthy = np.zeros(n_features)
+cov_healthy = 0.12 * np.eye(n_features)
+cov_healthy += 0.04 * np.ones((n_features, n_features))
+X_healthy = np.random.multivariate_normal(mean_healthy, cov_healthy, n_healthy)
+
+X_disrupt = []
+n_per_mode = 100
+base = X_healthy[:n_per_mode].copy()
+
+mode1 = base.copy(); mode1[:, 0:6] += np.random.uniform(2.8, 4.5, (n_per_mode, 6)); mode1[:, 20:28] += np.random.uniform(2.0, 3.8, (n_per_mode, 8))
+mode2 = base.copy(); mode2[:, 8:18] += np.random.normal(3.5, 1.2, (n_per_mode, 10))
+mode3 = base.copy(); mode3[:, 30:36] -= np.random.uniform(3.0, 5.5, (n_per_mode, 6))
+mode4 = base.copy(); mode4[:, 15:25] += 3.2; mode4[:, 35:45] *= 0.25
+mode5 = base.copy(); mode5[:, 6:12] += np.random.uniform(-4.0, 4.0, (n_per_mode, 6))
+mode6 = base.copy(); mode6[:, 25:35] += np.random.uniform(3.0, 5.0, (n_per_mode, 10))
+
+X_disrupt = np.vstack([mode1, mode2, mode3, mode4, mode5, mode6])
+X_disrupt += np.random.normal(0, 0.25, X_disrupt.shape)
+
+healthy_df = pd.DataFrame(X_healthy, columns=[f'sensor_{i}' for i in range(n_features)])
+healthy_df['is_disruptive'] = 0
+disrupt_df = pd.DataFrame(X_disrupt, columns=[f'sensor_{i}' for i in range(n_features)])
+disrupt_df['is_disruptive'] = 1
+
+simulated_data = pd.concat([healthy_df, disrupt_df], ignore_index=True)
+simulated_data = simulated_data.sample(frac=1, random_state=42).reset_index(drop=True)
+print(f"Generated ultra-realistic synthetic tokamak data: {n_healthy} healthy + {n_disruptive} disruptive")
+
+# --- DATA PIPELINE ---
+X_train_healthy = simulated_data[simulated_data['is_disruptive'] == 0].drop('is_disruptive', axis=1)
+X_test_anomalous = simulated_data[simulated_data['is_disruptive'] == 1].drop('is_disruptive', axis=1)
+features_to_use = X_train_healthy.columns[:20]
+X_train_healthy = X_train_healthy[features_to_use]
+X_test_anomalous = X_test_anomalous[features_to_use]
+
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X_train_healthy)
+pca = PCA(n_components=2)
+X_pca = pca.fit_transform(X_scaled)
+
+bins_per_dim = 4
+real_distribution_hist, x_edges, y_edges = np.histogram2d(X_pca[:, 0], X_pca[:, 1], bins=bins_per_dim, density=True)
+real_distribution = real_distribution_hist.flatten()
+real_distribution = real_distribution / (np.sum(real_distribution) + 1e-12)
+x_centers = (x_edges[:-1] + x_edges[1:]) / 2
+y_centers = (y_edges[:-1] + y_edges[1:]) / 2
+grid_samples = np.array(np.meshgrid(x_centers, y_centers)).T.reshape(-1, 2)
+print("Data pipeline complete.")
+
+# --- TENSORS ---
+real_data_dist = torch.tensor(real_distribution, dtype=torch.float32).reshape(-1, 1)
+data_samples = torch.tensor(grid_samples, dtype=torch.float32)
+valid = torch.ones(real_data_dist.shape, dtype=torch.float32)
+fake = torch.zeros(real_data_dist.shape, dtype=torch.float32)
+
+# --- LOSS ---
+def adversarial_loss(input_scores, target_labels, weights):
+    bce = target_labels * torch.log(input_scores + 1e-12) + (1 - target_labels) * torch.log(1 - input_scores + 1e-12)
+    return -torch.sum(weights * bce)
+
+# --- ANOMALY SCORER ---
+def detect_anomaly(reading, scaler, pca, model):
+    scaled = scaler.transform(reading.reshape(1, -1))
+    pcaed = pca.transform(scaled)
+    tensor = torch.tensor(pcaed, dtype=torch.float32)
+    model.eval()
+    with torch.no_grad():
+        return model(tensor).item()
+
+# --- MAIN TRIAL LOOP ---
+N_TRIALS = 20
+num_epochs = 800
+qgan_auc_scores = []
+
+for trial in range(N_TRIALS):
+    print(f"\n--- QGAN TRIAL {trial+1}/{N_TRIALS} (Upgraded 2025 NISQ Best Practices) ---")
+
+    # === UPGRADED QUANTUM GENERATOR (This is the winner) ===
+    num_qubits = 4
+    feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='linear')
+    ansatz = RealAmplitudes(num_qubits, reps=10, entanglement='full')
+    
+    qc = QuantumCircuit(num_qubits)
+    qc.compose(feature_map, inplace=True)
+    qc.compose(ansatz, inplace=True)
+    
+    sampler = Sampler()
+    qnn = SamplerQNN(
+        circuit=qc,
+        sampler=sampler,
+        input_params=feature_map.parameters,
+        weight_params=ansatz.parameters,
+        interpret=lambda x: x % 16,
+        output_shape=16
+    )
+    
+    # Small initial weights = stable training
+    initial_weights = 0.05 * (2 * torch.rand(qnn.num_weights, requires_grad=True) - 1)
+    generator = TorchConnector(qnn, initial_weights=initial_weights)
+
+    # === STRONGER, MORE STABLE DISCRIMINATOR ===
+    class Discriminator(nn.Module):
+        def __init__(self, input_size=2):
+            super().__init__()
+            self.net = nn.Sequential(
+                nn.Linear(input_size, 64),
+                nn.LayerNorm(64),
+                nn.LeakyReLU(0.2),
+                nn.Dropout(0.3),
+                nn.Linear(64, 32),
+                nn.LayerNorm(32),
+                nn.LeakyReLU(0.2),
+                nn.Linear(32, 1),
+                nn.Sigmoid()
+            )
+        def forward(self, x):
+            return self.net(x)
+    discriminator = Discriminator()
+
+    # === OPTIMIZED LEARNING RATES (No collapse) ===
+    generator_optimizer = Adam(generator.parameters(), lr=0.004, betas=(0.5, 0.9))
+    discriminator_optimizer = Adam(discriminator.parameters(), lr=0.006, betas=(0.5, 0.9))
+
+        # === FINAL STABLE CONTINUOUS-DENSITY QGAN (NO MORE COLLAPSE) ===
+    from sklearn.neighbors import KernelDensity
+
+    # Fit a smooth continuous density on real healthy data — this is our true target
+    kde = KernelDensity(bandwidth=0.35, kernel='gaussian', rtol=1e-4)
+    kde.fit(X_pca)  # use ALL healthy points for best density estimate
+
+    def get_density(samples):
+        return np.exp(kde.score_samples(samples))
+
+    # Pre-compute true density on the 16 evaluation points
+    true_density = torch.tensor(get_density(grid_samples), dtype=torch.float32).reshape(-1, 1)
+    true_density = true_density / (true_density.sum() + 1e-12)
+
+    print(f"Starting STABLE continuous-density training ({num_epochs} epochs)...")
+    for epoch in range(num_epochs):
+        # --- Discriminator training
+        discriminator_optimizer.zero_grad()
+        real_scores = discriminator(data_samples)                    # (16,1)
+        fake_data = generator(data_samples)                          # (16,16) → probabilities
+        fake_scores = discriminator(data_samples)
+
+        # Standard non-saturating GAN loss + small density bonus
+        d_loss_real = -torch.log(real_scores + 1e-12).mean()
+        d_loss_fake = -torch.log(1 - fake_scores + 1e-12).mean()
+        d_loss = d_loss_real + d_loss_fake
+        d_loss.backward()
+        discriminator_optimizer.step()
+
+        # Generator training — wants fake data in high-density regions
+        generator_optimizer.zero_grad()
+        fake_data = generator(data_samples)
+        fake_scores = discriminator(data_samples)
+        # Main GAN loss + tiny density reward to prevent collapse
+        g_gan_loss = -fake_scores.mean()
+        density_bonus = (fake_data * true_density).sum(dim=1).mean() * 0.05
+        g_loss = g_gan_loss - density_bonus
+        g_loss.backward()
+        generator_optimizer.step()
+
+        if (epoch + 1) % 200 == 0:
+            print(f"  Epoch {epoch+1:3d} | D: {d_loss.item():.3f} | G: {g_loss.item():.3f}")
+
+    # === FINAL VALIDATION (continuous density + discriminator) ===
+    healthy_scores = []
+    for i in range(1000):
+        raw = X_train_healthy.iloc[i].values.reshape(1, -1)
+        pca_pt = pca.transform(scaler.transform(raw))
+        disc_score = detect_anomaly(X_train_healthy.iloc[i].values, scaler, pca, discriminator)
+        density = get_density(pca_pt)[0]
+        combined = disc_score * (density ** 0.15)  # soft density weighting
+        healthy_scores.append(combined)
+
+    anomalous_scores = []
+    for i in range(len(X_test_anomalous)):
+        raw = X_test_anomalous.iloc[i].values.reshape(1, -1)
+        pca_pt = pca.transform(scaler.transform(raw))
+        disc_score = detect_anomaly(X_test_anomalous.iloc[i].values, scaler, pca, discriminator)
+        density = get_density(pca_pt)[0]
+        combined = disc_score * (density ** 0.15)
+        anomalous_scores.append(combined)
+
+    # ROC
+    y_true = np.concatenate([np.zeros(1000), np.ones(len(anomalous_scores))])
+    y_pred = np.concatenate([healthy_scores, anomalous_scores])
+    fpr, tpr, _ = roc_curve(y_true, y_pred)
+    roc_auc = auc(fpr, tpr)
+    qgan_auc_scores.append(roc_auc)
+    print(f"Trial {trial+1}/20 finished — AUC = {roc_auc:.4f}")
+
+    # Save ROC
+    plt.figure(figsize=(7,6))
+    plt.plot(fpr, tpr, label=f'AUC = {roc_auc:.4f}')
+    plt.plot([0,1],[0,1],'k--')
+    plt.title(f'QGAN Stable ROC - Trial {trial+1}')
+    plt.legend(); plt.grid(alpha=0.3)
+    plt.savefig(f'plots_benchmark/QGAN_STABLE_Trial_{trial+1}_ROC.png', dpi=150)
+    plt.close()
+    qgan_auc_scores.append(roc_auc)
+    print(f"Trial {trial+1} AUC: {roc_auc:.4f}")
+
+    
+
+# === FINAL RESULTS ===
+print("\n" + "="*50)
+print("FINAL UPGRADED QGAN RESULTS (2025 Best Practices)")
+print(f"Average AUC: {np.mean(qgan_auc_scores):.4f} ± {np.std(qgan_auc_scores):.4f}")
+print(f"Best AUC: {np.max(qgan_auc_scores):.4f}")
+print("="*50)

Phase 1/Bridge-island_visual.py

@@ -0,0 +1,79 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.patches import Ellipse, FancyBboxPatch
+
+# --- CONFIGURATION ---
+np.random.seed(42)
+n_points = 300
+
+# --- GENERATE "ISLAND" DATA (Schematic) ---
+# Mode 1: Ramp Up (Bottom Left)
+x1 = np.random.normal(-2, 0.4, n_points)
+y1 = np.random.normal(-2, 0.4, n_points)
+
+# Mode 2: Flat Top (Center)
+x2 = np.random.normal(0, 0.3, n_points)
+y2 = np.random.normal(0, 0.3, n_points)
+
+# Mode 3: Ramp Down (Top Right)
+x3 = np.random.normal(2, 0.4, n_points)
+y3 = np.random.normal(2, 0.4, n_points)
+
+# Anomalies (The Trap - In the gaps)
+xa = np.random.normal(-1, 0.15, 50)
+ya = np.random.normal(-1, 0.15, 50)
+
+xb = np.random.normal(1.2, 0.15, 50)
+yb = np.random.normal(1.2, 0.15, 50)
+
+# --- PLOTTING ---
+fig, ax = plt.subplots(figsize=(12, 7))
+
+# 1. Plot the "Healthy" Islands
+ax.scatter(x1, y1, c='#1f77b4', alpha=0.6, s=20, label='Healthy Plasma (3 Modes)')
+ax.scatter(x2, y2, c='#1f77b4', alpha=0.6, s=20)
+ax.scatter(x3, y3, c='#1f77b4', alpha=0.6, s=20)
+
+# 2. Plot the "Trap" Anomalies
+ax.scatter(xa, ya, c='red', marker='x', s=60, linewidth=2, label='Anomalies (Hidden in Gaps)')
+ax.scatter(xb, yb, c='red', marker='x', s=60, linewidth=2)
+
+# 3. DRAW THE "CLASSICAL BRIDGE" (The Failure)
+# A large, smooth ellipse that covers everything, including the traps
+classical_boundary = Ellipse((0, 0), width=7, height=7, angle=45, 
+                             edgecolor='red', linestyle='--', linewidth=3, 
+                             facecolor='red', alpha=0.1, label='Classical AI "Bridge" (Lazy)')
+ax.add_patch(classical_boundary)
+
+# 4. DRAW THE "QUANTUM TOPOLOGY" (The Success)
+# Tight circles around the modes
+q1 = Ellipse((-2, -2), width=2.5, height=2.5, angle=0, edgecolor='green', linewidth=3, facecolor='none')
+q2 = Ellipse((0, 0), width=2.0, height=2.0, angle=0, edgecolor='green', linewidth=3, facecolor='none')
+q3 = Ellipse((2, 2), width=2.5, height=2.5, angle=0, edgecolor='green', linewidth=3, facecolor='none')
+
+ax.add_patch(q1)
+ax.add_patch(q2)
+ax.add_patch(q3)
+# Ghost patch for legend
+ax.plot([], [], color='green', linewidth=3, label='Quantum AI "Topology" (Correct)')
+
+# --- ANNOTATIONS ---
+ax.text(-1.1, -0.8, "THE TRAP", color='red', fontsize=12, fontweight='bold')
+ax.text(1.3, 1.4, "THE TRAP", color='red', fontsize=12, fontweight='bold')
+ax.text(-3.5, 1.5, "Classical AI bridges the gap\nand calls anomalies 'Safe'", 
+        color='red', fontsize=11, bbox=dict(facecolor='white', alpha=0.8))
+ax.text(1.5, -2.5, "Quantum AI respects\nthe separation", 
+        color='green', fontsize=11, bbox=dict(facecolor='white', alpha=0.8))
+
+# Style
+ax.set_title("Why Classical AI Fails Fusion: The 'Bridge' Problem", fontsize=16, fontweight='bold')
+ax.legend(loc='upper left', fontsize=10)
+ax.set_xticks([])
+ax.set_yticks([])
+ax.grid(True, alpha=0.2)
+
+# Save
+plt.tight_layout()
+plt.savefig('slide_visual_the_trap.png', dpi=300)
+plt.close()
+print("Visual generated: slide_visual_the_trap.png")

Phase 1/V2.1_QGAN_HailMary.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+"""benchmark_qgan_v2.py
+
+The "Hail Mary" Configuration (V2.1)
+- Deep Quantum Circuit (reps=6)
+- High Generator LR (0.05) / Low Discriminator LR (0.001)
+- 700 Epochs
+"""
+
+# --- STEP 0: IMPORTS & HEADLESS MODE ---
+import matplotlib
+matplotlib.use('Agg') # No pop-ups
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.metrics import roc_curve, auc
+import torch
+import torch.nn as nn
+from torch.optim import Adam
+
+# Qiskit Imports
+from qiskit import QuantumCircuit
+from qiskit.circuit.library import EfficientSU2
+from qiskit.primitives import Sampler
+from qiskit_machine_learning.neural_networks import SamplerQNN
+from qiskit_machine_learning.connectors import TorchConnector
+
+print("All libraries imported. Running 'Hail Mary' QGAN V2.1")
+
+# --- SETUP DIRECTORIES ---
+if not os.path.exists('plots_v2_qgan'):
+    os.makedirs('plots_v2_qgan')
+print("Plots will be saved to 'plots_v2_qgan/' directory.")
+
+# --- STEP 1: LOAD THE V2 PHYSICS DATA ---
+print("\nLoading 'complex_tokamak_data.csv'...")
+try:
+    df_total = pd.read_csv('complex_tokamak_data.csv')
+except FileNotFoundError:
+    print("ERROR: 'complex_tokamak_data.csv' not found. Run physics_data.py first!")
+    exit()
+
+print(f"Data Loaded. Shape: {df_total.shape}")
+
+# --- STEP 2: PRE-PROCESSING (THE PIPELINE) ---
+print("Running Data Pipeline...")
+
+# Split Healthy vs Anomalous
+X_train_healthy = df_total[df_total['label'] == 0].drop('label', axis=1)
+X_test_anomalous = df_total[df_total['label'] == 1].drop('label', axis=1)
+
+# 1. Scale (Standardize)
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X_train_healthy)
+
+# 2. PCA (Compress to 2 Latent Dimensions)
+N_DIM = 2
+pca = PCA(n_components=N_DIM)
+X_pca = pca.fit_transform(X_scaled)
+
+# 3. Discretize (Map to 4x4 Grid = 16 bins)
+bins_per_dim = 4
+num_qubits = 4 # 2^4 = 16
+
+real_distribution_hist, x_edges, y_edges = np.histogram2d(
+    X_pca[:, 0], 
+    X_pca[:, 1], 
+    bins=bins_per_dim, 
+    density=True
+)
+
+# Flatten grid to probability vector
+real_distribution = real_distribution_hist.flatten()
+real_distribution = real_distribution / np.sum(real_distribution) # Normalize
+
+# Get grid centers for the Discriminator
+x_centers = (x_edges[:-1] + x_edges[1:]) / 2
+y_centers = (y_edges[:-1] + y_edges[1:]) / 2
+grid_samples = np.array(np.meshgrid(x_centers, y_centers)).T.reshape(-1, N_DIM)
+
+print("Target distribution created.")
+
+# Convert to PyTorch Tensors
+real_data_dist = torch.tensor(real_distribution, dtype=torch.float32).reshape(-1, 1)
+data_samples = torch.tensor(grid_samples, dtype=torch.float32)
+valid = torch.ones(real_data_dist.shape, dtype=torch.float32)
+fake = torch.zeros(real_data_dist.shape, dtype=torch.float32)
+
+# --- HELPER FUNCTIONS ---
+def adversarial_loss(input, target, w):
+    bce_loss = target * torch.log(input) + (1 - target) * torch.log(1 - input)
+    weighted_loss = w * bce_loss
+    total_loss = -torch.sum(weighted_loss)
+    return total_loss
+
+def detect_anomaly(new_sensor_reading, scaler_obj, pca_obj, discriminator_model):
+    x_scaled = scaler_obj.transform(new_sensor_reading.reshape(1, -1))
+    x_pca = pca_obj.transform(x_scaled)
+    x_tensor = torch.tensor(x_pca, dtype=torch.float32)
+    discriminator_model.eval()
+    with torch.no_grad():
+        score = discriminator_model(x_tensor)
+    return score.item()
+
+# --- STEP 3: THE BENCHMARK LOOP (HAIL MARY SETTINGS) ---
+N_TRIALS = 20 
+num_epochs = 700 # INCREASED: Give it more time to converge
+qgan_auc_scores = []
+
+print(f"\nStarting {N_TRIALS} Trials of QGAN-AD (Hail Mary Config)...")
+
+for trial in range(N_TRIALS):
+    print(f"\n--- TRIAL {trial+1}/{N_TRIALS} ---")
+
+    # A. BUILD GENERATOR (Quantum)
+    qc = QuantumCircuit(num_qubits)
+    qc.h(qc.qubits)
+    
+    # HAIL MARY TWEAK 1: Deeper Circuit
+    # reps=6 provides more parameters to fit the 3 separate islands
+    ansatz = EfficientSU2(num_qubits, reps=6) 
+    qc.compose(ansatz, inplace=True)
+    
+    sampler = Sampler()
+    qnn = SamplerQNN(
+        circuit=qc, 
+        sampler=sampler, 
+        input_params=[], 
+        weight_params=qc.parameters
+    )
+    
+    initial_weights = 0.1 * (2 * torch.rand(qnn.num_weights) - 1)
+    generator = TorchConnector(qnn, initial_weights=initial_weights)
+
+    # B. BUILD DISCRIMINATOR (Classical)
+    class Discriminator(nn.Module):
+        def __init__(self, input_size):
+            super(Discriminator, self).__init__()
+            self.model = nn.Sequential(
+                nn.Linear(input_size, 32),
+                nn.LeakyReLU(0.2),
+                nn.Linear(32, 16),
+                nn.LeakyReLU(0.2),
+                nn.Linear(16, 1),
+                nn.Sigmoid()
+            )
+        def forward(self, x):
+            return self.model(x)
+            
+    discriminator = Discriminator(input_size=N_DIM)
+
+    # C. OPTIMIZERS (HAIL MARY TWEAK 2)
+    # Generator: 0.05 (Very Fast - Needs to learn complex shapes quickly)
+    # Discriminator: 0.001 (Sedated - Prevents it from killing G too early)
+    lr_g = 0.05 
+    lr_d = 0.001
+    
+    # Added betas to help momentum
+    opt_g = Adam(generator.parameters(), lr=lr_g, betas=(0.7, 0.999))
+    opt_d = Adam(discriminator.parameters(), lr=lr_d, betas=(0.7, 0.999))
+
+    # D. TRAINING
+    g_losses = []
+    d_losses = []
+    
+    for epoch in range(num_epochs):
+        # Train D
+        opt_d.zero_grad()
+        disc_real = discriminator(data_samples)
+        gen_dist = generator(torch.tensor([])).reshape(-1, 1)
+        loss_d_real = adversarial_loss(disc_real, valid, real_data_dist)
+        loss_d_fake = adversarial_loss(disc_real, fake, gen_dist.detach())
+        loss_d = (loss_d_real + loss_d_fake) / 2
+        loss_d.backward()
+        opt_d.step()
+
+        # Train G
+        opt_g.zero_grad()
+        gen_dist = generator(torch.tensor([])).reshape(-1, 1)
+        disc_fake = discriminator(data_samples)
+        loss_g = adversarial_loss(disc_fake, valid, gen_dist)
+        loss_g.backward()
+        opt_g.step()
+        
+        if epoch % 100 == 0:
+            g_losses.append(loss_g.item())
+            d_losses.append(loss_d.item())
+
+    # E. VALIDATION
+    healthy_subset = X_train_healthy.sample(n=500) 
+    y_true = []
+    y_scores = []
+
+    for i in range(len(healthy_subset)):
+        sample = healthy_subset.iloc[i].values
+        score = detect_anomaly(sample, scaler, pca, discriminator)
+        y_true.append(0)
+        y_scores.append(score)
+
+    for i in range(len(X_test_anomalous)):
+        sample = X_test_anomalous.iloc[i].values
+        score = detect_anomaly(sample, scaler, pca, discriminator)
+        y_true.append(1)
+        y_scores.append(score)
+
+    # F. METRICS & PLOTS
+    fpr, tpr, _ = roc_curve(y_true, 1 - np.array(y_scores))
+    roc_auc = auc(fpr, tpr)
+    qgan_auc_scores.append(roc_auc)
+    
+    print(f"Trial {trial+1} Complete. AUC: {roc_auc:.4f}")
+
+    # Save ROC Plot
+    plt.figure(figsize=(6,5))
+    plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'AUC={roc_auc:.2f}')
+    plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
+    plt.title(f"QGAN V2.1 (Hail Mary) Trial {trial+1}")
+    plt.legend(loc="lower right")
+    plt.savefig(f'plots_v2_qgan/roc_trial_{trial+1}.png')
+    plt.close()
+
+# --- FINAL SUMMARY ---
+print("\n" + "="*30)
+print("--- QGAN V2.1 (HAIL MARY) RESULTS ---")
+print(f"Mean AUC: {np.mean(qgan_auc_scores):.4f}")
+print(f"Max AUC:  {np.max(qgan_auc_scores):.4f}")
+print(f"Std Dev:  {np.std(qgan_auc_scores):.4f}")
+print("="*30)

Phase 1/V2_benchmark_cgan

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+"""benchmark_cgan_v2.py
+The CLASSICAL Control Experiment.
+"""
+
+import matplotlib
+matplotlib.use('Agg') # Headless mode
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.metrics import roc_curve, auc
+import torch
+import torch.nn as nn
+from torch.optim import Adam
+
+print("Running CLASSICAL Benchmark V2 (Headless).")
+
+# --- SETUP DIRECTORIES ---
+if not os.path.exists('plots_v2_cgan'):
+    os.makedirs('plots_v2_cgan')
+print("Plots will be saved to 'plots_v2_cgan/' directory.")
+
+# --- STEP 1: LOAD THE SAME V2 DATA ---
+# Crucial: We must use the exact same CSV
+try:
+    df_total = pd.read_csv('complex_tokamak_data.csv')
+except FileNotFoundError:
+    print("ERROR: 'complex_tokamak_data.csv' not found.")
+    exit()
+
+# --- STEP 2: EXACT SAME PIPELINE ---
+X_train_healthy = df_total[df_total['label'] == 0].drop('label', axis=1)
+X_test_anomalous = df_total[df_total['label'] == 1].drop('label', axis=1)
+
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X_train_healthy)
+
+N_DIM = 2
+pca = PCA(n_components=N_DIM)
+X_pca = pca.fit_transform(X_scaled)
+
+bins_per_dim = 4
+num_qubits = 4 
+
+# Create Target Distribution
+real_distribution_hist, x_edges, y_edges = np.histogram2d(
+    X_pca[:, 0], X_pca[:, 1], bins=bins_per_dim, density=True
+)
+real_distribution = real_distribution_hist.flatten()
+real_distribution = real_distribution / np.sum(real_distribution)
+
+# Grid Centers
+x_centers = (x_edges[:-1] + x_edges[1:]) / 2
+y_centers = (y_edges[:-1] + y_edges[1:]) / 2
+grid_samples = np.array(np.meshgrid(x_centers, y_centers)).T.reshape(-1, N_DIM)
+
+# Tensors
+real_data_dist = torch.tensor(real_distribution, dtype=torch.float32).reshape(-1, 1)
+data_samples = torch.tensor(grid_samples, dtype=torch.float32)
+valid = torch.ones(real_data_dist.shape, dtype=torch.float32)
+fake = torch.zeros(real_data_dist.shape, dtype=torch.float32)
+
+# --- HELPER FUNCTIONS ---
+def adversarial_loss(input, target, w):
+    bce_loss = target * torch.log(input) + (1 - target) * torch.log(1 - input)
+    weighted_loss = w * bce_loss
+    total_loss = -torch.sum(weighted_loss)
+    return total_loss
+
+def detect_anomaly(new_sensor_reading, scaler_obj, pca_obj, discriminator_model):
+    x_scaled = scaler_obj.transform(new_sensor_reading.reshape(1, -1))
+    x_pca = pca_obj.transform(x_scaled)
+    x_tensor = torch.tensor(x_pca, dtype=torch.float32)
+    discriminator_model.eval()
+    with torch.no_grad():
+        score = discriminator_model(x_tensor)
+    return score.item()
+
+# --- STEP 3: THE BENCHMARK LOOP ---
+N_TRIALS = 20
+num_epochs = 400
+cgan_auc_scores = []
+
+print(f"\nStarting {N_TRIALS} Trials of C-GAN...")
+
+for trial in range(N_TRIALS):
+    print(f"\n--- TRIAL {trial+1}/{N_TRIALS} ---")
+
+    # A. CLASSICAL GENERATOR
+    # This mimics the QGAN architecture (learning a distribution) 
+    # but uses standard weights instead of quantum rotation angles.
+    class ClassicalGenerator(nn.Module):
+        def __init__(self, output_size=16):
+            super(ClassicalGenerator, self).__init__()
+            # 16 raw numbers (logits) that we learn
+            self.logits = nn.Parameter(torch.randn(1, output_size))
+            
+        def forward(self):
+            # Softmax converts logits to a probability distribution (0.0 to 1.0)
+            return torch.softmax(self.logits, dim=1)
+
+    generator = ClassicalGenerator(output_size=16)
+
+    # B. DISCRIMINATOR (Identical to QGAN)
+    class Discriminator(nn.Module):
+        def __init__(self, input_size):
+            super(Discriminator, self).__init__()
+            self.model = nn.Sequential(
+                nn.Linear(input_size, 32),
+                nn.LeakyReLU(0.2),
+                nn.Linear(32, 16),
+                nn.LeakyReLU(0.2),
+                nn.Linear(16, 1),
+                nn.Sigmoid()
+            )
+        def forward(self, x):
+            return self.model(x)
+
+    discriminator = Discriminator(input_size=N_DIM)
+
+    # C. OPTIMIZERS
+    # Classical usually needs lower LR to avoid "overshooting" the solution
+    opt_g = Adam(generator.parameters(), lr=0.01)
+    opt_d = Adam(discriminator.parameters(), lr=0.01)
+
+    # D. TRAINING
+    for epoch in range(num_epochs):
+        # Train D
+        opt_d.zero_grad()
+        disc_real = discriminator(data_samples)
+        gen_dist = generator().reshape(-1, 1) 
+        loss_d_real = adversarial_loss(disc_real, valid, real_data_dist)
+        loss_d_fake = adversarial_loss(disc_real, fake, gen_dist.detach())
+        loss_d = (loss_d_real + loss_d_fake) / 2
+        loss_d.backward()
+        opt_d.step()
+
+        # Train G
+        opt_g.zero_grad()
+        gen_dist = generator().reshape(-1, 1)
+        disc_fake = discriminator(data_samples)
+        loss_g = adversarial_loss(disc_fake, valid, gen_dist)
+        loss_g.backward()
+        opt_g.step()
+
+    # E. VALIDATION
+    healthy_subset = X_train_healthy.sample(n=500)
+    y_true = []
+    y_scores = []
+
+    for i in range(len(healthy_subset)):
+        sample = healthy_subset.iloc[i].values
+        score = detect_anomaly(sample, scaler, pca, discriminator)
+        y_true.append(0)
+        y_scores.append(score)
+
+    for i in range(len(X_test_anomalous)):
+        sample = X_test_anomalous.iloc[i].values
+        score = detect_anomaly(sample, scaler, pca, discriminator)
+        y_true.append(1)
+        y_scores.append(score)
+
+    # F. METRICS
+    fpr, tpr, _ = roc_curve(y_true, 1 - np.array(y_scores))
+    roc_auc = auc(fpr, tpr)
+    cgan_auc_scores.append(roc_auc)
+    print(f"Trial {trial+1} Complete. AUC: {roc_auc:.4f}")
+
+    # Save Plot
+    plt.figure(figsize=(6,5))
+    plt.plot(fpr, tpr, color='green', lw=2, label=f'AUC={roc_auc:.2f}')
+    plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
+    plt.title(f"C-GAN V2 Trial {trial+1}")
+    plt.legend(loc="lower right")
+    plt.savefig(f'plots_v2_cgan/roc_trial_{trial+1}.png')
+    plt.close()
+
+# --- FINAL SUMMARY ---
+print("\n" + "="*30)
+print("--- C-GAN V2 RESULTS ---")
+print(f"Mean AUC: {np.mean(cgan_auc_scores):.4f}")
+print(f"Max AUC:  {np.max(cgan_auc_scores):.4f}")
+print(f"Std Dev:  {np.std(cgan_auc_scores):.4f}")
+print("="*30)

Phase 1/V2_benchmark_qgan

@@ -0,0 +1,232 @@
+# -*- coding: utf-8 -*-
+"""benchmark_qgan_v2.py
+
+The "gap test" benchmark for QGAN on physics-informed tokamak data.
+"""
+
+# --- STEP 0: IMPORTS & HEADLESS MODE ---
+import matplotlib
+matplotlib.use('Agg') # No pop-ups
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.metrics import roc_curve, auc
+import torch
+import torch.nn as nn
+from torch.optim import Adam
+
+# Qiskit Imports
+from qiskit import QuantumCircuit
+from qiskit.circuit.library import EfficientSU2
+from qiskit.primitives import Sampler
+from qiskit_machine_learning.neural_networks import SamplerQNN
+from qiskit_machine_learning.connectors import TorchConnector
+
+print("All libraries imported. Running in Headless Mode.")
+
+# --- SETUP DIRECTORIES ---
+if not os.path.exists('plots_v2_qgan'):
+    os.makedirs('plots_v2_qgan')
+print("Plots will be saved to 'plots_v2_qgan/' directory.")
+
+# --- STEP 1: LOAD THE V2 PHYSICS DATA ---
+print("\nLoading 'complex_tokamak_data.csv'...")
+try:
+    df_total = pd.read_csv('complex_tokamak_data.csv')
+except FileNotFoundError:
+    print("ERROR: 'complex_tokamak_data.csv' not found. Run physics_data.py first!")
+    exit()
+
+print(f"Data Loaded. Shape: {df_total.shape}")
+
+# --- STEP 2: PRE-PROCESSING (THE PIPELINE) ---
+# We process the data ONCE before the loop to save time
+print("Running Data Pipeline...")
+
+# Split Healthy vs Anomalous
+X_train_healthy = df_total[df_total['label'] == 0].drop('label', axis=1)
+X_test_anomalous = df_total[df_total['label'] == 1].drop('label', axis=1)
+
+# 1. Scale (Standardize)
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X_train_healthy)
+
+# 2. PCA (Compress to 2 Latent Dimensions)
+N_DIM = 2
+pca = PCA(n_components=N_DIM)
+X_pca = pca.fit_transform(X_scaled)
+
+# 3. Discretize (Map to 4x4 Grid = 16 bins)
+bins_per_dim = 4
+num_qubits = 4 # 2^4 = 16
+
+real_distribution_hist, x_edges, y_edges = np.histogram2d(
+    X_pca[:, 0], 
+    X_pca[:, 1], 
+    bins=bins_per_dim, 
+    density=True
+)
+
+# Flatten grid to probability vector
+real_distribution = real_distribution_hist.flatten()
+real_distribution = real_distribution / np.sum(real_distribution) # Normalize
+
+# Get grid centers for the Discriminator
+x_centers = (x_edges[:-1] + x_edges[1:]) / 2
+y_centers = (y_edges[:-1] + y_edges[1:]) / 2
+grid_samples = np.array(np.meshgrid(x_centers, y_centers)).T.reshape(-1, N_DIM)
+
+print("Target distribution created (The 'Islands' map).")
+
+# Convert to PyTorch Tensors
+real_data_dist = torch.tensor(real_distribution, dtype=torch.float32).reshape(-1, 1)
+data_samples = torch.tensor(grid_samples, dtype=torch.float32)
+valid = torch.ones(real_data_dist.shape, dtype=torch.float32)
+fake = torch.zeros(real_data_dist.shape, dtype=torch.float32)
+
+# --- HELPER FUNCTIONS ---
+def adversarial_loss(input, target, w):
+    # Weighted BCE Loss
+    bce_loss = target * torch.log(input) + (1 - target) * torch.log(1 - input)
+    weighted_loss = w * bce_loss
+    total_loss = -torch.sum(weighted_loss)
+    return total_loss
+
+def detect_anomaly(new_sensor_reading, scaler_obj, pca_obj, discriminator_model):
+    # Pipeline for a single sample
+    x_scaled = scaler_obj.transform(new_sensor_reading.reshape(1, -1))
+    x_pca = pca_obj.transform(x_scaled)
+    x_tensor = torch.tensor(x_pca, dtype=torch.float32)
+    discriminator_model.eval()
+    with torch.no_grad():
+        score = discriminator_model(x_tensor)
+    return score.item()
+
+# --- STEP 3: THE BENCHMARK LOOP ---
+N_TRIALS = 20 
+num_epochs = 400 # Slightly reduced for speed, usually enough for convergence
+qgan_auc_scores = []
+
+print(f"\nStarting {N_TRIALS} Trials of QGAN-AD...")
+
+for trial in range(N_TRIALS):
+    print(f"\n--- TRIAL {trial+1}/{N_TRIALS} ---")
+
+    # A. BUILD GENERATOR (Quantum)
+    # EfficientSU2 is good for "expressivity" (handling the islands)
+    qc = QuantumCircuit(num_qubits)
+    qc.h(qc.qubits)
+    ansatz = EfficientSU2(num_qubits, reps=4) # reps=4 is a good balance
+    qc.compose(ansatz, inplace=True)
+    
+    sampler = Sampler()
+    qnn = SamplerQNN(
+        circuit=qc, 
+        sampler=sampler, 
+        input_params=[], 
+        weight_params=qc.parameters
+    )
+    
+    # Connect to PyTorch
+    initial_weights = 0.1 * (2 * torch.rand(qnn.num_weights) - 1)
+    generator = TorchConnector(qnn, initial_weights=initial_weights)
+
+    # B. BUILD DISCRIMINATOR (Classical)
+    class Discriminator(nn.Module):
+        def __init__(self, input_size):
+            super(Discriminator, self).__init__()
+            self.model = nn.Sequential(
+                nn.Linear(input_size, 32), # Slightly wider for complex data
+                nn.LeakyReLU(0.2),
+                nn.Linear(32, 16),
+                nn.LeakyReLU(0.2),
+                nn.Linear(16, 1),
+                nn.Sigmoid()
+            )
+        def forward(self, x):
+            return self.model(x)
+            
+    discriminator = Discriminator(input_size=N_DIM)
+
+    # C. OPTIMIZERS
+    # Generator needs to be faster to learn the complex map
+    lr_g = 0.04 
+    lr_d = 0.01
+    opt_g = Adam(generator.parameters(), lr=lr_g)
+    opt_d = Adam(discriminator.parameters(), lr=lr_d)
+
+    # D. TRAINING
+    g_losses = []
+    d_losses = []
+    
+    for epoch in range(num_epochs):
+        # Train D
+        opt_d.zero_grad()
+        disc_real = discriminator(data_samples)
+        gen_dist = generator(torch.tensor([])).reshape(-1, 1)
+        loss_d_real = adversarial_loss(disc_real, valid, real_data_dist)
+        loss_d_fake = adversarial_loss(disc_real, fake, gen_dist.detach())
+        loss_d = (loss_d_real + loss_d_fake) / 2
+        loss_d.backward()
+        opt_d.step()
+
+        # Train G
+        opt_g.zero_grad()
+        gen_dist = generator(torch.tensor([])).reshape(-1, 1)
+        disc_fake = discriminator(data_samples)
+        loss_g = adversarial_loss(disc_fake, valid, gen_dist)
+        loss_g.backward()
+        opt_g.step()
+        
+        if epoch % 100 == 0:
+            g_losses.append(loss_g.item())
+            d_losses.append(loss_d.item())
+
+    # E. VALIDATION (THE GAP TEST)
+    # We test on a subset of healthy and ALL anomalous
+    healthy_subset = X_train_healthy.sample(n=500) 
+    
+    y_true = []
+    y_scores = []
+
+    # Test Healthy
+    for i in range(len(healthy_subset)):
+        sample = healthy_subset.iloc[i].values
+        score = detect_anomaly(sample, scaler, pca, discriminator)
+        y_true.append(0) # 0 = Healthy
+        y_scores.append(score)
+
+    # Test Anomalous (The Trap)
+    for i in range(len(X_test_anomalous)):
+        sample = X_test_anomalous.iloc[i].values
+        score = detect_anomaly(sample, scaler, pca, discriminator)
+        y_true.append(1) # 1 = Anomalous
+        y_scores.append(score)
+
+    # F. METRICS & PLOTS
+    # Calculate AUC (Flip scores because 0.0 is anomalous)
+    fpr, tpr, _ = roc_curve(y_true, 1 - np.array(y_scores))
+    roc_auc = auc(fpr, tpr)
+    qgan_auc_scores.append(roc_auc)
+    
+    print(f"Trial {trial+1} Complete. AUC: {roc_auc:.4f}")
+
+    # Save ROC Plot
+    plt.figure(figsize=(6,5))
+    plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'AUC={roc_auc:.2f}')
+    plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
+    plt.title(f"QGAN V2 Trial {trial+1}")
+    plt.legend(loc="lower right")
+    plt.savefig(f'plots_v2_qgan/roc_trial_{trial+1}.png')
+    plt.close()
+
+# --- FINAL SUMMARY ---
+print("\n" + "="*30)
+print("--- QGAN V2 BENCHMARK RESULTS ---")
+print(f"Mean AUC: {np.mean(qgan_auc_scores):.4f}")
+print(f"Max AUC:  {np.max(qgan_auc_scores):.4f}")
+print(f"Std Dev:  {np.std(qgan_auc_scores):.4f}")
+print("="*30)

Phase 1/main_fusion_qgan.py

@@ -0,0 +1,367 @@
+# --- STEP 1: IMPORT ALL LIBRARIES ---
+# [cite: 66-83]
+import matplotlib
+matplotlib.use('Agg') # <-- ADD THIS: Use "headless" backend
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import os # <-- ADD THIS: To create plot directory
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.metrics import roc_curve, auc
+import torch
+import torch.nn as nn
+from torch.optim import Adam
+from qiskit import QuantumCircuit
+from qiskit.circuit.library import EfficientSU2
+from qiskit.primitives import Sampler
+from qiskit_machine_learning.neural_networks import SamplerQNN
+from qiskit_machine_learning.connectors import TorchConnector
+
+print("All libraries imported successfully.")
+# --- NEW: Check for plots directory ---
+if not os.path.exists('plots'):
+    os.makedirs('plots')
+    print("Created 'plots/' directory.")
+else:
+    print("Plots will be saved to 'plots/' directory.")
+
+
+
+    # --- STEP 2: CREATE SIMULATED TOKAMAK DATA ---
+    # [cite: 88-115]
+    def get_simulated_tokamak_data(n_features=50, healthy_samples=5000, anomalous_samples=500):
+        """
+        Generates a fake dataset of 'healthy' and 'anomalous' plasma.
+        """
+        print(f"Generating {healthy_samples} healthy and {anomalous_samples} anomalous data points...")
+
+        # 1. Create the 'healthy' data
+        healthy_mean = np.zeros(n_features)
+        healthy_cov = np.diag(np.ones(n_features))
+        X_healthy = np.random.multivariate_normal(healthy_mean, healthy_cov, healthy_samples)
+
+        # 2. Create the 'anomalous' (disruptive) data
+        anomalous_mean = np.ones(n_features) * 2.5
+        anomalous_cov = np.diag(np.ones(n_features) * 0.5) # Make it a tighter cluster
+        X_anomalous = np.random.multivariate_normal(anomalous_mean, anomalous_cov, anomalous_samples)
+
+        # 3. Combine them into a single DataFrame
+        df_healthy = pd.DataFrame(X_healthy, columns=[f'sensor_{i}' for i in range(n_features)])
+        df_healthy['label'] = 0  # 0 = Healthy
+
+        df_anomalous = pd.DataFrame(X_anomalous, columns=[f'sensor_{i}' for i in range(n_features)])
+        df_anomalous['label'] = 1  # 1 = Anomalous
+
+        df_total = pd.concat([df_healthy, df_anomalous], ignore_index=True)
+
+        print("Simulated data generation complete.")
+        return df_total
+
+    # --- Run the function to get our data ---
+    simulated_data = get_simulated_tokamak_data()
+
+    # --- Peek at the data ---
+    print("First 5 rows of simulated data:")
+    print(simulated_data.head())
+
+
+    # --- STEP 3: THE DATA PIPELINE ---
+    # [cite: 119-158]
+    print("\nStarting data pipeline...")
+
+    # 3a. CRITICAL DATA FILTERING
+    X_train_healthy = simulated_data[simulated_data['label'] == 0].drop('label', axis=1)
+    X_test_anomalous = simulated_data[simulated_data['label'] == 1].drop('label', axis=1)
+    print(f"Isolated {len(X_train_healthy)} 'healthy' samples for training.")
+    print(f"Isolated {len(X_test_anomalous)} 'anomalous' samples for final testing.")
+
+    # 3b. NORMALIZE THE DATA
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X_train_healthy)
+    print("Data normalized.")
+
+    # 3c. DIMENSIONALITY REDUCTION (PCA)
+    N_DIM = 2  # 2 Dimensions
+    pca = PCA(n_components=N_DIM)
+    X_pca = pca.fit_transform(X_scaled)
+    print(f"Data compressed from 50 features to {N_DIM} features using PCA.")
+
+    # 3d. DISCRETIZE THE "HEALTHY" DISTRIBUTION
+    bins_per_dim = 4
+    num_qubits = 4
+
+    real_distribution_hist, x_edges, y_edges = np.histogram2d(
+        X_pca[:, 0],
+        X_pca[:, 1],
+        bins=bins_per_dim,
+        density=True
+    )
+
+    real_distribution = real_distribution_hist.flatten()
+    real_distribution = real_distribution / np.sum(real_distribution)
+
+    x_centers = (x_edges[:-1] + x_edges[1:]) / 2
+    y_centers = (y_edges[:-1] + y_edges[1:]) / 2
+    grid_samples = np.array(np.meshgrid(x_centers, y_centers)).T.reshape(-1, N_DIM)
+
+    print("Data pipeline complete. Target distribution (16 bins) created.")
+    print("Shape of target distribution:", real_distribution.shape)
+    print("Shape of grid samples (bin-centers):", grid_samples.shape)
+
+ # 5a. Custom Adversarial Loss Function
+    def adversarial_loss(input, target, w):
+        bce_loss = target * torch.log(input) + (1 - target) * torch.log(1 - input)
+        weighted_loss = w * bce_loss
+        total_loss = -torch.sum(weighted_loss)
+        return total_loss
+# 5c. Convert Data to Tensors
+    real_data_dist = torch.tensor(real_distribution, dtype=torch.float32).reshape(-1, 1)
+    data_samples = torch.tensor(grid_samples, dtype=torch.float32)
+
+    valid = torch.ones(real_data_dist.shape, dtype=torch.float32)
+    fake = torch.zeros(real_data_dist.shape, dtype=torch.float32)
+    
+# 7a. Define the Anomaly Detector Function
+    def detect_anomaly(new_sensor_reading, scaler_obj, pca_obj, discriminator_model):
+        """
+        Takes a single, high-dimensional sensor reading and returns an
+        anomaly score. Score ~1.0 = Healthy. Score ~0.0 = Anomalous.
+        """
+        # 1. Reshape and Scale
+        x_scaled = scaler_obj.transform(new_sensor_reading.reshape(1, -1))
+        # 2. Compress with PCA
+        x_pca = pca_obj.transform(x_scaled)  # Output is (1, 2)
+        # 3. Convert to PyTorch Tensor
+        x_tensor = torch.tensor(x_pca, dtype=torch.float32)
+        # 4. Feed to the *trained discriminator*
+        discriminator_model.eval()  # Set to evaluation mode
+        with torch.no_grad():
+            anomaly_score = discriminator_model(x_tensor)
+        return anomaly_score.item()
+
+    print("Anomaly Detector function defined.")
+
+N_TRIALS = 50
+qgan_auc_scores = []
+
+
+# --- START OF 50-TRIAL LOOP ---
+for i in range(N_TRIALS):
+    print(f"\n--- QGAN TRIAL {i+1}/{N_TRIALS} ---")
+
+
+    # --- STEP 4: ARCHITECT THE QGAN ---
+    # [cite: 165-207]
+    print("\nBuilding QGAN components...")
+
+    # 4a. The Quantum Generator (G)
+    qc_ansatz = EfficientSU2(num_qubits, reps=6)
+    qc = QuantumCircuit(num_qubits)
+    qc.h(qc.qubits)  # Start in a superposition
+    qc.compose(qc_ansatz, inplace=True)
+
+    # 4b. The SamplerQNN
+    sampler = Sampler()
+    qnn_generator = SamplerQNN(
+        circuit=qc,
+        sampler=sampler,
+        input_params=[],  # The circuit takes NO input
+        weight_params=qc.parameters,  # All parameters are trainable weights
+    )
+
+    # 4c. The TorchConnector
+    initial_weights = (2 * torch.rand(qnn_generator.num_weights) - 1)
+    generator = TorchConnector(qnn_generator, initial_weights=initial_weights)
+
+    # 4d. The Classical Discriminator (D)
+    class Discriminator(nn.Module):
+        def __init__(self, input_size):
+            super(Discriminator, self).__init__()
+            self.linear_input = nn.Linear(input_size, 20)
+            self.leaky_relu = nn.LeakyReLU(0.2)
+            self.linear20 = nn.Linear(20, 1)
+            self.sigmoid = nn.Sigmoid()
+
+        def forward(self, input: torch.Tensor) -> torch.Tensor:
+            x = self.linear_input(input)
+            x = self.leaky_relu(x)
+            x = self.linear20(x)
+            x = self.sigmoid(x)
+            return x
+
+    discriminator = Discriminator(input_size=N_DIM)
+    print("Generator and Discriminator built.")
+
+
+    # --- STEP 5: DEFINE TRAINING COMPONENTS ---
+    # [cite: 213-241]
+    print("\nDefining training loop components...")
+
+
+
+    # 5b. Optimizers
+    # NEW, TUNED LEARNING RATES
+    lr_g = 0.02   # Generator learns FASTER
+    lr_d = 0.005  # Discriminator learns SLOWER
+    b1 = 0.7
+    b2 = 0.999
+
+    print(f"Using tuned learning rates: G={lr_g}, D={lr_d}")
+
+    generator_optimizer = Adam(generator.parameters(), lr=lr_g, betas=(b1, b2))
+    discriminator_optimizer = Adam(discriminator.parameters(), lr=lr_d, betas=(b1, b2))
+
+    
+
+    g_losses = []
+    d_losses = []
+    rel_ents = []
+    print("Training setup complete.")
+
+
+    # --- STEP 6: RUN THE TRAINING LOOP ---
+    # [cite: 244-297]
+    num_epochs = 500
+    print(f"Starting training for {num_epochs} epochs...")
+
+    for epoch in range(num_epochs):
+        # --- Train Discriminator (The "Guard") ---
+        discriminator_optimizer.zero_grad()
+        disc_scores = discriminator(data_samples)
+        gen_dist = generator(torch.tensor([])).reshape(-1, 1)
+        real_loss = adversarial_loss(disc_scores, valid, real_data_dist)
+        fake_loss = adversarial_loss(disc_scores, fake, gen_dist.detach())
+        discriminator_loss = (real_loss + fake_loss) / 2
+        discriminator_loss.backward()
+        discriminator_optimizer.step()
+
+        # --- Train Generator (The "Sparring Partner") ---
+        generator_optimizer.zero_grad()
+        gen_dist = generator(torch.tensor([])).reshape(-1, 1)
+        disc_scores = discriminator(data_samples)
+        generator_loss = adversarial_loss(disc_scores, valid, gen_dist)
+        generator_loss.backward()
+        generator_optimizer.step()
+
+        # --- Log Progress ---
+        g_losses.append(generator_loss.item())
+        d_losses.append(discriminator_loss.item())
+
+        gen_dist_np = gen_dist.detach().numpy().flatten()
+        real_dist_np = real_distribution.flatten()
+        rel_ent = np.sum(real_dist_np * np.log((real_dist_np + 1e-9) / (gen_dist_np + 1e-9)))
+        rel_ents.append(rel_ent)
+
+        if (epoch + 1) % 50 == 0:
+            print(f"Epoch [{epoch+1}/{num_epochs}] G Loss: {generator_loss.item():.4f} | D Loss: {discriminator_loss.item():.4f} | Rel Ent: {rel_ent:.4f}")
+
+    print("Training complete.")
+
+    # --- Plot Training Progress ---
+    # [cite: 299-317]
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+    fig.suptitle("QGAN-AD Training Progress")
+
+    ax1.plot(g_losses, label='Generator Loss')
+    ax1.plot(d_losses, label='Discriminator Loss')
+    ax1.set_title("Adversarial Losses")
+    ax1.set_xlabel("Epoch")
+    ax1.set_ylabel("Loss")
+    ax1.legend()
+
+    ax2.plot(rel_ents, label='Relative Entropy', color='green')
+    ax2.set_title("Relative Entropy (G vs. Real)")
+    ax2.set_xlabel("Epoch")
+    ax2.set_ylabel("Entropy (Lower is better)")
+    ax2.legend()
+
+    print("Displaying training graphs. Close the window to continue to the final test.")
+    plt.savefig(f'plots/QGAN_Trial_{i+1}_TrainingProgress.png')
+    plt.close(fig) # This closes the plot in memory, fixing the "beach ball"
+
+
+    # --- STEP 7: DEPLOYMENT AND VALIDATION---
+    # [cite: 323-345]
+    print("\n--- Phase IV: Deployment & Validation ---")
+
+    
+
+    # 7b. Test 1: Run the detector on "Healthy" data
+    # [cite: 347-356]
+    print("Testing detector on HEALTHY data (expect scores near 1.0)...")
+    healthy_scores = []
+    # We'll just test the first 1000 healthy samples for speed
+    for i in range(min(1000, len(X_train_healthy))):
+        sample = X_train_healthy.iloc[i].values
+        score = detect_anomaly(sample, scaler, pca, discriminator)
+        healthy_scores.append(score)
+
+    # 7c. Test 2: Run the detector on "Anomalous" data
+    # [cite: 358-366]
+    print("Testing detector on ANOMALOUS data (expect scores near 0.0)...")
+    anomalous_scores = []
+    for i in range(len(X_test_anomalous)):
+        sample = X_test_anomalous.iloc[i].values
+        score = detect_anomaly(sample, scaler, pca, discriminator)
+        anomalous_scores.append(score)
+
+    print("Validation complete.")
+
+    # 7d. Visualize the Results: The Histogram
+    # [cite: 368-380]
+    plt.figure(figsize=(10, 6))
+    plt.hist(healthy_scores, bins=50, alpha=0.7, label='Healthy Scores (Trained On)', density=True, color='blue')
+    plt.hist(anomalous_scores, bins=50, alpha=0.7, label='Anomalous Scores (NEVER Seen Before)', density=True, color='red')
+    plt.title("QGAN-AD: Anomaly Score Distributions")
+    plt.xlabel("Anomaly Score (1.0 = Real/Healthy, 0.0 = Fake/Anomalous)")
+    plt.ylabel("Probability Density")
+    plt.legend()
+    plt.savefig(f'plots/QGAN_Trial_{i+1}_Histogram.png')
+    plt.close() # Closes the current figure
+
+    # 7e. The "Money Plot": The ROC Curve
+    # [cite: 382-406]
+    print("Generating final ROC Curve...")
+
+    y_true_healthy = np.zeros(len(healthy_scores))
+    y_true_anomalous = np.ones(len(anomalous_scores))
+    y_true = np.concatenate([y_true_healthy, y_true_anomalous])
+    y_scores = np.concatenate([healthy_scores, anomalous_scores])
+
+    # We use (1 - y_scores) because our 'anomalous' class (1) has a score near 0.0
+    fpr, tpr, _ = roc_curve(y_true, 1 - np.array(y_scores))
+    roc_auc = auc(fpr, tpr)
+    qgan_auc_scores.append(roc_auc)
+
+    plt.figure(figsize=(10, 8))
+    plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (AUC = {roc_auc:.4f})')
+    plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
+    plt.xlim([0.0, 1.0])
+    plt.ylim([0.0, 1.05])
+    plt.xlabel('False Positive Rate (Fooled by "Healthy")')
+    plt.ylabel('True Positive Rate (Correctly caught "Anomalous")')
+    plt.title('Receiver Operating Characteristic (ROC) Curve for QGAN-AD')
+    plt.legend(loc="lower right")
+
+    print(f"\nFINAL RESULT: Area Under Curve (AUC) = {roc_auc:.4f}")
+    print("(An AUC of 1.0 is a perfect detector. 0.5 is random guessing.)")
+    plt.savefig(f'plots/QGAN_Trial_{i+1}_ROC.png')
+    plt.close() # Closes the current figure
+
+# ... (This is the end of the `for` loop) ...
+
+# --- FINAL RESULTS ---
+# (Make sure this block is UN-INDENTED, so it's OUTSIDE the loop)
+print("\n" + "="*30)
+print("--- FINAL QGAN RESULTS ---")
+print(f"Scores over {N_TRIALS} trials:")
+print([round(score, 4) for score in qgan_auc_scores])
+print(f"\nAverage QGAN AUC: {np.mean(qgan_auc_scores):.4f}")
+print(f"Standard Deviation: {np.std(qgan_auc_scores):.4f}")
+print(f"Max AUC (Best Run): {np.max(qgan_auc_scores):.4f}")
+print(f"Min AUC (Worst Run): {np.min(qgan_auc_scores):.4f}")
+print(f"\nAll {N_TRIALS*3} plots saved to 'plots/' directory.")
+print("="*30)
+
+print("\n--- ACTION PLAN COMPLETE ---")

Phase 1/physics_data

@@ -0,0 +1,110 @@
+# Save this as physics_data.py
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+
+def generate_complex_tokamak_data(n_samples=5000, n_features=50):
+    """
+    Simulates complex, multi-modal Tokamak data.
+    Modes:
+    1. Ramp-up (High variation, 'The Takeoff')
+    2. Flat-top (Stable, tight cluster, 'The Cruise')
+    3. Ramp-down (Lower energy, 'The Landing')
+    """
+    print(f"--- GENERATING PHYSICS-INFORMED DATA ({n_samples} samples) ---")
+    
+    np.random.seed(42) 
+
+    # --- 1. HEALTHY DATA (The "Three Phases") ---
+    # This mimics the distinct operational phases of a tokamak discharge.
+    
+    # Mode A: Ramp-Up (25% of data) - Noisy, rising current
+    n_a = int(0.25 * n_samples)
+    # Centered at (-2, -2) in latent space roughly
+    mean_a = np.zeros(n_features) - 2.0  
+    cov_a = np.eye(n_features) * 0.6     
+    data_a = np.random.multivariate_normal(mean_a, cov_a, n_a)
+
+    # Mode B: Flat-Top (50% of data) - The Stable Core
+    # This is the "safe" fusion state.
+    n_b = int(0.50 * n_samples)
+    mean_b = np.zeros(n_features)        
+    cov_b = np.eye(n_features) * 0.3     # Very tight, organized
+    data_b = np.random.multivariate_normal(mean_b, cov_b, n_b)
+
+    # Mode C: Ramp-Down (25% of data) - Cooling down
+    n_c = n_samples - n_a - n_b
+    mean_c = np.zeros(n_features) + 2.0  
+    cov_c = np.eye(n_features) * 0.6     
+    data_c = np.random.multivariate_normal(mean_c, cov_c, n_c)
+
+    # Stack them to create the "Healthy Manifold"
+    X_healthy = np.vstack([data_a, data_b, data_c])
+    
+    # --- 2. ANOMALOUS DATA (The "Trap") ---
+    n_anom = int(n_samples * 0.1) # 10% anomaly rate
+    
+    # Type 1: The "Bridge Gap" (Points hidden BETWEEN modes)
+    # These mimic "failed transitions" or "locked modes"
+    # If the discriminator is lazy, it will think these gaps are safe bridges.
+    n_anom_1 = int(n_anom * 0.6)
+    mean_bad_1 = np.zeros(n_features) - 1.0 # Stuck between Ramp and Flat-top
+    cov_bad_1 = np.eye(n_features) * 0.15   # Tight cluster in the gap
+    data_bad_1 = np.random.multivariate_normal(mean_bad_1, cov_bad_1, n_anom_1)
+
+    # Type 2: The "Hard Disruption" (Energy Spike / Greenwald Limit)
+    n_anom_2 = n_anom - n_anom_1
+    mean_bad_2 = np.ones(n_features) * 3.5 # Way outside normal bounds
+    cov_bad_2 = np.eye(n_features) * 0.5
+    data_bad_2 = np.random.multivariate_normal(mean_bad_2, cov_bad_2, n_anom_2)
+    
+    X_anomalous = np.vstack([data_bad_1, data_bad_2])
+
+    # --- 3. DATAFRAME CREATION ---
+    df_healthy = pd.DataFrame(X_healthy, columns=[f'sensor_{i}' for i in range(n_features)])
+    df_healthy['label'] = 0  # 0 = Healthy
+
+    df_anomalous = pd.DataFrame(X_anomalous, columns=[f'sensor_{i}' for i in range(n_features)])
+    df_anomalous['label'] = 1  # 1 = Anomalous
+
+    df_total = pd.concat([df_healthy, df_anomalous], ignore_index=True)
+    
+    # Shuffle the deck
+    df_total = df_total.sample(frac=1).reset_index(drop=True)
+    
+    print(f"Generated {len(df_healthy)} healthy and {len(df_anomalous)} anomalous samples.")
+    return df_total
+
+if __name__ == "__main__":
+    # Generate and Save
+    df = generate_complex_tokamak_data()
+    df.to_csv('complex_tokamak_data.csv', index=False)
+    print("Saved to 'complex_tokamak_data.csv'")
+    
+    # --- VISUAL PROOF ---
+    # We use PCA to project the 50D data to 2D so you can SEE the islands
+    print("Generating preview plot...")
+    pca = PCA(n_components=2)
+    X = df.drop('label', axis=1)
+    y = df['label']
+    X_pca = pca.fit_transform(X)
+    
+    plt.figure(figsize=(10, 8))
+    
+    # Plot Healthy (Blue)
+    plt.scatter(X_pca[y==0, 0], X_pca[y==0, 1], 
+                c='blue', alpha=0.2, s=10, label='Healthy (3 Modes)')
+    
+    # Plot Anomalous (Red)
+    plt.scatter(X_pca[y==1, 0], X_pca[y==1, 1], 
+                c='red', alpha=0.6, s=10, label='Anomalies (The Trap)')
+    
+    plt.title("V2 Benchmark Data: The 'Three Islands' Topology")
+    plt.xlabel("Principal Component 1")
+    plt.ylabel("Principal Component 2")
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    
+    plt.savefig('v2_data_topology.png')
+    print("Plot saved to 'v2_data_topology.png'. Open it to see the 'Islands'.")

plasma_sim_v2.py

@@ -0,0 +1,64 @@
+import numpy as np
+import pandas as pd
+from scipy.integrate import odeint
+
+def lorenz_system(current_state, t, sigma=10, rho=28, beta=8/3):
+    """
+    The Lorenz Attractor equations. 
+    x = Proxy for Plasma Radial Position
+    y = Proxy for Poloidal Magnetic Field
+    z = Proxy for Toroidal Magnetic Field
+    """
+    x, y, z = current_state
+    dx_dt = sigma * (y - x)
+    dy_dt = x * (rho - z) - y
+    dz_dt = x * y - beta * z
+    return [dx_dt, dy_dt, dz_dt]
+
+def generate_plasma_data(n_samples=5000):
+    """
+    Generates synthetic fusion data based on chaotic turbulence.
+    """
+    print(f"Generating {n_samples} physics-informed plasma samples...")
+    
+    # --- 1. Generate HEALTHY Data (The Attractor) ---
+    # We simulate a stable plasma orbit on the 'strange attractor'
+    dt = 0.01
+    t_span = np.arange(0, n_samples * dt, dt)
+    initial_state = [1.0, 1.0, 1.0]
+    
+    # Solve the differential equations
+    healthy_data = odeint(lorenz_system, initial_state, t_span)
+    
+    # Add 47 dummy 'noise' sensors to mimic a 50-sensor array
+    # Real sensors are just correlated versions of the main physics variables
+    noise_sensors = np.random.normal(0, 0.5, (n_samples, 47))
+    X_healthy = np.hstack([healthy_data, noise_sensors])
+    
+    # --- 2. Generate ANOMALOUS Data (The Disruption) ---
+    # We simulate a 'Locked Mode' by changing the physics parameter 'rho'
+    # This causes the plasma to drift off the stable manifold
+    t_span_anom = np.arange(0, (n_samples // 10) * dt, dt)
+    
+    # rho=15 changes the topology of the attractor (Disruption Precursor)
+    anomalous_data = odeint(lorenz_system, initial_state, t_span_anom, args=(10, 15, 8/3))
+    
+    noise_sensors_anom = np.random.normal(0, 0.5, (len(anomalous_data), 47))
+    X_anomalous = np.hstack([anomalous_data, noise_sensors_anom])
+
+    # --- 3. Save to CSV ---
+    df_healthy = pd.DataFrame(X_healthy, columns=[f'sensor_{i}' for i in range(50)])
+    df_healthy['label'] = 0  # 0 = Healthy
+    
+    df_anomalous = pd.DataFrame(X_anomalous, columns=[f'sensor_{i}' for i in range(50)])
+    df_anomalous['label'] = 1  # 1 = Disruption
+    
+    df_final = pd.concat([df_healthy, df_anomalous], ignore_index=True)
+    
+    output_file = "physics_informed_data.csv"
+    df_final.to_csv(output_file, index=False)
+    print(f"Success! Saved physics-informed data to {output_file}")
+    print("Shape:", df_final.shape)
+
+if __name__ == "__main__":
+    generate_plasma_data()