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

trajectree/quimb/tests/test_gen/test_operators.py

@@ -0,0 +1,361 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+import quimb as qu
+
+
+@pytest.mark.parametrize("sparse", [False, True])
+@pytest.mark.parametrize("stype", ["csr", "csc"])
+@pytest.mark.parametrize(
+    "dtype", ["don't pass", None, np.float64, np.complex128]
+)
+def test_hamiltonian_builder(sparse, stype, dtype):
+    from quimb.gen.operators import hamiltonian_builder
+
+    @hamiltonian_builder
+    def simple_ham(sparse=None, stype=None, dtype=None):
+        H = qu.qu(
+            [[0.0, 1.0], [1.0, 0.0]], sparse=True, stype="csr", dtype=dtype
+        )
+        return H
+
+    @hamiltonian_builder
+    def simple_ham_complex(sparse=None, stype=None, dtype=None):
+        H = qu.qu(
+            [[0.0, 1.0j], [-1.0j, 0.0]], sparse=True, stype="csr", dtype=dtype
+        )
+        return H
+
+    if dtype == "don't pass":
+        H = simple_ham(sparse=sparse, stype=stype)
+    else:
+        H = simple_ham(sparse=sparse, stype=stype, dtype=dtype)
+
+    if dtype == "don't pass" or dtype is None:
+        # check that passng no actual dtype keeps it as float
+        assert H.dtype == np.float64
+    else:
+        # check that explicit dtypes are respected
+        assert H.dtype == dtype
+    assert qu.issparse(H) == sparse
+    assert qu.isdense(H) != sparse
+    if sparse:
+        assert H.format == stype
+
+    with pytest.raises(ValueError):  # check immutability
+        H[0, 0] = 100
+
+    if dtype == "don't pass":
+        H = simple_ham_complex(sparse=sparse, stype=stype)
+    elif dtype is np.float64:
+        with pytest.warns(np.exceptions.ComplexWarning):
+            H = simple_ham_complex(sparse=sparse, stype=stype, dtype=dtype)
+    else:
+        H = simple_ham_complex(sparse=sparse, stype=stype, dtype=dtype)
+    if dtype == "don't pass" or dtype is None:
+        # check that passng no actual dtype keeps it as float
+        assert H.dtype == np.complex128
+    else:
+        # check that explicit dtypes are respected
+        assert H.dtype == dtype
+    assert qu.issparse(H) == sparse
+    assert qu.isdense(H) != sparse
+    if sparse:
+        assert H.format == stype
+
+    with pytest.raises(ValueError):  # check immutability
+        H[0, 0] = 100
+
+    return
+
+
+class TestSpinOperator:
+    def test_spin_half(self):
+        Sx = qu.spin_operator("x", 1 / 2)
+        assert_allclose(Sx, [[0.0, 0.5], [0.5, 0.0]])
+
+        Sy = qu.spin_operator("y", 1 / 2)
+        assert_allclose(Sy, [[0.0, -0.5j], [0.5j, 0.0]])
+
+        Sz = qu.spin_operator("z", 1 / 2)
+        assert_allclose(Sz, [[0.5, 0.0], [0.0, -0.5]])
+
+        Sp = qu.spin_operator("+", 1 / 2)
+        assert_allclose(Sp, [[0.0, 1.0], [0.0, 0.0]])
+
+        Sm = qu.spin_operator("-", 1 / 2)
+        assert_allclose(Sm, [[0.0, 0.0], [1.0, 0.0]])
+
+        SI = qu.spin_operator("I", 1 / 2)
+        assert_allclose(SI, [[1.0, 0.0], [0.0, 1.0]])
+
+    @pytest.mark.parametrize("label", ("x", "y", "z"))
+    @pytest.mark.parametrize("S", [1, 3 / 2, 2, 5 / 2])
+    def test_spin_high(self, label, S):
+        D = int(2 * S + 1)
+        op = qu.spin_operator(label, S)
+        assert_allclose(qu.eigvalsh(op), np.linspace(-S, S, D), atol=1e-13)
+
+
+class TestPauli:
+    def test_pauli_dim2(self):
+        for dir in (1, "x", "X", 2, "y", "Y", 3, "z", "Z"):
+            x = qu.pauli(dir)
+            assert_allclose(qu.eigvalsh(x), [-1, 1])
+
+    def test_pauli_dim3(self):
+        for dir in (1, "x", "X", 2, "y", "Y", 3, "z", "Z"):
+            x = qu.pauli(dir, dim=3)
+            assert_allclose(qu.eigvalsh(x), [-1, 0, 1], atol=1e-15)
+
+    def test_pauli_bad_dim(self):
+        with pytest.raises(KeyError):
+            qu.pauli("x", 4)
+
+    def test_pauli_bad_dir(self):
+        with pytest.raises(KeyError):
+            qu.pauli("w", 2)
+
+
+class TestControlledZ:
+    def test_controlled_z_dense(self):
+        cz = qu.controlled("z")
+        assert_allclose(cz, np.diag([1, 1, 1, -1]))
+
+    def test_controlled_z_sparse(self):
+        cz = qu.controlled("z", sparse=True)
+        assert qu.issparse(cz)
+        assert_allclose(cz.toarray(), np.diag([1, 1, 1, -1]))
+
+
+class TestGates:
+    @pytest.mark.parametrize(
+        "gate",
+        [
+            "Rx",
+            "Ry",
+            "Rz",
+            "T_gate",
+            "S_gate",
+            "CNOT",
+            "cX",
+            "cY",
+            "cZ",
+            "hadamard",
+            "phase_gate",
+            "iswap",
+            "swap",
+            "U_gate",
+            "fsim",
+            "fsimg",
+        ],
+    )
+    @pytest.mark.parametrize("dtype", [np.complex64, np.complex128])
+    @pytest.mark.parametrize("sparse", [False, True])
+    def test_construct(self, gate, dtype, sparse):
+        if gate in {"Rx", "Ry", "Rz", "phase_gate"}:
+            args = (0.43827,)
+        elif gate in {"U_gate"}:
+            args = (0.1, 0.2, 0.3)
+        elif gate in {"fsim"}:
+            args = (-1.3, 5.4)
+        elif gate in {"fsimg"}:
+            args = (-1.3, 5.4, 2.0, 3.0, 4.0)
+        else:
+            args = ()
+        G = getattr(qu, gate)(*args, dtype=dtype, sparse=sparse)
+        assert G.dtype == dtype
+        assert qu.issparse(G) is sparse
+        psi = qu.rand_ket(G.shape[0])
+        Gpsi = G @ psi
+        assert qu.expec(Gpsi, Gpsi) == pytest.approx(1.0)
+
+    def test_gates_import(self):
+        from quimb.gates import Z
+
+        assert_allclose(Z, [[1, 0], [0, -1]])
+
+    def test_fsim(self):
+        assert_allclose(qu.fsim(-qu.pi / 2, 0.0), qu.iswap(), atol=1e-12)
+
+    def test_fsimg(self):
+        assert_allclose(
+            qu.fsimg(-qu.pi / 2, 0.0, 0.0, 0.0, 0.0), qu.iswap(), atol=1e-12
+        )
+
+
+class TestHamHeis:
+    def test_ham_heis_2(self):
+        h = qu.ham_heis(2, cyclic=False)
+        evals = qu.eigvalsh(h)
+        assert_allclose(evals, [-0.75, 0.25, 0.25, 0.25])
+        gs = qu.groundstate(h)
+        assert_allclose(qu.expec(gs, qu.singlet()), 1.0)
+
+    @pytest.mark.parametrize("parallel", [False, True])
+    def test_ham_heis_sparse_cyclic_4(self, parallel):
+        h = qu.ham_heis(4, sparse=True, cyclic=True, parallel=parallel)
+        lk = qu.eigvalsh(h, k=4)
+        assert_allclose(lk, [-2, -1, -1, -1])
+
+    def test_ham_heis_bz(self):
+        h = qu.ham_heis(2, cyclic=False, b=1)
+        evals = qu.eigvalsh(h)
+        assert_allclose(evals, [-3 / 4, -3 / 4, 1 / 4, 5 / 4])
+
+    @pytest.mark.parametrize("stype", ["coo", "csr", "csc", "bsr"])
+    def test_sformat_construct(self, stype):
+        h = qu.ham_heis(4, sparse=True, stype=stype)
+        assert h.format == stype
+
+
+class TestHamJ1J2:
+    def test_ham_j1j2_3_dense(self):
+        h = qu.ham_j1j2(3, j2=1.0, cyclic=False)
+        h2 = qu.ham_heis(3, cyclic=True)
+        assert_allclose(h, h2)
+
+    def test_ham_j1j2_6_sparse_cyc(self):
+        h = qu.ham_j1j2(6, j2=0.5, sparse=True, cyclic=True)
+        lk = qu.eigvalsh(h, k=5)
+        assert_allclose(lk, [-9 / 4, -9 / 4, -7 / 4, -7 / 4, -7 / 4])
+
+    def test_ham_j1j2_4_bz(self):
+        h = qu.ham_j1j2(4, j2=0.5, cyclic=True, bz=0)
+        lk = qu.eigvalsh(h, k=11)
+        assert_allclose(
+            lk,
+            [-1.5, -1.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5],
+        )
+        h = qu.ham_j1j2(4, j2=0.5, cyclic=True, bz=0.05)
+        lk = qu.eigvalsh(h, k=11)
+        assert_allclose(
+            lk,
+            [
+                -1.5,
+                -1.5,
+                -0.55,
+                -0.55,
+                -0.55,
+                -0.5,
+                -0.5,
+                -0.5,
+                -0.45,
+                -0.45,
+                -0.45,
+            ],
+        )
+
+
+class TestHamMBL:
+    @pytest.mark.parametrize("cyclic", [False, True])
+    @pytest.mark.parametrize("sparse", [False, True])
+    @pytest.mark.parametrize("dh_dim", [1, 2, 3, "y", "xz"])
+    @pytest.mark.parametrize("dh_dist", ["s", "g"])
+    def test_construct(self, cyclic, sparse, dh_dim, dh_dist):
+        qu.ham_mbl(
+            n=3,
+            dh=3,
+            cyclic=cyclic,
+            sparse=sparse,
+            dh_dim=dh_dim,
+            dh_dist=dh_dist,
+        )
+
+    @pytest.mark.parametrize("cyclic", [False, True])
+    @pytest.mark.parametrize("sparse", [False, True])
+    def test_construct_qp(self, cyclic, sparse):
+        qu.ham_mbl(n=3, dh=3, cyclic=cyclic, sparse=sparse, dh_dist="qp")
+
+
+class TestHamHeis2D:
+    @pytest.mark.parametrize("cyclic", [False, True])
+    @pytest.mark.parametrize("sparse", [False, True])
+    @pytest.mark.parametrize("parallel", [False, True])
+    @pytest.mark.parametrize("bz", [0.0, 0.7])
+    def test_construct(self, cyclic, sparse, parallel, bz):
+        qu.ham_heis_2D(
+            2, 3, cyclic=cyclic, sparse=sparse, parallel=parallel, bz=bz
+        )
+
+
+class TestSpinZProjector:
+    @pytest.mark.parametrize("sz", [-2, -1, 0, 1, 2])
+    def test_works(self, sz):
+        prj = qu.zspin_projector(4, sz)
+        h = qu.ham_heis(4)
+        h0 = prj.T @ h @ prj
+        v0s = qu.eigvecsh(h0)
+        for i in range(v0s.shape[1]):
+            v0 = v0s[:, [i]]
+            vf = prj @ v0
+            prjv = vf @ vf.H
+            # Check reconstructed full eigenvectors commute with full ham
+            assert_allclose(prjv @ h, h @ prjv, atol=1e-13)
+        if sz == 0:
+            # Groundstate must be in most symmetric subspace
+            gs = qu.groundstate(h)
+            gs0 = prj @ v0s[:, [0]]
+            assert_allclose(qu.expec(gs, gs0), 1.0)
+            assert_allclose(qu.expec(h, gs0), qu.expec(h, gs))
+
+    def test_raises(self):
+        with pytest.raises(ValueError):
+            qu.zspin_projector(5, 0)
+        with pytest.raises(ValueError):
+            qu.zspin_projector(4, 1 / 2)
+
+    @pytest.mark.parametrize("sz", [(-1 / 2, 1 / 2), (3 / 2, 5 / 2)])
+    def test_spin_half_double_space(self, sz):
+        prj = qu.zspin_projector(5, sz)
+        h = qu.ham_heis(5)
+        h0 = prj.T @ h @ prj
+        v0s = qu.eigvecsh(h0)
+        for i in range(v0s.shape[1]):
+            v0 = v0s[:, [i]]
+            vf = prj @ v0
+            prjv = vf @ vf.H
+            # Check reconstructed full eigenvectors commute with full ham
+            assert_allclose(prjv @ h, h @ prjv, atol=1e-13)
+        if sz == 0:
+            # Groundstate must be in most symmetric subspace
+            gs = qu.groundstate(h)
+            gs0 = prj @ v0s[:, [0]]
+            assert_allclose(qu.expec(gs, gs0), 1.0)
+            assert_allclose(qu.expec(h, gs0), qu.expec(h, gs))
+
+
+class TestSwap:
+    @pytest.mark.parametrize("sparse", [False, True])
+    def test_swap_qubits(self, sparse):
+        a = qu.up() & qu.down()
+        s = qu.swap(2, sparse=sparse)
+        assert_allclose(s @ a, qu.down() & qu.up())
+
+    @pytest.mark.parametrize("sparse", [False, True])
+    def test_swap_higher_dim(self, sparse):
+        a = qu.rand_ket(9)
+        s = qu.swap(3, sparse=sparse)
+        assert_allclose(s @ a, a.reshape([3, 3]).T.reshape([9, 1]))
+
+
+@pytest.mark.parametrize("sparse", [False, True])
+def test_3qubit_gates(sparse):
+    psi = qu.rand_ket(8)
+    psi = qu.toffoli(sparse=sparse) @ psi
+    psi = qu.ccY(sparse=sparse) @ psi
+    psi = qu.fredkin(sparse=sparse) @ psi
+    psi = qu.ccZ(sparse=sparse) @ psi
+    assert qu.expec(psi, psi) == pytest.approx(1.0)
+
+
+class TestHubbardSpinless:
+    def test_half_filling_groundstate(self):
+        H = qu.ham_hubbard_hardcore(8, t=0.5, V=1.0, mu=1.0, cyclic=True)
+        gs = qu.groundstate(H)
+        dims = [2] * 8
+        cn = qu.num(2)
+        ens = [qu.expec(cn, qu.ptr(gs, dims, i)) for i in range(8)]
+        for en in ens:
+            assert en == pytest.approx(0.5, rel=1e-6)

