Fix app UI integration and cleanup

Author: quantumdynamics927-dotcom

app.py

@@ -1,6 +1,7 @@
 """
 Gradio interface for QPyth - Quantum-inspired Python experimentation.
-This provides a comprehensive web UI for the QPyth quantum computing library on Hugging Face Spaces.
+This provides a comprehensive web UI for the QPyth quantum computing
+library on Hugging Face Spaces.
 """
 
 import json
@@ -42,7 +43,8 @@ def run_quantum_teleport():
         circuit = build_teleport_circuit()
         result = engine.run(circuit)
         return (
-            f"Teleportation circuit executed successfully!\n\nCounts: {result.counts}"
+            "Teleportation circuit executed successfully!\n\n"
+            f"Counts: {result.counts}"
         )
     except Exception as e:
         return f"Error: {str(e)}"
@@ -61,7 +63,6 @@ def run_qec_demo(code_type="Shor"):
             return run_steane_qec_demo()
         else:  # Surface
             from quantumpytho.modules.qec_surface import run_surface_code_demo
-
             return run_surface_code_demo()
     except Exception as e:
         return f"Error: {str(e)}"
@@ -88,26 +89,23 @@ def generate_qrng(count, phi_scale=False):
 def run_vqe_h2(bond_length=0.74, shots=1024):
     """Run VQE for H2 molecule."""
     try:
-        from quantumpytho.modules.vqe_core import VQEEngine
-        from quantumpytho.modules.vqe_h2_exact import compute_exact_energy
-
-        # Compute exact energy
-        exact_energy = compute_exact_energy(bond_length)
+        from quantumpytho.modules.vqe_core import run_vqe_h2 as run_vqe_h2_core
 
-        # Run VQE
-        vqe_engine = VQEEngine()
-        result = vqe_engine.run_h2(bond_length=bond_length, shots=shots)
+        geometry = f"H 0 0 0; H 0 0 {bond_length}"
+        result = run_vqe_h2_core(geometry=geometry, max_iters=int(shots))
+        energies = result.energy_history
+        initial_energy = energies[0][1] if energies else result.ground_energy
+        error = abs(result.ground_energy - initial_energy) if energies else 0.0
 
         output = f"""VQE Results for H₂ Molecule:
 Bond Length: {bond_length} Å
-Shots: {shots}
+Iterations: {result.iterations}
 
-Exact Energy: {exact_energy:.6f} Hartree
-VQE Energy: {result.get("energy", "N/A")} Hartree
-Error: {result.get("error", "N/A")} Hartree
+Ground Energy: {result.ground_energy:.6f} Hartree
+Estimated Improvement: {error:.6f} Hartree
 
-Circuit Depth: {result.get("depth", "N/A")}
-Iterations: {result.get("iterations", "N/A")}
+Optimizer: {result.metadata.optimizer}
+Backend: {result.metadata.backend}
 """
         return output
     except Exception as e:
@@ -117,39 +115,35 @@ def run_vqe_h2(bond_length=0.74, shots=1024):
 def run_noisy_simulation(backend_profile="IBM", noise_level=0.01):
     """Run noisy simulation with backend profiles."""
     try:
-        from quantumpytho.modules.backend_profiles import get_backend_profile
-        from quantumpytho.modules.noise_builder import NoiseModelBuilder
+        from quantumpytho.modules.hardware_ibm import NoisySimulatorEngine
+        from quantumpytho.modules.noise_builder import get_backend_info
 
-        # Get backend profile
-        profile = get_backend_profile(backend_profile)
+        available_profiles = NoisySimulatorEngine.get_available_profiles()
+        profile_name = (
+            backend_profile if backend_profile in available_profiles else None
+        )
 
-        # Create circuit
         circuit = QuantumCircuit(2, 2)
         circuit.h(0)
         circuit.cx(0, 1)
         circuit.measure([0, 1], [0, 1])
 
-        # Build noise model
-        noise_builder = NoiseModelBuilder()
-        noise_model = noise_builder.build_from_profile(profile, noise_level)
-
-        # Run with noise
-        from qiskit_aer import AerSimulator
-
-        backend = AerSimulator(noise_model=noise_model)
-        job = backend.run(circuit, shots=1024)
-        result = job.result()
-        counts = result.get_counts()
+        simulator = NoisySimulatorEngine(
+            noise_profile=profile_name,
+            shots=1024,
+        )
+        result = simulator.run(circuit)
+        profile_info = get_backend_info(profile_name) if profile_name else None
 
         output = f"""Noisy Simulation Results:
-Backend Profile: {backend_profile}
+Backend Profile: {profile_name or 'simulator'}
 Noise Level: {noise_level}
 
 Measurement Counts:
-{json.dumps(counts, indent=2)}
+{json.dumps(result.counts, indent=2)}
 
 Profile Info:
-{json.dumps(profile, indent=2)}
+{json.dumps(profile_info or {'noise_model': 'none'}, indent=2)}
 """
         return output
     except Exception as e:
@@ -177,7 +171,7 @@ def explore_dna_circuits(sequence_name="ATCG"):
         output = f"""DNA Circuit Exploration:
 Sequence: {sequence_name}
 
-Available Sequences: {", ".join(available[:10])}...
+Available Sequences: {', '.join(available[:10])}...
 
 Sequence Data:
 {json.dumps(sequence_data, indent=2)}
@@ -193,21 +187,23 @@ def explore_dna_circuits(sequence_name="ATCG"):
 def run_tmt_sierpinski():
     """Run TMT Sierpinski 21-qubit sacred geometry circuit."""
     try:
-        from quantumpytho.modules.tmt_sierpinski import build_tmt_circuit
+        from quantumpytho.modules.tmt_sierpinski import (
+            run_tmt_sierpinski as run_tmt_demo,
+        )
 
-        circuit = build_tmt_circuit()
-        result = engine.run(circuit)
+        result = run_tmt_demo(engine)
 
         output = f"""TMT Sierpinski Circuit (Sacred Geometry):
