LT

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+archive
+__pycache__
+*.duckdb 
+*.parquet

Dockerfile

@@ -1,10 +1,3 @@
-# Dockerfile customized for deployment on HuggingFace Spaces platform
-
-# -- The Dockerfile has been tailored specifically for use on HuggingFace.
-# -- It implies that certain modifications or optimizations have been made with HuggingFace's environment in mind.
-# -- It uses "HuggingFace Spaces" to be more specific about the target platform.
-
-# FROM pytorch/pytorch:2.2.1-cuda12.1-cudnn8-devel
 FROM pytorch/pytorch:2.4.0-cuda12.1-cudnn9-devel 
 # FOR HF
 
@@ -38,7 +31,6 @@ ENV TZ=Asia/Dubai
 RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 
 
-
 RUN useradd -m -u 1000 user
     
 RUN apt-get update && apt-get install -y sudo && \
@@ -49,7 +41,6 @@ ENV HOME=/home/user \
 	PATH=/home/user/.local/bin:$PATH
 
 RUN mkdir $HOME/app
-RUN mkdir $HOME/app/test_images
 
 # WORKDIR $HOME/app
 
@@ -58,31 +49,20 @@ RUN chown -R user:user $HOME/app
 USER user
 WORKDIR $HOME/app
 
-RUN python -m  pip install  qwen-vl-utils 
-RUN python -m pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu122 mlc-ai-nightly-cu122
-#python -m pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cpu mlc-ai-nightly-cpu
 
 RUN  python3 -m pip install chromadb db-sqlite3 auto-gptq exllama sqlalchemy  
 WORKDIR $HOME/app
-RUN git clone https://github.com/casper-hansen/AutoAWQ  
-WORKDIR $HOME/app/AutoAWQ/ 
-RUN python3 -m pip  install -e .
-WORKDIR $HOME/app
 # ENV FLASH_ATTENTION_FORCE_BUILD=TRUE
 RUN python -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
 RUN python -m pip install  accelerate diffusers datasets timm flash-attn==2.6.1 gradio
 
 RUN  python3 -m pip install --no-deps optimum  
-RUN  python3 -m pip install --no-deps autoawq>=0.1.8 
 
 #This seems to be a must : Intel Extension for PyTorch 2.4 needs to work with PyTorch 2.4.*, but PyTorch 2.2.2 is
 RUN python -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
-RUN  python3 -m pip install -U accelerate 
+RUN  python3 -m pip install -U accelerate bitsandbytes
 RUN  python3 -m pip install -U git+https://github.com/huggingface/transformers
 
-WORKDIR $HOME/app
-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 qutip qutip-qip
@@ -91,3 +71,5 @@ WORKDIR $HOME/app
 EXPOSE 8097 7842 8501 8000 6666 7860
 
 CMD ["python", "app.py"]
+
+# mlc-llm server HF://mlc-ai/Llama-3.2-1B-Instruct-q4f16_1-MLC 

Q_app_llm_pairs_gen.py

@@ -0,0 +1,199 @@
+"""
+Quantum Physics Problem Generator
+Shlomo Kashani 
+
+Description:
+------------
+This module is part of the QuantumLLMInstruct system, designed to generate and solve quantum physics problems 
+using advanced Large Language Models (LLMs). It utilizes a multi-stage pipeline for problem generation, 
+solution generation, and database management.
+
+Core Functionalities:
+---------------------
+1. **Problem Generation**:
+   - Generates quantum physics problems in LaTeX format using LLMs.
+   - Supports domain-specific problem generation across multiple quantum fields.
+
+2. **Solution Generation**:
+   - Provides step-by-step LaTeX solutions for the generated problems using a second LLM.
+
+3. **Data Management**:
+   - Stores generated problems and solutions in DuckDB and Parquet files.
+   - Enables exporting data in Parquet format for scalability and compatibility.
+
+4. **Gradio Interface**:
+   - A user-friendly interface to interact with the system, including problem generation, 
+     solution generation, and database exploration.
+
+5. **Hugging Face Integration**:
+   - Supports visualization and interaction with the dataset on the Hugging Face platform.
+
+Main Components:
+----------------
+- **initialize_duckdb() / initialize_parquet()**: Initializes the database schema.
+- **generate_multiple_problems()**: Generates multiple problems for the selected quantum domains.
+- **generate_solutions()**: Solves unsolved problems in the database.
+- **export_parquet()**: Exports the database to a Parquet file for external use.
+
+Dependencies:
+-------------
+- Python 3.7+
+- Transformers: `transformers`
+- DuckDB: `duckdb`
+- Gradio: `gradio`
+- Pandas: `pandas`
+"""
+import gradio as gr
+
+from Q_llm_prompts import *
+from Q_quantum_utils import *
+
+initialize_duckdb()
+
+description = """
+This demo showcases **[QuantumLLMInstruct](https://huggingface.co/datasets/BoltzmannEntropy/QuantumLLMInstruct/)**
+<img src="https://huggingface.co/datasets/BoltzmannEntropy/QuantumLLMInstruct/resolve/main/qlmmi-detailed-flowchart.jpg" alt="The Pipeline" width="70%" align="center" />
+## 🚀 Pipeline:
+1. **📝 Problem Generation:** The Qwen model generates a user instruction.
+2. **💬 Solution Generation:** The Qwen model generates a response to this instruction.
+"""
+
+# Gradio app
+with gr.Blocks() as app:
+    """
+    Main Gradio application block defining the QuantumLLMInstruct pipeline.
+    Provides tabs for viewing datasets, generating problems, generating solutions,
+    and exporting the database.
+    """
+    gr.Markdown("# QuantumLLMInstruct: A 500k LLM Instruction-Tuning Dataset with Problem-Solution Pairs for Quantum Computing.")
+
+    with gr.Tab("View HF DB"):
+        """
+        Tab for displaying the Hugging Face QuantumLLMInstruct dataset.
+        Embeds a viewer for exploring the dataset hosted on Hugging Face.
+        """
+        gr.Markdown("### Generated Dataset")
+        gr.HTML("""<iframe
+        src="https://huggingface.co/datasets/BoltzmannEntropy/QuantumLLMInstruct/embed/viewer"
+        frameborder="0"
+        width="100%"
+    height="560px"
+    ></iframe>""")
+        
+    with gr.Tab("LLM stage 1 model: Generate Problems"):
+        """
+        Tab for generating quantum physics problems using the Qwen model.
+        Allows users to select models, choose domains, and specify the number of problems to generate.
+        """
+        model_selector = gr.Dropdown(
+            choices=model_options,
+            value=model_options[0],
+            label="Select Qwen Model"
+        )
+        reload_button = gr.Button("Reload Model")
+        reload_status = gr.Textbox(label="Model Status", interactive=False)
+
+        generate_button = gr.Button("🚀 Generate Instructions For the Pair")
+        result_output = gr.Textbox(label="Generated Problems", interactive=False)
+        num_pairs = gr.Radio(choices=[1, 5, 50, 200, 2000, 20000, 200000], value=5, label="Number of Problems")
+
+        domain_selector = gr.CheckboxGroup(
+            choices=list(quantum_problem_domains.keys()),
+            value=list(quantum_problem_domains.keys()),
+            label="Select Domain Types"
+        )
+
+        reload_button.click(
+            reload_model,
+            inputs=[model_selector],
+            outputs=[reload_status]
+        )
+        
+        def generate_and_display(num_pairs, selected_domains):
+            """
+            Generates multiple quantum problems based on user inputs.
+            
+            Args:
+                num_pairs (int): Number of problems to generate.
+                selected_domains (list): Selected quantum domains for problem generation.
+            
+            Returns:
+                str: Status message confirming successful problem generation.
+            """
+            generate_multiple_problems(num_pairs, selected_domains)
+            return "Problems generated successfully."
+
+        generate_button.click(
+            generate_and_display,
+            inputs=[num_pairs, domain_selector],
+            outputs=[result_output]
+        )
+
+    with gr.Tab("LLM Stage 2: Generate Solutions"):
+        """
+        Tab for generating solutions to the quantum problems using the Qwen solution models.
+        """
+        generate_solutions_button = gr.Button("🚀 Generate Responses for the Pair")
+        solutions_status = gr.Textbox(label="Solution Generation Status", interactive=False)
+
+        solutions_model_selector = gr.Dropdown(
+            choices=solutions_model_options,
+            value=solutions_model_options[4],
+            label="Select Solution Model"
+        )
+
+        generate_solutions_button.click(
+            generate_solutions,
+            inputs=[solutions_model_selector],
+            outputs=[solutions_status]
+        )
+
+    with gr.Tab("View instruction-pairs DB"):
+        """
+        Tab for viewing data stored in the DuckDB database.
+        Provides an HTML table viewer for summarized and detailed data exploration.
+        """
+        summary_output = gr.HTML()
+        view_button = gr.Button("View Data")
+        db_output_display = gr.HTML()
+
+        view_button.click(load_summary_from_duckdb, inputs=None, outputs=summary_output)
+
+        def view_db_data():
+            """
+            Loads and formats problems stored in the DuckDB database for display.
+            
+            Returns:
+                str: HTML representation of the database content or a message indicating no data.
+            """
+            df = load_problems_from_duckdb()
+            if df.empty:
+                return "<p>No data found in the DuckDB database.</p>"
+            html_table = df.to_html(index=False, escape=False)
+            return html_table
+
+        view_button.click(
+            view_db_data,
+            inputs=None,
+            outputs=[db_output_display]
+        )
+
+    with gr.Tab("Export Parquet"):
+        """
+        Tab for exporting the DuckDB database into a Parquet file format.
+        Enables efficient data sharing and downstream analysis.
+        """
+        gr.Markdown("### Export DuckDB Data to Parquet Format")
+        db_file_input = gr.Textbox(label="Database File Path", value="quantum_problems.duckdb")
+        export_button = gr.Button("Export Data")
+        export_status = gr.Textbox(label="Export Status", interactive=False)
+
+        export_button.click(
+            export_parquet,
+            inputs=[db_file_input],
+            outputs=[export_status]
+        )
+
+    gr.Markdown(description)
+
+app.launch()

Q_llm_prompts.py

