Trajectree 0.0.0__py3-none-any.whl → 0.0.1__py3-none-any.whl

trajectree/quimb/tests/test_tensor/test_tensor_1d.py

@@ -0,0 +1,1171 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+import quimb as qu
+import quimb.tensor as qtn
+
+dtypes = ["float32", "float64", "complex64", "complex128"]
+
+
+class TestMatrixProductState:
+    def test_matrix_product_state(self):
+        tensors = (
+            [np.random.rand(5, 2)]
+            + [np.random.rand(5, 5, 2) for _ in range(3)]
+            + [np.random.rand(5, 2)]
+        )
+        mps = qtn.MatrixProductState(tensors)
+        mps.check()
+        assert len(mps.tensors) == 5
+        nmps = mps.reindex_sites("foo{}", inplace=False, where=slice(0, 3))
+        assert nmps.site_ind_id == "k{}"
+        assert isinstance(nmps, qtn.MatrixProductState)
+        assert set(nmps.outer_inds()) == {"foo0", "foo1", "foo2", "k3", "k4"}
+        assert set(mps.outer_inds()) == {"k0", "k1", "k2", "k3", "k4"}
+        mps.site_ind_id = "foo{}"
+        assert set(mps.outer_inds()) == {
+            "foo0",
+            "foo1",
+            "foo2",
+            "foo3",
+            "foo4",
+        }
+        assert mps.site_inds == ("foo0", "foo1", "foo2", "foo3", "foo4")
+        assert mps.site_ind_id == "foo{}"
+        mps.show()
+
+    @pytest.mark.parametrize(
+        "dtype", [float, complex, np.complex128, np.float64, "raise"]
+    )
+    def test_rand_mps_dtype(self, dtype):
+        if dtype == "raise":
+            with pytest.raises(TypeError):
+                qtn.MPS_rand_state(10, 7, dtype=dtype)
+        else:
+            p = qtn.MPS_rand_state(10, 7, dtype=dtype)
+            assert p[0].dtype == dtype
+            assert p[7].dtype == dtype
+
+    def test_trans_invar(self):
+        with pytest.raises(ValueError):
+            psi = qtn.MPS_rand_state(10, 7, cyclic=False, trans_invar=True)
+
+        psi = qtn.MPS_rand_state(10, 7, cyclic=True, trans_invar=True)
+        z0 = psi.expec(psi.gate(qu.pauli("Z"), 0, contract=True))
+        z3 = psi.expec(psi.gate(qu.pauli("Z"), 0, contract=True))
+        z7 = psi.expec(psi.gate(qu.pauli("Z"), 0, contract=True))
+
+        assert_allclose(z0, z3)
+        assert_allclose(z3, z7)
+
+    def test_from_dense(self):
+        L = 8
+        psi = qu.rand_ket(2**L)
+        mps = qtn.MatrixProductState.from_dense(psi)
+        assert mps.tags == qtn.oset(f"I{i}" for i in range(L))
+        assert mps.site_inds == tuple(f"k{i}" for i in range(L))
+        assert mps.L == L
+        assert mps.bond_sizes() == [2, 4, 8, 16, 8, 4, 2]
+        mpod = mps.to_qarray()
+        assert qu.expec(mpod, psi) == pytest.approx(1)
+
+    def test_from_dense_low_rank(self):
+        L = 6
+        psi = qu.ghz_state(L)
+        mps = qtn.MatrixProductState.from_dense(psi, dims=[2] * L)
+        assert mps.tags == qtn.oset(f"I{i}" for i in range(L))
+        assert mps.site_inds == tuple(f"k{i}" for i in range(L))
+        assert mps.L == L
+        assert mps.bond_sizes() == [2, 2, 2, 2, 2]
+        mpod = mps.to_qarray()
+        assert qu.expec(mpod, psi) == pytest.approx(1)
+
+    def test_left_canonize_site(self):
+        a = np.random.randn(7, 2) + 1.0j * np.random.randn(7, 2)
+        b = np.random.randn(7, 7, 2) + 1.0j * np.random.randn(7, 7, 2)
+        c = np.random.randn(7, 2) + 1.0j * np.random.randn(7, 2)
+        mps = qtn.MatrixProductState([a, b, c], site_tag_id="I{}")
+
+        mps.left_canonize_site(0)
+        assert mps["I0"].shape == (2, 2)
+        assert mps["I0"].tags == qtn.oset(("I0",))
+        assert mps["I1"].tags == qtn.oset(("I1",))
+
+        U = mps["I0"].data
+        assert_allclose(U.conj().T @ U, np.eye(2), atol=1e-13)
+        assert_allclose(U @ U.conj().T, np.eye(2), atol=1e-13)
+
+        # combined two site contraction is identity also
+        mps.left_canonize_site(1)
+        ptn = (mps.H & mps) ^ ["I0", "I1"]
+        assert_allclose(ptn["I1"].data, np.eye(4), atol=1e-13)
+
+        # try normalizing the state
+        mps["I2"] /= mps["I2"].norm()
+
+        assert_allclose(abs(mps.H @ mps), 1.0)
+
+    def test_right_canonize_site(self):
+        a = np.random.randn(7, 2) + 1.0j * np.random.randn(7, 2)
+        b = np.random.randn(7, 7, 2) + 1.0j * np.random.randn(7, 7, 2)
+        c = np.random.randn(7, 2) + 1.0j * np.random.randn(7, 2)
+        mps = qtn.MatrixProductState([a, b, c], site_tag_id="I{}")
+
+        mps.right_canonize_site(2)
+        assert mps["I2"].shape == (2, 2)
+        assert mps["I2"].tags == qtn.oset(("I2",))
+        assert mps["I1"].tags == qtn.oset(("I1",))
+
+        U = mps["I2"].data
+        assert_allclose(U.conj().T @ U, np.eye(2), atol=1e-13)
+        assert_allclose(U @ U.conj().T, np.eye(2), atol=1e-13)
+
+        # combined two site contraction is identity also
+        mps.right_canonize_site(1)
+        ptn = (mps.H & mps) ^ ["I1", "I2"]
+        assert_allclose(ptn["I1"].data, np.eye(4), atol=1e-13)
+
+        # try normalizing the state
+        mps["I0"] /= mps["I0"].norm()
+
+        assert_allclose(mps.H @ mps, 1)
+
+    def test_rand_mps_left_canonize(self):
+        n = 10
+        k = qtn.MPS_rand_state(
+            n, 10, site_tag_id="foo{}", tags="bar", normalize=False
+        )
+        k.left_canonicalize_(normalize=True)
+
+        assert k.count_canonized() == (9, 0)
+
+        assert_allclose(k.H @ k, 1)
+        p_tn = (k.H & k) ^ slice(0, 9)
+        assert_allclose(p_tn["foo8"].data, np.eye(10), atol=1e-13)
+
+    def test_rand_mps_left_canonize_with_bra(self):
+        n = 10
+        k = qtn.MPS_rand_state(
+            n, 10, site_tag_id="foo{}", tags="bar", normalize=False
+        )
+        b = k.H
+        k.left_canonicalize_(normalize=True, bra=b)
+        assert_allclose(b @ k, 1)
+        p_tn = (b & k) ^ slice(0, 9)
+        assert_allclose(p_tn["foo8"].data, np.eye(10), atol=1e-13)
+
+    def test_rand_mps_right_canonize(self):
+        n = 10
+        k = qtn.MPS_rand_state(
+            n, 10, site_tag_id="foo{}", tags="bar", normalize=False
+        )
+        k.right_canonicalize_(normalize=True)
+        assert_allclose(k.H @ k, 1)
+        p_tn = (k.H & k) ^ slice(..., 0, -1)
+        assert_allclose(p_tn["foo1"].data, np.eye(10), atol=1e-13)
+
+    def test_rand_mps_right_canonize_with_bra(self):
+        n = 10
+        k = qtn.MPS_rand_state(
+            n, 10, site_tag_id="foo{}", tags="bar", normalize=False
+        )
+        b = k.H
+        k.right_canonicalize_(normalize=True, bra=b)
+        assert_allclose(b @ k, 1)
+        p_tn = (b & k) ^ slice(..., 0, -1)
+        assert_allclose(p_tn["foo1"].data, np.eye(10), atol=1e-13)
+
+    def test_rand_mps_mixed_canonize(self):
+        n = 10
+        rmps = qtn.MPS_rand_state(
+            n, 10, site_tag_id="foo{}", tags="bar", normalize=True
+        )
+
+        # move to the center
+        rmps.canonicalize_(4)
+        assert rmps.count_canonized() == (4, 5)
+        assert_allclose(rmps.H @ rmps, 1)
+        p_tn = (rmps.H & rmps) ^ slice(0, 4) ^ slice(..., 4, -1)
+        assert_allclose(p_tn["foo3"].data, np.eye(10), atol=1e-13)
+        assert_allclose(p_tn["foo5"].data, np.eye(10), atol=1e-13)
+
+        # try shifting to the right
+        rmps.shift_orthogonality_center(current=4, new=8)
+        assert_allclose(rmps.H @ rmps, 1)
+        p_tn = (rmps.H & rmps) ^ slice(0, 8) ^ slice(..., 8, -1)
+        assert_allclose(p_tn["foo7"].data, np.eye(4), atol=1e-13)
+        assert_allclose(p_tn["foo9"].data, np.eye(2), atol=1e-13)
+
+        # try shifting to the left
+        rmps.shift_orthogonality_center(current=8, new=6)
+        assert_allclose(rmps.H @ rmps, 1)
+        p_tn = (rmps.H & rmps) ^ slice(0, 6) ^ slice(..., 6, -1)
+        assert_allclose(p_tn["foo5"].data, np.eye(10), atol=1e-13)
+        assert_allclose(p_tn["foo7"].data, np.eye(8), atol=1e-13)
+
+    @pytest.mark.parametrize("dtype", dtypes)
+    def test_canonize_and_calc_current_orthog_center(self, dtype):
+        p = qtn.MPS_rand_state(20, 3, dtype=dtype)
+        co = p.calc_current_orthog_center()
+        assert co == (0, 19)
+        p.canonicalize_((5, 15), co)
+        co = p.calc_current_orthog_center()
+        assert co == (5, 15)
+        p.canonicalize_((8, 11), co)
+        co = p.calc_current_orthog_center()
+        assert co == (8, 11)
+        assert p.dtype == dtype
+
+    def test_can_change_data(self):
+        p = qtn.MPS_rand_state(3, 10)
+        assert_allclose(p.H @ p, 1)
+        p[1].modify(data=np.random.randn(10, 10, 2))
+        assert abs(p.H @ p - 1) > 1e-13
+
+    def test_can_change_data_using_subnetwork(self):
+        p = qtn.MPS_rand_state(3, 10)
+        pH = p.H
+        p.add_tag("__ket__")
+        pH.add_tag("__bra__")
+        tn = p | pH
+        assert_allclose((tn ^ ...), 1)
+        assert_allclose(
+            tn[("__ket__", "I1")].data, tn[("__bra__", "I1")].data.conj()
+        )
+        p[1].modify(data=np.random.randn(10, 10, 2))
+        assert abs((tn ^ ...) - 1) > 1e-13
+        assert not np.allclose(
+            tn[("__ket__", "I1")].data, tn[("__bra__", "I1")].data.conj()
+        )
+
+    def test_adding_mps(self):
+        p = qtn.MPS_rand_state(10, 7)
+        assert max(p["I4"].shape) == 7
+        p2 = p + p
+        assert max(p2["I4"].shape) == 14
+        assert_allclose(p2.H @ p, 2)
+        p += p
+        assert max(p["I4"].shape) == 14
+        assert_allclose(p.H @ p, 4)
+
+    @pytest.mark.parametrize("method", ["svd", "eig"])
+    @pytest.mark.parametrize("cutoff_mode", ["abs", "rel", "sum2"])
+    def test_compress_mps(self, method, cutoff_mode):
+        n = 10
+        chi = 7
+        p = qtn.MPS_rand_state(n, chi)
+        assert max(p["I4"].shape) == chi
+        p2 = p + p
+        assert max(p2["I4"].shape) == chi * 2
+        assert_allclose(p2.H @ p, 2)
+        p2.left_compress(method=method, cutoff=1e-6, cutoff_mode=cutoff_mode)
+        assert max(p2["I4"].shape) == chi
+        assert_allclose(p2.H @ p, 2)
+        assert p2.count_canonized() == (n - 1, 0)
+
+    def test_compress_mps_right(self):
+        p = qtn.MPS_rand_state(10, 7)
+        assert max(p["I4"].shape) == 7
+        p2 = p + p
+        assert max(p2["I4"].shape) == 14
+        assert_allclose(p2.H @ p, 2)
+        p2.right_compress()
+        assert max(p2["I4"].shape) == 7
+        assert_allclose(p2.H @ p, 2)
+
+    @pytest.mark.parametrize("method", ["svd", "eig"])
+    def test_compress_trim_max_bond(self, method):
+        p0 = qtn.MPS_rand_state(20, 20)
+        p = p0.copy()
+        p.compress(method=method, renorm=True)
+        assert max(p["I4"].shape) == 20
+        p.compress(max_bond=13, method=method, renorm=True)
+        assert max(p["I4"].shape) == 13
+        assert_allclose(p.H @ p, p0.H @ p0)
+
+    def test_compress_form(self):
+        p = qtn.MPS_rand_state(20, 20)
+        p.compress("left")
+        assert p.count_canonized() == (19, 0)
+        p.compress("right")
+        assert p.count_canonized() == (0, 19)
+        p.compress(7)
+        assert p.count_canonized() == (7, 12)
+        p = qtn.MPS_rand_state(20, 20)
+        p.compress("flat", absorb="left")
+        assert p.count_canonized() == (0, 0)
+
+    def test_compress_site(self):
+        psi = qtn.MPS_rand_state(10, 7)
+        psi.compress_site(3, max_bond=1)
+        assert psi.bond_sizes() == [2, 4, 1, 1, 7, 7, 7, 4, 2]
+        assert psi.calc_current_orthog_center() == (3, 3)
+
+        psi = qtn.MPS_rand_state(10, 7)
+        psi.compress_site(0, max_bond=1)
+        assert psi.bond_sizes() == [1, 7, 7, 7, 7, 7, 7, 4, 2]
+        assert psi.calc_current_orthog_center() == (0, 0)
+
+        psi = qtn.MPS_rand_state(10, 7)
+        psi.compress_site(9, max_bond=1)
+        assert psi.bond_sizes() == [2, 4, 7, 7, 7, 7, 7, 7, 1]
+        assert psi.calc_current_orthog_center() == (9, 9)
+
+    @pytest.mark.parametrize("method", ["svd", "eig"])
+    @pytest.mark.parametrize("form", ["left", "right", "raise"])
+    def test_add_and_compress_mps(self, method, form):
+        p = qtn.MPS_rand_state(10, 7)
+        assert max(p["I4"].shape) == 7
+
+        if form == "raise":
+            with pytest.raises(ValueError):
+                p.add_MPS(
+                    p, compress=True, method=method, form=form, cutoff=1e-6
+                )
+            return
+
+        p2 = p.add_MPS(p, compress=True, method=method, form=form, cutoff=1e-6)
+        assert max(p2["I4"].shape) == 7
+        assert_allclose(p2.H @ p, 2, rtol=1e-5)
+
+    def test_subtract(self):
+        a, b, c = (qtn.MPS_rand_state(10, 7) for _ in "abc")
+        ab = a.H @ b
+        ac = a.H @ c
+        abmc = a.H @ (b - c)
+        assert_allclose(ab - ac, abmc)
+
+    def test_subtract_inplace(self):
+        a, b, c = (qtn.MPS_rand_state(10, 7) for _ in "abc")
+        ab = a.H @ b
+        ac = a.H @ c
+        b -= c
+        abmc = a.H @ b
+        assert_allclose(ab - ac, abmc)
+
+    def test_amplitude(self):
+        mps = qtn.MPS_rand_state(10, 7)
+        k = mps.to_qarray()
+        idx = np.random.randint(0, k.shape[0])
+        c_b = mps.amplitude(f"{idx:0>10b}")
+        assert k[idx, 0] == pytest.approx(c_b)
+
+    def test_schmidt_values_entropy_gap_simple(self):
+        n = 12
+        p = qtn.MPS_rand_state(n, 16)
+        p.right_canonicalize_()
+        svns = []
+        sgs = []
+        info = {}
+        for i in range(1, n):
+            sgs.append(p.schmidt_gap(i, info=info))
+            svns.append(p.entropy(i, info=info))
+
+        pd = p.to_qarray()
+        ex_svns = [
+            qu.entropy_subsys(pd, [2] * n, range(i)) for i in range(1, n)
+        ]
+        ex_sgs = [qu.schmidt_gap(pd, [2] * n, range(i)) for i in range(1, n)]
+        assert_allclose(ex_svns, svns)
+        assert_allclose(ex_sgs, sgs)
+
+    def test_magnetization(self):
+        binary = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
+        p = qtn.MPS_computational_state(binary)
+        mzs = [p.magnetization(i) for i in range(len(binary))]
+        assert_allclose(mzs, 0.5 - np.array(binary))
+
+    @pytest.mark.parametrize("rescale", [False, True])
+    @pytest.mark.parametrize(
+        "keep", [(2, 3, 4, 6, 8), slice(-2, 4), slice(3, -1, -1), [1]]
+    )
+    def test_partial_trace(self, rescale, keep):
+        n = 10
+        p = qtn.MPS_rand_state(n, 7)
+        r = p.partial_trace_to_mpo(
+            keep=keep, upper_ind_id="u{}", rescale_sites=rescale
+        )
+        rd = r.to_qarray()
+        if isinstance(keep, slice):
+            keep = p.slice2sites(keep)
+        else:
+            if rescale:
+                if keep == [1]:
+                    assert r.lower_inds_present == ("u0",)
+                    assert r.upper_inds_present == ("k0",)
+                else:
+                    assert r.lower_inds_present == (
+                        "u0",
+                        "u1",
+                        "u2",
+                        "u3",
+                        "u4",
+                    )
+                    assert r.upper_inds_present == (
+                        "k0",
+                        "k1",
+                        "k2",
+                        "k3",
+                        "k4",
+                    )
+            else:
+                if keep == [1]:
+                    assert r.lower_inds_present == ("u1",)
+                    assert r.upper_inds_present == ("k1",)
+                else:
+                    assert r.lower_inds_present == (
+                        "u2",
+                        "u3",
+                        "u4",
+                        "u6",
+                        "u8",
+                    )
+                    assert r.upper_inds_present == (
+                        "k2",
+                        "k3",
+                        "k4",
+                        "k6",
+                        "k8",
+                    )
+        assert_allclose(r.trace(), 1.0)
+        assert qu.isherm(rd)
+        pd = p.to_qarray()
+        rdd = pd.ptr([2] * n, keep=keep)
+        assert_allclose(rd, rdd)
+
+    def test_bipartite_schmidt_state(self):
+        psi = qtn.MPS_rand_state(16, 5)
+        psid = psi.to_qarray()
+        eln = qu.logneg(psid, [2**7, 2**9])
+
+        s_d_ket = psi.bipartite_schmidt_state(7, get="ket-dense")
+        ln_d_ket = qu.logneg(s_d_ket, [5, 5])
+        assert_allclose(eln, ln_d_ket, rtol=1e-5)
+
+        s_d_rho = psi.bipartite_schmidt_state(7, get="rho-dense")
+        ln_d_rho = qu.logneg(s_d_rho, [5, 5])
+        assert_allclose(eln, ln_d_rho, rtol=1e-5)
+
+        T_s_ket = psi.bipartite_schmidt_state(7, get="ket")
+        assert set(T_s_ket.inds) == {"kA", "kB"}
+        assert_allclose(T_s_ket.H @ T_s_ket, 1.0)
+
+        T_s_rho = psi.bipartite_schmidt_state(7, get="rho")
+        assert set(T_s_rho.outer_inds()) == {"kA", "kB", "bA", "bB"}
+        assert_allclose(T_s_rho.H @ T_s_rho, 1.0)
+
+    @pytest.mark.parametrize(
+        "method", ["isvd", "svds", ("isvd", "eigsh"), ("isvd", "cholesky")]
+    )
+    @pytest.mark.parametrize("cyclic", [True, False])
+    @pytest.mark.parametrize(
+        "sysa", [range(0, 10), range(10, 20), range(20, 30), range(0, 30)]
+    )
+    @pytest.mark.parametrize(
+        "sysb", [range(30, 40), range(40, 50), range(50, 60), range(30, 60)]
+    )
+    def test_partial_trace_compress(self, method, cyclic, sysa, sysb):
+        k = qtn.MPS_rand_state(60, 5, cyclic=cyclic)
+        kws = dict(sysa=sysa, sysb=sysb, eps=1e-6, method=method, verbosity=2)
+        rhoc_ab = k.partial_trace_compress(**kws)
+        assert set(rhoc_ab.outer_inds()) == {"kA", "kB", "bA", "bB"}
+        inds = ["kA", "kB"], ["bA", "bB"]
+        x = rhoc_ab.trace(*inds)
+        assert_allclose(1.0, x, rtol=1e-3)
+
+    @pytest.mark.parametrize("cyclic", [True, False])
+    def test_known_bad_case(self, cyclic):
+        k = qtn.MPS_rand_state(5, 10, cyclic=cyclic)
+        rhoc_ab = k.partial_trace_compress(sysa=range(2), sysb=range(2, 4))
+        inds = ["kA", "kB"], ["bA", "bB"]
+        x = rhoc_ab.trace(*inds)
+        assert_allclose(1.0, x, rtol=1e-3)
+
+    @pytest.mark.parametrize(
+        "block",
+        [
+            0,
+            20,
+            39,
+            slice(0, 5),
+            slice(20, 25),
+            slice(35, 40),
+            slice(38, 42),
+            slice(-3, 2),
+        ],
+    )
+    @pytest.mark.parametrize("dtype", [float, complex])
+    def test_canonize_cyclic(self, dtype, block):
+        k = qtn.MPS_rand_state(40, 10, dtype=dtype, cyclic=True)
+        b = k.H
+        k.add_tag("KET")
+        b.add_tag("BRA")
+        kb = b | k
+
+        assert not np.allclose(k[block].H @ k[block], 1.0)
+        assert not np.allclose(b[block].H @ b[block], 1.0)
+        k.canonize_cyclic(block, bra=b)
+        assert_allclose(k[block].H @ k[block], 1.0, rtol=2e-4)
+        assert_allclose(b[block].H @ b[block], 1.0, rtol=2e-4)
+
+        ii = kb.select(block, which="!any") ^ all
+
+        if isinstance(block, slice):
+            start, stop = block.start, block.stop
+        else:
+            start, stop = block, block + 1
+
+        assert len(kb.select_tensors(block, "any")) == 2 * (stop - start)
+
+        (ul,) = qtn.bonds(
+            kb[k.site_tag(start - 1), "BRA"], kb[k.site_tag(start), "BRA"]
+        )
+        (ur,) = qtn.bonds(
+            kb[k.site_tag(stop - 1), "BRA"], kb[k.site_tag(stop), "BRA"]
+        )
+        (ll,) = qtn.bonds(
+            kb[k.site_tag(start - 1), "KET"], kb[k.site_tag(start), "KET"]
+        )
+        (lr,) = qtn.bonds(
+            kb[k.site_tag(stop - 1), "KET"], kb[k.site_tag(stop), "KET"]
+        )
+
+        ii = ii.to_qarray((ul, ur), (ll, lr))
+        assert_allclose(ii, np.eye(ii.shape[0]), rtol=0.001, atol=0.001)
+
+    @pytest.mark.parametrize("bsz", [1, 2])
+    @pytest.mark.parametrize("propagate_tags", [False, True])
+    @pytest.mark.parametrize("contract", [False, True])
+    def test_gate_no_contract(self, bsz, propagate_tags, contract):
+        p = qtn.MPS_rand_state(5, 7, tags={"PSI0"})
+        q = p.copy()
+        G = qu.rand_uni(2**bsz)
+        p = p.gate_(
+            G,
+            where=[i for i in range(2, 2 + bsz)],
+            tags="G",
+            contract=contract,
+            propagate_tags=propagate_tags,
+        )
+        TG = p["G"]
+        if propagate_tags or contract:
+            assert p.site_tag(2) in TG.tags
+        assert ("PSI0" in TG.tags) == (propagate_tags is True) or contract
+        assert (p.H & p) ^ all == pytest.approx(1.0)
+        assert abs((q.H & p) ^ all) < 1.0
+        assert len(p.tensors) == 6 - int(contract) * bsz
+        assert set(p.outer_inds()) == {f"k{i}" for i in range(5)}
+
+    @pytest.mark.parametrize(
+        "propagate_tags", [False, "sites", "register", True]
+    )
+    def test_gate_split_gate(self, propagate_tags):
+        p = qtn.MPS_rand_state(5, 7, tags={"PSI0"})
+        q = p.copy()
+        G = qu.CNOT()
+        p = p.gate_(
+            G,
+            where=[i for i in range(2, 4)],
+            tags="G",
+            contract="split-gate",
+            propagate_tags=propagate_tags,
+        )
+
+        TG = sorted(p["G"], key=lambda t: sorted(t.tags))
+
+        if propagate_tags is False:
+            assert TG[0].tags == qtn.oset(("G",))
+            assert TG[1].tags == qtn.oset(("G",))
+
+        elif propagate_tags == "register":
+            assert TG[0].tags == qtn.oset(["G", "I2"])
+            assert TG[1].tags == qtn.oset(["G", "I3"])
+
+        elif propagate_tags == "sites":
+            assert TG[0].tags == qtn.oset(["G", "I2", "I3"])
+            assert TG[1].tags == qtn.oset(["G", "I2", "I3"])
+
+        elif propagate_tags is True:
+            assert TG[0].tags == qtn.oset(["PSI0", "G", "I2", "I3"])
+            assert TG[1].tags == qtn.oset(["PSI0", "G", "I2", "I3"])
+
+        assert (p.H & p) ^ all == pytest.approx(1.0)
+        assert abs((q.H & p) ^ all) < 1.0
+        assert len(p.tensors) == 7
+        assert set(p.outer_inds()) == {f"k{i}" for i in range(5)}
+
+    def test_gate_swap_and_split_bond_sizes(self):
+        n = 10
+        p = qtn.MPS_computational_state("0" * n)
+        assert p.bond_sizes() == [1] * (n - 1)
+        G = qu.rand_uni(4)
+        p.gate_(G, (1, n - 2), contract="swap+split")
+        assert p.bond_sizes() == [1] + [2] * (n - 3) + [1]
+
+    def test_gate_swap_and_split_matches(self):
+        k = qtn.MPS_rand_state(6, 7)
+        kr = k.copy()
+
+        gates = [qu.rand_uni(4) for _ in range(3)]
+        wheres = [(0, 5), (3, 2), (4, 1)]
+
+        for G, (i, j) in zip(gates, wheres):
+            k.gate_(G, (i, j), contract="swap+split")
+            kr.gate_inds_(G, (k.site_ind(i), k.site_ind(j)))
+
+        assert_allclose(k.to_dense(), kr.to_dense())
+
+    def test_flip(self):
+        p = qtn.MPS_rand_state(5, 3)
+        pf = p.flip()
+        # we want a single index per dimension, not all combined into one
+        inds = [[ix] for ix in p.site_inds]
+        assert_allclose(p.to_qarray(*inds), pf.to_qarray(*inds).transpose())
+
+    def test_correlation(self):
+        ghz = (
+            qtn.MPS_computational_state("0000")
+            + qtn.MPS_computational_state("1111")
+        ) / 2**0.5
+
+        assert ghz.correlation(qu.pauli("Z"), 0, 1) == pytest.approx(1.0)
+        assert ghz.correlation(qu.pauli("Z"), 1, 2) == pytest.approx(1.0)
+        assert ghz.correlation(qu.pauli("Z"), 3, 1) == pytest.approx(1.0)
+        assert ghz.correlation(
+            qu.pauli("Z"), 3, 1, B=qu.pauli("Y")
+        ) == pytest.approx(0.0)
+
+        assert ghz.H @ ghz == pytest.approx(1.0)
+
+    def test_gate_split(self):
+        psi = qtn.MPS_rand_state(10, 3)
+        psi2 = psi.copy()
+        G = qu.eye(2) & qu.eye(2)
+        psi.gate_split_(G, (2, 3), cutoff=0)
+        assert psi.bond_size(2, 3) == 6
+        assert psi.H @ psi2 == pytest.approx(1.0)
+
+        # check a unitary application
+        G = qu.rand_uni(2**2)
+        psi.gate_split_(G, (7, 8))
+        psi.compress()
+        assert psi.bond_size(2, 3) == 3
+        assert psi.bond_size(7, 8) > 3
+        assert psi.H @ psi == pytest.approx(1.0)
+        assert abs(psi2.H @ psi) < 1.0
+
+        # check matches dense application of gate
+        psid = psi2.to_qarray()
+        Gd = qu.ikron(G, [2] * 10, (7, 8))
+        assert psi.to_qarray().H @ (Gd @ psid) == pytest.approx(1.0)
+
+    def test_swap_far_sites(self):
+        psi = qtn.MPS_rand_state(7, 2)
+        for i, j in [(0, 6), (6, 1), (5, 2)]:
+            k1 = psi.to_qarray(
+                [
+                    psi.site_ind(j if site == i else i if site == j else site)
+                    for site in psi.sites
+                ]
+            )
+            k2 = psi.swap_sites_with_compress(i, j).to_qarray()
+            assert qu.fidelity(k1, k2) == pytest.approx(1.0)
+
+    def test_swap_gating(self):
+        psi0 = qtn.MPS_rand_state(20, 5)
+        CNOT = qu.controlled("not")
+        psi0XX = psi0.gate(CNOT, (4, 13))
+        psi0XX_s = psi0.gate_with_auto_swap(CNOT, (4, 13))
+        assert psi0XX.H @ psi0XX_s == pytest.approx(1.0)
+
+    def test_auto_split_detection(self):
+        psi0 = qtn.MPS_computational_state("00")
+        CNOT = qu.controlled("not")
+        ISWAP = qu.iswap()
+        G = qu.rand_uni(4)
+
+        opts = {"contract": "auto-split-gate", "where": (0, 1)}
+
+        psi_cnot = psi0.gate(CNOT, **opts)
+        psi_iswap = psi0.gate(ISWAP, **opts)
+        psi_G = psi0.gate(G, **opts)
+
+        assert (
+            psi_cnot.max_bond()
+            == psi_iswap.max_bond()
+            == psi_G.max_bond()
+            == 2
+        )
+
+        assert len(psi_cnot.tensors) == len(psi_iswap.tensors) == 4
+        assert len(psi_G.tensors) == 3
+
+    @pytest.mark.parametrize("cur_orthog", (None, 3))
+    @pytest.mark.parametrize("site", (0, 5, 9))
+    @pytest.mark.parametrize("outcome", (None, 2))
+    @pytest.mark.parametrize("renorm", (True, False))
+    @pytest.mark.parametrize("remove", (True, False))
+    def test_mps_measure(self, cur_orthog, site, outcome, renorm, remove):
+        psi = qtn.MPS_rand_state(10, 7, phys_dim=3, dtype=complex)
+        if cur_orthog:
+            psi.canonicalize_(cur_orthog)
+        outcome, psim = psi.measure(
+            site,
+            outcome=outcome,
+            cur_orthog=cur_orthog,
+            renorm=renorm,
+            remove=remove,
+        )
+        newL = 10 - int(remove)
+        assert psim.L == newL
+        assert psim.num_tensors == newL
+        assert set(psim.site_tags) == {f"I{i}" for i in range(newL)}
+        assert set(psim.site_inds) == {f"k{i}" for i in range(newL)}
+        if renorm:
+            assert psim.H @ psim == pytest.approx(1.0)
+        else:
+            assert 0.0 < psim.H @ psim < 1.0
+        new_can_cen = min(site, newL - 1)
+        t = psim[new_can_cen]
+        if renorm:
+            assert t.H @ t == pytest.approx(1.0)
+        else:
+            0.0 < t.H @ t < 1.0
+
+    def test_measure_known_outcome(self):
+        mps = qtn.MPS_computational_state("010101")
+        assert mps.measure_(3, get="outcome") == 1
+
+    def test_permute_arrays(self):
+        mps = qtn.MPS_rand_state(7, 5)
+        k0 = mps.to_qarray()
+        mps.canonicalize_(3)
+        mps.permute_arrays("prl")
+        assert mps[0].shape == (2, 2)
+        assert mps[1].shape == (2, 4, 2)
+        assert mps[2].shape == (2, 5, 4)
+        kf = mps.to_qarray()
+        assert qu.fidelity(k0, kf) == pytest.approx(1.0)
+
+    @pytest.mark.parametrize("where", [(7, 2, 4), (0, 1), (6, 7), (0, 3, 7)])
+    @pytest.mark.parametrize("phys_dim", [2, 3])
+    def test_gate_non_local(self, where, phys_dim):
+        psi = qtn.MPS_rand_state(8, 3, phys_dim=phys_dim, dtype="complex128")
+        G = qu.rand_uni(phys_dim ** len(where))
+        Gpsi = psi.gate_nonlocal(G, where=where)
+        assert Gpsi.H @ Gpsi == pytest.approx(1.0)
+        assert Gpsi.distance_normalized(
+            psi.gate(G, where, contract=False)
+        ) == pytest.approx(0.0, abs=1e-6)
+
+    def test_sample_configuration(self):
+        psi = qtn.MPS_rand_state(10, 7)
+        config, omega = psi.sample_configuration()
+        assert len(config) == 10
+        assert abs(
+            psi.isel(
+                {psi.site_ind(i): xi for i, xi in enumerate(config)}
+            ).contract()
+        ) ** 2 == pytest.approx(omega)
+
+    def test_sample_seed(self):
+        psi = qtn.MPS_rand_state(10, 7)
+        configs = [
+            "".join(map(str, config))
+            for config, _ in psi.sample(10, seed=1234)
+        ]
+        assert len(set(configs)) > 1
+
+    def test_compute_local_expectation(self):
+        psi = qtn.MPS_rand_state(10, 7, dtype="complex128")
+        terms = {(i, i + 1): qu.rand_herm(4) for i in range(9)}
+
+        ex = psi.compute_local_expectation_exact(terms)
+        xa = psi.compute_local_expectation(terms, method="canonical")
+        assert xa == pytest.approx(ex)
+        xb = psi.compute_local_expectation(terms, method="envs")
+        assert xb == pytest.approx(ex)
+
+
+class TestMatrixProductOperator:
+    @pytest.mark.parametrize("cyclic", [False, True])
+    def test_matrix_product_operator(self, cyclic):
+        end_shape = (5, 5, 2, 2) if cyclic else (5, 2, 2)
+
+        tensors = (
+            [np.random.rand(*end_shape)]
+            + [np.random.rand(5, 5, 2, 2) for _ in range(3)]
+            + [np.random.rand(*end_shape)]
+        )
+        mpo = qtn.MatrixProductOperator(tensors)
+
+        mpo.show()
+        assert len(mpo.tensors) == 5
+        assert mpo.upper_inds == ("k0", "k1", "k2", "k3", "k4")
+        assert mpo.lower_inds == ("b0", "b1", "b2", "b3", "b4")
+        op = mpo ^ ...
+        # this would rely on left to right contraction if not in set form
+        assert set(op.inds) == {
+            "k0",
+            "b0",
+            "k1",
+            "b1",
+            "k2",
+            "b2",
+            "k3",
+            "b3",
+            "k4",
+            "b4",
+        }
+
+        assert set(mpo.site_tags) == {f"I{i}" for i in range(5)}
+        assert all(f"I{i}" in mpo.tags for i in range(5))
+        mpo.site_tag_id = "TEST1,{}"
+        assert set(mpo.site_tags) == {f"TEST1,{i}" for i in range(5)}
+        assert not any(f"I{i}" in mpo.tags for i in range(5))
+        assert all(f"TEST1,{i}" in mpo.tags for i in range(5))
+
+    @pytest.mark.parametrize("cyclic", [False, True])
+    def test_compress_mpo(self, cyclic):
+        A = qtn.MPO_rand(12, 5, cyclic=cyclic)
+        assert all(b == 5 for b in A.bond_sizes())
+        A.expand_bond_dimension(10)
+        assert all(b == 10 for b in A.bond_sizes())
+        A.compress()
+        assert all(b in (4, 5) for b in A.bond_sizes())
+
+    def test_add_mpo(self):
+        h = qtn.MPO_rand_herm(12, 5)
+        h2 = h + h
+        assert max(h2[6].shape) == 10
+        t = h.trace()
+        t2 = h2.trace()
+        assert_allclose(2 * t, t2)
+
+    def test_adding_mpo(self):
+        h = qtn.MPO_ham_heis(6)
+        hd = h.to_qarray()
+        assert_allclose(h @ h.H, (hd @ hd.H).tr())
+        h2 = h + h
+        assert_allclose(h2 @ h2.H, (hd @ hd.H).tr() * 4)
+        h2.right_compress()
+        assert_allclose(h2 @ h2.H, (hd @ hd.H).tr() * 4)
+        assert max(h2["I3"].shape) == 5
+
+    @pytest.mark.parametrize("cyclic", (False, True))
+    def test_subtract_mpo(self, cyclic):
+        a, b = (
+            qtn.MPO_rand(13, 7, cyclic=cyclic),
+            qtn.MPO_rand(13, 7, cyclic=cyclic),
+        )
+        x1 = a.trace() - b.trace()
+        assert_allclose(x1, (a - b).trace())
+        a -= b
+        assert_allclose(x1, a.trace())
+
+    @pytest.mark.parametrize("cyclic", (False, True))
+    @pytest.mark.parametrize("rand_strength", (0, 1e-9))
+    def test_expand_mpo(self, cyclic, rand_strength):
+        h = qtn.MPO_ham_heis(12, cyclic=cyclic)
+        assert h[0].dtype == float
+        he = h.expand_bond_dimension(13, rand_strength=rand_strength)
+        assert h[0].dtype == float
+        assert max(he[6].shape) == 13
+
+        if cyclic:
+            assert he.bond_size(0, -1) == 13
+
+        t = h.trace()
+        te = he.trace()
+        assert_allclose(t, te)
+
+    @pytest.mark.parametrize("cyclic", (False, True))
+    @pytest.mark.parametrize("rand_strength", (0, 1e-9))
+    def test_expand_mpo_limited(self, cyclic, rand_strength):
+        h = qtn.MPO_ham_heis(12, cyclic=cyclic)
+        he = h.expand_bond_dimension(3, rand_strength=rand_strength)
+        # should do nothing
+        assert max(he[6].shape) == 5
+
+    def test_mpo_identity(self):
+        k = qtn.MPS_rand_state(13, 7)
+        b = qtn.MPS_rand_state(13, 7)
+        o1 = k @ b
+        i = qtn.MPO_identity(13)
+        k, i, b = qtn.tensor_network_align(k, i, b)
+        o2 = (k & i & b) ^ ...
+        assert_allclose(o1, o2)
+
+    @pytest.mark.parametrize("cyclic", [False, True])
+    @pytest.mark.parametrize("dtype", (complex, float))
+    def test_mpo_rand_herm_and_trace(self, dtype, cyclic):
+        op = qtn.MPO_rand_herm(
+            20, bond_dim=5, phys_dim=3, dtype=dtype, cyclic=cyclic
+        )
+        assert_allclose(op.H @ op, 1.0)
+        tr_val = op.trace()
+        assert tr_val != 0.0
+        assert_allclose(tr_val.imag, 0.0, atol=1e-14)
+
+    @pytest.mark.parametrize("cyclic", [False, True])
+    def test_mpo_rand_herm_trace_and_identity_like(self, cyclic):
+        op = qtn.MPO_rand_herm(
+            20, bond_dim=5, phys_dim=3, upper_ind_id="foo{}", cyclic=cyclic
+        )
+        t = op.trace()
+        assert t != 0.0
+        Id = qtn.MPO_identity_like(op)
+        assert_allclose(Id.trace(), 3**20)
+        Id[0] *= 3 / 3**20
+        op += Id
+        assert_allclose(op.trace(), t + 3)
+
+    def test_partial_transpose(self):
+        p = qtn.MPS_rand_state(8, 10)
+        r = p.partial_trace_to_mpo([2, 3, 4, 5, 6, 7])
+        rd = r.to_qarray()
+
+        assert qu.isherm(rd)
+        assert qu.ispos(rd)
+
+        rpt = r.partial_transpose([0, 1, 2])
+        rptd = rpt.to_qarray()
+
+        upper_inds = tuple(f"b{i}" for i in range(6))
+        lower_inds = tuple(f"k{i}" for i in range(6))
+        outer_inds = rpt.outer_inds()
+        assert all(i in outer_inds for i in upper_inds + lower_inds)
+
+        assert qu.isherm(rptd)
+        assert not qu.ispos(rptd)
+
+    def test_upper_lower_ind_id_guard(self):
+        A = qtn.MPO_rand(8, 5)
+        with pytest.raises(ValueError):
+            A.upper_ind_id = "b{}"
+        with pytest.raises(ValueError):
+            A.lower_ind_id = "k{}"
+
+    @pytest.mark.parametrize("cyclic", (False, True))
+    def test_apply_mpo(self, cyclic):
+        A = qtn.MPO_rand(8, 5, cyclic=cyclic)
+        B = qtn.MPO_rand(
+            8, 5, upper_ind_id="q{}", lower_ind_id="w{}", cyclic=cyclic
+        )
+        C = A.apply(B)
+        assert C.max_bond() == 25
+        assert C.upper_ind_id == "q{}"
+        assert C.lower_ind_id == "w{}"
+        Ad, Bd, Cd = A.to_qarray(), B.to_qarray(), C.to_qarray()
+        assert_allclose(Ad @ Bd, Cd)
+
+    @pytest.mark.parametrize("cyclic", (False, True))
+    @pytest.mark.parametrize("site_ind_id", ("k{}", "test{}"))
+    def test_apply_mps(self, cyclic, site_ind_id):
+        A = qtn.MPO_rand(8, 5, cyclic=cyclic)
+        x = qtn.MPS_rand_state(8, 4, site_ind_id=site_ind_id, cyclic=cyclic)
+        y = A.apply(x)
+        assert y.max_bond() == 20
+        assert isinstance(y, qtn.MatrixProductState)
+        assert len(y.tensors) == 8
+        assert y.site_ind_id == site_ind_id
+        Ad, xd, yd = A.to_qarray(), x.to_qarray(), y.to_qarray()
+        assert_allclose(Ad @ xd, yd)
+
+    def test_permute_arrays(self):
+        mpo = qtn.MPO_rand(4, 3)
+        A0 = mpo.to_qarray()
+        mpo.permute_arrays("drul")
+        assert mpo[0].shape == (2, 3, 2)
+        assert mpo[1].shape == (2, 3, 2, 3)
+        Af = mpo.to_qarray()
+        assert_allclose(A0, Af)
+
+    def test_from_dense(self):
+        A = qu.rand_uni(2**4)
+        mpo = qtn.MatrixProductOperator.from_dense(A)
+        assert mpo.L == 4
+        assert_allclose(A, mpo.to_dense())
+
+    def test_from_dense_sites(self):
+        dims = [2, 3, 4, 5]
+        A = qu.rand_uni(2 * 3 * 4 * 5)
+        sites = [3, 1, 0, 2]
+        mpo = qtn.MatrixProductOperator.from_dense(A, dims, sites=sites)
+        assert mpo.L == 4
+        perm = [sites.index(i) for i in range(4)]
+        assert_allclose(qu.permute(A, dims, perm), mpo.to_dense())
+
+    def test_fill_empty_sites(self):
+        mps = qtn.MPS_rand_state(7, 3)
+        k = mps.to_dense()
+        A, B, C = (qu.rand_uni(2) for _ in range(3))
+        Ak = qu.ikron((A, B, C), [2] * 7, [5, 2, 3]) @ k
+
+        ABC = A & B & C
+        mpo = qtn.MatrixProductOperator.from_dense(ABC, sites=[5, 2, 3], L=7)
+        assert mpo.bond_size(2, 3) == 1
+        assert mpo.num_tensors == 3
+        assert mpo[3].bonds(mpo[5])
+        mpo.fill_empty_sites_("minimal")
+        assert not mpo[3].bonds(mpo[5])
+        assert mpo.num_tensors == 4
+        assert_allclose(
+            mps.gate_with_op_lazy(mpo).to_dense(),
+            Ak,
+        )
+        mpo.fill_empty_sites_("full")
+        assert mpo.num_tensors == 7
+        assert_allclose(
+            mps.gate_with_op_lazy(mpo).to_dense(),
+            Ak,
+        )
+
+
+# --------------------------------------------------------------------------- #
+#                         Test specific 1D instances                          #
+# --------------------------------------------------------------------------- #
+
+
+class TestSpecificStatesOperators:
+    @pytest.mark.parametrize("cyclic", [False, True])
+    def test_rand_ket_mps(self, cyclic):
+        n = 10
+        rmps = qtn.MPS_rand_state(
+            n, 10, site_tag_id="foo{}", tags="bar", cyclic=cyclic
+        )
+        assert rmps[0].tags == qtn.oset(["foo0", "bar"])
+        assert rmps[3].tags == qtn.oset(["foo3", "bar"])
+        assert rmps[-1].tags == qtn.oset(["foo9", "bar"])
+
+        rmpsH_rmps = rmps.H & rmps
+        assert len(rmpsH_rmps.tag_map["foo0"]) == 2
+        assert len(rmpsH_rmps.tag_map["bar"]) == n * 2
+
+        assert_allclose(rmps.H @ rmps, 1)
+        c = (rmps.H & rmps) ^ slice(0, 5) ^ slice(9, 4, -1) ^ slice(4, 6)
+        assert_allclose(c, 1)
+
+        assert rmps[0].data.ndim == (3 if cyclic else 2)
+        assert rmps[-1].data.ndim == (3 if cyclic else 2)
+
+    def test_mps_computation_state(self):
+        p = qtn.MPS_neel_state(10)
+        pd = qu.neel_state(10)
+        assert_allclose(p.to_qarray(), pd)
+
+    def test_zero_state(self):
+        z = qtn.MPS_zero_state(21, 7)
+        p = qtn.MPS_rand_state(21, 13)
+        assert_allclose(p.H @ z, 0.0)
+        assert_allclose(p.H @ p, 1.0)
+        zp = z + p
+        assert max(zp[13].shape) == 20
+        assert_allclose(zp.H @ p, 1.0)
+
+    @pytest.mark.parametrize("cyclic", [False, True])
+    @pytest.mark.parametrize("j", [7 / 11, 1, (0.2, 0.3, 0.4)])
+    @pytest.mark.parametrize("bz", [0, 7 / 11, 1])
+    @pytest.mark.parametrize("n", [2, 3, 4])
+    def test_mpo_site_ham_heis(self, cyclic, j, bz, n):
+        hh_mpo = qtn.MPO_ham_heis(n, tags=["foo"], cyclic=cyclic, j=j, bz=bz)
+        assert hh_mpo[0].tags == qtn.oset(["I0", "foo"])
+        assert hh_mpo[1].tags == qtn.oset(["I1", "foo"])
+        assert hh_mpo[-1].tags == qtn.oset([f"I{n - 1}", "foo"])
+        assert hh_mpo.shape == (2,) * 2 * n
+        hh_ex = qu.ham_heis(n, cyclic=cyclic, j=j, b=bz)
+        assert_allclose(
+            qu.eigvalsh(hh_ex), qu.eigvalsh(hh_mpo.to_qarray()), atol=1e-13
+        )
+
+    def test_mpo_zeros(self):
+        mpo0 = qtn.MPO_zeros(10)
+        assert mpo0.trace() == 0.0
+        assert mpo0.H @ mpo0 == 0.0
+
+    @pytest.mark.parametrize("cyclic", (False, True))
+    def test_mpo_zeros_like(self, cyclic):
+        A = qtn.MPO_rand(10, 7, phys_dim=3, normalize=False, cyclic=cyclic)
+        Z = qtn.MPO_zeros_like(A)
+        assert A @ Z == 0.0
+        assert Z.cyclic == cyclic
+        x1 = A.trace()
+        x2 = (A + Z).trace()
+        assert_allclose(x1, x2)
+
+
+class TestDense1D:
+    def test_simple(self):
+        n = 10
+        d_psi = qu.computational_state("0" * n)
+
+        t_psi = qtn.Dense1D(d_psi)
+        assert set(t_psi.outer_inds()) == {f"k{i}" for i in range(n)}
+        assert t_psi.tags == qtn.oset(f"I{i}" for i in range(n))
+
+        for i in range(n):
+            assert t_psi.H @ t_psi.gate(qu.pauli("Z"), i) == pytest.approx(1)
+
+        for i in range(n):
+            t_psi.gate_(qu.hadamard(), i)
+
+        assert len(t_psi.tensors) == n + 1
+
+        # should have '++++++++++'
+        assert t_psi.H @ t_psi == pytest.approx(1)
+        for i in range(n):
+            assert t_psi.H @ t_psi.gate(qu.pauli("X"), i) == pytest.approx(1)
+
+    def test_rand(self):
+        t_psi = qtn.Dense1D.rand(7, dtype="complex64")
+        assert t_psi.shape == (2,) * 7
+        assert t_psi.dtype == "complex64"
+        assert (t_psi.H @ t_psi) == pytest.approx(1.0)
+
+
+class TestTensor1DCompress:
+    @pytest.mark.parametrize(
+        "method", ["direct", "dm", "fit", "zipup", "zipup-first"]
+    )
+    @pytest.mark.parametrize("dtype", dtypes)
+    def test_mps_partial_mpo_apply(self, method, dtype):
+        mps = qtn.MPS_rand_state(10, 7, dtype=dtype)
+        A = qu.rand_uni(2**3, dtype=dtype)
+        where = [8, 4, 5]
+        mpo = qtn.MatrixProductOperator.from_dense(A, sites=where)
+        new = mps.gate_with_op_lazy(mpo)
+        assert (
+            qtn.tensor_network_1d_compress(new, method=method, inplace=True)
+            is new
+        )
+        assert new.num_tensors == 10
+        assert new.distance_normalized(mps.gate(A, where)) == pytest.approx(
+            0.0, abs=1e-3 if dtype in ("float32", "complex64") else 1e-6
+        )
+
+    @pytest.mark.parametrize(
+        "method", ["direct", "dm", "fit", "zipup", "zipup-first"]
+    )
+    @pytest.mark.parametrize("sweep_reverse", [False, True])
+    def test_mpo_compress_opts(self, method, sweep_reverse):
+        L = 6
+        A = qtn.MPO_rand(L, 2, phys_dim=3)
+        B = qtn.MPO_rand(L, 3, phys_dim=3)
+        AB = A.gate_upper_with_op_lazy(B)
+        assert AB.num_tensors == 2 * L
+        ABc = qtn.tensor_network_1d_compress(
+            AB,
+            method=method,
+            max_bond=5,
+            cutoff=1e-6,
+            sweep_reverse=sweep_reverse,
+            inplace=False,
+        )
+        assert ABc.num_tensors == L
+        assert ABc.num_indices == 2 * L + L - 1
+        assert ABc.max_bond() == 5
+        if sweep_reverse:
+            assert ABc.calc_current_orthog_center() == (L - 1, L - 1)
+        else:
+            assert ABc.calc_current_orthog_center() == (0, 0)