scalar_quantum_sim/ ├── core/ │ ├── __init__.py │ ├── hamiltonian.py (Construct scalar operators and matrices) │ └── engine.py (Quantum state evolution & IBM QPU driver) └── app.py (Streamlit Web GUI & interactive dashboard)

import numpy as np class ScalarHamiltonianBuilder: """Constructs parameterized Hamiltonian operators from scalar field metrics.""" def __init__(self): self.I = np.array([[1, 0], [0, 1]], dtype=complex) self.X = np.array([[0, 1], [1, 0]], dtype=complex) self.Z = np.array([[1, 0], [0, -1]], dtype=complex) def build_custom_operator(self, xi_scalar: float, coupling: float) -> np.ndarray: """ Generates the 4x4 matrix representation of H_Xi. H_Xi = Xi * (Z x I) + g * (X x X) """ H_field = xi_scalar * np.kron(self.Z, self.I) H_interaction = coupling * np.kron(self.X, self.X) return H_field + H_interaction

import numpy as np from scipy.linalg import expm from qiskit import QuantumCircuit from qiskit.quantum_info import Operator, Statevector from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler class QuantumSimulationEngine: """Handles time evolution compilation and dispatch to ideal simulators or IBM QPUs.""" def __init__(self, hamiltonian: np.ndarray, num_qubits: int = 2): self.H = hamiltonian self.num_qubits = num_qubits def generate_evolution_circuit(self, time_delta: float) -> QuantumCircuit: """Synthesizes the continuous operator into a Qiskit QuantumCircuit.""" U = expm(-1j * self.H * time_delta) qc = QuantumCircuit(self.num_qubits) qc.h(0) # Initial state preparation qc.append(Operator(U), range(self.num_qubits)) qc.measure_all() return qc def run_local_ideal(self, time_delta: float) -> dict: """Executes exact statevector evolution locally.""" U = expm(-1j * self.H * time_delta) qc = QuantumCircuit(self.num_qubits) qc.h(0) qc.append(Operator(U), range(self.num_qubits)) state = Statevector.from_label('00').evolve(qc) return { "mode": "Local Statevector (Ideal)", "probabilities": state.probabilities_dict(), "statevector": state.data, "circuit": qc } def run_ibm_quantum(self, time_delta: float, api_token: str, backend_name: str = "ibm_brisbane", shots: int = 1024) -> dict: """Submits synthesized circuits to remote IBM Quantum processing units.""" qc = self.generate_evolution_circuit(time_delta) service = QiskitRuntimeService(channel="ibm_quantum", token=api_token) backend = service.backend(backend_name) sampler = Sampler(mode=backend) job = sampler.run([qc], shots=shots) result = job.result() pub_result = result[0] counts = pub_result.data.meas.get_counts() total_shots = sum(counts.values()) probs = {state: count / total_shots for state, count in counts.items()} return { "mode": f"IBM Quantum ({backend_name})", "probabilities": probs, "counts": counts, "job_id": job.job_id(), "circuit": qc }

import streamlit as st import pandas as pd from core.hamiltonian import ScalarHamiltonianBuilder from core.engine import QuantumSimulationEngine st.set_page_config(page_title="Scalar Quantum Simulator", page_icon="⚛️", layout="wide") st.title("⚛️ Scalar Quantum Simulator Dashboard") st.markdown("Bridge abstract scalar frameworks into executable quantum algorithms.") # Sidebar Controls st.sidebar.header("🎛️ System Control Panel") xi_val = st.sidebar.slider("Xi Parameter (Xi)", min_value=0.0, max_value=5.0, value=1.618, step=0.01) coupling_val = st.sidebar.slider("Coupling Coefficient (g)", min_value=0.0, max_value=2.0, value=0.50, step=0.05) time_val = st.sidebar.slider("Evolution Delta (t)", min_value=0.1, max_value=10.0, value=1.0, step=0.1) backend_mode = st.sidebar.radio("Backend Mode:", ["Local Simulator (Ideal)", "Real IBM Quantum QPU"]) ibm_api_token = "" ibm_backend_choice = "ibm_brisbane" if backend_mode == "Real IBM Quantum QPU": ibm_api_token = st.sidebar.text_input("IBM Quantum API Token", type="password") ibm_backend_choice = st.sidebar.selectbox("Target Hardware Backend", ["ibm_brisbane", "ibm_kyoto", "ibm_osaka"]) run_button = st.sidebar.button("🚀 Execute Simulation", type="primary") if run_button: builder = ScalarHamiltonianBuilder() H_matrix = builder.build_custom_operator(xi_scalar=xi_val, coupling=coupling_val) engine = QuantumSimulationEngine(H_matrix) with st.spinner("Executing simulation pipeline..."): try: if backend_mode == "Local Simulator (Ideal)": results = engine.run_local_ideal(time_delta=time_val) else: if not ibm_api_token: st.error("Authentication Error: An IBM Quantum API Token is required.") st.stop() results = engine.run_ibm_quantum( time_delta=time_val, api_token=ibm_api_token, backend_name=ibm_backend_choice ) col1, col2 = st.columns([1, 1]) with col1: st.subheader("📊 Basis State Measurement Probabilities") df_probs = pd.DataFrame( list(results["probabilities"].items()), columns=["Basis State |q1 q0>", "Probability"] ).sort_values(by="Basis State |q1 q0>") st.bar_chart(df_probs.set_index("Basis State |q1 q0>")) st.dataframe(df_probs, use_container_width=True) with col2: st.subheader("⚙️ Quantum Circuit Assembly") st.markdown(f"**Execution Engine:** `{results['mode']}`") if "job_id" in results: st.success(f"**Hardware Job ID:** `{results['job_id']}`") st.code(str(results["circuit"].draw(output="text")), language="text") except Exception as e: st.error(f"Runtime Execution Failure: {str(e)}")

# Install required packages pip install qiskit qiskit-ibm-runtime scipy numpy pandas streamlit # Launch the Dashboard streamlit run app.py