def test_to_matrix(self): """to matrix text """ np.testing.assert_array_equal(X.to_matrix(), Operator.from_label('X').data) np.testing.assert_array_equal(Y.to_matrix(), Operator.from_label('Y').data) np.testing.assert_array_equal(Z.to_matrix(), Operator.from_label('Z').data) op1 = Y + H np.testing.assert_array_almost_equal(op1.to_matrix(), Y.to_matrix() + H.to_matrix()) op2 = op1 * .5 np.testing.assert_array_almost_equal(op2.to_matrix(), op1.to_matrix() * .5) op3 = (4 - .6j) * op2 np.testing.assert_array_almost_equal(op3.to_matrix(), op2.to_matrix() * (4 - .6j)) op4 = op3.tensor(X) np.testing.assert_array_almost_equal( op4.to_matrix(), np.kron(op3.to_matrix(), X.to_matrix())) op5 = op4.compose(H ^ I) np.testing.assert_array_almost_equal( op5.to_matrix(), np.dot(op4.to_matrix(), (H ^ I).to_matrix())) op6 = op5 + PrimitiveOp(Operator.from_label('+r').data) np.testing.assert_array_almost_equal( op6.to_matrix(), op5.to_matrix() + Operator.from_label('+r').data)
def setUp(self): """Set up a basic parameterized simulation.""" self.w = 5.0 self.r = 0.1 operators = [ 2 * np.pi * self.w * Array(Operator.from_label("Z").data) / 2, 2 * np.pi * self.r * Array(Operator.from_label("X").data) / 2, ] ham = HamiltonianModel(operators=operators) self.ham = ham def param_sim(amp, drive_freq): signals = [ Constant(1.0), Signal(lambda t: amp, carrier_freq=drive_freq) ] ham_copy = ham.copy() ham_copy.signals = signals results = solve_lmde( ham_copy, t_span=[0.0, 1 / self.r], y0=Array([0.0, 1.0], dtype=complex), method="jax_odeint", atol=1e-10, rtol=1e-10, ) return results.y[-1] self.param_sim = param_sim
def test_io_consistency(self): """ consistency test """ new_op = X ^ Y ^ I label = 'XYI' # label = new_op.primitive.to_label() self.assertEqual(str(new_op.primitive), label) np.testing.assert_array_almost_equal(new_op.primitive.to_matrix(), Operator.from_label(label).data) self.assertEqual(new_op.primitive, Pauli(label=label)) x_mat = X.primitive.to_matrix() y_mat = Y.primitive.to_matrix() i_mat = np.eye(2, 2) np.testing.assert_array_almost_equal(new_op.primitive.to_matrix(), np.kron(np.kron(x_mat, y_mat), i_mat)) hi = np.kron(H.to_matrix(), I.to_matrix()) hi2 = Operator.from_label('HI').data hi3 = (H ^ I).to_matrix() np.testing.assert_array_almost_equal(hi, hi2) np.testing.assert_array_almost_equal(hi2, hi3) xy = np.kron(X.to_matrix(), Y.to_matrix()) xy2 = Operator.from_label('XY').data xy3 = (X ^ Y).to_matrix() np.testing.assert_array_almost_equal(xy, xy2) np.testing.assert_array_almost_equal(xy2, xy3) # Check if numpy array instantiation is the same as from Operator matrix_op = Operator.from_label('+r') np.testing.assert_array_almost_equal(PrimitiveOp(matrix_op).to_matrix(), PrimitiveOp(matrix_op.data).to_matrix()) # Ditto list of lists np.testing.assert_array_almost_equal(PrimitiveOp(matrix_op.data.tolist()).to_matrix(), PrimitiveOp(matrix_op.data).to_matrix())
def test_composite_sqrt(self): """Test composite Gate.power(1/2) method. """ circ = QuantumCircuit(1, name='my_gate') import numpy as np thetaz = 0.1 thetax = 0.2 circ.rz(thetaz, 0) circ.rx(thetax, 0) gate = circ.to_gate() result = gate.power(1 / 2) iden = Operator.from_label('I') xgen = Operator.from_label('X') zgen = Operator.from_label('Z') def rzgate(theta): return np.cos(0.5 * theta) * iden - 1j * np.sin(0.5 * theta) * zgen def rxgate(theta): return np.cos(0.5 * theta) * iden - 1j * np.sin(0.5 * theta) * xgen rxrz = rxgate(thetax) * rzgate(thetaz) self.assertEqual(result.label, 'my_gate^0.5') self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) self.assertEqual(Operator(result) @ Operator(result), rxrz)
def test_subtract_operator_qargs(self, coeff, qargs): """Test qargs subtract operation with Operator (coeff={coeff}, qargs={qargs})""" # Get labels for qarg addition part_array = np.array(['X', 'Y', 'Z'])[range(len(qargs))] label = ''.join(part_array) full_array = np.array(3 * ['I']) inds = [2 - i for i in reversed(qargs)] full_array[inds] = part_array full_label = ''.join(full_array) dims = 3 * (2, ) val = ScalarOp(dims, coeff=coeff) - Operator.from_label(label)(qargs) target = (coeff * Operator.from_label(3 * 'I')) - Operator.from_label(full_label) self.assertOperator(val, dims, target)
def setUp(self): self.X = Array(Operator.from_label("X").data) self.Y = Array(Operator.from_label("Y").data) self.Z = Array(Operator.from_label("Z").data) # define a basic hamiltonian w = 2.0 r = 0.5 operators = [2 * np.pi * self.Z / 2, 2 * np.pi * r * self.X / 2] signals = [Constant(w), Signal(1.0, w)] self.w = w self.r = r self.basic_hamiltonian = HamiltonianModel(operators=operators, signals=signals)
def test_subtract_operator(self, coeff, label): """Test subtract operation with Operator (coeff={coeff}, label={label})""" dims = (2, 2) iden = ScalarOp(4, coeff=coeff) op = Operator.from_label(label) with self.subTest(msg="{} - Operator({})".format(iden, label)): val = iden - op target = coeff * Operator.from_label("II") - op self.assertOperator(val, dims, target) with self.subTest(msg="Operator({}) - {}".format(label, iden)): val = op - iden target = op - coeff * Operator.from_label("II") self.assertOperator(val, dims, target)
def test_add_operator(self, coeff, label): """Test add operation with Operator (coeff={coeff}, label={label})""" dims = (2, 2) iden = ScalarOp(4, coeff=coeff) op = Operator.from_label(label) with self.subTest(msg="{} + Operator({})".format(iden, label)): val = iden + op target = coeff * Operator.from_label("II") + op self.assertOperator(val, dims, target) with self.subTest(msg="Operator({}) + {}".format(label, iden)): val = op + iden target = coeff * Operator.from_label("II") + op self.assertOperator(val, dims, target)
def test_add_operator_qargs(self, coeff, qargs): """Test qargs add operation with Operator (coeff={coeff}, qargs={qargs})""" # Get labels for qarg addition part_array = np.array(["X", "Y", "Z"])[range(len(qargs))] label = "".join(part_array) full_array = np.array(3 * ["I"]) inds = [2 - i for i in reversed(qargs)] full_array[inds] = part_array full_label = "".join(full_array) dims = 3 * (2, ) val = ScalarOp(dims, coeff=coeff) + Operator.from_label(label)(qargs) target = (coeff * Operator.from_label( 3 * "I")) + Operator.from_label(full_label) self.assertOperator(val, dims, target)
def test_adjoint(self): """ adjoint test """ gnarly_op = 3 * (H ^ I ^ Y).compose(X ^ X ^ Z).tensor(T ^ Z) + \ PrimitiveOp(Operator.from_label('+r0IX').data) np.testing.assert_array_almost_equal( np.conj(np.transpose(gnarly_op.to_matrix())), gnarly_op.adjoint().to_matrix())
def test_primitive_strings(self): """ get primitives test """ self.assertEqual(X.primitive_strings(), {'Pauli'}) gnarly_op = 3 * (H ^ I ^ Y).compose(X ^ X ^ Z).tensor(T ^ Z) + \ PrimitiveOp(Operator.from_label('+r0IX').data) self.assertEqual(gnarly_op.primitive_strings(), {'QuantumCircuit', 'Matrix'})
def test_tensor_operator(self, coeff, label): """Test tensor and expand methods with ScalarOp and Operator. ({coeff}, {label})""" dim = 3 iden = ScalarOp(dim, coeff=coeff) op = Operator.from_label(label) with self.subTest(msg="{}.expand(Operator({}))".format(iden, label)): val = iden.expand(op) target = iden.to_operator().expand(op) self.assertOperator(val, (3, 2), target) with self.subTest(msg="Operator({}).expand({})".format(label, iden)): val = op.expand(iden) target = op.expand(iden.to_operator()) self.assertOperator(val, (2, 3), target) with self.subTest(msg="{}.tensor(Operator({}))".format(iden, label)): val = iden.tensor(op) target = iden.to_operator().tensor(op) self.assertOperator(val, (2, 3), target) with self.subTest(msg="Operator({}).tensor({})".format(label, iden)): val = op.tensor(iden) target = op.tensor(iden.to_operator()) self.assertOperator(val, (3, 2), target)
def setUp(self): self.X = Array(Operator.from_label("X").data) self.Y = Array(Operator.from_label("Y").data) self.Z = Array(Operator.from_label("Z").data) # define a basic model w = 2.0 r = 0.5 operators = [ -1j * 2 * np.pi * self.Z / 2, -1j * 2 * np.pi * r * self.X / 2 ] signals = [Constant(w), Signal(1.0, w)] self.w = 2 self.r = r self.basic_model = GeneratorModel(operators=operators, signals=signals)
def setUp(self): self.X = Array(Operator.from_label("X").data) self.Y = Array(Operator.from_label("Y").data) self.Z = Array(Operator.from_label("Z").data) # define a basic model w = Array(2.0) r = Array(0.5) operators = [ -1j * 2 * np.pi * self.Z / 2, -1j * 2 * np.pi * r * self.X / 2 ] def generator(t): return w * operators[0] + np.cos(2 * np.pi * w * t) * operators[1] self.w = 2 self.r = r self.basic_model = CallableGenerator(generator)
def test_to_pauli_op(self): """ Test to_pauli_op method """ gnarly_op = 3 * (H ^ I ^ Y).compose(X ^ X ^ Z).tensor(T ^ Z) + \ PrimitiveOp(Operator.from_label('+r0IX').data) mat_op = gnarly_op.to_matrix_op() pauli_op = gnarly_op.to_pauli_op() self.assertIsInstance(pauli_op, SummedOp) for p in pauli_op: self.assertIsInstance(p, PauliOp) np.testing.assert_array_almost_equal(mat_op.to_matrix(), pauli_op.to_matrix())
def test_compose_operator(self, coeff, label): """Test compose and dot methods with ScalarOp and Operator.""" dim = 4 iden = ScalarOp(dim, coeff=coeff) op = Operator.from_label(label) with self.subTest(msg=f"{iden}.compose(Operator({label}))"): val = iden.compose(op) target = iden.to_operator().compose(op) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"Operator({label}).compose({iden})"): val = op.compose(iden) target = op.compose(iden.to_operator()) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"{iden}.dot(Operator({label}))"): val = iden.dot(op) target = iden.to_operator().dot(op) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"Operator({label}).dot({iden})"): val = op.dot(iden) target = op.dot(iden.to_operator()) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"{iden} & Operator({label})"): val = iden & op target = iden.to_operator().compose(op) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"Operator({label}) & {iden}"): val = op & iden target = op.compose(iden.to_operator()) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target)
def test_evals(self): """ evals test """ # pylint: disable=no-member # TODO: Think about eval names self.assertEqual(Z.eval('0').eval('0'), 1) self.assertEqual(Z.eval('1').eval('0'), 0) self.assertEqual(Z.eval('0').eval('1'), 0) self.assertEqual(Z.eval('1').eval('1'), -1) self.assertEqual(X.eval('0').eval('0'), 0) self.assertEqual(X.eval('1').eval('0'), 1) self.assertEqual(X.eval('0').eval('1'), 1) self.assertEqual(X.eval('1').eval('1'), 0) self.assertEqual(Y.eval('0').eval('0'), 0) self.assertEqual(Y.eval('1').eval('0'), -1j) self.assertEqual(Y.eval('0').eval('1'), 1j) self.assertEqual(Y.eval('1').eval('1'), 0) # Check that Pauli logic eval returns same as matrix logic self.assertEqual(PrimitiveOp(Z.to_matrix()).eval('0').eval('0'), 1) self.assertEqual(PrimitiveOp(Z.to_matrix()).eval('1').eval('0'), 0) self.assertEqual(PrimitiveOp(Z.to_matrix()).eval('0').eval('1'), 0) self.assertEqual(PrimitiveOp(Z.to_matrix()).eval('1').eval('1'), -1) self.assertEqual(PrimitiveOp(X.to_matrix()).eval('0').eval('0'), 0) self.assertEqual(PrimitiveOp(X.to_matrix()).eval('1').eval('0'), 1) self.assertEqual(PrimitiveOp(X.to_matrix()).eval('0').eval('1'), 1) self.assertEqual(PrimitiveOp(X.to_matrix()).eval('1').eval('1'), 0) self.assertEqual(PrimitiveOp(Y.to_matrix()).eval('0').eval('0'), 0) self.assertEqual(PrimitiveOp(Y.to_matrix()).eval('1').eval('0'), -1j) self.assertEqual(PrimitiveOp(Y.to_matrix()).eval('0').eval('1'), 1j) self.assertEqual(PrimitiveOp(Y.to_matrix()).eval('1').eval('1'), 0) pauli_op = Z ^ I ^ X ^ Y mat_op = PrimitiveOp(pauli_op.to_matrix()) full_basis = list( map(''.join, itertools.product('01', repeat=pauli_op.num_qubits))) for bstr1, bstr2 in itertools.product(full_basis, full_basis): # print('{} {} {} {}'.format(bstr1, bstr2, pauli_op.eval(bstr1, bstr2), # mat_op.eval(bstr1, bstr2))) np.testing.assert_array_almost_equal( pauli_op.eval(bstr1).eval(bstr2), mat_op.eval(bstr1).eval(bstr2)) gnarly_op = SummedOp([(H ^ I ^ Y).compose(X ^ X ^ Z).tensor(Z), PrimitiveOp(Operator.from_label('+r0I')), 3 * (X ^ CX ^ T)], coeff=3 + .2j) gnarly_mat_op = PrimitiveOp(gnarly_op.to_matrix()) full_basis = list( map(''.join, itertools.product('01', repeat=gnarly_op.num_qubits))) for bstr1, bstr2 in itertools.product(full_basis, full_basis): np.testing.assert_array_almost_equal( gnarly_op.eval(bstr1).eval(bstr2), gnarly_mat_op.eval(bstr1).eval(bstr2))
def setUp(self): self.X = Array(Operator.from_label("X").data) self.Y = Array(Operator.from_label("Y").data) self.Z = Array(Operator.from_label("Z").data) # define a basic hamiltonian w = 2.0 r = 0.5 ham_operators = [2 * np.pi * self.Z / 2, 2 * np.pi * r * self.X / 2] ham_signals = [Constant(w), Signal(1.0, w)] self.w = w self.r = r noise_operators = Array([[[0.0, 0.0], [1.0, 0.0]]]) self.basic_lindblad = LindbladModel( hamiltonian_operators=ham_operators, hamiltonian_signals=ham_signals, noise_operators=noise_operators, )
def test_compose_qargs_operator(self, coeff, label): """Test qargs compose and dot methods with ScalarOp and Operator.""" iden = ScalarOp((2, 2), coeff=coeff) op = Operator.from_label(label) with self.subTest(msg=f"{iden}.compose(Operator({label}), qargs=[0])"): val = iden.compose(op, qargs=[0]) target = iden.to_operator().compose(op, qargs=[0]) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"{iden}.compose(Operator({label}), qargs=[1])"): val = iden.compose(op, qargs=[1]) target = iden.to_operator().compose(op, qargs=[1]) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"{iden}.dot(Operator({label}), qargs=[0])"): val = iden.dot(op, qargs=[0]) target = iden.to_operator().dot(op, qargs=[0]) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"{iden}.dot(Operator({label}), qargs=[1])"): val = iden.dot(op, qargs=[1]) target = iden.to_operator().dot(op, qargs=[1]) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"{iden} & Operator({label})([0])"): val = iden & op([0]) target = iden.to_operator().compose(op, qargs=[0]) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg=f"{iden} & Operator({label})([1])"): val = iden & op([1]) target = iden.to_operator().compose(op, qargs=[1]) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target)
def test_add_operator(self, coeff, label): """Test add and subtract operations with Operator (coeff={coeff}, label={label})""" dims = (2, 2) iden = ScalarOp(4, coeff=coeff) op = Operator.from_label(label) with self.subTest(msg='{} + Operator({})'.format(iden, label)): val = iden + op target = coeff * Operator.from_label('II') + op self.assertOperator(val, dims, target) with self.subTest(msg='Operator({}) + {}'.format(label, iden)): val = op + iden target = coeff * Operator.from_label('II') + op self.assertOperator(val, dims, target) with self.subTest(msg='{} - Operator({})'.format(iden, label)): val = iden - op target = coeff * Operator.from_label('II') - op self.assertOperator(val, dims, target) with self.subTest(msg='Operator({}) - {}'.format(label, iden)): val = op - iden target = op - coeff * Operator.from_label('II') self.assertOperator(val, dims, target)
def test_compose_operator(self, coeff, label): """Test compose and dot methods with ScalarOp and Operator.""" dim = 4 iden = ScalarOp(dim, coeff=coeff) op = Operator.from_label(label) with self.subTest(msg='{}.compose(Operator({}))'.format(iden, label)): val = iden.compose(op) target = iden.to_operator().compose(op) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg='Operator({}).compose({})'.format(label, iden)): val = op.compose(iden) target = op.compose(iden.to_operator()) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg='{}.dot(Operator({}))'.format(iden, label)): val = iden.dot(op) target = iden.to_operator().dot(op) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg='Operator({}).dot({})'.format(label, iden)): val = op.dot(iden) target = op.dot(iden.to_operator()) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg='{} @ Operator({})'.format(iden, label)): val = iden @ op target = iden.to_operator().compose(op) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg='Operator({}) @ {}'.format(label, iden)): val = op @ iden target = op.compose(iden.to_operator()) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg='{} * Operator({})'.format(iden, label)): val = iden * op target = iden.to_operator().dot(op) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target) with self.subTest(msg='Operator({}) * {}'.format(label, iden)): val = op * iden target = op.dot(iden.to_operator()) self.assertTrue(isinstance(val, Operator)) self.assertEqual(val.input_dims(), (2, 2)) self.assertEqual(val.output_dims(), (2, 2)) self.assertEqual(val, target)
def test_exact_two_qubit_cnot_decompose_paulis(self): """Verify exact CNOT decomposition for Paulis """ unitary = Operator.from_label('XZ') self.check_exact_decomposition(unitary.data, two_qubit_cnot_decompose)
def operator_from_label(label): """Construct operator from full Pauli group label""" pauli, coeff = _split_pauli_label(label) coeff = (-1j)**_phase_from_label(coeff) return coeff * Operator.from_label(pauli)
def setUp(self): self.X = Array(Operator.from_label("X").data) self.Y = Array(Operator.from_label("Y").data) self.Z = Array(Operator.from_label("Z").data)