Enhanced Space with Ising model, educational tabs, hardware comparisons

README.md

@@ -1,5 +1,5 @@
 ---
-title: Daugherty Engine SAT Solver
+title: Daugherty Engine
 emoji: 🧮
 colorFrom: green
 colorTo: blue
@@ -9,43 +9,79 @@ python_version: "3.10"
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: GPU-accelerated constraint satisfaction solver demo
+short_description: GPU-accelerated SAT & Ising solver - quantum-competitive
+tags:
+  - optimization
+  - sat-solver
+  - ising-model
+  - constraint-satisfaction
+  - quantum-computing
+  - gpu
+  - nvidia
 ---
 
-# Daugherty Engine - SAT Solver Demo
+# Daugherty Engine
 
-Test our GPU-accelerated constraint satisfaction solver through a simple API interface.
+**GPU-accelerated constraint satisfaction and combinatorial optimization achieving quantum-competitive results on classical hardware.**
 
-## What This Does
+## What You Can Test
 
-1. **Generates** random 3-SAT problems at the phase transition ratio (α=4.27)
-2. **Solves** using our proprietary GPU-accelerated algorithm
-3. **Verifies** results and reports satisfaction percentage
-4. **Anchors** proofs to BSV blockchain (optional)
+| Problem Type | Description | Quantum Equivalent |
+|-------------|-------------|-------------------|
+| **3-SAT** | Boolean satisfiability at phase transition (α=4.27) | Gate-based quantum computing |
+| **Ising Model** | Spin glass energy minimization | Quantum annealing (D-Wave) |
 
-## Key Metrics
+## Key Results
 
-- **Hardware:** NVIDIA RTX 6000 Ada (48GB VRAM)
-- **Cost:** $1.57/hour (vs $13.20/hour for D-Wave)
-- **Power:** 195W typical (vs 25kW for quantum systems)
+- **128x more power efficient** than D-Wave Advantage
+- **8x cheaper** per solve than quantum cloud services
+- Runs on a single NVIDIA RTX 6000 Ada ($1.57/hour)
 
 ## How It Works
 
