diff --git a/mirror_qa.ipynb b/mirror_qa.ipynb
new file mode 100644
index 0000000..8fdd9ff
--- /dev/null
+++ b/mirror_qa.ipynb
@@ -0,0 +1,505 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "35fe2f52",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "from qiskit.providers.fake_provider import GenericBackendV2\n",
+ "\n",
+ "from qiskit_device_benchmarking.bench_code.mrb import MirrorQA, QuantumAwesomeness\n",
+ "\n",
+ "# custom noisy backend (or an attempt at one, at least)\n",
+ "class NoisyBackend(GenericBackendV2):\n",
+ " def __init__(\n",
+ " self,\n",
+ " num_qubits: int,\n",
+ " basis_gates: list[str] | None = None,\n",
+ " coupling_map: list[list[int]] = None,\n",
+ " p1: float = 0,\n",
+ " p2: float = 0,\n",
+ " ):\n",
+ " self.p = (p1,p2)\n",
+ " super().__init__(\n",
+ " num_qubits,\n",
+ " basis_gates,\n",
+ " coupling_map=coupling_map,\n",
+ " noise_info = (p1>0 or p2 >0)\n",
+ " )\n",
+ " def _get_noise_defaults(self, name: str, num_qubits: int) -> tuple:\n",
+ " if name in ['delay', 'reset']:\n",
+ " return (self.p[0],self.p[0])\n",
+ " else:\n",
+ " if num_qubits == 1:\n",
+ " return (0,0,self.p[0],self.p[0])\n",
+ " else:\n",
+ " return (0,0,self.p[1],self.p[1])\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ab501d22",
+ "metadata": {},
+ "source": [
+ "We'll look at Quantum Awesomeness on either a real 127 qubit device, or a small emulated backend."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "e22a18ca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "real_device = False\n",
+ "\n",
+ "if real_device:\n",
+ " from qiskit_ibm_provider import IBMProvider\n",
+ " provider = IBMProvider(instance=\"ibm-q/open/main\")\n",
+ " backend = provider.get_backend('ibm_sherbrooke')\n",
+ "else:\n",
+ " p = 1e-2\n",
+ " backend = NoisyBackend(\n",
+ " num_qubits=8,\n",
+ " basis_gates = [\"id\", \"h\", \"x\", \"y\", \"z\", \"rx\", \"cx\"],\n",
+ " p1=p/10,\n",
+ " p2=p,\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d08297c5",
+ "metadata": {},
+ "source": [
+ "First we set up the experiment. \n",
+ "\n",
+ "Some notes on parameters:\n",
+ "* `range(backend.num_qubits)`: We use the whole device.\n",
+ "* `two_qubit_gate_density=0.25`: Having around half of all qubits involved in an entangling gate seems like a good fraction, and this makes that happen.\n",
+ "* `initial_entangling_angle=np.pi/2`: Default angle is `np.pi/2`, which creates maximally entangled pairs. We'll use `np.pi/2` so we can more easily see the gates when looking at the circuits.\n",
+ "* `num_samples=20`: Number of different sets of random Clifford circuits."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "13c56bab",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# number of shots per circuit\n",
+ "shots = 10000\n",
+ "\n",
+ "# lengths of different mirror circuits to run\n",
+ "lengths = [2]+[4,10,20,50,100]\n",
+ "\n",
+ "# set up the experiment object\n",
+ "exp = MirrorQA(\n",
+ " range(backend.num_qubits),\n",
+ " lengths,\n",
+ " backend=backend,\n",
+ " two_qubit_gate_density=0.25,\n",
+ " num_samples=20,\n",
+ " initial_entangling_angle=np.pi/4,\n",
+ " )\n",
+ "exp.set_run_options(\n",
+ " shots=shots\n",
+ ")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bbad7a6d",
+ "metadata": {},
+ "source": [
+ "Now we run it!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "655f5df4",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "['d0ee5e7a-32d6-47e2-824c-0c87db1728d7']\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/woottonjames/Library/CloudStorage/GoogleDrive-james@mothquantum.com/My Drive/Repos/qiskit-device-benchmarking/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/fake_provider/local_service.py:233: UserWarning: Options {'execution': {'meas_type': 'classified'}} have no effect in local testing mode.\n",
+ " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n"
+ ]
+ }
+ ],
+ "source": [
+ "#run\n",
+ "rb_data = exp.run()\n",
+ "print(rb_data.job_ids)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "503801cd",
+ "metadata": {},
+ "source": [
+ "To see what circuits were run, don't use `exp.circuits()` because that will set up a new bunch of circuits. Instead use `exp._static_trans_circuits`, which stores the transpiled circuits that were run.\n",
+ "\n",
+ "There are two differences between MQA circuits and MRB circuits:\n",
+ "* MQA places the new layers of the sequence at the beginning and end, whereas MRB places them in the middle.\n",
+ "* MQA inserts `rx` gates on the control qubit of any qubit involved in a CX in the first layer. Leading to entanglement for all pairs involved in a CX in the first layer.\n",
+ "\n",
+ "To see what pairs were used for the CX gates in the first layer of each circuit, use `exp._pairs`.\n",
+ "\n",
+ "Below are the first two lengths of circuit for the first sequence of random Cliffords. The `Rx(π/4)` gates here are those inserted to create the entangled pairs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "6677cfcb",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Pairs: []\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "global phase: π/2\n",
+ " ┌───┐ ░ ┌─────────┐ ┌───┐ ┌───┐ ░ ┌───┐ ░ ┌───┐ ┌──────────┐┌───┐ ░ ┌───┐ ░ ░ ┌─┐ \n",
+ " q_0: ┤ Y ├─░─┤ Rx(π/2) ├───┤ H ├────┤ X ├─░─┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├┤ Y ├──────░─┤ X ├─░──░─┤M├─────────────────────\n",
+ " ├───┤ ░ └──┬───┬──┘ └───┘ └───┘ ░ ├───┤ ░ ├───┤ └──────────┘└───┘ ░ ├───┤ ░ ░ └╥┘┌─┐ \n",
+ " q_1: ┤ X ├─░────┤ H ├─────────────────────░─┤ X ├─░────┤ H ├──────────────────────────░─┤ Y ├─░──░──╫─┤M├──────────────────\n",
+ " ├───┤ ░ ┌──┴───┴──┐ ┌───┐ ░ ├───┤ ░ ├───┤ ┌──────────┐ ░ └───┘ ░ ░ ║ └╥┘┌─┐ \n",
+ " q_2: ┤ Y ├─░─┤ Rx(π/2) ├───┤ H ├──────────░─┤ Z ├─░────┤ H ├───┤ Rx(-π/2) ├───────────░───────░──░──╫──╫─┤M├───────────────\n",
+ " ├───┤ ░ └──┬───┬──┘ └───┘ ░ ├───┤ ░ ├───┤ └──────────┘ ░ ┌───┐ ░ ░ ║ ║ └╥┘┌─┐ \n",
+ " q_3: ┤ X ├─░────┤ Y ├─────────────────────░─┤ X ├─░────┤ Y ├──────────────────────────░─┤ Y ├─░──░──╫──╫──╫─┤M├────────────\n",
+ " ├───┤ ░ ├───┤ ┌──────────┐ ░ ├───┤ ░ ┌──┴───┴──┐ ┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_4: ┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├──────░─┤ Z ├─░─┤ Rx(π/2) ├───┤ H ├───────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n",
+ " ├───┤ ░ ├───┤ ├─────────┬┘┌───┐ ░ ├───┤ ░ └──┬───┬──┘┌──┴───┴──┐ ┌───┐┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_5: ┤ Y ├─░────┤ H ├───┤ Rx(π/2) ├─┤ H ├─░─┤ X ├─░────┤ H ├───┤ Rx(π/2) ├─┤ H ├┤ Z ├─░─┤ X ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n",
+ " ├───┤ ░ ├───┤ ├─────────┴┐└───┘ ░ ├───┤ ░ ┌──┴───┴──┐└──┬───┬──┘ └───┘└───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_6: ┤ Y ├─░────┤ H ├───┤ Rx(-π/2) ├──────░─┤ Z ├─░─┤ Rx(π/2) ├───┤ H ├───────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n",
+ " ├───┤ ░ ├───┤ └──────────┘ ░ ├───┤ ░ └──┬───┬──┘ └───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n",
+ " q_7: ┤ X ├─░────┤ Z ├─────────────────────░─┤ X ├─░────┤ Z ├──────────────────────────░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
+ " └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ ░ ║ ║ ║ ║ ║ ║ ║ └╥┘\n",
+ "meas: 8/═══════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n",
+ " 0 1 2 3 4 5 6 7
"
+ ],
+ "text/plain": [
+ "global phase: π/2\n",
+ " ┌───┐ ░ ┌─────────┐ ┌───┐ ┌───┐ ░ ┌───┐ ░ ┌───┐ ┌──────────┐┌───┐ ░ ┌───┐ ░ ░ ┌─┐ \n",
+ " q_0: ┤ Y ├─░─┤ Rx(π/2) ├───┤ H ├────┤ X ├─░─┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├┤ Y ├──────░─┤ X ├─░──░─┤M├─────────────────────\n",
+ " ├───┤ ░ └──┬───┬──┘ └───┘ └───┘ ░ ├───┤ ░ ├───┤ └──────────┘└───┘ ░ ├───┤ ░ ░ └╥┘┌─┐ \n",
+ " q_1: ┤ X ├─░────┤ H ├─────────────────────░─┤ X ├─░────┤ H ├──────────────────────────░─┤ Y ├─░──░──╫─┤M├──────────────────\n",
+ " ├───┤ ░ ┌──┴───┴──┐ ┌───┐ ░ ├───┤ ░ ├───┤ ┌──────────┐ ░ └───┘ ░ ░ ║ └╥┘┌─┐ \n",
+ " q_2: ┤ Y ├─░─┤ Rx(π/2) ├───┤ H ├──────────░─┤ Z ├─░────┤ H ├───┤ Rx(-π/2) ├───────────░───────░──░──╫──╫─┤M├───────────────\n",
+ " ├───┤ ░ └──┬───┬──┘ └───┘ ░ ├───┤ ░ ├───┤ └──────────┘ ░ ┌───┐ ░ ░ ║ ║ └╥┘┌─┐ \n",
+ " q_3: ┤ X ├─░────┤ Y ├─────────────────────░─┤ X ├─░────┤ Y ├──────────────────────────░─┤ Y ├─░──░──╫──╫──╫─┤M├────────────\n",
+ " ├───┤ ░ ├───┤ ┌──────────┐ ░ ├───┤ ░ ┌──┴───┴──┐ ┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_4: ┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├──────░─┤ Z ├─░─┤ Rx(π/2) ├───┤ H ├───────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n",
+ " ├───┤ ░ ├───┤ ├─────────┬┘┌───┐ ░ ├───┤ ░ └──┬───┬──┘┌──┴───┴──┐ ┌───┐┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_5: ┤ Y ├─░────┤ H ├───┤ Rx(π/2) ├─┤ H ├─░─┤ X ├─░────┤ H ├───┤ Rx(π/2) ├─┤ H ├┤ Z ├─░─┤ X ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n",
+ " ├───┤ ░ ├───┤ ├─────────┴┐└───┘ ░ ├───┤ ░ ┌──┴───┴──┐└──┬───┬──┘ └───┘└───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_6: ┤ Y ├─░────┤ H ├───┤ Rx(-π/2) ├──────░─┤ Z ├─░─┤ Rx(π/2) ├───┤ H ├───────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n",
+ " ├───┤ ░ ├───┤ └──────────┘ ░ ├───┤ ░ └──┬───┬──┘ └───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n",
+ " q_7: ┤ X ├─░────┤ Z ├─────────────────────░─┤ X ├─░────┤ Z ├──────────────────────────░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
+ " └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ ░ ║ ║ ║ ║ ║ ║ ║ └╥┘\n",
+ "meas: 8/═══════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n",
+ " 0 1 2 3 4 5 6 7 "
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "print('Pairs:', exp._pairs[0])\n",
+ "exp._static_trans_circuits[0].draw(fold=-1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "c8f2da90",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Pairs: [(2, 6)]\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "global phase: π/2\n",
+ " ┌───┐ ░ ┌──────────┐ ┌───┐ ░ ░ ┌─────────┐ ┌───┐ ┌───┐ ░ ┌───┐ ░ ┌───┐ ┌──────────┐┌───┐ ░ ┌───┐ ░ ┌──────────┐ ┌───┐ ░ ┌───┐ ░ ░ ┌─┐ \n",
+ " q_0: ┤ Y ├─░─┤ Rx(-π/2) ├───┤ Z ├───────────────────────────░───────░─┤ Rx(π/2) ├───┤ H ├────┤ X ├─░─┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├┤ Y ├──────░─┤ X ├─░─┤ Rx(-π/2) ├───┤ Z ├─────────────────────────░─┤ X ├─░──░─┤M├─────────────────────\n",
+ " ├───┤ ░ └──┬───┬───┘┌──┴───┴───┐ ┌───┐ ░ ░ └──┬───┬──┘ └───┘ └───┘ ░ ├───┤ ░ ├───┤ └──────────┘└───┘ ░ ├───┤ ░ ├─────────┬┘ ├───┤ ┌───┐ ░ ├───┤ ░ ░ └╥┘┌─┐ \n",
+ " q_1: ┤ X ├─░────┤ H ├────┤ Rx(-π/2) ├───┤ Z ├───────────────░───────░────┤ H ├─────────────────────░─┤ Z ├─░────┤ H ├──────────────────────────░─┤ X ├─░─┤ Rx(π/2) ├────┤ H ├──────┤ Y ├──────────────░─┤ Y ├─░──░──╫─┤M├──────────────────\n",
+ " ├───┤ ░ └───┘ ├─────────┬┘ └───┘ ░ ┌───┐ ░ ┌──┴───┴──┐ ┌───┐ ░ ├───┤ ░ ├───┤ ┌──────────┐ ░ ├───┤ ░ └─────────┘ └───┘ └───┘ ░ └───┘ ░ ░ ║ └╥┘┌─┐ \n",
+ " q_2: ┤ Y ├─░──────■──────┤ Rx(π/4) ├────────────────────────░─┤ X ├─░─┤ Rx(π/2) ├───┤ H ├──────────░─┤ Y ├─░────┤ H ├───┤ Rx(-π/2) ├───────────░─┤ Z ├─░──────■───────────────────────────────────────░───────░──░──╫──╫─┤M├───────────────\n",
+ " ├───┤ ░ │ └──┬───┬──┘ ┌──────────┐┌───┐ ░ ├───┤ ░ └──┬───┬──┘ └───┘ ░ └───┘ ░ ├───┤ └──────────┘ ░ ├───┤ ░ │ ┌─────────┐ ┌───┐ ┌───┐ ░ ┌───┐ ░ ░ ║ ║ └╥┘┌─┐ \n",
+ " q_3: ┤ X ├─░──────┼─────────┤ H ├────┤ Rx(-π/2) ├┤ X ├──────░─┤ Y ├─░────┤ Y ├─────────────────────░───────░────┤ Y ├──────────────────────────░─┤ X ├─░──────┼──────┤ Rx(π/2) ├───┤ H ├───┤ Z ├──────░─┤ Y ├─░──░──╫──╫──╫─┤M├────────────\n",
+ " ├───┤ ░ │ ├───┤ ├─────────┬┘├───┤┌───┐ ░ ├───┤ ░ ├───┤ ┌──────────┐ ░ ┌───┐ ░ ┌──┴───┴──┐ ┌───┐ ░ ├───┤ ░ │ └──┬───┬──┘┌──┴───┴──┐├───┤┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_4: ┤ X ├─░──────┼─────────┤ H ├────┤ Rx(π/2) ├─┤ H ├┤ Y ├─░─┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├──────░─┤ Y ├─░─┤ Rx(π/2) ├───┤ H ├───────────────░─┤ Z ├─░──────┼─────────┤ H ├───┤ Rx(π/2) ├┤ H ├┤ Y ├─░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n",
+ " ├───┤ ░ │ ├───┤ └──┬───┬──┘ └───┘└───┘ ░ ├───┤ ░ ├───┤ ├─────────┬┘┌───┐ ░ ├───┤ ░ └──┬───┬──┘┌──┴───┴──┐ ┌───┐┌───┐ ░ ├───┤ ░ │ ├───┤ └──┬───┬──┘└───┘└───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_5: ┤ Y ├─░──────┼─────────┤ H ├───────┤ X ├───────────────░─┤ X ├─░────┤ H ├───┤ Rx(π/2) ├─┤ H ├─░─┤ X ├─░────┤ H ├───┤ Rx(π/2) ├─┤ H ├┤ Z ├─░─┤ X ├─░──────┼─────────┤ H ├──────┤ Z ├──────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n",
+ " ├───┤ ░ ┌─┴─┐ └───┘ └───┘ ░ ├───┤ ░ ├───┤ ├─────────┴┐└───┘ ░ ├───┤ ░ ┌──┴───┴──┐└──┬───┬──┘ └───┘└───┘ ░ ├───┤ ░ ┌─┴─┐ └───┘ └───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_6: ┤ Y ├─░────┤ X ├───────────────────────────────────────░─┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├──────░─┤ X ├─░─┤ Rx(π/2) ├───┤ H ├───────────────░─┤ Z ├─░────┤ X ├─────────────────────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n",
+ " ├───┤ ░ ├───┤ ┌───┐ ░ ├───┤ ░ ├───┤ └──────────┘ ░ └───┘ ░ └──┬───┬──┘ └───┘ ░ ├───┤ ░ ├───┤ ┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n",
+ " q_7: ┤ X ├─░────┤ H ├───────┤ Z ├───────────────────────────░─┤ Y ├─░────┤ Z ├─────────────────────░───────░────┤ Z ├──────────────────────────░─┤ X ├─░────┤ H ├───────┤ X ├─────────────────────────░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
+ " └───┘ ░ └───┘ └───┘ ░ └───┘ ░ └───┘ ░ ░ └───┘ ░ └───┘ ░ └───┘ └───┘ ░ └───┘ ░ ░ ║ ║ ║ ║ ║ ║ ║ └╥┘\n",
+ "meas: 8/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n",
+ " 0 1 2 3 4 5 6 7
"
+ ],
+ "text/plain": [
+ "global phase: π/2\n",
+ " ┌───┐ ░ ┌──────────┐ ┌───┐ ░ ░ ┌─────────┐ ┌───┐ ┌───┐ ░ ┌───┐ ░ ┌───┐ ┌──────────┐┌───┐ ░ ┌───┐ ░ ┌──────────┐ ┌───┐ ░ ┌───┐ ░ ░ ┌─┐ \n",
+ " q_0: ┤ Y ├─░─┤ Rx(-π/2) ├───┤ Z ├───────────────────────────░───────░─┤ Rx(π/2) ├───┤ H ├────┤ X ├─░─┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├┤ Y ├──────░─┤ X ├─░─┤ Rx(-π/2) ├───┤ Z ├─────────────────────────░─┤ X ├─░──░─┤M├─────────────────────\n",
+ " ├───┤ ░ └──┬───┬───┘┌──┴───┴───┐ ┌───┐ ░ ░ └──┬───┬──┘ └───┘ └───┘ ░ ├───┤ ░ ├───┤ └──────────┘└───┘ ░ ├───┤ ░ ├─────────┬┘ ├───┤ ┌───┐ ░ ├───┤ ░ ░ └╥┘┌─┐ \n",
+ " q_1: ┤ X ├─░────┤ H ├────┤ Rx(-π/2) ├───┤ Z ├───────────────░───────░────┤ H ├─────────────────────░─┤ Z ├─░────┤ H ├──────────────────────────░─┤ X ├─░─┤ Rx(π/2) ├────┤ H ├──────┤ Y ├──────────────░─┤ Y ├─░──░──╫─┤M├──────────────────\n",
+ " ├───┤ ░ └───┘ ├─────────┬┘ └───┘ ░ ┌───┐ ░ ┌──┴───┴──┐ ┌───┐ ░ ├───┤ ░ ├───┤ ┌──────────┐ ░ ├───┤ ░ └─────────┘ └───┘ └───┘ ░ └───┘ ░ ░ ║ └╥┘┌─┐ \n",
+ " q_2: ┤ Y ├─░──────■──────┤ Rx(π/4) ├────────────────────────░─┤ X ├─░─┤ Rx(π/2) ├───┤ H ├──────────░─┤ Y ├─░────┤ H ├───┤ Rx(-π/2) ├───────────░─┤ Z ├─░──────■───────────────────────────────────────░───────░──░──╫──╫─┤M├───────────────\n",
+ " ├───┤ ░ │ └──┬───┬──┘ ┌──────────┐┌───┐ ░ ├───┤ ░ └──┬───┬──┘ └───┘ ░ └───┘ ░ ├───┤ └──────────┘ ░ ├───┤ ░ │ ┌─────────┐ ┌───┐ ┌───┐ ░ ┌───┐ ░ ░ ║ ║ └╥┘┌─┐ \n",
+ " q_3: ┤ X ├─░──────┼─────────┤ H ├────┤ Rx(-π/2) ├┤ X ├──────░─┤ Y ├─░────┤ Y ├─────────────────────░───────░────┤ Y ├──────────────────────────░─┤ X ├─░──────┼──────┤ Rx(π/2) ├───┤ H ├───┤ Z ├──────░─┤ Y ├─░──░──╫──╫──╫─┤M├────────────\n",
+ " ├───┤ ░ │ ├───┤ ├─────────┬┘├───┤┌───┐ ░ ├───┤ ░ ├───┤ ┌──────────┐ ░ ┌───┐ ░ ┌──┴───┴──┐ ┌───┐ ░ ├───┤ ░ │ └──┬───┬──┘┌──┴───┴──┐├───┤┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_4: ┤ X ├─░──────┼─────────┤ H ├────┤ Rx(π/2) ├─┤ H ├┤ Y ├─░─┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├──────░─┤ Y ├─░─┤ Rx(π/2) ├───┤ H ├───────────────░─┤ Z ├─░──────┼─────────┤ H ├───┤ Rx(π/2) ├┤ H ├┤ Y ├─░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n",
+ " ├───┤ ░ │ ├───┤ └──┬───┬──┘ └───┘└───┘ ░ ├───┤ ░ ├───┤ ├─────────┬┘┌───┐ ░ ├───┤ ░ └──┬───┬──┘┌──┴───┴──┐ ┌───┐┌───┐ ░ ├───┤ ░ │ ├───┤ └──┬───┬──┘└───┘└───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_5: ┤ Y ├─░──────┼─────────┤ H ├───────┤ X ├───────────────░─┤ X ├─░────┤ H ├───┤ Rx(π/2) ├─┤ H ├─░─┤ X ├─░────┤ H ├───┤ Rx(π/2) ├─┤ H ├┤ Z ├─░─┤ X ├─░──────┼─────────┤ H ├──────┤ Z ├──────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n",
+ " ├───┤ ░ ┌─┴─┐ └───┘ └───┘ ░ ├───┤ ░ ├───┤ ├─────────┴┐└───┘ ░ ├───┤ ░ ┌──┴───┴──┐└──┬───┬──┘ └───┘└───┘ ░ ├───┤ ░ ┌─┴─┐ └───┘ └───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n",
+ " q_6: ┤ Y ├─░────┤ X ├───────────────────────────────────────░─┤ X ├─░────┤ H ├───┤ Rx(-π/2) ├──────░─┤ X ├─░─┤ Rx(π/2) ├───┤ H ├───────────────░─┤ Z ├─░────┤ X ├─────────────────────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n",
+ " ├───┤ ░ ├───┤ ┌───┐ ░ ├───┤ ░ ├───┤ └──────────┘ ░ └───┘ ░ └──┬───┬──┘ └───┘ ░ ├───┤ ░ ├───┤ ┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n",
+ " q_7: ┤ X ├─░────┤ H ├───────┤ Z ├───────────────────────────░─┤ Y ├─░────┤ Z ├─────────────────────░───────░────┤ Z ├──────────────────────────░─┤ X ├─░────┤ H ├───────┤ X ├─────────────────────────░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
+ " └───┘ ░ └───┘ └───┘ ░ └───┘ ░ └───┘ ░ ░ └───┘ ░ └───┘ ░ └───┘ └───┘ ░ └───┘ ░ ░ ║ ║ ║ ║ ║ ║ ║ └╥┘\n",
+ "meas: 8/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n",
+ " 0 1 2 3 4 5 6 7 "
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "print('Pairs:', exp._pairs[1])\n",
+ "exp._static_trans_circuits[1].draw(fold=-1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0e177145",
+ "metadata": {},
+ "source": [
+ "Now we can analyze the data according to our desired analysis method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "2f8f9c6c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "exp.analysis.set_options(analyzed_quantity='Effective Polarization')\n",
+ "#exp.analysis.set_options(analyzed_quantity='Mutual Information')\n",
+ "analysis = exp.analysis.run(rb_data)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9509b48a",
+ "metadata": {},
+ "source": [
+ "Then plot the results.\n",
+ "\n",
+ "Note: if you get the `'Figure index 0 out of range.'` error, it might be because the analysis is still running in the background. So just try again."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "0d7e760a",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "analysis.figure(0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "50a9f78e",
+ "metadata": {},
+ "source": [
+ "When we calculate the mutual informations, it is done by the `QuantumAwesomeness` object. We can also use this directly."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "00350a9d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "qa = QuantumAwesomeness(exp.backend.coupling_map)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "daf5e687",
+ "metadata": {},
+ "source": [
+ "It can be used to calculate the MIs for each pair in the coupling map for each circuit that was run."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "4a0023f0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "mi = qa.mutual_info(rb_data.data())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f008f380",
+ "metadata": {},
+ "source": [
+ "It can also be used to calculate the mean MIs, where separate means are taken for the entangled pairs and the non-entangled pairs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "0db0fbc2",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "mmi = qa.mean_mutual_info(rb_data.data(), exp._pairs)\n",
+ "\n",
+ "ys = [[[] for _ in range(6)] for _ in range(2)]\n",
+ "yerrs = [[],[]]\n",
+ "\n",
+ "for p, pairtype in enumerate(['paired', 'single']):\n",
+ " for j,m in enumerate(mmi[pairtype]):\n",
+ " if m is not np.nan:\n",
+ " ys[p][j%6].append(m)\n",
+ " for j in range(6):\n",
+ " yerrs[p].append(np.std(ys[p][j]))\n",
+ " ys[p][j] = np.mean(ys[p][j])\n",
+ "\n",
+ "plt.errorbar(lengths,ys[0],yerr=yerrs[0],label='paired')\n",
+ "plt.errorbar(lengths,ys[1],yerr=yerrs[1],label='singles')\n",
+ "plt.yscale('log')\n",
+ "plt.legend()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2bcf86a1",
+ "metadata": {},
+ "source": [
+ "Pickled results from a run on `'ibm_sherbrooke'`can be found in the following files.\n",
+ "\n",
+ "* `exp`: `'pickled_sherbrooke/exp_c0cc1667-c4da-475d-86c5-f85771ad4ce5.p'`\n",
+ "* `data`: `'pickled_sherbrooke/data_c0cc1667-c4da-475d-86c5-f85771ad4ce5.p'`\n",
+ "* `data.data()`: `'pickled_sherbrooke/data_data_c0cc1667-c4da-475d-86c5-f85771ad4ce5.p'`\n",
+ "* `mi`: `'pickled_sherbrooke/mi_c0cc1667-c4da-475d-86c5-f85771ad4ce5.p'`\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e14daef6",
+ "metadata": {},
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0163479e",
+ "metadata": {},
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e8249942",
+ "metadata": {},
+ "source": []
+ }
+ ],
+ "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.12.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/qiskit_device_benchmarking/bench_code/mrb/__init__.py b/qiskit_device_benchmarking/bench_code/mrb/__init__.py
index 9f2940e..01b6d47 100644
--- a/qiskit_device_benchmarking/bench_code/mrb/__init__.py
+++ b/qiskit_device_benchmarking/bench_code/mrb/__init__.py
@@ -28,10 +28,13 @@
from .mirror_qv_analysis import MirrorQuantumVolumeAnalysis
from .mirror_rb_experiment import MirrorRB
from .mirror_rb_analysis import MirrorRBAnalysis
+from .mirror_qa import MirrorQA, QuantumAwesomeness
__all__ = [
MirrorQuantumVolume,
MirrorQuantumVolumeAnalysis,
MirrorRB,
MirrorRBAnalysis,
+ MirrorQA,
+ QuantumAwesomeness
]
diff --git a/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py b/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py
new file mode 100644
index 0000000..bd2ef9a
--- /dev/null
+++ b/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py
@@ -0,0 +1,291 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Mirror QA Experiment class.
+"""
+from typing import Union, Iterable, Optional, List, Sequence
+import numpy as np
+from numpy import pi
+from numpy.random import Generator, BitGenerator, SeedSequence
+from scipy.stats import entropy
+from uncertainties import unumpy as unp
+from scipy.spatial.distance import hamming
+
+from qiskit.circuit import Instruction
+from qiskit.providers.backend import Backend
+from qiskit.circuit.library import CXGate
+
+from qiskit_experiments.framework import ExperimentData
+from qiskit_experiments.data_processing import DataProcessor
+
+from .mirror_rb_experiment import MirrorRB, MirrorRBAnalysis
+from .mirror_qv_analysis import _ComputeQuantities
+
+
+class MirrorQA(MirrorRB):
+ """An experiment to measure gate infidelity using mirrored circuit
+ layers sampled from a defined distribution.
+
+ # section: overview
+ Mirror randomized benchmarking (mirror RB) estimates the average error rate of
+ quantum gates using layers of gates sampled from a distribution that are then
+ inverted in the second half of the circuit.
+
+ The default mirror RB experiment generates circuits of layers of Cliffords,
+ consisting of single-qubit Cliffords and a two-qubit gate such as CX,
+ interleaved with layers of Pauli gates and capped at the start and end by a
+ layer of single-qubit Cliffords. The second half of the Clifford layers are the
+ inverses of the first half of Clifford layers. This algorithm has a lot less
+ overhead than the standard randomized benchmarking, which requires
+ n-qubit Clifford gates, and so it can be used for benchmarking gates on
+ 10s of or even 100+ noisy qubits.
+
+ After running the circuits on a backend, various quantities (success
+ probability, adjusted success probability, and effective polarization)
+ are computed and used to fit an exponential decay curve and calculate
+ the EPC (error per Clifford, also referred to as the average gate
+ infidelity) and entanglement infidelity (see references for more info).
+
+ # section: analysis_ref
+ :class:`MirrorRBAnalysis`
+
+ # section: manual
+ :doc:`/manuals/verification/mirror_rb`
+
+ # section: reference
+ .. ref_arxiv:: 1 2112.09853
+ .. ref_arxiv:: 2 2008.11294
+ .. ref_arxiv:: 3 2204.07568
+
+ """
+
+ # pylint: disable=dangerous-default-value
+ def __init__(
+ self,
+ physical_qubits: Sequence[int],
+ lengths: Iterable[int],
+ pauli_randomize: bool = True,
+ sampling_algorithm: str = "edge_grab",
+ two_qubit_gate_density: float = 0.25,
+ two_qubit_gate: Instruction = CXGate(),
+ num_samples: int = 3,
+ sampler_opts: Optional[dict] = {},
+ backend: Optional[Backend] = None,
+ seed: Optional[Union[int, SeedSequence, BitGenerator, Generator]] = None,
+ inverting_pauli_layer: bool = False,
+ initial_entangling_angle: float = pi/2,
+ final_entangling_angle: float = 0,
+ analyzed_quantity: str = "Effective Polarization",
+ ):
+ """Initialize a mirror quantum awesomeness experiment.
+
+ Args:
+ physical_qubits: A list of physical qubits for the experiment.
+ lengths: A list of RB sequences lengths.
+ sampling_algorithm: The sampling algorithm to use for generating
+ circuit layers. Defaults to "edge_grab" which uses :class:`.EdgeGrabSampler`.
+ start_end_clifford: If True, begin the circuit with uniformly random 1-qubit
+ Cliffords and end the circuit with their inverses.
+ pauli_randomize: If True, surround each sampled circuit layer with layers of
+ uniformly random 1-qubit Paulis.
+ two_qubit_gate_density: Expected proportion of qubit sites with two-qubit
+ gates over all circuit layers (not counting optional layers at the start
+ and end). Only has effect if the default sampler
+ :class:`.EdgeGrabSampler` is used.
+ two_qubit_gate: The two-qubit gate to use. Defaults to
+ :class:`~qiskit.circuit.library.CXGate`. Only has effect if the
+ default sampler :class:`.EdgeGrabSampler` is used.
+ num_samples: Number of samples to generate for each sequence length.
+ sampler_opts: Optional dictionary of keyword arguments to pass to the sampler.
+ backend: Optional, the backend to run the experiment on.
+ seed: Optional, seed used to initialize ``numpy.random.default_rng``.
+ when generating circuits. The ``default_rng`` will be initialized
+ with this seed value every time :meth:`circuits` is called.
+ full_sampling: If True all Cliffords are independently sampled for
+ all lengths. If False for sample of lengths longer sequences are
+ constructed by appending additional Clifford samples to shorter
+ sequences.
+ inverting_pauli_layer: If True, a layer of Pauli gates is appended at the
+ end of the circuit to set all qubits to 0.
+
+ Raises:
+ QiskitError: if an odd length or a negative two qubit gate density is provided
+ """
+
+ super().__init__(
+ physical_qubits,
+ lengths,
+ backend=backend,
+ pauli_randomize=pauli_randomize,
+ sampling_algorithm=sampling_algorithm,
+ two_qubit_gate_density=two_qubit_gate_density,
+ num_samples=num_samples,
+ sampler_opts=sampler_opts,
+ seed=seed,
+ inverting_pauli_layer=inverting_pauli_layer,
+ full_sampling=False,
+ start_end_clifford=False,
+ initial_entangling_angle = initial_entangling_angle,
+ final_entangling_angle = final_entangling_angle,
+ )
+
+ self.analysis = MirrorQAAnalysis()
+
+class MirrorQAAnalysis(MirrorRBAnalysis):
+
+ @classmethod
+ def _default_options(cls):
+ default_options = super()._default_options()
+
+ default_options.set_validator(
+ field="analyzed_quantity",
+ validator_value=[
+ "Success Probability",
+ "Adjusted Success Probability",
+ "Effective Polarization",
+ "Mutual Information"
+ ],
+ )
+ return default_options
+
+ def _initialize(self, experiment_data: ExperimentData):
+ """Initialize curve analysis by setting up the data processor for Mirror
+ RB data.
+
+ Args:
+ experiment_data: Experiment data to analyze.
+ """
+ super()._initialize(experiment_data)
+
+ num_qubits = len(self._physical_qubits)
+ target_bs = []
+ pairs = []
+ singles = []
+ for circ_result in experiment_data.data():
+ pairs.append(circ_result["metadata"]["pairs"])
+ singles.append(circ_result["metadata"]["singles"])
+ if circ_result["metadata"]["inverting_pauli_layer"] is True:
+ target_bs.append("0" * num_qubits)
+ else:
+ target_bs.append(circ_result["metadata"]["target"])
+
+ self.set_options(
+ data_processor=DataProcessor(
+ input_key="counts",
+ data_actions=[
+ _ComputeQAQuantities(
+ analyzed_quantity=self.options.analyzed_quantity,
+ num_qubits=num_qubits,
+ target_bs=target_bs,
+ pairs=pairs,
+ singles=singles,
+ coupling_map=circ_result["metadata"]["coupling_map"],
+ )
+ ],
+ )
+ )
+
+class _ComputeQAQuantities(_ComputeQuantities):
+ """Data processing node for computing useful mirror RB quantities from raw results."""
+
+ def __init__(
+ self,
+ num_qubits,
+ target_bs,
+ pairs,
+ singles,
+ coupling_map,
+ analyzed_quantity: str = "Effective Polarization",
+ validate: bool = True,
+ ):
+ """
+ Args:
+ num_qubits: Number of qubits.
+ quantity: The quantity to calculate.
+ validate: If set to False the DataAction will not validate its input.
+ """
+ super().__init__(
+ num_qubits = num_qubits,
+ target_bs = target_bs,
+ analyzed_quantity = analyzed_quantity,
+ validate = validate,
+ )
+ self._coupling_map = coupling_map
+ self._pairs = pairs
+
+ def _process(self, data: np.ndarray):
+ if self._analyzed_quantity == "Mutual Information":
+ qa = QuantumAwesomeness(self._coupling_map)
+ mutual_infos = qa.mean_mutual_info(data,self._pairs)
+ y_data = []
+ y_data_unc = []
+ for mi in mutual_infos['paired']:
+ y_data.append(mi)
+ y_data_unc.append(0)
+ return unp.uarray(y_data, y_data_unc)
+ else:
+ return super()._process(data)
+
+class QuantumAwesomeness():
+ def __init__(
+ self,
+ coupling_map
+ ):
+ self._coupling_map= coupling_map
+
+ def mutual_info(self, data: np.ndarray):
+
+ mutual_infos = []
+ for circ_data in data:
+ if 'counts' not in circ_data:
+ counts = circ_data
+ else:
+ counts = circ_data['counts']
+ shots = sum(counts.values())
+ p = {}
+ for j,k in self._coupling_map:
+ p[j,k] = {'00':0, '01':0, '10':0, '11':0}
+ for string in counts:
+ ss = string[-1-j] + string[-1-k]
+ p[j,k][ss] += counts[string]
+ for ss in p[j,k]:
+ p[j,k][ss] /= shots
+
+ mi = {}
+ for j,k in self._coupling_map:
+ if j Options:
@@ -227,8 +233,8 @@ def circuits(self) -> List[QuantumCircuit]:
Returns:
A list of :class:`QuantumCircuit`.
"""
- sequences = self._sample_sequences()
- circuits = self._sequences_to_circuits(sequences)
+ self._sequences = self._sample_sequences()
+ circuits = self._sequences_to_circuits(self._sequences)
return circuits
@@ -367,6 +373,31 @@ def _sample_sequences(self) -> List[Sequence[SequenceElementType]]:
for real_length in build_seq_lengths:
sequences.append(seq[: real_length // 2] + seq[-real_length // 2 :])
+ # Reverse order of Clifford layers if entangling pairs used
+ if not self.experiment_options.full_sampling and any(self._angles):
+ for s, sequence in enumerate(sequences):
+ hsl = (len(sequence)-1)//2
+ reordered_sequence = []
+ for j in range(len(sequence)):
+ h = (j > hsl)
+ if j%2: # cliffords
+ reordered_sequence.append(sequence[hsl-j-h])
+ else: # paulis
+ reordered_sequence.append(sequence[j])
+ sequences[s] = reordered_sequence
+
+ # Keep track of which qubits are paired and which not for the first Clifford layer of each circuit
+ self._pairs = []
+ self._singles = []
+ for s, sequence in enumerate(sequences):
+ self._pairs.append([])
+ self._singles.append([])
+ for gate in sequences[s][1]:
+ if len(gate.qargs) == 2:
+ self._pairs[s].append(gate.qargs)
+ else:
+ self._singles[s].append(gate.qargs[0])
+
return sequences
def _sequences_to_circuits(
@@ -381,16 +412,45 @@ def _sequences_to_circuits(
A list of RB circuits.
"""
basis_gates = tuple(self.backend.operation_names)
- circuits = []
+
+ # transpile 2q gates
+ qc2q = QuantumCircuit(2)
+ qc2q.append(self._two_qubit_gate, [0, 1])
+ qc2q = transpile(qc2q, basis_gates=basis_gates, optimization_level=3)
+ # pre-transpile pre and post rotations
+ qrx = []
+ for theta in self._angles:
+ qc = QuantumCircuit(1)
+ if theta == pi/2:
+ qc.h(0)
+ qc.s(0)
+ qc.h(0)
+ elif theta:
+ qc.rx(theta, 0)
+ qc = transpile(qc, basis_gates=basis_gates, optimization_level=3)
+ qrx.append(qc)
+ circuits = []
for i, seq in enumerate(sequences):
circ = QuantumCircuit(self.num_qubits)
# Hack to get target bitstrings until qiskit-terra#9475 is resolved
circ_target = QuantumCircuit(self.num_qubits)
- for layer in seq:
+ for l, layer in enumerate(seq):
for elem in layer:
- circ.append(self._to_instruction(elem.op, basis_gates), elem.qargs)
- circ_target.append(self._to_instruction(elem.op), elem.qargs)
+ instr = self._to_instruction(elem.op)
+ qargs = elem.qargs
+ if l == (len(seq) - 2) and instr.name == 'cx':
+ if self._angles[1]:
+ circ.compose(qrx[1], [qargs[0]], inplace=True)
+ if len(qargs) == 2:
+ # implement the compiled 2q gate
+ circ.compose(qc2q, qargs, inplace=True)
+ else:
+ circ.append(self._to_instruction(elem.op, basis_gates), qargs)
+ if l == 1 and instr.name == 'cx':
+ if self._angles[0]:
+ circ.compose(qrx[0], [qargs[0]], inplace=True)
+ circ_target.append(instr, elem.qargs)
circ.append(Barrier(self.num_qubits), circ.qubits)
circ.metadata = {
@@ -401,6 +461,9 @@ def _sequences_to_circuits(
),
"target": compute_target_bitstring(circ_target),
"inverting_pauli_layer": self.experiment_options.inverting_pauli_layer,
+ "pairs": self._pairs[i],
+ "singles": self._singles[i],
+ "coupling_map": self.backend.coupling_map,
}
if self.experiment_options.inverting_pauli_layer:
@@ -476,6 +539,7 @@ def _transpiled_circuits(self):
QiskitError: If an unknown DD sequence in specified.
"""
transpiled = super()._transpiled_circuits()
+ self._static_trans_circuits = transpiled
if getattr(self.run_options, "dd", False) is False:
return transpiled