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

qiskit/synthesis/arithmetic/multipliers/rg_qft_multiplier.py

@@ -0,0 +1,99 @@
+# 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.
+
+"""Compute the product of two qubit registers using QFT."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.library.standard_gates import PhaseGate
+from qiskit.circuit.library.basis_change import QFTGate
+
+
+def multiplier_qft_r17(
+    num_state_qubits: int, num_result_qubits: int | None = None
+) -> QuantumCircuit:
+    r"""A QFT multiplication circuit to store product of two input registers out-of-place.
+
+    Multiplication in this circuit is implemented using the procedure of Fig. 3 in [1], where
+    weighted sum rotations are implemented as given in Fig. 5 in [1]. QFT is used on the output
+    register and is followed by rotations controlled by input registers. The rotations
+    transform the state into the product of two input registers in QFT base, which is
+    reverted from QFT base using inverse QFT.
+    For example, on 3 state qubits, a full multiplier is given by:
+
+    .. plot::
+        :include-source:
+
+        from qiskit.synthesis.arithmetic import multiplier_qft_r17
+
+        num_state_qubits = 3
+        circuit = multiplier_qft_r17(num_state_qubits)
+        circuit.draw("mpl")
+
+    Args:
+        num_state_qubits: The number of qubits in either input register for
+            state :math:`|a\rangle` or :math:`|b\rangle`. The two input
+            registers must have the same number of qubits.
+        num_result_qubits: The number of result qubits to limit the output to.
+            If number of result qubits is :math:`n`, multiplication modulo :math:`2^n` is performed
+            to limit the output to the specified number of qubits. Default
+            value is ``2 * num_state_qubits`` to represent any possible
+            result from the multiplication of the two inputs.
+
+    Raises:
+        ValueError: If ``num_result_qubits`` is given and not valid, meaning not
+            in ``[num_state_qubits, 2 * num_state_qubits]``.
+
+    **References:**
+
+    [1] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.
+    `arXiv:1411.5949 <https://arxiv.org/pdf/1411.5949.pdf>`_
+
+    """
+    # define the registers
+    if num_result_qubits is None:
+        num_result_qubits = 2 * num_state_qubits
+    elif num_result_qubits < num_state_qubits or num_result_qubits > 2 * num_state_qubits:
+        raise ValueError(
+            f"num_result_qubits ({num_result_qubits}) must be in between num_state_qubits "
+            f"({num_state_qubits}) and 2 * num_state_qubits ({2 * num_state_qubits})"
+        )
+
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+    qr_out = QuantumRegister(num_result_qubits, name="out")
+
+    # build multiplication circuit
+    circuit = QuantumCircuit(qr_a, qr_b, qr_out)
+    qft = QFTGate(num_result_qubits)
+
+    circuit.append(qft, qr_out[:])
+
+    for j in range(1, num_state_qubits + 1):
+        for i in range(1, num_state_qubits + 1):
+            for k in range(1, num_result_qubits + 1):
+                lam = (2 * np.pi) / (2 ** (i + j + k - 2 * num_state_qubits))
+
+                # note: if we can synthesize the QFT without swaps, we can implement this circuit
+                # more efficiently and just apply phase gate on qr_out[(k - 1)] instead
+                circuit.append(
+                    PhaseGate(lam).control(2),
+                    [qr_a[num_state_qubits - j], qr_b[num_state_qubits - i], qr_out[~(k - 1)]],
+                )
+
+    circuit.append(qft.inverse(), qr_out[:])
+
+    return circuit

qiskit/synthesis/clifford/clifford_decompose_bm.py

@@ -41,7 +41,6 @@ def synth_clifford_bm(clifford: Clifford) -> QuantumCircuit:
            `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
     """
     circuit = QuantumCircuit._from_circuit_data(
-        synth_clifford_bm_inner(clifford.tableau.astype(bool)), add_regs=True
+        synth_clifford_bm_inner(clifford.tableau.astype(bool)), add_regs=True, name=str(clifford)
     )
-    circuit.name = str(clifford)
     return circuit

qiskit/synthesis/clifford/clifford_decompose_greedy.py

@@ -51,7 +51,8 @@ def synth_clifford_greedy(clifford: Clifford) -> QuantumCircuit:
            `arXiv:2105.02291 [quant-ph] <https://arxiv.org/abs/2105.02291>`_
     """
     circuit = QuantumCircuit._from_circuit_data(
-        synth_clifford_greedy_inner(clifford.tableau.astype(bool)), add_regs=True
+        synth_clifford_greedy_inner(clifford.tableau.astype(bool)),
+        add_regs=True,
+        name=str(clifford),
     )
-    circuit.name = str(clifford)
     return circuit

qiskit/synthesis/clifford/clifford_decompose_layers.py

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

qiskit/synthesis/evolution/__init__.py

@@ -18,3 +18,4 @@ from .product_formula import ProductFormula
 from .lie_trotter import LieTrotter
 from .suzuki_trotter import SuzukiTrotter
 from .qdrift import QDrift
+from .pauli_network import synth_pauli_network_rustiq

qiskit/synthesis/evolution/lie_trotter.py

@@ -14,18 +14,15 @@
 
 from __future__ import annotations
 
-import inspect
 from collections.abc import Callable
 from typing import Any
-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
+from .suzuki_trotter import SuzukiTrotter
 
 
-class LieTrotter(ProductFormula):
+class LieTrotter(SuzukiTrotter):
     r"""The Lie-Trotter product formula.
 
     The Lie-Trotter formula approximates the exponential of two non-commuting operators
