From b72c39f636c34551edc50ad6ec62e813c9e572fb Mon Sep 17 00:00:00 2001 From: quantumjim Date: Mon, 11 Nov 2024 12:30:49 +0100 Subject: [PATCH 1/7] update basisgate retrieval --- .../bench_code/mrb/mirror_rb_experiment.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py b/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py index 0beff85..9075b78 100644 --- a/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py +++ b/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py @@ -357,7 +357,7 @@ def _sequences_to_circuits( Returns: A list of RB circuits. """ - basis_gates = self._get_basis_gates() # pylint: disable=no-member + basis_gates = tuple(self.backend.operation_names) circuits = [] for i, seq in enumerate(sequences): From da85394c49605de5f4270407b81f2e05e43cce9a Mon Sep 17 00:00:00 2001 From: quantumjim Date: Wed, 13 Nov 2024 15:45:53 +0100 Subject: [PATCH 2/7] add pre and post gates --- .../bench_code/mrb/mirror_rb_experiment.py | 47 ++++++++++++++++--- 1 file changed, 41 insertions(+), 6 deletions(-) diff --git a/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py b/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py index 9075b78..8d430e3 100644 --- a/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py +++ b/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py @@ -27,6 +27,7 @@ from qiskit.providers.options import Options from qiskit.exceptions import QiskitError from qiskit.transpiler import CouplingMap, PassManager, InstructionDurations +from qiskit import transpile from qiskit.circuit.library import CXGate, CYGate, CZGate, ECRGate, SwapGate, XGate, RZGate from qiskit.transpiler.passes import ( ALAPScheduleAnalysis, @@ -42,6 +43,7 @@ from qiskit_experiments.library.randomized_benchmarking.clifford_utils import ( inverse_1q, _clifford_1q_int_to_instruction, + _clifford_2q_int_to_instruction, ) from .mirror_rb_analysis import MirrorRBAnalysis from qiskit_device_benchmarking.utilities.clifford_utils import compute_target_bitstring @@ -113,6 +115,8 @@ def __init__( seed: Optional[Union[int, SeedSequence, BitGenerator, Generator]] = None, full_sampling: bool = False, inverting_pauli_layer: bool = False, + initial_entangling_angle: float = 0.0, + final_entangling_angle: float = 0.0, ): """Initialize a mirror randomized benchmarking experiment. @@ -173,6 +177,9 @@ def __init__( self._distribution = self.sampler_map.get(sampling_algorithm)(seed=seed, **sampler_opts) self.analysis = MirrorRBAnalysis() + self._two_qubit_gate = two_qubit_gate + self._pre_theta = initial_entangling_angle + self._post_theta = final_entangling_angle @classmethod def _default_experiment_options(cls) -> Options: @@ -216,8 +223,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 @@ -358,16 +365,44 @@ def _sequences_to_circuits( A list of RB circuits. """ basis_gates = tuple(self.backend.operation_names) - circuits = [] + + # pre-transpile pre and post rotations + qrx = [] + for theta in [self._pre_theta, self._post_theta]: + qc = QuantumCircuit(1) + qc.rx(theta, 0) + qc = transpile(qc, basis_gates=basis_gates, optimization_level=3) + qrx.append(qc) + # transpile 2q gates + qc2q = QuantumCircuit(2) + qc2q.append(self._two_qubit_gate, [0, 1]) + qc2q = transpile(qc2q, basis_gates=basis_gates, optimization_level=3) + 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': + for gate in qrx[1]: + circ.append(gate.operation, [qargs[0]]) + if len(qargs) == 2: + # implement the compiled 2q gate + for gate in qc2q: + if len(gate.qubits) == 1: + circ.append(gate.operation, [qargs[gate.qubits[0]._index]]) + else: + circ.append(gate.operation, qargs) + else: + circ.append(self._to_instruction(elem.op, basis_gates), qargs) + if l == 1 and instr.name == 'cx': + for gate in qrx[0]: + circ.append(gate.operation, [qargs[0]]) + circ_target.append(instr, elem.qargs) circ.append(Barrier(self.num_qubits), circ.qubits) circ.metadata = { From 18d92c7bb345272520ec7c4e500962bf6a179e97 Mon Sep 17 00:00:00 2001 From: quantumjim Date: Thu, 21 Nov 2024 16:06:55 +0100 Subject: [PATCH 3/7] add mqa --- .../bench_code/mrb/__init__.py | 1 + .../bench_code/mrb/mirror_qa.py | 130 ++++++++++++++++++ .../bench_code/mrb/mirror_rb_experiment.py | 53 ++++--- 3 files changed, 168 insertions(+), 16 deletions(-) create mode 100644 qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py diff --git a/qiskit_device_benchmarking/bench_code/mrb/__init__.py b/qiskit_device_benchmarking/bench_code/mrb/__init__.py index 62fa474..f94c773 100644 --- a/qiskit_device_benchmarking/bench_code/mrb/__init__.py +++ b/qiskit_device_benchmarking/bench_code/mrb/__init__.py @@ -28,3 +28,4 @@ from .mirror_qv_analysis import MirrorQuantumVolumeAnalysis from .mirror_rb_experiment import MirrorRB from .mirror_rb_analysis import MirrorRBAnalysis +from .mirror_qa import MirrorQA 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..2c2ace7 --- /dev/null +++ b/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py @@ -0,0 +1,130 @@ +# 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 +from numpy import pi +from numpy.random import Generator, BitGenerator, SeedSequence +import rustworkx as rx + +from qiskit.circuit import Instruction +from qiskit.providers.backend import Backend +from qiskit.circuit.library import CXGate + +from .mirror_rb_experiment import MirrorRB + + +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, + ): + """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, + two_qubit_gate=two_qubit_gate, + 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 = pi/2, + final_entangling_angle = pi/2, + ) \ No newline at end of file diff --git a/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py b/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py index 8d430e3..4f78556 100644 --- a/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py +++ b/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py @@ -178,8 +178,7 @@ def __init__( self._distribution = self.sampler_map.get(sampling_algorithm)(seed=seed, **sampler_opts) self.analysis = MirrorRBAnalysis() self._two_qubit_gate = two_qubit_gate - self._pre_theta = initial_entangling_angle - self._post_theta = final_entangling_angle + self._angles = [initial_entangling_angle, final_entangling_angle] @classmethod def _default_experiment_options(cls) -> Options: @@ -351,6 +350,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( @@ -366,17 +390,17 @@ def _sequences_to_circuits( """ basis_gates = tuple(self.backend.operation_names) + # 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._pre_theta, self._post_theta]: + for theta in self._angles: qc = QuantumCircuit(1) qc.rx(theta, 0) qc = transpile(qc, basis_gates=basis_gates, optimization_level=3) qrx.append(qc) - # transpile 2q gates - qc2q = QuantumCircuit(2) - qc2q.append(self._two_qubit_gate, [0, 1]) - qc2q = transpile(qc2q, basis_gates=basis_gates, optimization_level=3) circuits = [] for i, seq in enumerate(sequences): @@ -388,20 +412,16 @@ def _sequences_to_circuits( instr = self._to_instruction(elem.op) qargs = elem.qargs if l == (len(seq) - 2) and instr.name == 'cx': - for gate in qrx[1]: - circ.append(gate.operation, [qargs[0]]) + if self._angles[1]: + circ.compose(qrx[1], [qargs[0]], inplace=True) if len(qargs) == 2: # implement the compiled 2q gate - for gate in qc2q: - if len(gate.qubits) == 1: - circ.append(gate.operation, [qargs[gate.qubits[0]._index]]) - else: - circ.append(gate.operation, qargs) + circ.compose(qc2q, qargs, inplace=True) else: circ.append(self._to_instruction(elem.op, basis_gates), qargs) if l == 1 and instr.name == 'cx': - for gate in qrx[0]: - circ.append(gate.operation, [qargs[0]]) + 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) @@ -486,6 +506,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 From d8c0fbc8a3e30018c0e790cacad30cd817f65353 Mon Sep 17 00:00:00 2001 From: quantumjim Date: Wed, 4 Dec 2024 17:13:05 +0100 Subject: [PATCH 4/7] add mqa notebook --- mirror_qa.ipynb | 490 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 490 insertions(+) create mode 100644 mirror_qa.ipynb diff --git a/mirror_qa.ipynb b/mirror_qa.ipynb new file mode 100644 index 0000000..42f2d2b --- /dev/null +++ b/mirror_qa.ipynb @@ -0,0 +1,490 @@ +{ + "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", + "from qiskit.circuit.library import CXGate\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": [ + "['7638e935-089a-47d1-ba90-00bc9a72d45e']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Library/Frameworks/Python.framework/Versions/3.12/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": 6, + "id": "6677cfcb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pairs: [(0, 7), (4, 2)]\n" + ] + }, + { + "data": { + "text/html": [ + "
        ┌───┐ ░      ┌─────────┐                             ░       ░                                  ░ ┌───┐ ░  ░ ┌─┐                     \n",
+       "   q_0: ┤ Z ├─░───■──┤ Rx(π/4) ├─────────────────────────────░───────░───■──────────────────────────────░─┤ Y ├─░──░─┤M├─────────────────────\n",
+       "        ├───┤ ░   │  ├─────────┤   ┌───┐      ┌───┐          ░ ┌───┐ ░   │  ┌───┐┌──────────┐┌───┐      ░ └───┘ ░  ░ └╥┘┌─┐                  \n",
+       "   q_1: ┤ Y ├─░───┼──┤ Rx(π/2) ├───┤ H ├──────┤ X ├──────────░─┤ Y ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├──────░───────░──░──╫─┤M├──────────────────\n",
+       "        └───┘ ░   │  └──┬───┬──┘   └───┘      └───┘          ░ └───┘ ░   │  ├───┤└──────────┘└───┘      ░ ┌───┐ ░  ░  ║ └╥┘┌─┐               \n",
+       "   q_2: ──────░───┼─────┤ X ├────────────────────────────────░───────░───┼──┤ X ├───────────────────────░─┤ X ├─░──░──╫──╫─┤M├───────────────\n",
+       "        ┌───┐ ░   │     └─┬─┘      ┌───┐   ┌──────────┐┌───┐ ░       ░   │  └─┬─┘┌─────────┐ ┌───┐┌───┐ ░ ├───┤ ░  ░  ║  ║ └╥┘┌─┐            \n",
+       "   q_3: ┤ Y ├─░───┼───────┼────────┤ H ├───┤ Rx(-π/2) ├┤ Z ├─░───────░───┼────┼──┤ Rx(π/2) ├─┤ H ├┤ Y ├─░─┤ Z ├─░──░──╫──╫──╫─┤M├────────────\n",
+       "        ├───┤ ░   │       │     ┌──┴───┴──┐└──────────┘└───┘ ░ ┌───┐ ░   │    │  └─────────┘ └───┘└───┘ ░ ├───┤ ░  ░  ║  ║  ║ └╥┘┌─┐         \n",
+       "   q_4: ┤ Y ├─░───┼───────■─────┤ Rx(π/4) ├──────────────────░─┤ Z ├─░───┼────■─────────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n",
+       "        ├───┤ ░   │     ┌───┐   └─────────┘                  ░ ├───┤ ░   │  ┌───┐                       ░ ├───┤ ░  ░  ║  ║  ║  ║ └╥┘┌─┐      \n",
+       "   q_5: ┤ Y ├─░───┼─────┤ X ├────────────────────────────────░─┤ Z ├─░───┼──┤ X ├───────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n",
+       "        ├───┤ ░   │     ├───┤      ┌───┐                     ░ ├───┤ ░   │  ├───┤   ┌───┐               ░ ├───┤ ░  ░  ║  ║  ║  ║  ║ └╥┘┌─┐   \n",
+       "   q_6: ┤ Z ├─░───┼─────┤ H ├──────┤ Z ├─────────────────────░─┤ Z ├─░───┼──┤ H ├───┤ X ├───────────────░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n",
+       "        ├───┤ ░ ┌─┴─┐   └───┘      └───┘                     ░ └───┘ ░ ┌─┴─┐└───┘   └───┘               ░ ├───┤ ░  ░  ║  ║  ║  ║  ║  ║ └╥┘┌─┐\n",
+       "   q_7: ┤ Y ├─░─┤ X ├────────────────────────────────────────░───────░─┤ X ├────────────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
+       "        └───┘ ░ └───┘                                        ░       ░ └───┘                            ░ └───┘ ░  ░  ║  ║  ║  ║  ║  ║  ║ └╥┘\n",
+       "meas: 8/══════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n",
+       "                                                                                                                      0  1  2  3  4  5  6  7
" + ], + "text/plain": [ + " ┌───┐ ░ ┌─────────┐ ░ ░ ░ ┌───┐ ░ ░ ┌─┐ \n", + " q_0: ┤ Z ├─░───■──┤ Rx(π/4) ├─────────────────────────────░───────░───■──────────────────────────────░─┤ Y ├─░──░─┤M├─────────────────────\n", + " ├───┤ ░ │ ├─────────┤ ┌───┐ ┌───┐ ░ ┌───┐ ░ │ ┌───┐┌──────────┐┌───┐ ░ └───┘ ░ ░ └╥┘┌─┐ \n", + " q_1: ┤ Y ├─░───┼──┤ Rx(π/2) ├───┤ H ├──────┤ X ├──────────░─┤ Y ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├──────░───────░──░──╫─┤M├──────────────────\n", + " └───┘ ░ │ └──┬───┬──┘ └───┘ └───┘ ░ └───┘ ░ │ ├───┤└──────────┘└───┘ ░ ┌───┐ ░ ░ ║ └╥┘┌─┐ \n", + " q_2: ──────░───┼─────┤ X ├────────────────────────────────░───────░───┼──┤ X ├───────────────────────░─┤ X ├─░──░──╫──╫─┤M├───────────────\n", + " ┌───┐ ░ │ └─┬─┘ ┌───┐ ┌──────────┐┌───┐ ░ ░ │ └─┬─┘┌─────────┐ ┌───┐┌───┐ ░ ├───┤ ░ ░ ║ ║ └╥┘┌─┐ \n", + " q_3: ┤ Y ├─░───┼───────┼────────┤ H ├───┤ Rx(-π/2) ├┤ Z ├─░───────░───┼────┼──┤ Rx(π/2) ├─┤ H ├┤ Y ├─░─┤ Z ├─░──░──╫──╫──╫─┤M├────────────\n", + " ├───┤ ░ │ │ ┌──┴───┴──┐└──────────┘└───┘ ░ ┌───┐ ░ │ │ └─────────┘ └───┘└───┘ ░ ├───┤ ░ ░ ║ ║ ║ └╥┘┌─┐ \n", + " q_4: ┤ Y ├─░───┼───────■─────┤ Rx(π/4) ├──────────────────░─┤ Z ├─░───┼────■─────────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n", + " ├───┤ ░ │ ┌───┐ └─────────┘ ░ ├───┤ ░ │ ┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_5: ┤ Y ├─░───┼─────┤ X ├────────────────────────────────░─┤ Z ├─░───┼──┤ X ├───────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n", + " ├───┤ ░ │ ├───┤ ┌───┐ ░ ├───┤ ░ │ ├───┤ ┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_6: ┤ Z ├─░───┼─────┤ H ├──────┤ Z ├─────────────────────░─┤ Z ├─░───┼──┤ H ├───┤ X ├───────────────░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n", + " ├───┤ ░ ┌─┴─┐ └───┘ └───┘ ░ └───┘ ░ ┌─┴─┐└───┘ └───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n", + " q_7: ┤ Y ├─░─┤ X ├────────────────────────────────────────░───────░─┤ X ├────────────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤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[0])\n", + "exp._static_trans_circuits[0].draw(fold=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c8f2da90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pairs: [(5, 7), (0, 4)]\n" + ] + }, + { + "data": { + "text/html": [ + "
        ┌───┐ ░      ┌─────────┐           ░ ┌───┐ ░                                        ░       ░                                  ░       ░                             ░ ┌───┐ ░  ░ ┌─┐                     \n",
+       "   q_0: ┤ Z ├─░───■──┤ Rx(π/4) ├───────────░─┤ Z ├─░───■────────────────────────────────────░───────░───■──────────────────────────────░───────░───■─────────────────────────░─┤ Y ├─░──░─┤M├─────────────────────\n",
+       "        ├───┤ ░   │  └──┬───┬──┘┌───┐      ░ ├───┤ ░   │  ┌─────────┐┌───┐   ┌───┐          ░ ┌───┐ ░   │  ┌───┐┌──────────┐┌───┐      ░ ┌───┐ ░   │  ┌───┐   ┌───┐          ░ └───┘ ░  ░ └╥┘┌─┐                  \n",
+       "   q_1: ┤ Y ├─░───┼─────┤ H ├───┤ Z ├──────░─┤ Z ├─░───┼──┤ Rx(π/2) ├┤ H ├───┤ X ├──────────░─┤ X ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├──────░─┤ Y ├─░───┼──┤ H ├───┤ X ├──────────░───────░──░──╫─┤M├──────────────────\n",
+       "        └───┘ ░   │  ┌──┴───┴──┐├───┤┌───┐ ░ ├───┤ ░   │  └──┬───┬──┘└───┘   └───┘          ░ ├───┤ ░   │  ├───┤└──────────┘└───┘      ░ └───┘ ░   │  ├───┤┌──┴───┴───┐┌───┐ ░ ┌───┐ ░  ░  ║ └╥┘┌─┐               \n",
+       "   q_2: ──────░───┼──┤ Rx(π/2) ├┤ H ├┤ Z ├─░─┤ Z ├─░───┼─────┤ X ├──────────────────────────░─┤ Y ├─░───┼──┤ X ├───────────────────────░───────░───┼──┤ H ├┤ Rx(-π/2) ├┤ X ├─░─┤ X ├─░──░──╫──╫─┤M├───────────────\n",
+       "        ┌───┐ ░   │  └──┬───┬──┘└───┘└───┘ ░ └───┘ ░   │     └─┬─┘   ┌───┐┌──────────┐┌───┐ ░ └───┘ ░   │  └─┬─┘┌─────────┐ ┌───┐┌───┐ ░       ░   │  ├───┤└──────────┘└───┘ ░ ├───┤ ░  ░  ║  ║ └╥┘┌─┐            \n",
+       "   q_3: ┤ Y ├─░───┼─────┤ H ├──────────────░───────░───┼───────┼─────┤ H ├┤ Rx(-π/2) ├┤ Z ├─░───────░───┼────┼──┤ Rx(π/2) ├─┤ H ├┤ Y ├─░───────░───┼──┤ H ├──────────────────░─┤ Z ├─░──░──╫──╫──╫─┤M├────────────\n",
+       "        ├───┤ ░ ┌─┴─┐   └───┘              ░ ┌───┐ ░   │       │     └───┘└──────────┘└───┘ ░       ░   │    │  └─────────┘ └───┘└───┘ ░ ┌───┐ ░ ┌─┴─┐└───┘                  ░ ├───┤ ░  ░  ║  ║  ║ └╥┘┌─┐         \n",
+       "   q_4: ┤ Y ├─░─┤ X ├──────────────────────░─┤ X ├─░───┼───────■────────────────────────────░───────░───┼────■─────────────────────────░─┤ Z ├─░─┤ X ├───────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n",
+       "        ├───┤ ░ └───┘┌─────────┐           ░ ├───┤ ░   │     ┌───┐                          ░ ┌───┐ ░   │  ┌───┐                       ░ ├───┤ ░ └───┘                       ░ ├───┤ ░  ░  ║  ║  ║  ║ └╥┘┌─┐      \n",
+       "   q_5: ┤ Y ├─░───■──┤ Rx(π/4) ├───────────░─┤ Y ├─░───┼─────┤ X ├──────────────────────────░─┤ X ├─░───┼──┤ X ├───────────────────────░─┤ Z ├─░───■─────────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n",
+       "        ├───┤ ░   │  ├─────────┤┌───┐┌───┐ ░ ├───┤ ░   │     ├───┤   ┌───┐                  ░ └───┘ ░   │  ├───┤   ┌───┐               ░ ├───┤ ░   │  ┌───┐┌──────────┐┌───┐ ░ ├───┤ ░  ░  ║  ║  ║  ║  ║ └╥┘┌─┐   \n",
+       "   q_6: ┤ Z ├─░───┼──┤ Rx(π/2) ├┤ H ├┤ X ├─░─┤ X ├─░───┼─────┤ H ├───┤ Z ├──────────────────░───────░───┼──┤ H ├───┤ X ├───────────────░─┤ Z ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├─░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n",
+       "        ├───┤ ░ ┌─┴─┐└─────────┘└───┘└───┘ ░ ├───┤ ░ ┌─┴─┐   └───┘   └───┘                  ░ ┌───┐ ░ ┌─┴─┐└───┘   └───┘               ░ └───┘ ░ ┌─┴─┐└───┘└──────────┘└───┘ ░ ├───┤ ░  ░  ║  ║  ║  ║  ║  ║ └╥┘┌─┐\n",
+       "   q_7: ┤ Y ├─░─┤ X ├──────────────────────░─┤ Y ├─░─┤ X ├──────────────────────────────────░─┤ Y ├─░─┤ X ├────────────────────────────░───────░─┤ X ├───────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
+       "        └───┘ ░ └───┘                      ░ └───┘ ░ └───┘                                  ░ └───┘ ░ └───┘                            ░       ░ └───┘                       ░ └───┘ ░  ░  ║  ║  ║  ║  ║  ║  ║ └╥┘\n",
+       "meas: 8/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n",
+       "                                                                                                                                                                                           0  1  2  3  4  5  6  7
" + ], + "text/plain": [ + " ┌───┐ ░ ┌─────────┐ ░ ┌───┐ ░ ░ ░ ░ ░ ░ ┌───┐ ░ ░ ┌─┐ \n", + " q_0: ┤ Z ├─░───■──┤ Rx(π/4) ├───────────░─┤ Z ├─░───■────────────────────────────────────░───────░───■──────────────────────────────░───────░───■─────────────────────────░─┤ Y ├─░──░─┤M├─────────────────────\n", + " ├───┤ ░ │ └──┬───┬──┘┌───┐ ░ ├───┤ ░ │ ┌─────────┐┌───┐ ┌───┐ ░ ┌───┐ ░ │ ┌───┐┌──────────┐┌───┐ ░ ┌───┐ ░ │ ┌───┐ ┌───┐ ░ └───┘ ░ ░ └╥┘┌─┐ \n", + " q_1: ┤ Y ├─░───┼─────┤ H ├───┤ Z ├──────░─┤ Z ├─░───┼──┤ Rx(π/2) ├┤ H ├───┤ X ├──────────░─┤ X ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├──────░─┤ Y ├─░───┼──┤ H ├───┤ X ├──────────░───────░──░──╫─┤M├──────────────────\n", + " └───┘ ░ │ ┌──┴───┴──┐├───┤┌───┐ ░ ├───┤ ░ │ └──┬───┬──┘└───┘ └───┘ ░ ├───┤ ░ │ ├───┤└──────────┘└───┘ ░ └───┘ ░ │ ├───┤┌──┴───┴───┐┌───┐ ░ ┌───┐ ░ ░ ║ └╥┘┌─┐ \n", + " q_2: ──────░───┼──┤ Rx(π/2) ├┤ H ├┤ Z ├─░─┤ Z ├─░───┼─────┤ X ├──────────────────────────░─┤ Y ├─░───┼──┤ X ├───────────────────────░───────░───┼──┤ H ├┤ Rx(-π/2) ├┤ X ├─░─┤ X ├─░──░──╫──╫─┤M├───────────────\n", + " ┌───┐ ░ │ └──┬───┬──┘└───┘└───┘ ░ └───┘ ░ │ └─┬─┘ ┌───┐┌──────────┐┌───┐ ░ └───┘ ░ │ └─┬─┘┌─────────┐ ┌───┐┌───┐ ░ ░ │ ├───┤└──────────┘└───┘ ░ ├───┤ ░ ░ ║ ║ └╥┘┌─┐ \n", + " q_3: ┤ Y ├─░───┼─────┤ H ├──────────────░───────░───┼───────┼─────┤ H ├┤ Rx(-π/2) ├┤ Z ├─░───────░───┼────┼──┤ Rx(π/2) ├─┤ H ├┤ Y ├─░───────░───┼──┤ H ├──────────────────░─┤ Z ├─░──░──╫──╫──╫─┤M├────────────\n", + " ├───┤ ░ ┌─┴─┐ └───┘ ░ ┌───┐ ░ │ │ └───┘└──────────┘└───┘ ░ ░ │ │ └─────────┘ └───┘└───┘ ░ ┌───┐ ░ ┌─┴─┐└───┘ ░ ├───┤ ░ ░ ║ ║ ║ └╥┘┌─┐ \n", + " q_4: ┤ Y ├─░─┤ X ├──────────────────────░─┤ X ├─░───┼───────■────────────────────────────░───────░───┼────■─────────────────────────░─┤ Z ├─░─┤ X ├───────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n", + " ├───┤ ░ └───┘┌─────────┐ ░ ├───┤ ░ │ ┌───┐ ░ ┌───┐ ░ │ ┌───┐ ░ ├───┤ ░ └───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_5: ┤ Y ├─░───■──┤ Rx(π/4) ├───────────░─┤ Y ├─░───┼─────┤ X ├──────────────────────────░─┤ X ├─░───┼──┤ X ├───────────────────────░─┤ Z ├─░───■─────────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n", + " ├───┤ ░ │ ├─────────┤┌───┐┌───┐ ░ ├───┤ ░ │ ├───┤ ┌───┐ ░ └───┘ ░ │ ├───┤ ┌───┐ ░ ├───┤ ░ │ ┌───┐┌──────────┐┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_6: ┤ Z ├─░───┼──┤ Rx(π/2) ├┤ H ├┤ X ├─░─┤ X ├─░───┼─────┤ H ├───┤ Z ├──────────────────░───────░───┼──┤ H ├───┤ X ├───────────────░─┤ Z ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├─░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n", + " ├───┤ ░ ┌─┴─┐└─────────┘└───┘└───┘ ░ ├───┤ ░ ┌─┴─┐ └───┘ └───┘ ░ ┌───┐ ░ ┌─┴─┐└───┘ └───┘ ░ └───┘ ░ ┌─┴─┐└───┘└──────────┘└───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n", + " q_7: ┤ Y ├─░─┤ X ├──────────────────────░─┤ Y ├─░─┤ X ├──────────────────────────────────░─┤ Y ├─░─┤ X ├────────────────────────────░───────░─┤ X ├───────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n", + " └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ ░ └───┘ ░ └───┘ ░ ░ ║ ║ ║ ║ ║ ║ ║ └╥┘\n", + "meas: 8/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n", + " 0 1 2 3 4 5 6 7 " + ] + }, + "execution_count": 7, + "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": 8, + "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": 9, + "id": "0d7e760a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "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": 10, + "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": 11, + "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": [] + } + ], + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From bfa2fe3acc876afef9afc82f79c2062e4075a731 Mon Sep 17 00:00:00 2001 From: quantumjim Date: Wed, 4 Dec 2024 17:20:15 +0100 Subject: [PATCH 5/7] add changes --- .../bench_code/mrb/mirror_qa.py | 175 +++++++++++++++++- 1 file changed, 169 insertions(+), 6 deletions(-) diff --git a/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py b/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py index 2c2ace7..28c9dbc 100644 --- a/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py +++ b/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py @@ -13,15 +13,22 @@ 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 -import rustworkx as rx +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 .mirror_rb_experiment import MirrorRB +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): @@ -75,6 +82,9 @@ def __init__( 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. @@ -118,13 +128,166 @@ def __init__( pauli_randomize=pauli_randomize, sampling_algorithm=sampling_algorithm, two_qubit_gate_density=two_qubit_gate_density, - two_qubit_gate=two_qubit_gate, + two_qubit_gate=CXGate(), 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 = pi/2, - final_entangling_angle = pi/2, - ) \ No newline at end of file + 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, + pairs = pairs, + singles = singles, + analyzed_quantity = analyzed_quantity, + validate = validate, + ) + self._coupling_map = coupling_map + + 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 Date: Wed, 4 Dec 2024 17:37:07 +0100 Subject: [PATCH 6/7] add awesome init --- qiskit_device_benchmarking/bench_code/mrb/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_device_benchmarking/bench_code/mrb/__init__.py b/qiskit_device_benchmarking/bench_code/mrb/__init__.py index f94c773..ba8effb 100644 --- a/qiskit_device_benchmarking/bench_code/mrb/__init__.py +++ b/qiskit_device_benchmarking/bench_code/mrb/__init__.py @@ -28,4 +28,4 @@ from .mirror_qv_analysis import MirrorQuantumVolumeAnalysis from .mirror_rb_experiment import MirrorRB from .mirror_rb_analysis import MirrorRBAnalysis -from .mirror_qa import MirrorQA +from .mirror_qa import MirrorQA, QuantumAwesomeness From 732692eb00e91ef570583716cb61176e15b9ff80 Mon Sep 17 00:00:00 2001 From: quantumjim Date: Wed, 4 Dec 2024 17:59:36 +0100 Subject: [PATCH 7/7] add further changes that should have been there already! --- mirror_qa.ipynb | 205 ++++++++++-------- .../bench_code/mrb/mirror_qa.py | 4 +- .../bench_code/mrb/mirror_rb_experiment.py | 3 + 3 files changed, 114 insertions(+), 98 deletions(-) diff --git a/mirror_qa.ipynb b/mirror_qa.ipynb index 42f2d2b..8fdd9ff 100644 --- a/mirror_qa.ipynb +++ b/mirror_qa.ipynb @@ -11,7 +11,6 @@ "import matplotlib.pyplot as plt\n", "\n", "from qiskit.providers.fake_provider import GenericBackendV2\n", - "from qiskit.circuit.library import CXGate\n", "\n", "from qiskit_device_benchmarking.bench_code.mrb import MirrorQA, QuantumAwesomeness\n", "\n", @@ -132,14 +131,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "['7638e935-089a-47d1-ba90-00bc9a72d45e']\n" + "['d0ee5e7a-32d6-47e2-824c-0c87db1728d7']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Library/Frameworks/Python.framework/Versions/3.12/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", + "/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" ] } @@ -168,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "6677cfcb", "metadata": {}, "outputs": [ @@ -176,55 +175,57 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pairs: [(0, 7), (4, 2)]\n" + "Pairs: []\n" ] }, { "data": { "text/html": [ - "
        ┌───┐ ░      ┌─────────┐                             ░       ░                                  ░ ┌───┐ ░  ░ ┌─┐                     \n",
-       "   q_0: ┤ Z ├─░───■──┤ Rx(π/4) ├─────────────────────────────░───────░───■──────────────────────────────░─┤ Y ├─░──░─┤M├─────────────────────\n",
-       "        ├───┤ ░   │  ├─────────┤   ┌───┐      ┌───┐          ░ ┌───┐ ░   │  ┌───┐┌──────────┐┌───┐      ░ └───┘ ░  ░ └╥┘┌─┐                  \n",
-       "   q_1: ┤ Y ├─░───┼──┤ Rx(π/2) ├───┤ H ├──────┤ X ├──────────░─┤ Y ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├──────░───────░──░──╫─┤M├──────────────────\n",
-       "        └───┘ ░   │  └──┬───┬──┘   └───┘      └───┘          ░ └───┘ ░   │  ├───┤└──────────┘└───┘      ░ ┌───┐ ░  ░  ║ └╥┘┌─┐               \n",
-       "   q_2: ──────░───┼─────┤ X ├────────────────────────────────░───────░───┼──┤ X ├───────────────────────░─┤ X ├─░──░──╫──╫─┤M├───────────────\n",
-       "        ┌───┐ ░   │     └─┬─┘      ┌───┐   ┌──────────┐┌───┐ ░       ░   │  └─┬─┘┌─────────┐ ┌───┐┌───┐ ░ ├───┤ ░  ░  ║  ║ └╥┘┌─┐            \n",
-       "   q_3: ┤ Y ├─░───┼───────┼────────┤ H ├───┤ Rx(-π/2) ├┤ Z ├─░───────░───┼────┼──┤ Rx(π/2) ├─┤ H ├┤ Y ├─░─┤ Z ├─░──░──╫──╫──╫─┤M├────────────\n",
-       "        ├───┤ ░   │       │     ┌──┴───┴──┐└──────────┘└───┘ ░ ┌───┐ ░   │    │  └─────────┘ └───┘└───┘ ░ ├───┤ ░  ░  ║  ║  ║ └╥┘┌─┐         \n",
-       "   q_4: ┤ Y ├─░───┼───────■─────┤ Rx(π/4) ├──────────────────░─┤ Z ├─░───┼────■─────────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n",
-       "        ├───┤ ░   │     ┌───┐   └─────────┘                  ░ ├───┤ ░   │  ┌───┐                       ░ ├───┤ ░  ░  ║  ║  ║  ║ └╥┘┌─┐      \n",
-       "   q_5: ┤ Y ├─░───┼─────┤ X ├────────────────────────────────░─┤ Z ├─░───┼──┤ X ├───────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n",
-       "        ├───┤ ░   │     ├───┤      ┌───┐                     ░ ├───┤ ░   │  ├───┤   ┌───┐               ░ ├───┤ ░  ░  ║  ║  ║  ║  ║ └╥┘┌─┐   \n",
-       "   q_6: ┤ Z ├─░───┼─────┤ H ├──────┤ Z ├─────────────────────░─┤ Z ├─░───┼──┤ H ├───┤ X ├───────────────░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n",
-       "        ├───┤ ░ ┌─┴─┐   └───┘      └───┘                     ░ └───┘ ░ ┌─┴─┐└───┘   └───┘               ░ ├───┤ ░  ░  ║  ║  ║  ║  ║  ║ └╥┘┌─┐\n",
-       "   q_7: ┤ Y ├─░─┤ X ├────────────────────────────────────────░───────░─┤ X ├────────────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
-       "        └───┘ ░ └───┘                                        ░       ░ └───┘                            ░ └───┘ ░  ░  ║  ║  ║  ║  ║  ║  ║ └╥┘\n",
-       "meas: 8/══════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n",
-       "                                                                                                                      0  1  2  3  4  5  6  7
" + "
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": [ - " ┌───┐ ░ ┌─────────┐ ░ ░ ░ ┌───┐ ░ ░ ┌─┐ \n", - " q_0: ┤ Z ├─░───■──┤ Rx(π/4) ├─────────────────────────────░───────░───■──────────────────────────────░─┤ Y ├─░──░─┤M├─────────────────────\n", - " ├───┤ ░ │ ├─────────┤ ┌───┐ ┌───┐ ░ ┌───┐ ░ │ ┌───┐┌──────────┐┌───┐ ░ └───┘ ░ ░ └╥┘┌─┐ \n", - " q_1: ┤ Y ├─░───┼──┤ Rx(π/2) ├───┤ H ├──────┤ X ├──────────░─┤ Y ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├──────░───────░──░──╫─┤M├──────────────────\n", - " └───┘ ░ │ └──┬───┬──┘ └───┘ └───┘ ░ └───┘ ░ │ ├───┤└──────────┘└───┘ ░ ┌───┐ ░ ░ ║ └╥┘┌─┐ \n", - " q_2: ──────░───┼─────┤ X ├────────────────────────────────░───────░───┼──┤ X ├───────────────────────░─┤ X ├─░──░──╫──╫─┤M├───────────────\n", - " ┌───┐ ░ │ └─┬─┘ ┌───┐ ┌──────────┐┌───┐ ░ ░ │ └─┬─┘┌─────────┐ ┌───┐┌───┐ ░ ├───┤ ░ ░ ║ ║ └╥┘┌─┐ \n", - " q_3: ┤ Y ├─░───┼───────┼────────┤ H ├───┤ Rx(-π/2) ├┤ Z ├─░───────░───┼────┼──┤ Rx(π/2) ├─┤ H ├┤ Y ├─░─┤ Z ├─░──░──╫──╫──╫─┤M├────────────\n", - " ├───┤ ░ │ │ ┌──┴───┴──┐└──────────┘└───┘ ░ ┌───┐ ░ │ │ └─────────┘ └───┘└───┘ ░ ├───┤ ░ ░ ║ ║ ║ └╥┘┌─┐ \n", - " q_4: ┤ Y ├─░───┼───────■─────┤ Rx(π/4) ├──────────────────░─┤ Z ├─░───┼────■─────────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n", - " ├───┤ ░ │ ┌───┐ └─────────┘ ░ ├───┤ ░ │ ┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ └╥┘┌─┐ \n", - " q_5: ┤ Y ├─░───┼─────┤ X ├────────────────────────────────░─┤ Z ├─░───┼──┤ X ├───────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n", - " ├───┤ ░ │ ├───┤ ┌───┐ ░ ├───┤ ░ │ ├───┤ ┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", - " q_6: ┤ Z ├─░───┼─────┤ H ├──────┤ Z ├─────────────────────░─┤ Z ├─░───┼──┤ H ├───┤ X ├───────────────░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n", - " ├───┤ ░ ┌─┴─┐ └───┘ └───┘ ░ └───┘ ░ ┌─┴─┐└───┘ └───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n", - " q_7: ┤ Y ├─░─┤ X ├────────────────────────────────────────░───────░─┤ X ├────────────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n", - " └───┘ ░ └───┘ ░ ░ └───┘ ░ └───┘ ░ ░ ║ ║ ║ ║ ║ ║ ║ └╥┘\n", - "meas: 8/══════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n", - " 0 1 2 3 4 5 6 7 " + "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": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -236,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "c8f2da90", "metadata": {}, "outputs": [ @@ -244,55 +245,57 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pairs: [(5, 7), (0, 4)]\n" + "Pairs: [(2, 6)]\n" ] }, { "data": { "text/html": [ - "
        ┌───┐ ░      ┌─────────┐           ░ ┌───┐ ░                                        ░       ░                                  ░       ░                             ░ ┌───┐ ░  ░ ┌─┐                     \n",
-       "   q_0: ┤ Z ├─░───■──┤ Rx(π/4) ├───────────░─┤ Z ├─░───■────────────────────────────────────░───────░───■──────────────────────────────░───────░───■─────────────────────────░─┤ Y ├─░──░─┤M├─────────────────────\n",
-       "        ├───┤ ░   │  └──┬───┬──┘┌───┐      ░ ├───┤ ░   │  ┌─────────┐┌───┐   ┌───┐          ░ ┌───┐ ░   │  ┌───┐┌──────────┐┌───┐      ░ ┌───┐ ░   │  ┌───┐   ┌───┐          ░ └───┘ ░  ░ └╥┘┌─┐                  \n",
-       "   q_1: ┤ Y ├─░───┼─────┤ H ├───┤ Z ├──────░─┤ Z ├─░───┼──┤ Rx(π/2) ├┤ H ├───┤ X ├──────────░─┤ X ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├──────░─┤ Y ├─░───┼──┤ H ├───┤ X ├──────────░───────░──░──╫─┤M├──────────────────\n",
-       "        └───┘ ░   │  ┌──┴───┴──┐├───┤┌───┐ ░ ├───┤ ░   │  └──┬───┬──┘└───┘   └───┘          ░ ├───┤ ░   │  ├───┤└──────────┘└───┘      ░ └───┘ ░   │  ├───┤┌──┴───┴───┐┌───┐ ░ ┌───┐ ░  ░  ║ └╥┘┌─┐               \n",
-       "   q_2: ──────░───┼──┤ Rx(π/2) ├┤ H ├┤ Z ├─░─┤ Z ├─░───┼─────┤ X ├──────────────────────────░─┤ Y ├─░───┼──┤ X ├───────────────────────░───────░───┼──┤ H ├┤ Rx(-π/2) ├┤ X ├─░─┤ X ├─░──░──╫──╫─┤M├───────────────\n",
-       "        ┌───┐ ░   │  └──┬───┬──┘└───┘└───┘ ░ └───┘ ░   │     └─┬─┘   ┌───┐┌──────────┐┌───┐ ░ └───┘ ░   │  └─┬─┘┌─────────┐ ┌───┐┌───┐ ░       ░   │  ├───┤└──────────┘└───┘ ░ ├───┤ ░  ░  ║  ║ └╥┘┌─┐            \n",
-       "   q_3: ┤ Y ├─░───┼─────┤ H ├──────────────░───────░───┼───────┼─────┤ H ├┤ Rx(-π/2) ├┤ Z ├─░───────░───┼────┼──┤ Rx(π/2) ├─┤ H ├┤ Y ├─░───────░───┼──┤ H ├──────────────────░─┤ Z ├─░──░──╫──╫──╫─┤M├────────────\n",
-       "        ├───┤ ░ ┌─┴─┐   └───┘              ░ ┌───┐ ░   │       │     └───┘└──────────┘└───┘ ░       ░   │    │  └─────────┘ └───┘└───┘ ░ ┌───┐ ░ ┌─┴─┐└───┘                  ░ ├───┤ ░  ░  ║  ║  ║ └╥┘┌─┐         \n",
-       "   q_4: ┤ Y ├─░─┤ X ├──────────────────────░─┤ X ├─░───┼───────■────────────────────────────░───────░───┼────■─────────────────────────░─┤ Z ├─░─┤ X ├───────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n",
-       "        ├───┤ ░ └───┘┌─────────┐           ░ ├───┤ ░   │     ┌───┐                          ░ ┌───┐ ░   │  ┌───┐                       ░ ├───┤ ░ └───┘                       ░ ├───┤ ░  ░  ║  ║  ║  ║ └╥┘┌─┐      \n",
-       "   q_5: ┤ Y ├─░───■──┤ Rx(π/4) ├───────────░─┤ Y ├─░───┼─────┤ X ├──────────────────────────░─┤ X ├─░───┼──┤ X ├───────────────────────░─┤ Z ├─░───■─────────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n",
-       "        ├───┤ ░   │  ├─────────┤┌───┐┌───┐ ░ ├───┤ ░   │     ├───┤   ┌───┐                  ░ └───┘ ░   │  ├───┤   ┌───┐               ░ ├───┤ ░   │  ┌───┐┌──────────┐┌───┐ ░ ├───┤ ░  ░  ║  ║  ║  ║  ║ └╥┘┌─┐   \n",
-       "   q_6: ┤ Z ├─░───┼──┤ Rx(π/2) ├┤ H ├┤ X ├─░─┤ X ├─░───┼─────┤ H ├───┤ Z ├──────────────────░───────░───┼──┤ H ├───┤ X ├───────────────░─┤ Z ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├─░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n",
-       "        ├───┤ ░ ┌─┴─┐└─────────┘└───┘└───┘ ░ ├───┤ ░ ┌─┴─┐   └───┘   └───┘                  ░ ┌───┐ ░ ┌─┴─┐└───┘   └───┘               ░ └───┘ ░ ┌─┴─┐└───┘└──────────┘└───┘ ░ ├───┤ ░  ░  ║  ║  ║  ║  ║  ║ └╥┘┌─┐\n",
-       "   q_7: ┤ Y ├─░─┤ X ├──────────────────────░─┤ Y ├─░─┤ X ├──────────────────────────────────░─┤ Y ├─░─┤ X ├────────────────────────────░───────░─┤ X ├───────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
-       "        └───┘ ░ └───┘                      ░ └───┘ ░ └───┘                                  ░ └───┘ ░ └───┘                            ░       ░ └───┘                       ░ └───┘ ░  ░  ║  ║  ║  ║  ║  ║  ║ └╥┘\n",
-       "meas: 8/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n",
-       "                                                                                                                                                                                           0  1  2  3  4  5  6  7
" + "
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": [ - " ┌───┐ ░ ┌─────────┐ ░ ┌───┐ ░ ░ ░ ░ ░ ░ ┌───┐ ░ ░ ┌─┐ \n", - " q_0: ┤ Z ├─░───■──┤ Rx(π/4) ├───────────░─┤ Z ├─░───■────────────────────────────────────░───────░───■──────────────────────────────░───────░───■─────────────────────────░─┤ Y ├─░──░─┤M├─────────────────────\n", - " ├───┤ ░ │ └──┬───┬──┘┌───┐ ░ ├───┤ ░ │ ┌─────────┐┌───┐ ┌───┐ ░ ┌───┐ ░ │ ┌───┐┌──────────┐┌───┐ ░ ┌───┐ ░ │ ┌───┐ ┌───┐ ░ └───┘ ░ ░ └╥┘┌─┐ \n", - " q_1: ┤ Y ├─░───┼─────┤ H ├───┤ Z ├──────░─┤ Z ├─░───┼──┤ Rx(π/2) ├┤ H ├───┤ X ├──────────░─┤ X ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├──────░─┤ Y ├─░───┼──┤ H ├───┤ X ├──────────░───────░──░──╫─┤M├──────────────────\n", - " └───┘ ░ │ ┌──┴───┴──┐├───┤┌───┐ ░ ├───┤ ░ │ └──┬───┬──┘└───┘ └───┘ ░ ├───┤ ░ │ ├───┤└──────────┘└───┘ ░ └───┘ ░ │ ├───┤┌──┴───┴───┐┌───┐ ░ ┌───┐ ░ ░ ║ └╥┘┌─┐ \n", - " q_2: ──────░───┼──┤ Rx(π/2) ├┤ H ├┤ Z ├─░─┤ Z ├─░───┼─────┤ X ├──────────────────────────░─┤ Y ├─░───┼──┤ X ├───────────────────────░───────░───┼──┤ H ├┤ Rx(-π/2) ├┤ X ├─░─┤ X ├─░──░──╫──╫─┤M├───────────────\n", - " ┌───┐ ░ │ └──┬───┬──┘└───┘└───┘ ░ └───┘ ░ │ └─┬─┘ ┌───┐┌──────────┐┌───┐ ░ └───┘ ░ │ └─┬─┘┌─────────┐ ┌───┐┌───┐ ░ ░ │ ├───┤└──────────┘└───┘ ░ ├───┤ ░ ░ ║ ║ └╥┘┌─┐ \n", - " q_3: ┤ Y ├─░───┼─────┤ H ├──────────────░───────░───┼───────┼─────┤ H ├┤ Rx(-π/2) ├┤ Z ├─░───────░───┼────┼──┤ Rx(π/2) ├─┤ H ├┤ Y ├─░───────░───┼──┤ H ├──────────────────░─┤ Z ├─░──░──╫──╫──╫─┤M├────────────\n", - " ├───┤ ░ ┌─┴─┐ └───┘ ░ ┌───┐ ░ │ │ └───┘└──────────┘└───┘ ░ ░ │ │ └─────────┘ └───┘└───┘ ░ ┌───┐ ░ ┌─┴─┐└───┘ ░ ├───┤ ░ ░ ║ ║ ║ └╥┘┌─┐ \n", - " q_4: ┤ Y ├─░─┤ X ├──────────────────────░─┤ X ├─░───┼───────■────────────────────────────░───────░───┼────■─────────────────────────░─┤ Z ├─░─┤ X ├───────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫─┤M├─────────\n", - " ├───┤ ░ └───┘┌─────────┐ ░ ├───┤ ░ │ ┌───┐ ░ ┌───┐ ░ │ ┌───┐ ░ ├───┤ ░ └───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ └╥┘┌─┐ \n", - " q_5: ┤ Y ├─░───■──┤ Rx(π/4) ├───────────░─┤ Y ├─░───┼─────┤ X ├──────────────────────────░─┤ X ├─░───┼──┤ X ├───────────────────────░─┤ Z ├─░───■─────────────────────────░─┤ Z ├─░──░──╫──╫──╫──╫──╫─┤M├──────\n", - " ├───┤ ░ │ ├─────────┤┌───┐┌───┐ ░ ├───┤ ░ │ ├───┤ ┌───┐ ░ └───┘ ░ │ ├───┤ ┌───┐ ░ ├───┤ ░ │ ┌───┐┌──────────┐┌───┐ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", - " q_6: ┤ Z ├─░───┼──┤ Rx(π/2) ├┤ H ├┤ X ├─░─┤ X ├─░───┼─────┤ H ├───┤ Z ├──────────────────░───────░───┼──┤ H ├───┤ X ├───────────────░─┤ Z ├─░───┼──┤ H ├┤ Rx(-π/2) ├┤ Y ├─░─┤ Y ├─░──░──╫──╫──╫──╫──╫──╫─┤M├───\n", - " ├───┤ ░ ┌─┴─┐└─────────┘└───┘└───┘ ░ ├───┤ ░ ┌─┴─┐ └───┘ └───┘ ░ ┌───┐ ░ ┌─┴─┐└───┘ └───┘ ░ └───┘ ░ ┌─┴─┐└───┘└──────────┘└───┘ ░ ├───┤ ░ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n", - " q_7: ┤ Y ├─░─┤ X ├──────────────────────░─┤ Y ├─░─┤ X ├──────────────────────────────────░─┤ Y ├─░─┤ X ├────────────────────────────░───────░─┤ X ├───────────────────────░─┤ X ├─░──░──╫──╫──╫──╫──╫──╫──╫─┤M├\n", - " └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ └───┘ ░ ░ └───┘ ░ └───┘ ░ ░ ║ ║ ║ ║ ║ ║ ║ └╥┘\n", - "meas: 8/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩═\n", - " 0 1 2 3 4 5 6 7 " + "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": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -312,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "2f8f9c6c", "metadata": {}, "outputs": [], @@ -334,18 +337,18 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "0d7e760a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -364,7 +367,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "00350a9d", "metadata": {}, "outputs": [], @@ -382,7 +385,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "4a0023f0", "metadata": {}, "outputs": [], @@ -407,7 +410,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -416,7 +419,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -464,11 +467,23 @@ "id": "e14daef6", "metadata": {}, "source": [] + }, + { + "cell_type": "markdown", + "id": "0163479e", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "id": "e8249942", + "metadata": {}, + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": ".venv", "language": "python", "name": "python3" }, diff --git a/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py b/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py index 28c9dbc..bd2ef9a 100644 --- a/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py +++ b/qiskit_device_benchmarking/bench_code/mrb/mirror_qa.py @@ -128,7 +128,6 @@ def __init__( pauli_randomize=pauli_randomize, sampling_algorithm=sampling_algorithm, two_qubit_gate_density=two_qubit_gate_density, - two_qubit_gate=CXGate(), num_samples=num_samples, sampler_opts=sampler_opts, seed=seed, @@ -217,12 +216,11 @@ def __init__( super().__init__( num_qubits = num_qubits, target_bs = target_bs, - pairs = pairs, - singles = singles, 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": diff --git a/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py b/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py index 4f78556..666b1e5 100644 --- a/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py +++ b/qiskit_device_benchmarking/bench_code/mrb/mirror_rb_experiment.py @@ -431,6 +431,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: