def test_tensor_inplace(self): """Test inplace tensor method.""" rho0, rho1 = np.diag([1, 0]), np.diag([0, 1]) rho_init = np.kron(rho0, rho0) # X \otimes I chan1 = Stinespring(self.matI) chan2 = Stinespring(self.matX) chan2.tensor(chan1, inplace=True) rho_targ = np.kron(rho1, rho0) self.assertEqual(chan2.dims, (4, 4)) self.assertAllClose(chan2._evolve(rho_init), rho_targ) # I \otimes X chan1 = Stinespring(self.matI) chan2 = Stinespring(self.matX) chan1.tensor(chan2, inplace=True) rho_targ = np.kron(rho0, rho1) self.assertEqual(chan1.dims, (4, 4)) self.assertAllClose(chan1._evolve(rho_init), rho_targ) # Completely depolarizing chan = Stinespring(self.depol_stine(1)) chan.tensor(chan, inplace=True) rho_targ = np.diag([1, 1, 1, 1]) / 4 self.assertEqual(chan.dims, (4, 4)) self.assertAllClose(chan._evolve(rho_init), rho_targ)
def test_multiply(self): """Test multiply method.""" # Random initial state and Stinespring ops rho = self.rand_rho(2) val = 0.5 stine1, stine2 = self.rand_matrix(16, 2), self.rand_matrix(16, 2) # Single Stinespring set chan1 = Stinespring(stine1, input_dim=2, output_dim=4) targ = val * chan1._evolve(rho) chan = chan1.multiply(val) self.assertAllClose(chan._evolve(rho), targ) chan = val * chan1 self.assertAllClose(chan._evolve(rho), targ) chan = chan1 * val self.assertAllClose(chan._evolve(rho), targ) # Double Stinespring set chan2 = Stinespring((stine1, stine2), input_dim=2, output_dim=4) targ = val * chan2._evolve(rho) chan = chan2.multiply(val) self.assertAllClose(chan._evolve(rho), targ) chan = val * chan2 self.assertAllClose(chan._evolve(rho), targ) chan = chan2 * val self.assertAllClose(chan._evolve(rho), targ)
def test_compose_front_inplace(self): """Test inplace front compose method.""" # Random input test state rho = self.rand_rho(2) # UnitaryChannel evolution chan1 = Stinespring(self.matX) chan2 = Stinespring(self.matY) chan1.compose(chan2, inplace=True, front=True) targ = Stinespring(self.matZ)._evolve(rho) self.assertAllClose(chan1._evolve(rho), targ) # 50% depolarizing channel chan = Stinespring(self.depol_stine(0.5)) chan.compose(chan, inplace=True, front=True) targ = Stinespring(self.depol_stine(0.75))._evolve(rho) self.assertAllClose(chan._evolve(rho), targ) # Compose different dimensions stine1, stine2 = self.rand_matrix(16, 2), self.rand_matrix(8, 4) chan1 = Stinespring(stine1, input_dim=2, output_dim=4) chan2 = Stinespring(stine2, input_dim=4, output_dim=2) targ = chan2._evolve(chan1._evolve(rho)) chan2.compose(chan1, inplace=True, front=True) self.assertEqual(chan2.dims, (2, 2)) self.assertAllClose(chan2._evolve(rho), targ)
def test_compose(self): """Test compose method.""" # Random input test state rho = self.rand_rho(2) # UnitaryChannel evolution chan1 = Stinespring(self.UX) chan2 = Stinespring(self.UY) chan = chan1.compose(chan2) targ = Stinespring(self.UZ)._evolve(rho) self.assertAllClose(chan._evolve(rho), targ) # 50% depolarizing channel chan1 = Stinespring(self.depol_stine(0.5)) chan = chan1.compose(chan1) targ = Stinespring(self.depol_stine(0.75))._evolve(rho) self.assertAllClose(chan._evolve(rho), targ) # Compose different dimensions stine1, stine2 = self.rand_matrix(16, 2), self.rand_matrix(8, 4) chan1 = Stinespring(stine1, input_dims=2, output_dims=4) chan2 = Stinespring(stine2, input_dims=4, output_dims=2) targ = chan2._evolve(chan1._evolve(rho)) chan = chan1.compose(chan2) self.assertEqual(chan.dim, (2, 2)) self.assertAllClose(chan._evolve(rho), targ) chan = chan1 @ chan2 self.assertEqual(chan.dim, (2, 2)) self.assertAllClose(chan._evolve(rho), targ)
def test_power_inplace(self): """Test inplace power method.""" # 10% depolarizing channel rho = np.diag([1, 0]) p_id = 0.9 chan = Stinespring(self.depol_stine(1 - p_id)) # Compose 3 times p_id3 = p_id**3 targ3a = chan._evolve(chan._evolve(chan._evolve(rho))) targ3b = Stinespring(self.depol_stine(1 - p_id3))._evolve(rho) chan.power(3, inplace=True) self.assertAllClose(chan._evolve(rho), targ3a) self.assertAllClose(chan._evolve(rho), targ3b)
def test_subtract(self): """Test subtract method.""" # Random input test state rho = self.rand_rho(2) stine1, stine2 = self.rand_matrix(16, 2), self.rand_matrix(16, 2) # Random Single-Stinespring maps chan1 = Stinespring(stine1, input_dim=2, output_dim=4) chan2 = Stinespring(stine2, input_dim=2, output_dim=4) targ = chan1._evolve(rho) - chan2._evolve(rho) chan = chan1.subtract(chan2) self.assertAllClose(chan._evolve(rho), targ) chan = chan1 - chan2 self.assertAllClose(chan._evolve(rho), targ) # Random Single-Stinespring maps chan = Stinespring((stine1, stine2)) targ = 0 * chan._evolve(rho) chan = chan.subtract(chan) self.assertAllClose(chan._evolve(rho), targ)
def test_add(self): """Test add method.""" # Random input test state rho = self.rand_rho(2) stine1, stine2 = self.rand_matrix(16, 2), self.rand_matrix(16, 2) # Random Single-Stinespring maps chan1 = Stinespring(stine1, input_dims=2, output_dims=4) chan2 = Stinespring(stine2, input_dims=2, output_dims=4) targ = chan1._evolve(rho) + chan2._evolve(rho) chan = chan1.add(chan2) self.assertAllClose(chan._evolve(rho), targ) chan = chan1 + chan2 self.assertAllClose(chan._evolve(rho), targ) # Random Single-Stinespring maps chan = Stinespring((stine1, stine2)) targ = 2 * chan._evolve(rho) chan = chan.add(chan) self.assertAllClose(chan._evolve(rho), targ)
def test_evolve(self): """Test evolve method.""" input_psi = [0, 1] input_rho = [[0, 0], [0, 1]] # Identity channel chan = Stinespring(self.matI) target_psi = np.array([0, 1]) self.assertAllClose(chan._evolve(input_psi), target_psi) self.assertAllClose(chan._evolve(np.array(input_psi)), target_psi) target_rho = np.array([[0, 0], [0, 1]]) self.assertAllClose(chan._evolve(input_rho), target_rho) self.assertAllClose(chan._evolve(np.array(input_rho)), target_rho) # Hadamard channel mat = np.array([[1, 1], [1, -1]]) / np.sqrt(2) chan = Stinespring(mat) target_psi = np.array([1, -1]) / np.sqrt(2) self.assertAllClose(chan._evolve(input_psi), target_psi) self.assertAllClose(chan._evolve(np.array(input_psi)), target_psi) target_rho = np.array([[1, -1], [-1, 1]]) / 2 self.assertAllClose(chan._evolve(input_rho), target_rho) self.assertAllClose(chan._evolve(np.array(input_rho)), target_rho) # Completely depolarizing channel chan = Stinespring(self.depol_stine(1)) target_rho = np.eye(2) / 2 self.assertAllClose(chan._evolve(input_psi), target_rho) self.assertAllClose(chan._evolve(np.array(input_psi)), target_rho) self.assertAllClose(chan._evolve(input_rho), target_rho) self.assertAllClose(chan._evolve(np.array(input_rho)), target_rho)