qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/quantum_info/states/utils.py

@@ -0,0 +1,245 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Quantum information utility functions for states.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.states.statevector import Statevector
+from qiskit.quantum_info.states.densitymatrix import DensityMatrix
+from qiskit.quantum_info.operators.channel import SuperOp
+from qiskit.quantum_info.operators.predicates import ATOL_DEFAULT
+
+
+def partial_trace(state: Statevector | DensityMatrix, qargs: list) -> DensityMatrix:
+    """Return reduced density matrix by tracing out part of quantum state.
+
+    If all subsystems are traced over this returns the
+    :meth:`~qiskit.quantum_info.DensityMatrix.trace` of the
+    input state.
+
+    Args:
+        state (Statevector or DensityMatrix): the input state.
+        qargs (list): The subsystems to trace over.
+
+    Returns:
+        DensityMatrix: The reduced density matrix.
+
+    Raises:
+        QiskitError: if input state is invalid.
+    """
+    state = _format_state(state, validate=False)
+
+    # Compute traced shape
+    traced_shape = state._op_shape.remove(qargs=qargs)
+    # Convert vector shape to matrix shape
+    traced_shape._dims_r = traced_shape._dims_l
+    traced_shape._num_qargs_r = traced_shape._num_qargs_l
+
+    # If we are tracing over all subsystems we return the trace
+    if traced_shape.size == 0:
+        return state.trace()
+
+    # Statevector case
+    if isinstance(state, Statevector):
+        trace_systems = len(state._op_shape.dims_l()) - 1 - np.array(qargs)
+        arr = state._data.reshape(state._op_shape.tensor_shape)
+        rho = np.tensordot(arr, arr.conj(), axes=(trace_systems, trace_systems))
+        rho = np.reshape(rho, traced_shape.shape)
+        return DensityMatrix(rho, dims=traced_shape._dims_l)
+
+    # Density matrix case
+    # Empty partial trace case.
+    if not qargs:
+        return state.copy()
+    # Trace first subsystem to avoid coping whole density matrix
+    dims = state.dims(qargs)
+    tr_op = SuperOp(np.eye(dims[0]).reshape(1, dims[0] ** 2), input_dims=[dims[0]], output_dims=[1])
+    ret = state.evolve(tr_op, [qargs[0]])
+    # Trace over remaining subsystems
+    for qarg, dim in zip(qargs[1:], dims[1:]):
+        tr_op = SuperOp(np.eye(dim).reshape(1, dim**2), input_dims=[dim], output_dims=[1])
+        ret = ret.evolve(tr_op, [qarg])
+    # Remove traced over subsystems which are listed as dimension 1
+    ret._op_shape = traced_shape
+    return ret
+
+
+def shannon_entropy(pvec: list | np.ndarray, base: int = 2) -> float:
+    r"""Compute the Shannon entropy of a probability vector.
+
+    The shannon entropy of a probability vector
+    :math:`\vec{p} = [p_0, ..., p_{n-1}]` is defined as
+
+    .. math::
+
+        H(\vec{p}) = \sum_{i=0}^{n-1} p_i \log_b(p_i)
+
+    where :math:`b` is the log base and (default 2), and
+    :math:`0 \log_b(0) \equiv 0`.
+
+    Args:
+        pvec (array_like): a probability vector.
+        base (int): the base of the logarithm [Default: 2].
+
+    Returns:
+        float: The Shannon entropy H(pvec).
+    """
+    if base == 2:
+
+        def logfn(x):
+            return -x * np.log2(x)
+
+    elif base == np.e:
+
+        def logfn(x):
+            return -x * np.log(x)
+
+    else:
+
+        def logfn(x):
+            return -x * np.log(x) / np.log(base)
+
+    h_val = 0.0
+    for x in pvec:
+        if 0 < x < 1:
+            h_val += logfn(x)
+    return h_val
+
+
+def schmidt_decomposition(state, qargs):
+    r"""Return the Schmidt Decomposition of a pure quantum state.
+
+    For an arbitrary bipartite state:
+
+    .. math::
+         |\psi\rangle_{AB} = \sum_{i,j} c_{ij}
+                             |x_i\rangle_A \otimes |y_j\rangle_B,
+
+    its Schmidt Decomposition is given by the single-index sum over k:
+
+    .. math::
+        |\psi\rangle_{AB} = \sum_{k} \lambda_{k}
+                            |u_k\rangle_A \otimes |v_k\rangle_B
+
+    where :math:`|u_k\rangle_A` and :math:`|v_k\rangle_B` are an
+    orthonormal set of vectors in their respective spaces :math:`A` and :math:`B`,
+    and the Schmidt coefficients :math:`\lambda_k` are positive real values.
+
+    Args:
+        state (Statevector or DensityMatrix): the input state.
+        qargs (list): the list of Input state positions corresponding to subsystem :math:`B`.
+
+    Returns:
+        list: list of tuples ``(s, u, v)``, where ``s`` (float) are the Schmidt coefficients
+        :math:`\lambda_k`, and ``u`` (Statevector), ``v`` (Statevector) are the Schmidt vectors
+        :math:`|u_k\rangle_A`, :math:`|u_k\rangle_B`, respectively.
+
+    Raises:
+        QiskitError: if Input qargs is not a list of positions of the Input state.
+        QiskitError: if Input qargs is not a proper subset of Input state.
+
+    .. note::
+        In Qiskit, qubits are ordered using little-endian notation, with the least significant
+        qubits having smaller indices. For example, a four-qubit system is represented as
+        :math:`|q_3q_2q_1q_0\rangle`. Using this convention, setting ``qargs=[0]`` will partition the
+        state as :math:`|q_3q_2q_1\rangle_A\otimes|q_0\rangle_B`. Furthermore, qubits will be organized
+        in this notation regardless of the order they are passed. For instance, passing either
+        ``qargs=[1,2]`` or ``qargs=[2,1]`` will result in partitioning the state as
+        :math:`|q_3q_0\rangle_A\otimes|q_2q_1\rangle_B`.
+    """
+    state = _format_state(state, validate=False)
+
+    # convert to statevector if state is density matrix. Errors if state is mixed.
+    if isinstance(state, DensityMatrix):
+        state = state.to_statevector()
+
+    # reshape statevector into state tensor
+    dims = state.dims()
+    state_tens = state._data.reshape(dims[::-1])
+    ndim = state_tens.ndim
+    qudits = list(range(ndim))
+
+    # check if qargs are valid
+    if not isinstance(qargs, (list, np.ndarray)):
+        raise QiskitError("Input qargs is not a list of positions of the Input state")
+    qargs = set(qargs)
+    if qargs == set(qudits) or not qargs.issubset(qudits):
+        raise QiskitError("Input qargs is not a proper subset of Input state")
+
+    # define subsystem A and B qargs and dims
+    qargs_b = list(qargs)
+    qargs_a = [i for i in qudits if i not in qargs_b]
+    dims_b = state.dims(qargs_b)
+    dims_a = state.dims(qargs_a)
+    ndim_b = np.prod(dims_b)
+    ndim_a = np.prod(dims_a)
+
+    # permute state for desired qargs order
+    qargs_axes = [qudits[::-1].index(i) for i in qargs_b + qargs_a][::-1]
+    state_tens = state_tens.transpose(qargs_axes)
+
+    # convert state tensor to matrix of prob amplitudes and perform svd.
+    state_mat = state_tens.reshape([ndim_a, ndim_b])
+    u_mat, s_arr, vh_mat = np.linalg.svd(state_mat, full_matrices=False)
+
+    schmidt_components = [
+        (s, Statevector(u, dims=dims_a), Statevector(v, dims=dims_b))
+        for s, u, v in zip(s_arr, u_mat.T, vh_mat)
+        if s > ATOL_DEFAULT
+    ]
+
+    return schmidt_components
+
+
+def _format_state(state, validate=True):
+    """Format input state into class object"""
+    if isinstance(state, list):
+        state = np.array(state, dtype=complex)
+    if isinstance(state, np.ndarray):
+        ndim = state.ndim
+        if ndim == 1:
+            state = Statevector(state)
+        elif ndim == 2:
+            dim1, dim2 = state.shape
+            if dim2 == 1:
+                state = Statevector(state)
+            elif dim1 == dim2:
+                state = DensityMatrix(state)
+    if not isinstance(state, (Statevector, DensityMatrix)):
+        raise QiskitError("Input is not a quantum state")
+    if validate and not state.is_valid():
+        raise QiskitError("Input quantum state is not a valid")
+    return state
+
+
+def _funm_svd(matrix, func):
+    """Apply real scalar function to singular values of a matrix.
+
+    Args:
+        matrix (array_like): (N, N) Matrix at which to evaluate the function.
+        func (callable): Callable object that evaluates a scalar function f.
+
+    Returns:
+        ndarray: funm (N, N) Value of the matrix function specified by func
+                 evaluated at `A`.
+    """
+    import scipy.linalg as la
+
+    unitary1, singular_values, unitary2 = la.svd(matrix)
+    diag_func_singular = np.diag(func(singular_values))
+    return unitary1.dot(diag_func_singular).dot(unitary2)

