{ "cells": [ { "cell_type": "markdown", "id": "frontmatter", "metadata": {}, "source": [ "---\n", "title: \"Quick start\"\n", "description: \"Quick start for the latest version of Operator backpropagation (OBP)\"\n", "---\n", "\n" ] }, { "cell_type": "markdown", "id": "intro", "metadata": {}, "source": [ "# Quick start\n", "\n", "This guide demonstrates a minimal working example of the `qiskit-addon-obp` package. We use operator backpropagation (OBP) to reduce the depth of a quantum circuit by absorbing trailing gates into the observable.\n", "\n", "An expectation value $\\langle O \\rangle = \\langle \\psi | U^\\dagger O U | \\psi \\rangle$ is unchanged if we peel a trailing block of gates off the circuit $U$ and conjugate the observable by it classically. OBP applies this repeatedly, evaluating part of the circuit classically so that only a shallower circuit runs on hardware. The price is that each absorbed gate can expand the observable into more Pauli terms, so the depth saved must be weighed against the growth of the observable.\n", "\n", "To see examples of how to build realistic workflows with this tool and execute on quantum hardware, check out the tutorials on the IBM Quantum Platform ([OBP Tutorial](/docs/tutorials/operator-back-propagation)).\n", "\n" ] }, { "cell_type": "markdown", "id": "inputs-header", "metadata": {}, "source": [ "## Prepare inputs for OBP\n", "\n", "OBP takes as input a list of circuit slices and an observable. It backpropagates slices one at a time from the end of the circuit into the observable, reducing circuit depth at the cost of additional Pauli terms in the observable. Here we generate a time-evolution circuit for a 10-qubit Heisenberg model and slice it by gate type.\n", "\n", "Below we draw the original circuit, then the same circuit recombined with barriers marking the slice boundaries — each slice is a unit that can be absorbed into the observable in a single backpropagation step.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "setup-inputs", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original circuit depth: 18\n", "Number of slices: 18\n", "Observable terms: 1\n" ] } ], "source": [ "import numpy as np\n", "from qiskit.quantum_info import SparsePauliOp\n", "from qiskit.synthesis import LieTrotter\n", "from qiskit.transpiler import CouplingMap\n", "from qiskit_addon_utils.problem_generators import (\n", " generate_time_evolution_circuit,\n", " generate_xyz_hamiltonian,\n", ")\n", "from qiskit_addon_utils.slicing import combine_slices, slice_by_gate_types\n", "\n", "# Generate a circuit to reduce\n", "coupling_map = CouplingMap.from_heavy_hex(3, bidirectional=False)\n", "reduced_coupling_map = coupling_map.reduce(\n", " [0, 13, 1, 14, 10, 16, 5, 12, 8, 18]\n", ")\n", "\n", "hamiltonian = generate_xyz_hamiltonian(\n", " reduced_coupling_map,\n", " coupling_constants=(np.pi / 8, np.pi / 4, np.pi / 2),\n", " ext_magnetic_field=(np.pi / 3, np.pi / 6, np.pi / 9),\n", ")\n", "\n", "circuit = generate_time_evolution_circuit(\n", " hamiltonian,\n", " time=0.2,\n", " synthesis=LieTrotter(reps=2),\n", ")\n", "\n", "# Slice the circuit and define an observable\n", "slices = slice_by_gate_types(circuit)\n", "observable = SparsePauliOp(\"IIIIIIIIIZ\")\n", "\n", "print(f\"Original circuit depth: {circuit.depth()}\")\n", "print(f\"Number of slices: {len(slices)}\")\n", "print(f\"Observable terms: {len(observable)}\")" ] }, { "cell_type": "code", "execution_count": 2, "id": "46efdcfc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original circuit:\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Sliced circuit (recombined with barriers for visualization)\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Recombine the slices with barriers to make the slice boundaries visible\n", "sliced_circuit = combine_slices(slices, include_barriers=True)\n", "\n", "print(\"Original circuit:\")\n", "display(circuit.draw(\"mpl\", scale=0.6, fold=-1))\n", "print(\"Sliced circuit (recombined with barriers for visualization)\")\n", "sliced_circuit.draw(\"mpl\", scale=0.6, fold=-1)" ] }, { "cell_type": "markdown", "id": "obp-header", "metadata": {}, "source": [ "## Reduce circuit depth with OBP\n", "\n", "We call `backpropagate` to absorb slices into the observable. The function returns the expanded observable, the circuit slices which were not propagated through, and metadata about the procedure.\n", "\n", "Left unchecked, the observable can grow toward $2^n$ Pauli terms. The `operator_budget` caps this growth — here we allow at most 8 qubit-wise commuting groups, which roughly sets the number of shots required to evaluate the observable on the QPU. Backpropagation halts as soon as absorbing the next slice would exceed the budget, which is exactly what happens below: only 7 of the 18 slices are absorbed before the observable fills all 8 commuting groups and the procedure stops.\n", "\n", "To push deeper into the circuit, the `truncation_error_budget` keyword argument to `backpropagate` can be used to drop small-coefficient Pauli terms from the observable as it grows. This dampens the growth of the observable in exchange for some error proportional to the magnitude of the Pauli terms being truncated. The two budgets are complementary and may be used together: `operator_budget` controls the *size* of the observable, while `truncation_error_budget` controls the *error* incurred by discarding terms.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "run-obp", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Backpropagated 7 of 18 slices.\n", "Reduced circuit depth: 11 (was 18)\n", "Observable grew from 1 to 18 Pauli terms.\n", "Filled 8 of 8 commuting groups, exhausting the budget.\n" ] } ], "source": [ "from qiskit_addon_obp import backpropagate\n", "from qiskit_addon_obp.utils.simplify import OperatorBudget\n", "\n", "max_qwc_groups = 8\n", "bp_obs, remaining_slices, metadata = backpropagate(\n", " observable,\n", " slices,\n", " operator_budget=OperatorBudget(max_qwc_groups=max_qwc_groups),\n", ")\n", "\n", "reduced_circuit = combine_slices(remaining_slices)\n", "num_groups = len(bp_obs.group_commuting(qubit_wise=True))\n", "\n", "print(\n", " f\"Backpropagated {metadata.num_backpropagated_slices} of {len(slices)} slices.\"\n", ")\n", "print(\n", " f\"Reduced circuit depth: {reduced_circuit.depth()} (was {circuit.depth()})\"\n", ")\n", "print(f\"Observable grew from {len(observable)} to {len(bp_obs)} Pauli terms.\")\n", "print(\n", " f\"Filled {num_groups} of {max_qwc_groups} commuting groups, exhausting the budget.\"\n", ")" ] }, { "cell_type": "code", "execution_count": 4, "id": "b006625e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "reduced_circuit.draw(\"mpl\", scale=0.6, fold=-1)" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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" } }, "nbformat": 4, "nbformat_minor": 5 }