def _simplUGates(self, dag): dag_nodes = dag.op_nodes() for node in dag_nodes: if node.op.name == 'u1' and node.op.params[0] == 0: node.op = IGate() for node in dag_nodes: if node.op.name == 'u' and node.op.params[ 0] == 0 and node.op.params[1] == 0 and node.op.params[ 2] == 0.0: #detects Id gates that have been implemented with u node.op = IGate() return dag
def test_instructions(self): self.assertEqual(self.empty_target.instructions, []) ibm_expected = [ (IGate(), (0, )), (IGate(), (1, )), (IGate(), (2, )), (IGate(), (3, )), (IGate(), (4, )), (RZGate(self.theta), (0, )), (RZGate(self.theta), (1, )), (RZGate(self.theta), (2, )), (RZGate(self.theta), (3, )), (RZGate(self.theta), (4, )), (SXGate(), (0, )), (SXGate(), (1, )), (SXGate(), (2, )), (SXGate(), (3, )), (SXGate(), (4, )), (XGate(), (0, )), (XGate(), (1, )), (XGate(), (2, )), (XGate(), (3, )), (XGate(), (4, )), (CXGate(), (3, 4)), (CXGate(), (4, 3)), (CXGate(), (3, 1)), (CXGate(), (1, 3)), (CXGate(), (1, 2)), (CXGate(), (2, 1)), (CXGate(), (0, 1)), (CXGate(), (1, 0)), (Measure(), (0, )), (Measure(), (1, )), (Measure(), (2, )), (Measure(), (3, )), (Measure(), (4, )), ] self.assertEqual(ibm_expected, self.ibm_target.instructions) ideal_sim_expected = [ (UGate(self.theta, self.phi, self.lam), None), (RXGate(self.theta), None), (RYGate(self.theta), None), (RZGate(self.theta), None), (CXGate(), None), (ECRGate(), None), (CCXGate(), None), (Measure(), None), ] self.assertEqual(ideal_sim_expected, self.ideal_sim_target.instructions)
def test_get_instructions_for_qargs(self): with self.assertRaises(KeyError): self.empty_target.operations_for_qargs((0, )) expected = [RZGate(self.theta), IGate(), SXGate(), XGate(), Measure()] res = self.ibm_target.operations_for_qargs((0, )) for gate in expected: self.assertIn(gate, res) expected = [ECRGate()] res = self.fake_backend_target.operations_for_qargs((1, 0)) for gate in expected: self.assertIn(gate, res) expected = [CXGate()] res = self.fake_backend_target.operations_for_qargs((0, 1)) self.assertEqual(expected, res) ideal_sim_expected = [ UGate(self.theta, self.phi, self.lam), RXGate(self.theta), RYGate(self.theta), RZGate(self.theta), CXGate(), ECRGate(), CCXGate(), Measure(), ] for gate in ideal_sim_expected: self.assertIn(gate, self.ideal_sim_target.operations_for_qargs(None))
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_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 make_oneq_cliffords(): """Make as list of 1q Cliffords""" ixyz_list = [g().to_matrix() for g in (IGate, XGate, YGate, ZGate)] ih_list = [g().to_matrix() for g in (IGate, HGate)] irs_list = [IGate().to_matrix(), SdgGate().to_matrix() @ HGate().to_matrix(), HGate().to_matrix() @ SGate().to_matrix()] oneq_cliffords = [Operator(ixyz @ ih @ irs) for ixyz in ixyz_list for ih in ih_list for irs in irs_list] return oneq_cliffords
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_measure_single_qubit(self): """Test a measurement of a single qubit""" for _ in range(self.samples): cliff = Clifford(XGate()) stab = StabilizerState(cliff) value = stab.measure()[0] self.assertEqual(value, "1") cliff = Clifford(IGate()) stab = StabilizerState(cliff) value = stab.measure()[0] self.assertEqual(value, "0") cliff = Clifford(HGate()) stab = StabilizerState(cliff) value = stab.measure()[0] self.assertIn(value, ["0", "1"])
def test_operations(self): self.assertEqual(self.empty_target.operations, []) ibm_expected = [ RZGate(self.theta), IGate(), SXGate(), XGate(), CXGate(), Measure() ] for gate in ibm_expected: self.assertIn(gate, self.ibm_target.operations) aqt_expected = [ RZGate(self.theta), RXGate(self.theta), RYGate(self.theta), RGate(self.theta, self.phi), RXXGate(self.theta), ] for gate in aqt_expected: self.assertIn(gate, self.aqt_target.operations) fake_expected = [ UGate(self.fake_backend._theta, self.fake_backend._phi, self.fake_backend._lam), CXGate(), Measure(), ECRGate(), RXGate(math.pi / 6), RXGate(self.fake_backend._theta), ] for gate in fake_expected: self.assertIn(gate, self.fake_backend_target.operations) ideal_sim_expected = [ UGate(self.theta, self.phi, self.lam), RXGate(self.theta), RYGate(self.theta), RZGate(self.theta), CXGate(), ECRGate(), CCXGate(), Measure(), ] for gate in ideal_sim_expected: self.assertIn(gate, self.ideal_sim_target.operations)
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 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)
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 setUp(self): super().setUp() self.fake_backend = FakeBackendV2() self.fake_backend_target = self.fake_backend.target self.theta = Parameter("theta") self.phi = Parameter("phi") self.ibm_target = Target() i_props = { (0, ): InstructionProperties(duration=35.5e-9, error=0.000413), (1, ): InstructionProperties(duration=35.5e-9, error=0.000502), (2, ): InstructionProperties(duration=35.5e-9, error=0.0004003), (3, ): InstructionProperties(duration=35.5e-9, error=0.000614), (4, ): InstructionProperties(duration=35.5e-9, error=0.006149), } self.ibm_target.add_instruction(IGate(), i_props) rz_props = { (0, ): InstructionProperties(duration=0, error=0), (1, ): InstructionProperties(duration=0, error=0), (2, ): InstructionProperties(duration=0, error=0), (3, ): InstructionProperties(duration=0, error=0), (4, ): InstructionProperties(duration=0, error=0), } self.ibm_target.add_instruction(RZGate(self.theta), rz_props) sx_props = { (0, ): InstructionProperties(duration=35.5e-9, error=0.000413), (1, ): InstructionProperties(duration=35.5e-9, error=0.000502), (2, ): InstructionProperties(duration=35.5e-9, error=0.0004003), (3, ): InstructionProperties(duration=35.5e-9, error=0.000614), (4, ): InstructionProperties(duration=35.5e-9, error=0.006149), } self.ibm_target.add_instruction(SXGate(), sx_props) x_props = { (0, ): InstructionProperties(duration=35.5e-9, error=0.000413), (1, ): InstructionProperties(duration=35.5e-9, error=0.000502), (2, ): InstructionProperties(duration=35.5e-9, error=0.0004003), (3, ): InstructionProperties(duration=35.5e-9, error=0.000614), (4, ): InstructionProperties(duration=35.5e-9, error=0.006149), } self.ibm_target.add_instruction(XGate(), x_props) cx_props = { (3, 4): InstructionProperties(duration=270.22e-9, error=0.00713), (4, 3): InstructionProperties(duration=305.77e-9, error=0.00713), (3, 1): InstructionProperties(duration=462.22e-9, error=0.00929), (1, 3): InstructionProperties(duration=497.77e-9, error=0.00929), (1, 2): InstructionProperties(duration=227.55e-9, error=0.00659), (2, 1): InstructionProperties(duration=263.11e-9, error=0.00659), (0, 1): InstructionProperties(duration=519.11e-9, error=0.01201), (1, 0): InstructionProperties(duration=554.66e-9, error=0.01201), } self.ibm_target.add_instruction(CXGate(), cx_props) measure_props = { (0, ): InstructionProperties(duration=5.813e-6, error=0.0751), (1, ): InstructionProperties(duration=5.813e-6, error=0.0225), (2, ): InstructionProperties(duration=5.813e-6, error=0.0146), (3, ): InstructionProperties(duration=5.813e-6, error=0.0215), (4, ): InstructionProperties(duration=5.813e-6, error=0.0333), } self.ibm_target.add_instruction(Measure(), measure_props) self.aqt_target = Target(description="AQT Target") rx_props = { (0, ): None, (1, ): None, (2, ): None, (3, ): None, (4, ): None, } self.aqt_target.add_instruction(RXGate(self.theta), rx_props) ry_props = { (0, ): None, (1, ): None, (2, ): None, (3, ): None, (4, ): None, } self.aqt_target.add_instruction(RYGate(self.theta), ry_props) rz_props = { (0, ): None, (1, ): None, (2, ): None, (3, ): None, (4, ): None, } self.aqt_target.add_instruction(RZGate(self.theta), rz_props) r_props = { (0, ): None, (1, ): None, (2, ): None, (3, ): None, (4, ): None, } self.aqt_target.add_instruction(RGate(self.theta, self.phi), r_props) rxx_props = { (0, 1): None, (0, 2): None, (0, 3): None, (0, 4): None, (1, 0): None, (2, 0): None, (3, 0): None, (4, 0): None, (1, 2): None, (1, 3): None, (1, 4): None, (2, 1): None, (3, 1): None, (4, 1): None, (2, 3): None, (2, 4): None, (3, 2): None, (4, 2): None, (3, 4): None, (4, 3): None, } self.aqt_target.add_instruction(RXXGate(self.theta), rxx_props) measure_props = { (0, ): None, (1, ): None, (2, ): None, (3, ): None, (4, ): None, } self.aqt_target.add_instruction(Measure(), measure_props) self.empty_target = Target() self.ideal_sim_target = Target(num_qubits=3, description="Ideal Simulator") self.lam = Parameter("lam") for inst in [ UGate(self.theta, self.phi, self.lam), RXGate(self.theta), RYGate(self.theta), RZGate(self.theta), CXGate(), ECRGate(), CCXGate(), Measure(), ]: self.ideal_sim_target.add_instruction(inst, {None: None})
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.
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)
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):