qiskit/quantum_info/synthesis/__init__.py

@@ -0,0 +1,20 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""State and Unitary synthesis methods."""
+
+from __future__ import annotations
+from .two_qubit_decompose import TwoQubitBasisDecomposer, two_qubit_cnot_decompose
+from .one_qubit_decompose import OneQubitEulerDecomposer
+from .quaternion import Quaternion
+from .clifford_decompose import decompose_clifford
+from .xx_decompose.decomposer import XXDecomposer

qiskit/quantum_info/synthesis/clifford_decompose.py

@@ -0,0 +1,69 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Circuit synthesis for the Clifford class.
+"""
+
+from __future__ import annotations
+from qiskit.synthesis.clifford import (
+    synth_clifford_ag,
+    synth_clifford_bm,
+    synth_clifford_greedy,
+)
+from qiskit.utils.deprecation import deprecate_func
+
+
+@deprecate_func(
+    additional_msg="Instead, use the function qiskit.synthesis.synth_clifford_full.",
+    since="0.23.0",
+    package_name="qiskit-terra",
+)
+def decompose_clifford(clifford, method=None):
+    """DEPRECATED: Decompose a Clifford operator into a QuantumCircuit.
+
+    For N <= 3 qubits this is based on optimal CX cost decomposition
+    from reference [1]. For N > 3 qubits this is done using the general
+    non-optimal greedy compilation routine from reference [3],
+    which typically yields better CX cost compared to the AG method in [2].
+
+    Args:
+        clifford (Clifford): a clifford operator.
+        method (str):  Optional, a synthesis method ('AG' or 'greedy').
+             If set this overrides optimal decomposition for N <=3 qubits.
+
+    Return:
+        QuantumCircuit: a circuit implementation of the Clifford.
+
+    References:
+        1. S. Bravyi, D. Maslov, *Hadamard-free circuits expose the
+           structure of the Clifford group*,
+           `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
+
+        2. S. Aaronson, D. Gottesman, *Improved Simulation of Stabilizer Circuits*,
+           Phys. Rev. A 70, 052328 (2004).
+           `arXiv:quant-ph/0406196 <https://arxiv.org/abs/quant-ph/0406196>`_
+
+        3. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin,
+           *Clifford Circuit Optimization with Templates and Symbolic Pauli Gates*,
+           `arXiv:2105.02291 [quant-ph] <https://arxiv.org/abs/2105.02291>`_
+    """
+    num_qubits = clifford.num_qubits
+    if method == "AG":
+        return synth_clifford_ag(clifford)
+
+    if method == "greedy":
+        return synth_clifford_greedy(clifford)
+
+    if num_qubits <= 3:
+        return synth_clifford_bm(clifford)
+
+    return synth_clifford_greedy(clifford)

