def test_extract_choi_channel(self, setup_one_mode_circuit, cutoff, tol):
        """Test that Choi channel extraction works for 1 mode"""
        prog, rho, initial_state = setup_one_mode_circuit

        choi = utils.extract_channel(prog,
                                     cutoff_dim=cutoff,
                                     representation="choi")
        final_rho = np.einsum("abcd,ab -> cd", choi, initial_state)

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)
    def test_extract_choi_channel(self, setup_two_mode_circuit, cutoff, tol):
        """Test that Choi channel extraction works for 2 mode"""
        prog, rho, initial_state = setup_two_mode_circuit

        choi = utils.extract_channel(prog,
                                     cutoff_dim=cutoff,
                                     vectorize_modes=False,
                                     representation="choi")
        final_rho = np.einsum("abcdefgh,abcd -> efgh", choi, initial_state)

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)
    def test_extract_kraus_channel(self, setup_one_mode_circuit, cutoff, tol):
        """Test that Kraus channel extraction works for 1 mode"""
        prog, rho, initial_state = setup_one_mode_circuit

        kraus = utils.extract_channel(prog,
                                      cutoff_dim=cutoff,
                                      representation="kraus")
        final_rho = np.einsum("abc,cd,aed -> be", kraus, initial_state,
                              np.conj(kraus))

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)
    def test_extract_liouville_channel(self, setup_one_mode_circuit, cutoff,
                                       tol):
        """Test that Liouville channel extraction works for 1 mode"""
        prog, rho, initial_state = setup_one_mode_circuit

        liouville = utils.extract_channel(prog,
                                          cutoff_dim=cutoff,
                                          representation="liouville")
        final_rho = np.einsum("abcd,db -> ca", liouville, initial_state)

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)
    def test_extract_kraus_channel(self, setup_two_mode_circuit, cutoff, tol):
        """Test that Kraus channel extraction works for 2 mode"""
        prog, rho, initial_state = setup_two_mode_circuit

        kraus = utils.extract_channel(prog,
                                      cutoff_dim=cutoff,
                                      vectorize_modes=False,
                                      representation="kraus")
        final_rho = np.einsum("abcde,cfeg,ahfig -> bhdi", kraus, initial_state,
                              np.conj(kraus))

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)
    def test_extract_liouville_channel(self, setup_two_mode_circuit, cutoff,
                                       tol):
        """Test that Liouville channel extraction works for 2 mode"""
        prog, rho, initial_state = setup_two_mode_circuit

        liouville = utils.extract_channel(prog,
                                          cutoff_dim=cutoff,
                                          vectorize_modes=False,
                                          representation="liouville")
        final_rho = np.einsum("abcdefgh,fbhd -> eagc", liouville,
                              initial_state)

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)
    def test_extract_liouville_channel_vectorize(self, setup_two_mode_circuit,
                                                 cutoff, tol):
        """Test that Liouville channel extraction works for 2 mode vectorized"""
        prog, rho, initial_state = setup_two_mode_circuit
        rho = np.einsum("abcd->acbd", rho).reshape(cutoff**2, cutoff**2)
        initial_state = np.einsum("abcd->acbd",
                                  initial_state).reshape(cutoff**2, cutoff**2)

        liouville = utils.extract_channel(prog,
                                          cutoff_dim=cutoff,
                                          vectorize_modes=True,
                                          representation="liouville")
        final_rho = np.einsum("abcd,db -> ca", liouville, initial_state)

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)
    def test_extract_choi_channel_vectorize(self, setup_two_mode_circuit,
                                            cutoff, tol):
        """Test that Choi channel extraction works for 2 mode vectorized"""
        eng, rho, initial_state = setup_two_mode_circuit
        rho = np.einsum("abcd->acbd", rho).reshape(cutoff**2, cutoff**2)
        initial_state = np.einsum("abcd->acbd",
                                  initial_state).reshape(cutoff**2, cutoff**2)

        choi = utils.extract_channel(eng,
                                     cutoff_dim=cutoff,
                                     vectorize_modes=True,
                                     representation="choi")
        final_rho = np.einsum("abcd,ab -> cd", choi, initial_state)

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)
    def test_extract_kraus_channel_vectorize(self, setup_two_mode_circuit,
                                             cutoff, tol):
        """Test that Kraus channel extraction works for 2 mode vectorized"""
        prog, rho, initial_state = setup_two_mode_circuit
        rho = np.einsum("abcd->acbd", rho).reshape(cutoff**2, cutoff**2)
        initial_state = np.einsum("abcd->acbd",
                                  initial_state).reshape(cutoff**2, cutoff**2)

        kraus = utils.extract_channel(prog,
                                      cutoff_dim=cutoff,
                                      vectorize_modes=True,
                                      representation="kraus")
        final_rho = np.einsum("abc,cd,aed -> be", kraus, initial_state,
                              np.conj(kraus))

        assert np.allclose(final_rho, rho, atol=tol, rtol=0)