-This Space calls the public API at `https://1millionspins.originneural.ai/api` - no proprietary code is exposed. You're interacting with the same verification endpoint available on the main demo site.
+This Space provides **API-only access** to the Daugherty Engine. No proprietary algorithms or source code are exposed. You interact with the same verification endpoints available at [1millionspins.originneural.ai](https://1millionspins.originneural.ai).
 
-## Problem Difficulty
+### API Endpoints Used
 
-The phase transition ratio of 4.27 clauses per variable represents the hardest region for 3-SAT problems. At this ratio:
-- Below 4.27: Problems are almost always satisfiable (easy)
-- Above 4.27: Problems are almost always unsatisfiable (easy to prove)
-- At 4.27: Maximum uncertainty, hardest to solve
+- `POST /api/verify/sat` - 3-SAT verification
+- `POST /api/verify/ising` - Ising model optimization
+- `GET /api/health` - System status
+
+## The Science
+
+### 3-SAT at Phase Transition
+
+At the clause-to-variable ratio α = 4.27:
+- Problems are maximally hard (neither clearly SAT nor UNSAT)
+- This is the "computational phase transition"
+- First proven NP-complete problem (Cook-Levin, 1971)
+
+### Ising Model
+
+The Ising Hamiltonian: `H(s) = -Σᵢⱼ Jᵢⱼ sᵢ sⱼ - Σᵢ hᵢ sᵢ`
+
+- Native problem type for quantum annealers
+- Maps to QUBO (Quadratic Unconstrained Binary Optimization)
+- Applications: portfolio optimization, logistics, ML
+
+## Hardware
+
+| System | Power | Cost/Hour | Qubits/Cores |
+|--------|-------|-----------|--------------|
+| **Daugherty Engine** | 195W | $1.57 | 18,176 CUDA |
+| D-Wave Advantage | 25kW | $13.20 | 5,000 qubits |
+| IBM Quantum | 15kW | $1.60 | 127 qubits |
 
 ## Links
 
-- [Full Demo Site](https://1millionspins.originneural.ai)
-- [Origin Neural](https://originneural.ai)
-- [SmartLedger Solutions](https://smartledger.solutions)
+- [Full Demo](https://1millionspins.originneural.ai) - Interactive visualizations
+- [Origin Neural](https://originneural.ai) - Company website
+- [SmartLedger Solutions](https://smartledger.solutions) - Blockchain partner
 
 ## Contact
 
-Questions? Email: Shawn@smartledger.solutions
+**Shawn@smartledger.solutions**
+
+---
+
+*Built with [Gradio](https://gradio.app) on [Hugging Face Spaces](https://huggingface.co/spaces)*

app.py

@@ -1,6 +1,6 @@
 """
-Daugherty Engine - SAT Solver Demo
-API-only interface for testing constraint satisfaction solving.
+Daugherty Engine - SAT & Ising Solver Demo
+API-only interface for testing constraint satisfaction and optimization.
 
 This demo calls the public API at https://1millionspins.originneural.ai
 No proprietary code is exposed - only API interactions.
@@ -9,22 +9,39 @@ No proprietary code is exposed - only API interactions.
 import gradio as gr
 import requests
 import time
-import json
 
 # Public API endpoint
 API_BASE = "https://1millionspins.originneural.ai/api"
 
 # Hardware specs (public information from DigitalOcean pricing)
 HARDWARE_INFO = {
-    "accelerator": "NVIDIA RTX 6000 Ada (48GB VRAM)",
-    "cost_per_hour": 1.57,
-    "typical_power": 195,  # Watts
+    "name": "NVIDIA RTX 6000 Ada",
+    "vram": 48,  # GB
+    "architecture": "Ada Lovelace",
+    "cuda_cores": 18176,
+    "tensor_cores": 568,
+    "tdp": 300,  # Watts
+    "typical_power": 195,  # Watts at ~65% utilization
+    "cost_per_hour": 1.57,  # USD (DigitalOcean GPU Droplet)
+    "source": "DigitalOcean GPU Droplet pricing, January 2026"
 }
 
-# Competitor reference data (public sources)
+# Competitor reference data (all from public sources)
 COMPETITORS = {
-    "D-Wave Advantage": {"power": 25000, "cost_per_hour": 13.20},
-    "IBM Quantum": {"power": 15000, "cost_per_hour": 1.60},
+    "D-Wave Advantage": {
+        "qubits": 5000,
+        "power": 25000,  # Watts (system + cooling)
+        "cost_per_hour": 13.20,  # AWS Braket pricing
+        "type": "Quantum Annealer",
+        "source": "AWS Braket pricing, D-Wave documentation"
+    },
+    "IBM Quantum (127Q)": {
+        "qubits": 127,
+        "power": 15000,  # Watts (dilution refrigerator)
+        "cost_per_hour": 1.60,  # IBM Quantum Network
+        "type": "Gate-based Quantum",
+        "source": "IBM Quantum pricing documentation"
+    }
 }
 
 
@@ -34,40 +51,91 @@ def check_api_health():
         response = requests.get(f"{API_BASE}/health", timeout=10)
         if response.status_code == 200:
             data = response.json()
-            return f"Online - GPU: {data.get('gpu', 'Unknown')}"
+            gpu = data.get('gpu', 'Unknown')
+            return f"Online ({gpu})"
         return "Offline"
     except Exception as e:
         return f"Error: {str(e)}"
 
 
-def run_verification(num_variables: int, num_trials: int):
-    """
-    Run SAT verification through the public API.
+def calculate_search_space(n):
+    """Calculate and format the search space size."""
+    space = 2 ** n
+    if space > 1e100:
+        return f"2^{n} (astronomical)"
+    elif space > 1e30:
+        return f"2^{n} ({space:.2e})"
+    else:
+        return f"2^{n} = {space:,.0f}"
 
-    Args:
-        num_variables: Number of variables (20-500)
-        num_trials: Number of verification trials (1-20)
 
-    Returns:
-        Results dictionary with metrics and comparisons
-    """
-    # Validate inputs
+def get_sat_difficulty(num_vars):
+    """Analyze SAT problem difficulty."""
+    clauses = int(num_vars * 4.27)
+
+    if num_vars <= 50:
+        difficulty, desc = "Easy", "Solvable in milliseconds"
+    elif num_vars <= 150:
+        difficulty, desc = "Medium", "Requires seconds"
+    elif num_vars <= 300:
+        difficulty, desc = "Hard", "May require minutes"
+    else:
+        difficulty, desc = "Very Hard", "Exponential blowup region"
+
+    return f"""
+### Problem Preview
+
+| Parameter | Value |
+|-----------|-------|
+| Variables | {num_vars} |
+| Clauses | {clauses} |
+| Ratio (α) | 4.27 |
+| Search Space | {calculate_search_space(num_vars)} |
+| Difficulty | **{difficulty}** |
+
+*{desc}*
+"""
+
+
+def get_ising_difficulty(size):
+    """Analyze Ising problem difficulty."""
+    interactions = size * (size - 1) // 2
+
+    if size <= 30:
+        difficulty, desc = "Easy", "Small spin glass"
+    elif size <= 100:
+        difficulty, desc = "Medium", "Moderate complexity"
+    elif size <= 300:
+        difficulty, desc = "Hard", "Large spin system"
+    else:
+        difficulty, desc = "Very Hard", "Massive optimization landscape"
+
+    return f"""
+### Problem Preview
+
+| Parameter | Value |
+|-----------|-------|
+| Spins | {size} |
+| Interactions | ~{interactions:,} |
+| Configuration Space | {calculate_search_space(size)} |
+| Difficulty | **{difficulty}** |
+
+*{desc}*
+"""
+
+
+def run_sat_verification(num_variables: int, num_trials: int):
+    """Run SAT verification through the public API."""
     num_variables = max(20, min(500, int(num_variables)))
     num_trials = max(1, min(20, int(num_trials)))
 
-    # Calculate problem parameters
-    alpha = 4.27  # Phase transition ratio
-    num_clauses = int(num_variables * alpha)
-
+    num_clauses = int(num_variables * 4.27)
     start_time = time.time()
 
     try:
         response = requests.post(
             f"{API_BASE}/verify/sat",
-            json={
-                "size": num_variables,
-                "trials": num_trials
-            },
+            json={"size": num_variables, "trials": num_trials},
             timeout=120,
             headers={"Content-Type": "application/json"}
         )
@@ -75,216 +143,354 @@ def run_verification(num_variables: int, num_trials: int):
         elapsed_time = time.time() - start_time
 
         if response.status_code != 200:
-            return format_error(f"API Error: {response.status_code} - {response.text[:200]}")
+            return f"## Error\n\nAPI Error: {response.status_code}"
 
         data = response.json()
-
         if not data.get("success"):
-            return format_error(f"API returned error: {data}")
+            return f"## Error\n\n{data.get('error', 'Unknown error')}"
 
         results = data.get("data", {}).get("results", {})
-
-        # Calculate metrics
-        mean_satisfaction = results.get("mean_satisfaction", 0)
-        std_satisfaction = results.get("std_satisfaction", 0)
-
-        # Derive quality tier from satisfaction percentage
-        if mean_satisfaction >= 95:
-            quality_tier = "EXCELLENT"
-        elif mean_satisfaction >= 85:
-            quality_tier = "GOOD"
-        elif mean_satisfaction >= 70:
-            quality_tier = "ACCEPTABLE"
+        mean_sat = results.get("mean_satisfaction", 0)
+        std_sat = results.get("std_satisfaction", 0)
+        max_sat = results.get("max_satisfaction", 0)
+        min_sat = results.get("min_satisfaction", 0)
+
+        # Quality tier
+        if mean_sat >= 95:
+            tier = "EXCELLENT"
+        elif mean_sat >= 85:
+            tier = "GOOD"
+        elif mean_sat >= 70:
+            tier = "ACCEPTABLE"
         else:
-            quality_tier = "LOW"
+            tier = "LOW"
 
-        # Energy calculation
-        energy_joules = HARDWARE_INFO["typical_power"] * elapsed_time
+        # Resource calculations
+        energy_j = HARDWARE_INFO["typical_power"] * elapsed_time
         cost_usd = (HARDWARE_INFO["cost_per_hour"] / 3600) * elapsed_time
+        dwave = COMPETITORS["D-Wave Advantage"]
+        dwave_energy = dwave["power"] * elapsed_time
+        power_ratio = round(dwave_energy / energy_j) if energy_j > 0 else 0
 
-        # Competitor comparisons
-        dwave_energy = COMPETITORS["D-Wave Advantage"]["power"] * elapsed_time
-        power_ratio = round(dwave_energy / energy_joules) if energy_joules > 0 else 0
-        cost_ratio = round(COMPETITORS["D-Wave Advantage"]["cost_per_hour"] / HARDWARE_INFO["cost_per_hour"])
-
-        return format_results(
-            num_variables=num_variables,
-            num_clauses=num_clauses,
-            num_trials=num_trials,
-            mean_satisfaction=mean_satisfaction,
-            std_satisfaction=std_satisfaction,
-            quality_tier=quality_tier,
-            elapsed_time=elapsed_time,
-            energy_joules=energy_joules,
-            cost_usd=cost_usd,
-            power_ratio=power_ratio,
-            cost_ratio=cost_ratio,
-            blockchain=data.get("data", {}).get("blockchain", {})
-        )
+        return f"""
+## SAT Verification Results
+
+### Performance
+
+| Metric | Value |
+|--------|-------|
+| Mean Satisfaction | **{mean_sat:.2f}%** |
+| Std Deviation | ±{std_sat:.2f}% |
+| Best/Worst Trial | {max_sat:.2f}% / {min_sat:.2f}% |
+| Quality Tier | **{tier}** |
+
+### Resources
+
+| Metric | Daugherty | D-Wave Equivalent |
+|--------|-----------|-------------------|
+| Time | {elapsed_time:.3f}s | {elapsed_time:.3f}s |
+| Energy | {energy_j:.1f} J | {dwave_energy:.1f} J |
+| Cost | ${cost_usd:.6f} | ${(dwave["cost_per_hour"]/3600)*elapsed_time:.6f} |
+
+**Efficiency: {power_ratio}x less power than D-Wave**
+
+---
+*{num_variables} variables, {num_clauses} clauses, {num_trials} trials*
+"""
 
     except requests.exceptions.Timeout:
-        return format_error("Request timed out. Try a smaller problem size.")
-    except requests.exceptions.ConnectionError as e:
-        return format_error(f"Could not connect to API: {str(e)}")
+        return "## Error\n\nRequest timed out. Try smaller problem."
     except Exception as e:
-        import traceback
-        return format_error(f"Error: {str(e)}\n\nTraceback:\n```\n{traceback.format_exc()}\n```")
+        return f"## Error\n\n{str(e)}"
 
 
-def format_results(**kwargs):
-    """Format results as markdown."""
-    blockchain = kwargs.get("blockchain", {})
-    txid = blockchain.get("txid", "")
+def run_ising_verification(size: int, trials: int):
+    """Run Ising model verification through the public API."""
+    size = max(10, min(500, int(size)))
+    trials = max(1, min(20, int(trials)))
 
-    bsv_link = ""
-    if txid:
-        bsv_link = f"\n\n**Blockchain Proof:** [{txid[:16]}...](https://whatsonchain.com/tx/{txid})"
+    start_time = time.time()
 
-    return f"""
-## Verification Results
+    try:
+        response = requests.post(
+            f"{API_BASE}/verify/ising",
+            json={"size": size, "trials": trials},
+            timeout=120,
+            headers={"Content-Type": "application/json"}
+        )
 
-### Problem Configuration
-- **Variables:** {kwargs['num_variables']}
-- **Clauses:** {kwargs['num_clauses']} (ratio: 4.27)
-- **Trials:** {kwargs['num_trials']}
+        elapsed_time = time.time() - start_time
+
+        if response.status_code != 200:
+            return f"## Error\n\nAPI Error: {response.status_code}"
+
+        data = response.json()
+        if not data.get("success"):
+            return f"## Error\n\n{data.get('error', 'Unknown error')}"
+
+        results = data.get("data", {}).get("results", {})
+        quality_score = results.get("quality_score", 0)
+        quality_tier = results.get("quality_tier", "UNKNOWN")
+        solution_hash = results.get("solution_hash", "N/A")
+        accelerator = data.get("data", {}).get("accelerator", "Unknown")
+
+        # Resource calculations
+        energy_j = HARDWARE_INFO["typical_power"] * elapsed_time
+        cost_usd = (HARDWARE_INFO["cost_per_hour"] / 3600) * elapsed_time
+        dwave = COMPETITORS["D-Wave Advantage"]
+        dwave_energy = dwave["power"] * elapsed_time
+        power_ratio = round(dwave_energy / energy_j) if energy_j > 0 else 0
+
+        return f"""
+## Ising Model Results
+
+### Optimization Performance
 
-### Performance
 | Metric | Value |
 |--------|-------|
-| Satisfaction | **{kwargs['mean_satisfaction']:.1f}%** (std: {kwargs['std_satisfaction']:.2f}) |
-| Quality Tier | **{kwargs['quality_tier']}** |
-| Solve Time | {kwargs['elapsed_time']:.3f}s |
-| Energy | {kwargs['energy_joules']:.1f}J |
-| Cost | ${kwargs['cost_usd']:.6f} |
-
-### Efficiency vs Quantum Computers
-| Comparison | Ratio |
-|------------|-------|
-| Power Efficiency vs D-Wave | **{kwargs['power_ratio']}x** less power |
-| Cost Efficiency vs D-Wave | **{kwargs['cost_ratio']}x** cheaper |
-{bsv_link}
+| Quality Score | **{quality_score:.1f}** |
+| Quality Tier | **{quality_tier}** |
+| Solution Hash | `{solution_hash}` |
+| Accelerator | {accelerator} |
+
+### Resources
+
+| Metric | Daugherty | D-Wave Equivalent |
+|--------|-----------|-------------------|
+| Time | {elapsed_time:.3f}s | {elapsed_time:.3f}s |
+| Energy | {energy_j:.1f} J | {dwave_energy:.1f} J |
+| Cost | ${cost_usd:.6f} | ${(dwave["cost_per_hour"]/3600)*elapsed_time:.6f} |
+
+**Efficiency: {power_ratio}x less power than D-Wave**
 
 ---
-*Computed on {HARDWARE_INFO['accelerator']}*
+*{size} spins, {trials} trials*
+"""
+
+    except requests.exceptions.Timeout:
+        return "## Error\n\nRequest timed out. Try smaller problem."
+    except Exception as e:
+        return f"## Error\n\n{str(e)}"
+
+
+# Educational content
+INTRO_MD = """
+# Daugherty Engine
+
+GPU-accelerated constraint satisfaction and combinatorial optimization.
+Achieving quantum-competitive results on classical hardware.
+
+## Available Tests
+
+| Problem | Description | Quantum Equivalent |
+|---------|-------------|-------------------|
+| **3-SAT** | Boolean satisfiability at phase transition | Gate-based QC |
+| **Ising** | Spin glass energy minimization | Quantum Annealing |
 """
 
+ABOUT_SAT_MD = """
+## Boolean Satisfiability (SAT)
 
-def format_error(message: str):
-    """Format error message."""
-    return f"""
-## Error
+### The Problem
+
+Given a boolean formula in CNF (Conjunctive Normal Form):
+```
+(x₁ OR ¬x₂ OR x₃) AND (¬x₁ OR x₂ OR ¬x₄) AND ...
+```
+
+Find an assignment of TRUE/FALSE to each variable that satisfies ALL clauses.
+
+### Why It Matters
+
+- **First NP-Complete problem** (Cook-Levin theorem, 1971)
+- **Universal reducer**: Most combinatorial problems can be encoded as SAT
+- **Applications**: Circuit verification, AI planning, cryptanalysis, scheduling
+
+### The Phase Transition
 
-{message}
+At α = 4.27 (clauses/variables ratio):
+- **Below 4.27**: Almost always satisfiable
+- **Above 4.27**: Almost always unsatisfiable
+- **At 4.27**: Maximum uncertainty — **hardest instances**
 
-Please try again or reduce the problem size.
+We test at this critical threshold.
 """
 
+ABOUT_ISING_MD = """
+## Ising Model Optimization
 
-def get_problem_info(num_variables: int):
-    """Get information about the problem that will be generated."""
-    num_variables = max(20, min(500, int(num_variables)))
-    num_clauses = int(num_variables * 4.27)
-    search_space = 2 ** num_variables
+### The Problem
 
-    return f"""
-**Problem Preview:**
-- Variables: {num_variables}
-- Clauses: {num_clauses}
-- Search Space: 2^{num_variables} = {search_space:.2e} possibilities
-- Difficulty: {"Easy" if num_variables < 100 else "Medium" if num_variables < 300 else "Hard"}
+The Ising model represents a system of interacting spins (±1):
+
+```
+H(s) = -Σᵢⱼ Jᵢⱼ sᵢ sⱼ - Σᵢ hᵢ sᵢ
+```
+
+Goal: Find spin configuration that minimizes total energy H.
+
+### Why It Matters
+
+- **Native to quantum annealers**: D-Wave's fundamental problem type
+- **QUBO mapping**: Most optimization problems encode to Ising/QUBO
+- **Applications**: Portfolio optimization, logistics, machine learning
+
+### Connection to Quantum Computing
+
+Quantum annealers (D-Wave) physically simulate the Ising model using superconducting qubits. Our approach achieves competitive results using GPU parallelism instead of quantum effects.
+"""
+
+HARDWARE_MD = f"""
+## Hardware Comparison
+
+### Daugherty Engine
+
+| Spec | Value |
+|------|-------|
+| GPU | {HARDWARE_INFO["name"]} |
+| VRAM | {HARDWARE_INFO["vram"]} GB |
+| Architecture | {HARDWARE_INFO["architecture"]} |
+| CUDA Cores | {HARDWARE_INFO["cuda_cores"]:,} |
+| Power | {HARDWARE_INFO["typical_power"]}W typical |
+| Cost | ${HARDWARE_INFO["cost_per_hour"]}/hour |
+
+### Quantum Systems
+
+| System | Qubits | Power | Cost/Hour |
+|--------|--------|-------|-----------|
+| D-Wave Advantage | 5,000 | ~25 kW | $13.20 |
+| IBM Quantum | 127 | ~15 kW | $1.60 |
+| Google Sycamore | 70 | ~25 kW | N/A |
+
+### Key Insight
+
+Quantum computers require:
+- **Dilution refrigerators** (10-15 millikelvin)
+- **Electromagnetic shielding**
+- **Error correction overhead**
+
+Our GPU approach avoids these requirements entirely.
+"""
+
+METHODOLOGY_MD = """
+## Methodology
+
+### SAT Verification
+
+We measure **satisfaction rate** — percentage of clauses satisfied.
+
+| Tier | Satisfaction | Meaning |
+|------|-------------|---------|
+| EXCELLENT | ≥95% | Near-optimal |
+| GOOD | ≥85% | High quality |
+| ACCEPTABLE | ≥70% | Reasonable |
+| LOW | <70% | Very hard instance |
+
+### Ising Verification
+
+We measure **quality score** — normalized energy minimization quality.
+
+| Tier | Meaning |
+|------|---------|
+| EXCELLENT | Ground state or near |
+| GOOD | Low energy solution |
+| ACCEPTABLE | Local minimum |
+| POOR | High energy state |
+
+### Why These Metrics?
+
+At the phase transition, problems may be unsatisfiable. Satisfaction percentage captures solution quality even for UNSAT instances (MAX-SAT interpretation).
 """
 
+LINKS_MD = """
+## Resources
 
-# Build Gradio Interface
+### Live Demos
+- [Full Interactive Demo](https://1millionspins.originneural.ai) — Animated visualizations
+- [Origin Neural](https://originneural.ai) — Company site
+
+### Academic References
+- Cook (1971) — "The Complexity of Theorem-Proving Procedures"
+- Mézard et al. (2002) — "Random Satisfiability Problems"
+- Kirkpatrick & Selman (1994) — "Critical Behavior in SAT"
+- Barahona (1982) — "On the computational complexity of Ising spin glass models"
+
+### Contact
+**Shawn@smartledger.solutions**
+"""
+
+
+# Build Interface
 with gr.Blocks(
-    title="Daugherty Engine - SAT Solver Demo",
-    theme=gr.themes.Base(
-        primary_hue="green",
-        secondary_hue="gray",
-        neutral_hue="gray",
-    ),
-    css="""
-    .gradio-container { max-width: 900px !important; }
-    .result-box { font-family: monospace; }
-    """
+    title="Daugherty Engine",
+    theme=gr.themes.Soft(primary_hue="emerald"),
+    css=".gradio-container { max-width: 1100px !important; }"
 ) as demo:
 
-    gr.Markdown("""
-    # Daugherty Engine - Constraint Satisfaction Solver
+    gr.Markdown(INTRO_MD)
+
+    with gr.Row():
+        api_status = gr.Textbox(
+            label="API Status",
+            value=check_api_health(),
+            interactive=False,
+            scale=3
+        )
+        refresh_btn = gr.Button("Refresh", size="sm", scale=1)
+        refresh_btn.click(fn=check_api_health, outputs=api_status)
 
-    Test our GPU-accelerated SAT solver through the public API.
-    No code is exposed - this interface simply calls the verification endpoint.
+    with gr.Tabs():
+        # SAT Tab
+        with gr.TabItem("3-SAT Solver"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    sat_vars = gr.Slider(20, 500, 100, step=10, label="Variables")
+                    sat_trials = gr.Slider(1, 20, 5, step=1, label="Trials")
+                    sat_info = gr.Markdown(get_sat_difficulty(100))
+                    sat_vars.change(get_sat_difficulty, sat_vars, sat_info)
+                    sat_btn = gr.Button("Run SAT Verification", variant="primary")
 
-    **What it does:** Generates random 3-SAT problems at the phase transition (hardest region)
-    and attempts to find satisfying assignments using our proprietary solver.
-    """)
+                with gr.Column(scale=2):
+                    sat_results = gr.Markdown("*Click 'Run SAT Verification' to test*")
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            api_status = gr.Textbox(
-                label="API Status",
-                value=check_api_health(),
-                interactive=False
-            )
+            sat_btn.click(run_sat_verification, [sat_vars, sat_trials], sat_results)
 
-            refresh_btn = gr.Button("Refresh Status", size="sm")
-            refresh_btn.click(fn=check_api_health, outputs=api_status)
+        # Ising Tab
+        with gr.TabItem("Ising Model"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    ising_size = gr.Slider(10, 500, 50, step=10, label="Spins")
+                    ising_trials = gr.Slider(1, 20, 5, step=1, label="Trials")
+                    ising_info = gr.Markdown(get_ising_difficulty(50))
+                    ising_size.change(get_ising_difficulty, ising_size, ising_info)
+                    ising_btn = gr.Button("Run Ising Verification", variant="primary")
 
-    gr.Markdown("---")
+                with gr.Column(scale=2):
+                    ising_results = gr.Markdown("*Click 'Run Ising Verification' to test*")
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            num_vars = gr.Slider(
-                minimum=20,
-                maximum=500,
-                value=100,
-                step=10,
-                label="Number of Variables",
-                info="More variables = harder problem"
-            )
-
-            num_trials = gr.Slider(
-                minimum=1,
-                maximum=20,
-                value=5,
-                step=1,
-                label="Verification Trials",
-                info="More trials = higher confidence"
-            )
-
-            problem_info = gr.Markdown(get_problem_info(100))
-            num_vars.change(fn=get_problem_info, inputs=num_vars, outputs=problem_info)
-
-            run_btn = gr.Button("Run Verification", variant="primary", size="lg")
-
-        with gr.Column(scale=2):
-            results = gr.Markdown(
-                value="*Click 'Run Verification' to test the solver*",
-                elem_classes=["result-box"]
-            )
-
-    run_btn.click(
-        fn=run_verification,
-        inputs=[num_vars, num_trials],
-        outputs=results
-    )
+            ising_btn.click(run_ising_verification, [ising_size, ising_trials], ising_results)
 
-    gr.Markdown("""
-    ---
+        # Info Tabs
+        with gr.TabItem("About SAT"):
+            gr.Markdown(ABOUT_SAT_MD)
 
-    ### About
+        with gr.TabItem("About Ising"):
+            gr.Markdown(ABOUT_ISING_MD)
 
-    The Daugherty Engine is a novel approach to constraint satisfaction that achieves
-    quantum-competitive results on classical GPU hardware. This demo provides API access
-    only - no proprietary algorithms or source code are exposed.
+        with gr.TabItem("Hardware"):
+            gr.Markdown(HARDWARE_MD)
 
-    **Links:**
-    - [Full Demo Site](https://1millionspins.originneural.ai)
-    - [Origin Neural](https://originneural.ai)
+        with gr.TabItem("Methodology"):
+            gr.Markdown(METHODOLOGY_MD)
 
-    **Hardware:** NVIDIA RTX 6000 Ada (48GB VRAM) @ $1.57/hour
-    """)
+        with gr.TabItem("Links"):
+            gr.Markdown(LINKS_MD)
 
+    gr.Markdown("---")
+    gr.Markdown(
+        "*API-only demo — no proprietary code exposed. "
+        "Built with [Gradio](https://gradio.app).*"
+    )
 
 if __name__ == "__main__":
     demo.launch()