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

trajectree/quimb/quimb/gen/states.py

@@ -0,0 +1,479 @@
+"""Functions for generating quantum states.
+"""
+
+import itertools
+import functools
+import math
+import numpy as np
+
+from ..core import (dag, ldmul, dot, make_immutable,
+                    qu, kron, eye, ikron, kronpow)
+from ..linalg.base_linalg import eigh
+from .operators import pauli, controlled
+
+
+def basis_vec(i, dim, ownership=None, **kwargs):
+    r"""Constructs a unit vector ket:
+
+    .. math::
+
+        |i\rangle = \begin{pmatrix}
+        0 \\ \vdots \\ 1 \\ \vdots \\ 0
+        \end{pmatrix}
+
+    Parameters
+    ----------
+    i : int
+        Which index should the single non-zero, unit entry.
+    dim : int
+        Total size of hilbert space.
+    sparse : bool, optional
+        Return vector as sparse matrix.
+    kwargs
+        Supplied to ``qu``.
+
+    Returns
+    -------
+    vector
+        The basis vector.
+    """
+    if ownership is None:
+        shape = (dim, 1)
+        x = np.zeros(shape, dtype=complex)
+        x[i] = 1.0
+    else:
+        ri, rf = ownership
+        shape = (rf - ri, 1)
+        x = np.zeros(shape, dtype=complex)
+        if ri <= i < rf:
+            x[i - ri] = 1.0
+
+    return qu(x, **kwargs)
+
+
+@functools.lru_cache(8)
+def up(**kwargs):
+    r"""Returns up-state, aka. ``|0>``, +Z eigenstate:
+
+    .. math::
+
+        |0\rangle = \begin{pmatrix}
+        1 \\ 0
+        \end{pmatrix}
+
+    """
+    u = qu([[1], [0]], **kwargs)
+    make_immutable(u)
+    return u
+
+
+zplus = up
+
+
+@functools.lru_cache(8)
+def down(**kwargs):
+    r"""Returns down-state, aka. ``|1>``, -Z eigenstate:
+
+    .. math::
+
+        |1\rangle = \begin{pmatrix}
+        0 \\ 1
+        \end{pmatrix}
+
+    """
+    d = qu([[0], [1]], **kwargs)
+    make_immutable(d)
+    return d
+
+
+zminus = down
+
+
+@functools.lru_cache(8)
+def plus(**kwargs):
+    r"""Returns plus-state, aka. ``|+>``, +X eigenstate:
+
+    .. math::
+
+        |+\rangle = \frac{1}{\sqrt{2}} \begin{pmatrix}
+        1 \\ 1
+        \end{pmatrix}
+
+    """
+    return qu([[2**-0.5], [2**-0.5]], **kwargs)
+
+
+xplus = plus
+
+
+@functools.lru_cache(8)
+def minus(**kwargs):
+    r"""Returns minus-state, aka. ``|->``, -X eigenstate:
+
+    .. math::
+
+        |-\rangle = \frac{1}{\sqrt{2}} \begin{pmatrix}
+        1 \\ -1
+        \end{pmatrix}
+
+    """
+    return qu([[2**-0.5], [-2**-0.5]], **kwargs)
+
+
+xminus = minus
+
+
+@functools.lru_cache(8)
+def yplus(**kwargs):
+    r"""Returns yplus-state, aka. ``|y+>``, +Y eigenstate:
+
+    .. math::
+
+        |y+\rangle = \frac{1}{\sqrt{2}} \begin{pmatrix}
+        1 \\ i
+        \end{pmatrix}
+
+    """
+    return qu([[2**-0.5], [1.0j / (2**0.5)]], **kwargs)
+
+
+@functools.lru_cache(8)
+def yminus(**kwargs):
+    r"""Returns yplus-state, aka. ``|y->``, -Y eigenstate:
+
+    .. math::
+
+        |y-\rangle = \frac{1}{\sqrt{2}} \begin{pmatrix}
+        1 \\ -i
+        \end{pmatrix}
+
+    """
+    return qu([[2**-0.5], [-1.0j / (2**0.5)]], **kwargs)
+
+
+def bloch_state(ax, ay, az, purified=False, **kwargs):
+    r"""Construct qubit density operator from bloch vector:
+
+    .. math::
+
+        \rho = \frac{1}{2} \left( I + a_x X + a_y Y + a_z Z \right)
+
+    Parameters
+    ----------
+    ax : float
+        X component of bloch vector.
+    ay : float
+        Y component of bloch vector.
+    az : float
+        Z component of bloch vector.
+    purified :
+        Whether to map vector to surface of bloch sphere.
+
+    Returns
+    -------
+    Matrix
+        Density operator of qubit 'pointing' in (ax, ay, az) direction.
+    """
+    n = (ax**2 + ay**2 + az**2)**.5
+    if purified:
+        ax, ay, az = (a / n for a in (ax, ay, az))
+    return sum(0.5 * a * pauli(s, **kwargs)
+               for a, s in zip((1, ax, ay, az), "ixyz"))
+
+
+@functools.lru_cache(maxsize=8)
+def bell_state(s, **kwargs):
+    r"""One of the four bell-states.
+
+    If n = 2**-0.5, they are:
+
+        0. ``'psi-'`` : ``n * ( |01> - |10> )``
+        1. ``'psi+'`` : ``n * ( |01> + |10> )``
+        2. ``'phi-'`` : ``n * ( |00> - |11> )``
+        3. ``'phi+'`` : ``n * ( |00> + |11> )``
+
+    They can be enumerated in this order.
+
+    Parameters
+    ----------
+    s : str or int
+        String of number of state corresponding to above.
+    kwargs :
+        Supplied to ``qu`` called on state.
+
+    Returns
+    -------
+    p : immutable vector
+        The bell-state ``s``.
+    """
+    keymap = {"psi-": "psi-", 0: "psi-", "psim": "psi-",
+              "psi+": "psi+", 1: "psi+", "psip": "psi+",
+              "phi-": "phi-", 2: "phi-", "phim": "phi-",
+              "phi+": "phi+", 3: "phi+", "phip": "phi+"}
+    c = 2.**-.5
+    statemap = {"psi-": lambda: qu([0, c, -c, 0], **kwargs),
+                "phi+": lambda: qu([c, 0, 0, c], **kwargs),
+                "phi-": lambda: qu([c, 0, 0, -c], **kwargs),
+                "psi+": lambda: qu([0, c, c, 0], **kwargs)}
+    state = statemap[keymap[s]]()
+    make_immutable(state)
+    return state
+
+
+def singlet(**kwargs):
+    """Alias for the 'psi-' bell-state.
+    """
+    return bell_state("psi-", **kwargs)
+
+
+def thermal_state(ham, beta, precomp_func=False):
+    """Generate a thermal state of a Hamiltonian.
+
+    Parameters
+    ----------
+    ham : operator or (1d-array, 2d-array)
+        Hamiltonian, either full or tuple of (evals, evecs).
+    beta : float
+        Inverse temperature of state.
+    precomp_func : bool, optional
+        If True, return a function that takes ``beta``
+        only and is closed over the solved hamiltonian.
+
+    Returns
+    -------
+    operator or callable
+        Density operator of thermal state, or function to generate such given
+        a temperature.
+    """
+    if isinstance(ham, (list, tuple)):  # solved already
+        evals, evecs = ham
+    else:
+        evals, evecs = eigh(ham)
+    evals -= evals.min()  # offset by min to avoid numeric problems
+
+    def gen_state(b):
+        el = np.exp(-b * evals)
+        el /= np.sum(el)
+        return dot(evecs, ldmul(el, dag(evecs)))
+
+    return gen_state if precomp_func else gen_state(beta)
+
+
+def computational_state(binary, **kwargs):
+    """Generate the qubit computational state with ``binary``.
+
+    Parameters
+    ----------
+    binary : sequence of 0s and 1s
+        The binary of the computation state.
+
+    Examples
+    --------
+    >>> computational_state('101'):
+    qarray([[0.+0.j],
+            [0.+0.j],
+            [0.+0.j],
+            [0.+0.j],
+            [0.+0.j],
+            [1.+0.j],
+            [0.+0.j],
+            [0.+0.j]])
+
+    >>> qu.computational_state([0, 1], qtype='dop')
+    qarray([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
+            [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
+            [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
+            [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]])
+
+    See Also
+    --------
+    MPS_computational_state, basic_vec
+    """
+    if not isinstance(binary, str):
+        binary = "".join(map(str, binary))
+
+    return basis_vec(int(binary, 2), 2 ** len(binary), **kwargs)
+
+
+def neel_state(n, down_first=False, **kwargs):
+    """Construct Neel state for n spins, i.e. alternating up/down.
+
+    Parameters
+    ----------
+    n : int
+        Number of spins.
+    down_first : bool, optional
+        Whether to start with '1' or '0' first.
+    kwargs
+        Supplied to ``qu`` called on state.
+
+    See Also
+    --------
+    computational_state, MPS_neel_state
+    """
+    binary = "01" * (n // 2) + (n % 2 == 1) * "0"
+    if down_first:
+        binary = "1" + binary[:-1]
+
+    return computational_state(binary, **kwargs)
+
+
+def singlet_pairs(n, **kwargs):
+    """Construct fully dimerised spin chain.
+
+    I.e. ``bell_state('psi-') & bell_state('psi-') & ...``
+
+    Parameters
+    ----------
+    n : int
+        Number of spins.
+    kwargs
+        Supplied to ``qu`` called on state.
+
+    Returns
+    -------
+    vector
+    """
+    return kronpow(bell_state('psi-', **kwargs), (n // 2))
+
+
+def werner_state(p, **kwargs):
+    """Construct Werner State, i.e. fractional mix of identity with singlet.
+
+    Parameters
+    ----------
+    p : float
+        Singlet Fraction.
+    kwargs
+        Supplied to :func:`~quimb.qu` called on state.
+
+    Returns
+    -------
+    qarray
+    """
+    return (p * bell_state('psi-', qtype="dop", **kwargs) +
+            (1 - p) * eye(4, **kwargs) / 4)
+
+
+def ghz_state(n, **kwargs):
+    """Construct GHZ state of `n` spins, i.e. equal superposition of all up
+    and down.
+
+    Parameters
+    ----------
+    n : int
+        Number of spins.
+    kwargs
+        Supplied to ``qu`` called on state.
+
+    Returns
+    -------
+    vector
+    """
+    psi = (basis_vec(0, 2**n) +
+           basis_vec(2**n - 1, 2**n)) / 2.**.5
+    return qu(psi, **kwargs)
+
+
+def w_state(n, **kwargs):
+    """Construct W-state: equal superposition of all single spin up states.
+
+    Parameters
+    ----------
+    n : int
+        Number of spins.
+    kwargs
+        Supplied to ``qu`` called on state.
+
+    Returns
+    -------
+    vector
+    """
+    return sum(basis_vec(2**i, 2**n, **kwargs) for i in range(n)) / n**0.5
+
+
+def levi_civita(perm):
+    """Compute the generalised levi-civita coefficient for a permutation.
+
+    Parameters
+    ----------
+    perm : sequence of int
+        The permutation, a re-arrangement of ``range(n)``.
+
+    Returns
+    -------
+    int
+        Either -1, 0 or 1.
+    """
+    n = len(perm)
+    if n != len(set(perm)):  # infer there are repeated elements
+        return 0
+    mat = np.zeros((n, n), dtype=np.int32)
+    for i, j in zip(range(n), perm):
+        mat[i, j] = 1
+    return int(np.linalg.det(mat))
+
+
+def perm_state(ps):
+    """Construct the anti-symmetric state which is the +- sum of all
+    tensored permutations of states ``ps``.
+
+    Parameters
+    ----------
+    ps :  sequence of states
+        The states to combine.
+
+    Returns
+    -------
+    vector or operator
+        The permutation state, dimension same as ``kron(*ps)``.
+
+    Examples
+    --------
+    A singlet is the ``perm_state`` of up and down.
+
+    >>> states = [up(), down()]
+    >>> pstate = perm_state(states)
+    >>> expec(pstate, singlet())
+    1.0
+    """
+    n = len(ps)
+    vec_perm = itertools.permutations(ps)
+    ind_perm = itertools.permutations(range(n))
+
+    def terms():
+        for vec, ind in zip(vec_perm, ind_perm):
+            yield levi_civita(ind) * kron(*vec)
+
+    return sum(terms()) / math.factorial(n)**0.5
+
+
+def graph_state_1d(n, cyclic=False, sparse=False):
+    """Graph State on a line.
+
+    Parameters
+    ----------
+    n : int
+        The number of spins.
+    cyclic : bool, optional
+        Whether to use cyclic boundary conditions for the graph.
+    sparse : bool, optional
+        Whether to return a sparse state.
+
+    Returns
+    -------
+    vector
+        The 1d-graph state.
+    """
+    p = kronpow(plus(sparse=sparse), n)
+
+    for i in range(n - 1):
+        p = ikron(controlled("z", sparse=True), [2] * n, (i, i + 1)) @ p
+
+    if cyclic:
+        p = ((eye(2, sparse=True) & eye(2**(n - 2), sparse=True) &
+              qu([1, 0], qtype="dop", sparse=True)) +
+             (pauli("z", sparse=True) & eye(2**(n - 2), sparse=True) &
+              qu([0, 1], qtype="dop", sparse=True))) @ p
+
+    return p

trajectree/quimb/quimb/linalg/__init__.py

@@ -0,0 +1,6 @@
+"""Linear algebra routines to solve quantum systems for example.
+"""
+
+from ..utils import find_library
+
+SLEPC4PY_FOUND = find_library("slepc4py")