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

trajectree/quimb/quimb/tensor/circuit_gen.py

@@ -0,0 +1,411 @@
+"""Functions for generating specific, e.g. ansatz, circuits."""
+
+import math
+import random
+import itertools
+
+from .. import rand, seed_rand
+
+
+def inject_u3s(
+    ent_gates,
+    gate2="cz",
+    avoid_doubling=False,
+    seed=None,
+):
+    r"""Take a sequence of pairs denoting qubits to entangle and interleave one
+    single qubit gate inbetween every leg. For example:
+
+        ent_gates = [(0, 1), (2, 3), (1, 2)]
+
+    Would go get made into a circuit like::
+
+        |  |  |  |        |  |  |  |
+        |  |  |  |        |  u  u  |
+        |  |  |  |        |  |  |  |
+        |  o++o  |        u  o++o  u
+        |  |  |  |        |  |  |  |
+        |  |  |  |  -->   |  u  u  |
+        |  |  |  |        |  |  |  |
+        o++o  o++o        o++o  o++o
+        |  |  |  |        |  |  |  |
+        |  |  |  |        u  u  u  u
+        |  |  |  |        |  |  |  |
+
+    Technically, this generates a bipartite graph between single qubit and two
+    qubit tensors, and should be the most expressive circuit possible for that
+    'budget' of entangling gates.
+
+    Parameters
+    ----------
+    ent_gates : sequence[tuple[int]]
+        A 'stack' of entangling gate pairs to apply.
+    gate2 : {'cx', 'cy', 'cz', 'iswap', ..., str}, optional
+        The gate to use for the entanling pairs.
+    avoid_doubling : bool, optional
+        Whether to avoid placing an entangling gate directly above the same
+        entangling gate (there will still be single qubit gates interleaved).
+
+    Returns
+    -------
+    Circuit
+    """
+    if seed is not None:
+        seed_rand(seed)
+
+    # keep track of where not to apply another entangling gate
+    just_entangled = set()
+
+    # keep track of where its worth putting a U3
+    n = max(itertools.chain.from_iterable(ent_gates)) + 1
+    needs_u3 = [True] * n
+
+    # create the circuit!
+    gates = []
+    # consume list of pairs to entangle
+    while ent_gates:
+        # break up entanling gates with U3s where necesary
+        for i in range(n):
+            if needs_u3[i]:
+                gates.append(("U3", *rand(3, scale=2 * math.pi), i))
+                needs_u3[i] = False
+
+        # try and get the next entanling gate which is not 'doubled'
+        for k, pair in enumerate(ent_gates):
+            # (just_entangled will never be populated if avoid_doubling=False)
+            if pair not in just_entangled:
+                break
+
+        i, j = ent_gates.pop(k)
+        gates.append((gate2, i, j))
+
+        #  1  2  3  4
+        #  ^  ^  ^  ^
+        #  |  |  |  |
+        #  o++o  o++o
+        #  |  |  |  |
+        #  |  o++o  |     <- if we have just placed (2, 3), disable it in next
+        #  |  |  |  |        round but enable (1, 2) and (3, 4) etc
+        #  ^  ^  ^  ^
+        if avoid_doubling:
+            just_entangled = {
+                ij for ij in just_entangled if (i not in ij) and (j not in ij)
+            }
+            just_entangled.add((i, j))
+
+        # update the register of where to place U3s
+        needs_u3[i] = needs_u3[j] = True
+
+    # place the final layer of U3s
+    for i in range(n):
+        if needs_u3[i]:
+            gates.append(("U3", *rand(3, scale=2 * math.pi), i))
+
+    return gates
+
+
+def gates_to_param_circuit(gates, n, parametrize="U3", **circuit_opts):
+    """Turn the sequence ``gates`` into a ``Circuit`` of ``n`` qubits, with any
+    gates that appear in ``parametrize`` being... parametrized.
+
+    Parameters
+    ----------
+    gates : sequence[tuple[str, float, int]]
+        The gates describing the circuit.
+    n : int
+        The number of qubits to make the circuit act one.
+    parametrize : str or sequence[str], optional
+        Which gates to parametrize.
+    circuit_opts
+        Supplied to :class:`~quimb.tensor.circuit.Circuit`.
+
+    Returns
+    -------
+    Circuit
+    """
+    from .circuit import Circuit
+
+    if isinstance(parametrize, str):
+        parametrize = (parametrize,)
+
+    circ = Circuit(n, **circuit_opts)
+    for g in gates:
+        circ.apply_gate(*g, parametrize=g[0] in parametrize)
+
+    return circ
+
+
+def circ_ansatz_1D_zigzag(n, depth, gate2="cz", seed=None, **circuit_opts):
+    r"""A 1D circuit ansatz with forward and backward layers of entangling
+    gates interleaved with U3 single qubit unitaries::
+
+        |  |  |  |
+        u  u  |  |
+        o++o  u  |
+        |  |  |  u
+        |  o++o  |
+        |  |  u  |
+        |  |  o++o
+        u  u  u  u
+        |  |  o++o
+        |  |  u  |
+        |  o++o  |
+        |  u  |  u
+        o++o  u  |
+        u  u  |  |
+        |  |  |  |
+
+    Parameters
+    ----------
+    n : int
+        The number of qubits.
+    depth : int
+        The number of entangling gates per pair.
+    gate2 : {'cx', 'cy', 'cz', 'iswap', ..., str}, optional
+        The gate to use for the entanling pairs.
+    seed : int, optional
+        Random seed for parameters.
+    opts
+        Supplied to :func:`~quimb.tensor.circuit_gen.gates_to_param_circuit`.
+
+    Returns
+    -------
+    Circuit
+
+    See Also
+    --------
+    circ_ansatz_1D_rand, circ_ansatz_1D_brickwork
+    """
+    ent_gates = []
+    forward_layer = [(i, i + 1) for i in range(n - 1)]
+    backward_layer = [(i + 1, i) for i in range(n - 2, -1, -1)]
+
+    for d in range(depth):
+        if d % 2 == 0:
+            ent_gates.extend(forward_layer)
+        else:
+            ent_gates.extend(backward_layer)
+
+    # inject U3 gates!
+    gates = inject_u3s(ent_gates, gate2=gate2, seed=seed)
+    circ = gates_to_param_circuit(gates, n, **circuit_opts)
+
+    return circ
+
+
+def circ_ansatz_1D_brickwork(
+    n, depth, cyclic=False, gate2="cz", seed=None, **circuit_opts
+):
+    r"""A 1D circuit ansatz with odd and even layers of entangling
+    gates interleaved with U3 single qubit unitaries::
+
+        |  |  |  |  |
+        |  u  u  u  u
+        u  o++o  o++o
+        |  u  u  u  |
+        o++o  o++o  u
+        |  u  u  u  |
+        u  o++o  o++o
+        |  u  u  u  |
+        o++o  o++o  u
+        |  u  u  u  u
+        u  o++o  o++o
+        |  u  u  u  |
+        o++o  o++o  u
+        u  u  u  u  |
+        |  |  |  |  |
+
+    Parameters
+    ----------
+    n : int
+        The number of qubits.
+    depth : int
+        The number of entangling gates per pair.
+    cyclic : bool, optional
+        Whether to add entangling gates between qubits 0 and n - 1.
+    gate2 : {'cx', 'cy', 'cz', 'iswap', ..., str}, optional
+        The gate to use for the entanling pairs.
+    seed : int, optional
+        Random seed for parameters.
+    opts
+        Supplied to :func:`~quimb.tensor.circuit_gen.gates_to_param_circuit`.
+
+
+    Returns
+    -------
+    Circuit
+
+    See Also
+    --------
+    circ_ansatz_1D_zigzag, circ_ansatz_1D_rand
+    """
+    ent_gates = []
+    for d in range(depth):
+        # the even pairs layer
+        ent_gates.extend((i, i + 1) for i in range(0, n - 1, 2))
+        if cyclic and (n % 2 == 1):
+            ent_gates.append((n - 1, 0))
+
+        # the odd pairs layer
+        ent_gates.extend((i, i + 1) for i in range(1, n - 1, 2))
+        if cyclic and (n % 2 == 0):
+            ent_gates.append((n - 1, 0))
+
+    # inject U3 gates!
+    gates = inject_u3s(ent_gates, gate2=gate2, seed=seed)
+    circ = gates_to_param_circuit(gates, n, **circuit_opts)
+
+    return circ
+
+
+def circ_ansatz_1D_rand(
+    n,
+    depth,
+    seed=None,
+    cyclic=False,
+    gate2="cz",
+    avoid_doubling=True,
+    **circuit_opts,
+):
+    """A 1D circuit ansatz with randomly place entangling gates interleaved
+    with U3 single qubit unitaries.
+
+    Parameters
+    ----------
+    n : int
+        The number of qubits.
+    depth : int
+        The number of entangling gates per pair.
+    seed : int, optional
+        Random seed.
+    cyclic : bool, optional
+        Whether to add entangling gates between qubits 0 and n - 1.
+    gate2 : {'cx', 'cy', 'cz', 'iswap', ..., str}, optional
+        The gate to use for the entanling pairs.
+    avoid_doubling : bool, optional
+        Whether to avoid placing an entangling gate directly above the same
+        entangling gate (there will still be single qubit gates interleaved).
+    opts
+        Supplied to :func:`~quimb.tensor.circuit_gen.gates_to_param_circuit`.
+
+    Returns
+    -------
+    Circuit
+
+    See Also
+    --------
+    circ_ansatz_1D_zigzag, circ_ansatz_1D_brickwork
+    """
+    if seed is not None:
+        random.seed(seed)
+
+    # the set number of entangling pairs to distribute randomly
+    ent_gates = [(i, i + 1) for i in range(n - 1) for _ in range(depth)]
+    if cyclic:
+        ent_gates.extend((n - 1, 0) for _ in range(depth))
+
+    # randomly permute the order
+    random.shuffle(ent_gates)
+
+    # inject U3 gates!
+    gates = inject_u3s(
+        ent_gates, avoid_doubling=avoid_doubling, gate2=gate2, seed=seed
+    )
+    circ = gates_to_param_circuit(gates, n, **circuit_opts)
+
+    return circ
+
+
+def circ_a2a_rand(
+    n,
+    depth,
+    seed=None,
+    gate2="cz",
+):
+    if not isinstance(seed, random.Random):
+        rng = random.Random(seed)
+
+    qubits = list(range(n))
+
+    ent_gates = []
+    for _ in range(depth):
+        rng.shuffle(qubits)
+        for i, j in zip(qubits[::2], qubits[1::2]):
+            ent_gates.append((i, j))
+
+    gates = inject_u3s(ent_gates, gate2=gate2, seed=seed)
+    circ = gates_to_param_circuit(gates, n)
+
+    return circ
+
+
+def circ_qaoa(
+    terms,
+    depth,
+    gammas,
+    betas,
+    **circuit_opts,
+):
+    r"""Generate the QAOA circuit for weighted graph described by ``terms``.
+
+    .. math::
+
+        |{\bar{\gamma}, \bar{\beta}}\rangle = U_B (\beta _p)
+        U_C (\gamma _p) \cdots U_B (\beta _1) U_C (\gamma _1) |{+}\rangle
+
+    with
+
+    .. math::
+
+        U_C (\gamma) = e^{-i \gamma \mathcal{C}} = \prod \limits_{i, j
+        \in E(G)} e^{-i \gamma w_{i j} Z_i Z_j}
+
+    and
+
+    .. math::
+
+        U_B (\beta) = \prod \limits_{i \in G} e^{-i \beta X_i}
+
+
+    Parameters
+    ----------
+    terms : dict[tuple[int], float]
+        The mapping of integer pair keys ``(i, j)`` to the edge weight values,
+        ``wij``. The integers should be a contiguous range enumerated from
+        zero, with the total number of qubits being inferred from this.
+    depth : int
+        The number of layers of gates to apply, ``p`` above.
+    gammas : iterable of float
+        The interaction angles for each layer.
+    betas : iterable of float
+        The rotation angles for each layer.
+    circuit_opts
+        Supplied to :class:`~quimb.tensor.circuit.Circuit`. Note
+        ``gate_opts={'contract': False}`` is set by default (it can be
+        overridden) since the RZZ gate, even though it has a rank-2
+        decomposition, is also diagonal.
+    """
+    from .circuit import Circuit
+
+    circuit_opts.setdefault("gate_opts", {})
+    circuit_opts["gate_opts"].setdefault("contract", False)
+
+    n = max(itertools.chain.from_iterable(terms)) + 1
+
+    gates = []
+
+    # layer of hadamards to get into plus state
+    for i in range(n):
+        gates.append((0, "h", i))
+
+    for d in range(depth):
+        for (i, j), wij in terms.items():
+            gates.append((d, "rzz", wij * gammas[d], i, j))
+
+        for i in range(n):
+            gates.append((d, "rx", -betas[d] * 2, i))
+
+    circ = Circuit(n, **circuit_opts)
+    circ.apply_gates(gates)
+
+    return circ