def test_init(self, j):
"""Test {j}-qubit automatic dims."""
dim = 2**j
op = ScalarOp(dim)
self.assertEqual(op.dim, (dim, dim))
self.assertEqual(op.input_dims(), j * (2, ))
self.assertEqual(op.output_dims(), j * (2, ))
self.assertEqual(op.coeff, 1)
def test_mul_scalar(self, coeff1, coeff2):
"""Test mul method with two ScalarOp. ({coeff1}, {coeff2})"""
dims = (3, 2)
op1 = ScalarOp(dims, coeff=coeff1)
op2 = ScalarOp(dims, coeff=coeff2)
val = op1.dot(op2)
target = coeff1 * coeff2
self.assertScalarOp(val, dims, target)
def test_subtract(self, coeff1, coeff2):
"""Test add operation with ScalarOp. ({coeff1} - {coeff2})"""
dims = (3, 2)
op1 = ScalarOp(dims, coeff=coeff1)
op2 = ScalarOp(6, coeff=coeff2)
val = op1 - op2
target = coeff1 - coeff2
self.assertScalarOp(val, dims, target)
def test_custom_dims(self):
"""Test custom dims."""
dims = (2, 3, 4, 5)
dim = np.product(dims)
op = ScalarOp(dims)
self.assertEqual(op.dim, (dim, dim))
self.assertEqual(op.input_dims(), dims)
self.assertEqual(op.output_dims(), dims)
self.assertEqual(op.coeff, 1)
def test_multiply(self, coeff1, coeff2):
"""Test scalar multiplication. ({coeff1}, {coeff2})"""
dims = (3, 2)
val = coeff2 * ScalarOp(dims, coeff=coeff1)
target = coeff1 * coeff2
self.assertScalarOp(val, dims, target)
val = ScalarOp(dims, coeff=coeff1) * coeff2
target = coeff2 * coeff1
self.assertScalarOp(val, dims, target)
def test_expand_scalar(self, coeff1, coeff2):
"""Test expand method with two ScalarOp ({coeff1}, {coeff2})"""
dims1 = (3, 2)
dims2 = (2, 4)
op1 = ScalarOp(dims1, coeff=coeff1)
op2 = ScalarOp(dims2, coeff=coeff2)
val = op1.expand(op2)
target = coeff1 * coeff2
self.assertScalarOp(val, dims1 + dims2, target)
def test_tensor_scalar(self, coeff1, coeff2):
"""Test tensor method with two ScalarOp. {coeff1}, {coeff2})"""
dims1 = (3, 2)
dims2 = (2, 4)
op1 = ScalarOp(dims1, coeff=coeff1)
op2 = ScalarOp(dims2, coeff=coeff2)
val = op1.tensor(op2)
target = coeff1 * coeff2
self.assertScalarOp(val, dims2 + dims1, target)
def test_add(self, coeff1, coeff2):
"""Test add operation with ScalarOp. ({coeff1} + {coeff2})"""
# Add two ScalarOps
dims = (3, 2)
op1 = ScalarOp(dims, coeff=coeff1)
op2 = ScalarOp(6, coeff=coeff2)
val = op1 + op2
target = coeff1 + coeff2
self.assertScalarOp(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=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_subtract_qargs(self, coeff1, coeff2, qargs):
"""Test subtract operation with ScalarOp. ({coeff1} - {coeff2}({qargs}))"""
# Add two ScalarOps
full_dims = np.array([2, 3, 4])
dims1 = tuple(full_dims.tolist())
dims2 = tuple(full_dims[qargs].tolist())
op1 = ScalarOp(dims1, coeff=coeff1)
op2 = ScalarOp(dims2, coeff=coeff2)
val = op1 - op2(qargs)
target = coeff1 - coeff2
self.assertScalarOp(val, dims1, target)
def test_to_operator(self, dims, coeff):
"""Test to_matrix and to_operator methods (dims={dims}, coeff={coeff})"""
dim = np.product(dims)
iden = ScalarOp(dims, coeff=coeff)
target = Operator(coeff * np.eye(dim),
input_dims=dims,
output_dims=dims)
with self.subTest(msg="to_operator"):
self.assertEqual(iden.to_operator(), target)
with self.subTest(msg="to_matrix"):
self.assertTrue(np.allclose(iden.to_matrix(), target.data))
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 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 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_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(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_complex_coeff(self):
"""Test complex coeff."""
op = ScalarOp(5, coeff=3j)
self.assertEqual(op.coeff, 3j)
def test_real_coeff(self):
"""Test real coeff."""
op = ScalarOp(5, coeff=5.2)
self.assertEqual(op.coeff, 5.2)
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="{}.compose(Operator({}), qargs=[0])".format(iden, label)):
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="{}.compose(Operator({}), qargs=[1])".format(iden, label)):
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="{}.dot(Operator({}), qargs=[0])".format(iden, label)):
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="{}.dot(Operator({}), qargs=[1])".format(iden, label)):
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="{} & Operator({})([0])".format(iden, label)):
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="{} & Operator({})([1])".format(iden, label)):
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)
with self.subTest(msg="{} * Operator({})([0])".format(iden, label)):
val = iden * op([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="{} * Operator({})([1])".format(iden, label)):
val = iden * op([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)
def test_compose_qargs_scalar(self, coeff1, coeff2):
"""Test qargs compose and dot methods with two ScalarOp. ({coeff1}, {coeff2})"""
dims = (2, 3)
op1 = ScalarOp(dims, coeff=coeff1)
op2 = ScalarOp(2, coeff=coeff2)
op3 = ScalarOp(3, coeff=coeff2)
with self.subTest(msg="{}.compose({}, qargs=[0])".format(op1, op2)):
val = op1.compose(op2, qargs=[0])
target = coeff1 * coeff2
self.assertScalarOp(val, dims, target)
with self.subTest(msg="{}.compose({}, qargs=[1])".format(op1, op3)):
val = op1.compose(op3, qargs=[1])
target = coeff1 * coeff2
self.assertScalarOp(val, dims, target)
with self.subTest(msg="{}.dot({}, qargs=[0])".format(op1, op2)):
val = op1.dot(op2, qargs=[0])
target = coeff1 * coeff2
self.assertTrue(isinstance(val, ScalarOp))
self.assertEqual(val.input_dims(), dims)
self.assertEqual(val.output_dims(), dims)
self.assertAlmostEqual(val.coeff, target)
with self.subTest(msg="{}.dot({}, qargs=[1])".format(op1, op3)):
val = op1.dot(op3, qargs=[1])
target = coeff1 * coeff2
self.assertTrue(isinstance(val, ScalarOp))
self.assertEqual(val.input_dims(), dims)
self.assertEqual(val.output_dims(), dims)
self.assertAlmostEqual(val.coeff, target)
with self.subTest(msg="{} & {}([0])".format(op1, op2)):
val = op1 & op2([0])
target = coeff1 * coeff2
self.assertTrue(isinstance(val, ScalarOp))
self.assertEqual(val.input_dims(), dims)
self.assertEqual(val.output_dims(), dims)
self.assertAlmostEqual(val.coeff, target)
with self.subTest(msg="{} & {}([1])".format(op1, op3)):
val = op1 & op3([1])
target = coeff1 * coeff2
self.assertTrue(isinstance(val, ScalarOp))
self.assertEqual(val.input_dims(), dims)
self.assertEqual(val.output_dims(), dims)
self.assertAlmostEqual(val.coeff, target)
with self.subTest(msg="{} * {}([0])".format(op1, op2)):
val = op1.dot(op2([0]))
target = coeff1 * coeff2
self.assertTrue(isinstance(val, ScalarOp))
self.assertEqual(val.input_dims(), dims)
self.assertEqual(val.output_dims(), dims)
self.assertAlmostEqual(val.coeff, target)
with self.subTest(msg="{} * {}([1])".format(op1, op3)):
val = op1.dot(op3([1]))
target = coeff1 * coeff2
self.assertTrue(isinstance(val, ScalarOp))
self.assertEqual(val.input_dims(), dims)
self.assertEqual(val.output_dims(), dims)
self.assertAlmostEqual(val.coeff, target)
def test_base_operator_power_exp(self, coeff, exp):
"""Test basic class power method (** {exp}, coeff={coeff})"""
op = ScalarOp(4, coeff=coeff).power(exp)
target = coeff**exp
self.assertTrue(isinstance(op, ScalarOp))
self.assertAlmostEqual(op.coeff, target)
def test_base_operator_transpose(self, coeff):
"""Test basic class transpose method (coeff={coeff})"""
op = ScalarOp(4, coeff=coeff).transpose()
self.assertTrue(isinstance(op, ScalarOp))
self.assertEqual(op.coeff, coeff)
def test_base_operator_power_0(self, coeff):
"""Test basic class power method (** 0, coeff={coeff})"""
op = ScalarOp(4, coeff=coeff).power(0)
target = 1
self.assertTrue(isinstance(op, ScalarOp))
self.assertAlmostEqual(op.coeff, 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_base_operator_conjugate(self, coeff):
"""Test basic class conjugate method (coeff={coeff})"""
op = ScalarOp(4, coeff=coeff).conjugate()
target = np.conjugate(coeff)
self.assertTrue(isinstance(op, ScalarOp))
self.assertEqual(op.coeff, target)
def test_multiply_negate(self, coeff):
"""Test scalar multiplication. Negate. (coeff={coeff})"""
dims = (3, 2)
val = -ScalarOp(dims, coeff=coeff)
target = -1 * coeff
self.assertScalarOp(val, dims, target)
