qiskit 1.3.0__cp39-abi3-win32.whl → 1.3.0b1__cp39-abi3-win32.whl

qiskit/synthesis/evolution/qdrift.py

@@ -16,19 +16,14 @@ from __future__ import annotations
 
 import inspect
 import math
-import typing
-from itertools import chain
 from collections.abc import Callable
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.quantum_info.operators import SparsePauliOp, Pauli
 from qiskit.utils.deprecation import deprecate_arg
-from qiskit.exceptions import QiskitError
 
-from .product_formula import ProductFormula, reorder_paulis
-
-if typing.TYPE_CHECKING:
-    from qiskit.circuit.library import PauliEvolutionGate
+from .product_formula import ProductFormula
+from .lie_trotter import LieTrotter
 
 
 class QDrift(ProductFormula):
@@ -68,7 +63,6 @@ class QDrift(ProductFormula):
         ) = None,
         seed: int | None = None,
         wrap: bool = False,
-        preserve_order: bool = True,
     ) -> None:
         r"""
         Args:
@@ -89,50 +83,49 @@ class QDrift(ProductFormula):
             seed: An optional seed for reproducibility of the random sampling process.
             wrap: Whether to wrap the atomic evolutions into custom gate objects. This only takes
                 effect when ``atomic_evolution is None``.
-            preserve_order: If ``False``, allows reordering the terms of the operator to
-                potentially yield a shallower evolution circuit. Not relevant
-                when synthesizing operator with a single term.
         """
-        super().__init__(
-            1, reps, insert_barriers, cx_structure, atomic_evolution, wrap, preserve_order
-        )
+        super().__init__(1, reps, insert_barriers, cx_structure, atomic_evolution, wrap)
         self.sampled_ops = None
         self.rng = np.random.default_rng(seed)
 
-    def expand(self, evolution: PauliEvolutionGate) -> list[tuple[str, tuple[int], float]]:
+    def synthesize(self, evolution):
+        # get operators and time to evolve
         operators = evolution.operator
-        time = evolution.time  # used to determine the number of gates
+        time = evolution.time
 
-        # QDrift is based on first-order Lie-Trotter, hence we can just concatenate all
-        # Pauli terms and ignore commutations
-        if isinstance(operators, list):
-            paulis = list(chain.from_iterable([op.to_sparse_list() for op in operators]))
+        if not isinstance(operators, list):
+            pauli_list = [(Pauli(op), coeff) for op, coeff in operators.to_list()]
+            coeffs = [np.real(coeff) for op, coeff in operators.to_list()]
         else:
-            paulis = operators.to_sparse_list()
-
-        try:
-            coeffs = [float(np.real_if_close(coeff)) for _, _, coeff in paulis]
-        except TypeError as exc:
-            raise QiskitError("QDrift requires bound, real coefficients.") from exc
+            pauli_list = [(op, 1) for op in operators]
+            coeffs = [1 for op in operators]
 
         # We artificially make the weights positive
         weights = np.abs(coeffs)
         lambd = np.sum(weights)
 
         num_gates = math.ceil(2 * (lambd**2) * (time**2) * self.reps)
-
         # The protocol calls for the removal of the individual coefficients,
         # and multiplication by a constant evolution time.
