def test_adjoint_inplace(self):
"""Test inplace adjoint method."""
matr = np.array([[1, 2], [3, 4]])
mati = np.array([[1, 2], [3, 4]])
chan = UnitaryChannel(matr + 1j * mati)
chan.adjoint(inplace=True)
self.assertEqual(chan, UnitaryChannel(matr.T - 1j * mati.T))
def test_transpose_inplace(self):
"""Test inplace transpose method."""
matr = np.array([[1, 2], [3, 4]])
mati = np.array([[1, 2], [3, 4]])
chan = UnitaryChannel(matr + 1j * mati)
chan.transpose(inplace=True)
self.assertEqual(chan, UnitaryChannel(matr.T + 1j * mati.T))
def test_is_cptp(self):
"""Test is_cptp method."""
# X-90 rotation
X90 = la.expm(-1j * 0.5 * np.pi * np.array([[0, 1], [1, 0]]) / 2)
self.assertTrue(UnitaryChannel(X90).is_cptp())
# Non-unitary should return false
self.assertFalse(UnitaryChannel([[1, 0], [0, 0]]).is_cptp())
def test_power(self):
"""Test power method."""
X90 = la.expm(-1j * 0.5 * np.pi * np.array([[0, 1], [1, 0]]) / 2)
chan = UnitaryChannel(X90)
self.assertEqual(chan.power(2), UnitaryChannel([[0, -1j], [-1j, 0]]))
self.assertEqual(chan.power(4), UnitaryChannel(-1 * np.eye(2)))
self.assertEqual(chan.power(8), UnitaryChannel(np.eye(2)))
def test_conjugate_inplace(self):
"""Test inplace conjugate method."""
matr = np.array([[1, 2], [3, 4]])
mati = np.array([[1, 2], [3, 4]])
chan = UnitaryChannel(matr + 1j * mati)
chan.conjugate(inplace=True)
self.assertEqual(chan, UnitaryChannel(matr - 1j * mati))
def test_conjugate(self):
"""Test conjugate method."""
matr = np.array([[1, 2], [3, 4]])
mati = np.array([[1, 2], [3, 4]])
chan = UnitaryChannel(matr + 1j * mati)
uni_conj = chan.conjugate()
self.assertEqual(uni_conj, UnitaryChannel(matr - 1j * mati))
def test_unitary_to_unitary(self):
"""Test UnitaryChannel to UnitaryChannel transformation."""
# Test unitary channels
for mat in self.unitary_mat:
chan1 = UnitaryChannel(mat)
chan2 = UnitaryChannel(chan1)
self.assertEqual(chan1, chan2)
def test_transpose(self):
"""Test transpose method."""
matr = np.array([[1, 2], [3, 4]])
mati = np.array([[1, 2], [3, 4]])
chan = UnitaryChannel(matr + 1j * mati)
uni_t = chan.transpose()
self.assertEqual(uni_t, UnitaryChannel(matr.T + 1j * mati.T))
def test_adjoint(self):
"""Test adjoint method."""
matr = np.array([[1, 2], [3, 4]])
mati = np.array([[1, 2], [3, 4]])
chan = UnitaryChannel(matr + 1j * mati)
uni_adj = chan.adjoint()
self.assertEqual(uni_adj, UnitaryChannel(matr.T - 1j * mati.T))
def test_choi_to_unitary(self):
"""Test Choi to UnitaryChannel transformation."""
# Test unitary channels
for mat, choi in zip(self.unitary_mat, self.unitary_choi):
chan1 = UnitaryChannel(mat)
chan2 = UnitaryChannel(Choi(choi))
self.assertTrue(
matrix_equal(chan2.data, chan1.data, ignore_phase=True))
def test_compose_except(self):
"""Test compose different dimension exception"""
self.assertRaises(QiskitError,
UnitaryChannel(np.eye(2)).compose,
UnitaryChannel(np.eye(3)))
self.assertRaises(QiskitError,
UnitaryChannel(np.eye(2)).compose, np.eye(2))
self.assertRaises(QiskitError, UnitaryChannel(np.eye(2)).compose, 2)
def test_ptm_to_unitary(self):
"""Test PTM to UnitaryChannel transformation."""
for mat, ptm in zip(self.unitary_mat, self.unitary_ptm):
chan1 = UnitaryChannel(mat)
chan2 = UnitaryChannel(PTM(ptm))
self.assertTrue(
matrix_equal(chan2.data, chan1.data, ignore_phase=True))
self.assertRaises(QiskitError, UnitaryChannel,
PTM(self.depol_ptm(0.5)))
def test_chi_to_unitary(self):
"""Test Chi to UnitaryChannel transformation."""
for mat, chi in zip(self.unitary_mat, self.unitary_chi):
chan1 = UnitaryChannel(mat)
chan2 = UnitaryChannel(Chi(chi))
self.assertTrue(
matrix_equal(chan2.data, chan1.data, ignore_phase=True))
self.assertRaises(QiskitError, UnitaryChannel,
Chi(self.depol_chi(0.5)))
def test_stinespring_to_unitary(self):
"""Test Stinespring to UnitaryChannel transformation."""
for mat in self.unitary_mat:
chan1 = UnitaryChannel(mat)
chan2 = UnitaryChannel(Stinespring(mat))
self.assertTrue(
matrix_equal(chan2.data, chan1.data, ignore_phase=True))
self.assertRaises(QiskitError, UnitaryChannel,
Stinespring(self.depol_stine(0.5)))
def test_superop_to_unitary(self):
"""Test SuperOp to UnitaryChannel transformation."""
for mat, sop in zip(self.unitary_mat, self.unitary_sop):
chan1 = UnitaryChannel(mat)
chan2 = UnitaryChannel(SuperOp(sop))
self.assertTrue(
matrix_equal(chan2.data, chan1.data, ignore_phase=True))
self.assertRaises(QiskitError, UnitaryChannel,
SuperOp(self.depol_sop(0.5)))
def test_subtract_inplace(self):
"""Test inplace subtract method."""
chan = UnitaryChannel([[1, 2], [3, 4]])
chan.subtract(chan, inplace=True)
self.assertEqual(chan, UnitaryChannel(np.zeros((2, 2))))
chan = UnitaryChannel([[1, 2], [3, 4]])
chan -= chan
self.assertEqual(chan, UnitaryChannel(np.zeros((2, 2))))
def test_multiply_inplace(self):
"""Test inplace multiply method."""
chan = UnitaryChannel([[1, 2], [3, 4]])
chan.multiply(2.0, inplace=True)
self.assertEqual(chan, UnitaryChannel([[2, 4], [6, 8]]))
chan = UnitaryChannel([[1, 2], [3, 4]])
chan *= 2
self.assertEqual(chan, UnitaryChannel([[2, 4], [6, 8]]))
def test_kraus_to_unitary(self):
"""Test Kraus to UnitaryChannel transformation."""
for mat in self.unitary_mat:
chan1 = UnitaryChannel(mat)
chan2 = UnitaryChannel(Kraus(mat))
self.assertTrue(
matrix_equal(chan2.data, chan1.data, ignore_phase=True))
self.assertRaises(QiskitError, UnitaryChannel,
Kraus(self.depol_kraus(0.5)))
def test_add_inplace(self):
"""Test inplace add method."""
chan = UnitaryChannel([[1, 2], [3, 4]])
chan.add(chan, inplace=True)
self.assertEqual(chan, UnitaryChannel([[2, 4], [6, 8]]))
chan = UnitaryChannel([[1, 2], [3, 4]])
chan += chan
self.assertEqual(chan, UnitaryChannel([[2, 4], [6, 8]]))
def test_power_inplace(self):
"""Test inplace power method."""
X90 = la.expm(-1j * 0.5 * np.pi * np.array([[0, 1], [1, 0]]) / 2)
chan = UnitaryChannel(X90)
chan.power(2, inplace=True)
self.assertEqual(chan, UnitaryChannel([[0, -1j], [-1j, 0]]))
chan.power(2, inplace=True)
self.assertEqual(chan, UnitaryChannel(-1 * np.eye(2)))
chan.power(4, inplace=True)
self.assertEqual(chan, UnitaryChannel(np.eye(2)))
def _other_to_unitary(self, rep, qubits_test_cases, repetitions):
"""Test Other to UnitaryChannel evolution."""
for nq in qubits_test_cases:
dim = 2**nq
for _ in range(repetitions):
rho = self.rand_rho(dim)
mat = self.rand_matrix(dim, dim)
chan1 = rep(UnitaryChannel(mat))
rho1 = chan1._evolve(rho)
chan2 = UnitaryChannel(chan1)
rho2 = chan2._evolve(rho)
self.assertAllClose(rho1, rho2)
def test_compose(self):
"""Test compose method."""
matX = np.array([[0, 1], [1, 0]], dtype=complex)
matY = np.array([[0, -1j], [1j, 0]], dtype=complex)
chan1 = UnitaryChannel(matX)
chan2 = UnitaryChannel(matY)
targ = UnitaryChannel(np.dot(matY, matX))
self.assertEqual(chan1.compose(chan2), targ)
self.assertEqual(chan1 @ chan2, targ)
targ = UnitaryChannel(np.dot(matX, matY))
self.assertEqual(chan2.compose(chan1), targ)
self.assertEqual(chan2 @ chan1, targ)
def test_unitary_to_superop(self):
"""Test UnitaryChannel to SuperOp transformation."""
# Test unitary channels
for mat, sop in zip(self.unitary_mat, self.unitary_sop):
chan1 = SuperOp(sop)
chan2 = SuperOp(UnitaryChannel(mat))
self.assertEqual(chan1, chan2)
def test_unitary_to_kraus(self):
"""Test UnitaryChannel to Kraus transformation."""
# Test unitary channels
for mat in self.unitary_mat:
chan1 = Kraus(mat)
chan2 = Kraus(UnitaryChannel(mat))
self.assertEqual(chan1, chan2)
def test_unitary_to_stinespring(self):
"""Test UnitaryChannel to Stinespring transformation."""
# Test unitary channels
for mat in self.unitary_mat:
chan1 = Stinespring(mat)
chan2 = Stinespring(UnitaryChannel(chan1))
self.assertEqual(chan1, chan2)
def test_unitary_to_chi(self):
"""Test UnitaryChannel to Chi transformation."""
# Test unitary channels
for mat, chi in zip(self.unitary_mat, self.unitary_chi):
chan1 = Chi(chi)
chan2 = Chi(UnitaryChannel(mat))
self.assertEqual(chan1, chan2)
def test_copy(self):
"""Test copy method"""
mat = np.eye(2)
orig = UnitaryChannel(mat)
cpy = orig.copy()
cpy._data[0, 0] = 0.0
self.assertFalse(cpy == orig)
def test_unitary_to_ptm(self):
"""Test UnitaryChannel to PTM transformation."""
# Test unitary channels
for mat, ptm in zip(self.unitary_mat, self.unitary_ptm):
chan1 = PTM(ptm)
chan2 = PTM(UnitaryChannel(mat))
self.assertEqual(chan1, chan2)
def _compare_adjoint_to_unitary(self, chans, mats):
"""Test adjoint is equivalent"""
unitaries = [
UnitaryChannel(np.conjugate(np.transpose(i))) for i in mats
]
channels = [i.adjoint() for i in chans]
for chan, uni in zip(channels, unitaries):
self.assertEqual(chan, chan.__class__(uni))
def test_power_except(self):
"""Test power method raises exceptions."""
chan = UnitaryChannel(np.eye(3))
# Negative power raises error
self.assertRaises(QiskitError, chan.power, -1)
# 0 power raises error
self.assertRaises(QiskitError, chan.power, 0)
# Non-integer power raises error
self.assertRaises(QiskitError, chan.power, 0.5)
