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

trajectree/quimb/tests/test_tensor/test_circuit.py

@@ -0,0 +1,816 @@
+import math
+import itertools
+
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose
+
+import quimb as qu
+import quimb.tensor as qtn
+
+
+def rand_reg_graph(reg, n, seed=None):
+    import networkx as nx
+
+    G = nx.random_regular_graph(reg, n, seed=seed)
+    return G
+
+
+def graph_to_qsim(G, gamma0=-0.743043, beta0=0.754082):
+    n = G.number_of_nodes()
+
+    # add all the gates
+    circ = f"{n}\n"
+    for i in range(n):
+        circ += f"H {i}\n"
+    for i, j in G.edges:
+        circ += f"Rzz {gamma0} {i} {j}\n"
+    for i in range(n):
+        circ += f"Rx {beta0} {i}\n"
+
+    return circ
+
+
+def random_a2a_circ(L, depth, seed=42):
+    rng = np.random.default_rng(seed)
+
+    qubits = np.arange(L)
+    gates = []
+
+    for i in range(L):
+        gates.append((0, "h", i))
+
+    for d in range(depth):
+        rng.shuffle(qubits)
+
+        for i in range(0, L - 1, 2):
+            g = rng.choice(["cx", "cy", "cz", "iswap"])
+            gates.append((d, g, qubits[i], qubits[i + 1]))
+
+        for q in qubits:
+            g = rng.choice(["rx", "ry", "rz"])
+            gates.append((d, g, rng.normal(1.0, 0.5), q))
+
+    circ = qtn.Circuit(L)
+    circ.apply_gates(gates)
+
+    return circ
+
+
+def qft_circ(n, swaps=True, **circuit_opts):
+    circ = qtn.Circuit(n, **circuit_opts)
+
+    for i in range(n):
+        circ.h(i)
+        for j, m in zip(range(i + 1, n), itertools.count(2)):
+            circ.cu1(2 * math.pi / 2**m, j, i)
+
+    if swaps:
+        for i in range(n // 2):
+            circ.swap(i, n - i - 1)
+
+    return circ
+
+
+def swappy_circ(n, depth):
+    circ = qtn.Circuit(n)
+
+    for d in range(depth):
+        pairs = np.random.permutation(np.arange(n))
+
+        for i in range(n // 2):
+            qi = pairs[2 * i]
+            qj = pairs[2 * i + 1]
+
+            gate = np.random.choice(["FSIM", "SWAP"])
+            if gate == "FSIM":
+                params = np.random.randn(2)
+            elif gate == "FSIMG":
+                params = np.random.randn(5)
+            else:
+                params = ()
+
+            circ.apply_gate(gate, *params, qi, qj)
+
+    return circ
+
+
+def example_openqasm2_qft():
+    return """
+    // quantum Fourier transform
+
+    OPENQASM 2.0;
+    include "qelib1.inc";
+
+    qreg q[4];
+    creg c[4];
+    x q[0];
+    x q[2];
+    barrier q;
+    h q[0];
+    cu1(pi/2) q[1],q[0];
+    h q[1];
+    cu1(pi/4) q[2],q[0];
+    cu1(pi/2) q[2],q[1];
+    /*
+    This is a multi line comment.
+    */
+    h q[2];
+    cu1(pi/8) q[3],q[0];
+    cu1(pi/4) q[3],q[1];
+    cu1(pi/2) q[3],q[2];
+    h q[3];
+
+    measure q -> c;
+    """
+
+
+class TestCircuit:
+    def test_prepare_GHZ(self):
+        qc = qtn.Circuit(3)
+        gates = [
+            ("H", 0),
+            ("H", 1),
+            ("CNOT", 1, 2),
+            ("CNOT", 0, 2),
+            ("H", 0),
+            ("H", 1),
+            ("H", 2),
+        ]
+        qc.apply_gates(gates)
+        assert qu.expec(qc.psi.to_dense(), qu.ghz_state(3)) == pytest.approx(1)
+        counts = qc.simulate_counts(1024)
+        assert len(counts) == 2
+        assert "000" in counts
+        assert "111" in counts
+        assert counts["000"] + counts["111"] == 1024
+
+    def test_from_qsim(self):
+        G = rand_reg_graph(reg=3, n=18, seed=42)
+        qsim = graph_to_qsim(G)
+        qc = qtn.Circuit.from_qsim_str(qsim)
+        assert (qc.psi.H & qc.psi) ^ all == pytest.approx(1.0)
+
+    def test_from_openqasm2(self):
+        qc = qtn.Circuit.from_openqasm2_str(example_openqasm2_qft())
+        assert (qc.psi.H & qc.psi) ^ all == pytest.approx(1.0)
+
+    def test_openqasm2_custom_gates(self):
+        circ = qtn.Circuit.from_openqasm2_str(
+            """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[3];
+
+        gate hello a, b {
+            h a;
+            cx a, b;
+            u3(0.1, 0.2, 0.3) b;
+        }
+
+        gate world(param1, θ) q
+        {
+            u2(θ / 2, param1) q;
+            u2(param1, θ / 2) q;
+        }
+
+        hello q[0], q[1];
+        world(0.1, 0.2) q[2];
+        hello q[2], q[1];
+        """
+        )
+        assert [g.label for g in circ.gates] == [
+            "H",
+            "CX",
+            "U3",
+            "U2",
+            "U2",
+            "H",
+            "CX",
+            "U3",
+        ]
+
+    def test_openqasm2_custom_nested_gates(self):
+        circ = qtn.Circuit.from_openqasm2_str(
+            """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[3];
+
+        gate cphase(θ) a, b
+        {
+            U3(0, 0, θ / 2) a;
+            CX a, b;
+            U3(0, 0, -θ / 2) b;
+            CX a, b;
+            U3(0, 0, θ / 2) b;
+        }
+
+        gate doublecphase(θ) a, b, c {
+            cphase(θ) a, b;
+            cphase(θ) b, c;
+        }
+
+        doublecphase(0.1) q[0], q[1], q[2];
+        doublecphase(0.2) q[2], q[0], q[1];
+        """
+        )
+        assert [g.label for g in circ.gates] == [
+            "U3",
+            "CX",
+            "U3",
+            "CX",
+            "U3",
+        ] * 4
+
+    @pytest.mark.parametrize(
+        "Circ", [qtn.Circuit, qtn.CircuitMPS, qtn.CircuitDense]
+    )
+    def test_all_gate_methods(self, Circ):
+        import random
+
+        g_nq_np = [
+            # single qubit
+            ("x", 1, 0),
+            ("y", 1, 0),
+            ("z", 1, 0),
+            ("s", 1, 0),
+            ("t", 1, 0),
+            ("h", 1, 0),
+            ("iden", 1, 0),
+            ("x_1_2", 1, 0),
+            ("y_1_2", 1, 0),
+            ("z_1_2", 1, 0),
+            ("w_1_2", 1, 0),
+            ("hz_1_2", 1, 0),
+            # single qubit parametrizable
+            ("rx", 1, 1),
+            ("ry", 1, 1),
+            ("rz", 1, 1),
+            ("u3", 1, 3),
+            ("u2", 1, 2),
+            ("u1", 1, 1),
+            ("phase", 1, 1),
+            # two qubit
+            ("cx", 2, 0),
+            ("cy", 2, 0),
+            ("cz", 2, 0),
+            ("cnot", 2, 0),
+            ("swap", 2, 0),
+            ("iswap", 2, 0),
+            # two qubit parametrizable
+            ("rxx", 2, 1),
+            ("ryy", 2, 1),
+            ("rzz", 2, 1),
+            ("crx", 2, 1),
+            ("cry", 2, 1),
+            ("crz", 2, 1),
+            ("cu3", 2, 3),
+            ("cu2", 2, 2),
+            ("cu1", 2, 1),
+            ("cphase", 2, 1),
+            ("fsim", 2, 2),
+            ("fsimg", 2, 5),
+            ("givens", 2, 1),
+            ("givens2", 2, 2),
+            ("su4", 2, 15),
+        ]
+        random.shuffle(g_nq_np)
+
+        psi0 = qtn.MPS_rand_state(2, 2)
+        circ = Circ(2, psi0=psi0, tags="PSI0")
+
+        for g, n_q, n_p in g_nq_np:
+            args = [
+                *np.random.uniform(0, 2 * np.pi, size=n_p),
+                *np.random.choice([0, 1], replace=False, size=n_q),
+            ]
+            getattr(circ, g)(*args)
+
+        assert circ.psi.H @ circ.psi == pytest.approx(1.0)
+        assert abs((circ.psi.H & psi0) ^ all) < 0.99999999
+
+    def test_su4(self):
+        psi0 = qtn.MPS_rand_state(2, 2)
+        circ_a = qtn.Circuit(psi0=psi0)
+        params = qu.randn(15)
+
+        circ_a.su4(*params, 0, 1)
+        psi_a = circ_a.to_dense()
+
+        circ_b = qtn.Circuit(psi0=psi0)
+        (
+            theta1,
+            phi1,
+            lamda1,
+            theta2,
+            phi2,
+            lamda2,
+            theta3,
+            phi3,
+            lamda3,
+            theta4,
+            phi4,
+            lamda4,
+            t1,
+            t2,
+            t3,
+        ) = params
+        circ_b.u3(theta1, phi1, lamda1, 0)
+        circ_b.u3(theta2, phi2, lamda2, 1)
+        circ_b.cnot(1, 0)
+        circ_b.rz(t1, 0)
+        circ_b.ry(t2, 1)
+        circ_b.cnot(0, 1)
+        circ_b.ry(t3, 1)
+        circ_b.cnot(1, 0)
+        circ_b.u3(theta3, phi3, lamda3, 0)
+        circ_b.u3(theta4, phi4, lamda4, 1)
+        psi_b = circ_b.to_dense()
+
+        assert qu.fidelity(psi_a, psi_b) == pytest.approx(1.0)
+
+    def test_three_qubit_gates(self):
+        psi0 = qtn.MPS_rand_state(3, 2)
+        circ = qtn.Circuit(psi0=psi0)
+        circ.ccx(0, 1, 2)
+        circ.cswap(2, 1, 0)
+        circ.toffoli(0, 1, 2)
+        circ.ccy(1, 0, 2)
+        circ.ccz(1, 2, 0)
+        circ.fredkin(2, 1, 0)
+        psi = circ.psi.to_dense()
+        assert qu.expec(psi, psi) == pytest.approx(1.0)
+
+    def test_auto_split_gate(self):
+        n = 3
+        ops = [
+            ("u3", 1.0, 2.0, 3.0, 0),
+            ("u3", 2.0, 3.0, 1.0, 1),
+            ("u3", 3.0, 1.0, 2.0, 2),
+            ("cz", 0, 1),
+            ("iswap", 1, 2),
+            ("cx", 2, 0),
+            ("iswap", 2, 1),
+            ("h", 0),
+            ("h", 1),
+            ("h", 2),
+        ]
+        cnorm = qtn.Circuit(n, gate_opts=dict(contract="split-gate"))
+        cnorm.apply_gates(ops)
+        assert cnorm.psi.max_bond() == 4
+
+        cswap = qtn.Circuit(n, gate_opts=dict(contract="swap-split-gate"))
+        cswap.apply_gates(ops)
+        assert cswap.psi.max_bond() == 4
+
+        cauto = qtn.Circuit(n, gate_opts=dict(contract="auto-split-gate"))
+        cauto.apply_gates(ops)
+        assert cauto.psi.max_bond() == 2
+
+        assert qu.fidelity(
+            cnorm.psi.to_dense(), cswap.psi.to_dense()
+        ) == pytest.approx(1.0)
+        assert qu.fidelity(
+            cswap.psi.to_dense(), cauto.psi.to_dense()
+        ) == pytest.approx(1.0)
+
+    @pytest.mark.parametrize("gate2", ["cx", "iswap"])
+    def test_circuit_simplify_tensor_network(self, gate2):
+        import random
+        import itertools
+
+        depth = n = 8
+
+        circ = qtn.Circuit(n)
+
+        def random_single_qubit_layer():
+            return [
+                (random.choice(["X_1_2", "Y_1_2", "W_1_2"]), i)
+                for i in range(n)
+            ]
+
+        def even_two_qubit_layer():
+            return [(gate2, i, i + 1) for i in range(0, n, 2)]
+
+        def odd_two_qubit_layer():
+            return [(gate2, i, i + 1) for i in range(1, n - 1, 2)]
+
+        layering = itertools.cycle(
+            [
+                random_single_qubit_layer,
+                even_two_qubit_layer,
+                random_single_qubit_layer,
+                odd_two_qubit_layer,
+            ]
+        )
+
+        for i, layer_fn in zip(range(depth), layering):
+            for g in layer_fn():
+                circ.apply_gate(*g, gate_round=i)
+
+        psif = qtn.MPS_computational_state("0" * n).squeeze_()
+        tn = circ.psi & psif
+
+        c = tn.contract(all)
+        cw = tn.contraction_width()
+
+        tn_s = tn.full_simplify()
+        assert tn_s.num_tensors < tn.num_tensors
+        assert tn_s.num_indices < tn.num_indices
+        # need to specify output inds since we now have hyper edges
+        c_s = tn_s.contract(all, output_inds=[])
+        assert c_s == pytest.approx(c)
+        cw_s = tn_s.contraction_width(output_inds=[])
+        assert cw_s <= cw
+
+    def test_amplitude(self):
+        L = 5
+        circ = random_a2a_circ(L, 3)
+        psi = circ.to_dense()
+
+        for i in range(2**L):
+            b = f"{i:0>{L}b}"
+            c = circ.amplitude(b)
+            assert c == pytest.approx(psi[i, 0])
+
+    def test_partial_trace(self):
+        L = 5
+        circ = random_a2a_circ(L, 3)
+        psi = circ.to_dense()
+        for i in range(L - 1):
+            keep = (i, i + 1)
+            assert_allclose(
+                qu.partial_trace(psi, [2] * 5, keep=keep),
+                circ.partial_trace(keep),
+                atol=1e-12,
+            )
+
+    @pytest.mark.parametrize("group_size", (1, 2, 6))
+    def test_sample(self, group_size):
+        import collections
+        from scipy.stats import power_divergence
+
+        C = 2**10
+        L = 5
+        circ = random_a2a_circ(L, 3)
+
+        psi = circ.to_dense()
+        p_exp = abs(psi.reshape(-1)) ** 2
+        f_exp = p_exp * C
+
+        counts = collections.Counter(circ.sample(C, group_size=group_size))
+        f_obs = np.zeros(2**L)
+        for b, c in counts.items():
+            f_obs[int(b, 2)] = c
+
+        assert power_divergence(f_obs, f_exp)[0] < 100
+
+    @pytest.mark.parametrize("group_size", (1, 3))
+    def test_sample_gate_by_gate(self, group_size):
+        import collections
+        from scipy.stats import power_divergence
+
+        C = 2**10
+        L = 5
+        circ = random_a2a_circ(L, 3)
+
+        psi = circ.to_dense()
+        p_exp = abs(psi.reshape(-1)) ** 2
+        f_exp = p_exp * C
+
+        counts = collections.Counter(
+            circ.sample_gate_by_gate(C, group_size=group_size)
+        )
+        f_obs = np.zeros(2**L)
+        for b, c in counts.items():
+            f_obs[int(b, 2)] = c
+
+        assert power_divergence(f_obs, f_exp)[0] < 100
+
+    def test_sample_chaotic(self):
+        import collections
+        from scipy.stats import power_divergence
+
+        C = 2**12
+        L = 5
+        reps = 3
+        depth = 2
+        goodnesses = [0] * 5
+
+        for _ in range(reps):
+            circ = random_a2a_circ(L, depth)
+
+            psi = circ.to_dense()
+            p_exp = abs(psi.reshape(-1)) ** 2
+            f_exp = p_exp * C
+
+            for num_marginal in [3, 4, 5]:
+                counts = collections.Counter(
+                    circ.sample_chaotic(C, num_marginal, seed=666)
+                )
+                f_obs = np.zeros(2**L)
+                for b, c in counts.items():
+                    f_obs[int(b, 2)] = c
+
+                goodness = power_divergence(f_obs, f_exp)[0]
+                goodnesses[num_marginal - 1] += goodness
+
+        # assert average sampling goodness gets better with larger marginal
+        assert sum(goodnesses[i] < goodnesses[i - 1] for i in range(1, L)) == 2
+
+    def test_local_expectation(self):
+        import random
+
+        L = 5
+        depth = 3
+        circ = random_a2a_circ(L, depth)
+        psi = circ.to_dense()
+        for _ in range(10):
+            G = qu.rand_matrix(4)
+            i = random.randint(0, L - 2)
+            where = (i, i + 1)
+            x1 = qu.expec(qu.ikron(G, [2] * L, where), psi)
+            x2 = circ.local_expectation(G, where)
+            assert x1 == pytest.approx(x2)
+
+    def test_local_expectation_multigate(self):
+        circ = qtn.Circuit(2)
+        circ.h(0)
+        circ.cnot(0, 1)
+        circ.y(1)
+        Gs = [qu.kronpow(qu.pauli(s), 2) for s in "xyz"]
+        exps = circ.local_expectation(Gs, [0, 1])
+        assert exps[0] == pytest.approx(-1)
+        assert exps[1] == pytest.approx(-1)
+        assert exps[2] == pytest.approx(-1)
+
+    def test_local_expectation_len1(self):
+        circ = qtn.Circuit(1)
+        circ.apply_gate("H", 0, gate_round=0)
+        circ.local_expectation([qu.pauli("X")], (0,))
+
+    def test_uni_to_dense(self):
+        import cmath
+
+        circ = qft_circ(3)
+        U = circ.uni.to_dense()
+        w = cmath.exp(2j * math.pi / 2**3)
+        ex = 2 ** (-3 / 2) * np.array(
+            [
+                [w**0, w**0, w**0, w**0, w**0, w**0, w**0, w**0],
+                [w**0, w**1, w**2, w**3, w**4, w**5, w**6, w**7],
+                [w**0, w**2, w**4, w**6, w**0, w**2, w**4, w**6],
+                [w**0, w**3, w**6, w**1, w**4, w**7, w**2, w**5],
+                [w**0, w**4, w**0, w**4, w**0, w**4, w**0, w**4],
+                [w**0, w**5, w**2, w**7, w**4, w**1, w**6, w**3],
+                [w**0, w**6, w**4, w**2, w**0, w**6, w**4, w**2],
+                [w**0, w**7, w**6, w**5, w**4, w**3, w**2, w**1],
+            ]
+        )
+        assert_allclose(U, ex)
+
+    def test_swap_lighcones(self):
+        circ = qtn.Circuit(3)
+        circ.x(0)  # 0
+        circ.x(1)  # 1
+        circ.x(2)  # 2
+        circ.swap(0, 1)  # 3
+        circ.cx(1, 2)  # 4
+        circ.cx(0, 1)  # 5
+        assert circ.get_reverse_lightcone_tags((2,)) == (
+            "PSI0",
+            "GATE_0",
+            "GATE_2",
+            "GATE_4",
+        )
+
+    def test_swappy_local_expecs(self):
+        circ = swappy_circ(4, 4)
+        Gs = [qu.rand_matrix(4) for _ in range(3)]
+        pairs = [(0, 1), (1, 2), (2, 3)]
+
+        psi = circ.to_dense()
+        dims = [2] * 4
+
+        exs = [
+            qu.expec(qu.ikron(G, dims, pair), psi)
+            for G, pair in zip(Gs, pairs)
+        ]
+        aps = [circ.local_expectation(G, pair) for G, pair in zip(Gs, pairs)]
+
+        assert_allclose(exs, aps)
+
+    @pytest.mark.parametrize(
+        "name, densefn, nparam, nqubit",
+        [
+            ("rx", qu.Rx, 1, 1),
+            ("ry", qu.Ry, 1, 1),
+            ("rz", qu.Rz, 1, 1),
+            ("u3", qu.U_gate, 3, 1),
+            ("fsim", qu.fsim, 2, 2),
+            ("fsimg", qu.fsimg, 5, 2),
+        ],
+    )
+    def test_parametrized_gates_rx(self, name, densefn, nparam, nqubit):
+        k0 = qu.rand_ket(2**nqubit)
+        params = qu.randn(nparam)
+        kf = densefn(*params) @ k0
+        k0mps = qtn.MatrixProductState.from_dense(k0, [2] * nqubit)
+        circ = qtn.Circuit(psi0=k0mps, gate_opts={"contract": False})
+        getattr(circ, name)(*params, *range(nqubit), parametrize=True)
+        tn = circ.psi
+        assert isinstance(tn["GATE_0"], qtn.PTensor)
+        assert_allclose(circ.to_dense(), kf)
+
+    def test_apply_raw_gate(self):
+        k0 = qu.rand_ket(4)
+        psi0 = qtn.MatrixProductState.from_dense(k0, [2] * 2)
+        circ = qtn.Circuit(psi0=psi0)
+        U = qu.rand_uni(4)
+        circ.apply_gate_raw(U, [0, 1], tags="UCUSTOM")
+        assert len(circ.gates) == 1
+        assert "UCUSTOM" in circ.psi.tags
+        assert qu.fidelity(circ.to_dense(), U @ k0) == pytest.approx(1)
+
+    def test_apply_controlled_gate_basic_equiv(self):
+        circ = qtn.Circuit(3)
+        circ.apply_gate("x", qubits=(2,), controls=(0, 1))
+        U = circ.get_uni().to_dense()
+        assert_allclose(U, qu.toffoli())
+
+        circ = qtn.Circuit(3)
+        circ.apply_gate("swap", qubits=(1, 2), controls=(0,))
+        U = circ.get_uni().to_dense()
+        assert_allclose(U, qu.fredkin())
+
+    def test_multi_controlled_circuit(self):
+        import random
+
+        N = 10
+        circ = qtn.Circuit(N)
+        regs = list(range(N))
+        random.shuffle(regs)
+        circ.apply_gate("H", regs[0])
+        for i in range(N - 1):
+            circ.apply_gate("CNOT", regs[i], regs[i + 1])
+        circ.apply_gate("X", N - 1, controls=range(N - 1))
+        circ.apply_gate("SWAP", qubits=(N - 2, N - 1), controls=range(N - 2))
+        (b,) = circ.sample(1, group_size=3)
+        assert b[N - 2] == "0"
+
+
+class TestCircuitMPS:
+    def test_from_qsim_mps_swapsplit(self):
+        G = rand_reg_graph(reg=3, n=18, seed=42)
+        qsim = graph_to_qsim(G)
+        qc = qtn.CircuitMPS.from_qsim_str(qsim)
+        assert len(qc.psi.tensors) == 18
+        assert (qc.psi.H & qc.psi) ^ all == pytest.approx(1.0)
+
+    def test_multi_controlled_mps_circuit(self):
+        N = 10
+        rng = np.random.default_rng(42)
+
+        gates = []
+        for i in range(N):
+            gates.append(
+                qtn.Gate(
+                    "U3", params=rng.uniform(0, 2 * np.pi, size=3), qubits=[i]
+                )
+            )
+        gates.append(
+            qtn.Gate(
+                "SU4",
+                params=rng.uniform(0, 2 * np.pi, size=15),
+                qubits=[6, 2],
+                controls=[8, 3, 4, 0],
+            )
+        )
+        for i in range(N):
+            gates.append(
+                qtn.Gate(
+                    "U3", params=rng.uniform(0, 2 * np.pi, size=3), qubits=[i]
+                )
+            )
+        gates.append(
+            qtn.Gate.from_raw(
+                qu.rand_uni(2**3), qubits=[0, 9, 5], controls=[1, 2, 7]
+            )
+        )
+
+        circ = qtn.Circuit(N=10)
+        circ.apply_gates(gates)
+        psi_lazy = circ.psi
+        circ = qtn.CircuitMPS(N=10)
+        circ.apply_gates(gates)
+        mps = circ.psi
+        assert mps.norm() == pytest.approx(1.0)
+        assert mps.distance_normalized(psi_lazy) < 1e-6
+
+    def test_mps_sampling(self):
+        N = 6
+        circ = qtn.CircuitMPS(N)
+        circ.h(3)
+        circ.cx(3, 2)
+        circ.cx(2, 1)
+        circ.cx(1, 0)
+        circ.cx(0, 5)
+        circ.cx(5, 4)
+        circ.x(4)
+        for x in circ.sample(10):
+            assert x in {"000010", "111101"}
+
+    def test_mps_sampling_seed(self):
+        N = 1
+        circ = qtn.CircuitMPS(N)
+        circ.h(0)
+        samples = list(circ.sample(10, seed=1234))
+        assert len(set(samples)) == 2
+
+    def test_permmps_sampling(self):
+        N = 6
+        circ = qtn.CircuitPermMPS(N)
+        circ.h(3)
+        circ.cx(3, 2)
+        circ.cx(2, 1)
+        circ.cx(1, 0)
+        circ.cx(0, 5)
+        circ.cx(5, 4)
+        circ.x(4)
+        assert circ.qubits != tuple(range(N))
+        for x in circ.sample(10):
+            assert x in {"000010", "111101"}
+
+    def test_permmps_sampling_seed(self):
+        N = 1
+        circ = qtn.CircuitPermMPS(N)
+        circ.h(0)
+        samples = list(circ.sample(10, seed=1234))
+        assert len(set(samples)) == 2
+
+
+class TestCircuitGen:
+    @pytest.mark.parametrize(
+        "ansatz,cyclic",
+        [
+            ("zigzag", False),
+            ("brickwork", False),
+            ("brickwork", True),
+            ("rand", False),
+            ("rand", True),
+        ],
+    )
+    @pytest.mark.parametrize("n", [4, 5])
+    def test_1D_ansatzes(self, ansatz, cyclic, n):
+        depth = 3
+        num_pairs = n if cyclic else n - 1
+
+        fn = {
+            "zigzag": qtn.circ_ansatz_1D_zigzag,
+            "brickwork": qtn.circ_ansatz_1D_brickwork,
+            "rand": qtn.circ_ansatz_1D_rand,
+        }[ansatz]
+
+        opts = dict(
+            n=n,
+            depth=3,
+            gate_opts=dict(contract=False),
+        )
+        if cyclic:
+            opts["cyclic"] = True
+        if ansatz == "rand":
+            opts["seed"] = 42
+
+        circ = fn(**opts)
+        tn = circ.uni
+
+        # total number of entangling gates
+        assert len(tn["CZ"]) == num_pairs * depth
+
+        # number of entangling gates per pair
+        for i in range(num_pairs):
+            assert len(tn["CZ", f"I{i}", f"I{(i + 1) % n}"]) == depth
+
+        assert all(isinstance(t, qtn.PTensor) for t in tn["U3"])
+
+    def test_qaoa(self):
+        G = rand_reg_graph(3, 10, seed=666)
+        terms = {(i, j): 1.0 for i, j in G.edges}
+        ZZ = qu.pauli("Z") & qu.pauli("Z")
+
+        gammas = [-0.6]
+        betas = [-0.4]
+
+        circ1 = qtn.circ_qaoa(terms, 1, gammas, betas)
+
+        energy1 = sum(circ1.local_expectation(ZZ, edge) for edge in terms)
+        assert energy1 < -4
+
+        gammas = [-0.4]
+        betas = [0.3]
+
+        circ2 = qtn.circ_qaoa(terms, 1, gammas, betas)
+
+        energy2 = sum(circ2.local_expectation(ZZ, edge) for edge in terms)
+        assert energy2 > 4