-        sampled = self.rng.choice(
-            np.array(paulis, dtype=object), size=(num_gates,), p=weights / lambd
+        evolution_time = lambd * time / num_gates
+
+        self.sampled_ops = self.rng.choice(
+            np.array(pauli_list, dtype=object),
+            size=(num_gates,),
+            p=weights / lambd,
         )
 
-        rescaled_time = 2 * lambd / num_gates * time
-        sampled_paulis = [
-            (pauli[0], pauli[1], np.real(np.sign(pauli[2])) * rescaled_time) for pauli in sampled
-        ]
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.library.pauli_evolution import PauliEvolutionGate
 
-        if not self.preserve_order:
-            sampled_paulis = reorder_paulis(sampled_paulis)
+        # Build the evolution circuit using the LieTrotter synthesis with the sampled operators
+        lie_trotter = LieTrotter(
+            insert_barriers=self.insert_barriers, atomic_evolution=self.atomic_evolution
+        )
+        evolution_circuit = PauliEvolutionGate(
+            sum(SparsePauliOp(np.sign(coeff) * op) for op, coeff in self.sampled_ops),
+            time=evolution_time,
+            synthesis=lie_trotter,
+        ).definition
 
-        return sampled_paulis
+        return evolution_circuit

qiskit/synthesis/evolution/suzuki_trotter.py

@@ -15,19 +15,16 @@
 from __future__ import annotations
 
 import inspect
-import typing
 from collections.abc import Callable
-from itertools import chain
+
+import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.quantum_info.operators import SparsePauliOp, Pauli
 from qiskit.utils.deprecation import deprecate_arg
 
-from .product_formula import ProductFormula, reorder_paulis
 
-if typing.TYPE_CHECKING:
-    from qiskit.circuit.quantumcircuit import ParameterValueType
-    from qiskit.circuit.library.pauli_evolution import PauliEvolutionGate
+from .product_formula import ProductFormula
 
 
 class SuzukiTrotter(ProductFormula):
@@ -47,7 +44,7 @@ class SuzukiTrotter(ProductFormula):
 
     .. math::
 
-        e^{-it(XI + ZZ)} = e^{-it/2 XI}e^{-it ZZ}e^{-it/2 XI} + \mathcal{O}(t^3).
+        e^{-it(XX + ZZ)} = e^{-it/2 ZZ}e^{-it XX}e^{-it/2 ZZ} + \mathcal{O}(t^3).
 
     References:
         [1]: D. Berry, G. Ahokas, R. Cleve and B. Sanders,
@@ -85,7 +82,6 @@ class SuzukiTrotter(ProductFormula):
             | None
         ) = None,
         wrap: bool = False,
-        preserve_order: bool = True,
     ) -> None:
         """
         Args:
@@ -105,111 +101,55 @@ class SuzukiTrotter(ProductFormula):
                 built.
             wrap: Whether to wrap the atomic evolutions into custom gate objects. This only takes
                 effect when ``atomic_evolution is None``.
-            preserve_order: If ``False``, allows reordering the terms of the operator to
-                potentially yield a shallower evolution circuit. Not relevant
-                when synthesizing operator with a single term.
         Raises:
             ValueError: If order is not even
         """
 
-        if order > 1 and order % 2 == 1:
+        if order % 2 == 1:
             raise ValueError(
                 "Suzuki product formulae are symmetric and therefore only defined "
-                f"for when the order is 1 or even, not {order}."
+                "for even orders."
             )
-        super().__init__(
-            order,
-            reps,
-            insert_barriers,
-            cx_structure,
-            atomic_evolution,
-            wrap,
-            preserve_order=preserve_order,
-        )
-
-    def expand(
-        self, evolution: PauliEvolutionGate
-    ) -> list[tuple[str, list[int], ParameterValueType]]:
-        """Expand the Hamiltonian into a Suzuki-Trotter sequence of sparse gates.
-
-        For example, the Hamiltonian ``H = IX + ZZ`` for an evolution time ``t`` and
-        1 repetition for an order 2 formula would get decomposed into a list of 3-tuples
-        containing ``(pauli, indices, rz_rotation_angle)``, that is:
-
-        .. code-block:: text
-
-            ("X", [0], t), ("ZZ", [0, 1], 2t), ("X", [0], 2)
-
-        Note that the rotation angle contains a factor of 2, such that that evolution
-        of a Pauli :math:`P` over time :math:`t`, which is :math:`e^{itP}`, is represented
-        by ``(P, indices, 2 * t)``.
-
-        For ``N`` repetitions, this sequence would be repeated ``N`` times and the coefficients
-        divided by ``N``.
+        super().__init__(order, reps, insert_barriers, cx_structure, atomic_evolution, wrap)
 
-        Args:
-            evolution: The evolution gate to expand.
-
-        Returns:
-            The Pauli network implementing the Trotter expansion.
-        """
-        operators = evolution.operator  # type: SparsePauliOp | list[SparsePauliOp]
+    def synthesize(self, evolution):
+        # get operators and time to evolve
+        operators = evolution.operator
         time = evolution.time
 