@@ -0,0 +1,726 @@
+import io 
+
+quantum_problem_domains = {
+    "QASM Generation": {
+        "description": "Generate a quantum physics problem involving generating executable QASM code in OpenQASM  for a given quantum circuit.",
+        "template": """{Problem:} Design a quantum circuit that prepares the Bell state \\( |\\phi^+\\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle) \\) and generate the corresponding QASM code.
+{Domain:} QASM GENERATION"""
+    },
+    "Quantum Hamiltonians": {
+        "description": "Generate a quantum physics problem such as Hamiltonian time evolution and ground-state energy calculations.",
+        "template": """{Problem:} Given a three-qubit system with the Hamiltonian:
+\\[
+H = J (\\sigma_1^z \\sigma_2^z + \\sigma_2^z \\sigma_3^z) - h \\sum_{i=1}^3 \\sigma_i^x
+\\]
+where \\( J = 1.5 \\) and \\( h = 0.8 \\), determine the ground-state energy.
+{Domain:} QUANTUM HAMILTONIANS"""
+    },
+    "Yang-Baxter Solvability": {
+        "description": "Generate a quantum physics problem focused on determining if a quantum model is Yang-Baxter solvable.",
+        "template": """{Problem:} Verify whether the following 2x2 R-matrix satisfies the Yang-Baxter equation:
+\\[
+R = \\begin{bmatrix}
+1 & 0 & 0 & 0 \\\\
+0 & 0 & 1 & 0 \\\\
+0 & 1 & 0 & 0 \\\\
+0 & 0 & 0 & 1
+\\end{bmatrix}.
+\\]
+{Domain:} YANG-BAXTER SOLVABILITY"""
+    },
+    "Trotter-Suzuki Decomposition": {
+        "description": "Generate a quantum physics problem involving the Trotter-Suzuki decomposition of Hamiltonians.",
+        "template": """{Problem:} Perform a first-order Trotter-Suzuki decomposition for the Hamiltonian:
+\\[
+H = H_A + H_B, \\quad H_A = \\sigma_1^x \\sigma_2^x, \\quad H_B = \\sigma_1^z \\sigma_2^z.
+\\]
+Write the decomposition for \\( e^{-iHt} \\) up to time \\( t = 1 \\).
+{Domain:} TROTTER-SUZUKI DECOMPOSITION"""
+    },
+    "Lindblad Dynamics": {
+        "description": "Generate a quantum physics problem related to simulating the dynamics of a qubit interacting with a thermal bath using the Lindblad equation.",
+        "template": """{Problem:} Simulate the time evolution of a single qubit under the Lindblad master equation:
+\\[
+\\frac{d\\rho}{dt} = -i[H, \\rho] + \\sum_k \\left(L_k \\rho L_k^\\dagger - \\frac{1}{2} \\{L_k^\\dagger L_k, \\rho\\}\\right),
+\\]
+where \\( H = \\frac{\\omega}{2} \\sigma^z \\) and \\( L_k = \\sqrt{\\gamma} \\sigma^- \\). Calculate \\( \\rho(t) \\) for \\( t = 1 \\).
+{Domain:} LINDBLAD DYNAMICS"""
+    },
+    "Randomized Circuits Optimization": {
+        "description": "Generate a quantum physics problem that requires the optimization of a randomized quantum circuit to minimize error rates.",
+        "template": """{Problem:} Design a randomized quantum circuit of 5 qubits with a depth of 10, and propose a cost function to optimize the fidelity of the output state.
+{Domain:} RANDOMIZED CIRCUITS OPTIMIZATION"""
+    },
+    "Quantum Phase Estimation": {
+        "description": "Generate a quantum physics problem involving the implementation of quantum phase estimation for an eigenvalue calculation.",
+        "template": """{Problem:} Design a quantum phase estimation circuit to determine the eigenvalue \\( \\phi \\) of a unitary operator \\( U \\) for \\( U |\\psi\\rangle = e^{2\\pi i \\phi} |\\psi\\rangle \\). Provide an example with \\( U = \\text{diag}(1, e^{2\\pi i / 4}) \\).
+{Domain:} QUANTUM PHASE ESTIMATION"""
+    },
+    "Cluster States Verification": {
+        "description": "Generate a quantum physics problem focusing on the preparation and verification of cluster states for measurement-based quantum computation.",
+        "template": """{Problem:} Prepare a four-qubit cluster state using Hadamard gates and controlled-Z operations. Verify the entanglement of the state using stabilizer measurements.
+{Domain:} CLUSTER STATES VERIFICATION"""
+    },
+    "VQE Analysis": {
+        "description": "Generate a quantum physics problem involving the construction and evaluation of a variational quantum eigensolver (VQE) Ansatz for a specific molecular Hamiltonian.",
+        "template": """{Problem:} Construct a variational quantum eigensolver (VQE) Ansatz to approximate the ground-state energy of the H2 molecule. Use the Hamiltonian:
+\\[
+H = g (\\sigma_1^z \\sigma_2^z) + J (\\sigma_1^x + \\sigma_2^x),
+\\]
+where \\( g = 1.0 \\) and \\( J = 0.5 \\). Describe the optimization process.
+{Domain:} VQE ANALYSIS"""
+    },
+    "Quantum Algorithm Development": {
+        "description": "Develop a quantum algorithm to solve a complex problem, such as integer factorization or database search, using principles of quantum computing.",
+        "template": """{Problem:} Develop a quantum algorithm using Grover's search to find a marked item in an unsorted database of size 8. Provide the circuit and explain the amplification steps.
+{Domain:} QUANTUM ALGORITHM DEVELOPMENT"""
+    },
+    "Entanglement and Quantum Information Theory": {
+        "description": "Generate a quantum physics problem that explores the properties and applications of entangled states within quantum information theory frameworks.",
+        "template": """{Problem:} Demonstrate the violation of Bell's inequality using the CHSH game. Compute the quantum value for the CHSH parameter given a maximally entangled state.
+{Domain:} ENTANGLEMENT AND QUANTUM INFORMATION THEORY"""
+    },
+    "Quantum Error Correction": {
+        "description": "Create a quantum physics problem centered on designing and implementing error correction codes to protect qubits from decoherence and other quantum noise sources.",
+        "template": """{Problem:} Design a quantum error correction scheme using the Shor code to protect against arbitrary single-qubit errors. Show the encoding and decoding procedures.
+{Domain:} QUANTUM ERROR CORRECTION"""
+    },
+    "Semiclassical Quantum Simulation": {
+        "description": "Generate a quantum physics problem that involves simulating the dynamics of a quantum system using semiclassical methods, where some degrees of freedom are treated classically while others are treated quantum mechanically.",
+        "template": """{Problem:} Simulate a particle in a double-well potential using semiclassical methods, treating position classically and momentum quantum mechanically. Compute the tunneling rate.
+{Domain:} SEMICLASSICAL QUANTUM SIMULATION"""
+    },
+    "Quantum Communication Protocols": {
+        "description": "Develop a quantum physics problem related to the implementation and evaluation of secure communication protocols such as Quantum Key Distribution (QKD) or superdense coding.",
+        "template": """{Problem:} Implement the BB84 protocol for quantum key distribution. Describe the process for generating and verifying the shared secret key.
+{Domain:} QUANTUM COMMUNICATION PROTOCOLS"""
+    },
+    "Topological Quantum Computing": {
+        "description": "Generate a quantum physics problem involving the study of topological quantum computing, focusing on braiding operations in anyonic quasiparticles to achieve fault-tolerant computation.",
+        "template": """{Problem:} Illustrate how to braid anyons in a topological quantum computing model to implement a CNOT gate. Explain the fault tolerance of this operation.
+{Domain:} TOPOLOGICAL QUANTUM COMPUTING"""
+    },
+    "Quantum Complexity Classes": {
+        "description": "Formulate a quantum physics problem that investigates the classification of computational problems based on their solvability by quantum algorithms and the complexity of these solutions.",
+        "template": """{Problem:} Explain why the factoring problem belongs to the class BQP and discuss the implications of Shor's algorithm in computational complexity theory.
+{Domain:} QUANTUM COMPLEXITY CLASSES"""
+    },
+    "Quantum Thermodynamics": {
+        "description": "Create a quantum physics problem that involves analyzing thermodynamic quantities, such as entropy or work extraction, in isolated or open quantum systems.",
+        "template": """{Problem:} Calculate the entropy of a two-qubit thermal state described by the density matrix:
+\\[
+\\rho = \\frac{e^{-\\beta H}}{Z},
+\\]
+where \\( H = \\sigma_1^z \\sigma_2^z \\) and \\( \\beta = 1 \\).
+{Domain:} QUANTUM THERMODYNAMICS"""
+    },
+    "Interacting Quantum Systems": {
+        "description": "Generate a quantum physics problem that studies the dynamics and correlations of interacting quantum systems, potentially including many-body localized phases or critical behavior near phase transitions.",
+        "template": """{Problem:} Analyze the dynamics of a three-qubit system governed by the Hamiltonian:
+\\[
+H = J \\sigma_1^z \\sigma_2^z + h (\\sigma_2^x + \\sigma_3^x),
+\\]
+where \\( J = 1.0 \\) and \\( h = 0.5 \\). Determine the time evolution of the initial state \\( |101\\rangle \\).
+{Domain:} INTERACTING QUANTUM SYSTEMS"""
+    },
+    "Quantum Cryptography": {
+        "description": "Generate a quantum physics problem exploring quantum cryptographic protocols like quantum key distribution (QKD) and secure communication methods.",
+        "template": """{Problem:} Propose a quantum cryptography protocol for superdense coding to send two classical bits using one qubit. Explain the encoding and decoding processes.
+{Domain:} QUANTUM CRYPTOGRAPHY"""
+    },
+    "Quantum Channels": {
+        "description": "Generate a quantum physics problem that involves the mathematical and physical properties of quantum channels for information transfer.",
+        "template": """{Problem:} Analyze the action of the amplitude-damping channel on a single-qubit state. Compute the output state for \\( \\rho = |1\\rangle\\langle 1| \\) with damping probability \\( p = 0.2 \\).
+{Domain:} QUANTUM CHANNELS"""
+    },
+    "Quantum Fourier Transform": {
+        "description": "Develop a problem exploring the implementation and use of the quantum Fourier transform in quantum algorithms.",
+        "template": """{Problem:} Implement the quantum Fourier transform for a 3-qubit system. Show the transformation of the computational basis state \\( |101\\rangle \\).
+{Domain:} QUANTUM FOURIER TRANSFORM"""
+    },
+    "Quantum Machine Learning": {
+        "description": "Generate a problem that focuses on the application of quantum circuits to machine learning tasks such as classification or regression.",
+        "template": """{Problem:} Design a variational quantum classifier to separate linearly non-separable data points in a 2D space. Describe the Ansatz and the cost function used.
+{Domain:} QUANTUM MACHINE LEARNING"""
+    },
+    "Quantum State Tomography": {
+        "description": "Create a problem requiring the reconstruction of quantum states using measurement data and tomography techniques.",
+        "template": """{Problem:} Perform quantum state tomography to reconstruct the density matrix of a two-qubit state given measurement outcomes in the \\( \\sigma^x \\), \\( \\sigma^y \\), and \\( \\sigma^z \\) bases.
+{Domain:} QUANTUM STATE TOMOGRAPHY"""
+    },
+    "Bell Inequalities and Nonlocality": {
+        "description": "Formulate a quantum problem centered on testing Bell inequalities and analyzing quantum nonlocality through experiments.",
+        "template": """{Problem:} Test the violation of Bell's inequality using a singlet state \\( |\\psi\\rangle = \\frac{1}{\\sqrt{2}}(|01\\rangle - |10\\rangle) \\). Compute the expected CHSH parameter.
+{Domain:} BELL INEQUALITIES AND NONLOCALITY"""
+    }, 
+
+    "Diagonalization of Two-Spin Hamiltonian": {
+        "description": "Find the eigenvalues of a Hamiltonian for a two-spin system without using a computer.",
+        "template": """{Problem:} Consider a Hamiltonian for two spin-1/2s:
+\\[
+H = A \\sigma_1^z \\otimes I_2 + B (\\sigma_1^x \\otimes \\sigma_2^x + \\sigma_1^y \\otimes \\sigma_2^y).
+\\]
+Find all the eigenvalues of \\( H \\) without using a computer.
+{Domain:} DIAGONALIZATION"""
+    },
+    "Energy Eigenvalues via Perturbation Theory": {
+        "description": "Calculate the exact energy eigenvalues of a given Hamiltonian via diagonalization and compare with first-order perturbation theory.",
+        "template": """{Problem:} Calculate the exact energy eigenvalues for the Hamiltonian:
+\\[
+H = \\omega_o \\sigma_z + \\omega \\sigma_x.
+\\]
+Perform diagonalization and compare with the results obtained via first-order perturbation theory.
+{Domain:} PERTURBATION THEORY"""
+    },
+    "Measurement in Plus-Minus Basis": {
+        "description": "Explore the measurement probabilities and post-measurement states in the |+⟩, |-⟩ basis.",
+        "template": """{Problem:} Consider the state \\( |+\\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle + |1\\rangle) \\). 
+If measured in the \\( |+\\rangle, |−\\rangle \\) basis (where \\( |−\\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle − |1\\rangle) \\)), calculate the probability of each outcome. Derive the resulting post-measurement state.
+{Domain:} MEASUREMENT BASIS"""
+    },
+    "Pauli Spin Matrices Analysis": {
+        "description": "Analyze properties of Pauli matrices, find linear combinations, and diagonalize matrices.",
+        "template": """{Problem:} The Pauli spin matrices are:
+\\[
+\\sigma_1 = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}, \\quad
+\\sigma_2 = \\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}, \\quad
+\\sigma_3 = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}.
+\\]
+(a) Show that \\( \\sigma_i \\sigma_j = i \\epsilon_{ijk} \\sigma_k \\) (cyclic permutation property). \\\\
+(b) Express the matrix \\( A = \\begin{bmatrix} 5 & 2 + 3i \\\\ 2 - 3i & -3 \\end{bmatrix} \\) as a linear combination of the Pauli matrices and the identity matrix. \\\\
+(c) Diagonalize each of the Pauli matrices and specify the eigenvalues and normalized eigenvectors.
+{Domain:} PAULI MATRICES"""
+    },
+    "Born's Rule and State Measurement": {
+        "description": "Use Born's rule to calculate measurement probabilities and post-measurement states.",
+        "template": """{Problem:} For the state:
+\\[
+|\\psi\\rangle = \\frac{1}{\\sqrt{2}} |00\\rangle + \\frac{1}{2} |10\\rangle − \\frac{1}{2} |11\\rangle,
+\\]
+calculate the probability of measuring the second qubit in the state \\( |0\\rangle \\). Use the projective measurement operator \\( M = I \\otimes |0\\rangle \\langle 0| \\). Determine the resulting post-measurement state.
+{Domain:} BORN'S RULE"""
+    },
+
+"Quantum Hamiltonians": {
+        "description": "Generate a quantum physics problem such as Hamiltonian time evolution and ground-state energy calculations.",
+        "example": """{Problem:} Calculate the exact energy eigenvalues for the Hamiltonian \\( H = \\omega_o \\sigma_z + \\omega \\sigma_x \\) via diagonalization. Compare with the results from first-order perturbation theory.
+{Domain:} QUANTUM HAMILTONIANS"""
+    },
+    "Measurement in Qubit Basis": {
+        "description": "Generate a problem focusing on the quantum measurement principle in various bases.",
+        "example": """{Problem:} Consider the quantum state \\( |\\psi\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{e^{i\\theta}}{\\sqrt{2}} |1\\rangle \\). Compute the probability of measuring \\( |+\\rangle \\) and \\( |-\\rangle \\) in the \\( \\{|+\\rangle, |-\\rangle\\} \\) basis.
+{Domain:} MEASUREMENT PRINCIPLE"""
+    },
+    "Density Matrix Analysis": {
+        "description": "Generate a problem focusing on density matrix representation and tracing out subsystems.",
+        "example": """{Problem:} For the quantum state \\( |\\psi\\rangle = \\frac{|00\\rangle + |11\\rangle}{\\sqrt{2}} \\), compute the density matrix \\( \\rho \\). Trace out the second qubit to determine the reduced density matrix of the first qubit.
+{Domain:} DENSITY MATRIX ANALYSIS"""
+    },
+    "Spin Chains": {
+        "description": "Generate a quantum physics problem on integrable spin chains, such as the Heisenberg or Ising model.",
+        "example": """{Problem:} Consider the Heisenberg spin chain with the Hamiltonian:
+\\[
+H = J \\sum_{i} \\sigma_i^z \\sigma_{i+1}^z + h \\sum_i \\sigma_i^x
+\\]
+where \\( J = 1 \\) and \\( h = 0.5 \\). Determine the ground state energy and eigenvalues.
+{Domain:} SPIN CHAINS"""
+    },
+    "Bell State and Concurrence": {
+        "description": "Generate a problem on the preparation and analysis of Bell states and concurrence.",
+        "example": """{Problem:} Alice and Bob prepare two qubits in the Bell state \\( |\\psi\\rangle = \\frac{3}{7}|00\\rangle + \\frac{6}{7}|01\\rangle + \\frac{2}{7}|10\\rangle \\). Calculate the concurrence of \\( |\\psi\\rangle \\) and determine the expectation value of \\( \\sigma_z \\) for qubit B.
+{Domain:} BELL STATES"""
+    },
+    "Quantum Probability Calculations": {
+        "description": "Generate a problem involving calculation of quantum probabilities.",
+        "example": """{Problem:} Given the final quantum state:
+\\[
+|\\psi\\rangle = \\frac{1}{2}\\begin{pmatrix} 1 + e^{i\\phi} \\\\ 1 - e^{i\\phi} \\end{pmatrix}
+\\]
+calculate the probability of finding the system in state \\( |1\\rangle \\).
+{Domain:} QUANTUM PROBABILITY"""
+    },
+    "Quantum Phase Estimation": {
+        "description": "Generate a problem involving quantum phase estimation techniques.",
+        "example": """{Problem:} Consider the quantum state \\( |\\psi\\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle + e^{i\\theta}|1\\rangle) \\). Perform a measurement in the \\( \\{|+\\rangle, |-\\rangle\\} \\) basis and compute the probabilities for each outcome as a function of \\( \\theta \\).
+{Domain:} QUANTUM PHASE ESTIMATION"""
+    },
+
+    "Quantum Paradoxes": {
+        "description": "Generate a quantum physics problem focusing on Hardy's paradox or other quantum paradoxes illustrating non-classical phenomena.",
+        "template": """{Problem:} Hardy's paradox is a thought experiment that demonstrates non-classical correlations without probabilities adding up to one in certain measurement scenarios. 
+(a) Explain Hardy's paradox for a two-particle quantum system.
+(b) Design a quantum circuit to reproduce the experimental setup for Hardy's paradox.
+{Domain:} QUANTUM PARADOXES"""
+    },
+
+    "PennyLane Quantum Circuits": {
+        "description": "Generate a quantum physics problem involving the implementation of a quantum circuit using the PennyLane framework.",
+        "template": """{Problem:} Implement a quantum circuit in PennyLane that prepares the Bell state \\( |\\phi^+\\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle) \\) and measures the expectation value of \\( \\sigma_z \\otimes \\sigma_z \\).
+{Domain:} PENNYLANE QUANTUM CIRCUITS"""
+    },
+    
+    "PennyLane Circuit Analysis": {
+        "description":"Analyze a given PennyLane program and its corresponding quantum circuit diagram to describe its functionality.",
+        "template": """{Problem:} Given the following PennyLane program:} 
+        ```python
+import pennylane as qml
+import numpy as np
+dev = qml.device('default.qubit', wires=2)
+
+@qml.qnode(dev)
+def circuit(theta):
+    qml.Hadamard(wires=0)
+    qml.CNOT(wires=[0, 1])
+    qml.RZ(theta, wires=1)
+    return qml.expval(qml.PauliZ(1)) ``` 
+    Describe the quantum operations performed by this circuit. (b) Generate the corresponding quantum circuit diagram.
+ {Domain:} PENNYLANE CIRCUIT ANALYSIS"""
+    },
+    "Building Molecular Hamiltonian": {
+        "description": "Generate a quantum physics problem that involves constructing a molecular Hamiltonian for a given molecule using second quantization and quantum chemistry principles.",
+        "template": """{Problem:} Build the molecular Hamiltonian for a water molecule (H2O) using second quantization. Include both one-electron and two-electron integrals. Represent the Hamiltonian in matrix form.
+{Domain:} BUILDING MOLECULAR HAMILTONIAN"""
+    },
+    "Variational Quantum Eigensolver (VQE)": {
+        "description": "Generate a quantum physics problem that focuses on implementing and optimizing the variational quantum eigensolver (VQE) for a specific Hamiltonian.",
+        "template": """{Problem:} Implement a variational quantum eigensolver (VQE) to find the ground-state energy of the Hamiltonian:
+\\[
+H = -J \\sigma_1^z \\sigma_2^z + h (\\sigma_1^x + \\sigma_2^x),
+\\]
+where \\( J = 1.0 \\) and \\( h = 0.5 \\). Use a hardware-efficient Ansatz and evaluate its performance.
+{Domain:} VARIATIONAL QUANTUM EIGENSOLVER"""
+    },
+    "Subspace Search-Quantum Variational Quantum Eigensolver (SSVQE)": {
+        "description": "Generate a quantum physics problem that involves applying the subspace search quantum variational quantum eigensolver (SSVQE) to find multiple eigenstates of a Hamiltonian.",
+        "template": """{Problem:} Use the SSVQE approach to find the first three eigenstates of the Hamiltonian:
+\\[
+H = - \\sum_{i=1}^{N-1} J \\sigma_i^z \\sigma_{i+1}^z + h \\sum_{i=1}^N \\sigma_i^x,
+\\]
+where \\( J = 1.0 \\), \\( h = 0.5 \\), and \\( N = 4 \\). Design the Ansatz and cost function to achieve this.
+{Domain:} SUBSPACE SSVQE"""
+    },
+    "Variational Quantum State Diagonalization (VQSD)": {
+        "description": "Generate a quantum physics problem involving variational quantum state diagonalization (VQSD) to diagonalize a given quantum state or density matrix.",
+        "template": """{Problem:} Apply VQSD to diagonalize the density matrix \\( \\rho \\) of a two-qubit quantum system:
+\\[
+\\rho = \\frac{1}{2} \\begin{bmatrix}
+1 & 0.3 \\\\
+0.3 & 0.7
+\\end{bmatrix}.
+\\]
+Describe the Ansatz and optimization process required.
+{Domain:} VARIATIONAL QUANTUM STATE DIAGONALIZATION"""
+    },
+    "Gibbs State Preparation": {
+        "description": "Generate a quantum physics problem that focuses on preparing a Gibbs state for a given Hamiltonian and temperature.",
+        "template": """{Problem:} Prepare the Gibbs state for the Hamiltonian:
+\\[
+H = \\sigma^z + 0.5 \\sigma^x,
+\\]
+at a temperature \\( T = 0.5 \\). Use variational methods to approximate the state.
+{Domain:} GIBBS STATE PREPARATION"""
+    },
+    "The Classical Shadow of Unknown Quantum States": {
+        "description": "Generate a quantum physics problem involving the use of classical shadows to approximate properties of unknown quantum states.",
+        "template": """{Problem:} Use the classical shadow method to estimate the expectation value of the observable \\( \\sigma^z \\) for an unknown quantum state \\( |\\psi\\rangle \\). Explain the protocol and compute the sample complexity.
+{Domain:} CLASSICAL SHADOWS"""
+    },
+    "Estimation of Quantum State Properties Based on the Classical Shadow": {
+        "description": "Generate a quantum physics problem that involves estimating properties of quantum states using classical shadows.",
+        "template": """{Problem:} Estimate the purity \\( \\text{Tr}(\\rho^2) \\) of a quantum state \\( \\rho \\) using classical shadow techniques. Describe the measurement protocol and necessary post-processing.
+{Domain:} QUANTUM STATE PROPERTY ESTIMATION"""
+    },
+    "Hamiltonian Simulation with Product Formula": {
+        "description": "Generate a quantum physics problem that involves simulating the dynamics of a Hamiltonian using the product formula method.",
+        "template": """{Problem:} Simulate the time evolution of the Hamiltonian:
+\\[
+H = \\sigma^z + 0.5 \\sigma^x,
+\\]
+for time \\( t = 1.0 \\) using the first-order Trotter product formula. Calculate the approximation error.
+{Domain:} PRODUCT FORMULA SIMULATION"""
+    },
+    "Simulate the Spin Dynamics on a Heisenberg Chain": {
+        "description": "Generate a quantum physics problem focusing on simulating spin dynamics in a Heisenberg chain.",
+        "template": """{Problem:} Simulate the spin dynamics of a three-qubit Heisenberg chain with the Hamiltonian:
+\\[
+H = J \\sum_{i=1}^{2} (\\sigma_i^x \\sigma_{i+1}^x + \\sigma_i^y \\sigma_{i+1}^y + \\sigma_i^z \\sigma_{i+1}^z),
+\\]
+where \\( J = 1.0 \\). Calculate the time evolution of the initial state \\( |\\uparrow \\downarrow \\uparrow\\rangle \\).
+{Domain:} HEISENBERG CHAIN SIMULATION"""
+    },
+    "Distributed Variational Quantum Eigensolver Based on Schmidt Decomposition": {
+        "description": "Generate a quantum physics problem involving distributed VQE using Schmidt decomposition.",
+        "template": """{Problem:} Implement a distributed VQE algorithm to find the ground state of a bipartite system with the Hamiltonian:
+\\[
+H = \\sigma^z \\otimes \\sigma^z + 0.5 (\\sigma^x \\otimes I + I \\otimes \\sigma^x).
+\\]
+Use Schmidt decomposition to partition the system.
+{Domain:} DISTRIBUTED VQE"""
+    },
+    "Quantum Signal Processing and Quantum Singular Value Transformation": {
+        "description": "Generate a quantum physics problem involving quantum signal processing and singular value transformation.",
+        "template": """{Problem:} Design a quantum circuit to implement the quantum singular value transformation (QSVT) for the operator:
+\\[
+U = e^{-i H t},
+\\]
+where \\( H = \\sigma^z \\) and \\( t = 1.0 \\). Explain how QSVT can be used for Hamiltonian simulation.
+{Domain:} QSVT AND SIGNAL PROCESSING"""
+    },
+    "Hamiltonian Simulation with qDRIFT": {
+        "description": "Generate a quantum physics problem that involves simulating Hamiltonian dynamics using the qDRIFT method.",
+        "template": """{Problem:} Simulate the time evolution of the Hamiltonian:
+\\[
+H = \\sigma^z + 0.5 \\sigma^x,
+\\]
+for time \\( t = 2.0 \\) using the qDRIFT method. Estimate the sampling error and number of terms required.
+{Domain:} QDRIFT SIMULATION"""
+    },
+    "Quantum Phase Processing": {
+        "description": "Generate a quantum physics problem that focuses on quantum phase processing techniques.",
+        "template": """{Problem:} Apply quantum phase processing to amplify the signal of the eigenvalue \\( \\lambda = 0.5 \\) of the operator:
+\\[
+H = \\sigma^z.
+\\]
+Design a quantum circuit for the amplification.
+{Domain:} QUANTUM PHASE PROCESSING"""
+    },
+    "Variational Quantum Metrology": {
+        "description": "Generate a quantum physics problem involving variational quantum metrology to optimize quantum sensing.",
+        "template": """{Problem:} Use variational quantum metrology to estimate the parameter \\( \\theta \\) in the state:
+\\[
+|\\psi(\\theta)\\rangle = \\cos(\\theta/2)|0\\rangle + \\sin(\\theta/2)|1\\rangle.
+\\]
+Optimize the measurement settings to minimize the estimation error.
+{Domain:} VARIATIONAL QUANTUM METROLOGY"""
+    },
+ "Encoding Classical Data into Quantum States": {
+        "description": "Generate a quantum physics problem focusing on encoding classical data into quantum states for quantum computation.",
+        "template": """{Problem:} Encode the classical data vector \\( [1, 0, -1] \\) into a quantum state using amplitude encoding. Explain the process and construct the required quantum circuit.
+{Domain:} DATA ENCODING"""
+    },
+    "Quantum Classifier": {
+        "description": "Generate a quantum physics problem involving the implementation and optimization of a quantum classifier for machine learning tasks.",
+        "template": """{Problem:} Design a quantum classifier to distinguish between the quantum states \\( |0\\rangle \\) and \\( |1\\rangle \\) based on a variational Ansatz. Optimize the parameters to maximize classification accuracy.
+{Domain:} QUANTUM CLASSIFIER"""
+    },
+    "Variational Shadow Quantum Learning (VSQL)": {
+        "description": "Generate a quantum physics problem involving variational shadow quantum learning to approximate quantum state properties.",
+        "template": """{Problem:} Use the VSQL method to approximate the trace of the operator \\( H = \\sigma^z \\otimes \\sigma^z \\) for a two-qubit state. Explain the variational Ansatz and optimization process.
+{Domain:} VSQL"""
+    },
+    "Quantum Kernel Methods": {
+        "description": "Generate a quantum physics problem exploring the use of quantum kernel methods in machine learning.",
+        "template": """{Problem:} Develop a quantum kernel function to compute the similarity between the classical data points \\( x_1 = [1, 0] \\) and \\( x_2 = [0, 1] \\). Construct the quantum circuit for kernel evaluation and calculate the kernel value.
+{Domain:} QUANTUM KERNELS"""
+    },
+    "Quantum Autoencoder": {
+        "description": "Generate a quantum physics problem focusing on designing and training a quantum autoencoder to compress quantum data.",
+        "template": """{Problem:} Design a quantum autoencoder to compress a two-qubit quantum state \\( |\\psi\\rangle = \\frac{1}{\\sqrt{2}} (|00\\rangle + |11\\rangle) \\) into a single qubit. Describe the training process and Ansatz used.
+{Domain:} QUANTUM AUTOENCODER"""
+    },
+    "Quantum GAN": {
+        "description": "Generate a quantum physics problem that involves implementing a quantum generative adversarial network (GAN) for quantum data generation.",
+        "template": """{Problem:} Implement a quantum GAN to generate the quantum state \\( |\\psi\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |1\\rangle) \\). Describe the architecture of the generator and discriminator circuits and the training process.
+{Domain:} QUANTUM GAN"""
+    },
+    "Variational Quantum Singular Value Decomposition (VQSVD)": {
+        "description": "Generate a quantum physics problem that involves using VQSVD to approximate the singular value decomposition of a quantum operator.",
+        "template": """{Problem:} Apply VQSVD to find the singular value decomposition of the operator \\( A = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix} \\). Construct the variational Ansatz and describe the optimization process.
+{Domain:} VQSVD"""
+    },
+    "Data Encoding Analysis": {
+        "description": "Generate a quantum physics problem focusing on analyzing the efficiency and fidelity of different data encoding methods in quantum computation.",
+        "template": """{Problem:} Compare amplitude encoding and basis encoding for the classical vector \\( [1, 0, 1, 0] \\). Analyze the circuit depth and fidelity of each method.
+{Domain:} DATA ENCODING ANALYSIS"""
+    },
+    "Quantum Neural Network Approximating Functions": {
+        "description": "Generate a quantum physics problem involving a quantum neural network approximating a given function.",
+        "template": """{Problem:} Construct a quantum neural network to approximate the function \\( f(x) = \\sin(x) \\) for \\( x \\in [0, \\pi] \\). Use a variational Ansatz and optimize the parameters to minimize the error.
+{Domain:} QUANTUM NEURAL NETWORK"""
+    },
+    "Variational Quantum Amplitude Estimation": {
+        "description": "Generate a quantum physics problem that involves variational quantum amplitude estimation for a given probability distribution.",
+        "template": """{Problem:} Use variational quantum amplitude estimation to estimate the amplitude \\( \\alpha \\) in the state \\( \\sqrt{\\alpha}|0\\rangle + \\sqrt{1-\\alpha}|1\\rangle \\). Design the Ansatz and describe the optimization process.
+{Domain:} VARIATIONAL AMPLITUDE ESTIMATION"""
+    },
+      "Quantum Approximation Optimization Algorithm (QAOA)": {
+        "description": "Generate a quantum physics problem focusing on implementing the Quantum Approximation Optimization Algorithm (QAOA) to solve combinatorial optimization problems.",
+        "template": """{Problem:} Implement QAOA to find the ground state of the cost Hamiltonian \\( H_C = Z_1 Z_2 + Z_2 Z_3 \\) for a three-qubit system. Describe the Ansatz and the optimization of the variational parameters \\( \\gamma \\) and \\( \\beta \\).
+{Domain:} QAOA"""
+    },
+    "Solving Max-Cut Problem with QAOA": {
+        "description": "Generate a quantum physics problem that uses QAOA to solve the Max-Cut problem on a given graph.",
+        "template": """{Problem:} Solve the Max-Cut problem for a graph with three vertices and two edges \\( (1, 2), (2, 3) \\) using QAOA. Construct the cost Hamiltonian \\( H_C \\), prepare the initial state, and describe the variational optimization process.
+{Domain:} MAX-CUT QAOA"""
+    },
+    "Large-scale QAOA via Divide-and-Conquer": {
+        "description": "Generate a quantum physics problem exploring the application of divide-and-conquer techniques to scale QAOA for large problem instances.",
+        "template": """{Problem:} Apply the divide-and-conquer approach to solve a Max-Cut problem on a graph with six vertices. Decompose the graph into two smaller subgraphs, solve them individually using QAOA, and combine the solutions to find the global Max-Cut.
+{Domain:} LARGE-SCALE QAOA"""
+    },
+    "Travelling Salesman Problem": {
+        "description": "Generate a quantum physics problem involving the application of quantum algorithms, such as QAOA or Grover's search, to solve the Travelling Salesman Problem.",
+        "template": """{Problem:} Solve the Travelling Salesman Problem (TSP) for four cities \\( A, B, C, D \\) with the distance matrix:
+\\[
+\\begin{bmatrix}
+0 & 2 & 9 & 10 \\\\
+1 & 0 & 6 & 4 \\\\
+15 & 7 & 0 & 8 \\\\
+6 & 3 & 12 & 0
+\\end{bmatrix}
+\\]
+Use QAOA to minimize the total travel distance. Construct the cost Hamiltonian and describe the optimization of variational parameters.
+{Domain:} TSP QAOA"""
+    },
+    "Jordan-Wigner Transformations": {
+    "description": "Design problems using Jordan-Wigner transformations to map spin models to fermionic systems.",
+    "template": """{Problem:} Jordan-Wigner transformations are used to transform spin models into fermionic representations.
+(a) Derive the Jordan-Wigner transformation for a 1D XXZ spin chain.
+(b) Discuss the implications of non-locality introduced by string operators in the transformation.
+{Domain:} SPIN-FERMION MAPPINGS"""
+  },
+  "Bethe Ansatz Application": {
+    "description": "Problems on solving the Heisenberg spin chain spectrum using the Bethe Ansatz.",
+    "template": """{Problem:} The Bethe Ansatz is a key method for solving the spectrum of the Heisenberg spin chain. 
+(a) Derive the energy spectrum for the XXZ spin chain using the Bethe Ansatz for a system with periodic boundary conditions.
+(b) Discuss the implications of magnon scattering phases in determining the chain's spectrum.
+{Domain:} INTEGRABLE SYSTEMS"""
+  },
+  "Generalized Spin Chain Compression": {
+    "description": "Design problems related to compressing quantum circuits using the Yang-Baxter equation for various spin chain models, including the generalized XYZ Heisenberg model and its variations.",
+    "template": """{Problem:} Generalized spin chain models, such as the XYZ Heisenberg model, include interactions along all spatial directions, often coupled with external fields or anisotropic interactions. These features present unique challenges for compressing quantum circuits using the Yang-Baxter equation.
+(a) Analyze the conditions under which a generalized spin chain model (e.g., XYZ or XXZ with external fields) resists compression using the Yang-Baxter equation.
+(b) Explore potential modifications to the Hamiltonian or circuit representation (e.g., introducing symmetries or reparametrizing coupling constants) that might render the model compressible.
+(c) Evaluate the computational trade-offs introduced by these modifications in terms of circuit depth and fidelity.
+{Domain:} SPIN CHAIN MODELS"""
+  },
+    "Wave-Particle Duality": {
+        "description": "Generate a quantum mechanics problem illustrating the dual nature of particles and waves, focusing on the photoelectric effect and Compton scattering.",
+        "template": """{Problem:} Discuss how the photoelectric effect supports the particle nature of light.
+(a) Calculate the maximum kinetic energy of emitted electrons when light of frequency f strikes a metallic surface with work function W.
+(b) Derive the Compton wavelength shift formula for photons scattering off free electrons.
+{Domain:} WAVE-PARTICLE DUALITY"""
+    },
+    "Uncertainty Principle": {
+        "description": "Develop a problem involving Heisenberg's uncertainty principle and its implications for the ground state energy of quantum systems.",
+        "template": """{Problem:} Using the uncertainty principle, derive an expression for the minimum energy of a particle confined in a one-dimensional infinite potential well of width L.
+(a) Calculate the ground-state energy for an electron in such a well with L = 1 nm.
+(b) Discuss the implications for quantum confinement in nanoscale devices.
+{Domain:} UNCERTAINTY PRINCIPLE"""
+    },
+    "Perturbation Theory": {
+        "description": "Formulate a problem using time-independent perturbation theory to analyze the correction of energy levels in a perturbed quantum harmonic oscillator.",
+        "template": """{Problem:} A quantum harmonic oscillator is subjected to a perturbation V(x) = λx^4.
+(a) Using first-order perturbation theory, calculate the energy correction to the ground state.
+(b) Discuss the physical implications of the perturbation on the potential shape.
+{Domain:} PERTURBATION THEORY"""
+    },
+    "Angular Momentum": {
+        "description": "Create a problem exploring angular momentum eigenstates and their addition rules in quantum systems.",
+        "template": """{Problem:} Two particles have spins S1 = 1 and S2 = 1/2.
+(a) Determine the possible total spin states using the addition of angular momentum.
+(b) Write down the Clebsch-Gordan coefficients for these states.
+{Domain:} ANGULAR MOMENTUM"""
+    },
+    "Hydrogen Atom": {
+        "description": "Design a problem focusing on the quantization of energy levels in the hydrogen atom and transitions between them.",
+        "template": """{Problem:} Calculate the wavelength of the photon emitted during a transition from n=3 to n=2 in a hydrogen atom.
+(a) Use the Rydberg formula for hydrogen to verify the Balmer series.
+(b) Discuss the physical significance of this transition in spectroscopy.
+{Domain:} HYDROGEN ATOM"""
+    },
+    "Scattering Theory": {
+        "description": "Develop a problem involving quantum scattering and phase shifts using the Born approximation.",
+        "template": """{Problem:} A particle of mass m and energy E scatters off a potential V(r) = V0 exp(-r/a).
+(a) Use the Born approximation to calculate the scattering amplitude.
+(b) Discuss the physical interpretation of the phase shift in the low-energy limit.
+{Domain:} SCATTERING THEORY"""
+    },
+    "Quantum Tunneling": {
+        "description": "Create a problem analyzing tunneling phenomena through potential barriers using the WKB approximation.",
+        "template": """{Problem:} Derive the tunneling probability for a particle encountering a potential barrier of height V0 and width d using the WKB approximation.
+(a) Apply the formula to an electron with E = 5 eV tunneling through a barrier with V0 = 10 eV and d = 1 nm.
+(b) Explain the implications of this for alpha decay in nuclear physics.
+{Domain:} QUANTUM TUNNELING"""
+    },
+    "Entanglement": {
+        "description": "Formulate a problem on the concept of quantum entanglement and its applications in quantum communication.",
+        "template": """{Problem:} Two qubits are entangled in the state |ψ⟩ = (|00⟩ + |11⟩)/√2.
+(a) Calculate the reduced density matrix for one qubit.
+(b) Discuss the significance of the von Neumann entropy for this state.
+{Domain:} QUANTUM ENTANGLEMENT"""
+    },
+    "Time Evolution": {
+        "description": "Generate a problem analyzing time evolution in quantum mechanics using the Schrödinger equation.",
+        "template": """{Problem:} A particle is initially in a superposition state |ψ(0)⟩ = (|1⟩ + |2⟩)/√2, where |1⟩ and |2⟩ are energy eigenstates with energies E1 and E2.
+(a) Derive the time-evolved state |ψ(t)⟩.
+(b) Calculate the probability of measuring the particle in state |1⟩ at time t.
+{Domain:} TIME EVOLUTION"""
+    },
+    "Quantum Measurement": {
+        "description": "Develop a problem focusing on quantum measurement theory and wavefunction collapse.",
+        "template": """{Problem:} A spin-1/2 particle is prepared in the state |ψ⟩ = α|↑⟩ + β|↓⟩.
+(a) If a measurement of Sz is performed, calculate the probabilities of outcomes ±ħ/2.
+(b) Discuss the implications of wavefunction collapse in the context of this measurement.
+{Domain:} QUANTUM MEASUREMENT"""
+    },
+    "Quantum Harmonic Oscillator": {
+        "description": "Generate a problem analyzing the energy eigenvalues and wavefunctions of the quantum harmonic oscillator.",
+        "template": """{Problem:} Solve the Schrödinger equation for the quantum harmonic oscillator and derive the energy eigenvalues.
+(a) Show that the ground state wavefunction is a Gaussian.
+(b) Calculate the expectation value of the position operator in the first excited state.
+{Domain:} QUANTUM HARMONIC OSCILLATOR"""
+    },
+    "Spin-Orbit Coupling": {
+        "description": "Develop a problem exploring the spin-orbit interaction in atomic systems.",
+        "template": """{Problem:} Derive the form of the spin-orbit coupling term in the hydrogen atom.
+(a) Calculate the energy shift caused by spin-orbit coupling for the n=2 level.
+(b) Discuss its significance in the fine structure of spectral lines.
+{Domain:} SPIN-ORBIT COUPLING"""
+    },
+    "Quantum Zeno Effect": {
+        "description": "Create a problem that demonstrates the quantum Zeno effect and its experimental implications.",
+        "template": """{Problem:} A quantum system is prepared in a superposition state and repeatedly measured at time intervals Δt.
+(a) Derive the probability of finding the system in its initial state after n measurements.
+(b) Discuss the implications of the quantum Zeno effect on the decay of unstable systems.
+{Domain:} QUANTUM ZENO EFFECT"""
+    },
+    "Quantum Gates": {
+        "description": "Formulate a problem involving quantum gates and their implementation in quantum circuits.",
+        "template": """{Problem:} Construct a quantum circuit using Hadamard and CNOT gates to create a Bell state.
+(a) Write the unitary matrix representation of this circuit.
+(b) Explain the significance of this state in quantum communication protocols.
+{Domain:} QUANTUM GATES"""
+    },
+    "Adiabatic Theorem": {
+        "description": "Design a problem demonstrating the adiabatic theorem and its application to quantum systems.",
+        "template": """{Problem:} A particle is in the ground state of a slowly varying potential V(x, t).
+(a) Use the adiabatic theorem to argue why the system remains in the instantaneous ground state.
+(b) Discuss the breakdown of the adiabatic approximation for rapid changes in V(x, t).
+{Domain:} ADIABATIC THEOREM"""
+    },
+    "Bell Inequalities": {
+        "description": "Generate a problem testing Bell inequalities in quantum mechanics.",
+        "template": """{Problem:} Consider a system of two entangled spin-1/2 particles. Derive the CHSH inequality for the system.
+(a) Show how quantum mechanics predicts a violation of this inequality.
+(b) Discuss the implications for local hidden variable theories.
+{Domain:} BELL INEQUALITIES"""
+    },
+    "Superposition Principle": {
+        "description": "Create a problem exploring the principle of superposition in quantum mechanics.",
+        "template": """{Problem:} A particle in a 1D infinite potential well is in a superposition of the first two energy eigenstates.
+(a) Write the time-dependent wavefunction of the system.
+(b) Calculate the probability density and discuss its periodicity.
+{Domain:} SUPERPOSITION PRINCIPLE"""
+    },
+    "Quantum Decoherence": {
+        "description": "Formulate a problem examining quantum decoherence and its effects on quantum systems.",
+        "template": """{Problem:} A qubit interacts with its environment modeled as a thermal bath.
+(a) Derive the master equation governing the reduced density matrix of the qubit.
+(b) Discuss the loss of coherence in the off-diagonal elements of the density matrix.
+{Domain:} QUANTUM DECOHERENCE"""
+    },
+    "Topological Quantum States": {
+        "description": "Develop a problem on topological quantum states and their robustness against local perturbations.",
+        "template": """{Problem:} Consider a quantum system with a non-trivial topological phase.
+(a) Calculate the Chern number for a 2D electron gas in a magnetic field.
+(b) Discuss the physical significance of topologically protected edge states.
+{Domain:} TOPOLOGICAL QUANTUM STATES"""
+    },
+    "Quantum Cryptography": {
+        "description": "Generate a problem analyzing the principles of quantum cryptography.",
+        "template": """{Problem:} Explain the BB84 protocol for quantum key distribution.
+(a) Calculate the error rate threshold for secure communication in the presence of an eavesdropper.
+(b) Discuss the role of entanglement in quantum cryptographic protocols.
+{Domain:} QUANTUM CRYPTOGRAPHY"""
+    },
+    "Quantum Eraser": {
+        "description": "Design a problem on the quantum eraser experiment and its implications for wave-particle duality.",
+        "template": """{Problem:} In a double-slit experiment with a quantum eraser, analyze the interference pattern.
+(a) Derive the conditions under which interference fringes are observed.
+(b) Discuss the delayed-choice quantum eraser and its implications for causality.
+{Domain:} QUANTUM ERASER"""
+    },
+    "Quantum Teleportation": {
+        "description": "Formulate a problem demonstrating the principles of quantum teleportation.",
+        "template": """{Problem:} Alice and Bob share an entangled pair of qubits. Alice wishes to teleport an unknown quantum state to Bob.
+(a) Write down the quantum circuit for the teleportation protocol.
+(b) Discuss the role of classical communication in completing the protocol.
+{Domain:} QUANTUM TELEPORTATION"""
+    },
+    "Path Integral Formulation": {
+        "description": "Create a problem utilizing the path integral formulation of quantum mechanics.",
+        "template": """{Problem:} Derive the propagator for a free particle using the path integral approach.
+(a) Discuss the significance of the classical action in the path integral formulation.
+(b) Compare the result with the propagator derived from the Schrödinger equation.
+{Domain:} PATH INTEGRAL FORMULATION"""
+    },
+    "Quantum Annealing": {
+        "description": "Generate a problem analyzing the principles of quantum annealing for optimization problems.",
+        "template": """{Problem:} Describe the quantum annealing process for solving the Ising model.
+(a) Derive the time-dependent Hamiltonian used in quantum annealing.
+(b) Discuss the role of tunneling in escaping local minima during the annealing process.
+{Domain:} QUANTUM ANNEALING"""
+    },
+    "Berry Phase": {
+        "description": "Develop a problem on the geometric phase in quantum systems.",
+        "template": """{Problem:} A quantum system evolves adiabatically around a closed loop in parameter space.
+(a) Derive the expression for the Berry phase acquired by the system.
+(b) Discuss an example where the Berry phase has observable consequences.
+{Domain:} BERRY PHASE"""
+    },
+    "Quantum Cloning": {
+        "description": "Formulate a problem exploring the no-cloning theorem in quantum mechanics.",
+        "template": """{Problem:} Prove the no-cloning theorem for arbitrary quantum states.
+(a) Discuss why cloning is forbidden in the context of the linearity of quantum mechanics.
+(b) Explore the implications of this theorem for quantum communication.
+{Domain:} QUANTUM CLONING"""
+    },
+    "Density Matrix Formalism": {
+        "description": "Create a problem utilizing the density matrix formalism to describe mixed states.",
+        "template": """{Problem:} A two-level quantum system is described by the density matrix ρ.
+(a) Calculate the purity of the state and interpret its physical meaning.
+(b) Discuss the evolution of ρ under a unitary transformation.
+{Domain:} DENSITY MATRIX FORMALISM"""
+    },
+    "Quantum Computation": {
+        "description": "Generate a problem involving basic concepts of quantum computation.",
+        "template": """{Problem:} Implement the Deutsch-Jozsa algorithm for a quantum oracle.
+(a) Write down the steps of the algorithm and the required quantum circuit.
+(b) Discuss the computational advantage over classical methods.
+{Domain:} QUANTUM COMPUTATION"""
+    },
+    "Relativistic Quantum Mechanics": {
+        "description": "Develop a problem on the Klein-Gordon or Dirac equations.",
+        "template": """{Problem:} Solve the Klein-Gordon equation for a free particle.
+(a) Derive the relativistic energy-momentum relation from the equation.
+(b) Discuss the significance of negative energy solutions.
+{Domain:} RELATIVISTIC QUANTUM MECHANICS"""
+    },
+    "Quantum Field Theory": {
+        "description": "Create a problem introducing basic concepts of quantum field theory.",
+        "template": """{Problem:} Quantize the scalar field and derive the commutation relations for the field operators.
+(a) Discuss the role of creation and annihilation operators.
+(b) Explain the physical interpretation of the vacuum state.
+{Domain:} QUANTUM FIELD THEORY"""
+    }
+}
+
+
+
+
+stage3_prompt = ("You are a math-solving assistant. You will be presented with a math problem and a proposed solution. Your task is to determine if the provided solution is correct. "
+          "If the solution is correct, confirm it with a detailed explanation. If the solution is incorrect, identify the errors and provide a full corrected solution using the "
+          "TORA framework: Think—understand and restate the problem, identifying key details; Organize—break it into manageable steps; Reason—solve systematically, showing all "
+          "intermediate steps and calculations; and Answer—present the final solution clearly and concisely. Always use Chain of Thought reasoning to ensure logical progression "
+          "and clarity. Here is an example: \n\n"
+          "Problem: A train travels 120 miles in 2 hours. What is its average speed?\n"
+          "Proposed Solution: The average speed is 70 mph.\n"
+          "Analysis: The solution is incorrect. Think: Speed is distance divided by time. The distance is 120 miles, and the time is 2 hours. Organize: Write the formula "
+          "Speed = Distance / Time. Reason: Substitute the values, Speed = 120 / 2 = 60 mph. Answer: The correct average speed is 60 mph.\n\n"
+          "Now analyze the following problem and solution:\n\n"
+          "Problem: [Insert Problem Here]\n"
+          "Proposed Solution: [Insert Proposed Solution Here]")
+
+
+

