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_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_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_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 _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_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_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 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_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_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 _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(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_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)
def test_init(self): """Test initialization""" mat = np.eye(3) chan = UnitaryChannel(mat) self.assertAllClose(chan.data, mat) self.assertEqual(chan.dims, (3, 3)) # Non-square matrix should raise exception self.assertRaises(QiskitError, UnitaryChannel, np.zeros((2, 3))) # Wrong input or output dims should raise exception self.assertRaises(QiskitError, UnitaryChannel, mat, input_dim=2) self.assertRaises(QiskitError, UnitaryChannel, mat, output_dim=2)
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)