-        def to_sparse_list(operator):
-            paulis = (time * (2 / self.reps) * operator).to_sparse_list()
-            if not self.preserve_order:
-                return reorder_paulis(paulis)
+        if not isinstance(operators, list):
+            pauli_list = [(Pauli(op), np.real(coeff)) for op, coeff in operators.to_list()]
+        else:
+            pauli_list = [(op, 1) for op in operators]
 
-            return paulis
+        ops_to_evolve = self._recurse(self.order, time / self.reps, pauli_list)
 
         # construct the evolution circuit
-        if isinstance(operators, list):  # already sorted into commuting bits
-            non_commuting = [to_sparse_list(operator) for operator in operators]
-        else:
-            # Assume no commutativity here. If we were to group commuting Paulis,
-            # here would be the location to do so.
-            non_commuting = [[op] for op in to_sparse_list(operators)]
-
-        # normalize coefficients, i.e. ensure they are float or ParameterExpression
-        non_commuting = self._normalize_coefficients(non_commuting)
+        single_rep = QuantumCircuit(operators[0].num_qubits)
 
-        # we're already done here since Lie Trotter does not do any operator repetition
-        product_formula = self._recurse(self.order, non_commuting)
-        flattened = self.reps * list(chain.from_iterable(product_formula))
+        for i, (op, coeff) in enumerate(ops_to_evolve):
+            self.atomic_evolution(single_rep, op, coeff)
+            if self.insert_barriers and i != len(ops_to_evolve) - 1:
+                single_rep.barrier()
 
-        return flattened
+        return single_rep.repeat(self.reps, insert_barriers=self.insert_barriers).decompose()
 
     @staticmethod
-    def _recurse(order, grouped_paulis):
+    def _recurse(order, time, pauli_list):
         if order == 1:
-            return grouped_paulis
+            return pauli_list
 
         elif order == 2:
-            halves = [
-                [(label, qubits, coeff / 2) for label, qubits, coeff in paulis]
-                for paulis in grouped_paulis[:-1]
-            ]
-            full = [grouped_paulis[-1]]
+            halves = [(op, coeff * time / 2) for op, coeff in pauli_list[:-1]]
+            full = [(pauli_list[-1][0], time * pauli_list[-1][1])]
             return halves + full + list(reversed(halves))
 
         else:
             reduction = 1 / (4 - 4 ** (1 / (order - 1)))
             outer = 2 * SuzukiTrotter._recurse(
-                order - 2,
-                [
-                    [(label, qubits, coeff * reduction) for label, qubits, coeff in paulis]
-                    for paulis in grouped_paulis
-                ],
+                order - 2, time=reduction * time, pauli_list=pauli_list
             )
             inner = SuzukiTrotter._recurse(
-                order - 2,
-                [
-                    [
-                        (label, qubits, coeff * (1 - 4 * reduction))
-                        for label, qubits, coeff in paulis
-                    ]
-                    for paulis in grouped_paulis
-                ],
+                order - 2, time=(1 - 4 * reduction) * time, pauli_list=pauli_list
             )
             return outer + inner + outer

qiskit/synthesis/multi_controlled/__init__.py

@@ -12,7 +12,6 @@
 
 """Module containing multi-controlled circuits synthesis"""
 
