Upload folder using huggingface_hub

app.py

@@ -0,0 +1,409 @@
+"""
+Text-to-Quantum Circuit Generator
+Convert natural language to OpenQASM quantum circuits
+
+Eric Raymond | Purdue ECE 2026
+"""
+
+import gradio as gr
+import re
+from typing import Tuple, Optional
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import io
+import numpy as np
+
+# Qiskit imports
+try:
+    from qiskit import QuantumCircuit
+    from qiskit.visualization import circuit_drawer
+    from qiskit_aer import AerSimulator
+    from qiskit.compiler import transpile
+    QISKIT_AVAILABLE = True
+except ImportError:
+    QISKIT_AVAILABLE = False
+
+TITLE = "Text-to-Quantum Circuit"
+DESCRIPTION = """
+## English to OpenQASM Generator
+
+Convert natural language descriptions into executable quantum circuits.
+
+### Supported Operations
+- **Single-qubit gates:** H (Hadamard), X, Y, Z, S, T, Rx, Ry, Rz
+- **Two-qubit gates:** CNOT/CX, CZ, SWAP
+- **Three-qubit gates:** Toffoli/CCX, Fredkin/CSWAP
+- **Measurement:** measure qubit(s)
+
+### Example Phrases
+- "Create a Bell state with 2 qubits"
+- "Apply Hadamard to qubit 0, then CNOT from 0 to 1"
+- "3 qubit GHZ state"
+- "Quantum teleportation circuit"
+
+Built by Eric Raymond | Purdue ECE
+"""
+
+# Common circuit templates
+CIRCUIT_TEMPLATES = {
+    'bell': [
+        ('h', [0]),
+        ('cx', [0, 1]),
+        ('measure_all', []),
+    ],
+    'ghz3': [
+        ('h', [0]),
+        ('cx', [0, 1]),
+        ('cx', [0, 2]),
+        ('measure_all', []),
+    ],
+    'teleportation': [
+        ('h', [1]),
+        ('cx', [1, 2]),
+        ('cx', [0, 1]),
+        ('h', [0]),
+        ('measure', [0]),
+        ('measure', [1]),
+    ],
+    'grover2': [
+        ('h', [0]), ('h', [1]),
+        ('cz', [0, 1]),
+        ('h', [0]), ('h', [1]),
+        ('x', [0]), ('x', [1]),
+        ('cz', [0, 1]),
+        ('x', [0]), ('x', [1]),
+        ('h', [0]), ('h', [1]),
+        ('measure_all', []),
+    ],
+    'qft2': [
+        ('h', [0]),
+        ('cp', [1, 0, np.pi/2]),
+        ('h', [1]),
+        ('swap', [0, 1]),
+        ('measure_all', []),
+    ],
+}
+
+
+def detect_template(text: str) -> Optional[str]:
+    """Detect if user is asking for a known circuit template."""
+    text_lower = text.lower()
+
+    if 'bell' in text_lower and ('state' in text_lower or 'pair' in text_lower):
+        return 'bell'
+    if 'ghz' in text_lower or ('entangle' in text_lower and '3' in text_lower):
+        return 'ghz3'
+    if 'teleport' in text_lower:
+        return 'teleportation'
+    if 'grover' in text_lower:
+        return 'grover2'
+    if 'qft' in text_lower or 'fourier' in text_lower:
+        return 'qft2'
+
+    return None
+
+
+def parse_qubit_count(text: str) -> int:
+    """Extract number of qubits from text."""
+    match = re.search(r'(\d+)\s*qubits?', text.lower())
+    if match:
+        return int(match.group(1))
+
+    indices = re.findall(r'qubit\s*(\d+)', text.lower())
+    indices += re.findall(r'\bq(\d+)\b', text.lower())
+    indices += re.findall(r'\b(\d+)\s*(?:to|and|,)\s*(\d+)', text.lower())
+
+    flat_indices = []
+    for i in indices:
+        if isinstance(i, tuple):
+            flat_indices.extend(i)
+        else:
+            flat_indices.append(i)
+
+    if flat_indices:
+        return max(int(i) for i in flat_indices) + 1
+
+    return 2
+
+
+def nl_to_operations(text: str) -> Tuple[list, int, str]:
+    """Convert natural language to list of gate operations."""
+
+    # Check templates first
+    template = detect_template(text)
+    if template:
+        ops = CIRCUIT_TEMPLATES[template]
+        n_qubits = max(max(op[1]) if op[1] else 0 for op in ops) + 1
+        return ops, n_qubits, f"Using template: {template}"
+
+    operations = []
+    n_qubits = parse_qubit_count(text)
+    text_lower = text.lower()
+    notes = []
+
+    # Superposition patterns
+    if 'superposition' in text_lower or 'hadamard all' in text_lower or 'h all' in text_lower:
+        for i in range(n_qubits):
+            operations.append(('h', [i]))
+        notes.append(f"Applied H to all {n_qubits} qubits")
+
+    # Parse gate patterns
+    patterns = [
+        # Hadamard
+        (r'(?:hadamard|h)\s+(?:on\s+)?(?:qubit\s+)?(\d+)', 'h', lambda m: [int(m.group(1))]),
+        (r'apply\s+(?:hadamard|h)\s+to\s+(?:qubit\s+)?(\d+)', 'h', lambda m: [int(m.group(1))]),
+
+        # Pauli gates
+        (r'(?:pauli[- ]?)?x\s+(?:on\s+)?(?:qubit\s+)?(\d+)', 'x', lambda m: [int(m.group(1))]),
+        (r'(?:pauli[- ]?)?y\s+(?:on\s+)?(?:qubit\s+)?(\d+)', 'y', lambda m: [int(m.group(1))]),
+        (r'(?:pauli[- ]?)?z\s+(?:on\s+)?(?:qubit\s+)?(\d+)', 'z', lambda m: [int(m.group(1))]),
+        (r'(?:not|flip)\s+(?:qubit\s+)?(\d+)', 'x', lambda m: [int(m.group(1))]),
+
+        # Phase gates
+        (r's\s+(?:gate\s+)?(?:on\s+)?(?:qubit\s+)?(\d+)', 's', lambda m: [int(m.group(1))]),
+        (r't\s+(?:gate\s+)?(?:on\s+)?(?:qubit\s+)?(\d+)', 't', lambda m: [int(m.group(1))]),
+
+        # CNOT
+        (r'(?:cnot|cx)\s+(?:from\s+)?(?:qubit\s+)?(\d+)\s+(?:to\s+)?(?:qubit\s+)?(\d+)', 'cx', lambda m: [int(m.group(1)), int(m.group(2))]),
+        (r'(?:cnot|cx)\s+(\d+)\s*[,→-]\s*(\d+)', 'cx', lambda m: [int(m.group(1)), int(m.group(2))]),
+        (r'controlled[- ]?(?:not|x)\s+(?:control\s+)?(\d+)\s+(?:target\s+)?(\d+)', 'cx', lambda m: [int(m.group(1)), int(m.group(2))]),
+
+        # CZ
+        (r'cz\s+(\d+)\s*[,→-]?\s*(\d+)', 'cz', lambda m: [int(m.group(1)), int(m.group(2))]),
+        (r'controlled[- ]?z\s+(\d+)\s+(\d+)', 'cz', lambda m: [int(m.group(1)), int(m.group(2))]),
+
+        # SWAP
+        (r'swap\s+(?:qubit\s+)?(\d+)\s+(?:and\s+)?(?:qubit\s+)?(\d+)', 'swap', lambda m: [int(m.group(1)), int(m.group(2))]),
+
+        # Toffoli
+        (r'(?:toffoli|ccx)\s+(\d+)\s+(\d+)\s+(\d+)', 'ccx', lambda m: [int(m.group(1)), int(m.group(2)), int(m.group(3))]),
+
+        # Measurement
+        (r'measure\s+(?:qubit\s+)?(\d+)', 'measure', lambda m: [int(m.group(1))]),
+        (r'measure\s+all', 'measure_all', lambda m: []),
+    ]
+
+    for pattern, gate, extractor in patterns:
+        for match in re.finditer(pattern, text_lower):
+            args = extractor(match)
+            operations.append((gate, args))
+            if args:
+                n_qubits = max(n_qubits, max(args) + 1)
+
+    status = f"Parsed {len(operations)} operations for {n_qubits} qubits"
+    if notes:
+        status += " | " + ", ".join(notes)
+
+    return operations, n_qubits, status
+
+
+def operations_to_qasm(operations: list, n_qubits: int) -> str:
+    """Convert operations list to OpenQASM 2.0 string."""
+    lines = [
+        'OPENQASM 2.0;',
+        'include "qelib1.inc";',
+        f'qreg q[{n_qubits}];',
+        f'creg c[{n_qubits}];',
+        '',
+    ]
+
+    for gate, args in operations:
+        if gate == 'h':
+            lines.append(f'h q[{args[0]}];')
+        elif gate == 'x':
+            lines.append(f'x q[{args[0]}];')
+        elif gate == 'y':
+            lines.append(f'y q[{args[0]}];')
+        elif gate == 'z':
+            lines.append(f'z q[{args[0]}];')
+        elif gate == 's':
+            lines.append(f's q[{args[0]}];')
+        elif gate == 't':
+            lines.append(f't q[{args[0]}];')
+        elif gate == 'cx':
+            lines.append(f'cx q[{args[0]}], q[{args[1]}];')
+        elif gate == 'cz':
+            lines.append(f'cz q[{args[0]}], q[{args[1]}];')
+        elif gate == 'swap':
+            lines.append(f'swap q[{args[0]}], q[{args[1]}];')
+        elif gate == 'ccx':
+            lines.append(f'ccx q[{args[0]}], q[{args[1]}], q[{args[2]}];')
+        elif gate == 'cp':
+            lines.append(f'cp({args[2]}) q[{args[0]}], q[{args[1]}];')
+        elif gate == 'measure':
+            lines.append(f'measure q[{args[0]}] -> c[{args[0]}];')
+        elif gate == 'measure_all':
+            for i in range(n_qubits):
+                lines.append(f'measure q[{i}] -> c[{i}];')
+
+    return '\n'.join(lines)
+
+
+def operations_to_circuit(operations: list, n_qubits: int) -> Optional[QuantumCircuit]:
+    """Convert operations to Qiskit circuit."""
+    if not QISKIT_AVAILABLE:
+        return None
+
+    try:
+        qc = QuantumCircuit(n_qubits, n_qubits)
+
+        for gate, args in operations:
+            if gate == 'h':
+                qc.h(args[0])
+            elif gate == 'x':
+                qc.x(args[0])
+            elif gate == 'y':
+                qc.y(args[0])
+            elif gate == 'z':
+                qc.z(args[0])
+            elif gate == 's':
+                qc.s(args[0])
+            elif gate == 't':
+                qc.t(args[0])
+            elif gate == 'cx':
+                qc.cx(args[0], args[1])
+            elif gate == 'cz':
+                qc.cz(args[0], args[1])
+            elif gate == 'swap':
+                qc.swap(args[0], args[1])
+            elif gate == 'ccx':
+                qc.ccx(args[0], args[1], args[2])
+            elif gate == 'cp':
+                qc.cp(args[2], args[0], args[1])
+            elif gate == 'measure':
+                qc.measure(args[0], args[0])
+            elif gate == 'measure_all':
+                qc.measure_all()
+
+        return qc
+    except Exception as e:
+        print(f"Circuit error: {e}")
+        return None
+
+
+def simulate(qc: QuantumCircuit, shots: int = 1024) -> dict:
+    """Run simulation."""
+    if not QISKIT_AVAILABLE or qc is None:
+        return {}
+
+    try:
+        # Ensure measurements
+        if qc.num_clbits == 0 or not any(i.operation.name == 'measure' for i in qc.data):
+            qc = qc.copy()
+            qc.measure_all()
+
+        sim = AerSimulator()
+        compiled = transpile(qc, sim)
+        result = sim.run(compiled, shots=shots).result()
+        return result.get_counts()
+    except Exception as e:
+        print(f"Sim error: {e}")
+        return {}
+
+
+def format_results(counts: dict) -> str:
+    """Format results as markdown."""
+    if not counts:
+        return ""
+
+    total = sum(counts.values())
+    lines = ["\n### Simulation Results (1024 shots)\n"]
+
+    for state, count in sorted(counts.items(), key=lambda x: -x[1])[:8]:
+        prob = count / total * 100
+        bar = "█" * int(prob / 4)
+        lines.append(f"`|{state}>` {prob:5.1f}% {bar}")
+
+    return '\n'.join(lines)
+
+
+def draw_circuit(qc: QuantumCircuit) -> Optional[str]:
+    """Draw circuit to temp file."""
+    if not QISKIT_AVAILABLE or qc is None:
+        return None
+
+    try:
+        import tempfile
+        fig = circuit_drawer(qc, output='mpl', style='iqp')
+        tmp = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+        fig.savefig(tmp.name, dpi=150, bbox_inches='tight', facecolor='white')
+        plt.close(fig)
+        return tmp.name
+    except Exception as e:
+        print(f"Draw error: {e}")
+        return None
+
+
+def generate(description: str, run_sim: bool = True) -> Tuple[str, Optional[str], str]:
+    """Main: NL -> QASM + Circuit + Simulation."""
+
+    if not description.strip():
+        return "", None, "Please enter a circuit description"
+
+    # Parse
+    operations, n_qubits, status = nl_to_operations(description)
+
+    if not operations:
+        return "", None, "Could not parse any quantum operations. Try: 'Hadamard 0, CNOT 0 1, measure all'"
+
+    # Generate QASM
+    qasm = operations_to_qasm(operations, n_qubits)
+
+    # Build circuit
+    qc = operations_to_circuit(operations, n_qubits)
+
+    # Draw
+    img_path = draw_circuit(qc)
+
+    # Simulate
+    results_md = ""
+    if run_sim and qc:
+        counts = simulate(qc)
+        results_md = format_results(counts)
+
+    output = f"### OpenQASM 2.0\n```qasm\n{qasm}\n```\n{results_md}"
+
+    return output, img_path, status
+
+
+# Build UI
+with gr.Blocks(title=TITLE, theme=gr.themes.Soft()) as demo:
+    gr.Markdown(f"# {TITLE}")
+    gr.Markdown(DESCRIPTION)
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            input_text = gr.Textbox(
+                label="Describe your quantum circuit",
+                placeholder="Example: Create a Bell state with 2 qubits",
+                lines=3
+            )
+
+            with gr.Row():
+                sim_check = gr.Checkbox(label="Run simulation", value=True)
+                btn = gr.Button("Generate Circuit", variant="primary")
+
+            gr.Examples(
+                examples=[
+                    ["Create a Bell state with 2 qubits"],
+                    ["3 qubit GHZ state"],
+                    ["Hadamard 0, CNOT 0 1, measure all"],
+                    ["Quantum teleportation circuit"],
+                    ["Put 4 qubits in superposition, then measure all"],
+                    ["Grover's algorithm for 2 qubits"],
+                    ["Apply X to qubit 0, H to qubit 1, then CZ 0 1"],
+                ],
+                inputs=input_text
+            )
+
+        with gr.Column(scale=3):
+            status = gr.Textbox(label="Status", lines=1)
+            circuit_img = gr.Image(label="Circuit Diagram")
+            output = gr.Markdown(label="Output")
+
+    btn.click(generate, [input_text, sim_check], [output, circuit_img, status])
+    input_text.submit(generate, [input_text, sim_check], [output, circuit_img, status])
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0
+numpy
+matplotlib
+qiskit>=1.0
+qiskit-aer