@@ -40,7 +37,7 @@ class LieTrotter(ProductFormula):
 
     .. math::
 
-        e^{-it(XX + ZZ)} = e^{-it XX}e^{-it ZZ} + \mathcal{O}(t^2).
+        e^{-it(XI + ZZ)} = e^{-it XI}e^{-it ZZ} + \mathcal{O}(t^2).
 
     References:
 
@@ -52,21 +49,6 @@ class LieTrotter(ProductFormula):
         `arXiv:math-ph/0506007 <https://arxiv.org/pdf/math-ph/0506007.pdf>`_
     """
 
-    @deprecate_arg(
-        name="atomic_evolution",
-        since="1.2",
-        predicate=lambda callable: callable is not None
-        and len(inspect.signature(callable).parameters) == 2,
-        deprecation_description=(
-            "The 'Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]' signature of the "
-            "'atomic_evolution' argument"
-        ),
-        additional_msg=(
-            "Instead you should update your 'atomic_evolution' function to be of the following "
-            "type: 'Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]'."
-        ),
-        pending=True,
-    )
     def __init__(
         self,
         reps: int = 1,
@@ -78,6 +60,7 @@ class LieTrotter(ProductFormula):
             | None
         ) = None,
         wrap: bool = False,
+        preserve_order: bool = True,
     ) -> None:
         """
         Args:
@@ -97,28 +80,19 @@ class LieTrotter(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.
         """
-        super().__init__(1, reps, insert_barriers, cx_structure, atomic_evolution, wrap)
-
-    def synthesize(self, evolution):
-        # get operators and time to evolve
-        operators = evolution.operator
-        time = evolution.time
-
-        # construct the evolution circuit
-        single_rep = QuantumCircuit(operators[0].num_qubits)
-
-        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]
-
-        for i, (op, coeff) in enumerate(pauli_list):
-            self.atomic_evolution(single_rep, op, coeff * time / self.reps)
-            if self.insert_barriers and i != len(pauli_list) - 1:
-                single_rep.barrier()
-
-        return single_rep.repeat(self.reps, insert_barriers=self.insert_barriers).decompose()
+        super().__init__(
+            1,
+            reps,
+            insert_barriers,
+            cx_structure,
+            atomic_evolution,
+            wrap,
+            preserve_order=preserve_order,
+        )
 
     @property
     def settings(self) -> dict[str, Any]:

qiskit/synthesis/evolution/pauli_network.py

@@ -0,0 +1,80 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024.
+#
+# 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 pauli evolution gates."""
+
+from __future__ import annotations
+
+from qiskit.circuit import QuantumCircuit
+
+from qiskit._accelerate.synthesis.evolution import (
+    pauli_network_synthesis as pauli_network_synthesis_inner,
+)
+
+
+def synth_pauli_network_rustiq(
+    num_qubits: int,
+    pauli_network: list,
+    optimize_count: bool = True,
+    preserve_order: bool = True,
+    upto_clifford: bool = False,
+    upto_phase: bool = False,
+    resynth_clifford_method: int = 0,
+) -> QuantumCircuit:
+    """
+    Calls Rustiq's pauli network synthesis algorithm.
+
+    The algorithm is described in [1]. The source code (in Rust) is available at
+    https://github.com/smartiel/rustiq-core.
+
+    Args:
+        num_qubits: the number of qubits over which the pauli network is defined.
+        pauli_network: a list of pauli rotations, represented in sparse format: a list of
+            triples such as `[("XX", [0, 3], theta), ("ZZ", [0, 1], 0.1)]`.
+        optimize_count: if `True` the synthesis algorithm will try to optimize the 2-qubit
+            gate count; and if `False` then the 2-qubit depth.
+        preserve_order: whether the order of paulis should be preserved, up to
+            commutativity. If the order is not preserved, the returned circuit will
+            generally not be equivalent to the given pauli network.
+        upto_clifford: if `True`, the final Clifford operator is not synthesized
+            and the returned circuit will generally not be equivalent to the given
+            pauli network. In addition, the argument `upto_phase` would be ignored.
+        upto_phase: if `True`, the global phase of the returned circuit may differ
+             from the global phase of the given pauli network. The argument is ignored
+             when `upto_clifford` is `True`.
+        resynth_clifford_method: describes the strategy to synthesize the final Clifford
+            operator. If `0` a naive approach is used, which doubles the number of gates
+            but preserves the global phase of the circuit. If `1`, the Clifford is
+            resynthesized using Qiskit's greedy Clifford synthesis algorithm. If `2`, it
+            is resynthesized by Rustiq itself. If `upto_phase` is `False`, the naive
+            approach is used, as neither synthesis method preserves the global phase.
+
+    Returns:
+        A circuit implementation of the pauli network.
+
+    References:
+        1. Timothée Goubault de Brugière and Simon Martiel,
+           *Faster and shorter synthesis of Hamiltonian simulation circuits*,
+           `arXiv:2404.03280 [quant-ph] <https://arxiv.org/abs/2404.03280>`_
+
+    """
+    out = pauli_network_synthesis_inner(
+        num_qubits=num_qubits,
+        pauli_network=pauli_network,
+        optimize_count=optimize_count,
+        preserve_order=preserve_order,
+        upto_clifford=upto_clifford,
+        upto_phase=upto_phase,
+        resynth_clifford_method=resynth_clifford_method,
+    )
+    circuit = QuantumCircuit._from_circuit_data(out, add_regs=True)
+    return circuit