qiskit/quantum_info/synthesis/cnotdihedral_decompose.py

@@ -0,0 +1,50 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Circuit synthesis for the CNOTDihedral class.
+"""
+
+from __future__ import annotations
+from qiskit.synthesis.cnotdihedral import (
+    synth_cnotdihedral_two_qubits,
+    synth_cnotdihedral_general,
+)
+from qiskit.utils.deprecation import deprecate_func
+
+
+@deprecate_func(
+    additional_msg="Instead, use the function qiskit.synthesis.synth_cnotdihedral_full.",
+    since="0.23.0",
+    package_name="qiskit-terra",
+)
+def decompose_cnotdihedral(elem):
+    """DEPRECATED: Decompose a CNOTDihedral element into a QuantumCircuit.
+
+    Args:
+        elem (CNOTDihedral): a CNOTDihedral element.
+    Return:
+        QuantumCircuit: a circuit implementation of the CNOTDihedral element.
+
+    References:
+        1. Shelly Garion and Andrew W. Cross, *Synthesis of CNOT-Dihedral circuits
+           with optimal number of two qubit gates*, `Quantum 4(369), 2020
+           <https://quantum-journal.org/papers/q-2020-12-07-369/>`_
+        2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta,
+           *Scalable randomised benchmarking of non-Clifford gates*,
+           npj Quantum Inf 2, 16012 (2016).
+    """
+
+    num_qubits = elem.num_qubits
+    if num_qubits < 3:
+        return synth_cnotdihedral_two_qubits(elem)
+
+    return synth_cnotdihedral_general(elem)

qiskit/quantum_info/synthesis/ion_decompose.py

@@ -0,0 +1,55 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Decomposition methods for trapped-ion basis gates RXXGate, RXGate, RYGate.
+"""
+
+from __future__ import annotations
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.library.standard_gates.ry import RYGate
+from qiskit.circuit.library.standard_gates.rx import RXGate
+from qiskit.circuit.library.standard_gates.rxx import RXXGate
+
+
+def cnot_rxx_decompose(plus_ry: bool = True, plus_rxx: bool = True):
+    """Decomposition of CNOT gate.
+
+    NOTE: this differs to CNOT by a global phase.
+    The matrix returned is given by exp(1j * pi/4) * CNOT
+
+    Args:
+        plus_ry (bool): positive initial RY rotation
+        plus_rxx (bool): positive RXX rotation.
+
+    Returns:
+        QuantumCircuit: The decomposed circuit for CNOT gate (up to
+        global phase).
+    """
+    # Convert boolean args to +/- 1 signs
+    if plus_ry:
+        sgn_ry = 1
+    else:
+        sgn_ry = -1
+    if plus_rxx:
+        sgn_rxx = 1
+    else:
+        sgn_rxx = -1
+    circuit = QuantumCircuit(2, global_phase=-sgn_ry * sgn_rxx * np.pi / 4)
+    circuit.append(RYGate(sgn_ry * np.pi / 2), [0])
+    circuit.append(RXXGate(sgn_rxx * np.pi / 2), [0, 1])
+    circuit.append(RXGate(-sgn_rxx * np.pi / 2), [0])
+    circuit.append(RXGate(-sgn_rxx * sgn_ry * np.pi / 2), [1])
+    circuit.append(RYGate(-sgn_ry * np.pi / 2), [0])
+    return circuit

