Added display of full circuit Hamiltonian and reworked position of tiles

app.py

@@ -69,7 +69,7 @@ for handler in logger.handlers:
     handler.setLevel(logging.DEBUG)
 
 def install_dependencies():
-    """Install required packages from requirements.txt."""
+    print("""Install required packages from requirements.txt.""")
     try:
         subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
         print("Dependencies installed successfully")
@@ -77,6 +77,16 @@ def install_dependencies():
         print(f"Error installing dependencies: {e}")
         sys.exit(1)
 
+# Test if cudaq is already installed
+try:
+    import cudaq
+    print("CUDA-Q already installed, skipping dependency installation")
+except ImportError:
+    print("CUDA-Q not found, installing dependencies...")
+    # Run installation before any other imports
+    install_dependencies()
+
+
 # Load molecule definitions
 def load_molecules():
     """Load molecule definitions from JSON file."""
@@ -87,15 +97,6 @@ def load_molecules():
         print(f"Error loading molecules.json: {e}", file=sys.stderr)
         return {}
 
-# Test if cudaq is already installed
-try:
-    import cudaq
-    print("CUDA-Q already installed, skipping dependency installation")
-except ImportError:
-    print("CUDA-Q not found, installing dependencies...")
-    # Run installation before any other imports
-    install_dependencies()
-
 # Now import the rest of the modules
 import gradio as gr
 import numpy as np
@@ -182,11 +183,14 @@ def create_interface():
         Select a molecule below, adjust its parameters, and watch as the simulation computes the lowest 
         possible energy state using quantum-inspired algorithms accelerated by NVIDIA GPUs.
 
+        Even for small molecules, the needed quantum circuit can be quite large so for learning purposes we display it in all it's sacred glory.
+
         Inspired by the CUDA-Q VQE Example: https://nvidia.github.io/cuda-quantum/latest/applications/python/vqe_advanced.html
         """)
         
         state = gr.State({})  # Store current molecule data
         
+        # Top section: 3 columns
         with gr.Row():
             with gr.Column(scale=1):
                 # Molecule selection controls
@@ -195,7 +199,7 @@ def create_interface():
                     value=list(molecules.keys())[0],
                     label="Select Molecule",
                     interactive=True,
-                    allow_custom_value=False  # Prevent text input
+                    allow_custom_value=False
                 )
                 
                 # Get scale range from selected molecule
@@ -208,41 +212,91 @@ def create_interface():
                     label="Scale Factor (1.0 = original size)",
                     interactive=True
                 )
-                
-                # Split into two buttons
-                generate_ham_button = gr.Button("Generate Hamiltonian")
-                run_vqe_button = gr.Button("Run VQE Simulation", interactive=False)
-                
+            
             with gr.Column(scale=1):
                 # Molecule parameters display
                 params_display = gr.HTML(
                     label="Molecule Parameters",
                     value=format_molecule_params(default_molecule)
                 )
+            
+            with gr.Column(scale=1):
+                # 3D Molecule Viewer
+                molecule_viz = MolGallery3D(
+                    columns=1,
+                    height=400,  # Reduced height to match other elements
+                    label="3D Molecule Viewer",
+                    automatic_rotation=True
+                )
         
-        # Simulation results box below controls
-        with gr.Row():
-            simulation_results = gr.HTML(
-                label="Simulation Results",
-                value="<div style='padding: 10px; background-color: #f5f5f5; border-radius: 5px;'>" +
-                      "Click 'Generate Hamiltonian' to start.</div>"
-            )
-        
-        # Plots and visualization
+        # Middle section: Buttons and results in 2 columns
         with gr.Row():
             with gr.Column(scale=1):
+                # Buttons side by side
+                with gr.Row():
+                    generate_ham_button = gr.Button("Generate Hamiltonian")
+                    run_vqe_button = gr.Button("Run VQE Simulation", interactive=False)
+                
+                # Hamiltonian Information
+                simulation_results = gr.HTML(
+                    label="Hamiltonian Information",
+                    value="<div style='padding: 10px; background-color: #f5f5f5; border-radius: 5px; font-size: 0.8em;'>" +
+                          "Click 'Generate Hamiltonian' to start.</div>"
+                )
+            
+            with gr.Column(scale=1):
+                # VQE Convergence Plot
                 convergence_plot = gr.Plot(
                     label="VQE Convergence",
                     show_label=True
                 )
-            with gr.Column(scale=1, min_width=600):
-                molecule_viz = MolGallery3D(
-                    columns=1,
-                    height=600,
-                    label="3D Molecule Viewer",
-                    automatic_rotation=True
-                )
-
+        
+        # Bottom section: Full width circuit visualization
+        circuit_latex_display = gr.Markdown(
+            label="Quantum Circuit Visualization",
+            value="Circuit will be displayed after generation.",
+            elem_classes="circuit-output"
+        )
+        
+        # Add CSS styling
+        gr.Markdown("""
+        <style>
+            .circuit-output {
+                font-family: monospace;
+                font-size: 0.6em;
+                white-space: pre;
+                overflow-x: auto;
+                padding: 10px;
+                background-color: #f8f8f8;
+                width: 100%;
+                max-width: 100%;
+                box-sizing: border-box;
+                display: block;
+            }
+            .circuit-output pre {
+                margin: 0 auto;
+                background: none !important;
+                border: none !important;
+                padding: 0 !important;
+                width: 100%;
+                overflow-x: auto;
+            }
+            .circuit-output code {
+                background: none !important;
+                border: none !important;
+                padding: 0 !important;
+            }
+            .gradio-container .prose {
+                max-width: 100% !important;
+                width: 100% !important;
+            }
+            .markdown-text {
+                width: 100% !important;
+                max-width: none !important;
+            }
+        </style>
+        """)
+        
         def generate_hamiltonian(molecule_choice: str, scale_factor: float) -> tuple:
             """Generate Hamiltonian for the selected molecule."""
             try:
@@ -258,25 +312,28 @@ def create_interface():
                 
                 # Format Hamiltonian results
                 hamiltonian_html = f"""
