diff --git a/docs/sphinx/applications/python/images/speedup.png b/docs/sphinx/applications/python/images/speedup.png new file mode 100644 index 00000000000..2b109b960a3 Binary files /dev/null and b/docs/sphinx/applications/python/images/speedup.png differ diff --git a/docs/sphinx/applications/python/skqd.ipynb b/docs/sphinx/applications/python/skqd.ipynb index b1da41c5f76..16a2c27343e 100644 --- a/docs/sphinx/applications/python/skqd.ipynb +++ b/docs/sphinx/applications/python/skqd.ipynb @@ -1,411 +1,452 @@ { - "cells": [{ - "cell_type": - "markdown", - "id": - "b26c5874", - "metadata": {}, - "source": [ - "# Sample-Based Krylov Quantum Diagonalization (SKQD)\n", "\n", - "**Sample-Based Krylov Quantum Diagonalization (SKQD)** is a hybrid quantum-classical algorithm that combines the theoretical guarantees of Krylov Quantum Diagonalization (KQD) with the practical efficiency of sample-based methods. Instead of expensive quantum measurements to compute Hamiltonian matrix elements, SKQD samples from quantum states to construct a computational subspace, then diagonalizes the Hamiltonian within that subspace classically.\n", - "\n", "## Why SKQD?\n", "\n", - "Traditional quantum algorithms like VQE face several fundamental challenges:\n", - "\n", - "- **Optimization complexity**: VQE requires optimizing many variational parameters in a high-dimensional, non-convex landscape\n", - "- **Measurement overhead**: Computing expectation values $\\langle\\psi(\\theta)|H|\\psi(\\theta)\\rangle$ requires many measurements for each Pauli term\n", - "- **Barren plateaus**: Optimization landscapes can become exponentially flat, making gradient-based optimization ineffective\n", - "- **Parameter initialization**: Poor initial parameters can lead to local minima far from the global optimum\n", - "\n", "SKQD addresses these fundamental limitations:\n", "\n", - "- ✅ **No optimization required**: Uses deterministic quantum time evolution instead of variational circuits\n", - "- ✅ **Provable convergence**: Theoretical guarantees based on the Rayleigh-Ritz variational principle\n", - "- ✅ **Measurement efficient**: Only requires computational basis measurements (Z-basis), the most natural measurement on quantum hardware \n", - "- ✅ **Noise resilient**: Can filter out problematic measurement outcomes and handle finite sampling\n", - "- ✅ **Systematic improvement**: Increasing Krylov dimension monotonically improves ground state estimates\n", - "- ✅ **Hardware friendly**: Time evolution circuits are more amenable to near-term quantum devices than deep variational ansätze\n", - "\n", "\n", "\n" - ] - }, { - "cell_type": "markdown", - "id": "e3b64321", - "metadata": {}, - "source": ["## Setup and Imports\n", "\n", "\n"] - }, { - "cell_type": - "code", - "execution_count": - 1, - "id": - "c726160d", - "metadata": { - "execution": { - "iopub.execute_input": "2025-09-08T14:32:49.164309Z", - "iopub.status.busy": "2025-09-08T14:32:49.164205Z", - "iopub.status.idle": "2025-09-08T14:32:51.746424Z", - "shell.execute_reply": "2025-09-08T14:32:51.745880Z" - } + "cells": [ + { + "cell_type": "markdown", + "id": "64a64d79", + "metadata": {}, + "source": [ + "# Sample-Based Krylov Quantum Diagonalization (SKQD)\n", + "\n", + "**Sample-Based Krylov Quantum Diagonalization (SKQD)** is a hybrid quantum-classical algorithm that combines the theoretical guarantees of Krylov Quantum Diagonalization (KQD) with the practical efficiency of sample-based methods. Instead of expensive quantum measurements to compute Hamiltonian matrix elements, SKQD samples from quantum states to construct a computational subspace, then diagonalizes the Hamiltonian within that subspace classically.\n", + "\n", + "## Why SKQD?\n", + "\n", + "Traditional quantum algorithms like VQE face several fundamental challenges:\n", + "\n", + "- **Optimization complexity**: VQE requires optimizing many variational parameters in a high-dimensional, non-convex landscape\n", + "- **Measurement overhead**: Computing expectation values $\\langle\\psi(\\theta)|H|\\psi(\\theta)\\rangle$ requires many measurements for each Pauli term\n", + "- **Barren plateaus**: Optimization landscapes can become exponentially flat, making gradient-based optimization ineffective\n", + "- **Parameter initialization**: Poor initial parameters can lead to local minima far from the global optimum\n", + "\n", + "SKQD addresses these fundamental limitations:\n", + "\n", + "- ✅ **No optimization required**: Uses deterministic quantum time evolution instead of variational circuits\n", + "- ✅ **Provable convergence**: Theoretical guarantees based on the Rayleigh-Ritz variational principle\n", + "- ✅ **Measurement efficient**: Only requires computational basis measurements (Z-basis), the most natural measurement on quantum hardware \n", + "- ✅ **Noise resilient**: Can filter out problematic measurement outcomes and handle finite sampling\n", + "- ✅ **Systematic improvement**: Increasing Krylov dimension monotonically improves ground state estimates\n", + "- ✅ **Hardware friendly**: Time evolution circuits are more amenable to near-term quantum devices than deep variational ansätze\n", + "\n", + "\n", + "\n" + ] }, - "outputs": [{ - "name": - "stdout", - "output_type": - "stream", - "text": [ - "Using: CUDA-Q Version amd64-cu12-latest (https://github.com/NVIDIA/cuda-quantum e1958798aad2b53eea1bb398be1187da31835020)\n" + { + "cell_type": "markdown", + "id": "79bc6748", + "metadata": {}, + "source": [ + "## Understanding Krylov Subspaces\n", + "\n", + "### What is a Krylov Subspace?\n", + "\n", + "A **Krylov subspace** $\\mathcal{K}^r$ of dimension $r$ is the space spanned by vectors obtained by repeatedly applying an operator $A$ to a reference vector $|\\psi\\rangle$:\n", + "\n", + "$$\\mathcal{K}^r = \\text{span}\\{|\\psi\\rangle, A|\\psi\\rangle, A^2|\\psi\\rangle, \\ldots, A^{r-1}|\\psi\\rangle\\}$$\n", + "\n", + "\n", + "\n", + "### The SKQD Algorithm\n", + "\n", + "The key insight of SKQD is that we can:\n", + "1. **Generate** Krylov states $U^k|\\psi\\rangle$ using quantum time evolution\n", + "2. **Sample** from these states to get computational basis measurements\n", + "3. **Combine** all samples to form a computational subspace\n", + "4. **Diagonalize** the Hamiltonian within this subspace classically\n", + "\n", + "This approach is much more efficient than computing matrix elements via quantum measurements!\n" ] - }], - "source": [ - "import cudaq\n", "\n", "import numpy as np\n", - "import matplotlib.pyplot as plt\n", "\n", - "from skqd_src.pre_and_postprocessing import *\n", "\n", - "cudaq.set_target(\"nvidia\")\n", "\n", - "cudaq.set_random_seed(42)\n", "np.random.seed(43)\n", "\n", - "print(\"Using:\", cudaq.__version__)" - ] - }, { - "cell_type": - "markdown", - "id": - "375be8e5", - "metadata": {}, - "source": [ - "## Understanding Krylov Subspaces\n", "\n", - "### What is a Krylov Subspace?\n", "\n", - "A **Krylov subspace** $\\mathcal{K}^r$ of dimension $r$ is the space spanned by vectors obtained by repeatedly applying an operator $A$ to a reference vector $|\\psi\\rangle$:\n", - "\n", - "$$\\mathcal{K}^r = \\text{span}\\{|\\psi\\rangle, A|\\psi\\rangle, A^2|\\psi\\rangle, \\ldots, A^{r-1}|\\psi\\rangle\\}$$\n", - "\n", "\n", "\n", "### The SKQD Algorithm\n", "\n", - "The key insight of SKQD is that we can:\n", - "1. **Generate** Krylov states $U^k|\\psi\\rangle$ using quantum time evolution\n", - "2. **Sample** from these states to get computational basis measurements\n", - "3. **Combine** all samples to form a computational subspace\n", - "4. **Diagonalize** the Hamiltonian within this subspace classically\n", - "\n", - "This approach is much more efficient than computing matrix elements via quantum measurements!\n" - ] - }, { - "cell_type": - "code", - "execution_count": - 2, - "id": - "24ddc5de", - "metadata": { - "execution": { - "iopub.execute_input": "2025-09-08T14:32:51.766899Z", - "iopub.status.busy": "2025-09-08T14:32:51.766785Z", - "iopub.status.idle": "2025-09-08T14:32:51.772257Z", - "shell.execute_reply": "2025-09-08T14:32:51.771867Z" - } }, - "outputs": [], - "source": [ - "num_spins = 22 # Number of qubits/spins in our chain\n", - "measurement_shots = 100_000 # Number of measurements per Krylov state\n", - "\n", "# Krylov subspace parameters\n", - "krylov_subspace_dimension = 5 # Size of Krylov subspace K^r\n", - "num_trotter_steps = 8 # Trotter decomposition steps for time evolution\n", - "total_evolution_time = np.pi # Total evolution time per Krylov step\n", - "time_step = total_evolution_time / num_trotter_steps # Individual Trotter time step\n", - "\n", "# Classical eigenvalue solver configuration\n", - "eigenvalue_solver_options = {\n", " \"k\": 2,\n", - " \"which\": \"SA\"\n", "} # Find 2 smallest eigenvalues\n", - "\n", - "Jx, Jy, Jz = 1.0, 1.0, 1.0 # Coupling coefficients for Heisenberg Hamiltonian\n", - "h_x, h_y, h_z = np.ones(num_spins), np.ones(num_spins), np.ones(num_spins)\n", - "spin_hamiltonian = create_heisenberg_hamiltonian(num_spins, Jx, Jy, Jz, h_x,\n", - " h_y, h_z)\n", - "exact_ground_state_energy = -38.272304 # Exact ground state energy (computed via classical exact diagonalization)\n", - "\n", - "# Extract Hamiltonian components for CUDA-Q circuits and classical processing\n", - "hamiltonian_coefficients, pauli_operator_words, pauli_operator_strings = extract_hamiltonian_data(\n", - " spin_hamiltonian)\n", - "hamiltonian_coefficients_numpy = np.array(hamiltonian_coefficients)" - ] - }, { - "cell_type": - "markdown", - "id": - "68915ab5", - "metadata": {}, - "source": [ - "## Krylov State Generation via Repeated Evolution\n", "\n", - "For SKQD, we generate the Krylov sequence:\n", - "$$|\\psi_0\\rangle, U|\\psi_0\\rangle, U^2|\\psi_0\\rangle, \\ldots, U^{r-1}|\\psi_0\\rangle$$\n", - "\n", - "where $U = e^{-iH\\Delta t}$ is approximated via Trotter decomposition.\n", - "\n", "**Implementation Strategy**:\n", - "1. Start with reference state $|\\psi_0\\rangle$\n", - "2. Apply Trotter-decomposed time evolution $k$ times for $U^k|\\psi_0\\rangle$\n", - "3. Measure each Krylov state in computational basis\n", - "4. Accumulate measurement statistics across all Krylov powers\n", - "\n" - ] - }, { - "cell_type": - "code", - "execution_count": - 3, - "id": - "44e3422c", - "metadata": { - "execution": { - "iopub.execute_input": "2025-09-08T14:32:51.773472Z", - "iopub.status.busy": "2025-09-08T14:32:51.773267Z", - "iopub.status.idle": "2025-09-08T14:32:51.783809Z", - "shell.execute_reply": "2025-09-08T14:32:51.783445Z" - } + { + "cell_type": "code", + "execution_count": 1, + "id": "568f214d", + "metadata": {}, + "outputs": [], + "source": [ + "import cudaq\n", + "import matplotlib.pyplot as plt\n", + "import cupy as cp\n", + "import numpy as np\n", + "from skqd_src.pre_and_postprocessing import *\n", + "\n", + "use_gpu = True #this is for postprocessing, the quantum circuit simulation is done on GPU via the nvidia target using CUDA-Q\n", + "if use_gpu == True:\n", + " from cupyx.scipy.sparse import csr_matrix\n", + " from cupyx.scipy.sparse.linalg import eigsh\n", + "else: \n", + " from scipy.sparse import csr_matrix\n", + " from scipy.sparse.linalg import eigsh\n", + "\n", + "\n", + "cudaq.set_target('nvidia') \n", + "cudaq.set_random_seed(42)\n", + "np.random.seed(43)\n", + "cp.random.seed(44)\n" + ] }, - "outputs": [], - "source": [ - "@cudaq.kernel\n", "def quantum_krylov_evolution_circuit(\n", - " num_qubits: int, krylov_power: int, trotter_steps: int,\n", - " time_step: float, pauli_operator_words: list[cudaq.pauli_word],\n", - " hamiltonian_coefficients: list[float]):\n", " \"\"\"\n", - " CUDA-Q kernel for generating Krylov states via quantum time evolution.\n", - " \n", - " This kernel implements the core quantum computation of SKQD:\n", - " 1. Prepare Néel reference state |ψ⟩ = |010101...⟩\n", - " 2. Apply time evolution U = e^{-iH*dt} using Trotter decomposition \n", - " 3. Repeat k times to get U^k|ψ⟩\n", - " 4. Measure in computational basis\n", " \"\"\"\n", "\n", - " # Allocate quantum register\n", - " qubits = cudaq.qvector(num_qubits)\n", "\n", - " # Step 1: Prepare Néel state as reference |010101...⟩\n", - " for qubit_index in range(num_qubits):\n", - " if qubit_index % 2 == 0:\n", - " x(qubits[qubit_index])\n", "\n", - " # Step 2: Apply time evolution U^k = (e^{-iH*dt})^k\n", - " for _ in range(krylov_power): # Apply U exactly k times\n", - "\n", - " # Each application of U uses Trotter decomposition: U ≈ ∏ᵢ e^{-ih_i*dt/n}\n", - " for _ in range(trotter_steps):\n", "\n", - " # Apply each Pauli term in the Hamiltonian\n", - " # exp_pauli(θ, qubits, P) implements e^{-iθP} for Pauli string P\n", - " for term_index in range(len(hamiltonian_coefficients)):\n", - "\n", - " coefficient = hamiltonian_coefficients[term_index]\n", - " pauli_term = pauli_operator_words[term_index]\n", - "\n", - " exp_pauli(coefficient * time_step, qubits, pauli_term)\n", - "\n", - " # Step 3: Measure all qubits in computational (Z) basis\n", - " mz(qubits)" - ] - }, { - "cell_type": - "markdown", - "id": - "bfe32121", - "metadata": {}, - "source": [ - "## Quantum Measurements and Sampling\n", "\n", "\n", - "### The Sampling Process\n", "\n", - "For each $k = 0, 1, 2, \\ldots, r-1$:\n", - "1. **Prepare** the state $U^k|\\psi\\rangle$ using our quantum circuit\n", - "2. **Measure** in the computational basis many times\n", - "3. **Collect** the resulting bitstring counts\n", "\n", - "The key insight: these measurement outcomes give us a statistical representation of each Krylov state, which we can then use to construct our computational subspace classically.\n" - ] - }, { - "cell_type": - "code", - "execution_count": - 4, - "id": - "b7d39e9d", - "metadata": { - "execution": { - "iopub.execute_input": "2025-09-08T14:32:51.784748Z", - "iopub.status.busy": "2025-09-08T14:32:51.784627Z", - "iopub.status.idle": "2025-09-08T14:32:52.478971Z", - "shell.execute_reply": "2025-09-08T14:32:52.478409Z" - } + { + "cell_type": "markdown", + "id": "28cb9f2d", + "metadata": {}, + "source": [ + "## Problem Setup: 22-Qubit Heisenberg Model\n", + "\n", + "We'll demonstrate SKQD on a 1D Heisenberg spin chain with 22 qubits:\n", + "\n", + "$$H = \\sum_{i} \\left(J_x \\sigma_i^x \\sigma_{i+1}^x + J_y \\sigma_i^y \\sigma_{i+1}^y + J_z \\sigma_i^z \\sigma_{i+1}^z\\right) + \\sum_i \\left(h_x \\sigma_i^x + h_y \\sigma_i^y + h_z \\sigma_i^z\\right)$$\n" + ] }, - "outputs": [{ - "name": - "stdout", - "output_type": - "stream", - "text": [ - " • Sampling U^0|ψ⟩...\n", " • Sampling U^1|ψ⟩...\n", - " • Sampling U^2|ψ⟩...\n", " • Sampling U^3|ψ⟩...\n", - " • Sampling U^4|ψ⟩...\n" + { + "cell_type": "code", + "execution_count": 2, + "id": "85c715f1", + "metadata": {}, + "outputs": [], + "source": [ + "num_spins = 22 \n", + "\n", + "if num_spins >= 63:\n", + " raise ValueError(f\"Vectorized implementation of postprocessing supports max 62 qubits due to int64 packing. Requested: {num_spins}\")\n", + "\n", + "shots = 100_000 \n", + "\n", + "total_time_evolution = np.pi \n", + "num_trotter_steps = 8 \n", + "dt = total_time_evolution / num_trotter_steps \n", + "\n", + "max_k = 12 # largest k for U^k\n", + "\n", + "eigenvalue_solver_options = {\"k\": 2, \"which\": \"SA\"} # Find 2 smallest eigenvalues\n", + "\n", + "\n", + "\n", + "Jx, Jy, Jz = 1.0, 1.0, 1.0 \n", + "h_x, h_y, h_z = np.ones(num_spins), np.ones(num_spins), np.ones(num_spins)\n", + "H = create_heisenberg_hamiltonian(num_spins, Jx, Jy, Jz, h_x, h_y, h_z)\n", + "exact_ground_state_energy = -38.272304 # Computed via exact diagonalization\n", + "hamiltonian_coefficients, pauli_words = extract_coeffs_and_paulis(H)\n", + "hamiltonian_coefficients_numpy = np.array(hamiltonian_coefficients)" ] - }], - "source": [ - "# Storage for measurement results from each Krylov state\n", - "measurement_results_all = []\n", "\n", - "# Execute quantum circuit for each Krylov power k = 0, 1, 2, ..., r-1\n", - "for krylov_power in range(krylov_subspace_dimension):\n", "\n", - " print(f\" • Sampling U^{krylov_power}|ψ⟩...\")\n", "\n", - " # Run the quantum circuit and collect measurement statistics\n", - " sampling_result = cudaq.sample(\n", - " quantum_krylov_evolution_circuit,\n", - " num_spins, # Number of qubits\n", - " krylov_power, # How many times to apply U\n", - " num_trotter_steps, # Trotter decomposition steps\n", - " time_step, # Time step per evolution\n", - " pauli_operator_words, # Hamiltonian Pauli terms\n", - " hamiltonian_coefficients, # Hamiltonian coefficients\n", - " shots_count=measurement_shots # Number of measurements\n", - " )\n", "\n", - " # Convert CUDA-Q result to standard dictionary format\n", - " measurement_dict = dict(sampling_result.items())\n", - " measurement_results_all.append(measurement_dict)\n", "\n", - "accumulated_measurement_data = accumulate_krylov_measurements(\n", - " measurement_results_all, krylov_subspace_dimension)" - ] - }, { - "cell_type": - "markdown", - "id": - "87a8788c", - "metadata": {}, - "source": [ - "## Classical Post-Processing and Diagonalization\n", "\n", - "Now comes the classical part of SKQD: we use our quantum measurement data to construct and diagonalize the Hamiltonian within each Krylov subspace.\n", - "\n", "1. **Extract basis states** from measurement counts\n", - "2. **Project Hamiltonian** onto the computational subspace spanned by these states \n", - "3. **Diagonalize** the projected Hamiltonian classically\n", - "4. **Extract ground state energy** estimate\n", "\n", "\n", "\n", - "### The SKQD Algorithm: Matrix Construction Details\n", "\n", - "The core of SKQD is constructing the effective Hamiltonian matrix within the computational subspace:\n", - "\n", - "1. **Computational Subspace Formation**: From quantum measurements, we obtain a set of computational basis states $\\{|s_1\\rangle, |s_2\\rangle, \\ldots, |s_d\\rangle\\}$ that spans our approximation to the Krylov subspace.\n", - "\n", - "2. **Matrix Element Computation**: For each Pauli term $P_k$ in the Hamiltonian with coefficient $h_k$:\n", - " $$H = \\sum_k h_k P_k$$\n", " \n", - " We compute matrix elements: $\\langle s_i | P_k | s_j \\rangle$ by applying the Pauli string $P_k$ to each basis state $|s_j\\rangle$.\n", - "\n", - "3. **Effective Hamiltonian**: The projected Hamiltonian becomes:\n", - " $$H_{\\text{eff}}[i,j] = \\sum_k h_k \\langle s_i | P_k | s_j \\rangle$$\n", - "\n" - ] - }, { - "cell_type": - "code", - "execution_count": - 5, - "id": - "56dccb91", - "metadata": { - "execution": { - "iopub.execute_input": "2025-09-08T14:32:52.481026Z", - "iopub.status.busy": "2025-09-08T14:32:52.480900Z", - "iopub.status.idle": "2025-09-08T14:33:02.212271Z", - "shell.execute_reply": "2025-09-08T14:33:02.211367Z" - } }, - "outputs": [{ - "name": - "stdout", - "output_type": - "stream", - "text": [ - "Performing classical diagonalization for each Krylov subspace...\n", - " • Krylov dimension 2\n", " • Krylov dimension 3\n", - " • Krylov dimension 4\n", " • Krylov dimension 5\n" + { + "cell_type": "markdown", + "id": "9cd4c837", + "metadata": {}, + "source": [ + "## Krylov State Generation via Repeated Evolution\n", + "\n", + "For SKQD, we generate the Krylov sequence:\n", + "$$|\\psi_0\\rangle, U|\\psi_0\\rangle, U^2|\\psi_0\\rangle, \\ldots, U^{k-1}|\\psi_0\\rangle$$\n", + "\n", + "where $U = e^{-iHT}$ is approximated via Trotter decomposition.\n", + "\n", + "**Implementation Strategy**:\n", + "1. Start with reference state $|\\psi_0\\rangle$\n", + "2. Apply Trotter-decomposed time evolution $k$ times for $U^k|\\psi_0\\rangle$\n", + "3. Measure each Krylov state in computational basis\n", + "4. Accumulate measurement statistics across all Krylov powers\n", + "\n" ] - }], - "source": [ - "# Storage for ground state energy estimates at each Krylov dimension\n", - "estimated_ground_state_energies = []\n", "\n", - "print(\"Performing classical diagonalization for each Krylov subspace...\")\n", - "\n", - "# Process each accumulated subspace (k=1,2,3,... since k=0 is just the reference state)\n", - "for subspace_index, measurement_data in enumerate(accumulated_measurement_data):\n", - "\n", - " # Extract unique computational basis states from measurement data\n", - " computational_basis_states = extract_basis_states_from_measurements(\n", - " measurement_data)\n", - " subspace_dimension = computational_basis_states.shape[0]\n", - "\n", - " # Skip k=0 case (just reference state, no interesting physics)\n", - " if subspace_index > 0:\n", "\n", - " print(f\" • Krylov dimension {subspace_index + 1}\")\n", - "\n", - " # Project Hamiltonian onto this subspace and find lowest eigenvalues\n", - " eigenvalues = diagonalize_subspace_hamiltonian(\n", - " computational_basis_states,\n", - " pauli_operator_strings,\n", - " hamiltonian_coefficients_numpy,\n", - " verbose=False,\n", - " **eigenvalue_solver_options)\n", "\n", - " # Extract ground state energy estimate (lowest eigenvalue)\n", - " ground_state_energy = np.min(eigenvalues)\n", - " estimated_ground_state_energies.append(ground_state_energy)\n", - "\n", "estimated_ground_state_energies = [\n", - " energy.get() if hasattr(energy, 'get') else energy\n", - " for energy in estimated_ground_state_energies\n", "]" - ] - }, { - "cell_type": - "markdown", - "id": - "0ee7ab01", - "metadata": {}, - "source": [ - "## Results Analysis and Convergence\n", "\n", - "Let's visualize our results and analyze how SKQD converges to the true ground state energy. This is the moment of truth - does our quantum-classical hybrid algorithm work?\n", - "\n", "### What to Expect:\n", "\n", - "- **Monotonic improvement**: Each additional Krylov dimension should give a better (lower) energy estimate\n", - "- **Convergence**: The estimates should approach the exact ground state energy \n", - "- **Diminishing returns**: Later Krylov dimensions provide smaller improvements\n", - "\n", - "The exact ground state energy for our selected Hamiltonian was computed earlier via classical exact diagonalization and will be used as the reference for comparison with SKQD results.\n" - ] - }, { - "cell_type": - "code", - "execution_count": - 13, - "id": - "13037304", - "metadata": { - "execution": { - "iopub.execute_input": "2025-09-08T14:33:02.214500Z", - "iopub.status.busy": "2025-09-08T14:33:02.214329Z", - "iopub.status.idle": "2025-09-08T14:33:02.317453Z", - "shell.execute_reply": "2025-09-08T14:33:02.316959Z" - } }, - "outputs": [{ - "data": { - "image/png": - "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", - "text/plain": ["
"] + { + "cell_type": "code", + "execution_count": 3, + "id": "44e3422c", + "metadata": { + "execution": { + "iopub.execute_input": "2025-09-08T14:32:51.773472Z", + "iopub.status.busy": "2025-09-08T14:32:51.773267Z", + "iopub.status.idle": "2025-09-08T14:32:51.783809Z", + "shell.execute_reply": "2025-09-08T14:32:51.783445Z" + } }, + "outputs": [], + "source": [ + "@cudaq.kernel\n", + "def quantum_krylov_evolution_circuit(\n", + " num_qubits: int, \n", + " krylov_power: int, \n", + " trotter_steps: int,\n", + " dt: float,\n", + " H_pauli_words: list[cudaq.pauli_word],\n", + " H_coeffs: list[float]):\n", + " \n", + " \"\"\"\n", + " Generate Krylov states via repeated time evolution.\n", + " \n", + " Args:\n", + " num_qubits: Number of qubits in the system\n", + " krylov_power: Power k for computing U^k|ψ⟩\n", + " trotter_steps: Number of Trotter steps for each U application\n", + " dt: Time step for Trotter decomposition\n", + " H_pauli_words: Pauli decomposition of Hamiltonian\n", + " H_coeffs: Coefficients for each Pauli term\n", + " \n", + " Returns:\n", + " Measurement results in computational basis\n", + " \"\"\"\n", + " \n", + " qubits = cudaq.qvector(num_qubits)\n", + "\n", + " #Prepare Néel state as reference |010101...⟩\n", + " for qubit_index in range(num_qubits):\n", + " if qubit_index % 2 == 0:\n", + " x(qubits[qubit_index])\n", + "\n", + "\n", + " for _ in range(krylov_power): #applies U^k where U = exp(-iHT)\n", + " \n", + " for _ in range(trotter_steps): #applies exp(-iHT)\n", + " \n", + " for i in range(len(H_coeffs)): #applies exp(-iHdt)\n", + " exp_pauli( -1 * H_coeffs[i] * dt, qubits, H_pauli_words[i]) #applies exp(-ihdt)\n", + "\n", + "\n", + " mz(qubits)" + ] + }, + { + "cell_type": "markdown", + "id": "981f54b4", "metadata": {}, - "output_type": "display_data" - }], - "source": [ - "# Create visualization of SKQD convergence\n", - "plt.figure(figsize=(6, 5))\n", "\n", - "krylov_dims_used = range(2, krylov_subspace_dimension + 1)\n", - "all_dims = range(1, krylov_subspace_dimension + 1)\n", "\n", - "plt.plot(krylov_dims_used,\n", - " estimated_ground_state_energies,\n", " 'o-',\n", - " linewidth=2,\n", " markersize=8,\n", - " label='SKQD')\n", "\n", - "plt.plot(all_dims, [exact_ground_state_energy] * krylov_subspace_dimension,\n", - " 'g',\n", " linewidth=2,\n", - " label='Exact ground state')\n", "\n", - "plt.xticks(all_dims)\n", - "plt.xlabel(\"Krylov Subspace Dimension\", fontsize=12)\n", - "plt.ylabel(\"Ground State Energy\", fontsize=12)\n", - "plt.title(\"Ground State Energy vs Krylov Dimension\", fontsize=14, pad=20)\n", - "plt.legend(fontsize=11)\n", "plt.grid(True, alpha=0.3)\n", "\n", - "# Add convergence analysis text\n", - "final_error = abs(estimated_ground_state_energies[-1] -\n", - " exact_ground_state_energy)\n", "plt.text(\n", - " 0.02,\n", " 0.98,\n", - " f'Final error: {final_error:.6f}\\nExact energy: {exact_ground_state_energy:.6f}',\n", - " transform=plt.gca().transAxes,\n", - " verticalalignment='top',\n", - " bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))\n", - "\n", "plt.tight_layout()\n", "\n", "plt.show()" - ] - }], + "source": [ + "## Quantum Measurements and Sampling\n", + "\n", + "\n", + "### The Sampling Process\n", + "\n", + "For each krylov power $ = 0, 1, 2, \\ldots, k-1$:\n", + "1. **Prepare** the state $U^k|\\psi\\rangle$ using our quantum circuit\n", + "2. **Measure** in the computational basis many times\n", + "3. **Collect** the resulting bitstring counts\n", + "\n", + "The key insight: these measurement outcomes give us a statistical representation of each Krylov state, which we can then use to construct our computational subspace classically.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ccca2170", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating Krylov state U^0...\n", + "Generating Krylov state U^1...\n", + "Generating Krylov state U^2...\n", + "Generating Krylov state U^3...\n", + "Generating Krylov state U^4...\n", + "Generating Krylov state U^5...\n", + "Generating Krylov state U^6...\n", + "Generating Krylov state U^7...\n", + "Generating Krylov state U^8...\n", + "Generating Krylov state U^9...\n", + "Generating Krylov state U^10...\n", + "Generating Krylov state U^11...\n" + ] + } + ], + "source": [ + "all_measurement_results = []\n", + "\n", + "for krylov_power in range(max_k):\n", + " print(f\"Generating Krylov state U^{krylov_power}...\")\n", + " \n", + " sampling_result = cudaq.sample(\n", + " quantum_krylov_evolution_circuit,\n", + " num_spins, \n", + " krylov_power, \n", + " num_trotter_steps, \n", + " dt, \n", + " pauli_words, \n", + " hamiltonian_coefficients, \n", + " shots_count=shots) \n", + " \n", + " all_measurement_results.append(dict(sampling_result.items()))\n", + " \n", + "\n", + "cumulative_results = calculate_cumulative_results(all_measurement_results)\n" + ] + }, + { + "cell_type": "markdown", + "id": "36a00631", + "metadata": {}, + "source": [ + "## Classical Post-Processing and Diagonalization\n", + "\n", + "Now comes the classical part of SKQD: we use our quantum measurement data to construct and diagonalize the Hamiltonian within each Krylov subspace.\n", + "\n", + "1. **Extract basis states** from measurement counts\n", + "2. **Project Hamiltonian** onto the computational subspace spanned by these states \n", + "3. **Diagonalize** the projected Hamiltonian classically\n", + "4. **Extract ground state energy** estimate\n", + "\n", + "\n", + "\n", + "### The SKQD Algorithm: Matrix Construction Details\n", + "\n", + "The core of SKQD is constructing the effective Hamiltonian matrix within the computational subspace:\n", + "\n", + "1. **Computational Subspace Formation**: From quantum measurements, we obtain a set of computational basis states $\\{|s_1\\rangle, |s_2\\rangle, \\ldots, |s_d\\rangle\\}$ that spans our approximation to the Krylov subspace.\n", + "\n", + "2. **Matrix Element Computation**: For each Pauli term $P_k$ in the Hamiltonian with coefficient $h_k$:\n", + " $$H = \\sum_k h_k P_k$$\n", + " \n", + " We compute matrix elements: $\\langle s_i | P_k | s_j \\rangle$ by applying the Pauli string $P_k$ to each basis state $|s_j\\rangle$.\n", + "\n", + "3. **Effective Hamiltonian**: The projected Hamiltonian becomes:\n", + " $$H_{\\text{eff}}[i,j] = \\sum_k h_k \\langle s_i | P_k | s_j \\rangle$$\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6bed2897", + "metadata": {}, + "outputs": [], + "source": [ + "energies = []\n", + "\n", + "for k in range(1, max_k):\n", + "\n", + " cumulative_subspace_results = cumulative_results[k]\n", + " basis_states = get_basis_states_as_array(cumulative_subspace_results, num_spins)\n", + " subspace_dimension = len(cumulative_subspace_results)\n", + " assert len(cumulative_subspace_results) == basis_states.shape[0]\n", + "\n", + " # matrix_rows, matrix_cols, matrix_elements = projected_hamiltonian(basis_states, pauli_words, hamiltonian_coefficients_numpy, verbose) #slower non-vectorized implementation\n", + "\n", + " #if use_gpu is True, the projected hamiltonian & eigenvalue solver are computed on the GPU\n", + " matrix_rows, matrix_cols, matrix_elements = vectorized_projected_hamiltonian(basis_states, pauli_words, hamiltonian_coefficients_numpy, use_gpu)\n", + " projected_hamiltonian = csr_matrix((matrix_elements, (matrix_rows, matrix_cols)), shape=(subspace_dimension, subspace_dimension))\n", + " eigenvalue = eigsh(projected_hamiltonian, return_eigenvectors=False, **eigenvalue_solver_options)\n", + " \n", + " energies.append(np.min(eigenvalue).item())\n" + ] + }, + { + "cell_type": "markdown", + "id": "f36b27e7", + "metadata": {}, + "source": [ + "## Results Analysis and Convergence\n", + "\n", + "Let's visualize our results and analyze how SKQD converges to the true ground state energy. This is the moment of truth - does our quantum-classical hybrid algorithm work?\n", + "\n", + "### What to Expect:\n", + "\n", + "- **Monotonic improvement**: Each additional Krylov dimension should give a better (lower) energy estimate\n", + "- **Convergence**: The estimates should approach the exact ground state energy \n", + "- **Diminishing returns**: Later Krylov dimensions provide smaller improvements\n", + "\n", + "The exact ground state energy for our selected Hamiltonian was computed earlier via classical exact diagonalization and will be used as the reference for comparison with SKQD results.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ab727651", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create visualization of SKQD convergence\n", + "\n", + "plt.figure(figsize=(5, 4))\n", + "all_dims = range(1, max_k)\n", + "\n", + "plt.plot(all_dims, energies, 'o-', linewidth=2, markersize=8, label='SKQD')\n", + "plt.plot(all_dims, [exact_ground_state_energy] * (max_k-1), 'g', linewidth=2, label='Exact ground state')\n", + "\n", + "plt.xticks(all_dims)\n", + "plt.xlabel(\"Krylov Subspace Dimension\", fontsize=12)\n", + "plt.ylabel(\"Ground State Energy\", fontsize=12)\n", + "plt.title(\"Ground State Energy vs Krylov Dimension\", fontsize=14, pad=20)\n", + "plt.legend(fontsize=11)\n", + "plt.grid(True, alpha=0.3)\n", + "\n", + "final_error = abs(energies[-1] - exact_ground_state_energy)\n", + "plt.text(0.02, 0.98, f'Final error: {final_error:.6f}\\nExact energy: {exact_ground_state_energy:.6f}',\n", + " transform=plt.gca().transAxes, verticalalignment='top',\n", + " bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "042aa6aa", + "metadata": {}, + "source": [ + "## GPU Acceleration for Postprocessing \n", + "\n", + "The critical postprocessing operations are:\n", + "\n", + "1. Hamiltonian projection onto computational subspace\n", + "\n", + "`matrix_rows, matrix_cols, matrix_elements = vectorized_projected_hamiltonian(basis_states, pauli_words, hamiltonian_coefficients_numpy, use_gpu)`\n", + "\n", + "2. Sparse matrix construction\n", + "\n", + "`projected_hamiltonian = csr_matrix((matrix_elements, (matrix_rows, matrix_cols)), shape=(subspace_dimension, subspace_dimension))`\n", + "\n", + "3. Eigenvalue computation\n", + "\n", + "`eigenvalue = eigsh(projected_hamiltonian, return_eigenvectors=False, **eigenvalue_solver_options)`\n", + "\n", + "This substantial acceleration comes from:\n", + "- **Parallel Pauli string evaluation** across thousands of basis states simultaneously\n", + "- **Vectorized matrix element computation** leveraging CUDA cores\n", + "- **GPU-optimized sparse linear algebra** via cuSPARSE library for eigenvalue solving\n", + "\n", + "The speedup becomes increasingly critical as the Krylov dimension grows, since the computational subspace dimension (and thus the matrix size) scales exponentially with k. For higher k values, GPU acceleration transforms previously intractable postprocessing into feasible computation times.\n", + "\n", + "**Note**: Set `use_gpu = True` at the beginning of the notebook to enable GPU acceleration for postprocessing. The quantum circuit simulation uses the NVIDIA target in CUDA-Q regardless of this flag." + ] + }, + { + "cell_type": "markdown", + "id": "230e700d", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2d422417", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using: CUDA-Q Version (https://github.com/NVIDIA/cuda-quantum 37053302ceb3d83684186b2a99aac500df7b847e)\n" + ] + } + ], + "source": [ + "print(\"Using:\", cudaq.__version__)" + ] + } + ], "metadata": { "kernelspec": { "display_name": "Python 3", @@ -422,7 +463,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/sphinx/applications/python/skqd_src/pre_and_postprocessing.py b/docs/sphinx/applications/python/skqd_src/pre_and_postprocessing.py index 6510b6e83d7..3c64ec7d186 100644 --- a/docs/sphinx/applications/python/skqd_src/pre_and_postprocessing.py +++ b/docs/sphinx/applications/python/skqd_src/pre_and_postprocessing.py @@ -1,270 +1,38 @@ import cudaq from cudaq import spin - from collections import Counter import numpy as np +import cupy as cp -from scipy.sparse import csr_matrix -from scipy.sparse.linalg import eigsh +def get_basis_states_as_array(results, num_spins): -def transform_state_with_pauli_operator(computational_state, - pauli_operator_string): - """ - Transform a computational basis state by applying a Pauli operator string. - - This function computes how a Pauli string acts on a computational basis state. - For example, applying "`XY`" to |01⟩ gives i|10⟩ (bit flip + phase). - - Implementation follows MSB convention: `pauli_operator_string[i]` acts on computational_state[i] - where i=0 corresponds to the most significant bit (leftmost position). - - Args: - computational_state: Binary array representing |0⟩ and |1⟩ states in MSB order - `pauli_operator_string`: String of Pauli operators (I, X, Y, Z) in MSB order - - Returns: - tuple: (transformed_state, quantum_phase) where quantum_phase is ±1 or ±1j - """ - transformed_state = computational_state.copy() - quantum_phase = 1.0 + 0j # Start with no phase; Y operators will add ±i phases - - # Apply each Pauli operator to its corresponding qubit - for qubit_position, pauli_op in enumerate(pauli_operator_string): - if pauli_op == 'I': - # Identity: no change to state or phase - continue - elif pauli_op == 'X': - # Pauli-X: bit flip |0⟩ ↔ |1⟩ - transformed_state[ - qubit_position] = 1 - transformed_state[qubit_position] - elif pauli_op == 'Y': - # Pauli-Y = i·X·Z: bit flip with phase ±i depending on initial state - if transformed_state[qubit_position] == 0: - quantum_phase *= 1j # Y|0⟩ = i|1⟩ - else: - quantum_phase *= -1j # Y|1⟩ = -i|0⟩ - transformed_state[ - qubit_position] = 1 - transformed_state[qubit_position] - elif pauli_op == 'Z': - # Pauli-Z: phase flip for |1⟩ state - if transformed_state[qubit_position] == 1: - quantum_phase *= -1 # Z|1⟩ = -|1⟩, Z|0⟩ = |0⟩ - - return transformed_state, quantum_phase - - -def construct_hamiltonian_in_subspace(pauli_operator_list, - hamiltonian_coefficients, - subspace_basis_states): - """ - Project Hamiltonian operator onto the computational subspace spanned by basis states. - - This is the heart of SKQD: instead of computing expensive quantum matrix elements, - we compute how each Pauli term in the Hamiltonian acts on our sampled basis states. - Only matrix elements between states in our subspace contribute to the final result. - - Native CUDA-Q implementation using MSB (Most Significant Bit first) convention: - - Both Pauli operator strings and basis states follow MSB bit ordering - - Pauli operator index 0 acts on qubit 0 (leftmost bit position) - - Args: - `pauli_operator_list: List of Pauli operator strings (e.g., ['IIXY', 'ZIII'])` - hamiltonian_coefficients: List of real coefficients for each Pauli operator - subspace_basis_states: Array of computational basis states defining the subspace - - Returns: - `scipy.sparse matrix representing projected Hamiltonian within the subspace` - """ - subspace_dimension = subspace_basis_states.shape[0] + ans = np.array([list(map(int, k)) for k in results.keys()]) + assert ans.shape == (len(results), num_spins) - # Create fast lookup: basis state → subspace index - # This allows O(1) checking if a transformed state is in our subspace - state_to_index_map = {} - for idx, basis_state in enumerate(subspace_basis_states): - state_key = tuple(basis_state) - state_to_index_map[state_key] = idx + return ans - # Build sparse matrix in COO format (rows, cols, values) - matrix_rows, matrix_cols, matrix_elements = [], [], [] - # For each basis state |i⟩ in our subspace... - for initial_state_idx, initial_state in enumerate(subspace_basis_states): - # For each Pauli term P_k in the Hamiltonian... - for pauli_operator, coefficient in zip(pauli_operator_list, - hamiltonian_coefficients): - # Compute P_k|i⟩ = phase × |j⟩ - final_state, phase_factor = transform_state_with_pauli_operator( - initial_state, pauli_operator) - final_state_key = tuple(final_state) - - # Only keep matrix element if |j⟩ is also in our subspace - if final_state_key in state_to_index_map: - final_state_idx = state_to_index_map[final_state_key] - matrix_rows.append(final_state_idx) - matrix_cols.append(initial_state_idx) +def calculate_cumulative_results(all_measurement_results): - # Matrix element: ⟨j|H|i⟩ = coefficient × phase_factor - hamiltonian_element = coefficient * phase_factor - - # Clean up tiny imaginary parts (should be real for Hermitian H) - if abs(hamiltonian_element.imag) < 1e-14: - hamiltonian_element = hamiltonian_element.real - matrix_elements.append(hamiltonian_element) - - # Convert to efficient sparse matrix format - return csr_matrix((matrix_elements, (matrix_rows, matrix_cols)), - shape=(subspace_dimension, subspace_dimension)) - - -def diagonalize_subspace_hamiltonian(subspace_basis_states, - pauli_operator_list, - hamiltonian_coefficients, - verbose=False, - **solver_options): - """ - Perform eigenvalue decomposition of Hamiltonian within the computational subspace. - - This function combines Hamiltonian projection and `diagonalization` into one step. - It's the final piece of SKQD: finding the lowest eigenvalues in our Krylov subspace. - - Args: - subspace_basis_states: Array of computational basis states defining the subspace - `pauli_operator_list: List of Pauli operator strings (e.g., ['IIXY', 'ZIII'])` - hamiltonian_coefficients: List of real coefficients for each Pauli operator - verbose: Enable diagnostic output - `**solver_options: Additional arguments for scipy.sparse.linalg.eigsh` - - Returns: - `numpy` array of eigenvalues from the subspace `diagonalization` - """ - if subspace_basis_states.shape[0] == 0: - return np.array([]) - - # Step 1: Project the full Hamiltonian onto our sampled subspace - projected_hamiltonian = construct_hamiltonian_in_subspace( - pauli_operator_list, hamiltonian_coefficients, subspace_basis_states) - - if verbose: - print(f"Subspace dimension: {projected_hamiltonian.shape[0]}") - print( - f"Hamiltonian sparsity: {projected_hamiltonian.nnz / (projected_hamiltonian.shape[0]**2):.4f}" - ) - - # Step 2: Find eigenvalues of the projected Hamiltonian - try: - # Use sparse eigensolver for efficiency (typically we only need a few eigenvalues) - eigenvalues = eigsh(projected_hamiltonian, - return_eigenvectors=False, - **solver_options) - return eigenvalues - except Exception as solver_error: - if verbose: - print(f"Sparse eigensolver failed: {solver_error}") - - # Fallback: use dense `diagonalization` for small matrices - if projected_hamiltonian.shape[0] <= 100: - dense_hamiltonian = projected_hamiltonian.toarray() - eigenvalues = np.linalg.eigvals(dense_hamiltonian) - - # Extract only the requested eigenvalues to match sparse solver behavior - num_eigenvalues = solver_options.get('k', min(6, len(eigenvalues))) - eigenvalue_selection = solver_options.get('which', 'SA') - if eigenvalue_selection == 'SA': # smallest algebraic eigenvalues - selected_indices = np.argsort(eigenvalues)[:num_eigenvalues] - else: - selected_indices = np.argsort(eigenvalues)[-num_eigenvalues:] - return eigenvalues[selected_indices] - else: - raise - - -def accumulate_krylov_measurements(measurement_results_sequence, - krylov_dimension): - """ - Progressively accumulate measurement outcomes from Krylov state evolution. - - This is a key insight of SKQD: instead of treating each Krylov state separately, - we combine measurements from |ψ⟩, U|ψ⟩, U²|ψ⟩, ... to build increasingly - rich computational `subspaces` that better approximate the true Krylov space. - - Args: - measurement_results_sequence: List of measurement dictionaries from each U^k|ψ⟩ - krylov_dimension: Number of Krylov states to consider - - Returns: - List of accumulated measurement dictionaries, where entry k contains - measurements from all states |ψ⟩, U|ψ⟩, ..., U^k|ψ⟩ - """ - accumulated_measurements = [] + cumulative_results = [] - # For each Krylov dimension k = 1, 2, 3, ... - for evolution_step in range(krylov_dimension): - measurement_accumulator = Counter() + running = Counter() + for d in all_measurement_results: + running += Counter(d) # add current dict to running total + cumulative_results.append(dict(running)) # store a *copy* as plain dict - # Combine measurements from all states up to U^k|ψ⟩ - for measurement_data in measurement_results_sequence[:evolution_step + - 1]: - measurement_accumulator.update(measurement_data) + return cumulative_results - # Convert back to dictionary and store - combined_measurements = dict(measurement_accumulator) - accumulated_measurements.append(combined_measurements) - return accumulated_measurements +def get_basis_states_and_index(sample_results): + basis_states_and_index = {} + for i, (k, v) in enumerate(sample_results.items()): + binary_tuple = tuple(int(bit) for bit in k) # convert '101' -> (1,0,1) + basis_states_and_index[binary_tuple] = i # assign new index -def construct_xyz_spin_hamiltonian( - system_size: int, - interaction_strengths: tuple[float, float, float] = (1.0, 1.0, 1.0), - external_field_strengths: tuple[float, float, float] = (0.0, 0.0, 0.0), - topology_type: str = "ring") -> cudaq.SpinOperator: - """ - Construct `XYZ` spin model Hamiltonian using native CUDA-Q SpinOperator framework. - - Implements the quantum many-body Hamiltonian: - H = sum_{(i,j) ∈ edges} [J_x σ_i^x σ_j^x + J_y σ_i^y σ_j^y + J_z σ_i^z σ_j^z] + - sum_{i ∈ sites} [h_x σ_i^x + h_y σ_i^y + h_z σ_i^z] - - Args: - system_size: Number of quantum spins in the system - interaction_strengths: (J_x, J_y, J_z) nearest-neighbor coupling parameters - external_field_strengths: (h_x, h_y, h_z) local magnetic field components - topology_type: Lattice connectivity ("ring" implements periodic boundary conditions) - - Returns: - CUDA-Q SpinOperator encoding the XYZ spin Hamiltonian - """ - J_x, J_y, J_z = interaction_strengths - h_x, h_y, h_z = external_field_strengths - - # Initialize Hamiltonian with null operator - spin_hamiltonian = 0.0 * spin.z(0) - - # Construct nearest-neighbor interaction terms (ring topology only) - for site_i in range(system_size): - site_j = (site_i + - 1) % system_size # Nearest neighbor with periodic wrapping - - # Add Pauli tensor product interactions (skip zero coefficients) - if J_x != 0.0: - spin_hamiltonian += J_x * spin.x(site_i) * spin.x(site_j) - if J_y != 0.0: - spin_hamiltonian += J_y * spin.y(site_i) * spin.y(site_j) - if J_z != 0.0: - spin_hamiltonian += J_z * spin.z(site_i) * spin.z(site_j) - - # Add local magnetic field terms (skip zero fields) - if h_x != 0.0 or h_y != 0.0 or h_z != 0.0: - for site_i in range(system_size): - if h_x != 0.0: - spin_hamiltonian += h_x * spin.x(site_i) - if h_y != 0.0: - spin_hamiltonian += h_y * spin.y(site_i) - if h_z != 0.0: - spin_hamiltonian += h_z * spin.z(site_i) - - return spin_hamiltonian + return basis_states_and_index def create_heisenberg_hamiltonian(n_spins: int, Jx: float, Jy: float, Jz: float, @@ -282,80 +50,214 @@ def create_heisenberg_hamiltonian(n_spins: int, Jx: float, Jy: float, Jz: float, return ham -def extract_hamiltonian_data(spin_operator: cudaq.SpinOperator): - """Extract coefficients, Pauli words, and strings from CUDA-Q SpinOperator. +def extract_coeffs_and_paulis(H: cudaq.SpinOperator): + + coefficients = [] + pauli_words = [] + n_qubits = H.qubit_count + + for term in H: + + coefficients.append(term.evaluate_coefficient()) + pauli_words.append(term.get_pauli_word(n_qubits)) + + coefficients = np.array(coefficients) + if np.allclose(coefficients.imag, 0): + coefficients = coefficients.real + + return coefficients, pauli_words + + +def vectorized_projected_hamiltonian(basis_states, hamiltonian_pauli_words, + hamiltonian_coefficients_numpy, use_gpu): + """ + GPU-accelerated, `vectorized` implementation of projected_hamiltonian. - Optimized single-pass extraction of all required Hamiltonian data. + Uses CuPy when GPU is available, otherwise falls back to NumPy. + Produces bit-for-bit identical results to the original function. Args: - spin_operator: CUDA-Q SpinOperator to decompose - + basis_states: (n_basis, n_qubits) array of basis state bit vectors + `hamiltonian_pauli_words: list of Pauli strings (e.g., ['XYZII', 'ZZXYI'])` + `hamiltonian_coefficients_numpy: array of coefficients for each Pauli term` + verbose: if True, print debug info (not used in accelerated version) + `use_gpu: True (force GPU), or False (force CPU)` + Returns: - `tuple: (coefficients_list, pauli_words_list, pauli_strings_list)` + matrix_rows, matrix_cols, matrix_elements: lists matching original function """ - system_size = spin_operator.qubit_count - coefficients_list = [] - pauli_words_list = [] - pauli_strings_list = [] + # Determine backend: CuPy (GPU) or NumPy (CPU) + + xp = cp if use_gpu else np + + n_basis = basis_states.shape[0] + n_qubits = basis_states.shape[1] + n_terms = len(hamiltonian_pauli_words) + + if n_basis == 0 or n_terms == 0: + return [], [], [] + + # Transfer data to device + basis_states_xp = xp.asarray(basis_states, dtype=xp.int8) + coefficients_xp = xp.asarray(hamiltonian_coefficients_numpy, + dtype=xp.complex128) + + # Convert Pauli strings to numeric array: I=0, X=1, Y=2, Z=3 + pauli_to_int = {'I': 0, 'X': 1, 'Y': 2, 'Z': 3} + pauli_ops_np = np.array([[pauli_to_int[p] + for p in pauli_word] + for pauli_word in hamiltonian_pauli_words], + dtype=np.int8) + pauli_ops = xp.asarray(pauli_ops_np) # (n_terms, n_qubits) + + # Broadcast for all (basis_state, `pauli_term`) combinations + # states_expanded: (n_basis, 1, n_qubits) + # `pauli_expanded`: (1, n_terms, n_qubits) + states_expanded = basis_states_xp[:, None, :] + pauli_expanded = pauli_ops[None, :, :] + + # STEP 1: Compute transformed states (X and Y flip bits) + flip_mask = (pauli_expanded == 1) | (pauli_expanded == 2) # X=1 or Y=2 + transformed_states = xp.where(flip_mask, 1 - states_expanded, + states_expanded) + # transformed_states: (n_basis, n_terms, n_qubits) + + # STEP 2: Compute phase factors + # Y on initial 0 → multiply by +1j + # Y on initial 1 → multiply by -1j + # Z on initial 1 → multiply by -1 + + y_mask = (pauli_expanded == 2) + z_mask = (pauli_expanded == 3) + + # Count phase contributions per (basis, term) pair + n_y0 = xp.sum(y_mask & (states_expanded == 0), axis=2, + dtype=xp.int32) # (n_basis, n_terms) + n_y1 = xp.sum(y_mask & (states_expanded == 1), axis=2, dtype=xp.int32) + n_z1 = xp.sum(z_mask & (states_expanded == 1), axis=2, dtype=xp.int32) + + # Compute phase index (mod 4) and look up phase value + phase_index = (n_y0 - n_y1 + 2 * n_z1) % 4 # (n_basis, n_terms) + phase_lookup = xp.array([1.0 + 0j, 0.0 + 1j, -1.0 + 0j, 0.0 - 1j], + dtype=xp.complex128) + phase_factors = phase_lookup[phase_index] # (n_basis, n_terms) + + # STEP 3: Compute Hamiltonian matrix elements + hamiltonian_elements = coefficients_xp[None, :] * phase_factors + + # STEP 4: Convert states to integers for fast lookup + # Binary to integer: state_int = sum(bit[q] * 2^(n_qubits-1-q)) + powers_of_2 = xp.asarray( + 1 << np.arange(n_qubits - 1, -1, -1, dtype=np.int64)) + + basis_ints = xp.sum(basis_states_xp.astype(xp.int64) * powers_of_2, + axis=1) # (n_basis,) + transformed_ints = xp.sum(transformed_states.astype(xp.int64) * powers_of_2, + axis=2) # (n_basis, n_terms) + + # STEP 5: Find matching basis states using sorted search + # Sort basis integers and use binary search for O(log n) lookup + sorted_indices = xp.argsort(basis_ints) + sorted_basis_ints = basis_ints[sorted_indices] + + transformed_flat = transformed_ints.ravel() # (n_basis * n_terms,) + + # Binary search to find potential match positions + search_positions = xp.searchsorted(sorted_basis_ints, transformed_flat) + + # Validate matches (`searchsorted` finds insertion point, not necessarily exact match) + in_bounds = search_positions < n_basis + search_positions_clipped = xp.minimum(search_positions, n_basis - 1) + actually_found = in_bounds & (sorted_basis_ints[search_positions_clipped] + == transformed_flat) + + # Map back to original indices + final_indices = sorted_indices[search_positions_clipped] + + # STEP 6: Build output arrays with correct ordering + # Column indices: for pair (i, j), col = i (the initial basis state index) + col_indices = xp.repeat(xp.arange(n_basis, dtype=xp.int64), n_terms) + + # Filter to valid entries only + matrix_rows_xp = final_indices[actually_found] + matrix_cols_xp = col_indices[actually_found] + matrix_elements_xp = hamiltonian_elements.ravel()[actually_found] + + # STEP 7: Return arrays in appropriate format + if use_gpu: + # Return CuPy arrays directly for GPU sparse matrix + return matrix_rows_xp, matrix_cols_xp, matrix_elements_xp + else: + matrix_rows = matrix_rows_xp.tolist() + matrix_cols = matrix_cols_xp.tolist() + matrix_elements = matrix_elements_xp.tolist() + return matrix_rows, matrix_cols, matrix_elements + + +def projected_hamiltonian(basis_states, hamiltonian_pauli_words, + hamiltonian_coefficients_numpy, verbose): - for pauli_term in spin_operator: - # Extract coefficient - term_coefficient = pauli_term.evaluate_coefficient() - assert abs( - term_coefficient.imag - ) < 1e-10, f"Non-real coefficient encountered: {term_coefficient}" - coefficients_list.append(float(term_coefficient.real)) + matrix_rows, matrix_cols, matrix_elements = [], [], [] - # Extract Pauli string - pauli_string = pauli_term.get_pauli_word(system_size) - pauli_strings_list.append(pauli_string) + for i in range( + basis_states.shape[0]): #loop over all basis states in subspace - # Create Pauli word object - pauli_words_list.append(cudaq.pauli_word(pauli_string)) + for pauli_operator, coefficient in zip( + hamiltonian_pauli_words, hamiltonian_coefficients_numpy + ): #loop over each term in the Hamiltonian - return coefficients_list, pauli_words_list, pauli_strings_list + initial_state = basis_states[i] + initial_state_idx = i + transformed_state = initial_state.copy() + phase_factor = 1.0 + 0j -def create_tfim_hamiltonian(n_spins: int, h_field: float): - """Create the Hamiltonian operator""" - ham = 0 + if verbose: + print('initial_state ', initial_state) + if verbose: + print('pauli_operator, coeff ', pauli_operator, coefficient) - # Add single-qubit terms - for i in range(0, n_spins): - ham += -1 * h_field * spin.x(i) + for qubit_position, pauli_op in enumerate( + pauli_operator + ): #loop over each qubit in each term of the Hamiltonian + # `print('pauli_op, qubit_position', pauli_op, qubit_position)` - # Add two-qubit interaction terms for Ising Hamiltonian - for i in range(0, n_spins - 1): - ham += -1 * spin.z(i) * spin.z(i + 1) + if pauli_op == 'I': + pass - return ham + elif pauli_op == 'X': + transformed_state[ + qubit_position] = 1 - transformed_state[qubit_position] -def extract_basis_states_from_measurements(measurement_counts): - """ - Extract computational basis states from CUDA-Q measurement results. - - This function converts the measurement outcome dictionary into a matrix where - each row represents a unique computational basis state observed during sampling. - - Args: - measurement_counts: Dictionary mapping bitstring outcomes to their frequencies - - Returns: - `numpy` array of computational basis states (MSB ordering) - `Shape: (num_unique_states, num_qubits)` - """ - if not measurement_counts: - return np.array([]) + elif pauli_op == 'Y': + + if transformed_state[qubit_position] == 0: + phase_factor *= 1j + else: + phase_factor *= -1j + + transformed_state[ + qubit_position] = 1 - transformed_state[qubit_position] + + elif pauli_op == 'Z': + if transformed_state[qubit_position] == 1: + phase_factor *= -1 - # Extract all unique bitstrings that were observed during measurements - observed_bitstrings = list(measurement_counts.keys()) - num_qubits = len(observed_bitstrings[0]) + if verbose: + print('final_state, phase_factor', transformed_state, + phase_factor) + if verbose: + print(' ') - # Convert bitstrings to binary matrix representation - # Each row is a computational basis state |00...⟩, |01...⟩, etc. - basis_state_matrix = np.array( - [[int(bit) for bit in bitstring] for bitstring in observed_bitstrings], - dtype=np.int8) + hamiltonian_element = coefficient * phase_factor + + matches = np.all(basis_states == transformed_state, axis=1) + final_index = np.where(matches)[0] + + if len(final_index) >= 1: + matrix_rows.append(final_index[0]) + matrix_cols.append(initial_state_idx) + matrix_elements.append(hamiltonian_element) - return basis_state_matrix + return matrix_rows, matrix_cols, matrix_elements diff --git a/docs/sphinx/snippets/python/using/examples/two_qubit_custom_op.py b/docs/sphinx/snippets/python/using/examples/two_qubit_custom_op.py index cca71ce240a..a0e5927bd1e 100644 --- a/docs/sphinx/snippets/python/using/examples/two_qubit_custom_op.py +++ b/docs/sphinx/snippets/python/using/examples/two_qubit_custom_op.py @@ -6,7 +6,7 @@ # the terms of the Apache License 2.0 which accompanies this distribution. # # ============================================================================ # -# fmt: off +# `fmt: off` #[Begin Docs] import cudaq import numpy as np @@ -45,4 +45,4 @@ def custom_xy_test(): cudaq.sample(custom_xy_test).dump() # prints { 10:1000 } #[End Docs] -# fmt: on +# `fmt: on` diff --git a/docs/sphinx/using/backends/sims/photonics.rst b/docs/sphinx/using/backends/sims/photonics.rst index ba785e951f4..6ad65207c97 100644 --- a/docs/sphinx/using/backends/sims/photonics.rst +++ b/docs/sphinx/using/backends/sims/photonics.rst @@ -50,6 +50,8 @@ Quantum Photonic States We define a qumode (qudit) to have the states :math:`\ket{0}`, :math:`\ket{1}`, ... :math:`\ket{d}` in Dirac notation where: +:spellcheck-disable: + .. math:: \ket{0} = \begin{bmatrix} 1 & 0 & 0 & \dots & 0 \end{bmatrix} ^ \top .. math:: \ket{1} = \begin{bmatrix} 0 & 1 & 0 & \dots & 0 \end{bmatrix}^ \top @@ -60,6 +62,8 @@ We define a qumode (qudit) to have the states .. math:: \ket{d} = \begin{bmatrix} 0 & 0 & 0 & \dots & 1 \end{bmatrix}^ \top +:spellcheck-enable: + where the linear combinations of states or superpositions are: .. math:: \ket{\psi} = \alpha_0\ket{0} + \alpha_1\ket{1} + \alpha_2\ket{2} + \dots + \alpha_d\ket{d} @@ -94,6 +98,8 @@ qumode up to a maximum given by the qudit level :math:`d`: .. math:: C \ket{0} = \ket{1} +:spellcheck-disable: + .. math:: \begin{bmatrix} 0 & 0 & \dots & 0 & 0 & 0 & 0 \\ 1 & 0 & \dots & 0 & 0 & 0 & 0 \\ @@ -106,6 +112,8 @@ qumode up to a maximum given by the qudit level :math:`d`: \begin{bmatrix} 1 \\ 0 \\ 0 \\ \vdots \\ 0 \\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 \\ 1 \\ 0 \\ \vdots \\ 0 \\ 0 \\ 0 \end{bmatrix} +:spellcheck-enable: + .. literalinclude:: ../../../snippets/python/using/examples/create_photonic_gate.py :language: python :start-after: [Begin Docs] @@ -121,6 +129,8 @@ value 0, the operation has no effect: .. math:: A \ket{1} = \ket{0} +:spellcheck-disable: + .. math:: \begin{bmatrix} 1 & 1 & 0 & 0 & \dots & 0 & 0 \\ 0 & 0 & 1 & 0 & \dots & 0 & 0 \\ @@ -133,6 +143,8 @@ value 0, the operation has no effect: \begin{bmatrix} 0 \\ 1 \\ 0 \\ \vdots \\ 0 \\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 1 \\ 0 \\ 0 \\ \vdots \\ 0 \\ 0 \\ 0 \end{bmatrix} +:spellcheck-enable: + .. literalinclude:: ../../../snippets/python/using/examples/annihilate_photonic_gate.py :language: python :start-after: [Begin Docs]