qiskit/quantum_info/synthesis/local_invariance.py

@@ -0,0 +1,93 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+# pylint: disable=invalid-name
+
+"""Routines that use local invariants to compute properties
+of two-qubit unitary operators.
+"""
+from __future__ import annotations
+from math import sqrt
+import numpy as np
+
+INVARIANT_TOL = 1e-12
+
+# Bell "Magic" basis
+MAGIC = (
+    1.0
+    / sqrt(2)
+    * np.array([[1, 0, 0, 1j], [0, 1j, 1, 0], [0, 1j, -1, 0], [1, 0, 0, -1j]], dtype=complex)
+)
+
+
+def two_qubit_local_invariants(U: np.ndarray) -> np.ndarray:
+    """Computes the local invariants for a two-qubit unitary.
+
+    Args:
+        U (ndarray): Input two-qubit unitary.
+
+    Returns:
+        ndarray: NumPy array of local invariants [g0, g1, g2].
+
+    Raises:
+        ValueError: Input not a 2q unitary.
+
+    Notes:
+        Y. Makhlin, Quant. Info. Proc. 1, 243-252 (2002).
+        Zhang et al., Phys Rev A. 67, 042313 (2003).
+    """
+    U = np.asarray(U)
+    if U.shape != (4, 4):
+        raise ValueError("Unitary must correspond to a two-qubit gate.")
+
+    # Transform to bell basis
+    Um = MAGIC.conj().T.dot(U.dot(MAGIC))
+    # Get determinate since +- one is allowed.
+    det_um = np.linalg.det(Um)
+    M = Um.T.dot(Um)
+    # trace(M)**2
+    m_tr2 = M.trace()
+    m_tr2 *= m_tr2
+
+    # Table II of Ref. 1 or Eq. 28 of Ref. 2.
+    G1 = m_tr2 / (16 * det_um)
+    G2 = (m_tr2 - np.trace(M.dot(M))) / (4 * det_um)
+
+    # Here we split the real and imag pieces of G1 into two so as
+    # to better equate to the Weyl chamber coordinates (c0,c1,c2)
+    # and explore the parameter space.
+    # Also do a FP trick -0.0 + 0.0 = 0.0
+    return np.round([G1.real, G1.imag, G2.real], 12) + 0.0
+
+
+def local_equivalence(weyl: np.ndarray) -> np.ndarray:
+    """Computes the equivalent local invariants from the
+    Weyl coordinates.
+
+    Args:
+        weyl (ndarray): Weyl coordinates.
+
+    Returns:
+        ndarray: Local equivalent coordinates [g0, g1, g3].
+
+    Notes:
+        This uses Eq. 30 from Zhang et al, PRA 67, 042313 (2003),
+        but we multiply weyl coordinates by 2 since we are
+        working in the reduced chamber.
+    """
+    g0_equiv = np.prod(np.cos(2 * weyl) ** 2) - np.prod(np.sin(2 * weyl) ** 2)
+    g1_equiv = np.prod(np.sin(4 * weyl)) / 4
+    g2_equiv = (
+        4 * np.prod(np.cos(2 * weyl) ** 2)
+        - 4 * np.prod(np.sin(2 * weyl) ** 2)
+        - np.prod(np.cos(4 * weyl))
+    )
+    return np.round([g0_equiv, g1_equiv, g2_equiv], 12) + 0.0