-                <div style='padding: 10px; background-color: #f5f5f5; border-radius: 5px;'>
+                <div style='padding: 10px; background-color: #f5f5f5; border-radius: 5px; font-size: 0.8em;'>
                     <h3>Hamiltonian Generated:</h3>
                     <ul style='list-style-type: none; padding-left: 0;'>
                         <li><b>Number of Qubits:</b> {results['qubit_count']}</li>
                         <li><b>Number of Electrons:</b> {results['electron_count']}</li>
-                        <li><b>Parameter Count:</b> {results['parameter_count']}</li>
                         <li><b>Hamiltonian Terms:</b> {results['hamiltonian_terms']}</li>
+                        <li style='margin-top: 8px; color: #2a6f97;'><b>Quantum Circuit Parameters:</b> {results['parameter_count']} <i>(parameters needed to represent the system in quantum circuit form)</i></li>
                         <li><b>Scale Factor:</b> {scale_factor:.2f}</li>
                     </ul>
                     <p><i>Ready to run VQE optimization.</i></p>
                 </div>
                 """
                 
+                # Format circuit output with monospace preservation and escape special characters
+                circuit_latex = f"""<div class='circuit-output'><pre>{results.get('circuit_latex', 'Circuit visualization not available').replace('`', '&#96;')}</pre></div>"""
+                
                 # Enable the VQE button now that Hamiltonian is generated
-                return hamiltonian_html, gr.update(interactive=True), None
+                return hamiltonian_html, circuit_latex, gr.update(interactive=True), None
             
             except Exception as e:
                 error_msg = f"<div style='color: red;'>Error generating Hamiltonian:<br>{str(e)}</div>"
-                return error_msg, gr.update(interactive=False), None
+                return error_msg, "Error generating circuit visualization", gr.update(interactive=False), None
 
         def run_vqe_optimization(molecule_choice: str, scale_factor: float) -> tuple:
             """Run VQE optimization after Hamiltonian is generated."""
@@ -376,7 +433,7 @@ def create_interface():
         generate_ham_button.click(
             fn=generate_hamiltonian,
             inputs=[molecule_choice, scale_factor],
-            outputs=[simulation_results, run_vqe_button, convergence_plot]
+            outputs=[simulation_results, circuit_latex_display, run_vqe_button, convergence_plot]
         )
         
         # Run VQE optimization when button is clicked

quantum_utils.py

@@ -236,6 +236,7 @@ def generate_hamiltonian(molecule_data: Dict[str, Any],
         - 'electron_count': Number of electrons in the system
         - 'parameter_count': Number of UCCSD parameters needed
         - 'hamiltonian_terms': Number of terms in the Hamiltonian
+        - 'circuit_latex': LaTeX representation of the quantum circuit
     """
     logging.info(f"Generating Hamiltonian for {molecule_data['name']} with scale factor {scale_factor}")
     
@@ -267,12 +268,25 @@ def generate_hamiltonian(molecule_data: Dict[str, Any],
     parameter_count = cudaq.kernels.uccsd_num_parameters(electron_count, qubit_count)
     logging.info(f"Number of UCCSD parameters needed = {parameter_count}")
     
+    # Generate LaTeX representation of the circuit
+    try:
+        logging.info("Starting circuit LaTeX generation")
+        thetas_draw = np.random.normal(0, 1, parameter_count)
+        # Draw the circuit in fancy nice stuff
+        circuit_latex = cudaq.draw(kernel, qubit_count, electron_count, thetas_draw)
+        logging.info("Successfully generated circuit LaTeX representation")
+        logging.info(circuit_latex)
+    except Exception as e:
+        logging.error(f"Failed to generate circuit LaTeX: {str(e)}")
+        circuit_latex = "Error generating circuit visualization"
+    
     return {
         'hamiltonian': spin_hamiltonian,
         'qubit_count': qubit_count,
         'electron_count': electron_count,
         'parameter_count': parameter_count,
-        'hamiltonian_terms': term_count
+        'hamiltonian_terms': term_count,
+        'circuit_latex': circuit_latex
     }
 
 @spaces.GPU
@@ -306,7 +320,8 @@ def run_vqe_simulation(molecule_data: Dict[str, Any],
             'hamiltonian_terms': ham_info['hamiltonian_terms'],
             'qubit_count': ham_info['qubit_count'],
             'electron_count': ham_info['electron_count'],
-            'message': "Hamiltonian generated successfully"
+            'message': "Hamiltonian generated successfully",
+            'circuit_latex': ham_info['circuit_latex']
         }
     
     # Otherwise continue with VQE optimization