def test_fidelity_non_identical_states_2(self): """Test the fidelity between two non-identical states.""" e_0, e_1 = ket(2, 0), ket(2, 1) rho = 3 / 4 * e_0 * e_0.conj().T + 1 / 4 * e_1 * e_1.conj().T sigma = 1 / 8 * e_0 * e_0.conj().T + 7 / 8 * e_1 * e_1.conj().T self.assertEqual(np.isclose(fidelity(rho, sigma), 0.774, rtol=1e-03), True)
def test_domino_2(self): """Domino with index = 2.""" e_0, e_1 = ket(3, 0), ket(3, 1) expected_res = np.kron(e_0, 1 / np.sqrt(2) * (e_0 - e_1)) res = domino(2) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_domino_8(self): """Domino with index = 8.""" e_0, e_1, e_2 = ket(3, 0), ket(3, 1), ket(3, 2) expected_res = np.kron(1 / np.sqrt(2) * (e_0 - e_1), e_2) res = domino(8) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_concurrence_separable(self): """The concurrence of a product state is zero.""" e_0, e_1 = ket(2, 0), ket(2, 1) v_vec = np.kron(e_0, e_1) sigma = v_vec * v_vec.conj().T res = concurrence(sigma) self.assertEqual(np.isclose(res, 0), True)
def test_state_distinguishability_three_state_vec(self): """State distinguishability for two state vectors.""" e_0, e_1 = ket(2, 0), ket(2, 1) states = [e_0, e_1] probs = [1 / 2, 1 / 2] res = state_distinguishability(states, probs) self.assertEqual(np.isclose(res, 1 / 2), True)
def test_sub_fidelity_lower_bound_2(self): """Test sub_fidelity is lower bound on fidelity for rho and pi.""" e_0, e_1 = ket(2, 0), ket(2, 1) rho = 3 / 4 * e_0 * e_0.conj().T + 1 / 4 * e_1 * e_1.conj().T sigma = 1 / 8 * e_0 * e_0.conj().T + 7 / 8 * e_1 * e_1.conj().T res = sub_fidelity(rho, sigma) self.assertLessEqual(res, fidelity(rho, sigma))
def test_max_ent_2(self): """Generate maximally entangled state: `1/sqrt(2) * (|00> + |11>)`.""" e_0, e_1 = ket(2, 0), ket(2, 1) expected_res = 1 / np.sqrt(2) * (np.kron(e_0, e_0) + np.kron(e_1, e_1)) res = max_entangled(2) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_max_ent_2_0_0(self): """Generate maximally entangled state: `|00> + |11>`.""" e_0, e_1 = ket(2, 0), ket(2, 1) expected_res = 1 * (np.kron(e_0, e_0) + np.kron(e_1, e_1)) res = max_entangled(2, False, False) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_domino_4(self): """Domino with index = 4.""" e_1, e_2 = ket(3, 1), ket(3, 2) expected_res = np.kron(e_2, 1 / np.sqrt(2) * (e_1 - e_2)) res = domino(4) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_is_not_mub_dim_2(self): """Return False for non-MUB of dimension 2.""" e_0, e_1 = ket(2, 0), ket(2, 1) mub_1 = [e_0, e_1] mub_2 = [1 / np.sqrt(2) * (e_0 + e_1), e_1] mub_3 = [1 / np.sqrt(2) * (e_0 + 1j * e_1), e_0] mubs = [mub_1, mub_2, mub_3] self.assertEqual(is_mub(mubs), False)
def test_schmidt_rank_singlet_state(self): """ Computing the Schmidt rank of the entangled singlet state should yield a value greater than 1. """ e_0, e_1 = ket(2, 0), ket(2, 1) rho = 1 / np.sqrt(2) * (np.kron(e_0, e_1) - np.kron(e_1, e_0)) rho = rho.conj().T * rho self.assertEqual(schmidt_rank(rho) > 1, True)
def test_tensor_list_3(self): """Test tensor list with three items.""" e_0, e_1 = ket(2, 0), ket(2, 1) expected_res = np.kron(np.kron(e_0, e_1), e_0) res = tensor([e_0, e_1, e_0]) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_is_pure_list(self): """Check that list of pure states returns True.""" e_0, e_1, e_2 = ket(3, 0), ket(3, 1), ket(3, 2) e0_dm = e_0 * e_0.conj().T e1_dm = e_1 * e_1.conj().T e2_dm = e_2 * e_2.conj().T self.assertEqual(is_pure([e0_dm, e1_dm, e2_dm]), True)
def test_bell_3(self): """Generates the Bell state: `1/sqrt(2) * (|01> - |10>)`.""" e_0, e_1 = ket(2, 0), ket(2, 1) expected_res = 1 / np.sqrt(2) * (np.kron(e_0, e_1) - np.kron(e_1, e_0)) res = bell(3) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_ghz_2_3(self): """Produces the 3-qubit GHZ state: `1/sqrt(2) * (|000> + |111>)`.""" e_0, e_1 = ket(2, 0), ket(2, 1) expected_res = 1 / np.sqrt(2) * (tensor(e_0, e_0, e_0) + tensor(e_1, e_1, e_1)) res = ghz(2, 3).toarray() bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_concurrence_entangled(self): """The concurrence on maximally entangled Bell state.""" e_0, e_1 = ket(2, 0), ket(2, 1) e_00, e_11 = np.kron(e_0, e_0), np.kron(e_1, e_1) u_vec = 1 / np.sqrt(2) * (e_00 + e_11) rho = u_vec * u_vec.conj().T res = concurrence(rho) self.assertEqual(np.isclose(res, 1), True)
def test_state_distinguishability_two_states(self): """State distinguishability for two state density matrices.""" e_0, e_1 = ket(2, 0), ket(2, 1) e_00 = e_0 * e_0.conj().T e_11 = e_1 * e_1.conj().T states = [e_00, e_11] probs = [1 / 2, 1 / 2] res = state_distinguishability(states, probs) self.assertEqual(np.isclose(res, 1 / 2), True)
def bell(idx: int) -> np.ndarray: r""" Produce a Bell state [WIKBELL]_. Returns one of the following four Bell states depending on the value of `idx`: .. math:: \begin{equation} \begin{aligned} \frac{1}{\sqrt{2}} \left( |00 \rangle + |11 \rangle \right) & \qquad & \frac{1}{\sqrt{2}} \left( |00 \rangle - |11 \rangle \right) \\ \frac{1}{\sqrt{2}} \left( |01 \rangle + |10 \rangle \right) & \qquad & \frac{1}{\sqrt{2}} \left( |01 \rangle - |10 \rangle \right) \end{aligned} \end{equation} Examples ========== When `idx = 0`, this produces the following Bell state .. math:: \frac{1}{\sqrt{2}} \left( |00 \rangle + |11 \rangle \right). Using `toqito`, we can see that this yields the proper state. >>> from toqito.states.states.bell import bell >>> import numpy as np >>> bell(0) array([[0.70710678], [0. ], [0. ], [0.70710678]]) References ========== .. [WIKBELL] Wikipedia: Bell state https://en.wikipedia.org/wiki/Bell_state :param idx: A parameter in [0, 1, 2, 3] """ e_0, e_1 = ket(2, 0), ket(2, 1) if idx == 0: return 1 / np.sqrt(2) * (np.kron(e_0, e_0) + np.kron(e_1, e_1)) if idx == 1: return 1 / np.sqrt(2) * (np.kron(e_0, e_0) - np.kron(e_1, e_1)) if idx == 2: return 1 / np.sqrt(2) * (np.kron(e_0, e_1) + np.kron(e_1, e_0)) if idx == 3: return 1 / np.sqrt(2) * (np.kron(e_0, e_1) - np.kron(e_1, e_0)) raise ValueError("Invalid integer value for Bell state.")
def test_is_mub_dim_2(self): """Return True for MUB of dimension 2.""" e_0, e_1 = ket(2, 0), ket(2, 1) mub_1 = [e_0, e_1] mub_2 = [1 / np.sqrt(2) * (e_0 + e_1), 1 / np.sqrt(2) * (e_0 - e_1)] mub_3 = [ 1 / np.sqrt(2) * (e_0 + 1j * e_1), 1 / np.sqrt(2) * (e_0 - 1j * e_1) ] mubs = [mub_1, mub_2, mub_3] self.assertEqual(is_mub(mubs), True)
def test_tile_3(self): r"""Generate the Tile state for index = 3: .. math:: |\psi_3\rangle = \frac{1}{\sqrt{2}} \left(|1\rangle - |2\rangle \right) |0\rangle """ e_0, e_1, e_2 = ket(3, 0), ket(3, 1), ket(3, 2) expected_res = 1 / np.sqrt(2) * (e_1 - e_2) * e_0 res = tile(3) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_tile_0(self): r"""Generate the Tile state for index = 0: .. math:: |\psi_0 \rangle = \frac{1}{\sqrt{2}} |0 \rangle \left(|0\rangle - |1\rangle \right). """ e_0, e_1 = ket(3, 0), ket(3, 1) expected_res = 1 / np.sqrt(2) * e_0 * (e_0 - e_1) res = tile(0) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_w_state_3(self): """The 3-qubit W-state.""" e_0, e_1 = ket(2, 0), ket(2, 1) expected_res = ( 1 / np.sqrt(3) * (tensor(e_1, e_0, e_0) + tensor(e_0, e_1, e_0) + tensor(e_0, e_0, e_1)) ) res = w_state(3) bool_mat = np.isclose(res, expected_res, atol=0.2) self.assertEqual(np.all(bool_mat), True)
def test_tile_4(self): r"""Generate the Tile state for index = 4: .. math:: |\psi_4\rangle = \frac{1}{3} \left(|0\rangle + |1\rangle + |2\rangle)\right) \left(|0\rangle + |1\rangle + |2\rangle. """ e_0, e_1, e_2 = ket(3, 0), ket(3, 1), ket(3, 2) expected_res = 1 / 3 * (e_0 + e_1 + e_2) * (e_0 + e_1 + e_2) res = tile(4) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)
def test_schmidt_rank_separable_state(self): """ Computing the Schmidt rank of a separable state should yield a value equal to 1. """ e_0, e_1 = ket(2, 0), ket(2, 1) e_00 = np.kron(e_0, e_0) e_01 = np.kron(e_0, e_1) e_10 = np.kron(e_1, e_0) e_11 = np.kron(e_1, e_1) rho = 1 / 2 * (e_00 - e_01 - e_10 + e_11) rho = rho.conj().T * rho self.assertEqual(schmidt_rank(rho) == 1, True)
def test_trace_distance_same_state(self): r"""Test that: :math:`T(\rho, \sigma) = 0` iff `\rho = \sigma`.""" e_0, e_1 = ket(2, 0), ket(2, 1) e_00 = np.kron(e_0, e_0) e_11 = np.kron(e_1, e_1) u_vec = 1 / np.sqrt(2) * (e_00 + e_11) rho = u_vec * u_vec.conj().T sigma = rho res = trace_distance(rho, sigma) self.assertEqual(np.isclose(res, 0), True)
def test_trace_norm(self): """Test trace norm.""" e_0, e_1 = ket(2, 0), ket(2, 1) e_00 = np.kron(e_0, e_0) e_11 = np.kron(e_1, e_1) u_vec = 1 / np.sqrt(2) * (e_00 + e_11) rho = u_vec * u_vec.conj().T res = trace_norm(rho) _, singular_vals, _ = np.linalg.svd(rho) expected_res = float(np.sum(singular_vals)) self.assertEqual(np.isclose(res, expected_res), True)
def test_counterfeit_attack_wiesner_money(self): """Probability of counterfeit attack on Wiesner's quantum money.""" e_0, e_1 = ket(2, 0), ket(2, 1) e_p = (e_0 + e_1) / np.sqrt(2) e_m = (e_0 - e_1) / np.sqrt(2) e_000 = tensor(e_0, e_0, e_0) e_111 = tensor(e_1, e_1, e_1) e_ppp = tensor(e_p, e_p, e_p) e_mmm = tensor(e_m, e_m, e_m) q_a = (1 / 4 * (e_000 * e_000.conj().T + e_111 * e_111.conj().T + e_ppp * e_ppp.conj().T + e_mmm * e_mmm.conj().T)) res = counterfeit_attack(q_a) self.assertEqual(np.isclose(res, 3 / 4), True)
def test_weak_coin_flipping(self): """ Test for maximally entangled state. Refer to the appendix of https://arxiv.org/abs/1703.03887 """ e_0, e_1 = ket(2, 0), ket(2, 1) e_m = (e_0 - e_1) / np.sqrt(2) rho = np.kron(e_1 * e_1.conj().T, e_0 * e_0.conj().T) + np.kron( e_m * e_m.conj().T, e_1 * e_1.conj().T ) self.assertEqual( np.isclose(weak_coin_flipping(rho), np.cos(np.pi / 8) ** 2), True )
def test_tensor_n_0(self): """Test tensor n=0 times.""" e_0 = ket(2, 0) expected_res = None res = tensor(e_0, 0) self.assertEqual(res, expected_res)
def test_tensor_n_3(self): """Test tensor n=3 times.""" e_0 = ket(2, 0) expected_res = np.kron(np.kron(e_0, e_0), e_0) res = tensor(e_0, 3) bool_mat = np.isclose(res, expected_res) self.assertEqual(np.all(bool_mat), True)