-from .mcmt_vchain import synth_mcmt_vchain
 from .mcx_synthesis import (
     synth_mcx_n_dirty_i15,
     synth_mcx_n_clean_m15,

qiskit/synthesis/qft/qft_decompose_full.py

@@ -14,7 +14,6 @@ Circuit synthesis for a QFT circuit.
 """
 
 from __future__ import annotations
-import warnings
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 
@@ -55,7 +54,7 @@ def synth_qft_full(
         A circuit implementing the QFT operation.
 
     """
-    _warn_if_precision_loss(num_qubits - approximation_degree - 1)
+
     circuit = QuantumCircuit(num_qubits, name=name)
 
     for j in reversed(range(num_qubits)):
@@ -78,20 +77,3 @@ def synth_qft_full(
         circuit = circuit.inverse()
 
     return circuit
-
-
-def _warn_if_precision_loss(max_num_entanglements):
-    """Issue a warning if constructing the circuit will lose precision.
-
-    If we need an angle smaller than ``pi * 2**-1022``, we start to lose precision by going into
-    the subnormal numbers.  We won't lose _all_ precision until an exponent of about 1075, but
-    beyond 1022 we're using fractional bits to represent leading zeros.
-    """
-    if max_num_entanglements > -np.finfo(float).minexp:  # > 1022 for doubles.
-        warnings.warn(
-            "precision loss in QFT."
-            f" The rotation needed to represent {max_num_entanglements} entanglements"
-            " is smaller than the smallest normal floating-point number.",
-            category=RuntimeWarning,
-            stacklevel=4,
-        )

qiskit/synthesis/qft/qft_decompose_lnn.py

@@ -16,7 +16,6 @@ Circuit synthesis for a QFT circuit.
 import numpy as np
 from qiskit.circuit import QuantumCircuit
 from qiskit.synthesis.permutation.permutation_reverse_lnn import _append_reverse_permutation_lnn_kms
-from .qft_decompose_full import _warn_if_precision_loss
 
 
 def synth_qft_line(
@@ -52,7 +51,7 @@ def synth_qft_line(
            Quantum Info. Comput. 4, 4 (July 2004), 237–251.
            `arXiv:quant-ph/0402196 [quant-ph] <https://arxiv.org/abs/quant-ph/0402196>`_
     """
-    _warn_if_precision_loss(num_qubits - approximation_degree - 1)
+
     qc = QuantumCircuit(num_qubits)
 
     for i in range(num_qubits):

qiskit/synthesis/stabilizer/stabilizer_decompose.py

@@ -46,8 +46,7 @@ def synth_stabilizer_layers(
 
     For example, a 5-qubit stabilizer state is decomposed into the following layers:
 
-    .. code-block:: text
-
+    .. parsed-literal::
              ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
         q_0: ┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
              │     ││     ││     ││     ││        │

qiskit/synthesis/two_qubit/two_qubit_decompose.py

@@ -24,6 +24,8 @@ Gambetta, J. M. Validating quantum computers using randomized model circuits.
 arXiv:1811.12926 [quant-ph] (2018).
 """
 from __future__ import annotations
+import cmath
+import math
 import io
 import base64
 import warnings
@@ -89,18 +91,41 @@ def decompose_two_qubit_product_gate(special_unitary_matrix: np.ndarray):
         QiskitError: if decomposition isn't possible.
     """
     special_unitary_matrix = np.asarray(special_unitary_matrix, dtype=complex)
-    (L, R, phase) = two_qubit_decompose.decompose_two_qubit_product_gate(special_unitary_matrix)
+    # extract the right component
+    R = special_unitary_matrix[:2, :2].copy()
+    detR = R[0, 0] * R[1, 1] - R[0, 1] * R[1, 0]
+    if abs(detR) < 0.1:
+        R = special_unitary_matrix[2:, :2].copy()
+        detR = R[0, 0] * R[1, 1] - R[0, 1] * R[1, 0]
+    if abs(detR) < 0.1:
+        raise QiskitError("decompose_two_qubit_product_gate: unable to decompose: detR < 0.1")
+    R /= np.sqrt(detR)
+
+    # extract the left component
+    temp = np.kron(np.eye(2), R.T.conj())
+    temp = special_unitary_matrix.dot(temp)
+    L = temp[::2, ::2]
+    detL = L[0, 0] * L[1, 1] - L[0, 1] * L[1, 0]
+    if abs(detL) < 0.9:
+        raise QiskitError("decompose_two_qubit_product_gate: unable to decompose: detL < 0.9")
+    L /= np.sqrt(detL)
+    phase = cmath.phase(detL) / 2
 
     temp = np.kron(L, R)
     deviation = abs(abs(temp.conj().T.dot(special_unitary_matrix).trace()) - 4)
-
     if deviation > 1.0e-13:
         raise QiskitError(
             "decompose_two_qubit_product_gate: decomposition failed: "
             f"deviation too large: {deviation}"
         )
 
-    return (L, R, phase)
+    return L, R, phase
+
+
+_ipx = np.array([[0, 1j], [1j, 0]], dtype=complex)
+_ipy = np.array([[0, 1], [-1, 0]], dtype=complex)
+_ipz = np.array([[1j, 0], [0, -1j]], dtype=complex)
+_id = np.array([[1, 0], [0, 1]], dtype=complex)
 
 
 class TwoQubitWeylDecomposition:
@@ -214,7 +239,7 @@ class TwoQubitWeylDecomposition:
         """Calculates the actual fidelity of the decomposed circuit to the input unitary."""
         circ = self.circuit(**kwargs)
         trace = np.trace(Operator(circ).data.T.conj() @ self.unitary_matrix)
-        return two_qubit_decompose.trace_to_fid(trace)
+        return trace_to_fid(trace)
 
     def __repr__(self):
         """Represent with enough precision to allow copy-paste debugging of all corner cases"""
@@ -435,6 +460,40 @@ class TwoQubitControlledUDecomposer:
         return circ
 
 
+def Ud(a, b, c):
+    r"""Generates the array :math:`e^{(i a XX + i b YY + i c ZZ)}`"""
+    return np.array(
+        [
+            [cmath.exp(1j * c) * math.cos(a - b), 0, 0, 1j * cmath.exp(1j * c) * math.sin(a - b)],
+            [0, cmath.exp(-1j * c) * math.cos(a + b), 1j * cmath.exp(-1j * c) * math.sin(a + b), 0],
+            [0, 1j * cmath.exp(-1j * c) * math.sin(a + b), cmath.exp(-1j * c) * math.cos(a + b), 0],
+            [1j * cmath.exp(1j * c) * math.sin(a - b), 0, 0, cmath.exp(1j * c) * math.cos(a - b)],
+        ],
+        dtype=complex,
+    )
+
+
+def trace_to_fid(trace):
+    r"""Average gate fidelity is
+
+    .. math::
+
+        \bar{F} = \frac{d + |\mathrm{Tr} (U_\text{target} \cdot U^{\dag})|^2}{d(d+1)}
+
+    M. Horodecki, P. Horodecki and R. Horodecki, PRA 60, 1888 (1999)"""
+    return (4 + abs(trace) ** 2) / 20
+
+
+def rz_array(theta):
+    """Return numpy array for Rz(theta).
+
+    Rz(theta) = diag(exp(-i*theta/2),exp(i*theta/2))
+    """
+    return np.array(
+        [[cmath.exp(-1j * theta / 2.0), 0], [0, cmath.exp(1j * theta / 2.0)]], dtype=complex
+    )
+
+
 class TwoQubitBasisDecomposer:
     """A class for decomposing 2-qubit unitaries into minimal number of uses of a 2-qubit
     basis gate.

qiskit/synthesis/two_qubit/weyl.py

@@ -0,0 +1,97 @@
+# 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 compute  and use the Weyl chamber coordinates.
+"""
+
+from __future__ import annotations
+import numpy as np
+
+# "Magic" basis used for the Weyl decomposition. The basis and its adjoint are stored individually
+# unnormalized, but such that their matrix multiplication is still the identity.  This is because
+# they are only used in unitary transformations (so it's safe to do so), and `sqrt(0.5)` is not
+# exactly representable in floating point.  Doing it this way means that every element of the matrix
+# is stored exactly correctly, and the multiplication is _exactly_ the identity rather than
+# differing by 1ULP.
+_B_nonnormalized = np.array([[1, 1j, 0, 0], [0, 0, 1j, 1], [0, 0, 1j, -1], [1, -1j, 0, 0]])
+_B_nonnormalized_dagger = 0.5 * _B_nonnormalized.conj().T
+
+
+def transform_to_magic_basis(U: np.ndarray, reverse: bool = False) -> np.ndarray:
+    """Transform the 4-by-4 matrix ``U`` into the magic basis.
+
+    This method internally uses non-normalized versions of the basis to minimize the floating-point
+    errors that arise during the transformation.
+
+    Args:
+        U (np.ndarray): 4-by-4 matrix to transform.
+        reverse (bool): Whether to do the transformation forwards (``B @ U @ B.conj().T``, the
+        default) or backwards (``B.conj().T @ U @ B``).
+
+    Returns:
+        np.ndarray: The transformed 4-by-4 matrix.
+    """
+    if reverse:
+        return _B_nonnormalized_dagger @ U @ _B_nonnormalized
+    return _B_nonnormalized @ U @ _B_nonnormalized_dagger
+
+
+def weyl_coordinates(U: np.ndarray) -> np.ndarray:
+    """Computes the Weyl coordinates for a given two-qubit unitary matrix.
+
+    Args:
+        U (np.ndarray): Input two-qubit unitary.
+
+    Returns:
+        np.ndarray: Array of the 3 Weyl coordinates.
+    """
+    import scipy.linalg as la
+
+    pi2 = np.pi / 2
+    pi4 = np.pi / 4
+
+    U = U / la.det(U) ** (0.25)
+    Up = transform_to_magic_basis(U, reverse=True)
+    # We only need the eigenvalues of `M2 = Up.T @ Up` here, not the full diagonalization.
+    D = la.eigvals(Up.T @ Up)
+    d = -np.angle(D) / 2
+    d[3] = -d[0] - d[1] - d[2]
+    cs = np.mod((d[:3] + d[3]) / 2, 2 * np.pi)
+
+    # Reorder the eigenvalues to get in the Weyl chamber
+    cstemp = np.mod(cs, pi2)
+    np.minimum(cstemp, pi2 - cstemp, cstemp)
+    order = np.argsort(cstemp)[[1, 2, 0]]
+    cs = cs[order]
+    d[:3] = d[order]
+
+    # Flip into Weyl chamber
+    if cs[0] > pi2:
+        cs[0] -= 3 * pi2
+    if cs[1] > pi2:
+        cs[1] -= 3 * pi2
+    conjs = 0
+    if cs[0] > pi4:
+        cs[0] = pi2 - cs[0]
+        conjs += 1
+    if cs[1] > pi4:
+        cs[1] = pi2 - cs[1]
+        conjs += 1
+    if cs[2] > pi2:
+        cs[2] -= 3 * pi2
+    if conjs == 1:
+        cs[2] = pi2 - cs[2]
+    if cs[2] > pi4:
+        cs[2] -= pi2
+
+    return cs[[1, 0, 2]]

qiskit/synthesis/unitary/qsd.py

@@ -47,8 +47,7 @@ def qs_decomposition(
 
     This decomposition is described in Shende et al. [1].
 
-    .. code-block:: text
-
+    .. parsed-literal::
           ┌───┐               ┌───┐     ┌───┐     ┌───┐
          ─┤   ├─       ───────┤ Rz├─────┤ Ry├─────┤ Rz├─────
           │   │    ≃     ┌───┐└─┬─┘┌───┐└─┬─┘┌───┐└─┬─┘┌───┐
@@ -251,13 +250,14 @@ def _get_ucry_cz(nqubits, angles):
 
 
 def _apply_a2(circ):
+    from qiskit.compiler import transpile
     from qiskit.quantum_info import Operator
     from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
-    from qiskit.transpiler.passes.synthesis import HighLevelSynthesis
 
     decomposer = two_qubit_decompose_up_to_diagonal
-    hls = HighLevelSynthesis(basis_gates=["u", "cx", "qsd2q"], qubits_initially_zero=False)
-    ccirc = hls(circ)
+    ccirc = transpile(
+        circ, basis_gates=["u", "cx", "qsd2q"], optimization_level=0, qubits_initially_zero=False
+    )
     ind2q = []
     # collect 2q instrs
     for i, instruction in enumerate(ccirc.data):