diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb new file mode 100644 index 00000000000..6c003330f0c --- /dev/null +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -0,0 +1,1132 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8e82ead7", + "metadata": {}, + "source": [ + "---\n", + "title: Simulate neutron scattering in quantum materials with quantum circuits\n", + "description: Compute the dynamical structure factor of a quantum magnet using Trotter circuits and MPS simulation.\n", + "---\n", + "\n", + "{/* cspell:ignore DSFs spinon Cloizeaux DMRG eigsh viridis fontsize vmax vmin Aer's cadetblue */}\n", + "\n", + "# Simulate neutron scattering in quantum materials with quantum circuits\n", + "\n", + "*Usage estimate: 13 minutes on a Heron r2 processor (NOTE: This is an estimate only. Your runtime might vary.)*" + ] + }, + { + "cell_type": "markdown", + "id": "11033666", + "metadata": {}, + "source": [ + "## Learning outcomes\n", + "\n", + "After completing this tutorial, you can expect to understand the following information:\n", + "- How inelastic neutron scattering (INS) spectra connect to dynamical structure factors (DSFs) of quantum spin models.\n", + "- How to prepare a ground state, apply a local perturbation, and perform Trotter time evolution on a quantum circuit.\n", + "- How to use approximate quantum compiling (AQC) with `qiskit-addon-aqc-tensor` to compress deep Trotter circuits for hardware execution.\n", + "- How to extract the retarded Green's function (RGF) from qubit expectation values and Fourier-transform it into a DSF.\n", + "\n", + "## Prerequisites\n", + "It is recommended that you familiarize yourself with these topics:\n", + "- [Basics of Quantum Circuits and Gates](https://learning.quantum.ibm.com/course/basics-of-quantum-information)\n", + "- [Variational Algorithms and Hamiltonian Simulation](https://learning.quantum.ibm.com/course/variational-algorithm-design)\n", + "- [Introduction to Qiskit Primitives (Estimator & Sampler)](https://docs.quantum.ibm.com/guides/primitives)\n", + "\n", + "## Background\n", + "\n", + "In this tutorial, we reproduce the results of [Lee et al., arXiv:2603.15608](https://arxiv.org/abs/2603.15608) at a smaller scale. While that paper ran a 50-qubit experiment, here we run a 20-qubit experiment to keep the cost of performing approximate quantum compilation (AQC) more manageable.\n", + "\n", + "### Inelastic neutron scattering and the dynamical structure factor\n", + "\n", + "Inelastic neutron scattering (INS) is one of the most powerful experimental probes of magnetic excitations in quantum materials. When a beam of thermal or cold neutrons impinges on a crystal, individual neutrons exchange both momentum $\\mathbf{q}$ and energy $\\omega$ with the magnetic subsystem. The measured scattering intensity is proportional to the dynamical structure factor (DSF),\n", + "\n", + "$$S^{\\alpha\\beta}(q,\\omega) = \\sum_{j} e^{-iq\\,j}\\int_{-\\infty}^{\\infty} dt\\; e^{i\\omega t}\\, \\langle S_0^{\\alpha}(0)\\, S_j^{\\beta}(t)\\rangle,$$\n", + "\n", + "which encodes the full space-time correlations of the spin degrees of freedom.\n", + "\n", + "### KCuF$_3$ — a canonical Luttinger-liquid magnet\n", + "\n", + "Potassium copper fluoride (KCuF$_3$) is a quasi-one-dimensional antiferromagnet in which chains of spin-$\\frac{1}{2}$ Cu$^{2+}$ ions interact via a nearest-neighbor Heisenberg exchange $J \\approx 34\\;\\mathrm{meV}$, while the interchain coupling is only $\\sim 2.7\\%$ of $J$. At $T = 6\\;\\mathrm{K}$ where INS data are available, the spectrum is dominated by fractionalized spinon excitations characteristic of a Tomonaga-Luttinger liquid. Because the intrachain dynamics are well described by the one-dimensional spin-$\\frac{1}{2}$ XXZ Hamiltonian at the isotropic point ($\\epsilon = 1$),\n", + "\n", + "$$H = J\\sum_{i}\\left[S_i^Z S_{i+1}^Z + \\epsilon\\left(S_i^X S_{i+1}^X + S_i^Y S_{i+1}^Y\\right)\\right],$$\n", + "\n", + "KCuF$_3$ serves as an ideal benchmark for quantum simulation: the Hamiltonian is simple enough to implement on a quantum processor, yet the ground state is strongly entangled and the excitation spectrum features a broad two-spinon continuum.\n", + "\n", + "### What we simulate and measure\n", + "\n", + "The physical quantity we compute is the **retarded Green’s function** (RGF), defined as the time-dependent spin–spin correlation function\n", + "\n", + "$$G^R_{\\alpha\\beta}(j, j_c, t) = -i\\,\\theta(t)\\,\\langle\\psi_{\\mathrm{GS}}|\\,[S_j^\\alpha(t),\\, S_{j_c}^\\beta(0)]\\,|\\psi_{\\mathrm{GS}}\\rangle,$$\n", + "\n", + "where $j_c$ is a reference site (the chain center) and $S_j^\\alpha(t) = e^{iHt}S_j^\\alpha e^{-iHt}$ is the Heisenberg-picture spin operator. In this tutorial we focus on the $zz$ component ($\\alpha = \\beta = z$). On a quantum computer the RGF is accessed by preparing the ground state, applying a local perturbation at $j_c$, time-evolving the perturbed state, and measuring the single-qubit expectation value $\\langle\\sigma_j^z\\rangle$ at every site $j$ for each time step. The key insight is that each $\\langle\\sigma_j^z\\rangle$ gives the difference from the ground-state magnetization, which — for the antiferromagnetic ground state — directly yields $G^R(j, j_c, t)$.\n", + "\n", + "By collecting $G^R(j, j_c, t)$ over all sites and time steps, we assemble a two-dimensional dataset that is then Fourier-transformed in both space and time to produce the **dynamical structure factor** $S(q,\\omega)$. The DSF is the quantity directly measured in an INS experiment: it tells us what magnetic excitations exist at each momentum $q$ and energy $\\omega$. For the isotropic Heisenberg chain the exact excitation spectrum is a **two-spinon continuum** — a broad band of scattering intensity bounded below by $\\omega_{\\mathrm{lower}}(q) = \\frac{\\pi}{2}|\\sin q|$ (the des Cloizeaux–Pearson dispersion) and above by $\\omega_{\\mathrm{upper}}(q) = \\pi|\\sin(q/2)|$. Reproducing this continuum from a quantum circuit serves as a stringent end-to-end benchmark: it validates the ground-state preparation, perturbation, Trotter time evolution, and measurement protocol all at once.\n", + "\n", + "### Quantum-simulation workflow\n", + "\n", + "The workflow mirrors the physics of an INS event. We (1) prepare the many-body ground state $|\\psi_{\\mathrm{GS}}\\rangle$ on $n$ qubits, (2) apply a local spin-flip perturbation $U_{j_c} = \\frac{1}{\\sqrt{2}}(I - i\\sigma^z_{j_c})$ at the chain center to mimic the neutron’s spin transfer, (3) evolve under $H$ for discrete time steps using second-order Trotterization, and (4) measure $\\langle\\sigma_i^z\\rangle$ on every qubit at each step to obtain the RGF. A two-dimensional discrete Fourier transform then yields the DSF $S(q,\\omega)$.\n", + "\n", + "The observable we measure at every time step is $\\sigma_i^z$ on each qubit $i$. In Qiskit this is represented as a list of `SparsePauliOp` operators — one single-qubit $Z$ embedded in the $n$-qubit identity string for each site. These observables are constructed once during the problem-mapping step (Step 1) and reused for every circuit.\n", + "\n", + "### Approximate quantum compiling (AQC)\n", + "\n", + "Deep Trotter circuits can be compressed with **approximate quantum compiling (AQC)**, which replaces the first several Trotter layers with a shorter parameterized ansatz whose parameters are classically optimized to maximize the MPS-level fidelity with the original deep circuit. The remaining Trotter steps are appended exactly, producing a \"mixed\" AQC + Trotter circuit with substantially fewer two-qubit gates. In this tutorial AQC is demonstrated conceptually in Step 2 and applied programmatically in the large-scale section.\n", + "\n", + "### MPS simulation\n", + "\n", + "For a one-dimensional system, matrix-product-state (MPS) methods can efficiently simulate both ground-state preparation (via DMRG) and circuit-level time evolution. By controlling the bond dimension $\\chi$, one trades off accuracy against computational cost. In this tutorial we use MPS simulation within `qiskit-addon-aqc-tensor` to compute high-fidelity AQC ansätze that compress the deep Trotter circuits for hardware execution." + ] + }, + { + "cell_type": "markdown", + "id": "de1ad5a2", + "metadata": {}, + "source": [ + "## Requirements\n", + "Before starting this tutorial, be sure you have the following installed:\n", + "\n", + "- Qiskit SDK with visualization extras (`pip install qiskit[visualization]`)\n", + "- Qiskit Runtime (`pip install qiskit-ibm-runtime`)\n", + "- qiskit-addon-aqc-tensor with quimb and JAX extras (`pip install 'qiskit-addon-aqc-tensor[quimb-jax]'`)" + ] + }, + { + "cell_type": "markdown", + "id": "9938e4bd", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "71835ff6", + "metadata": {}, + "outputs": [], + "source": [ + "import timeit\n", + "from functools import partial\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import quimb as qu\n", + "import quimb.tensor as qtn\n", + "import scipy.optimize\n", + "import scipy.sparse.linalg\n", + "from numpy.typing import NDArray\n", + "from qiskit import QuantumCircuit\n", + "from qiskit.circuit.library import PauliEvolutionGate\n", + "from qiskit.primitives import StatevectorEstimator\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "from qiskit_addon_aqc_tensor import generate_ansatz_from_circuit\n", + "from qiskit_addon_aqc_tensor.objective import MaximizeStateFidelity\n", + "from qiskit_addon_aqc_tensor.simulation import tensornetwork_from_circuit\n", + "from qiskit_addon_aqc_tensor.simulation.quimb import QuimbSimulator\n", + "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n", + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Hamiltonian construction (exact diagonalization)\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def build_xxz_hamiltonian(\n", + " n: int, coupling: float = 1.0, coupling_z: float = 1.0\n", + ") -> SparsePauliOp:\n", + " \"\"\"Build the 1D XXZ Hamiltonian as a SparsePauliOp (open boundary).\n", + "\n", + " H = coupling * sum_i [ coupling_z * Sz_i Sz_{i+1}\n", + " + 0.5*(S+_i S-_{i+1} + S-_i S+_{i+1}) ]\n", + " = coupling/4 * sum_{nn pair} [ coupling_z * ZZ + (XX + YY) ]\n", + "\n", + " Args:\n", + " n: Number of qubits (sites).\n", + " coupling: XY coupling strength (J in the paper).\n", + " coupling_z: Ising coupling strength (Jz in the paper).\n", + "\n", + " Returns:\n", + " The XXZ Hamiltonian as a SparsePauliOp.\n", + " \"\"\"\n", + " terms = []\n", + " for i in range(n - 1):\n", + " terms.append((\"ZZ\", [i, i + 1], 0.25 * coupling * coupling_z))\n", + " terms.append((\"XX\", [i, i + 1], 0.25 * coupling))\n", + " terms.append((\"YY\", [i, i + 1], 0.25 * coupling))\n", + " return SparsePauliOp.from_sparse_list(terms, num_qubits=n)\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Trotter circuit builder (2nd-order Suzuki-Trotter)\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def trotter_circuit(\n", + " n: int,\n", + " gs_circuit: QuantumCircuit,\n", + " time_steps: int,\n", + " pair_ham: SparsePauliOp,\n", + " dt: float,\n", + " site: int,\n", + ") -> QuantumCircuit:\n", + " \"\"\"Build a 2nd-order Trotter circuit for time evolution.\n", + "\n", + " Args:\n", + " n: Number of qubits.\n", + " gs_circuit: Ground-state preparation circuit.\n", + " time_steps: Number of Trotter steps.\n", + " pair_ham: Nearest-neighbor pair Hamiltonian.\n", + " dt: Trotter time step.\n", + " site: Perturbation site (center qubit).\n", + "\n", + " Returns:\n", + " The full Trotter circuit with perturbation applied at ``site``.\n", + " \"\"\"\n", + " half_t = PauliEvolutionGate(pair_ham, time=dt / 2)\n", + " full_t = PauliEvolutionGate(pair_ham, time=dt)\n", + " qc = gs_circuit.copy()\n", + " qc.rz(np.pi / 2, site) # perturbation\n", + " for i in range(n // 2): # half even layer\n", + " qc.append(half_t, [2 * i, 2 * i + 1])\n", + " for i in range(n // 2 - 1): # full odd layer\n", + " qc.append(full_t, [2 * i + 1, 2 * i + 2])\n", + " for _ in range(time_steps - 1): # interior steps\n", + " for i in range(n // 2):\n", + " qc.append(full_t, [2 * i, 2 * i + 1])\n", + " for i in range(n // 2 - 1):\n", + " qc.append(full_t, [2 * i + 1, 2 * i + 2])\n", + " for i in range(n // 2): # half even layer\n", + " qc.append(half_t, [2 * i, 2 * i + 1])\n", + " return qc\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Mixed (AQC + Trotter) circuit\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def mixed_circuit(\n", + " n: int,\n", + " aqc_circuit: QuantumCircuit,\n", + " time_diff: int,\n", + " pair_ham: SparsePauliOp,\n", + " dt: float,\n", + ") -> QuantumCircuit:\n", + " \"\"\"Concatenate additional Trotter steps onto an AQC-compressed circuit.\n", + "\n", + " Args:\n", + " n: Number of qubits.\n", + " aqc_circuit: AQC-optimized circuit covering the first few steps.\n", + " time_diff: Number of additional Trotter steps to append.\n", + " pair_ham: Nearest-neighbor pair Hamiltonian.\n", + " dt: Trotter time step.\n", + "\n", + " Returns:\n", + " The mixed AQC + Trotter circuit.\n", + " \"\"\"\n", + " half_t = PauliEvolutionGate(pair_ham, time=dt / 2)\n", + " full_t = PauliEvolutionGate(pair_ham, time=dt)\n", + " qc = aqc_circuit.copy()\n", + " if time_diff != 0:\n", + " for i in range(n // 2):\n", + " qc.append(half_t, [2 * i, 2 * i + 1])\n", + " for i in range(n // 2 - 1):\n", + " qc.append(full_t, [2 * i + 1, 2 * i + 2])\n", + " for _ in range(time_diff - 1):\n", + " for i in range(n // 2):\n", + " qc.append(full_t, [2 * i, 2 * i + 1])\n", + " for i in range(n // 2 - 1):\n", + " qc.append(full_t, [2 * i + 1, 2 * i + 2])\n", + " for i in range(n // 2):\n", + " qc.append(half_t, [2 * i, 2 * i + 1])\n", + " return qc\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# DSF via discrete Fourier transform\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def get_dsf(\n", + " n: int,\n", + " rgf_mat: NDArray[np.floating],\n", + " dt: float,\n", + " time_steps: int,\n", + " q_steps: int,\n", + " w_steps: int,\n", + ") -> NDArray[np.floating]:\n", + " \"\"\"Compute the dynamical structure factor from the retarded Green's function.\n", + "\n", + " Uses the center-site approximation and a discrete Fourier transform.\n", + "\n", + " Args:\n", + " n: Number of qubits (sites).\n", + " rgf_mat: RGF matrix of shape ``(time_steps, n)``.\n", + " dt: Trotter time-step size.\n", + " time_steps: Number of time steps.\n", + " q_steps: Number of momentum points.\n", + " w_steps: Number of frequency points.\n", + "\n", + " Returns:\n", + " DSF array of shape ``(w_steps, q_steps)``.\n", + " \"\"\"\n", + " green = rgf_mat / 4 # sigma -> S=1/2\n", + " omega_max = np.pi / dt\n", + " q_points = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", + " omegas = np.arange(0, omega_max, omega_max / w_steps)\n", + " green_map = np.zeros((omegas.shape[0], q_points.shape[0]))\n", + " center = n // 2 - 1\n", + " for iw, w in enumerate(omegas):\n", + " exponent = np.exp(1j * w * dt * np.arange(1, time_steps + 1))\n", + " green_omega = np.dot(green.T, exponent) * dt # S(omega): time Fourier slice of the Green's function\n", + " for iq, q in enumerate(q_points):\n", + " q_matrix = np.exp(-1j * q * np.arange(-center, center + 2, 1))\n", + " green_map[iw, iq] = np.imag(np.dot(green_omega, q_matrix))\n", + " return green_map\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Plotting helpers\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def plot_dsf(\n", + " dsf: NDArray[np.floating],\n", + " dt: float,\n", + " q_steps: int,\n", + " w_steps: int,\n", + " title: str | None = None,\n", + ") -> None:\n", + " \"\"\"Heat-map of the dynamical structure factor.\n", + "\n", + " Args:\n", + " dsf: DSF array of shape ``(w_steps, q_steps)``.\n", + " dt: Trotter time-step size.\n", + " q_steps: Number of momentum points.\n", + " w_steps: Number of frequency points.\n", + " title: Optional plot title.\n", + " \"\"\"\n", + " omega_max = np.pi / dt\n", + " q_points = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", + " omegas = np.arange(0, omega_max, omega_max / w_steps)\n", + " x, y = np.meshgrid(q_points, omegas)\n", + " fig, ax = plt.subplots(figsize=(8, 5))\n", + " c = ax.pcolormesh(x, y, dsf / np.max(dsf), cmap=\"viridis\", shading=\"auto\")\n", + " fig.colorbar(c, ax=ax, label=\"Normalized intensity\")\n", + " ax.set_ylim(0, 3.6)\n", + " ax.set_xlim(0, 2 * np.pi - 2 * np.pi / q_steps)\n", + " ax.set_xlabel(r\"$q$\", fontsize=16)\n", + " ax.set_ylabel(r\"$\\tilde{\\omega} = \\omega / J$\", fontsize=16)\n", + " ax.set_xticks([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi])\n", + " ax.set_xticklabels([\"0\", r\"$\\pi/2$\", r\"$\\pi$\", r\"$3\\pi/2$\", r\"$2\\pi$\"])\n", + " if title:\n", + " ax.set_title(title, fontsize=14)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def plot_rgf(\n", + " n: int,\n", + " rgf_mat: NDArray[np.floating],\n", + " time_steps: int,\n", + " dt: float,\n", + " title: str | None = None,\n", + ") -> None:\n", + " \"\"\"Heat-map of the retarded Green's function in real space and time.\n", + "\n", + " Args:\n", + " n: Number of qubits (sites).\n", + " rgf_mat: RGF matrix of shape ``(time_steps, n)``.\n", + " time_steps: Number of time steps.\n", + " dt: Trotter time-step size.\n", + " title: Optional plot title.\n", + " \"\"\"\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + " qubit_axis = np.arange(n)\n", + " t_axis = np.arange(1, time_steps + 1) * dt\n", + " x, y = np.meshgrid(qubit_axis, t_axis)\n", + " c = ax.pcolormesh(\n", + " x,\n", + " y,\n", + " np.real(rgf_mat),\n", + " cmap=\"RdBu\",\n", + " vmax=0.5,\n", + " vmin=-0.5,\n", + " shading=\"auto\",\n", + " )\n", + " fig.colorbar(c, ax=ax, label=r\"Re $G^R(j, j_c, t)$\")\n", + " ax.set_xlabel(\"Qubit\", fontsize=16)\n", + " ax.set_ylabel(r\"Time\", fontsize=16)\n", + " if title:\n", + " ax.set_title(title, fontsize=14)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Variational ground-state ansatz (HVA)\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def build_gs_ansatz(\n", + " n: int, params: NDArray[np.floating], layers: int\n", + ") -> QuantumCircuit:\n", + " \"\"\"Build the Hamiltonian variational ansatz (HVA) circuit for\n", + " ground-state preparation of the 1D Heisenberg model.\n", + "\n", + " Starts from a product of singlet pairs and applies alternating\n", + " odd/even layers of parameterized XXZ pair-evolution gates.\n", + "\n", + " Args:\n", + " n: Number of qubits (must be even).\n", + " params: Variational parameters, length ``2 * layers``.\n", + " layers: Number of HVA layers.\n", + "\n", + " Returns:\n", + " The HVA preparation circuit.\n", + " \"\"\"\n", + " qc = QuantumCircuit(n)\n", + " # Initial singlet product state\n", + " for i in range(n // 2):\n", + " qc.x(2 * i)\n", + " qc.x(2 * i + 1)\n", + " qc.h(2 * i + 1)\n", + " qc.cx(2 * i + 1, 2 * i)\n", + " # Variational layers: each pair gate is exp(-i theta (XX+YY+ZZ)/2)\n", + " pair_ham_hva = SparsePauliOp([\"XX\", \"YY\", \"ZZ\"], coeffs=[0.5, 0.5, 0.5]) # H_pair (HVA form)\n", + " for r in range(layers):\n", + " for i in range(1, (n + 1) // 2): # odd layer\n", + " qc.append(\n", + " PauliEvolutionGate(pair_ham_hva, time=params[2 * r]),\n", + " [2 * i - 1, 2 * i],\n", + " )\n", + " for i in range(n // 2): # even layer\n", + " qc.append(\n", + " PauliEvolutionGate(pair_ham_hva, time=params[2 * r + 1]),\n", + " [2 * i, 2 * i + 1],\n", + " )\n", + " return qc\n", + "\n", + "\n", + "def optimize_gs_params(\n", + " n: int,\n", + " layers: int,\n", + " x0: NDArray[np.floating],\n", + " coupling: float = 1.0,\n", + " coupling_z: float = 1.0,\n", + " *,\n", + " max_bond: int | None = None,\n", + " cutoff: float = 1e-10,\n", + " method: str = \"COBYQA\",\n", + " options: dict | None = None,\n", + ") -> tuple[NDArray[np.floating], float]:\n", + " \"\"\"Optimize HVA parameters by minimizing ```` via quimb ``CircuitMPS``.\n", + "\n", + " The HVA circuit is simulated as a matrix product state with the given\n", + " bond-dimension truncation, and ```` is evaluated as a sum of\n", + " nearest-neighbor pair terms ``coupling/4 * (coupling_z*ZZ + XX + YY)``.\n", + "\n", + " Args:\n", + " n: Number of qubits (sites).\n", + " layers: Number of HVA layers (length of ``x0`` must be ``2 * layers``).\n", + " x0: Initial parameters.\n", + " coupling: XY coupling strength (J in the paper).\n", + " coupling_z: Ising coupling strength (Jz in the paper).\n", + " max_bond: Maximum MPS bond dimension during gate application.\n", + " cutoff: Singular-value cutoff during gate application.\n", + " method: ``scipy.optimize.minimize`` method.\n", + " options: Options dict forwarded to ``scipy.optimize.minimize``.\n", + "\n", + " Returns:\n", + " ``(optimized_params, optimized_energy)``.\n", + " \"\"\"\n", + " zz = qu.pauli(\"Z\") & qu.pauli(\"Z\")\n", + " xx = qu.pauli(\"X\") & qu.pauli(\"X\")\n", + " yy = qu.pauli(\"Y\") & qu.pauli(\"Y\")\n", + " pair = 0.25 * coupling * (coupling_z * zz + xx + yy)\n", + " terms = {(i, i + 1): pair for i in range(n - 1)}\n", + "\n", + " sim = QuimbSimulator(\n", + " quimb_circuit_factory=partial(\n", + " qtn.CircuitMPS, gate_opts=dict(cutoff=cutoff, max_bond=max_bond)\n", + " ),\n", + " )\n", + "\n", + " def energy(params: NDArray[np.floating]) -> float:\n", + " qc = build_gs_ansatz(n, params, layers).decompose([\"PauliEvolution\"])\n", + " circ = tensornetwork_from_circuit(qc, sim)\n", + " return circ.psi.compute_local_expectation(terms, normalized=True).real\n", + "\n", + " result = scipy.optimize.minimize(\n", + " energy, np.asarray(x0), method=method, options=options\n", + " )\n", + " return result.x, result.fun" + ] + }, + { + "cell_type": "markdown", + "id": "d28d01a6", + "metadata": {}, + "source": [ + "## Small-scale simulator example\n", + "\n", + "We first demonstrate the full workflow on **10 qubits**, optimizing the HVA ground-state ansatz via MPS simulation and using Qiskit's statevector simulator for time evolution. Exact diagonalization gives a reference ground-state energy. This small-scale example lets us validate every step before scaling up." + ] + }, + { + "cell_type": "markdown", + "id": "3818ed8f", + "metadata": {}, + "source": [ + "### Step 1: Map classical inputs to a quantum problem\n", + "\n", + "We begin by defining the physical model and constructing the quantum circuits.\n", + "\n", + "**Hamiltonian.** KCuF$_3$ is modelled by the 1D XXZ Hamiltonian at the isotropic point ($J = J_z = 1$, setting $2J = 1$ as the energy unit).\n", + "\n", + "**Ground state.** We use a Hamiltonian variational ansatz (HVA) circuit, `build_gs_ansatz`, as the ground-state preparation circuit. The HVA parameters are optimized classically by minimizing $\\langle\\psi_{\\mathrm{HVA}}(\\theta)|H|\\psi_{\\mathrm{HVA}}(\\theta)\\rangle$, where the energy is evaluated by simulating the HVA circuit as a matrix product state with quimb's `CircuitMPS` and summing the nearest-neighbor pair-term expectation values. We use `scipy.optimize.minimize` for the optimization. At 10 qubits, exact diagonalization is also tractable, so we additionally compute the exact ground-state energy as a reference to gauge the quality of the HVA solution.\n", + "\n", + "**Trotter gates.** Each nearest-neighbor interaction term $e^{-i\\Delta t\\, H_{\\mathrm{pair}}}$ with $H_{\\mathrm{pair}} = (J/4)(XX + YY + ZZ)$ is constructed via `PauliEvolutionGate(H_pair, time=dt)`. Qiskit synthesizes this into the optimal three-CNOT decomposition during transpilation.\n", + "\n", + "**Perturbation.** An $R_z(\\pi/2)$ gate on the center qubit implements $U_{j_c} = \\frac{1}{\\sqrt{2}}(I - i\\sigma^z_{j_c})$, mimicking the local spin-flip produced by a scattered neutron.\n", + "\n", + "**Observables.** We construct a $\\sigma^z$ observable for each qubit site. These `SparsePauliOp` objects are passed to the Estimator primitive in Step 3 to extract $\\langle\\sigma_i^z\\rangle$ at every time step." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "58305fbc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exact ground-state energy: -4.258035\n", + "Optimizing ground state ansatz...\n", + "Finished optimizing ground state ansatz in 23.29955880000489 seconds.\n", + "Ground state ansatz energy: -4.239831\n", + "Built 10 circuits, deepest depth = 85\n", + "Defined 10 Z observables.\n" + ] + } + ], + "source": [ + "# -- Physical parameters --\n", + "n = 10\n", + "coupling = 1.0 # J\n", + "coupling_z = 1.0 # Jz\n", + "dt = 0.6\n", + "time_steps = 10\n", + "center = n // 2 - 1\n", + "\n", + "# -- Exact Hamiltonian and ground-state energy --\n", + "ham_op = build_xxz_hamiltonian(n, coupling, coupling_z) # H\n", + "ham_mat = ham_op.to_matrix(sparse=True) # H (sparse matrix)\n", + "(exact_energy,), _ = scipy.sparse.linalg.eigsh(ham_mat, k=1, which=\"SA\")\n", + "print(f\"Exact ground-state energy: {exact_energy:.6f}\")\n", + "\n", + "# -- Optimize HVA parameters by minimizing via MPS simulation --\n", + "gs_layers = 3\n", + "# Initialize odd-layer angles near 0 (where the inter-pair gate is the\n", + "# identity) and even-layer angles near pi/2 (where the intra-pair gate\n", + "# is a SWAP, since 0.5*(XX + YY + ZZ) = SWAP - I/2).\n", + "rng = np.random.default_rng(12345)\n", + "x0_init = np.tile([0, np.pi / 2], gs_layers) + rng.normal(\n", + " scale=0.1, size=2 * gs_layers\n", + ")\n", + "print(\"Optimizing ground state ansatz...\")\n", + "t0 = timeit.default_timer()\n", + "gs_params, hva_energy = optimize_gs_params(\n", + " n,\n", + " gs_layers,\n", + " x0_init,\n", + " coupling=coupling,\n", + " coupling_z=coupling_z,\n", + " max_bond=32,\n", + " cutoff=1e-10,\n", + ")\n", + "t1 = timeit.default_timer()\n", + "print(f\"Finished optimizing ground state ansatz in {t1 - t0} seconds.\")\n", + "print(f\"Ground state ansatz energy: {hva_energy:.6f}\")\n", + "\n", + "# Decompose PauliEvolutionGate so the AQC MPS backend can ingest the\n", + "# circuits below.\n", + "gs_circuit = build_gs_ansatz(\n", + " n, gs_params, gs_layers\n", + ").decompose([\"PauliEvolution\"])\n", + "\n", + "# -- Pair Hamiltonian for Trotter gates --\n", + "pair_ham = SparsePauliOp( # H_pair\n", + " [\"XX\", \"YY\", \"ZZ\"], coeffs=[0.25 * coupling, 0.25 * coupling, 0.25 * coupling]\n", + ")\n", + "\n", + "# -- Build circuits for each time step --\n", + "# Decompose PauliEvolutionGate into RXX/RYY/RZZ so the AQC MPS backend can\n", + "# ingest the circuits; the transpiler later fuses each triple back into a\n", + "# single 3-CNOT block.\n", + "circuits = [\n", + " trotter_circuit(\n", + " n, gs_circuit, t, pair_ham, dt, center\n", + " ).decompose([\"PauliEvolution\"])\n", + " for t in range(1, time_steps + 1)\n", + "]\n", + "print(\n", + " f\"Built {len(circuits)} circuits, deepest depth = {circuits[-1].depth()}\"\n", + ")\n", + "\n", + "# -- Observables: Z on each qubit site --\n", + "observables = [\n", + " SparsePauliOp(\"I\" * (n - 1 - i) + \"Z\" + \"I\" * i)\n", + " for i in range(n)\n", + "]\n", + "print(f\"Defined {len(observables)} Z observables.\")" + ] + }, + { + "cell_type": "markdown", + "id": "39191552", + "metadata": {}, + "source": [ + "### Step 2: Optimize problem for quantum hardware execution\n", + "\n", + "For real hardware, the Trotter circuits above would be too deep. **Approximate Quantum Compiling (AQC)** addresses this by replacing the first $k$ Trotter layers (including the ground-state circuit) with a shorter parameterized ansatz optimized to maximize the MPS-level fidelity with the original deep circuit. The remaining Trotter steps are appended exactly, producing a shallower \"AQC + Trotter\" circuit.\n", + "\n", + "The AQC workflow has four sub-steps:\n", + "\n", + "1. **Build target circuits** — the first $k$ circuits from Step 1 serve directly as AQC targets.\n", + "2. **Compute target MPS** — simulate each target circuit as a matrix-product state using `quimb.tensor.CircuitMPS`.\n", + "3. **Generate and optimize ansatz** — `generate_ansatz_from_circuit` creates a parameterized ansatz; parameters are optimized via L-BFGS-B with JAX-accelerated gradients to minimize $1 - |\\langle\\psi_{\\mathrm{ansatz}}|\\psi_{\\mathrm{target}}\\rangle|^2$.\n", + "4. **Assemble mixed circuits** — for time steps beyond the AQC checkpoint, append exact Trotter layers to the optimized AQC circuit using `mixed_circuit`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e78f8d9a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step 2a — target circuit depths:\n", + " k=1: depth = 31\n", + " k=2: depth = 37\n", + " k=3: depth = 43\n", + "\n", + "Step 2b — target MPS:\n", + " k=1: max bond = 22\n", + " k=2: max bond = 22\n", + " k=3: max bond = 23\n", + "\n", + "Step 2c — ansatz: 389 parameters, depth = 19\n", + " k=1: fidelity = 1.0000, depth = 19, 11.1s\n", + " k=2: fidelity = 0.9993, depth = 19, 13.2s\n", + " k=3: fidelity = 0.9985, depth = 19, 14.1s\n", + "\n", + "Step 2d — assembled 10 circuits\n", + " Depth at step 10: Trotter = 85, AQC+Trotter = 64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aqc_steps = 3\n", + "\n", + "# ── Step 2a: Target circuits (first aqc_steps circuits from Step 1) ──\n", + "target_circuits = {\n", + " k: circuits[k - 1] for k in range(1, aqc_steps + 1)\n", + "}\n", + "print(\"Step 2a — target circuit depths:\")\n", + "for k, qc in target_circuits.items():\n", + " print(f\" k={k}: depth = {qc.depth()}\")\n", + "\n", + "# ── Step 2b: Compute target MPS ──\n", + "aqc_sim = QuimbSimulator(\n", + " quimb_circuit_factory=partial(\n", + " qtn.CircuitMPS, gate_opts=dict(cutoff=1e-8, max_bond=32)\n", + " ),\n", + " autodiff_backend=\"jax\",\n", + ")\n", + "print(\"\\nStep 2b — target MPS:\")\n", + "target_mps = {}\n", + "for k in range(1, aqc_steps + 1):\n", + " target_mps[k] = tensornetwork_from_circuit(\n", + " target_circuits[k], aqc_sim\n", + " )\n", + " print(f\" k={k}: max bond = {target_mps[k].psi.max_bond()}\")\n", + "\n", + "# ── Step 2c: Generate ansatz and optimize parameters ──\n", + "ansatz, initial_params = generate_ansatz_from_circuit(\n", + " target_circuits[1], qubits_initially_zero=True\n", + ")\n", + "initial_params = np.array(initial_params)\n", + "print(\n", + " f\"\\nStep 2c — ansatz: {ansatz.num_parameters} parameters, depth = {ansatz.depth()}\"\n", + ")\n", + "\n", + "aqc_circuits = {}\n", + "aqc_params = {}\n", + "for k in range(1, aqc_steps + 1):\n", + " x0 = aqc_params.get(k - 1, initial_params)\n", + " obj = MaximizeStateFidelity(\n", + " target_mps[k], ansatz, aqc_sim\n", + " )\n", + " t0 = timeit.default_timer()\n", + " result = scipy.optimize.minimize(\n", + " obj.loss_function,\n", + " x0,\n", + " method=\"L-BFGS-B\",\n", + " jac=True,\n", + " options=dict(maxiter=300),\n", + " )\n", + " elapsed = timeit.default_timer() - t0\n", + " aqc_params[k] = result.x\n", + " aqc_circuits[k] = ansatz.assign_parameters(result.x)\n", + " print(\n", + " f\" k={k}: fidelity = {1 - result.fun:.4f}, depth = {aqc_circuits[k].depth()}, {elapsed:.1f}s\"\n", + " )\n", + "\n", + "# ── Step 2d: Assemble full circuit set (AQC + Trotter) ──\n", + "all_circuits = []\n", + "for k in range(1, aqc_steps + 1):\n", + " all_circuits.append(aqc_circuits[k])\n", + "for k in range(1, time_steps - aqc_steps + 1):\n", + " all_circuits.append(\n", + " mixed_circuit(\n", + " n, aqc_circuits[aqc_steps], k, pair_ham, dt\n", + " ).decompose([\"PauliEvolution\"])\n", + " )\n", + "\n", + "full_depths = [\n", + " circuits[k - 1].depth() for k in range(1, time_steps + 1)\n", + "]\n", + "aqc_depths = [qc.depth() for qc in all_circuits]\n", + "print(f\"\\nStep 2d — assembled {len(all_circuits)} circuits\")\n", + "print(\n", + " f\" Depth at step {time_steps}: Trotter = {full_depths[-1]}, AQC+Trotter = {aqc_depths[-1]}\"\n", + ")\n", + "\n", + "steps_axis = np.arange(1, time_steps + 1)\n", + "fig, ax = plt.subplots(figsize=(7, 4))\n", + "ax.plot(steps_axis, full_depths, \"-o\", color=\"black\", label=\"Full Trotter\")\n", + "ax.plot(\n", + " steps_axis, aqc_depths, \"-o\", color=\"cadetblue\", label=\"AQC + Trotter\"\n", + ")\n", + "ax.set_xlabel(\"Trotter steps\", fontsize=13)\n", + "ax.set_ylabel(\"Circuit depth\", fontsize=13)\n", + "ax.set_title(f\"AQC circuit-depth reduction ({n} qubits)\", fontsize=13)\n", + "ax.legend(fontsize=11)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "43ad6048", + "metadata": {}, + "source": [ + "### Step 3: Execute using Qiskit primitives\n", + "\n", + "We simulate each AQC-compiled circuit using the `StatevectorEstimator` primitive and extract the expectation value $\\langle\\sigma_i^z\\rangle$ for every qubit $i$ at each time step $t$. These values form the retarded Green's function matrix $G^R(j, j_c, t)$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b8f9e41c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Completed time step 5/10\n", + " Completed time step 10/10\n", + "RGF matrix shape: (10, 10)\n" + ] + } + ], + "source": [ + "estimator = StatevectorEstimator()\n", + "rgf_mat = np.zeros((time_steps, n))\n", + "\n", + "for t_idx, qc in enumerate(all_circuits):\n", + " pub = (qc, observables)\n", + " job = estimator.run([pub])\n", + " result = job.result()\n", + " rgf_mat[t_idx, :] = result[0].data.evs\n", + "\n", + " if (t_idx + 1) % 5 == 0:\n", + " print(f\" Completed time step {t_idx + 1}/{time_steps}\")\n", + "\n", + "print(f\"RGF matrix shape: {rgf_mat.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cb12662c", + "metadata": {}, + "source": [ + "### Step 4: Post-process and return result in desired classical format\n", + "\n", + "We now Fourier-transform the RGF into the dynamical structure factor $S(q, \\omega)$, apply mirror symmetry, clip negative values, and plot both the RGF and the DSF." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4585d139", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# -- Compute DSF --\n", + "q_res, w_res = 100, 100\n", + "spectrum = get_dsf(n, rgf_mat, dt, time_steps, q_res, w_res)\n", + "spectrum = -(spectrum + spectrum[:, ::-1]) / 2\n", + "spectrum = np.clip(spectrum, a_min=0, a_max=None)\n", + "\n", + "# -- Plot retarded Green's function --\n", + "plot_rgf(\n", + " n,\n", + " rgf_mat,\n", + " time_steps,\n", + " dt,\n", + " title=f\"Retarded Green's function — {n} qubits (simulation)\",\n", + ")\n", + "\n", + "# -- Plot DSF --\n", + "plot_dsf(\n", + " spectrum,\n", + " dt,\n", + " q_res,\n", + " w_res,\n", + " title=f\"Dynamical structure factor — {n} qubits (simulation)\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ls-intro", + "metadata": {}, + "source": [ + "## Large-scale hardware execution\n", + "\n", + "We now scale up to **20 qubits**. Note that the paper scaled to 50 qubits, but reaching that scale required a large amount of computational resources to run AQC.\n", + "\n", + "The code below follows the same four-step structure as the small-scale example. The HVA ground-state parameters are again optimized via MPS simulation, this time with a smaller bond-dimension budget that matches the AQC settings. The following table summarizes how the large-scale experiment differs from the small-scale one:\n", + "\n", + "| | Small scale | Large scale |\n", + "|---|---|---|\n", + "| Qubits | 10 | 20 |\n", + "| Time steps | 10 | 20 |\n", + "| AQC checkpoints | 3 | 5 |\n", + "| HVA layers | 3 | 6 |\n", + "| Reference ground-state energy | Exact diagonalization | DMRG |\n", + "| MPS max bond dimension | 32 | 10 |\n", + "| Estimator | `StatevectorEstimator` | QPU with DD + Pauli twirling + TREX |" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fbe57e1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ground-state energy (DMRG): -8.682473\n", + "Optimizing ground state ansatz...\n", + "Finished optimizing ground state ansatz in 90.11342196702026 seconds.\n", + "Ground state ansatz energy: -8.559921\n", + "Built 20 circuits, deepest depth = 163\n", + "Ansatz: 1327 parameters, depth = 31\n", + " k=1: fidelity = 0.9874, depth = 31, 56.2s\n", + " k=2: fidelity = 0.9652, depth = 31, 55.9s\n", + " k=3: fidelity = 0.9207, depth = 31, 56.3s\n", + " k=4: fidelity = 0.8801, depth = 31, 57.4s\n", + " k=5: fidelity = 0.8623, depth = 31, 56.9s\n", + "Backend: ibm_miami\n", + "Job 1: d8qr4gmab0ds73dqtid0\n", + "Job 2: d8qr4gq01fac73d3i3vg\n" + ] + } + ], + "source": [ + "# ── Parameters ──────────────────────────────────────────────────────────────\n", + "n = 20 # 10 → 20\n", + "coupling = 1.0 # J\n", + "coupling_z = 1.0 # Jz\n", + "dt = 0.6\n", + "time_steps = 20 # 10 → 20\n", + "center = n // 2 - 1\n", + "aqc_steps = 5 # 3 → 5\n", + "gs_layers = 6 # 3 → 6\n", + "\n", + "# ── Step 1: Map ──────────────────────────────────────────────────────────────\n", + "# Ground-state energy via DMRG (substitute for exact diagonalization)\n", + "builder = qtn.SpinHam1D(S=1 / 2)\n", + "builder += coupling * 0.5, \"+\", \"-\"\n", + "builder += coupling * 0.5, \"-\", \"+\"\n", + "builder += coupling_z, \"Z\", \"Z\"\n", + "ham_mpo = builder.build_mpo(L=n) # H (as MPO)\n", + "dmrg = qtn.DMRG2(ham_mpo, cutoffs=1e-10)\n", + "dmrg.solve(tol=1e-10, verbosity=0)\n", + "print(f\"Ground-state energy (DMRG): {dmrg.energy:.6f}\")\n", + "\n", + "# Optimize HVA parameters by minimizing via MPS simulation. Truncation\n", + "# (max_bond=10, cutoff=1e-4) matches the AQC settings used below.\n", + "# Same near-identity / near-SWAP init as the small-scale case.\n", + "rng = np.random.default_rng(12345)\n", + "x0_init = np.tile([0.0, np.pi / 2], gs_layers) + rng.normal(\n", + " scale=0.1, size=2 * gs_layers\n", + ")\n", + "print(\"Optimizing ground state ansatz...\")\n", + "t0 = timeit.default_timer()\n", + "gs_params, hva_energy = optimize_gs_params(\n", + " n,\n", + " gs_layers,\n", + " x0_init,\n", + " coupling=coupling,\n", + " coupling_z=coupling_z,\n", + " max_bond=10,\n", + " cutoff=1e-4,\n", + ")\n", + "t1 = timeit.default_timer()\n", + "print(f\"Finished optimizing ground state ansatz in {t1 - t0} seconds.\")\n", + "print(f\"Ground state ansatz energy: {hva_energy:.6f}\")\n", + "\n", + "gs_circuit = build_gs_ansatz(\n", + " n, gs_params, gs_layers\n", + ").decompose([\"PauliEvolution\"])\n", + "\n", + "pair_ham = SparsePauliOp( # H_pair\n", + " [\"XX\", \"YY\", \"ZZ\"], coeffs=[0.25 * coupling, 0.25 * coupling, 0.25 * coupling]\n", + ")\n", + "\n", + "# Decompose PauliEvolutionGate into RXX/RYY/RZZ so the AQC MPS backend can\n", + "# ingest the circuits; the transpiler later fuses each triple back into a\n", + "# single 3-CNOT block.\n", + "circuits = [\n", + " trotter_circuit(\n", + " n, gs_circuit, t, pair_ham, dt, center\n", + " ).decompose([\"PauliEvolution\"])\n", + " for t in range(1, time_steps + 1)\n", + "]\n", + "print(\n", + " f\"Built {len(circuits)} circuits, deepest depth = {circuits[-1].depth()}\"\n", + ")\n", + "\n", + "observables = [\n", + " SparsePauliOp(\"I\" * (n - 1 - i) + \"Z\" + \"I\" * i)\n", + " for i in range(n)\n", + "]\n", + "\n", + "# ── Step 2: AQC ──────────────────────────────────────────────────────────────\n", + "target_circuits = {\n", + " k: circuits[k - 1] for k in range(1, aqc_steps + 1)\n", + "}\n", + "\n", + "aqc_sim = QuimbSimulator(\n", + " quimb_circuit_factory=partial(\n", + " qtn.CircuitMPS,\n", + " gate_opts=dict(cutoff=1e-4, max_bond=10), # truncated (32 → 10)\n", + " ),\n", + " autodiff_backend=\"jax\",\n", + ")\n", + "\n", + "target_mps = {}\n", + "for k in range(1, aqc_steps + 1):\n", + " target_mps[k] = tensornetwork_from_circuit(\n", + " target_circuits[k], aqc_sim\n", + " )\n", + "\n", + "ansatz, initial_params = generate_ansatz_from_circuit(\n", + " target_circuits[1], qubits_initially_zero=True\n", + ")\n", + "initial_params = np.array(initial_params)\n", + "print(\n", + " f\"Ansatz: {ansatz.num_parameters} parameters, depth = {ansatz.depth()}\"\n", + ")\n", + "\n", + "aqc_circuits = {}\n", + "aqc_params = {}\n", + "for k in range(1, aqc_steps + 1):\n", + " x0 = aqc_params.get(k - 1, initial_params)\n", + " obj = MaximizeStateFidelity(\n", + " target_mps[k], ansatz, aqc_sim\n", + " )\n", + " t0 = timeit.default_timer()\n", + " result = scipy.optimize.minimize(\n", + " obj.loss_function,\n", + " x0,\n", + " method=\"L-BFGS-B\",\n", + " jac=True,\n", + " options=dict(maxiter=10),\n", + " )\n", + " elapsed = timeit.default_timer() - t0\n", + " aqc_params[k] = result.x\n", + " aqc_circuits[k] = ansatz.assign_parameters(result.x)\n", + " print(\n", + " f\" k={k}: fidelity = {1 - result.fun:.4f}, depth = {aqc_circuits[k].depth()}, {elapsed:.1f}s\"\n", + " )\n", + "\n", + "all_circuits = []\n", + "for k in range(1, aqc_steps + 1):\n", + " all_circuits.append(aqc_circuits[k])\n", + "for k in range(1, time_steps - aqc_steps + 1):\n", + " all_circuits.append(\n", + " mixed_circuit(\n", + " n,\n", + " aqc_circuits[aqc_steps],\n", + " k,\n", + " pair_ham,\n", + " dt,\n", + " ).decompose([\"PauliEvolution\"])\n", + " )\n", + "\n", + "# ── Step 3: Execute on IBM Quantum hardware ───────────────────────────────────\n", + "# (replaces StatevectorEstimator)\n", + "service = QiskitRuntimeService()\n", + "backend = service.least_busy(\n", + " min_num_qubits=n, operational=True, simulator=False\n", + ")\n", + "print(f\"Backend: {backend.name}\")\n", + "\n", + "pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", + "isa_circuits = pm.run(all_circuits, num_processes=1)\n", + "isa_obs = [\n", + " SparsePauliOp.from_list(\n", + " [(\"I\" * i + \"Z\" + \"I\" * (n - i - 1), 1)]\n", + " ).apply_layout(isa_circuits[0].layout)\n", + " for i in range(n)\n", + "]\n", + "\n", + "estimator = Estimator(backend)\n", + "estimator.options.dynamical_decoupling.enable = True\n", + "estimator.options.dynamical_decoupling.sequence_type = \"XY4\"\n", + "estimator.options.twirling.enable_gates = True\n", + "estimator.options.twirling.num_randomizations = 1000\n", + "estimator.options.twirling.shots_per_randomization = 128\n", + "estimator.options.resilience.measure_mitigation = True\n", + "estimator.options.resilience.measure_noise_learning.num_randomizations = 32\n", + "estimator.options.resilience.measure_noise_learning.shots_per_randomization = 100\n", + "\n", + "mid = time_steps // 2\n", + "pubs = [(qc, isa_obs) for qc in isa_circuits]\n", + "job_1 = estimator.run(pubs[:mid])\n", + "job_2 = estimator.run(pubs[mid:])\n", + "print(f\"Job 1: {job_1.job_id()}\")\n", + "print(f\"Job 2: {job_2.job_id()}\")\n", + "\n", + "result_1 = job_1.result()\n", + "result_2 = job_2.result()\n", + "\n", + "rgf_mat = np.zeros((time_steps, n))\n", + "for i in range(mid):\n", + " rgf_mat[i, :] = result_1[i].data.evs[::-1]\n", + "for i in range(time_steps - mid):\n", + " rgf_mat[mid + i, :] = result_2[i].data.evs[::-1]\n", + "\n", + "# ── Step 4: Post-process ──────────────────────────────────────────────────────\n", + "q_res, w_res = 100, 100\n", + "spectrum = get_dsf(n, rgf_mat, dt, time_steps, q_res, w_res)\n", + "spectrum = -(spectrum + spectrum[:, ::-1]) / 2\n", + "spectrum = np.clip(spectrum, a_min=0, a_max=None)\n", + "\n", + "plot_rgf(\n", + " n,\n", + " rgf_mat,\n", + " time_steps,\n", + " dt,\n", + " title=f\"Retarded Green's function — {n} qubits (QPU)\",\n", + ")\n", + "plot_dsf(\n", + " spectrum,\n", + " dt,\n", + " q_res,\n", + " w_res,\n", + " title=rf\"KCuF$_3$ DSF — {n} qubits (QPU)\"\n", + " \"\\n(AQC + DD + Pauli twirling + TREX)\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ls-nextsteps", + "metadata": {}, + "source": [ + "## Next steps\n", + "If you found this work interesting, you might be interested in the following material:\n", + "\n", + "\n", + "- [Lee et al., \"Benchmarking quantum simulation with neutron-scattering experiments\" (arXiv:2603.15608)](https://arxiv.org/abs/2603.15608) — the reference paper this tutorial is based on\n", + "- [Error Suppression and Mitigation with Qiskit Runtime](https://docs.quantum.ibm.com/guides/error-mitigation-and-suppression-techniques) — DD, Pauli twirling, and TREX used in the hardware experiments\n", + "- [Approximate quantum compilation for time evolution circuits](https://quantum.cloud.ibm.com/docs/en/tutorials/approximate-quantum-compilation-for-time-evolution) — tutorial on AQC-Tensor\n", + "- [AQC-Tensor documentation](https://qiskit.github.io/qiskit-addon-aqc-tensor/)\n", + "\n", + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-0.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-0.avif new file mode 100644 index 00000000000..ff664325c79 Binary files /dev/null and b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-0.avif differ diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-1.avif new file mode 100644 index 00000000000..749d83f7a40 Binary files /dev/null and b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-1.avif differ diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/e78f8d9a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/e78f8d9a-1.avif new file mode 100644 index 00000000000..b7a12c838a5 Binary files /dev/null and b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/e78f8d9a-1.avif differ diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-1.avif new file mode 100644 index 00000000000..cf175c90574 Binary files /dev/null and b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-1.avif differ diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-2.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-2.avif new file mode 100644 index 00000000000..a0a6728e54d Binary files /dev/null and b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-2.avif differ