Add paper link to demo interface

app.py

@@ -1,463 +1,474 @@
-"""
-Phase 4: Quantum-ML Compression Demo
-Interactive Gradio application showcasing quantum computing, model compression, and energy efficiency
-"""
-
-import gradio as gr
-import pandas as pd
-import numpy as np
-import torch
-import torch.nn as nn
-import json
-import plotly.graph_objects as go
-from typing import Dict, Tuple, List
-import time
-
-# Mock quantum simulator (replace with actual implementation)
-def simulate_grover(n_qubits: int, target_pattern: str, iterations: int) -> Dict:
-    """Simulate Grover's algorithm"""
-    # Theoretical success probability
-    N = 2 ** n_qubits
-    theta = np.arcsin(1 / np.sqrt(N))
-    success_prob = np.sin((2 * iterations + 1) * theta) ** 2
-    
-    # Add some noise for realism
-    noise = np.random.normal(0, 0.02)
-    success_prob = np.clip(success_prob + noise, 0, 1)
-    
-    return {
-        "n_qubits": n_qubits,
-        "target": target_pattern,
-        "iterations": iterations,
-        "success_rate": float(success_prob),
-        "optimal_k": int(np.pi / 4 * np.sqrt(N))
-    }
-
-def create_grover_plot(n_qubits: int, target_pattern: str) -> go.Figure:
-    """Create Grover's algorithm success probability plot"""
-    N = 2 ** n_qubits
-    k_values = range(0, min(20, N))
-    theta = np.arcsin(1 / np.sqrt(N))
-    probabilities = [np.sin((2 * k + 1) * theta) ** 2 for k in k_values]
-    
-    optimal_k = int(np.pi / 4 * np.sqrt(N))
-    
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(
-        x=list(k_values),
-        y=probabilities,
-        mode='lines+markers',
-        name='Success Probability',
-        line=dict(color='purple', width=2),
-        marker=dict(size=8)
-    ))
-    
-    # Mark optimal k
-    fig.add_vline(
-        x=optimal_k, 
-        line_dash="dash", 
-        line_color="red",
-        annotation_text=f"Optimal k={optimal_k}"
-    )
-    
-    fig.update_layout(
-        title=f"Grover's Algorithm: n={n_qubits} qubits, target=|{target_pattern}⟩",
-        xaxis_title="Iterations (k)",
-        yaxis_title="Success Probability",
-        yaxis_range=[0, 1],
-        template="plotly_white",
-        height=400
-    )
-    
-    return fig
-
-def compress_model_demo(model_type: str, compression_method: str) -> Dict:
-    """Demonstrate model compression"""
-    
-    # Model configurations
-    model_configs = {
-        "MLP": {"params": 235146, "original_size": 943404, "compressed_size": 241202},
-        "CNN": {"params": 422000, "original_size": 1689976, "compressed_size": 483378},
-        "Custom": {"params": 500000, "original_size": 2000000, "compressed_size": 550000}
-    }
-    
-    config = model_configs.get(model_type, model_configs["MLP"])
-    
-    if compression_method == "Dynamic INT8":
-        ratio = config["original_size"] / config["compressed_size"]
-        quality = 99.8 - np.random.uniform(0, 0.5)
-    else:  # Static INT8
-        ratio = (config["original_size"] / config["compressed_size"]) * 1.1
-        quality = 99.9 - np.random.uniform(0, 0.3)
-    
-    return {
-        "model_type": model_type,
-        "compression_method": compression_method,
-        "parameters": f"{config['params']:,}",
-        "original_size_kb": f"{config['original_size']/1024:.1f} KB",
-        "compressed_size_kb": f"{config['compressed_size']/1024:.1f} KB",
-        "compression_ratio": f"{ratio:.2f}×",
-        "quality_preserved": f"{quality:.1f}%",
-        "inference_speedup": f"{np.random.uniform(0.8, 1.2):.2f}×"
-    }
-
-def calculate_energy_savings(
-    model_size_mb: float, 
-    batch_size: int, 
-    iterations: int,
-    use_compression: bool
-) -> pd.DataFrame:
-    """Calculate energy efficiency metrics"""
-    
-    # Base calculations
-    base_power = 125.0  # Watts
-    compressed_power = 68.75  # Watts
-    
-    tokens_per_second_base = 66.67
-    tokens_per_second_compressed = 85.47
-    
-    total_tokens = batch_size * iterations * 100  # Assume 100 tokens per batch
-    
-    if use_compression:
-        time_seconds = total_tokens / tokens_per_second_compressed
-        energy_joules = compressed_power * time_seconds
-        power = compressed_power
-        throughput = tokens_per_second_compressed
-    else:
-        time_seconds = total_tokens / tokens_per_second_base
-        energy_joules = base_power * time_seconds
-        power = base_power
-        throughput = tokens_per_second_base
-    
-    # Create comparison table
-    data = {
-        "Metric": [
-            "Model Size (MB)",
-            "Average Power (W)",
-            "Throughput (tokens/s)",
-            "Total Time (s)",
-            "Total Energy (J)",
-            "Energy per 1K tokens (J)",
-            "Carbon Footprint (g CO₂)"
-        ],
-        "Baseline (FP32)": [
-            f"{model_size_mb:.1f}",
-            f"{base_power:.1f}",
-            f"{tokens_per_second_base:.1f}",
-            f"{total_tokens/tokens_per_second_base:.2f}",
-            f"{base_power * (total_tokens/tokens_per_second_base):.1f}",
-            f"{base_power * (1000/tokens_per_second_base):.1f}",
-            f"{base_power * (total_tokens/tokens_per_second_base) * 0.5:.1f}"
-        ]
-    }
-    
-    if use_compression:
-        data["Compressed (INT8)"] = [
-            f"{model_size_mb/4:.1f}",
-            f"{power:.1f}",
-            f"{throughput:.1f}",
-            f"{time_seconds:.2f}",
-            f"{energy_joules:.1f}",
-            f"{power * (1000/throughput):.1f}",
-            f"{energy_joules * 0.5:.1f}"
-        ]
-        
-        data["Savings"] = [
-            f"{(1 - 1/4)*100:.0f}%",
-            f"{(1 - compressed_power/base_power)*100:.0f}%",
-            f"{(throughput/tokens_per_second_base - 1)*100:.0f}%",
-            f"{(1 - time_seconds/(total_tokens/tokens_per_second_base))*100:.0f}%",
-            f"{(1 - energy_joules/(base_power * (total_tokens/tokens_per_second_base)))*100:.0f}%",
-            f"{(1 - (power * (1000/throughput))/(base_power * (1000/tokens_per_second_base)))*100:.0f}%",
-            f"{(1 - energy_joules/(base_power * (total_tokens/tokens_per_second_base)))*100:.0f}%"
-        ]
-    
-    return pd.DataFrame(data)
-
-def load_benchmark_results() -> pd.DataFrame:
-    """Load pre-computed benchmark results"""
-    data = {
-        "Experiment": [
-            "Quantum (Simulator)",
-            "Quantum (IBM Hardware)",
-            "Compression (MLP)",
-            "Compression (CNN)",
-            "Energy Reduction",
-            "SGD Optimization",
-            "Evolution Optimization"
-        ],
-        "Metric": [
-            "Success Rate",
-            "Success Rate",
-            "Compression Ratio",
-            "Compression Ratio",
-            "Power Reduction",
-            "Convergence Time",
-            "Final Loss"
-        ],
-        "Target": [
-            "≥90%",
-            "≥55%",
-            "≥4.0×",
-            "≥4.0×",
-            "≥40%",
-            "Baseline",
-            "Better Loss"
-        ],
-        "Achieved": [
-            "95.3%",
-            "59.9%",
-            "3.91×",
-            "3.50×",
-            "57.1%",
-            "0.232s",
-            "7.67e-11"
-        ],
-        "Status": [
-            "✅ PASS",
-            "✅ PASS",
-            "⚠️ 98% of target",
-            "⚠️ 87% of target",
-            "✅ EXCEEDS",
-            "✅ BASELINE",
-            "✅ 128× better"
-        ]
-    }
-    
-    return pd.DataFrame(data)
-
-def create_app():
-    """Create the main Gradio application"""
-    
-    with gr.Blocks(
-        title="Phase 4: Quantum-ML Benchmark Demo",
-        theme=gr.themes.Soft(primary_hue="purple"),
-        css="""
-        .gradio-container {
-            max-width: 1200px;
-            margin: auto;
-        }
-        """
-    ) as app:
-        
-        # Header
-        gr.Markdown("""
-        # ⚛️ Phase 4: Quantum Computing + ML Compression Demo
-        
-        Interactive demonstration of quantum algorithms, model compression, and energy efficiency benchmarks.
-        
-        [![Models](https://img.shields.io/badge/🤗%20Models-phase4--quantum--compression-blue)](https://huggingface.co/jmurray10/phase4-quantum-compression)
-        [![Dataset](https://img.shields.io/badge/🤗%20Dataset-phase4--quantum--benchmarks-green)](https://huggingface.co/datasets/jmurray10/phase4-quantum-benchmarks)
-        [![GitHub](https://img.shields.io/badge/GitHub-Source%20Code-black)](https://github.com/jmurray10/phase4-experiment)
-        """)
-        
-        with gr.Tabs():
-            
-            # Tab 1: Quantum Computing
-            with gr.TabItem("🔬 Quantum Computing"):
-                gr.Markdown("## Grover's Algorithm Simulator")
-                gr.Markdown("Demonstrate quantum search with quadratic speedup")
-                
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        n_qubits = gr.Slider(
-                            2, 5, value=3, step=1,
-                            label="Number of Qubits (n)"
-                        )
-                        target_pattern = gr.Textbox(
-                            value="101",
-                            label="Target Pattern (binary)",
-                            placeholder="e.g., 101 for 3 qubits"
-                        )
-                        iterations = gr.Slider(
-                            1, 10, value=2, step=1,
-                            label="Grover Iterations (k)"
-                        )
-                        
-                        run_quantum = gr.Button("Run Quantum Simulation", variant="primary")
-                        
-                        quantum_results = gr.JSON(label="Simulation Results")
-                    
-                    with gr.Column(scale=2):
-                        quantum_plot = gr.Plot(label="Success Probability vs Iterations")
-                        
-                        gr.Markdown("""
-                        **Theory**: Grover's algorithm finds a marked item in O(√N) time.
-                        
-                        **Optimal iterations**: k* = ⌊π/4 √(2^n)⌋
-                        """)
-                
-                def run_quantum_sim(n, pattern, k):
-                    result = simulate_grover(n, pattern, k)
-                    plot = create_grover_plot(n, pattern)
-                    return result, plot
-                
-                run_quantum.click(
-                    run_quantum_sim,
-                    inputs=[n_qubits, target_pattern, iterations],
-                    outputs=[quantum_results, quantum_plot]
-                )
-            
-            # Tab 2: Model Compression
-            with gr.TabItem("📦 Model Compression"):
-                gr.Markdown("## PyTorch Model Compression Demo")
-                gr.Markdown("Compress models with INT8 quantization and measure real file sizes")
-                
-                with gr.Row():
-                    with gr.Column():
-                        model_type = gr.Dropdown(
-                            ["MLP", "CNN", "Custom"],
-                            value="MLP",
-                            label="Model Type"
-                        )
-                        compression_method = gr.Dropdown(
-                            ["Dynamic INT8", "Static INT8"],
-                            value="Dynamic INT8",
-                            label="Compression Method"
-                        )
-                        
-                        compress_btn = gr.Button("Compress Model", variant="primary")
-                        
-                    with gr.Column():
-                        compression_output = gr.JSON(label="Compression Results")
-                
-                gr.Markdown("""
-                ### Real Results from Phase 4:
-                - **MLP**: 943KB → 241KB (3.91× compression)
-                - **CNN**: 1,690KB → 483KB (3.50× compression)
-                - **Quality Preserved**: >99.8%
-                
-                *Note: Compression ratio below theoretical 4× due to PyTorch metadata overhead*
-                """)
-                
-                compress_btn.click(
-                    compress_model_demo,
-                    inputs=[model_type, compression_method],
-                    outputs=compression_output
-                )
-            
-            # Tab 3: Energy Efficiency
-            with gr.TabItem("⚡ Energy Calculator"):
-                gr.Markdown("## Energy Efficiency Calculator")
-                gr.Markdown("Calculate energy savings from model compression")
-                
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        model_size = gr.Number(
-                            value=1.0,
-                            label="Model Size (MB)"
-                        )
-                        batch_size = gr.Slider(
-                            1, 128, value=32,
-                            label="Batch Size"
-                        )
-                        iterations = gr.Number(
-                            value=1000,
-                            label="Number of Iterations"
-                        )
-                        use_compression = gr.Checkbox(
-                            value=True,
-                            label="Use INT8 Compression"
-                        )
-                        
-                        calculate_btn = gr.Button("Calculate Energy", variant="primary")
-                    
-                    with gr.Column(scale=2):
-                        energy_output = gr.DataFrame(
-                            label="Energy Consumption Analysis",
-                            headers=["Metric", "Baseline (FP32)", "Compressed (INT8)", "Savings"]
-                        )
-                
-                gr.Markdown("""
-                ### Measured Energy Savings:
-                - **Power Reduction**: 125W → 68.75W (45%)
-                - **Energy per Million Tokens**: 1,894 kJ → 813 kJ (57% reduction)
-                - **Carbon Footprint**: Reduced by >50%
-                """)
-                
-                calculate_btn.click(
-                    calculate_energy_savings,
-                    inputs=[model_size, batch_size, iterations, use_compression],
-                    outputs=energy_output
-                )
-            
-            # Tab 4: Benchmark Results
-            with gr.TabItem("📊 Results Dashboard"):
-                gr.Markdown("## Complete Phase 4 Benchmark Results")
-                
-                results_df = gr.DataFrame(
-                    value=load_benchmark_results(),
-                    label="All Benchmark Results",
-                    interactive=False
-                )
-                
-                gr.Markdown("""
-                ### Key Achievements:
-                - ✅ **Quantum Success**: 95.3% (simulator), 59.9% (IBM hardware)
-                - ✅ **Compression**: 3.91× for MLP (98% of target)
-                - ✅ **Energy Savings**: 57.1% reduction achieved
-                - ✅ **ML Optimization**: SGD 3.84× more efficient
-                
-                ### Summary Statistics:
-                - **Tests Run**: 5 major categories
-                - **Pass Rate**: 100% acceptance criteria
-                - **IBM Quantum**: Real hardware execution verified
-                - **No Hardcoding**: All results computed at runtime
-                """)
-            
-            # Tab 5: About
-            with gr.TabItem("ℹ️ About"):
-                gr.Markdown("""
-                ## About Phase 4 Experiment
-                
-                This project demonstrates the successful integration of:
-                - 🔬 **Quantum Computing**: Grover's algorithm on IBM hardware
-                - 📦 **Model Compression**: Real PyTorch INT8 quantization
-                - ⚡ **Energy Efficiency**: Measured power savings
-                - 🎯 **ML Optimization**: SGD vs Evolution comparison
-                
-                ### Technical Highlights:
-                - Executed on IBM Brisbane (127-qubit quantum computer)
-                - Achieved 3.91× compression with <0.2% quality loss
-                - Reduced energy consumption by 57%
-                - 100% test coverage with no hardcoded results
-                
-                ### Resources:
-                - 📦 [Download Models](https://huggingface.co/jmurray10/phase4-quantum-compression)
-                - 📊 [Access Dataset](https://huggingface.co/datasets/jmurray10/phase4-quantum-benchmarks)
-                - 📝 [Technical Documentation](https://github.com/jmurray10/phase4-experiment)
-                - 🔬 [Research Paper](#) (Coming Soon)
-                
-                ### Citation:
-                ```bibtex
-                @software{phase4_2025,
-                  title={Phase 4: Quantum-ML Compression Benchmarks},
-                  author={Phase 4 Research Team},
-                  year={2025},
-                  publisher={Hugging Face}
-                }
-                ```
-                
-                ---
-                *Made with ❤️ by the Phase 4 Research Team*
-                """)
-        
-        # Footer
-        gr.Markdown("""
-        ---
-        **Phase 4: Making Quantum & AI Efficiency Real** | 
-        [Models](https://huggingface.co/jmurray10/phase4-quantum-compression) | 
-        [Dataset](https://huggingface.co/datasets/jmurray10/phase4-quantum-benchmarks) | 
-        [GitHub](https://github.com/jmurray10/phase4-experiment)
-        """)
-    
-    return app
-
-if __name__ == "__main__":
-    app = create_app()
-    app.launch(
-        share=False,
-        show_error=True,
-        server_name="0.0.0.0",
-        server_port=7860
+"""
+Phase 4: Quantum-ML Compression Demo
+Interactive Gradio application showcasing quantum computing, model compression, and energy efficiency
+"""
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import json
+import plotly.graph_objects as go
+from typing import Dict, Tuple, List
+import time
+
+# Mock quantum simulator (replace with actual implementation)
+def simulate_grover(n_qubits: int, target_pattern: str, iterations: int) -> Dict:
+    """Simulate Grover's algorithm"""
+    # Theoretical success probability
+    N = 2 ** n_qubits
+    theta = np.arcsin(1 / np.sqrt(N))
+    success_prob = np.sin((2 * iterations + 1) * theta) ** 2
+    
+    # Add some noise for realism
+    noise = np.random.normal(0, 0.02)
+    success_prob = np.clip(success_prob + noise, 0, 1)
+    
+    return {
+        "n_qubits": n_qubits,
+        "target": target_pattern,
+        "iterations": iterations,
+        "success_rate": float(success_prob),
+        "optimal_k": int(np.pi / 4 * np.sqrt(N))
+    }
+
+def create_grover_plot(n_qubits: int, target_pattern: str) -> go.Figure:
+    """Create Grover's algorithm success probability plot"""
+    N = 2 ** n_qubits
+    k_values = range(0, min(20, N))
+    theta = np.arcsin(1 / np.sqrt(N))
+    probabilities = [np.sin((2 * k + 1) * theta) ** 2 for k in k_values]
+    
+    optimal_k = int(np.pi / 4 * np.sqrt(N))
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(
+        x=list(k_values),
+        y=probabilities,
+        mode='lines+markers',
+        name='Success Probability',
+        line=dict(color='purple', width=2),
+        marker=dict(size=8)
+    ))
+    
+    # Mark optimal k
+    fig.add_vline(
+        x=optimal_k, 
+        line_dash="dash", 
+        line_color="red",
+        annotation_text=f"Optimal k={optimal_k}"
+    )
+    
+    fig.update_layout(
+        title=f"Grover's Algorithm: n={n_qubits} qubits, target=|{target_pattern}⟩",
+        xaxis_title="Iterations (k)",
+        yaxis_title="Success Probability",
+        yaxis_range=[0, 1],
+        template="plotly_white",
+        height=400
+    )
+    
+    return fig
+
+def compress_model_demo(model_type: str, compression_method: str) -> Dict:
+    """Demonstrate model compression"""
+    
+    # Model configurations
+    model_configs = {
+        "MLP": {"params": 235146, "original_size": 943404, "compressed_size": 241202},
+        "CNN": {"params": 422000, "original_size": 1689976, "compressed_size": 483378},
+        "Custom": {"params": 500000, "original_size": 2000000, "compressed_size": 550000}
+    }
+    
+    config = model_configs.get(model_type, model_configs["MLP"])
+    
+    if compression_method == "Dynamic INT8":
+        ratio = config["original_size"] / config["compressed_size"]
+        quality = 99.8 - np.random.uniform(0, 0.5)
+    else:  # Static INT8
+        ratio = (config["original_size"] / config["compressed_size"]) * 1.1
+        quality = 99.9 - np.random.uniform(0, 0.3)
+    
+    return {
+        "model_type": model_type,
+        "compression_method": compression_method,
+        "parameters": f"{config['params']:,}",
+        "original_size_kb": f"{config['original_size']/1024:.1f} KB",
+        "compressed_size_kb": f"{config['compressed_size']/1024:.1f} KB",
+        "compression_ratio": f"{ratio:.2f}×",
+        "quality_preserved": f"{quality:.1f}%",
+        "inference_speedup": f"{np.random.uniform(0.8, 1.2):.2f}×"
+    }
+
+def calculate_energy_savings(
+    model_size_mb: float, 
+    batch_size: int, 
+    iterations: int,
+    use_compression: bool
+) -> pd.DataFrame:
+    """Calculate energy efficiency metrics"""
+    
+    # Base calculations
+    base_power = 125.0  # Watts
+    compressed_power = 68.75  # Watts
+    
+    tokens_per_second_base = 66.67
+    tokens_per_second_compressed = 85.47
+    
+    total_tokens = batch_size * iterations * 100  # Assume 100 tokens per batch
+    
+    if use_compression:
+        time_seconds = total_tokens / tokens_per_second_compressed
+        energy_joules = compressed_power * time_seconds
+        power = compressed_power
+        throughput = tokens_per_second_compressed
+    else:
+        time_seconds = total_tokens / tokens_per_second_base
+        energy_joules = base_power * time_seconds
+        power = base_power
+        throughput = tokens_per_second_base
+    
+    # Create comparison table
+    data = {
+        "Metric": [
+            "Model Size (MB)",
+            "Average Power (W)",
+            "Throughput (tokens/s)",
+            "Total Time (s)",
+            "Total Energy (J)",
+            "Energy per 1K tokens (J)",
+            "Carbon Footprint (g CO₂)"
+        ],
+        "Baseline (FP32)": [
+            f"{model_size_mb:.1f}",
+            f"{base_power:.1f}",
+            f"{tokens_per_second_base:.1f}",
+            f"{total_tokens/tokens_per_second_base:.2f}",
+            f"{base_power * (total_tokens/tokens_per_second_base):.1f}",
+            f"{base_power * (1000/tokens_per_second_base):.1f}",
+            f"{base_power * (total_tokens/tokens_per_second_base) * 0.5:.1f}"
+        ]
+    }
+    
+    if use_compression:
+        data["Compressed (INT8)"] = [
+            f"{model_size_mb/4:.1f}",
+            f"{power:.1f}",
+            f"{throughput:.1f}",
+            f"{time_seconds:.2f}",
+            f"{energy_joules:.1f}",
+            f"{power * (1000/throughput):.1f}",
+            f"{energy_joules * 0.5:.1f}"
+        ]
+        
+        data["Savings"] = [
+            f"{(1 - 1/4)*100:.0f}%",
+            f"{(1 - compressed_power/base_power)*100:.0f}%",
+            f"{(throughput/tokens_per_second_base - 1)*100:.0f}%",
+            f"{(1 - time_seconds/(total_tokens/tokens_per_second_base))*100:.0f}%",
+            f"{(1 - energy_joules/(base_power * (total_tokens/tokens_per_second_base)))*100:.0f}%",
+            f"{(1 - (power * (1000/throughput))/(base_power * (1000/tokens_per_second_base)))*100:.0f}%",
+            f"{(1 - energy_joules/(base_power * (total_tokens/tokens_per_second_base)))*100:.0f}%"
+        ]
+    
+    return pd.DataFrame(data)
+
+def load_benchmark_results() -> pd.DataFrame:
+    """Load pre-computed benchmark results"""
+    data = {
+        "Experiment": [
+            "Quantum (Simulator)",
+            "Quantum (IBM Hardware)",
+            "Compression (MLP)",
+            "Compression (CNN)",
+            "Energy Reduction",
+            "SGD Optimization",
+            "Evolution Optimization"
+        ],
+        "Metric": [
+            "Success Rate",
+            "Success Rate",
+            "Compression Ratio",
+            "Compression Ratio",
+            "Power Reduction",
+            "Convergence Time",
+            "Final Loss"
+        ],
+        "Target": [
+            "≥90%",
+            "≥55%",
+            "≥4.0×",
+            "≥4.0×",
+            "≥40%",
+            "Baseline",
+            "Better Loss"
+        ],
+        "Achieved": [
+            "95.3%",
+            "59.9%",
+            "3.91×",
+            "3.50×",
+            "57.1%",
+            "0.232s",
+            "7.67e-11"
+        ],
+        "Status": [
+            "✅ PASS",
+            "✅ PASS",
+            "⚠️ 98% of target",
+            "⚠️ 87% of target",
+            "✅ EXCEEDS",
+            "✅ BASELINE",
+            "✅ 128× better"
+        ]
+    }
+    
+    return pd.DataFrame(data)
+
+def create_app():
+    """Create the main Gradio application"""
+    
+    with gr.Blocks(
+        title="Phase 4: Quantum-ML Benchmark Demo",
+        theme=gr.themes.Soft(primary_hue="purple"),
+        css="""
+        .gradio-container {
+            max-width: 1200px;
+            margin: auto;
+        }
+        """
+    ) as app:
+        
+        # Header
+        gr.Markdown("""
+        # ⚛️ Phase 4: Quantum Computing + ML Compression Demo
+        
+        Interactive demonstration of quantum algorithms, model compression, and energy efficiency benchmarks.
+        
+        [![Models](https://img.shields.io/badge/🤗%20Models-phase4--quantum--compression-blue)](https://huggingface.co/jmurray10/phase4-quantum-compression)
+        [![Dataset](https://img.shields.io/badge/🤗%20Dataset-phase4--quantum--benchmarks-green)](https://huggingface.co/datasets/jmurray10/phase4-quantum-benchmarks)
+        [![GitHub](https://img.shields.io/badge/GitHub-Source%20Code-black)](https://github.com/jmurray10/phase4-experiment)
+        """)
+        
+        with gr.Tabs():
+            
+            # Tab 1: Quantum Computing
+            with gr.TabItem("🔬 Quantum Computing"):
+                gr.Markdown("## Grover's Algorithm Simulator")
+                gr.Markdown("Demonstrate quantum search with quadratic speedup")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        n_qubits = gr.Slider(
+                            2, 5, value=3, step=1,
+                            label="Number of Qubits (n)"
+                        )
+                        target_pattern = gr.Textbox(
+                            value="101",
+                            label="Target Pattern (binary)",
+                            placeholder="e.g., 101 for 3 qubits"
+                        )
+                        iterations = gr.Slider(
+                            1, 10, value=2, step=1,
+                            label="Grover Iterations (k)"
+                        )
+                        
+                        run_quantum = gr.Button("Run Quantum Simulation", variant="primary")
+                        
+                        quantum_results = gr.JSON(label="Simulation Results")
+                    
+                    with gr.Column(scale=2):
+                        quantum_plot = gr.Plot(label="Success Probability vs Iterations")
+                        
+                        gr.Markdown("""
+                        **Theory**: Grover's algorithm finds a marked item in O(√N) time.
+                        
+                        **Optimal iterations**: k* = ⌊π/4 √(2^n)⌋
+                        """)
+                
+                def run_quantum_sim(n, pattern, k):
+                    result = simulate_grover(n, pattern, k)
+                    plot = create_grover_plot(n, pattern)
+                    return result, plot
+                
+                run_quantum.click(
+                    run_quantum_sim,
+                    inputs=[n_qubits, target_pattern, iterations],
+                    outputs=[quantum_results, quantum_plot]
+                )
+            
+            # Tab 2: Model Compression
+            with gr.TabItem("📦 Model Compression"):
+                gr.Markdown("## PyTorch Model Compression Demo")
+                gr.Markdown("Compress models with INT8 quantization and measure real file sizes")
+                
+                with gr.Row():
+                    with gr.Column():
+                        model_type = gr.Dropdown(
+                            ["MLP", "CNN", "Custom"],
+                            value="MLP",
+                            label="Model Type"
+                        )
+                        compression_method = gr.Dropdown(
+                            ["Dynamic INT8", "Static INT8"],
+                            value="Dynamic INT8",
+                            label="Compression Method"
+                        )
+                        
+                        compress_btn = gr.Button("Compress Model", variant="primary")
+                        
+                    with gr.Column():
+                        compression_output = gr.JSON(label="Compression Results")
+                
+                gr.Markdown("""
+                ### Real Results from Phase 4:
+                - **MLP**: 943KB → 241KB (3.91× compression)
+                - **CNN**: 1,690KB → 483KB (3.50× compression)
+                - **Quality Preserved**: >99.8%
+                
+                *Note: Compression ratio below theoretical 4× due to PyTorch metadata overhead*
+                """)
+                
+                compress_btn.click(
+                    compress_model_demo,
+                    inputs=[model_type, compression_method],
+                    outputs=compression_output
+                )
+            
+            # Tab 3: Energy Efficiency
+            with gr.TabItem("⚡ Energy Calculator"):
+                gr.Markdown("## Energy Efficiency Calculator")
+                gr.Markdown("Calculate energy savings from model compression")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        model_size = gr.Number(
+                            value=1.0,
+                            label="Model Size (MB)"
+                        )
+                        batch_size = gr.Slider(
+                            1, 128, value=32,
+                            label="Batch Size"
+                        )
+                        iterations = gr.Number(
+                            value=1000,
+                            label="Number of Iterations"
+                        )
+                        use_compression = gr.Checkbox(
+                            value=True,
+                            label="Use INT8 Compression"
+                        )
+                        
+                        calculate_btn = gr.Button("Calculate Energy", variant="primary")
+                    
+                    with gr.Column(scale=2):
+                        energy_output = gr.DataFrame(
+                            label="Energy Consumption Analysis",
+                            headers=["Metric", "Baseline (FP32)", "Compressed (INT8)", "Savings"]
+                        )
+                
+                gr.Markdown("""
+                ### Measured Energy Savings:
+                - **Power Reduction**: 125W → 68.75W (45%)
+                - **Energy per Million Tokens**: 1,894 kJ → 813 kJ (57% reduction)
+                - **Carbon Footprint**: Reduced by >50%
+                """)
+                
+                calculate_btn.click(
+                    calculate_energy_savings,
+                    inputs=[model_size, batch_size, iterations, use_compression],
+                    outputs=energy_output
+                )
+            
+            # Tab 4: Benchmark Results
+            with gr.TabItem("📊 Results Dashboard"):
+                gr.Markdown("## Complete Phase 4 Benchmark Results")
+                
+                results_df = gr.DataFrame(
+                    value=load_benchmark_results(),
+                    label="All Benchmark Results",
+                    interactive=False
+                )
+                
+                gr.Markdown("""
+                ### Key Achievements:
+                - ✅ **Quantum Success**: 95.3% (simulator), 59.9% (IBM hardware)
+                - ✅ **Compression**: 3.91× for MLP (98% of target)
+                - ✅ **Energy Savings**: 57.1% reduction achieved
+                - ✅ **ML Optimization**: SGD 3.84× more efficient
+                
+                ### Summary Statistics:
+                - **Tests Run**: 5 major categories
+                - **Pass Rate**: 100% acceptance criteria
+                - **IBM Quantum**: Real hardware execution verified
+                - **No Hardcoding**: All results computed at runtime
+                """)
+            
+            # Tab 5: About
+            with gr.TabItem("ℹ️ About"):
+                gr.Markdown("""
+                ## About Phase 4 Experiment
+                
+                This project demonstrates the successful integration of:
+                - 🔬 **Quantum Computing**: Grover's algorithm on IBM hardware
+                - 📦 **Model Compression**: Real PyTorch INT8 quantization
+                - ⚡ **Energy Efficiency**: Measured power savings
+                - 🎯 **ML Optimization**: SGD vs Evolution comparison
+                
+                ### Research Paper:
+                
+                📄 **[Mathematical Framework for Bio-Transcendent Intelligence](./papers/BioTranscendent_Intelligence_Phase4.pdf)**
+                
+                This paper presents the theoretical framework behind Phase 4, including:
+                - Mathematical proof that biological limitations are not fundamental to intelligence
+                - Application validation with real quantum hardware (59.9% success rate)
+                - Near-theoretical 4× model compression achievements
+                - Energy efficiency measurements and optimization trade-offs
+                
+                ### Technical Highlights:
+                - Executed on IBM Brisbane (127-qubit quantum computer)
+                - Achieved 3.91× compression with <0.2% quality loss
+                - Reduced energy consumption by 57%
+                - 100% test coverage with no hardcoded results
+                
+                ### Resources:
+                - 📄 [Research Paper: Mathematical Framework for Bio-Transcendent Intelligence](./papers/BioTranscendent_Intelligence_Phase4.pdf)
+                - 📦 [Download Models](https://huggingface.co/jmurray10/phase4-quantum-compression)
+                - 📊 [Access Dataset](https://huggingface.co/datasets/jmurray10/phase4-quantum-benchmarks)
+                - 📝 [Technical Documentation](https://github.com/jmurray10/phase4-experiment)
+                - 🔬 [Research Paper](#) (Coming Soon)
+                
+                ### Citation:
+                ```bibtex
+                @software{phase4_2025,
+                  title={Phase 4: Quantum-ML Compression Benchmarks},
+                  author={Phase 4 Research Team},
+                  year={2025},
+                  publisher={Hugging Face}
+                }
+                ```
+                
+                ---
+                *Made with ❤️ by the Phase 4 Research Team*
+                """)
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        **Phase 4: Making Quantum & AI Efficiency Real** | 
+        [Models](https://huggingface.co/jmurray10/phase4-quantum-compression) | 
+        [Dataset](https://huggingface.co/datasets/jmurray10/phase4-quantum-benchmarks) | 
+        [GitHub](https://github.com/jmurray10/phase4-experiment)
+        """)
+    
+    return app
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch(
+        share=False,
+        show_error=True,
+        server_name="0.0.0.0",
+        server_port=7860
     )