{ "cells": [ { "cell_type": "markdown", "id": "cell-00", "metadata": {}, "source": [ "# How to compute custom bounds\n", "\n", "`compute_forward_bounds` and `compute_backward_bounds` are convenience wrappers. Both are built from\n", "the same three pieces, which the public API exposes:\n", "\n", "- A **norm function**, which bounds a single evolved Pauli error term\n", "- A **light cone**, which seeds what the error terms are evolved toward\n", "- `compute_bounds`, which iterates the circuit and distributes the per-term work\n", "\n", "Assembling them yourself means you can bound something the wrappers don't cover. This guide works\n", "through one case where that is worth doing: a **mirror circuit**, where the usual backward bound is\n", "needlessly loose." ] }, { "cell_type": "markdown", "id": "cell-01", "metadata": {}, "source": [ "## What the wrappers actually do\n", "\n", "The two wrappers differ in the three places listed above:\n", "\n", "| | `compute_forward_bounds` | `compute_backward_bounds` |\n", "| --- | --- | --- |\n", "| circuit | as given | `remove_measure(circuit).inverse()` |\n", "| norm function | `time_evolved_norm_forward`, against the observable | `time_evolved_norm_backward`, against the initial state |\n", "| light cone | `LightCone.initialize_from_pauli`, seeded from the observable | `LightCone.initialize_from_measurements`, seeded from every active qubit |\n", "| `backwards` | `False` | `True` |\n", "\n", "The forward bound asks *\"How much can this error change the observable I am about to measure?\"* and\n", "answers it with the spectral norm of a commutator. The backward bound asks *\"How much can this error\n", "change the state I started from?\"* and answers with a nuclear norm, taking that state to be the\n", "all-zero state on every active qubit. They are different questions, and each is the right one for\n", "errors in its own half of the circuit." ] }, { "cell_type": "markdown", "id": "cell-02", "metadata": {}, "source": [ "## The mirror circuit case\n", "\n", "A mirror circuit applies some unitary and then undoes it: $U^\\dagger U$. These appear whenever\n", "the ideal outcome has to be known exactly (generally Loschmidt echoes, randomized benchmarking, and\n", "verification experiments).\n", "\n", "Mirror circuits have a property the generic backward bound cannot exploit. Because the second half\n", "is the inverse of the first, *evolving an error backward to the initial state* traverses the same\n", "gates as *evolving it forward to the observable*. The two questions coincide, so the sharper\n", "forward-style bound is valid for the backward direction too." ] }, { "cell_type": "code", "execution_count": 1, "id": "cell-03", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mirror circuit: 10 qubits, depth 24\n", "noisy layers: 4\n" ] } ], "source": [ "import numpy as np\n", "from qiskit import QuantumCircuit\n", "from qiskit.quantum_info import Pauli\n", "from qiskit_addon_slc.utils import generate_noise_model_paulis\n", "from samplomatic.transpiler import generate_boxing_pass_manager\n", "from samplomatic.utils import find_unique_box_instructions\n", "\n", "\n", "def trotter_ising_circuit(num_qubits, num_steps, rx_angle, rzz_angle):\n", " \"\"\"Trotterized transverse-field Ising evolution on a 1D chain.\"\"\"\n", " circuit = QuantumCircuit(num_qubits)\n", " for _ in range(num_steps):\n", " circuit.rx(rx_angle, range(num_qubits))\n", " circuit.barrier()\n", " for start in (0, 1): # even then odd bonds\n", " for i in range(start, num_qubits - 1, 2):\n", " circuit.rzz(rzz_angle, i, i + 1)\n", " circuit.barrier()\n", " return circuit\n", "\n", "\n", "num_qubits = 10\n", "# The circuit of the quickstart guide...\n", "forward_half = trotter_ising_circuit(\n", " num_qubits, num_steps=4, rx_angle=np.pi / 16, rzz_angle=-np.pi / 3\n", ")\n", "# ...followed by its inverse. The ideal result is the initial state.\n", "circuit = forward_half.compose(forward_half.inverse())\n", "\n", "observable = Pauli(\"I\" * num_qubits).compose(\"Z\", [num_qubits // 2])\n", "\n", "boxing_pass = generate_boxing_pass_manager(\n", " inject_noise_targets=\"all\",\n", " inject_noise_strategy=\"individual_modification\",\n", " inject_noise_site=\"after\",\n", " twirling_strategy=\"active\",\n", " remove_barriers=\"never\",\n", ")\n", "boxed_circuit = boxing_pass.run(circuit)\n", "noise_model_paulis = generate_noise_model_paulis(find_unique_box_instructions(boxed_circuit))\n", "\n", "print(f\"mirror circuit: {num_qubits} qubits, depth {circuit.depth()}\")\n", "print(f\"noisy layers: {len(noise_model_paulis)}\")" ] }, { "cell_type": "markdown", "id": "cell-04", "metadata": {}, "source": [ "## Assemble the custom bound\n", "\n", "The recipe keeps what `compute_backward_bounds` does with the circuit (strip the measurements,\n", "invert it, and iterate it with `backwards=True`) and substitutes the other two pieces: the forward\n", "norm function, and a light cone seeded from the observable with `LightCone.initialize_from_pauli`,\n", "exactly as `compute_forward_bounds` seeds its own. Each substitution is one line." ] }, { "cell_type": "code", "execution_count": 2, "id": "cell-05", "metadata": {}, "outputs": [], "source": [ "from functools import partial\n", "\n", "from qiskit_addon_slc.bounds import LightCone, compute_bounds, time_evolved_norm_forward\n", "from qiskit_addon_slc.utils import remove_measure\n", "\n", "\n", "def compute_mirror_backward_bounds(\n", " circuit, noise_model_paulis, /, observable, *, evolution_max_terms=1_000_000, **kwargs\n", "):\n", " \"\"\"Bounds the backward direction of a mirror circuit with a forward-style bound.\n", "\n", " Valid only for circuits whose second half inverts the first: the backward evolution then\n", " traverses the same gates as the forward one, and reproduces the forward bounds.\n", " \"\"\"\n", " # As `compute_backward_bounds` does: strip measurements and invert, so that walking the circuit\n", " # backwards from its end becomes walking the inverted circuit forwards.\n", " circuit = remove_measure(circuit).inverse()\n", "\n", " # The substitution: the forward norm function, bounding against the observable rather than\n", " # against the initial state.\n", " norm_fn = partial(\n", " time_evolved_norm_forward,\n", " observable=observable,\n", " evolution_max_terms=evolution_max_terms,\n", " )\n", "\n", " # Seed the light cone from the observable, not from every active qubit.\n", " light_cone = LightCone.initialize_from_pauli(circuit, observable)\n", "\n", " return compute_bounds(\n", " circuit, noise_model_paulis, light_cone, norm_fn, backwards=True, **kwargs\n", " )" ] }, { "cell_type": "markdown", "id": "cell-06", "metadata": {}, "source": [ "## How much it gains\n", "\n", "Comparing against the stock backward bound on the same circuit, summarized the same way as in the\n", "[configuration guide](configuration_options.ipynb): the mean bound and its standard deviation,\n", "followed by the share of terms bounded by 0, with a bound computed in between, and left at the\n", "trivial 2.0." ] }, { "cell_type": "code", "execution_count": 3, "id": "cell-07", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "forward mean 0.4323 ± 0.679 │ at 0: 38% computed: 61% at 2.0: 1%\n", "backward (stock) mean 1.7218 ± 0.592 │ at 0: 0% computed: 95% at 2.0: 5%\n", "backward (custom) mean 0.4323 ± 0.679 │ at 0: 38% computed: 61% at 2.0: 1%\n" ] } ], "source": [ "from qiskit_addon_slc.bounds import compute_backward_bounds, compute_forward_bounds\n", "\n", "forward_bounds = compute_forward_bounds(boxed_circuit, noise_model_paulis, observable)\n", "stock_backward = compute_backward_bounds(boxed_circuit, noise_model_paulis)\n", "custom_backward = compute_mirror_backward_bounds(boxed_circuit, noise_model_paulis, observable)\n", "\n", "\n", "def summarize(label, bounds):\n", " \"\"\"Prints a one-line summary of a set of bounds.\"\"\"\n", " rates = np.concatenate([bound.rates for bound in bounds.values()])\n", " # The bounds are floating-point results, so a term counts as bounded by 0, or as left at the\n", " # trivial 2.0, when it is within rounding error of that value.\n", " exact = np.isclose(rates, 0.0, rtol=0.0, atol=1e-12)\n", " trivial = np.isclose(rates, 2.0, rtol=0.0, atol=1e-12)\n", " computed = ~exact & ~trivial\n", " print(\n", " f\"{label:18} mean {rates.mean():.4f} ± {rates.std():.3f} │ \"\n", " f\"at 0: {exact.mean():4.0%} computed: {computed.mean():4.0%} \"\n", " f\"at 2.0: {trivial.mean():4.0%}\"\n", " )\n", "\n", "\n", "summarize(\"forward\", forward_bounds)\n", "summarize(\"backward (stock)\", stock_backward)\n", "summarize(\"backward (custom)\", custom_backward)" ] }, { "cell_type": "markdown", "id": "cell-08", "metadata": {}, "source": [ "The stock backward bound sits near the trivial value of 2.0, which carries almost no information. On\n", "a mirror circuit, every error is \"close to the initial state\" in the sense that bound measures, so\n", "it cannot discriminate between terms. The custom bound is several times tighter and bounds many of the terms by 0.\n", "\n", "To check the implementation, the two can be compared box by box. For every box, the\n", "custom backward bound comes out **identical** to that same box's forward bound, up to rounding\n", "error. Both bound the same error at the same point in the circuit, and on a mirror circuit the gates\n", "after that point cancel to the inverse of the gates before it, so the two computations evaluate the\n", "same quantity from opposite ends:" ] }, { "cell_type": "code", "execution_count": 4, "id": "cell-09", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "16 of 16 boxes match the forward bounds\n", "largest disagreement across all terms: 6.00e-15\n" ] } ], "source": [ "matches = sum(\n", " np.allclose(forward_bounds[box_id].rates, custom_backward[box_id].rates)\n", " for box_id in forward_bounds\n", ")\n", "print(f\"{matches} of {len(forward_bounds)} boxes match the forward bounds\")\n", "\n", "worst = max(\n", " np.abs(forward_bounds[box_id].rates - custom_backward[box_id].rates).max()\n", " for box_id in forward_bounds\n", ")\n", "print(f\"largest disagreement across all terms: {worst:.2e}\")" ] }, { "cell_type": "markdown", "id": "cell-10", "metadata": {}, "source": [ "
\n", "\n", "**Note:** This equality is a property of the mirror structure, not of the technique. On a circuit\n", "that is not self-inverting, the same substitution still runs but no longer computes a *valid* bound\n", "for the backward direction: it answers the forward question about a circuit half where that\n", "question does not apply. **Only use this when the second half of your circuit inverts the\n", "first.**\n", "\n", "
\n", "\n", "## Feed it into the rest of the workflow\n", "\n", "The result is an ordinary `Bounds` dictionary, so everything that follows is unchanged.\n", "\n", "On a mirror circuit there is also no reason to compute either bound for the whole circuit. The\n", "forward bounds are only needed for the boxes of $U^\\dagger$, counted from the end, and the backward\n", "bounds only for the boxes of $U$, counted from the start. `max_num_boxes` therefore limits each of\n", "them to half of the noisy boxes, and `merge_bounds` joins the two halves.\n", "\n", "This is how the bounds are used in practice, and it means the box-for-box comparison above is no\n", "longer available: it needs both bounds for every box. It is a check of the implementation for this guide, not workflow step." ] }, { "cell_type": "code", "execution_count": 5, "id": "cell-11", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Optimal spacetime partitioning not implemented! Just partitioning list of noisy boxes.\n", "Optimal spacetime partitioning not implemented! Just partitioning list of noisy boxes.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "each bound computed for 8 of 16 noisy boxes\n", "\n", "bounds overhead residual bias\n", "forward + stock backward 29848.0583 0.0498\n", "forward + custom backward 465.4028 0.0498\n", "forward only, whole circuit 465.4028 0.0498\n" ] } ], "source": [ "from qiskit.quantum_info import PauliLindbladMap, QubitSparsePauliList\n", "from qiskit_addon_slc.bounds import compute_local_scales, merge_bounds\n", "\n", "# Stand-in for rates that a noise-learning experiment would measure on hardware.\n", "rng = np.random.default_rng(42)\n", "noise_rates = {\n", " layer: PauliLindbladMap.from_components(\n", " rng.random(len(terms)) * 5e-3,\n", " QubitSparsePauliList.from_sparse_list(terms.to_sparse_list(), terms.num_qubits),\n", " )\n", " for layer, terms in noise_model_paulis.items()\n", "}\n", "\n", "# Compute each bound for its own half of the mirror circuit only. `forward_bounds` has an entry\n", "# for every noisy box, which are the boxes `max_num_boxes` counts.\n", "half = len(forward_bounds) // 2\n", "half_forward = compute_forward_bounds(\n", " boxed_circuit, noise_model_paulis, observable, max_num_boxes=half\n", ")\n", "half_stock = compute_backward_bounds(boxed_circuit, noise_model_paulis, max_num_boxes=half)\n", "half_custom = compute_mirror_backward_bounds(\n", " boxed_circuit, noise_model_paulis, observable, max_num_boxes=half\n", ")\n", "\n", "print(f\"each bound computed for {half} of {len(forward_bounds)} noisy boxes\\n\")\n", "print(f\"{'bounds':34} {'overhead':>12} {'residual bias':>14}\")\n", "for label, bounds in (\n", " (\n", " \"forward + stock backward\",\n", " merge_bounds(boxed_circuit, half_forward, half_stock, noise_rates),\n", " ),\n", " (\n", " \"forward + custom backward\",\n", " merge_bounds(boxed_circuit, half_forward, half_custom, noise_rates),\n", " ),\n", " (\"forward only, whole circuit\", forward_bounds),\n", "):\n", " _, cost, bias = compute_local_scales(boxed_circuit, bounds, noise_rates, bias_tolerance=0.05)\n", " print(f\"{label:34} {cost:12.4f} {bias:14.4f}\")" ] }, { "cell_type": "markdown", "id": "cell-12", "metadata": {}, "source": [ "With the stock backward bounds, the sampling overhead is far larger. `merge_bounds` uses the\n", "backward bounds up to one switch point in the circuit and the forward bounds from there on,\n", "choosing the point that minimizes the total bias. With each bound computed for one half, that point\n", "falls in the middle of the circuit, so the boxes of $U$ are covered by backward bounds alone. The\n", "stock backward bound is close to the trivial 2.0 there, which drives the overhead up. The custom\n", "one is as tight as the forward bound would have been, so the overhead matches that of the complete\n", "forward bounds.\n", "\n", "That raises the obvious question of why to bother, when the complete forward bounds alone give the\n", "same result. The answer is cost. A forward bound for a box early in the circuit evolves its error\n", "through the rest of $U$ and then all of $U^\\dagger$, which is the longest and widest evolution in\n", "the circuit. The evolved operator can grow exponentially in the number of non-Clifford gates\n", "it passes through, and computing the commutator's spectral norm gets exponentially more expensive as\n", "the light cone widens. In the half-and-half approach, no error is evolved through more than half of\n", "the circuit.\n", "\n", "The saving therefore grows with the circuit depth. More importantly, the complete forward\n", "bounds stop being computable long before the halfway ones do. Once the evolutions of the early\n", "boxes exceed `evolution_max_terms` or `eigval_max_qubits`, their bounds are truncated or fall back\n", "to the triangle inequality, and eventually they cost too much to compute. Wherever that point\n", "lies, the half-and-half approach only needs it to fall somewhere in the first half of the circuit.\n", "The forward bounds have to reach no further than the middle, and on a mirror circuit, the backward\n", "bounds for the boxes of $U$ evolve their errors back to the start through as much of the\n", "circuit as the forward bounds for the matching boxes of $U^\\dagger$ do to the end, so they run out\n", "at the same depth.\n", "\n", "
\n", "\n", "**Note:** Why compute backward bounds for the boxes of $U$, when the forward bounds of the\n", "boxes of $U^\\dagger$ look like they should hold the same numbers? Because the boxes are not mirror\n", "images of each other. Each box injects its noise on one side of its gates, and the inverse layers of\n", "$U^\\dagger$ are separate boxes with noise models of their own, so the box that mirrors a box of $U$\n", "sees its errors at a different point in the circuit. Therefore, their bounds only partly agree, and\n", "the bounds for the boxes of $U$ have to be computed for those boxes.\n", "\n", "
\n", "\n", "## Writing other custom bounds\n", "\n", "The same three substitutions cover other cases:\n", "\n", "- **A different norm.** `time_evolved_norm_forward` accepts `comm_norm_order`; passing anything\n", " other than `2` skips the eigensolver and computes that norm directly.\n", "- **A different light cone.** `LightCone.initialize_from_pauli` seeds a light cone from any Pauli,\n", " and the `LightCone` constructor takes the qubits to track and the operations seeding it, so a\n", " bound can be computed against any operator you can express that way.\n", "- **A different norm function entirely.** `compute_bounds` only requires a callable: taking a\n", " `Pauli` and `RotationGates` and returning a `CommutatorBounds`. Anything satisfying that signature\n", " works, including a closed-form bound specific to your circuit family.\n", "\n", "Whatever you substitute, you must prove that the result is a genuine upper bound.\n", "Understating an error term's effect does not produce a visible failure. It produces an expectation\n", "value that is quietly wrong, because the term will have been dropped from the mitigated noise model." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.15" } }, "nbformat": 4, "nbformat_minor": 5 }