Q_quantum_utils.py

@@ -0,0 +1,625 @@
+"""
+Quantum Physics Problem Generator
+Shlomo Kashani 
+
+Description:
+------------
+This module is part of the QuantumLLMInstruct system, designed to generate and solve quantum physics problems 
+using advanced Large Language Models (LLMs). It utilizes a multi-stage pipeline for problem generation, 
+solution generation, and database management.
+
+Core Functionalities:
+---------------------
+1. **Problem Generation**:
+   - Generates quantum physics problems in LaTeX format using LLMs.
+   - Supports domain-specific problem generation across multiple quantum fields.
+
+2. **Solution Generation**:
+   - Provides step-by-step LaTeX solutions for the generated problems using a second LLM.
+
+3. **Data Management**:
+   - Stores generated problems and solutions in DuckDB and Parquet files.
+   - Enables exporting data in Parquet format for scalability and compatibility.
+
+4. **Gradio Interface**:
+   - A user-friendly interface to interact with the system, including problem generation, 
+     solution generation, and database exploration.
+
+5. **Hugging Face Integration**:
+   - Supports visualization and interaction with the dataset on the Hugging Face platform.
+
+Main Components:
+----------------
+- **initialize_duckdb() / initialize_parquet()**: Initializes the database schema.
+- **generate_multiple_problems()**: Generates multiple problems for the selected quantum domains.
+- **generate_solutions()**: Solves unsolved problems in the database.
+- **export_parquet()**: Exports the database to a Parquet file for external use.
+
+Dependencies:
+-------------
+- Python 3.7+
+- Transformers: `transformers`
+- DuckDB: `duckdb`
+- Gradio: `gradio`
+- Pandas: `pandas`
+"""
+
+import numpy as np
+import random
+import io
+import duckdb
+import math
+from datetime import datetime
+import PIL
+from PIL import Image
+import pennylane as qml
+import base64
+import platform
+from math import pi
+import pandas as pd 
+import os 
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import tqdm 
+import duckdb
+from tqdm import tqdm
+import uuid
+import random
+import sympy
+from datetime import datetime
+
+from Q_llm_prompts import * 
+
+# Predefined Qwen models
+# Qwen2.5 offers multiple model sizes, including 72B, 32B, 14B, 7B, 3B, 1.5B, 0.5B, etc.
+# You can choose the appropriate model based on your needs and GPU memory size
+model_options = [
+    "Qwen/Qwen2.5-Coder-1.5B-Instruct",
+    "Qwen/Qwen2.5-Coder-3B-Instruct",
+    "Qwen/Qwen2.5-Coder-7B-Instruct",
+    "Qwen/Qwen2.5-Math-7B-Instruct",
+    "Qwen/Qwen2.5-Coder-32B-Instruct",
+    "meta-llama/Llama-3.2-3B-Instruct"
+    # "unsloth/Qwen2.5-Math-7B-Instruct",
+    # "unsloth/Llama-3.2-3B-Instruct-bnb-4bit",
+    # "nvidia/OpenMath-CodeLlama-7b-Python-hf" tokenizer.chat_template is not set and no template argument was passed! 
+]
+
+solutions_model_options = model_options
+
+# Load default model and tokenizer
+selected_model = model_options[0]
+model = AutoModelForCausalLM.from_pretrained(
+    selected_model,
+    torch_dtype="auto",
+    device_map="auto"
+)
+tokenizer = AutoTokenizer.from_pretrained(selected_model)
+solution_model = selected_model
+solution_tokenizer =tokenizer
+solution_model_instance =model
+
+# Function to reload the model when selection changes
+def reload_model(model_name):
+    global model, tokenizer
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        torch_dtype="auto",
+        device_map="auto"
+    )
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    return f"Model loaded: {model_name}"
+
+
+
+# Define a Pennylane device
+dev = qml.device('default.qubit', wires=10)
+
+# Detect platform-specific device
+def is_mac_os():
+    return platform.system() == 'Darwin'
+
+device = 'cpu' if is_mac_os() else 'cuda'
+
+RESPONSE_SOLUTION_LLM_SYS_PROMPT = "You are an expert in quantum physics and provide detailed solutions in plain text. All mathematical equations and symbols must strictly be in LaTeX."
+RESPONSE_SOLUTION_LLM_USR_PROMPT = """
+Provide a complete solution to the following quantum physics problem in plain text format:
+{problem}
+"""
+
+# Parquet file setup
+PARQUET_FILE = 'quantum_problems.parquet'
+
+def initialize_parquet():
+    """Initialize Parquet file with the required schema if it doesn't exist."""
+    if not os.path.exists(PARQUET_FILE):
+        data = {
+            "uuid": [],
+            "timestamp": [],
+            "problem": [],
+            "sub_domain": [],
+            "main_domain": [],
+            "model_name": [],
+            "solution": [],
+            "solution_model_name": []
+        }
+        df = pd.DataFrame(data)
+        df.to_parquet(PARQUET_FILE, index=False)
+        print("Initialized Parquet file with schema.")
+
+def load_parquet():
+    """Load data from the Parquet file."""
+    if os.path.exists(PARQUET_FILE):
+        return pd.read_parquet(PARQUET_FILE)
+    else:
+        initialize_parquet()
+        return pd.read_parquet(PARQUET_FILE)
+
+def save_parquet(df):
+    """Save DataFrame to Parquet file."""
+    df.to_parquet(PARQUET_FILE, index=False)
+
+def insert_problem_pqt(uuid, timestamp, problem, main_domain, sub_domain, model_name, solution=None, solution_model_name=None):
+    """Insert a new problem into the Parquet file."""
+    df = load_parquet()
+    new_row = {
+        "uuid": uuid,
+        "timestamp": timestamp,
+        "problem": problem,
+        "sub_domain": sub_domain,
+        "main_domain": main_domain,
+        "model_name": model_name,
+        "solution": solution,
+        "solution_model_name": solution_model_name
+    }
+    df = pd.concat([df, pd.DataFrame([new_row])], ignore_index=True)
+    save_parquet(df)
+
+def update_solution_pqt(uuid, solution, solution_model_name):
+    """Update the solution for a given problem UUID."""
+    df = load_parquet()
+    df.loc[df["uuid"] == uuid, ["solution", "solution_model_name"]] = solution, solution_model_name
+    save_parquet(df)
+
+
+# DuckDB setup
+DB_FILE = 'quantum_problems.duckdb'
+
+def initialize_duckdb():
+    conn = duckdb.connect(database=DB_FILE)
+
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS problems (
+           uuid TEXT UNIQUE NOT NULL,
+            timestamp TEXT,
+            problem TEXT,
+            sub_domain TEXT,
+            main_domain TEXT,
+            model_name TEXT,
+            solution TEXT,
+            solution_model_name TEXT
+        )
+    """)
+    # print ("Created schema")
+    # df = conn.execute("SELECT * FROM problems").df()
+    # print (df.count)
+    conn.close()
+
+# Function to buffer the plot and return as PIL image
+def buffer_plot_and_get(fig):
+    buf = io.BytesIO()
+    fig.savefig(buf, format='png')
+    buf.seek(0)
+    return PIL.Image.open(buf)
+
+# Store image in bytes for DuckDB
+def pil_image_to_bytes(image):
+    img_byte_arr = io.BytesIO()
+    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 = []
+    for _ in range(random.randint(1, 5)):
+        coeff = round(random.uniform(-1, 1), 2)
+        pauli_ops = [random.choice(['I', 'X', 'Y', 'Z']) for _ in range(num_qubits)]
+        term = f"{coeff} * {' '.join(pauli_ops)}"
+        terms.append(term)
+    return " + ".join(terms)
+
+# Function to convert Hamiltonian to QASM code
+def hamiltonian_to_qasm(hamiltonian, num_qubits):
+    qasm_code = f"OPENQASM 2.0;\ninclude \"qelib1.inc\";\nqreg q[{num_qubits}];\n"
+    rotations = {i: 0.0 for i in range(num_qubits)}
+    terms = hamiltonian.split(" + ")
+    
+    for term in terms:
+        coeff, paulis = term.split(" * ")
+        paulis = paulis.split()
+        coeff = float(coeff)
+
+        for i, pauli in enumerate(paulis):
+            if pauli == "X":
+                qasm_code += f"x q[{i}];\n"
+            elif pauli == "Y":
+                qasm_code += f"ry(pi/2) q[{i}];\n"
+            elif pauli == "Z":
+                rotations[i] += coeff
+
+    for i, angle in rotations.items():
+        if angle != 0:
+            angle_degrees = round(angle * 180 / math.pi, 2)
+            qasm_code += f"rz({angle_degrees}) q[{i}];\n"
+    
+    return qasm_code
+
+# 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
+    
+    @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 circuit
+
+# # Store data in DuckDB
+# def store_in_duckdb(data, db_file='quantum_hamiltonians.duckdb'):
+#     conn = duckdb.connect(database=db_file)
+#     conn.execute("""CREATE TABLE IF NOT EXISTS hamiltonians (
+#         id INTEGER,
+#         plot BLOB,
+#         hamiltonian VARCHAR,
+#         qasm_code VARCHAR,
+#         trotter_code VARCHAR,
+#         num_qubits INTEGER,
+#         trotter_order INTEGER,
+#         timestamp TIMESTAMP
+#     )""")
+#     conn.executemany("""INSERT INTO hamiltonians (id, plot, hamiltonian, qasm_code, trotter_code, num_qubits, trotter_order, timestamp)
+#                         VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", data)
+#     conn.close()
+
+# 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()
+    conn.close()
+
+    # Convert results to HTML with images
+    html_content = []
+    for index, row in df.iterrows():
+        plot_blob = row['plot']
+        encoded_img = encode_image_from_blob(plot_blob)
+
+        html_content.append(f"""
+            <table style='width: 100%; border-collapse: collapse; margin: 10px;'>
+                <tr>
+                    <td style='width: 30%; text-align: center;'>
+                        <h3>Circuit {index + 1}</h3>
+                        {encoded_img}  <!-- Display the image -->
+                    </td>        
+                    <td style='padding: 10px;'>
+                        <table style='width: 100%; border-collapse: collapse;'>
+                            <tr>
+                                <td><strong>Hamiltonian:</strong></td><td>{row['hamiltonian']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>QASM Representation:</strong></td><td>{row['qasm_code']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>Trotter Decomposition:</strong></td><td>{row['trotter_code']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>Number of Qubits:</strong></td><td>{row['num_qubits']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>Trotter Order:</strong></td><td>{row['trotter_order']}</td>
+                            </tr>
+                            <tr>
+                                <td><strong>Timestamp:</strong></td><td>{row['timestamp']}</td>
+                            </tr>
+                        </table>
+                    </td>
+                </tr>
+            </table>
+        """)
+
+    return "".join(html_content)
+
+# Function to generate Hamiltonians
+def generate_hamiltonians(num_hamiltonians, selected_qubits, selected_order):
+    results_table = []
+    timestamp = str(datetime.now())
+
+    for i in range(num_hamiltonians):
+        num_qubits = random.choice(selected_qubits)
+        order = selected_order
+        hamiltonian = generate_random_hamiltonian(num_qubits)
+        qasm_code = hamiltonian_to_qasm(hamiltonian, num_qubits)
+        trotter_code = trotter_decomposition(hamiltonian, order)
+
+        # 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)
+
+        # Append data to results table
+        results_table.append((i + 1, circuit_plot_bytes, hamiltonian, qasm_code, trotter_code, num_qubits, order, timestamp))
+
+
+# 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)
+
+# def export_parquet(db_file):
+#     """Export DuckDB table to a Parquet file using COPY."""
+#     try:
+#         conn = duckdb.connect(database=db_file)
+#         parquet_file = f"quantum_problems_{datetime.now().strftime('%Y%m%d_%H%M%S')}.parquet"
+#         conn.execute(f"COPY problems TO '{parquet_file}' (FORMAT PARQUET);")
+#         conn.close()
+#         return f"Data successfully exported to Parquet file: {parquet_file}"
+#     except Exception as e:
+#         return f"Error exporting to Parquet: {e}"
+
+def export_parquet(db_file):
+    """Export DuckDB table to a Parquet file using COPY."""
+    try:
+        conn = duckdb.connect(database=db_file)
+        parquet_file = f"quantum_problems_{datetime.now().strftime('%Y%m%d_%H%M%S')}.parquet"
+        conn.execute(f"""
+            COPY (
+                SELECT 
+                    uuid,
+                    CAST(timestamp AS VARCHAR) AS timestamp, 
+                    problem, 
+                    sub_domain, 
+                    main_domain, 
+                    model_name, 
+                    solution, 
+                    solution_model_name
+                FROM problems
+            ) TO '{parquet_file}' (FORMAT PARQUET);
+        """)
+        conn.close()
+        df = pd.read_parquet(parquet_file)
+        df['timestamp'] = df['timestamp'].astype(str)                
+        df.to_parquet(parquet_file, index=False)
+
+        return f"Data successfully exported to Parquet file: {parquet_file}"
+    except Exception as e:
+        return f"Error exporting to Parquet: {e}"
+
+def generate_dynamic_prompt(selected_domains):
+    if not selected_domains:
+        raise ValueError("No domains selected. Please select at least one domain.")
+    # Select a single domain randomly
+    selected_domain = random.choice(selected_domains)
+    print("Selected Domain:", selected_domain)
+    # Retrieve the description and template
+    domain_details = quantum_problem_domains[selected_domain]
+    domain_description = domain_details["description"]
+    example_output = domain_details["template"]
+    RESPONSE_INSTRUCTION_LLM_PROMPT = f"""
+            Generate a single detailed quantum physics problem for an exam in LaTeX format. Do not solve the problem. 
+            Do not include additional explanations or comments outside of LaTeX, and avoid unnecessary LaTeX imports (e.g., \\documentclass{{}}, \\usepackage{{}}, or \\begin{{document}}). 
+            All mathematical equations and symbols must strictly be in LaTeX. 
+            Your response must strictly follow this provided format:
+            1) {{Problem:}} Clearly define the quantum physics problem here, using mathematical precision and LaTeX formatting. Provide any equations or detailed descriptions necessary for students to understand and solve the problem.
+            2) {{Domain:}} Provide a concise two-word domain description in CAPS such as "ISING HAMILTONIAN".
+            Do not solve the problem!. The problem must strictly adhere to one and only one of the following domain types:
+            {domain_description}
+            Example Response Output:
+            {example_output}
+            """
+    return RESPONSE_INSTRUCTION_LLM_PROMPT, selected_domain
+
+# Function to generate a quantum physics problem
+def generate_problem(pair_id, model_name, selected_domains):
+    try:
+        prompt, selected_domain = generate_dynamic_prompt(selected_domains)
+    
+        messages = [
+            {"role": "system", "content": "You are a quantum physics professor and an expert in quantum computing."},
+            {"role": "user", "content": prompt}
+        ]
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+        generated_ids = model.generate(
+            **model_inputs,
+            max_new_tokens=10024
+        )
+        generated_ids = [
+            output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+        ]
+        response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+
+        if "{Problem:}" not in response or "{Domain:}" not in response:
+            raise ValueError(f"Generated problem does not match the expected format. Response:\n{response}")
+
+        problem = response.split("{Problem:}")[1].split("{Domain:}")[0].strip()
+        sub_domain = response.split("{Domain:}")[1].strip()      
+
+        # Insert the problem into DuckDB
+        conn = duckdb.connect(database=DB_FILE)
+        conn.execute("""
+            INSERT INTO problems (uuid, timestamp, problem, main_domain, sub_domain, model_name)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (str(uuid.uuid4()), datetime.now().isoformat(), problem, selected_domain, sub_domain, model_name.split("/")[-1]))
+        conn.close()
+        
+        # print(response)
+        return response
+    except Exception as e:
+        print(f"Error generating problem {pair_id}: {e}")
+        return None
+
+# Generate multiple problems with progress
+def generate_multiple_problems(num_pairs, selected_domains):
+    if not selected_domains:
+        return "Please select at least one domain type."
+        
+    conn = duckdb.connect(database=DB_FILE)
+    current_count = conn.execute("SELECT COUNT(*) FROM problems").fetchone()[0]
+    conn.close()
+
+    responses = []
+    with tqdm(total=num_pairs, desc="Generating Problems", unit="problem") as pbar:
+        for i in range(num_pairs):
+            response = generate_problem(current_count + i + 1, selected_model, selected_domains)
+            if response:
+                responses.append(response)
+            pbar.update(1)
+    return "\n\n".join(responses)
+
+def generate_solutions_pqt(solution_model_name):
+    df = load_parquet()
+    unsolved_problems = df[df["solution"].isna()]
+
+    if unsolved_problems.empty:
+        return "No unsolved problems found in the database."
+
+    with tqdm(total=len(unsolved_problems), desc="Generating Solutions", unit="solution") as pbar:
+        for _, row in unsolved_problems.iterrows():
+            try:
+                solution_prompt = RESPONSE_SOLUTION_LLM_USR_PROMPT.format(problem=row["problem"])
+                
+                messages = [
+                    {"role": "system", "content": RESPONSE_SOLUTION_LLM_SYS_PROMPT},
+                    {"role": "user", "content": solution_prompt}
+                ]
+                text = solution_tokenizer.apply_chat_template(
+                    messages,
+                    tokenize=False,
+                    add_generation_prompt=True
+                )
+                model_inputs = solution_tokenizer([text], return_tensors="pt").to(solution_model_instance.device)
+
+                generated_ids = solution_model_instance.generate(
+                    **model_inputs,
+                    max_new_tokens=10024
+                )
+                generated_ids = [
+                    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+                ]
+                solution = solution_tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+
+                # Update solution in Parquet
+                update_solution_pqt(row["uuid"], solution, solution_model_name.split("/")[-1])
+            except Exception as e:
+                print(f"Error generating solution for problem {row['uuid']}: {e}")
+            pbar.update(1)
+    return "Solutions generated successfully!"
+
+# Function to generate solutions for unsolved problems
+def generate_solutions(solution_model_name):
+    conn = duckdb.connect(database=DB_FILE)
+    problems = conn.execute("SELECT uuid, problem FROM problems WHERE solution IS NULL").fetchall()
+
+    if not problems:
+        return "No unsolved problems found in the database."
+
+    with tqdm(total=len(problems), desc="Generating Solutions", unit="solution") as pbar:
+        for problem_id, problem_text in problems:
+            try:
+                solution_prompt = RESPONSE_SOLUTION_LLM_USR_PROMPT.format(problem=problem_text)
+                
+                messages = [
+                    {"role": "system", "content": RESPONSE_SOLUTION_LLM_SYS_PROMPT},
+                    {"role": "user", "content": solution_prompt}
+                ]
+                text = solution_tokenizer.apply_chat_template(
+                    messages,
+                    tokenize=False,
+                    add_generation_prompt=True
+                )
+                model_inputs = solution_tokenizer([text], return_tensors="pt").to(solution_model_instance.device)
+
+                generated_ids = solution_model_instance.generate(
+                    **model_inputs,
+                    max_new_tokens=10024
+                )
+                generated_ids = [
+                    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+                ]
+                solution = solution_tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+
+                conn.execute("""
+                    UPDATE problems
+                    SET solution = ?, solution_model_name = ?
+                    WHERE uuid = ?
+                """, (solution, solution_model_name.split("/")[-1], problem_id))
+            except Exception as e:
+                print(f"Error generating solution for problem {problem_id}: {e}")
+            pbar.update(1)
+    conn.close()
+    return "Solutions generated successfully!"
+
+# Load problems from DuckDB
+def load_problems_from_duckdb():
+    """Load all problems and solutions from the DuckDB database."""
+    conn = duckdb.connect(database=DB_FILE)
+    df = conn.execute("SELECT * FROM problems").df()
+    conn.close()
+    return df
+
+# Load summary from DuckDB
+def load_summary_from_duckdb():
+    conn = duckdb.connect(database=DB_FILE)
+
+    # Total number of problems
+    total_problems = conn.execute("SELECT COUNT(*) FROM problems").fetchone()[0]
+
+    # Count of distinct domains
+    distinct_domains_count = conn.execute("SELECT COUNT(DISTINCT main_domain) FROM problems").fetchone()[0]
+
+    # Problems by model
+    problems_by_model = conn.execute("SELECT model_name, COUNT(*) as count FROM problems GROUP BY model_name").fetchall()
+    conn.close()
+
+    # Build the summary
+    summary = f"<h3>Total Problems: {total_problems}</h3>"
+    summary += f"<h4>Distinct Domains: {distinct_domains_count}</h4>"
+
+    summary += "<h4>Problems by Model:</h4><ul>"
+    for model_name, count in problems_by_model:
+        summary += f"<li>{model_name}: {count}</li>"
+    summary += "</ul>"
+
+    return summary

README.md

@@ -1,11 +1,92 @@
 ---
-title: QuantumLLMInstruct
-emoji: 🦀
-colorFrom: green
-colorTo: indigo
-sdk: docker
-pinned: false
-short_description: 'An open-source dataset designed to assess whether solutions '
+license: apache-2.0
+language:
+- en
+
+---
+
+# QuantumLLMInstruct: A 500k LLM Instruction-Tuning Dataset with Problem-Solution Pairs for Quantum Computing
+
+### Dataset Overview
+
+**QuantumLLMInstruct (QLMMI)** is a groundbreaking dataset designed to fine-tune and evaluate Large Language Models (LLMs) in the domain of quantum computing. This dataset spans **90 primary quantum computing domains** and contains over **500,000 rigorously curated instruction-following problem-solution pairs**. 
+
+The dataset focuses on enhancing reasoning capabilities in LLMs for quantum-specific tasks, including Hamiltonian dynamics, quantum circuit optimization, and Yang-Baxter solvability. 
+
+Each entry consists of:
+- A **quantum computing problem** expressed in natural language and/or LaTeX.
+- A detailed **step-by-step solution**, designed for precision and clarity.
+- Domain-specific metadata, such as the problem's **main domain**, **sub-domain**, and associated tags.
+
+![QuantumLLMInstruct Workflow](qlmmi-detailed-flowchart.jpg)
 ---
 
+### Data Sources
+
+The dataset leverages cutting-edge methodologies to generate problems and solutions:
+1. **Predefined Templates**: Problems crafted using robust templates to ensure domain specificity and mathematical rigor.
+2. **LLM-Generated Problems**: Models such as `Qwen-2.5-Coder` autonomously generate complex problems across diverse quantum topics, including:
+   - Synthetic Hamiltonians
+   - QASM code
+   - Jordan-Wigner transformations
+   - Trotter-Suzuki decompositions
+   - Quantum phase estimation
+   - Variational Quantum Eigensolvers (VQE)
+   - Gibbs state preparation
+3. **Advanced Reasoning Techniques**: Leveraging Chain-of-Thought (CoT) and Task-Oriented Reasoning and Action (ToRA) frameworks to refine problem-solution pairs.
+
+---
+
+### Structure
+
+The dataset contains the following fields:
+- `images`: Optional multimodal inputs, such as visualizations of quantum circuits or spin models.
+- `problem_text`: The quantum computing problem, formatted in plain text or LaTeX.
+- `solution`: A detailed solution generated by state-of-the-art LLMs.
+- `main_domain`: The primary quantum domain, e.g., "Quantum Spin Chains" or "Hamiltonian Dynamics."
+- `sub_domain`: Specific subtopics, e.g., "Ising Models" or "Trotterization."
+- `tags`: Relevant tags for classification and retrieval.
+- `model_name`: The name of the model used to generate the problem or solution.
+- `timestamp`: The date and time of creation.
+
+---
+
+### Key Features
+
+- **Comprehensive Coverage**: Spanning 90 primary domains and hundreds of subdomains.
+- **High Quality**: Problems and solutions validated through advanced reasoning frameworks and Judge LLMs.
+- **Open Access**: Designed to support researchers, educators, and developers in the field of quantum computing.
+- **Scalable Infrastructure**: Metadata and structure optimized for efficient querying and usage.
+
+---
+
+### Example Domains
+
+Some of the key domains covered in the dataset include:
+- Synthetic Hamiltonians: Energy computations and time evolution.
+- Quantum Spin Chains: Ising, Heisenberg, and advanced integrable models.
+- Yang-Baxter Solvability: Solving for quantum integrable models.
+- Trotter-Suzuki Decompositions: Efficient simulation of Hamiltonian dynamics.
+- Quantum Phase Estimation: Foundational in quantum algorithms.
+- Variational Quantum Eigensolvers (VQE): Optimization for quantum chemistry.
+- Randomized Circuit Optimization: Enhancing algorithm robustness in noisy conditions.
+- Quantum Thermodynamics: Gibbs state preparation and entropy calculations.
+
+---
+
+### Contributions
+
+This dataset represents a collaborative effort to advance quantum computing research through the use of large-scale LLMs. It offers:
+1. A scalable and comprehensive dataset for fine-tuning LLMs.
+2. Rigorous methodologies for generating and validating quantum problem-solving tasks.
+3. Open-access resources to foster collaboration and innovation in the quantum computing community.
+
+---
 
+Cite:
+@dataset{quantumllm_instruct,
+  title={QuantumLLMInstruct: A 500k LLM Instruction-Tuning Dataset with Problem-Solution Pairs for Quantum Computing},
+  author={Shlomo Kashani},
+  year={2025},
+  url={https://huggingface.co/datasets/QuantumLLMInstruct}
+}

app.py

@@ -1,255 +0,0 @@
-import numpy as np
-import random
-import io
-import duckdb
-import gradio as gr
-import math
-from datetime import datetime
-import PIL
-import matplotlib.pyplot as plt
-from PIL import Image
-import pennylane as qml
-import base64
-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 Pennylane device
-dev = qml.device('default.qubit', wires=10)
-
-# Hugging Face and DuckDB function placeholders
-def store_in_hf_dataset(data):
-    pass
-
-def load_from_hf_dataset():
-    return []
-
-# Function to buffer the plot and return as PIL image
-def buffer_plot_and_get(fig):
-    buf = io.BytesIO()
-    fig.savefig(buf, format='png')
-    buf.seek(0)
-    return PIL.Image.open(buf)
-
-# Store image in bytes for DuckDB
-def pil_image_to_bytes(image):
-    img_byte_arr = io.BytesIO()
-    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 = []
-    for _ in range(random.randint(1, 5)):
-        coeff = round(random.uniform(-1, 1), 2)
-        pauli_ops = [random.choice(['I', 'X', 'Y', 'Z']) for _ in range(num_qubits)]
-        term = f"{coeff} * {' '.join(pauli_ops)}"
-        terms.append(term)
-    return " + ".join(terms)
-
-# Function to convert Hamiltonian to QASM code
-def hamiltonian_to_qasm(hamiltonian, num_qubits):
-    qasm_code = f"OPENQASM 2.0;\ninclude \"qelib1.inc\";\nqreg q[{num_qubits}];\n"
-    rotations = {i: 0.0 for i in range(num_qubits)}
-    terms = hamiltonian.split(" + ")
-    
-    for term in terms:
-        coeff, paulis = term.split(" * ")
-        paulis = paulis.split()
-        coeff = float(coeff)
-
-        for i, pauli in enumerate(paulis):
-            if pauli == "X":
-                qasm_code += f"x q[{i}];\n"
-            elif pauli == "Y":
-                qasm_code += f"ry(pi/2) q[{i}];\n"
-            elif pauli == "Z":
-                rotations[i] += coeff
-
-    for i, angle in rotations.items():
-        if angle != 0:
-            angle_degrees = round(angle * 180 / math.pi, 2)
-            qasm_code += f"rz({angle_degrees}) q[{i}];\n"
-    
-    return qasm_code
-
-# 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
-    
-    @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 circuit
-
-# Store data in DuckDB
-def store_in_duckdb(data, db_file='quantum_hamiltonians.duckdb'):
-    conn = duckdb.connect(database=db_file)
-    conn.execute("""CREATE TABLE IF NOT EXISTS hamiltonians (
-        id INTEGER,
-        plot BLOB,
-        hamiltonian VARCHAR,
-        qasm_code VARCHAR,
-        trotter_code VARCHAR,
-        num_qubits INTEGER,
-        trotter_order INTEGER,
-        timestamp TIMESTAMP
-    )""")
-    conn.executemany("""INSERT INTO hamiltonians (id, plot, hamiltonian, qasm_code, trotter_code, num_qubits, trotter_order, timestamp)
-                        VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", data)
-    conn.close()
-
-# 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()
-    conn.close()
-
-    # Convert results to HTML with images
-    html_content = []
-    for index, row in df.iterrows():
-        plot_blob = row['plot']
-        encoded_img = encode_image_from_blob(plot_blob)
-
-        html_content.append(f"""
-            <table style='width: 100%; border-collapse: collapse; margin: 10px;'>
-                <tr>
-                    <td style='width: 30%; text-align: center;'>
-                        <h3>Circuit {index + 1}</h3>
-                        {encoded_img}  <!-- Display the image -->
-                    </td>        
-                    <td style='padding: 10px;'>
-                        <table style='width: 100%; border-collapse: collapse;'>
-                            <tr>
-                                <td><strong>Hamiltonian:</strong></td><td>{row['hamiltonian']}</td>
-                            </tr>
-                            <tr>
-                                <td><strong>QASM Representation:</strong></td><td>{row['qasm_code']}</td>
-                            </tr>
-                            <tr>
-                                <td><strong>Trotter Decomposition:</strong></td><td>{row['trotter_code']}</td>
-                            </tr>
-                            <tr>
-                                <td><strong>Number of Qubits:</strong></td><td>{row['num_qubits']}</td>
-                            </tr>
-                            <tr>
-                                <td><strong>Trotter Order:</strong></td><td>{row['trotter_order']}</td>
-                            </tr>
-                            <tr>
-                                <td><strong>Timestamp:</strong></td><td>{row['timestamp']}</td>
-                            </tr>
-                        </table>
-                    </td>
-                </tr>
-            </table>
-        """)
-
-    return "".join(html_content)
-
-# Function to generate Hamiltonians
-def generate_hamiltonians(num_hamiltonians, selected_qubits, selected_order, write_to_hf, write_to_duckdb):
-    results_table = []
-    timestamp = datetime.now()
-
-    for i in range(num_hamiltonians):
-        num_qubits = random.choice(selected_qubits)
-        order = selected_order
-        hamiltonian = generate_random_hamiltonian(num_qubits)
-        qasm_code = hamiltonian_to_qasm(hamiltonian, num_qubits)
-        trotter_code = trotter_decomposition(hamiltonian, order)
-
-        # 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)
-
-        # Append data to results table
-        results_table.append((i + 1, circuit_plot_bytes, hamiltonian, qasm_code, trotter_code, num_qubits, order, timestamp))
-
-    # Write data to Hugging Face dataset if selected
-    if write_to_hf:
-        store_in_hf_dataset(results_table)
-    
-    # Write data to DuckDB if selected
-    if write_to_duckdb:
-        store_in_duckdb(results_table)
-
-# Function to load results from either DuckDB or Hugging Face dataset
-def load_results(load_from_hf, load_from_duckdb1):
-    if load_from_hf:
-        return load_from_hf_dataset()
-    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")
-    
-    with gr.Tab("Generate Hamiltonians"):
-        num_hamiltonians = gr.Dropdown(label="Select number of Hamiltonians to generate", choices=[1, 10, 20, 100], value=20)
-        qubit_choices = [1, 2, 3, 4, 5, 6]
-        selected_qubits = gr.CheckboxGroup(label="Select number of qubits", choices=qubit_choices, value=[1])
-        order_choices = [1, 2, 3, 4, 5]
-        selected_order = gr.Dropdown(label="Select Trotter order", choices=order_choices, value=1)
-
-        # Checkboxes for writing to HF dataset and DuckDB
-        write_to_hf = gr.Checkbox(label="Write to Hugging Face dataset", value=False)
-        write_to_duckdb = gr.Checkbox(label="Write to DuckDB", value=True)
-
-        generate_button = gr.Button("Generate Hamiltonians")
-        status = gr.Markdown("Click 'Generate Hamiltonians' to start the process.")
-
-        def update_status(num, qubits, order, write_hf, write_duckdb):
-            generate_hamiltonians(num, qubits, order, write_hf, write_duckdb)
-            return "Data stored as per selection."
-
-        generate_button.click(update_status, inputs=[num_hamiltonians, selected_qubits, selected_order, write_to_hf, write_to_duckdb], outputs=status)
-
-    with gr.Tab("View Results"):
-        load_from_hf = gr.Checkbox(label="Load from Hugging Face dataset", value=False)
-        load_from_duckdb1 = gr.Checkbox(label="Load from DuckDB", value=True)
-
-        load_button = gr.Button("Load Results")
-        output_display = gr.HTML()
-
-        load_button.click(load_results, inputs=[load_from_hf, load_from_duckdb1], outputs=output_display)
-
-app.launch()