trajectree/quimb/tests/test_gen/test_rand.py

@@ -0,0 +1,296 @@
+import pytest
+from numpy.testing import assert_allclose
+import numpy as np
+import scipy.sparse as sp
+
+import quimb as qu
+
+
+dtypes = [np.float32, np.float64, np.complex128, np.complex64]
+
+
+class TestRandn:
+    @pytest.mark.parametrize(
+        "dtype",
+        dtypes
+        + [
+            float,
+            complex,
+            "f8",
+            "f4",
+            "c8",
+            "c16",
+            "float32",
+            "float64",
+            "complex64",
+            "complex128",
+        ],
+    )
+    def test_basic(self, dtype):
+        x = qu.randn((2, 3, 4), dtype=dtype)
+        assert x.shape == (2, 3, 4)
+        assert x.dtype == np.dtype(dtype)
+
+    @pytest.mark.parametrize("num_threads", [2, 3])
+    @pytest.mark.parametrize("dist", ["uniform", "normal", "exp"])
+    def test_multithreaded(self, num_threads, dist):
+        x = qu.randn((2, 3, 4), dist=dist, num_threads=num_threads, seed=42)
+        y = qu.randn((2, 3, 4), dist=dist, num_threads=num_threads, seed=42)
+        assert_allclose(x, y)
+
+    def test_can_seed(self):
+        assert_allclose(qu.randn(5, seed=42), qu.randn(5, seed=42))
+
+    def test_scale_and_loc(self):
+        x = qu.randn(1000, scale=100, loc=50, dtype=float, seed=42)
+        assert_allclose(np.mean(x), 50, rtol=1e-1)
+        assert_allclose(np.std(x), 100, rtol=1e-1)
+
+    @pytest.mark.parametrize(
+        "dtype,tol",
+        [
+            ("complex64", 1e-5),
+            ("complex128", 1e-11),
+        ],
+    )
+    def test_rand_phase(self, dtype, tol):
+        x = qu.gen.rand.rand_phase(10, dtype=dtype)
+        assert x.dtype == dtype
+        assert_allclose(np.abs(x), np.ones(10), rtol=tol)
+
+    @pytest.mark.parametrize(
+        "dtype", ["float32", "float64", "complex64", "complex128"]
+    )
+    def test_rand_rademacher(self, dtype):
+        x = qu.gen.rand.rand_rademacher(10, dtype=dtype)
+        assert x.dtype == dtype
+        assert_allclose(np.abs(x), np.ones(10))
+
+    @pytest.mark.parametrize(
+        "bitgen",
+        [
+            "MT19937",
+            "PCG64",
+            "Philox",
+            "SFC64",
+        ],
+    )
+    def test_set_bitgen(self, bitgen):
+        x0 = qu.randn(3, seed=42)
+        qu.set_rand_bitgen(bitgen)
+        x1 = qu.randn(3, seed=42)
+        assert not np.allclose(x0, x1) or bitgen == "PCG64"  # <- default
+        x2 = qu.randn(3, seed=42)
+        assert_allclose(x1, x2)
+        qu.set_rand_bitgen(None)
+        x3 = qu.randn(3, seed=42)
+        assert_allclose(x0, x3)
+
+
+@pytest.mark.parametrize("dtype", dtypes)
+class TestRandMatrix:
+    def test_rand_matrix(self, dtype):
+        a = qu.rand_matrix(3, scaled=True, dtype=dtype)
+        assert a.shape == (3, 3)
+        assert type(a) == qu.qarray
+        assert a.dtype == dtype
+
+    def test_rand_matrix_sparse(self, dtype):
+        a = qu.rand_matrix(3, sparse=True, dtype=dtype)
+        assert a.shape == (3, 3)
+        assert type(a) == sp.csr_matrix
+        assert a.dtype == dtype
+
+    def test_rand_matrix_sparse_density(self, dtype):
+        a = qu.rand_matrix(3, sparse=True, density=1 / 9, dtype=dtype)
+        assert a.nnz == 1
+        a = qu.rand_matrix(3, sparse=True, density=7 / 9, dtype=dtype)
+        assert a.nnz == 7
+
+    def test_rand_matrix_bsr(self, dtype):
+        a = qu.rand_matrix(
+            10, sparse=True, density=0.2, stype="bsr", dtype=dtype
+        )
+        assert a.shape == (10, 10)
+        assert type(a) == sp.bsr_matrix
+        assert a.dtype == dtype
+
+    @pytest.mark.parametrize("sparse", [False, True])
+    def test_seed(self, dtype, sparse):
+        a = qu.rand_matrix(10, sparse=sparse, dtype=dtype, seed=42)
+        b = qu.rand_matrix(10, sparse=sparse, dtype=dtype, seed=42)
+        if sparse:
+            assert_allclose(a.data, b.data)
+        else:
+            assert_allclose(a, b)
+
+
+@pytest.mark.parametrize("dtype", dtypes)
+class TestRandHerm:
+    def test_rand_herm(self, dtype):
+        a = qu.rand_herm(3, dtype=dtype)
+        assert a.shape == (3, 3)
+        assert type(a) == qu.qarray
+        assert a.dtype == dtype
+        assert_allclose(a, a.H)
+        evals = qu.eigvalsh(a)
+        assert_allclose(evals.imag, [0, 0, 0], atol=1e-14)
+
+    def test_rand_herm_sparse(self, dtype):
+        a = qu.rand_herm(3, sparse=True, density=0.3, dtype=dtype)
+        assert a.shape == (3, 3)
+        assert type(a) == sp.csr_matrix
+        assert qu.isherm(a)
+        assert a.dtype == dtype
+        evals = qu.eigvalsh(a.toarray())
+        assert_allclose(evals.imag, [0, 0, 0], atol=1e-14)
+
+
+@pytest.mark.parametrize("dtype", dtypes)
+class TestRandPos:
+    def test_rand_pos(self, dtype):
+        a = qu.rand_pos(3, dtype=dtype)
+        assert qu.ispos(a)
+        assert a.shape == (3, 3)
+        assert type(a) == qu.qarray
+        assert a.dtype == dtype
+        evals = qu.eigvalsh(a)
+        assert_allclose(evals.imag, [0, 0, 0], atol=1e-7)
+        assert np.all(evals.real >= 0)
+
+    def test_rand_pos_sparse(self, dtype):
+        a = qu.rand_pos(3, sparse=True, density=0.3, dtype=dtype)
+        assert a.shape == (3, 3)
+        assert type(a) == sp.csr_matrix
+        assert a.dtype == dtype
+        evals = qu.eigvalsh(a.toarray())
+        assert_allclose(evals.imag, [0, 0, 0], atol=1e-7)
+        assert np.all(evals.real >= -1e-15)
+
+
+@pytest.mark.parametrize("dtype", dtypes)
+class TestRandRho:
+    def test_rand_rho(self, dtype):
+        rho = qu.rand_rho(3, dtype=dtype)
+        assert rho.shape == (3, 3)
+        assert type(rho) == qu.qarray
+        assert rho.dtype == dtype
+        assert_allclose(qu.tr(rho), 1.0)
+
+    def test_rand_rho_sparse(self, dtype):
+        rho = qu.rand_rho(3, sparse=True, density=0.3, dtype=dtype)
+        assert rho.shape == (3, 3)
+        assert type(rho) == sp.csr_matrix
+        assert rho.dtype == dtype
+        assert_allclose(qu.tr(rho), 1.0)
+
+
+@pytest.mark.parametrize("dtype", dtypes)
+class TestRandUni:
+    def test_rand_uni(self, dtype):
+        u = qu.rand_uni(3, dtype=dtype)
+        assert u.shape == (3, 3)
+        assert type(u) == qu.qarray
+        assert u.dtype == dtype
+        # low tolerances for float32 etc
+        assert_allclose(qu.eye(3), u @ u.H, atol=1e-7, rtol=1e-5)
+        assert_allclose(qu.eye(3), u.H @ u, atol=1e-7, rtol=1e-5)
+
+
+class TestRandKet:
+    def test_rand_ket(self):
+        ket = qu.rand_ket(3)
+        assert ket.shape == (3, 1)
+        assert type(ket) == qu.qarray
+        assert_allclose(qu.tr(ket.H @ ket), 1.0)
+
+
+class TestRandHaarState:
+    def test_rand_haar_state(self):
+        ket = qu.rand_haar_state(3)
+        assert ket.shape == (3, 1)
+        assert type(ket) == qu.qarray
+        assert_allclose(qu.tr(ket.H @ ket), 1.0)
+
+    def test_gen_rand_haar_states(self):
+        kets = [*qu.gen_rand_haar_states(3, 6)]
+        for ket in kets:
+            assert ket.shape == (3, 1)
+            assert type(ket) == qu.qarray
+            assert_allclose(qu.tr(ket.H @ ket), 1.0)
+
+
+class TestRandMix:
+    @pytest.mark.parametrize("mode", ["rand", "haar"])
+    def test_rand_mix(self, mode):
+        rho = qu.rand_mix(3, mode=mode)
+        assert rho.shape == (3, 3)
+        assert type(rho) == qu.qarray
+        assert_allclose(qu.tr(rho), 1.0)
+        mixedness = qu.tr(rho @ rho)
+        assert mixedness < 1.0
+
+
+class TestRandProductState:
+    def test_rand_product_state(self):
+        a = qu.rand_product_state(3)
+        assert a.shape[0] == 2**3
+        assert (a.H @ a)[0, 0].real == pytest.approx(1.0)
+        assert qu.mutinf(a, [2, 2, 2], 0, 1) == pytest.approx(0.0)
+        assert qu.mutinf(a, [2, 2, 2], 1, 2) == pytest.approx(0.0)
+        assert qu.mutinf(a, [2, 2, 2], 0, 2) == pytest.approx(0.0)
+
+
+class TestRandMPS:
+    @pytest.mark.parametrize("cyclic", (True, False))
+    @pytest.mark.parametrize(
+        "d_n_b_e",
+        [
+            (2, 4, 5, 16),
+            (2, 4, 1, 16),
+            (3, 3, 7, 27),
+        ],
+    )
+    def test_shape(self, d_n_b_e, cyclic):
+        d, n, b, e = d_n_b_e
+        psi = qu.rand_matrix_product_state(n, b, d, cyclic=cyclic)
+        assert psi.shape == (e, 1)
+
+        assert_allclose(qu.expec(psi, psi), 1.0)
+
+    @pytest.mark.parametrize("cyclic", (True, False))
+    @pytest.mark.parametrize("bond_dim", (1, 2, 3))
+    def test_rank(self, bond_dim, cyclic):
+        psi = qu.rand_matrix_product_state(10, bond_dim, cyclic=cyclic)
+        rhoa = qu.ptr(psi, [2] * 10, [0, 1, 2, 3])
+        el = qu.eigvalsh(rhoa)
+        # bond_dim squared as cyclic mps is generated
+        assert sum(el > 1e-12) == bond_dim ** (2 if cyclic else 1)
+
+
+class TestRandSeperable:
+    def test_entanglement(self):
+        rho = qu.rand_seperable([2, 3, 2], 10)
+        assert_allclose(qu.tr(rho), 1.0)
+        assert qu.isherm(rho)
+
+        assert qu.logneg(rho, [2, 6]) < 1e-12
+        assert qu.logneg(rho, [6, 2]) < 1e-12
+
+        rho_a = qu.ptr(rho, [2, 3, 2], 1)
+
+        el = qu.eigvalsh(rho_a)
+        assert np.all(el < 1 - 1e-12)
+        assert np.all(el > 1e-12)
+
+
+class TestRandMERA:
+    @pytest.mark.parametrize("invariant", [False, True])
+    @pytest.mark.parametrize(
+        "dtype", ["float32", "float64", "complex64", "complex128"]
+    )
+    def test_simple(self, invariant, dtype):
+        m = qu.rand_mera(8, invariant=invariant, dtype=dtype)
+        assert m.dtype == dtype
+        assert m.H @ m == pytest.approx(1.0)
+        assert m.shape == (256, 1)