-Qubits: 21
-Circuit Type: Sierpinski Triangle Pattern
+Qubits: {result['qubits']}
+Circuit Type: {result['circuit']}
 
 Measurement Counts:
-{result.counts}
+{json.dumps(result['counts'], indent=2)}
 
 Circuit Metadata:
-Depth: {result.circuit.depth()}
-Gates: {len(result.circuit.data)}
+Depth: {result['depth']}
+Shots: {result['shots']}
+Most Common: {result['most_common']}
 """
         return output
     except Exception as e:
@@ -217,18 +213,32 @@ def run_tmt_sierpinski():
 def run_benchmark():
     """Run benchmark dashboard."""
     try:
-        from quantumpytho.modules.benchmark_dashboard import run_benchmark_suite
+        from quantumpytho.validation import (
+            ValidationRunConfig,
+            build_noisy_simulation_executor,
+            reference_benchmarks,
+            run_benchmark_suite,
+        )
 
-        results = run_benchmark_suite()
+        benchmarks = reference_benchmarks()
+        config = ValidationRunConfig(backend_name="simulator", shots=1024)
+        executor = build_noisy_simulation_executor(
+            noise_profile=None,
+            default_shots=1024,
+        )
+        results = run_benchmark_suite(benchmarks, executor, executor, config)
+        mean_match_score = sum(
+            record.mean_metric for record in results
+        ) / len(results)
 
         output = f"""QPyth Benchmark Results:
 
-{json.dumps(results, indent=2)}
+{json.dumps([record.to_dict() for record in results], indent=2)}
 
 Summary:
 - Total Tests: {len(results)}
-- Passed: {sum(1 for r in results.values() if r.get("status") == "pass")}
-- Failed: {sum(1 for r in results.values() if r.get("status") == "fail")}
+- Mean Match Score: {mean_match_score:.4f}
+- Backend: {config.backend_name}
 """
         return output
     except Exception as e:
@@ -237,23 +247,32 @@ def run_benchmark():
 
 # Create Gradio interface
 def create_interface():
-    with gr.Blocks(title="QPyth - Quantum Computing", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(
+        title="QPyth - Quantum Computing",
+        theme=gr.themes.Soft(),
+    ) as app_interface:
         gr.Markdown("""
         # ⚛️ QPyth - Quantum Computing Environment
-        
+
         A professionally engineered quantum computing library built on Qiskit.
-        Featuring VQE, IBM Quantum integration, QEC, noisy simulation, and more.
+        Featuring VQE, IBM Quantum integration, QEC, noisy simulation,
+        and more.
         """)
 
         with gr.Tab("Bloch Sphere"):
             gr.Markdown("Visualize quantum states on the Bloch sphere")
             with gr.Row():
                 theta = gr.Slider(0, 180, value=45, label="Theta (degrees)")
                 phi = gr.Slider(0, 360, value=45, label="Phi (degrees)")
-            bloch_output = gr.Textbox(label="Bloch Sphere Visualization", lines=20)
+            bloch_output = gr.Textbox(
+                label="Bloch Sphere Visualization",
+                lines=20,
+            )
             bloch_btn = gr.Button("Generate")
             bloch_btn.click(
-                bloch_sphere_demo, inputs=[theta, phi], outputs=bloch_output
+                bloch_sphere_demo,
+                inputs=[theta, phi],
+                outputs=bloch_output,
             )
 
         with gr.Tab("Bell Pair"):
@@ -264,21 +283,34 @@ def create_interface():
 
         with gr.Tab("Quantum Teleportation"):
             gr.Markdown("Run the quantum teleportation protocol")
-            teleport_output = gr.Textbox(label="Teleportation Results", lines=15)
+            teleport_output = gr.Textbox(
+                label="Teleportation Results",
+                lines=15,
+            )
             teleport_btn = gr.Button("Run Teleportation")
             teleport_btn.click(run_quantum_teleport, outputs=teleport_output)
 
         with gr.Tab("Quantum Error Correction"):
             gr.Markdown("Demonstrate quantum error correction codes")
-            code_type = gr.Radio(["Shor", "Steane"], label="Code Type", value="Shor")
+            code_type = gr.Radio(
+                ["Shor", "Steane"],
+                label="Code Type",
+                value="Shor",
+            )
             qec_output = gr.Textbox(label="Result", lines=15)
             qec_btn = gr.Button("Run QEC Demo")
             qec_btn.click(run_qec_demo, inputs=code_type, outputs=qec_output)
 
         with gr.Tab("Quantum RNG"):
             gr.Markdown("Generate quantum random numbers")
             with gr.Row():
-                count = gr.Slider(1, 100, value=10, step=1, label="Number of values")
+                count = gr.Slider(
+                    1,
+                    100,
+                    value=10,
+                    step=1,
+                    label="Number of values",
+                )
                 phi_scale = gr.Checkbox(label="Use phi-scaling")
             qrng_output = gr.Textbox(label="Random Numbers", lines=15)
             qrng_btn = gr.Button("Generate")
@@ -288,16 +320,16 @@ def create_interface():
 
         gr.Markdown("""
         ---
-        
+
         **QPyth v0.4.0** | Built with Qiskit | Apache 2.0 License
-        
+
         For CLI access and advanced features, install with: `pip install QPyth`
         """)
 
-    return demo
+    return app_interface
 
 
 # Launch the app
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()
+    launched_interface = create_interface()
+    launched_interface.launch()