def test_insert_dd_ghz_everywhere(self): """Test DD gates even on initial idle spots. ┌───┐ ┌────────────────┐┌───┐┌────────────────┐┌───┐» q_0: ──────┤ H ├─────────■──┤ Delay(100[dt]) ├┤ Y ├┤ Delay(200[dt]) ├┤ Y ├» ┌─────┴───┴─────┐ ┌─┴─┐└────────────────┘└───┘└────────────────┘└───┘» q_1: ┤ Delay(50[dt]) ├─┤ X ├───────────────────────────────────────────■──» ├───────────────┴┐├───┤┌────────────────┐┌───┐┌────────────────┐┌─┴─┐» q_2: ┤ Delay(162[dt]) ├┤ Y ├┤ Delay(326[dt]) ├┤ Y ├┤ Delay(162[dt]) ├┤ X ├» ├────────────────┤├───┤├────────────────┤├───┤├────────────────┤└───┘» q_3: ┤ Delay(212[dt]) ├┤ Y ├┤ Delay(426[dt]) ├┤ Y ├┤ Delay(212[dt]) ├─────» └────────────────┘└───┘└────────────────┘└───┘└────────────────┘ » « ┌────────────────┐ «q_0: ┤ Delay(100[dt]) ├───────────────────────────────────────────── « ├───────────────┬┘┌───┐┌────────────────┐┌───┐┌───────────────┐ «q_1: ┤ Delay(50[dt]) ├─┤ Y ├┤ Delay(100[dt]) ├┤ Y ├┤ Delay(50[dt]) ├ « └───────────────┘ └───┘└────────────────┘└───┘└───────────────┘ «q_2: ────────■────────────────────────────────────────────────────── « ┌─┴─┐ «q_3: ──────┤ X ├──────────────────────────────────────────────────── « └───┘ """ dd_sequence = [YGate(), YGate()] pm = PassManager([ ALAPScheduleAnalysis(self.durations), PadDynamicalDecoupling(self.durations, dd_sequence, skip_reset_qubits=False), ]) ghz4_dd = pm.run(self.ghz4) expected = self.ghz4.copy() expected = expected.compose(Delay(50), [1], front=True) expected = expected.compose(Delay(162), [2], front=True) expected = expected.compose(YGate(), [2], front=True) expected = expected.compose(Delay(326), [2], front=True) expected = expected.compose(YGate(), [2], front=True) expected = expected.compose(Delay(162), [2], front=True) expected = expected.compose(Delay(212), [3], front=True) expected = expected.compose(YGate(), [3], front=True) expected = expected.compose(Delay(426), [3], front=True) expected = expected.compose(YGate(), [3], front=True) expected = expected.compose(Delay(212), [3], front=True) expected = expected.compose(Delay(100), [0]) expected = expected.compose(YGate(), [0]) expected = expected.compose(Delay(200), [0]) expected = expected.compose(YGate(), [0]) expected = expected.compose(Delay(100), [0]) expected = expected.compose(Delay(50), [1]) expected = expected.compose(YGate(), [1]) expected = expected.compose(Delay(100), [1]) expected = expected.compose(YGate(), [1]) expected = expected.compose(Delay(50), [1]) self.assertEqual(ghz4_dd, expected)
def to_circuit(self) -> QuantumCircuit: pauli = self.primitive.to_label()[-self.num_qubits:] phase = self.primitive.phase qc = QuantumCircuit(self.num_qubits) if pauli == "I" * self.num_qubits: qc.global_phase = -phase * pi / 2 return qc if self.num_qubits == 1: gate = { "I": IGate(), "X": XGate(), "Y": YGate(), "Z": ZGate() }[pauli] else: gate = PauliGate(pauli) qc.append(gate, range(self.num_qubits)) if not phase: return qc qc.global_phase = -phase * pi / 2 return qc
def test_insert_dd_bad_sequence(self): """Test DD raises when non-identity sequence is inserted.""" dd_sequence = [XGate(), YGate()] pm = PassManager([ ALAPScheduleAnalysis(self.durations), PadDynamicalDecoupling(self.durations, dd_sequence), ]) with self.assertRaises(TranspilerError): pm.run(self.ghz4)
def test_from_label(self): """Test from_label method""" label = 'IXYZHS' CI = Clifford(IGate()) CX = Clifford(XGate()) CY = Clifford(YGate()) CZ = Clifford(ZGate()) CH = Clifford(HGate()) CS = Clifford(SGate()) target = CI.tensor(CX).tensor(CY).tensor(CZ).tensor(CH).tensor(CS) self.assertEqual(Clifford.from_label(label), target)
def generate_entangled(self): left_circuit = QuantumCircuit(self.width, name="q") left_dag = circuit_to_dag(left_circuit) right_circuit = QuantumCircuit(self.width, name="q") right_dag = circuit_to_dag(right_circuit) qubit_targets = {qubit: set() for qubit in range(self.width)} while True: """ Apply a random two-qubit gate to either left_dag or right_dag """ random_control_qubit_idx = self.get_random_control(qubit_targets) random_target_qubit_idx = self.get_random_target( random_control_qubit_idx, qubit_targets) dag_to_apply = random.choice([left_dag, right_dag]) random_control_qubit = dag_to_apply.qubits[ random_control_qubit_idx] random_target_qubit = dag_to_apply.qubits[random_target_qubit_idx] dag_to_apply.apply_operation_back( op=CPhaseGate(theta=0.0), qargs=[random_control_qubit, random_target_qubit], cargs=[], ) qubit_targets[random_control_qubit_idx].add( random_target_qubit_idx) """ Apply a random 1-q gate to left_dag Apply its inverse to right_dag """ single_qubit_gate = random.choice( [HGate(), TGate(), XGate(), YGate(), ZGate()]) random_qubit = left_dag.qubits[random.choice(range(self.width))] left_dag.apply_operation_back(op=single_qubit_gate, qargs=[random_qubit], cargs=[]) right_dag.apply_operation_front(op=single_qubit_gate.inverse(), qargs=[random_qubit], cargs=[]) """ Terminate when there is enough depth """ if left_dag.depth() + right_dag.depth() >= self.depth: break entangled_dag = left_dag.compose(right_dag, inplace=False) entangled_circuit = dag_to_circuit(entangled_dag) num_targets = [ len(qubit_targets[qubit]) for qubit in range(self.width) ] for qubit in range(self.width): assert num_targets[qubit] <= self.num_targets_ubs[qubit] return entangled_circuit, num_targets
class TestParameterCtrlState(QiskitTestCase): """Test gate equality with ctrl_state parameter.""" @data((RXGate(0.5), CRXGate(0.5)), (RYGate(0.5), CRYGate(0.5)), (RZGate(0.5), CRZGate(0.5)), (XGate(), CXGate()), (YGate(), CYGate()), (ZGate(), CZGate()), (U1Gate(0.5), CU1Gate(0.5)), (SwapGate(), CSwapGate()), (HGate(), CHGate()), (U3Gate(0.1, 0.2, 0.3), CU3Gate(0.1, 0.2, 0.3))) @unpack def test_ctrl_state_one(self, gate, controlled_gate): """Test controlled gates with ctrl_state See https://github.com/Qiskit/qiskit-terra/pull/4025 """ self.assertEqual(gate.control(1, ctrl_state='1'), controlled_gate)
def test_dd_can_sequentially_called(self): """Test if sequentially called DD pass can output the same circuit. This test verifies: - if global phase is properly propagated from the previous padding node. - if node_start_time property is properly updated for new dag circuit. """ dd_sequence = [XGate(), YGate(), XGate(), YGate()] pm1 = PassManager([ ALAPScheduleAnalysis(self.durations), PadDynamicalDecoupling(self.durations, dd_sequence, qubits=[0]), PadDynamicalDecoupling(self.durations, dd_sequence, qubits=[1]), ]) circ1 = pm1.run(self.ghz4) pm2 = PassManager([ ALAPScheduleAnalysis(self.durations), PadDynamicalDecoupling(self.durations, dd_sequence, qubits=[0, 1]), ]) circ2 = pm2.run(self.ghz4) self.assertEqual(circ1, circ2)
class TestPauliConversions(QiskitTestCase): """Test representation conversions of Pauli""" @data(*pauli_group_labels(1), *pauli_group_labels(2)) def test_labels(self, label): """Test round trip label conversion""" pauli = Pauli(label) self.assertEqual(Pauli(str(pauli)), pauli) @data("S", "XX-") def test_invalid_labels(self, label): """Test raise if invalid labels are supplied""" with self.assertRaises(QiskitError): Pauli(label) @data(*pauli_group_labels(1), *pauli_group_labels(2)) def test_to_operator(self, label): """Test Pauli operator conversion""" value = Operator(Pauli(label)) target = operator_from_label(label) self.assertEqual(value, target) @data(*pauli_group_labels(1), *pauli_group_labels(2)) def test_to_matrix_sparse(self, label): """Test Pauli operator conversion""" spmat = Pauli(label).to_matrix(sparse=True) value = Operator(spmat.todense()) target = operator_from_label(label) self.assertEqual(value, target) @data(*pauli_group_labels(1), *pauli_group_labels(2)) def test_to_instruction(self, label): """Test Pauli to instruction""" pauli = Pauli(label) value = Operator(pauli.to_instruction()) target = Operator(pauli) self.assertEqual(value, target) @data((IGate(), "I"), (XGate(), "X"), (YGate(), "Y"), (ZGate(), "Z")) @unpack def test_init_single_pauli_gate(self, gate, label): """Test initialization from Pauli basis gates""" self.assertEqual(str(Pauli(gate)), label) @data("IXYZ", "XXY", "ZYX", "ZI", "Y") def test_init_pauli_gate(self, label): """Test initialization from Pauli basis gates""" pauli = Pauli(PauliGate(label)) self.assertEqual(str(pauli), label)
def test_open_controlled_equality(self): """ Test open controlled gates are equal if their base gates and control states are equal. """ self.assertEqual(XGate().control(1), XGate().control(1)) self.assertNotEqual(XGate().control(1), YGate().control(1)) self.assertNotEqual(XGate().control(1), XGate().control(2)) self.assertEqual(XGate().control(1, ctrl_state='0'), XGate().control(1, ctrl_state='0')) self.assertNotEqual(XGate().control(1, ctrl_state='0'), XGate().control(1, ctrl_state='1'))
def test_asymmetric_xy4_in_t2(self): """Test insertion of XY4 sequence with unbalanced spacing. global phase: π ┌───┐┌───┐┌────────────────┐┌───┐┌────────────────┐┌───┐┌────────────────┐» q_0: ┤ H ├┤ X ├┤ Delay(450[dt]) ├┤ Y ├┤ Delay(450[dt]) ├┤ X ├┤ Delay(450[dt]) ├» └───┘└───┘└────────────────┘└───┘└────────────────┘└───┘└────────────────┘» « ┌───┐┌────────────────┐┌───┐ «q_0: ┤ Y ├┤ Delay(450[dt]) ├┤ H ├ « └───┘└────────────────┘└───┘ """ dd_sequence = [XGate(), YGate()] * 2 spacing = [0] + [1 / 4] * 4 pm = PassManager([ ALAPScheduleAnalysis(self.durations), PadDynamicalDecoupling(self.durations, dd_sequence, spacing=spacing), ]) t2 = QuantumCircuit(1) t2.h(0) t2.delay(2000, 0) t2.h(0) expected = QuantumCircuit(1) expected.h(0) expected.x(0) expected.delay(450, 0) expected.y(0) expected.delay(450, 0) expected.x(0) expected.delay(450, 0) expected.y(0) expected.delay(450, 0) expected.h(0) expected.global_phase = pi t2_dd = pm.run(t2) self.assertEqual(t2_dd, expected) # check global phase is correct self.assertEqual(Operator(t2), Operator(expected))
class TestPauliConversions(QiskitTestCase): """Test representation conversions of Pauli""" @data(*pauli_group_labels(1), *pauli_group_labels(2)) def test_labels(self, label): """Test round trip label conversion""" pauli = Pauli(label) self.assertEqual(Pauli(str(pauli)), pauli) @data(*pauli_group_labels(1), *pauli_group_labels(2)) def test_to_operator(self, label): """Test Pauli operator conversion""" value = Operator(Pauli(label)) target = operator_from_label(label) self.assertEqual(value, target) @data(*pauli_group_labels(1), *pauli_group_labels(2)) def test_to_matrix_sparse(self, label): """Test Pauli operator conversion""" spmat = Pauli(label).to_matrix(sparse=True) value = Operator(spmat.todense()) target = operator_from_label(label) self.assertEqual(value, target) @data(*pauli_group_labels(1), *pauli_group_labels(2)) def test_to_instruction(self, label): """Test Pauli to instruction""" pauli = Pauli(label) value = Operator(pauli.to_instruction()) target = Operator(pauli) self.assertEqual(value, target) @data((IGate(), 'I'), (XGate(), 'X'), (YGate(), 'Y'), (ZGate(), 'Z')) @unpack def test_init_single_pauli_gate(self, gate, label): """Test initialization from Pauli basis gates""" self.assertEqual(str(Pauli(gate)), label) @data('IXYZ', 'XXY', 'ZYX', 'ZI', 'Y') def test_init_pauli_gate(self, label): """Test initialization from Pauli basis gates""" pauli = Pauli(PauliGate(label)) self.assertEqual(str(pauli), label)
def random_clifford_circuit(num_qubits, num_gates, gates='all', seed=None): """Generate a pseudo random Clifford circuit.""" if gates == 'all': if num_qubits == 1: gates = ['i', 'x', 'y', 'z', 'h', 's', 'sdg', 'v', 'w'] else: gates = [ 'i', 'x', 'y', 'z', 'h', 's', 'sdg', 'v', 'w', 'cx', 'cz', 'swap' ] instructions = { 'i': (IGate(), 1), 'x': (XGate(), 1), 'y': (YGate(), 1), 'z': (ZGate(), 1), 'h': (HGate(), 1), 's': (SGate(), 1), 'sdg': (SdgGate(), 1), 'v': (VGate(), 1), 'w': (WGate(), 1), 'cx': (CXGate(), 2), 'cz': (CZGate(), 2), 'swap': (SwapGate(), 2) } if isinstance(seed, np.random.Generator): rng = seed else: rng = np.random.default_rng(seed) samples = rng.choice(gates, num_gates) circ = QuantumCircuit(num_qubits) for name in samples: gate, nqargs = instructions[name] qargs = rng.choice(range(num_qubits), nqargs, replace=False).tolist() circ.append(gate, qargs) return circ
def random_clifford_circuit(num_qubits, num_gates, gates="all", seed=None): """Generate a pseudo random Clifford circuit.""" if gates == "all": if num_qubits == 1: gates = ["i", "x", "y", "z", "h", "s", "sdg", "v", "w"] else: gates = [ "i", "x", "y", "z", "h", "s", "sdg", "v", "w", "cx", "cz", "swap" ] instructions = { "i": (IGate(), 1), "x": (XGate(), 1), "y": (YGate(), 1), "z": (ZGate(), 1), "h": (HGate(), 1), "s": (SGate(), 1), "sdg": (SdgGate(), 1), "v": (VGate(), 1), "w": (WGate(), 1), "cx": (CXGate(), 2), "cz": (CZGate(), 2), "swap": (SwapGate(), 2), } if isinstance(seed, np.random.Generator): rng = seed else: rng = np.random.default_rng(seed) samples = rng.choice(gates, num_gates) circ = QuantumCircuit(num_qubits) for name in samples: gate, nqargs = instructions[name] qargs = rng.choice(range(num_qubits), nqargs, replace=False).tolist() circ.append(gate, qargs) return circ
from typing import Dict, List, Optional, Set, Union, cast import numpy as np from scipy.sparse import spmatrix from qiskit import QuantumCircuit from qiskit.circuit import Instruction, ParameterExpression from qiskit.circuit.library import IGate, RXGate, RYGate, RZGate, XGate, YGate, ZGate from qiskit.opflow.exceptions import OpflowError from qiskit.opflow.list_ops.summed_op import SummedOp from qiskit.opflow.list_ops.tensored_op import TensoredOp from qiskit.opflow.operator_base import OperatorBase from qiskit.opflow.primitive_ops.primitive_op import PrimitiveOp from qiskit.quantum_info import Pauli, SparsePauliOp, Statevector PAULI_GATE_MAPPING = {"X": XGate(), "Y": YGate(), "Z": ZGate(), "I": IGate()} class PauliOp(PrimitiveOp): """Class for Operators backed by Terra's ``Pauli`` module.""" primitive: Pauli def __init__(self, primitive: Pauli, coeff: Union[complex, ParameterExpression] = 1.0) -> None: """ Args: primitive: The Pauli which defines the behavior of the underlying function. coeff: A coefficient multiplying the primitive.
from scipy.sparse import spmatrix from qiskit import QuantumCircuit from qiskit.circuit import ParameterExpression, Instruction from qiskit.quantum_info import Pauli from qiskit.circuit.library import RZGate, RYGate, RXGate, XGate, YGate, ZGate, IGate from ..operator_base import OperatorBase from .primitive_op import PrimitiveOp from ..list_ops.summed_op import SummedOp from ..list_ops.composed_op import ComposedOp from ..list_ops.tensored_op import TensoredOp from ..legacy.weighted_pauli_operator import WeightedPauliOperator logger = logging.getLogger(__name__) PAULI_GATE_MAPPING = {'X': XGate(), 'Y': YGate(), 'Z': ZGate(), 'I': IGate()} class PauliOp(PrimitiveOp): """ Class for Operators backed by Terra's ``Pauli`` module. """ def __init__(self, primitive: Union[Pauli] = None, coeff: Union[int, float, complex, ParameterExpression] = 1.0) -> None: """ Args: primitive: The Pauli which defines the behavior of the underlying function. coeff: A coefficient multiplying the primitive.
class TestRBUtilities(QiskitExperimentsTestCase): """ A test class for additional functionality provided by the StandardRB class. """ instructions = { "i": IGate(), "x": XGate(), "y": YGate(), "z": ZGate(), "h": HGate(), "s": SGate(), "sdg": SdgGate(), "cx": CXGate(), "cz": CZGate(), "swap": SwapGate(), } seed = 42 @data( [1, {((0,), "x"): 3, ((0,), "y"): 2, ((0,), "h"): 1}], [5, {((1,), "x"): 3, ((4,), "y"): 2, ((1,), "h"): 1, ((1, 4), "cx"): 7}], ) @unpack def test_count_ops(self, num_qubits, expected_counts): """Testing the count_ops utility function this function receives a circuit and counts the number of gates in it, counting gates for different qubits separately""" circuit = QuantumCircuit(num_qubits) gates_to_add = [] for gate, count in expected_counts.items(): gates_to_add += [gate for _ in range(count)] rng = np.random.default_rng(self.seed) rng.shuffle(gates_to_add) for qubits, gate in gates_to_add: circuit.append(self.instructions[gate], qubits) counts = rb.RBUtils.count_ops(circuit) self.assertDictEqual(expected_counts, counts) def test_calculate_1q_epg(self): """Testing the calculation of 1 qubit error per gate The EPG is computed based on the error per clifford determined in the RB experiment, the gate counts, and an estimate about the relations between the errors of different gate types """ epc_1_qubit = FitVal(0.0037, 0) qubits = [0] gate_error_ratio = {((0,), "id"): 1, ((0,), "rz"): 0, ((0,), "sx"): 1, ((0,), "x"): 1} gates_per_clifford = {((0,), "rz"): 10.5, ((0,), "sx"): 8.15, ((0,), "x"): 0.25} epg = rb.RBUtils.calculate_1q_epg(epc_1_qubit, qubits, gate_error_ratio, gates_per_clifford) error_dict = { ((0,), "rz"): FitVal(0, 0), ((0,), "sx"): FitVal(0.0004432101747785104, 0), ((0,), "x"): FitVal(0.0004432101747785104, 0), } for gate in ["x", "sx", "rz"]: expected_epg = error_dict[((0,), gate)] actual_epg = epg[(0,)][gate] self.assertTrue(np.allclose(expected_epg.value, actual_epg.value, atol=0.001)) self.assertTrue(np.allclose(expected_epg.stderr, actual_epg.stderr, atol=0.001)) def test_calculate_2q_epg(self): """Testing the calculation of 2 qubit error per gate The EPG is computed based on the error per clifford determined in the RB experiment, the gate counts, and an estimate about the relations between the errors of different gate types """ epc_2_qubit = FitVal(0.034184849962675984, 0) qubits = [1, 4] gate_error_ratio = { ((1,), "id"): 1, ((4,), "id"): 1, ((1,), "rz"): 0, ((4,), "rz"): 0, ((1,), "sx"): 1, ((4,), "sx"): 1, ((1,), "x"): 1, ((4,), "x"): 1, ((4, 1), "cx"): 1, ((1, 4), "cx"): 1, } gates_per_clifford = { ((1, 4), "barrier"): 1.032967032967033, ((1,), "rz"): 15.932967032967033, ((1,), "sx"): 12.382417582417583, ((4,), "rz"): 18.681946624803768, ((4,), "sx"): 14.522605965463109, ((1, 4), "cx"): 1.0246506515936569, ((4, 1), "cx"): 0.5212064090480678, ((4,), "x"): 0.24237661112857592, ((1,), "measure"): 0.01098901098901099, ((4,), "measure"): 0.01098901098901099, ((1,), "x"): 0.2525918944392083, } epg_1_qubit = [ AnalysisResultData("EPG_rz", 0.0, device_components=[1]), AnalysisResultData("EPG_rz", 0.0, device_components=[4]), AnalysisResultData("EPG_sx", 0.00036207066403884814, device_components=[1]), AnalysisResultData("EPG_sx", 0.0005429962529239195, device_components=[4]), AnalysisResultData("EPG_x", 0.00036207066403884814, device_components=[1]), AnalysisResultData("EPG_x", 0.0005429962529239195, device_components=[4]), ] epg = rb.RBUtils.calculate_2q_epg( epc_2_qubit, qubits, gate_error_ratio, gates_per_clifford, epg_1_qubit ) error_dict = { ((1, 4), "cx"): FitVal(0.012438847900902494, 0), } expected_epg = error_dict[((1, 4), "cx")] actual_epg = epg[(1, 4)]["cx"] self.assertTrue(np.allclose(expected_epg.value, actual_epg.value, atol=0.001)) self.assertTrue(np.allclose(expected_epg.stderr, actual_epg.stderr, atol=0.001)) def test_coherence_limit(self): """Test coherence_limit.""" t1 = 100.0 t2 = 100.0 gate_2_qubits = 0.5 gate_1_qubit = 0.1 twoq_coherence_err = rb.RBUtils.coherence_limit(2, [t1, t1], [t2, t2], gate_2_qubits) oneq_coherence_err = rb.RBUtils.coherence_limit(1, [t1], [t2], gate_1_qubit) self.assertAlmostEqual(oneq_coherence_err, 0.00049975, 6, "Error: 1Q Coherence Limit") self.assertAlmostEqual(twoq_coherence_err, 0.00597, 5, "Error: 2Q Coherence Limit") def test_clifford_1_qubit_generation(self): """Verify 1-qubit clifford indeed generates the correct group""" clifford_dicts = [ {"stabilizer": ["+Z"], "destabilizer": ["+X"]}, {"stabilizer": ["+X"], "destabilizer": ["+Z"]}, {"stabilizer": ["+Y"], "destabilizer": ["+X"]}, {"stabilizer": ["+X"], "destabilizer": ["+Y"]}, {"stabilizer": ["+Z"], "destabilizer": ["+Y"]}, {"stabilizer": ["+Y"], "destabilizer": ["+Z"]}, {"stabilizer": ["-Z"], "destabilizer": ["+X"]}, {"stabilizer": ["+X"], "destabilizer": ["-Z"]}, {"stabilizer": ["-Y"], "destabilizer": ["+X"]}, {"stabilizer": ["+X"], "destabilizer": ["-Y"]}, {"stabilizer": ["-Z"], "destabilizer": ["-Y"]}, {"stabilizer": ["-Y"], "destabilizer": ["-Z"]}, {"stabilizer": ["-Z"], "destabilizer": ["-X"]}, {"stabilizer": ["-X"], "destabilizer": ["-Z"]}, {"stabilizer": ["+Y"], "destabilizer": ["-X"]}, {"stabilizer": ["-X"], "destabilizer": ["+Y"]}, {"stabilizer": ["-Z"], "destabilizer": ["+Y"]}, {"stabilizer": ["+Y"], "destabilizer": ["-Z"]}, {"stabilizer": ["+Z"], "destabilizer": ["-X"]}, {"stabilizer": ["-X"], "destabilizer": ["+Z"]}, {"stabilizer": ["-Y"], "destabilizer": ["-X"]}, {"stabilizer": ["-X"], "destabilizer": ["-Y"]}, {"stabilizer": ["+Z"], "destabilizer": ["-Y"]}, {"stabilizer": ["-Y"], "destabilizer": ["+Z"]}, ] cliffords = [Clifford.from_dict(i) for i in clifford_dicts] utils = rb.CliffordUtils() for n in range(24): clifford = utils.clifford_1_qubit(n) self.assertEqual(clifford, cliffords[n]) def test_clifford_2_qubit_generation(self): """Verify 2-qubit clifford indeed generates the correct group""" utils = rb.CliffordUtils() pauli_free_elements = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 5760, 5761, 5762, 5763, 5764, 5765, 5766, 5767, 5768, 5769, 5770, 5771, 5772, 5773, 5774, 5775, 5776, 5777, 5778, 5779, 5780, 5781, 5782, 5783, 5784, 5785, 5786, 5787, 5788, 5789, 5790, 5791, 5792, 5793, 5794, 5795, 5796, 5797, 5798, 5799, 5800, 5801, 5802, 5803, 5804, 5805, 5806, 5807, 5808, 5809, 5810, 5811, 5812, 5813, 5814, 5815, 5816, 5817, 5818, 5819, 5820, 5821, 5822, 5823, 5824, 5825, 5826, 5827, 5828, 5829, 5830, 5831, 5832, 5833, 5834, 5835, 5836, 5837, 5838, 5839, 5840, 5841, 5842, 5843, 5844, 5845, 5846, 5847, 5848, 5849, 5850, 5851, 5852, 5853, 5854, 5855, 5856, 5857, 5858, 5859, 5860, 5861, 5862, 5863, 5864, 5865, 5866, 5867, 5868, 5869, 5870, 5871, 5872, 5873, 5874, 5875, 5876, 5877, 5878, 5879, 5880, 5881, 5882, 5883, 5884, 5885, 5886, 5887, 5888, 5889, 5890, 5891, 5892, 5893, 5894, 5895, 5896, 5897, 5898, 5899, 5900, 5901, 5902, 5903, 5904, 5905, 5906, 5907, 5908, 5909, 5910, 5911, 5912, 5913, 5914, 5915, 5916, 5917, 5918, 5919, 5920, 5921, 5922, 5923, 5924, 5925, 5926, 5927, 5928, 5929, 5930, 5931, 5932, 5933, 5934, 5935, 5936, 5937, 5938, 5939, 5940, 5941, 5942, 5943, 5944, 5945, 5946, 5947, 5948, 5949, 5950, 5951, 5952, 5953, 5954, 5955, 5956, 5957, 5958, 5959, 5960, 5961, 5962, 5963, 5964, 5965, 5966, 5967, 5968, 5969, 5970, 5971, 5972, 5973, 5974, 5975, 5976, 5977, 5978, 5979, 5980, 5981, 5982, 5983, 5984, 5985, 5986, 5987, 5988, 5989, 5990, 5991, 5992, 5993, 5994, 5995, 5996, 5997, 5998, 5999, 6000, 6001, 6002, 6003, 6004, 6005, 6006, 6007, 6008, 6009, 6010, 6011, 6012, 6013, 6014, 6015, 6016, 6017, 6018, 6019, 6020, 6021, 6022, 6023, 6024, 6025, 6026, 6027, 6028, 6029, 6030, 6031, 6032, 6033, 6034, 6035, 6036, 6037, 6038, 6039, 6040, 6041, 6042, 6043, 6044, 6045, 6046, 6047, 6048, 6049, 6050, 6051, 6052, 6053, 6054, 6055, 6056, 6057, 6058, 6059, 6060, 6061, 6062, 6063, 6064, 6065, 6066, 6067, 6068, 6069, 6070, 6071, 6072, 6073, 6074, 6075, 6076, 6077, 6078, 6079, 6080, 6081, 6082, 6083, 10944, 10945, 10946, 10947, 10948, 10949, 10950, 10951, 10952, 10953, 10954, 10955, 10956, 10957, 10958, 10959, 10960, 10961, 10962, 10963, 10964, 10965, 10966, 10967, 10968, 10969, 10970, 10971, 10972, 10973, 10974, 10975, 10976, 10977, 10978, 10979, ] cliffords = [] for n in pauli_free_elements: clifford = utils.clifford_2_qubit(n) phase = clifford.table.phase for i in range(4): self.assertFalse(phase[i]) for other_clifford in cliffords: self.assertNotEqual(clifford, other_clifford) cliffords.append(clifford) pauli_check_elements_list = [ [0, 36, 72, 108, 144, 180, 216, 252, 288, 324, 360, 396, 432, 468, 504, 540], [ 576, 900, 1224, 1548, 1872, 2196, 2520, 2844, 3168, 3492, 3816, 4140, 4464, 4788, 5112, 5436, ], [ 5760, 6084, 6408, 6732, 7056, 7380, 7704, 8028, 8352, 8676, 9000, 9324, 9648, 9972, 10296, 10620, ], [ 10944, 10980, 11016, 11052, 11088, 11124, 11160, 11196, 11232, 11268, 11304, 11340, 11376, 11412, 11448, 11484, ], ] for pauli_check_elements in pauli_check_elements_list: phases = [] table = None for n in pauli_check_elements: clifford = utils.clifford_2_qubit(n) if table is None: table = clifford.table.array else: self.assertTrue(np.all(table == clifford.table.array)) phase = tuple(clifford.table.phase) for other_phase in phases: self.assertNotEqual(phase, other_phase) phases.append(phase)
def test_insert_dd_ghz_xy4(self): """Test XY4 sequence of DD gates. ┌───┐ ┌───────────────┐ ┌───┐ ┌───────────────┐» q_0: ──────┤ H ├─────────■──┤ Delay(37[dt]) ├──────┤ X ├──────┤ Delay(75[dt]) ├» ┌─────┴───┴─────┐ ┌─┴─┐└───────────────┘┌─────┴───┴─────┐└─────┬───┬─────┘» q_1: ┤ Delay(50[dt]) ├─┤ X ├────────■────────┤ Delay(12[dt]) ├──────┤ X ├──────» ├───────────────┴┐└───┘ ┌─┴─┐ └───────────────┘ └───┘ » q_2: ┤ Delay(750[dt]) ├───────────┤ X ├──────────────■─────────────────────────» ├────────────────┤ └───┘ ┌─┴─┐ » q_3: ┤ Delay(950[dt]) ├────────────────────────────┤ X ├───────────────────────» └────────────────┘ └───┘ » « ┌───┐ ┌───────────────┐ ┌───┐ ┌───────────────┐» «q_0: ──────┤ Y ├──────┤ Delay(76[dt]) ├──────┤ X ├──────┤ Delay(75[dt]) ├» « ┌─────┴───┴─────┐└─────┬───┬─────┘┌─────┴───┴─────┐└─────┬───┬─────┘» «q_1: ┤ Delay(25[dt]) ├──────┤ Y ├──────┤ Delay(26[dt]) ├──────┤ X ├──────» « └───────────────┘ └───┘ └───────────────┘ └───┘ » «q_2: ────────────────────────────────────────────────────────────────────» « » «q_3: ────────────────────────────────────────────────────────────────────» « » « ┌───┐ ┌───────────────┐ «q_0: ──────┤ Y ├──────┤ Delay(37[dt]) ├───────────────── « ┌─────┴───┴─────┐└─────┬───┬─────┘┌───────────────┐ «q_1: ┤ Delay(25[dt]) ├──────┤ Y ├──────┤ Delay(12[dt]) ├ « └───────────────┘ └───┘ └───────────────┘ «q_2: ─────────────────────────────────────────────────── « «q_3: ─────────────────────────────────────────────────── """ dd_sequence = [XGate(), YGate(), XGate(), YGate()] pm = PassManager([ ALAPScheduleAnalysis(self.durations), PadDynamicalDecoupling(self.durations, dd_sequence), ]) ghz4_dd = pm.run(self.ghz4) expected = self.ghz4.copy() expected = expected.compose(Delay(50), [1], front=True) expected = expected.compose(Delay(750), [2], front=True) expected = expected.compose(Delay(950), [3], front=True) expected = expected.compose(Delay(37), [0]) expected = expected.compose(XGate(), [0]) expected = expected.compose(Delay(75), [0]) expected = expected.compose(YGate(), [0]) expected = expected.compose(Delay(76), [0]) expected = expected.compose(XGate(), [0]) expected = expected.compose(Delay(75), [0]) expected = expected.compose(YGate(), [0]) expected = expected.compose(Delay(37), [0]) expected = expected.compose(Delay(12), [1]) expected = expected.compose(XGate(), [1]) expected = expected.compose(Delay(25), [1]) expected = expected.compose(YGate(), [1]) expected = expected.compose(Delay(26), [1]) expected = expected.compose(XGate(), [1]) expected = expected.compose(Delay(25), [1]) expected = expected.compose(YGate(), [1]) expected = expected.compose(Delay(12), [1]) self.assertEqual(ghz4_dd, expected)
from qiskit.circuit.library import HGate, XGate, YGate, ZGate, CXGate, CYGate, CZGate, CHGate from qiskit.circuit.library import SwapGate, IGate, SGate, TGate, TdgGate, SdgGate, RYGate from qiskit import QuantumCircuit, Aer, execute, QuantumRegister, ClassicalRegister import numpy as np SINGLE_GATE_DICT = { 'I' : IGate(), 'H' : HGate(), 'X' : XGate(), 'Y' : YGate(), 'Z' : ZGate(), 'S' : SGate(), 'T' : TGate(), 'T_dg' : TdgGate(), 'S_dg' : SdgGate(), 'Ry' : RYGate(np.pi / 4) } CONTROLLED_GATE_DICT = { 'CX0' : CXGate(), 'CX1' : CXGate(), 'CY0' : CYGate(), 'CY1' : CYGate(), 'CZ0' : CZGate(), 'CZ1' : CYGate(), 'CH0' : CHGate(), 'CH1' : CHGate() } def _state_to_gates(state):
class TestPauli(QiskitTestCase): """Tests for Pauli operator class.""" @data(*pauli_group_labels(2)) def test_conjugate(self, label): """Test conjugate method.""" value = Pauli(label).conjugate() target = operator_from_label(label).conjugate() self.assertEqual(Operator(value), target) @data(*pauli_group_labels(2)) def test_transpose(self, label): """Test transpose method.""" value = Pauli(label).transpose() target = operator_from_label(label).transpose() self.assertEqual(Operator(value), target) @data(*pauli_group_labels(2)) def test_adjoint(self, label): """Test adjoint method.""" value = Pauli(label).adjoint() target = operator_from_label(label).adjoint() self.assertEqual(Operator(value), target) @data(*pauli_group_labels(2)) def test_inverse(self, label): """Test inverse method.""" pauli = Pauli(label) value = pauli.inverse() target = pauli.adjoint() self.assertEqual(value, target) @data(*it.product(pauli_group_labels(2, full_group=False), repeat=2)) @unpack def test_dot(self, label1, label2): """Test dot method.""" p1 = Pauli(label1) p2 = Pauli(label2) value = Operator(p1.dot(p2)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.dot(op2) self.assertEqual(value, target) @data(*pauli_group_labels(1)) def test_dot_qargs(self, label2): """Test dot method with qargs.""" label1 = '-iXYZ' p1 = Pauli(label1) p2 = Pauli(label2) qargs = [0] value = Operator(p1.dot(p2, qargs=qargs)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.dot(op2, qargs=qargs) self.assertEqual(value, target) @data(*it.product(pauli_group_labels(2, full_group=False), repeat=2)) @unpack def test_compose(self, label1, label2): """Test compose method.""" p1 = Pauli(label1) p2 = Pauli(label2) value = Operator(p1.compose(p2)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.compose(op2) self.assertEqual(value, target) @data(*pauli_group_labels(1)) def test_compose_qargs(self, label2): """Test compose method with qargs.""" label1 = '-XYZ' p1 = Pauli(label1) p2 = Pauli(label2) qargs = [0] value = Operator(p1.compose(p2, qargs=qargs)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.compose(op2, qargs=qargs) self.assertEqual(value, target) @data(*it.product(pauli_group_labels(1, full_group=False), repeat=2)) @unpack def test_tensor(self, label1, label2): """Test tensor method.""" p1 = Pauli(label1) p2 = Pauli(label2) value = Operator(p1.tensor(p2)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.tensor(op2) self.assertEqual(value, target) @data(*it.product(pauli_group_labels(1, full_group=False), repeat=2)) @unpack def test_expand(self, label1, label2): """Test expand method.""" p1 = Pauli(label1) p2 = Pauli(label2) value = Operator(p1.expand(p2)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.expand(op2) self.assertEqual(value, target) @data('II', 'XI', 'YX', 'ZZ', 'YZ') def test_power(self, label): """Test power method.""" iden = Pauli('II') op = Pauli(label) self.assertTrue(op**2, iden) @data(1, 1.0, -1, -1.0, 1j, -1j) def test_multiply(self, val): """Test multiply method.""" op = val * Pauli(([True, True], [False, False], 0)) phase = (-1j)**op.phase self.assertEqual(phase, val) def test_multiply_except(self): """Test multiply method raises exceptions.""" op = Pauli('XYZ') self.assertRaises(QiskitError, op._multiply, 2) @data(0, 1, 2, 3) def test_negate(self, phase): """Test negate method""" op = Pauli(([False], [True], phase)) neg = -op self.assertTrue(op.equiv(neg)) self.assertEqual(neg.phase, (op.phase + 2) % 4) @data(*it.product(pauli_group_labels(1, False), repeat=2)) @unpack def test_commutes(self, p1, p2): """Test commutes method""" P1 = Pauli(p1) P2 = Pauli(p2) self.assertEqual(P1.commutes(P2), P1.dot(P2) == P2.dot(P1)) @data(*it.product(pauli_group_labels(1, False), repeat=2)) @unpack def test_anticommutes(self, p1, p2): """Test anticommutes method""" P1 = Pauli(p1) P2 = Pauli(p2) self.assertEqual(P1.anticommutes(P2), P1.dot(P2) == -P2.dot(P1)) @data(*it.product( (IGate(), XGate(), YGate(), ZGate(), HGate(), SGate(), SdgGate()), pauli_group_labels(1, False))) @unpack def test_evolve_clifford1(self, gate, label): """Test evolve method for 1-qubit Clifford gates.""" cliff = Clifford(gate) op = Operator(gate) pauli = Pauli(label) value = Operator(pauli.evolve(cliff)) target = op.adjoint().dot(pauli).dot(op) self.assertEqual(value, target) @data(*it.product((CXGate(), CYGate(), CZGate(), SwapGate()), pauli_group_labels(2, False))) @unpack def test_evolve_clifford2(self, gate, label): """Test evolve method for 2-qubit Clifford gates.""" cliff = Clifford(gate) op = Operator(gate) pauli = Pauli(label) value = Operator(pauli.evolve(cliff)) target = op.adjoint().dot(pauli).dot(op) self.assertEqual(value, target) def test_evolve_clifford_qargs(self): """Test evolve method for random Clifford""" cliff = random_clifford(3, seed=10) op = Operator(cliff) pauli = random_pauli(5, seed=10) qargs = [3, 0, 1] value = Operator(pauli.evolve(cliff, qargs=qargs)) target = Operator(pauli).compose(op.adjoint(), qargs=qargs).dot(op, qargs=qargs) self.assertEqual(value, target)
class TestPauli(QiskitTestCase): """Tests for Pauli operator class.""" @data(*pauli_group_labels(2)) def test_conjugate(self, label): """Test conjugate method.""" value = Pauli(label).conjugate() target = operator_from_label(label).conjugate() self.assertEqual(Operator(value), target) @data(*pauli_group_labels(2)) def test_transpose(self, label): """Test transpose method.""" value = Pauli(label).transpose() target = operator_from_label(label).transpose() self.assertEqual(Operator(value), target) @data(*pauli_group_labels(2)) def test_adjoint(self, label): """Test adjoint method.""" value = Pauli(label).adjoint() target = operator_from_label(label).adjoint() self.assertEqual(Operator(value), target) @data(*pauli_group_labels(2)) def test_inverse(self, label): """Test inverse method.""" pauli = Pauli(label) value = pauli.inverse() target = pauli.adjoint() self.assertEqual(value, target) @data(*it.product(pauli_group_labels(2, full_group=False), repeat=2)) @unpack def test_dot(self, label1, label2): """Test dot method.""" p1 = Pauli(label1) p2 = Pauli(label2) value = Operator(p1.dot(p2)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.dot(op2) self.assertEqual(value, target) @data(*pauli_group_labels(1)) def test_dot_qargs(self, label2): """Test dot method with qargs.""" label1 = "-iXYZ" p1 = Pauli(label1) p2 = Pauli(label2) qargs = [0] value = Operator(p1.dot(p2, qargs=qargs)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.dot(op2, qargs=qargs) self.assertEqual(value, target) @data(*it.product(pauli_group_labels(2, full_group=False), repeat=2)) @unpack def test_compose(self, label1, label2): """Test compose method.""" p1 = Pauli(label1) p2 = Pauli(label2) value = Operator(p1.compose(p2)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.compose(op2) self.assertEqual(value, target) @data(*pauli_group_labels(1)) def test_compose_qargs(self, label2): """Test compose method with qargs.""" label1 = "-XYZ" p1 = Pauli(label1) p2 = Pauli(label2) qargs = [0] value = Operator(p1.compose(p2, qargs=qargs)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.compose(op2, qargs=qargs) self.assertEqual(value, target) @data(*it.product(pauli_group_labels(1, full_group=False), repeat=2)) @unpack def test_tensor(self, label1, label2): """Test tensor method.""" p1 = Pauli(label1) p2 = Pauli(label2) value = Operator(p1.tensor(p2)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.tensor(op2) self.assertEqual(value, target) @data(*it.product(pauli_group_labels(1, full_group=False), repeat=2)) @unpack def test_expand(self, label1, label2): """Test expand method.""" p1 = Pauli(label1) p2 = Pauli(label2) value = Operator(p1.expand(p2)) op1 = operator_from_label(label1) op2 = operator_from_label(label2) target = op1.expand(op2) self.assertEqual(value, target) @data("II", "XI", "YX", "ZZ", "YZ") def test_power(self, label): """Test power method.""" iden = Pauli("II") op = Pauli(label) self.assertTrue(op**2, iden) @data(1, 1.0, -1, -1.0, 1j, -1j) def test_multiply(self, val): """Test multiply method.""" op = val * Pauli(([True, True], [False, False], 0)) phase = (-1j)**op.phase self.assertEqual(phase, val) def test_multiply_except(self): """Test multiply method raises exceptions.""" op = Pauli("XYZ") self.assertRaises(QiskitError, op._multiply, 2) @data(0, 1, 2, 3) def test_negate(self, phase): """Test negate method""" op = Pauli(([False], [True], phase)) neg = -op self.assertTrue(op.equiv(neg)) self.assertEqual(neg.phase, (op.phase + 2) % 4) @data(*it.product(pauli_group_labels(1, False), repeat=2)) @unpack def test_commutes(self, p1, p2): """Test commutes method""" P1 = Pauli(p1) P2 = Pauli(p2) self.assertEqual(P1.commutes(P2), P1.dot(P2) == P2.dot(P1)) @data(*it.product(pauli_group_labels(1, False), repeat=2)) @unpack def test_anticommutes(self, p1, p2): """Test anticommutes method""" P1 = Pauli(p1) P2 = Pauli(p2) self.assertEqual(P1.anticommutes(P2), P1.dot(P2) == -P2.dot(P1)) @data(*it.product( (IGate(), XGate(), YGate(), ZGate(), HGate(), SGate(), SdgGate()), pauli_group_labels(1, False), )) @unpack def test_evolve_clifford1(self, gate, label): """Test evolve method for 1-qubit Clifford gates.""" op = Operator(gate) pauli = Pauli(label) value = Operator(pauli.evolve(gate)) value_h = Operator(pauli.evolve(gate, frame="h")) value_s = Operator(pauli.evolve(gate, frame="s")) value_inv = Operator(pauli.evolve(gate.inverse())) target = op.adjoint().dot(pauli).dot(op) self.assertEqual(value, target) self.assertEqual(value, value_h) self.assertEqual(value_inv, value_s) @data(*it.product((CXGate(), CYGate(), CZGate(), SwapGate()), pauli_group_labels(2, False))) @unpack def test_evolve_clifford2(self, gate, label): """Test evolve method for 2-qubit Clifford gates.""" op = Operator(gate) pauli = Pauli(label) value = Operator(pauli.evolve(gate)) value_h = Operator(pauli.evolve(gate, frame="h")) value_s = Operator(pauli.evolve(gate, frame="s")) value_inv = Operator(pauli.evolve(gate.inverse())) target = op.adjoint().dot(pauli).dot(op) self.assertEqual(value, target) self.assertEqual(value, value_h) self.assertEqual(value_inv, value_s) def test_evolve_clifford_qargs(self): """Test evolve method for random Clifford""" cliff = random_clifford(3, seed=10) op = Operator(cliff) pauli = random_pauli(5, seed=10) qargs = [3, 0, 1] value = Operator(pauli.evolve(cliff, qargs=qargs)) value_h = Operator(pauli.evolve(cliff, qargs=qargs, frame="h")) value_s = Operator(pauli.evolve(cliff, qargs=qargs, frame="s")) value_inv = Operator(pauli.evolve(cliff.adjoint(), qargs=qargs)) target = Operator(pauli).compose(op.adjoint(), qargs=qargs).dot(op, qargs=qargs) self.assertEqual(value, target) self.assertEqual(value, value_h) self.assertEqual(value_inv, value_s) def test_barrier_delay_sim(self): """Test barrier and delay instructions can be simulated""" target_circ = QuantumCircuit(2) target_circ.x(0) target_circ.y(1) target = Pauli(target_circ) circ = QuantumCircuit(2) circ.x(0) circ.delay(100, 0) circ.barrier([0, 1]) circ.y(1) value = Pauli(circ) self.assertEqual(value, target)
def test_controlled_y(self): """Test creation of controlled y gate""" self.assertEqual(YGate().control(), CYGate())
def test_insert_dd_ghz_xy4_with_alignment(self): """Test DD with pulse alignment constraints. ┌───┐ ┌───────────────┐ ┌───┐ ┌───────────────┐» q_0: ──────┤ H ├─────────■──┤ Delay(40[dt]) ├──────┤ X ├──────┤ Delay(70[dt]) ├» ┌─────┴───┴─────┐ ┌─┴─┐└───────────────┘┌─────┴───┴─────┐└─────┬───┬─────┘» q_1: ┤ Delay(50[dt]) ├─┤ X ├────────■────────┤ Delay(20[dt]) ├──────┤ X ├──────» ├───────────────┴┐└───┘ ┌─┴─┐ └───────────────┘ └───┘ » q_2: ┤ Delay(750[dt]) ├───────────┤ X ├──────────────■─────────────────────────» ├────────────────┤ └───┘ ┌─┴─┐ » q_3: ┤ Delay(950[dt]) ├────────────────────────────┤ X ├───────────────────────» └────────────────┘ └───┘ » « ┌───┐ ┌───────────────┐ ┌───┐ ┌───────────────┐» «q_0: ──────┤ Y ├──────┤ Delay(70[dt]) ├──────┤ X ├──────┤ Delay(70[dt]) ├» « ┌─────┴───┴─────┐└─────┬───┬─────┘┌─────┴───┴─────┐└─────┬───┬─────┘» «q_1: ┤ Delay(20[dt]) ├──────┤ Y ├──────┤ Delay(20[dt]) ├──────┤ X ├──────» « └───────────────┘ └───┘ └───────────────┘ └───┘ » «q_2: ────────────────────────────────────────────────────────────────────» « » «q_3: ────────────────────────────────────────────────────────────────────» « » « ┌───┐ ┌───────────────┐ «q_0: ──────┤ Y ├──────┤ Delay(50[dt]) ├───────────────── « ┌─────┴───┴─────┐└─────┬───┬─────┘┌───────────────┐ «q_1: ┤ Delay(20[dt]) ├──────┤ Y ├──────┤ Delay(20[dt]) ├ « └───────────────┘ └───┘ └───────────────┘ «q_2: ─────────────────────────────────────────────────── « «q_3: ─────────────────────────────────────────────────── « """ dd_sequence = [XGate(), YGate(), XGate(), YGate()] pm = PassManager([ ALAPScheduleAnalysis(self.durations), PadDynamicalDecoupling( self.durations, dd_sequence, pulse_alignment=10, extra_slack_distribution="edges", ), ]) ghz4_dd = pm.run(self.ghz4) expected = self.ghz4.copy() expected = expected.compose(Delay(50), [1], front=True) expected = expected.compose(Delay(750), [2], front=True) expected = expected.compose(Delay(950), [3], front=True) expected = expected.compose(Delay(40), [0]) expected = expected.compose(XGate(), [0]) expected = expected.compose(Delay(70), [0]) expected = expected.compose(YGate(), [0]) expected = expected.compose(Delay(70), [0]) expected = expected.compose(XGate(), [0]) expected = expected.compose(Delay(70), [0]) expected = expected.compose(YGate(), [0]) expected = expected.compose(Delay(50), [0]) expected = expected.compose(Delay(20), [1]) expected = expected.compose(XGate(), [1]) expected = expected.compose(Delay(20), [1]) expected = expected.compose(YGate(), [1]) expected = expected.compose(Delay(20), [1]) expected = expected.compose(XGate(), [1]) expected = expected.compose(Delay(20), [1]) expected = expected.compose(YGate(), [1]) expected = expected.compose(Delay(20), [1]) self.assertEqual(ghz4_dd, expected)
def test_local_mbasis_inst(self): """Test custom local measurement basis""" basis = LocalMeasurementBasis("custom_basis", [XGate(), YGate(), HGate()]) self._test_ideal_basis(basis, [0, 1])