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

{qiskit-1.3.0b1.dist-info → qiskit-1.3.0rc2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: false
 Tag: cp39-abi3-win32
 

{qiskit-1.3.0b1.dist-info → qiskit-1.3.0rc2.dist-info}/entry_points.txt

@@ -1,4 +1,20 @@
 [qiskit.synthesis]
+FullAdder.default = qiskit.transpiler.passes.synthesis.hls_plugins:FullAdderSynthesisC04
+FullAdder.ripple_c04 = qiskit.transpiler.passes.synthesis.hls_plugins:FullAdderSynthesisC04
+FullAdder.ripple_v95 = qiskit.transpiler.passes.synthesis.hls_plugins:FullAdderSynthesisV95
+HalfAdder.default = qiskit.transpiler.passes.synthesis.hls_plugins:HalfAdderSynthesisDefault
+HalfAdder.qft_d00 = qiskit.transpiler.passes.synthesis.hls_plugins:HalfAdderSynthesisD00
+HalfAdder.ripple_c04 = qiskit.transpiler.passes.synthesis.hls_plugins:HalfAdderSynthesisC04
+HalfAdder.ripple_v95 = qiskit.transpiler.passes.synthesis.hls_plugins:HalfAdderSynthesisV95
+ModularAdder.default = qiskit.transpiler.passes.synthesis.hls_plugins:ModularAdderSynthesisDefault
+ModularAdder.qft_d00 = qiskit.transpiler.passes.synthesis.hls_plugins:ModularAdderSynthesisD00
+ModularAdder.ripple_c04 = qiskit.transpiler.passes.synthesis.hls_plugins:ModularAdderSynthesisC04
+ModularAdder.ripple_v95 = qiskit.transpiler.passes.synthesis.hls_plugins:ModularAdderSynthesisV95
+Multiplier.cumulative_h18 = qiskit.transpiler.passes.synthesis.hls_plugins:MultiplierSynthesisH18
+Multiplier.default = qiskit.transpiler.passes.synthesis.hls_plugins:MultiplierSynthesisR17
+Multiplier.qft_r17 = qiskit.transpiler.passes.synthesis.hls_plugins:MultiplierSynthesisR17
+PauliEvolution.default = qiskit.transpiler.passes.synthesis.hls_plugins:PauliEvolutionSynthesisDefault
+PauliEvolution.rustiq = qiskit.transpiler.passes.synthesis.hls_plugins:PauliEvolutionSynthesisRustiq
 clifford.ag = qiskit.transpiler.passes.synthesis.hls_plugins:AGSynthesisClifford
 clifford.bm = qiskit.transpiler.passes.synthesis.hls_plugins:BMSynthesisClifford
 clifford.default = qiskit.transpiler.passes.synthesis.hls_plugins:DefaultSynthesisClifford
@@ -8,6 +24,9 @@ clifford.lnn = qiskit.transpiler.passes.synthesis.hls_plugins:LayerLnnSynthesisC
 linear_function.default = qiskit.transpiler.passes.synthesis.hls_plugins:DefaultSynthesisLinearFunction
 linear_function.kms = qiskit.transpiler.passes.synthesis.hls_plugins:KMSSynthesisLinearFunction
 linear_function.pmh = qiskit.transpiler.passes.synthesis.hls_plugins:PMHSynthesisLinearFunction
+mcmt.default = qiskit.transpiler.passes.synthesis.hls_plugins:MCMTSynthesisDefault
+mcmt.noaux = qiskit.transpiler.passes.synthesis.hls_plugins:MCMTSynthesisNoAux
+mcmt.vchain = qiskit.transpiler.passes.synthesis.hls_plugins:MCMTSynthesisVChain
 mcx.1_clean_b95 = qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesis1CleanB95
 mcx.default = qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisDefault
 mcx.gray_code = qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisGrayCode

qiskit/circuit/library/data_preparation/zz_feature_map.py

@@ -1,118 +0,0 @@
-# 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.
-
-"""Second-order Pauli-Z expansion circuit."""
-
-from typing import Callable, List, Union, Optional, Dict, Tuple
-import numpy as np
-from .pauli_feature_map import PauliFeatureMap
-
-
-class ZZFeatureMap(PauliFeatureMap):
-    r"""Second-order Pauli-Z evolution circuit.
-
-    For 3 qubits and 1 repetition and linear entanglement the circuit is represented by:
-
-    .. parsed-literal::
-
-        ┌───┐┌─────────────────┐
-        ┤ H ├┤ U1(2.0*φ(x[0])) ├──■────────────────────────────■────────────────────────────────────
-        ├───┤├─────────────────┤┌─┴─┐┌──────────────────────┐┌─┴─┐
-        ┤ H ├┤ U1(2.0*φ(x[1])) ├┤ X ├┤ U1(2.0*φ(x[0],x[1])) ├┤ X ├──■────────────────────────────■──
-        ├───┤├─────────────────┤└───┘└──────────────────────┘└───┘┌─┴─┐┌──────────────────────┐┌─┴─┐
-        ┤ H ├┤ U1(2.0*φ(x[2])) ├──────────────────────────────────┤ X ├┤ U1(2.0*φ(x[1],x[2])) ├┤ X ├
-        └───┘└─────────────────┘                                  └───┘└──────────────────────┘└───┘
-
-    where :math:`\varphi` is a classical non-linear function, which defaults to :math:`\varphi(x) = x`
-    if and :math:`\varphi(x,y) = (\pi - x)(\pi - y)`.
-
-    Examples:
-
-        >>> from qiskit.circuit.library import ZZFeatureMap
-        >>> prep = ZZFeatureMap(2, reps=1)
-        >>> print(prep)
-             ┌───┐┌──────────────┐
-        q_0: ┤ H ├┤ U1(2.0*x[0]) ├──■───────────────────────────────────────■──
-             ├───┤├──────────────┤┌─┴─┐┌─────────────────────────────────┐┌─┴─┐
-        q_1: ┤ H ├┤ U1(2.0*x[1]) ├┤ X ├┤ U1(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
-             └───┘└──────────────┘└───┘└─────────────────────────────────┘└───┘
-
-        >>> from qiskit.circuit.library import EfficientSU2
-        >>> classifier = ZZFeatureMap(3) + EfficientSU2(3)
-        >>> classifier.num_parameters
-        15
-        >>> classifier.parameters  # 'x' for the data preparation, 'θ' for the SU2 parameters
-        ParameterView([
-            ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
-            ParameterVectorElement(x[2]), ParameterVectorElement(θ[0]),
-            ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]),
-            ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]),
-            ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]),
-            ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]),
-            ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]),
-            ParameterVectorElement(θ[11]), ParameterVectorElement(θ[12]),
-            ParameterVectorElement(θ[13]), ParameterVectorElement(θ[14]),
-            ParameterVectorElement(θ[15]), ParameterVectorElement(θ[16]),
-            ParameterVectorElement(θ[17]), ParameterVectorElement(θ[18]),
-            ParameterVectorElement(θ[19]), ParameterVectorElement(θ[20]),
-            ParameterVectorElement(θ[21]), ParameterVectorElement(θ[22]),
-            ParameterVectorElement(θ[23])
-        ])
-        >>> classifier.count_ops()
-        OrderedDict([('ZZFeatureMap', 1), ('EfficientSU2', 1)])
-    """
-
-    def __init__(
-        self,
-        feature_dimension: int,
-        reps: int = 2,
-        entanglement: Union[
-            str,
-            Dict[int, List[Tuple[int]]],
-            Callable[[int], Union[str, Dict[int, List[Tuple[int]]]]],
-        ] = "full",
-        data_map_func: Optional[Callable[[np.ndarray], float]] = None,
-        parameter_prefix: str = "x",
-        insert_barriers: bool = False,
-        name: str = "ZZFeatureMap",
-    ) -> None:
-        """Create a new second-order Pauli-Z expansion.
-
-        Args:
-            feature_dimension: Number of features.
-            reps: The number of repeated circuits, has a min. value of 1.
-            entanglement: Specifies the entanglement structure. Refer to
-                :class:`~qiskit.circuit.library.PauliFeatureMap` for detail.
-            data_map_func: A mapping function for data x.
-            parameter_prefix: The prefix used if default parameters are generated.
-            insert_barriers: If True, barriers are inserted in between the evolution instructions
-                and hadamard layers.
-
-        Raises:
-            ValueError: If the feature dimension is smaller than 2.
-        """
-        if feature_dimension < 2:
-            raise ValueError(
-                "The ZZFeatureMap contains 2-local interactions and cannot be "
-                f"defined for less than 2 qubits. You provided {feature_dimension}."
-            )
-
-        super().__init__(
-            feature_dimension=feature_dimension,
-            reps=reps,
-            entanglement=entanglement,
-            paulis=["Z", "ZZ"],
-            data_map_func=data_map_func,
-            parameter_prefix=parameter_prefix,
-            insert_barriers=insert_barriers,
-            name=name,
-        )

qiskit/synthesis/two_qubit/weyl.py

@@ -1,97 +0,0 @@
-# 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/transpiler/passes/synthesis/qubit_tracker.py

@@ -1,132 +0,0 @@
-# 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.
-
-"""A qubit state tracker for synthesizing operations with auxiliary qubits."""
-
-from __future__ import annotations
-from collections.abc import Iterable
-from dataclasses import dataclass
-
-
-@dataclass
-class QubitTracker:
-    """Track qubits (by global index) and their state.
-
-    The states are distinguished into clean (meaning in state :math:`|0\rangle`) or dirty (an
-    unknown state).
-    """
-
-    # This could in future be extended to track different state types, if necessary.
-    # However, using sets of integers here is much faster than e.g. storing a dictionary with
-    # {index: state} entries.
-    qubits: tuple[int]
-    clean: set[int]
-    dirty: set[int]
-
-    def num_clean(self, active_qubits: Iterable[int] | None = None):
-        """Return the number of clean qubits, not considering the active qubits."""
-        # this could be cached if getting the set length becomes a performance bottleneck
-        return len(self.clean.difference(active_qubits or set()))
-
-    def num_dirty(self, active_qubits: Iterable[int] | None = None):
-        """Return the number of dirty qubits, not considering the active qubits."""
-        return len(self.dirty.difference(active_qubits or set()))
-
-    def borrow(self, num_qubits: int, active_qubits: Iterable[int] | None = None) -> list[int]:
-        """Get ``num_qubits`` qubits, excluding ``active_qubits``."""
-        active_qubits = set(active_qubits or [])
-        available_qubits = [qubit for qubit in self.qubits if qubit not in active_qubits]
-
-        if num_qubits > (available := len(available_qubits)):
-            raise RuntimeError(f"Cannot borrow {num_qubits} qubits, only {available} available.")
-
-        # for now, prioritize returning clean qubits
-        available_clean = [qubit for qubit in available_qubits if qubit in self.clean]
-        available_dirty = [qubit for qubit in available_qubits if qubit in self.dirty]
-
-        borrowed = available_clean[:num_qubits]
-        return borrowed + available_dirty[: (num_qubits - len(borrowed))]
-
-    def used(self, qubits: Iterable[int], check: bool = True) -> None:
-        """Set the state of ``qubits`` to used (i.e. False)."""
-        qubits = set(qubits)
-
-        if check:
-            if len(untracked := qubits.difference(self.qubits)) > 0:
-                raise ValueError(f"Setting state of untracked qubits: {untracked}. Tracker: {self}")
-
-        self.clean -= qubits
-        self.dirty |= qubits
-
-    def reset(self, qubits: Iterable[int], check: bool = True) -> None:
-        """Set the state of ``qubits`` to 0 (i.e. True)."""
-        qubits = set(qubits)
-
-        if check:
-            if len(untracked := qubits.difference(self.qubits)) > 0:
-                raise ValueError(f"Setting state of untracked qubits: {untracked}. Tracker: {self}")
-
-        self.clean |= qubits
-        self.dirty -= qubits
-
-    def drop(self, qubits: Iterable[int], check: bool = True) -> None:
-        """Drop qubits from the tracker, meaning that they are no longer available."""
-        qubits = set(qubits)
-
-        if check:
-            if len(untracked := qubits.difference(self.qubits)) > 0:
-                raise ValueError(f"Dropping untracked qubits: {untracked}. Tracker: {self}")
-
-        self.qubits = tuple(qubit for qubit in self.qubits if qubit not in qubits)
-        self.clean -= qubits
-        self.dirty -= qubits
-
-    def copy(
-        self, qubit_map: dict[int, int] | None = None, drop: Iterable[int] | None = None
-    ) -> "QubitTracker":
-        """Copy self.
-
-        Args:
-            qubit_map: If provided, apply the mapping ``{old_qubit: new_qubit}`` to
-                the qubits in the tracker. Only those old qubits in the mapping will be
-                part of the new one.
-            drop: If provided, drop these qubits in the copied tracker. This argument is ignored
-                if ``qubit_map`` is given, since the qubits can then just be dropped in the map.
-        """
-        if qubit_map is None and drop is not None:
-            remaining_qubits = [qubit for qubit in self.qubits if qubit not in drop]
-            qubit_map = dict(zip(remaining_qubits, remaining_qubits))
-
-        if qubit_map is None:
-            clean = self.clean.copy()
-            dirty = self.dirty.copy()
-            qubits = self.qubits  # tuple is immutable, no need to copy
-        else:
-            clean, dirty = set(), set()
-            for old_index, new_index in qubit_map.items():
-                if old_index in self.clean:
-                    clean.add(new_index)
-                elif old_index in self.dirty:
-                    dirty.add(new_index)
-                else:
-                    raise ValueError(f"Unknown old qubit index: {old_index}. Tracker: {self}")
-
-            qubits = tuple(qubit_map.values())
-
-        return QubitTracker(qubits, clean=clean, dirty=dirty)
-
-    def __str__(self) -> str:
-        return (
-            f"QubitTracker({len(self.qubits)}, clean: {self.num_clean()}, dirty: {self.num_dirty()})"
-            + f"\n\tclean: {self.clean}"
-            + f"\n\tdirty: {self.dirty}"
-        )