Co

Dockerfile

@@ -85,7 +85,7 @@ COPY --chown=user:user app.py .
 # COPY --chown=user:user test_images /home/user/app/test_images
 
 ENV PYTHONUNBUFFERED=1 	GRADIO_ALLOW_FLAGGING=never 	GRADIO_NUM_PORTS=1 	GRADIO_SERVER_NAME=0.0.0.0     GRADIO_SERVER_PORT=7860 	SYSTEM=spaces
-RUN python3 -m pip  install pennylane sympy pennylane-qiskit duckdb
+RUN python3 -m pip  install pennylane sympy pennylane-qiskit duckdb qutip qutip-qip
 WORKDIR $HOME/app
 
 EXPOSE 8097 7842 8501 8000 6666 7860

app.py

@@ -10,33 +10,20 @@ import matplotlib.pyplot as plt
 from PIL import Image
 import pennylane as qml
 import base64
-
-from numpy import pi
-import numpy as np
 from qutip import *
 from qutip.qip.operations import *
 from qutip.qip.circuit import QubitCircuit, Gate
+import pennylane as qml
+from math import pi
 
-# Define a device
+# Define a Pennylane device
 dev = qml.device('default.qubit', wires=10)
 
-def plot_qutip_circuit():
-    q = QubitCircuit(2, reverse_states=False)
-    q.add_gate("CNOT", controls=[0], targets=[1])
-    
-    # Display the circuit as an image
-    q.png  # Generates and renders the circuit diagram
-
-    return q
-
-
 # Hugging Face and DuckDB function placeholders
 def store_in_hf_dataset(data):
-    # Implement storing data in the Hugging Face dataset
     pass
 
 def load_from_hf_dataset():
-    # Implement loading data from the Hugging Face dataset
     return []
 
 # Function to buffer the plot and return as PIL image
@@ -52,6 +39,13 @@ def pil_image_to_bytes(image):
     image.save(img_byte_arr, format='PNG')
     return img_byte_arr.getvalue()
 
+# Encode the image in base64 to display in HTML
+def encode_image_from_blob(blob):
+    img_buffer = io.BytesIO(blob)
+    image = Image.open(img_buffer)
+    img_str = base64.b64encode(img_buffer.getvalue()).decode("utf-8")
+    return f'<img src="data:image/png;base64,{img_str}" style="max-width:500px;"/>'
+
 # Function to generate a random Hamiltonian
 def generate_random_hamiltonian(num_qubits):
     terms = []
@@ -88,20 +82,24 @@ def hamiltonian_to_qasm(hamiltonian, num_qubits):
     
     return qasm_code
 
-# Function for Trotter decomposition
-def trotter_decomposition(hamiltonian, order):
-    terms = hamiltonian.split(" + ")
-    trotter_steps = []
+# Function to parse QASM code and create Pennylane circuit
+def qasm_to_pennylane(qasm_code):
+    qasm_lines = qasm_code.split("\n")
+    num_qubits = int(qasm_lines[2].split('[')[1].split(']')[0])  # Extract number of qubits from QASM
     
-    for term in terms:
-        coeff, *pauli_ops = term.split(" * ")
-        coeff = float(coeff)
-        for _ in range(order):
-            trotter_steps.append(f"exp({coeff / order}) * ({' * '.join(pauli_ops)})")
-        for _ in range(order):
-            trotter_steps.append(f"exp({-coeff / order}) * ({' * '.join(pauli_ops)})")
+    @qml.qnode(dev)
+    def circuit():
+        for line in qasm_lines:
+            if "x" in line:
+                qml.PauliX(int(line.split('q[')[1].split(']')[0]))
+            elif "rz" in line:
+                angle = float(line.split('(')[1].split(')')[0])
+                qml.RZ(angle, int(line.split('q[')[1].split(']')[0]))
+            elif "ry" in line:
+                qml.RY(pi / 2, int(line.split('q[')[1].split(']')[0]))
+        return qml.state()
     
-    return " + ".join(trotter_steps)
+    return circuit
 
 # Store data in DuckDB
 def store_in_duckdb(data, db_file='quantum_hamiltonians.duckdb'):
@@ -120,13 +118,7 @@ def store_in_duckdb(data, db_file='quantum_hamiltonians.duckdb'):
                         VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", data)
     conn.close()
 
-# Load results from DuckDB and encode images to base64
-def encode_image_from_blob(blob):
-    img_buffer = io.BytesIO(blob)
-    image = Image.open(img_buffer)
-    img_str = base64.b64encode(img_buffer.getvalue()).decode("utf-8")
-    return f'<img src="data:image/png;base64,{img_str}" style="max-width:500px;"/>'
-
+# Function to load results from DuckDB
 def load_from_duckdb(db_file='quantum_hamiltonians.duckdb'):
     conn = duckdb.connect(database=db_file)
     df = conn.execute("SELECT * FROM hamiltonians").df()
@@ -185,9 +177,11 @@ def generate_hamiltonians(num_hamiltonians, selected_qubits, selected_order, wri
         qasm_code = hamiltonian_to_qasm(hamiltonian, num_qubits)
         trotter_code = trotter_decomposition(hamiltonian, order)
 
-        # Create a dummy plot (replace with actual plot creation logic)
-        fig, ax = plt.subplots()
-        ax.plot([0, 1], [0, 1])
+        # Generate Pennylane circuit from QASM code
+        circuit = qasm_to_pennylane(qasm_code)
+
+        # Draw the Pennylane circuit and save as an image
+        fig, ax = qml.draw_mpl(circuit)()
         circuit_plot_image = buffer_plot_and_get(fig)
         circuit_plot_bytes = pil_image_to_bytes(circuit_plot_image)
 
@@ -209,6 +203,22 @@ def load_results(load_from_hf, load_from_duckdb1):
     if load_from_duckdb1:
         return load_from_duckdb()
 
+# Function for Trotter decomposition
+def trotter_decomposition(hamiltonian, order):
+    terms = hamiltonian.split(" + ")
+    trotter_steps = []
+    
+    for term in terms:
+        coeff, *pauli_ops = term.split(" * ")
+        coeff = float(coeff)
+        for _ in range(order):
+            trotter_steps.append(f"exp({coeff / order}) * ({' * '.join(pauli_ops)})")
+        for _ in range(order):
+            trotter_steps.append(f"exp({-coeff / order}) * ({' * '.join(pauli_ops)})")
+    
+    return " + ".join(trotter_steps)
+
+
 # Gradio app
 with gr.Blocks() as app:
     gr.Markdown("# Quantum Hamiltonian Generator")