qiskit 1.3.0__cp39-abi3-macosx_10_12_x86_64.whl → 1.3.1__cp39-abi3-macosx_10_12_x86_64.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.3.0
+1.3.1

qiskit/circuit/add_control.py

@@ -13,6 +13,7 @@
 """Add control to operation if supported."""
 from __future__ import annotations
 
+from math import pi
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit.library import UnitaryGate
 from qiskit.transpiler import PassManager
@@ -92,7 +93,6 @@ def control(
     Raises:
         CircuitError: gate contains non-gate in definition
     """
-    from math import pi
 
     # pylint: disable=cyclic-import
     from qiskit.circuit import controlledgate
@@ -101,22 +101,23 @@ def control(
 
     q_control = QuantumRegister(num_ctrl_qubits, name="control")
     q_target = QuantumRegister(operation.num_qubits, name="target")
-    q_ancillae = None  # TODO: add
     controlled_circ = QuantumCircuit(q_control, q_target, name=f"c_{operation.name}")
     if isinstance(operation, controlledgate.ControlledGate):
         original_ctrl_state = operation.ctrl_state
+        operation = operation.to_mutable()
+        operation.ctrl_state = None
+
     global_phase = 0
-    if operation.name == "x" or (
-        isinstance(operation, controlledgate.ControlledGate) and operation.base_gate.name == "x"
-    ):
-        controlled_circ.mcx(q_control[:] + q_target[:-1], q_target[-1], q_ancillae)
-        if operation.definition is not None and operation.definition.global_phase:
-            global_phase += operation.definition.global_phase
+
+    basis = ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
+
+    if operation.name in basis:
+        apply_basic_controlled_gate(controlled_circ, operation, q_control, q_target[0])
     else:
-        basis = ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
         if isinstance(operation, controlledgate.ControlledGate):
             operation = operation.to_mutable()
             operation.ctrl_state = None
+
         unrolled_gate = _unroll_gate(operation, basis_gates=basis)
         if unrolled_gate.definition.global_phase:
             global_phase += unrolled_gate.definition.global_phase
@@ -130,87 +131,17 @@ def control(
 
         for instruction in definition.data:
             gate, qargs = instruction.operation, instruction.qubits
-            if gate.name == "x":
-                controlled_circ.mcx(q_control, q_target[bit_indices[qargs[0]]], q_ancillae)
-            elif gate.name == "rx":
-                controlled_circ.mcrx(
-                    gate.definition.data[0].operation.params[0],
-                    q_control,
-                    q_target[bit_indices[qargs[0]]],
-                    use_basis_gates=False,
-                )
-            elif gate.name == "ry":
-                controlled_circ.mcry(
-                    gate.definition.data[0].operation.params[0],
-                    q_control,
-                    q_target[bit_indices[qargs[0]]],
-                    q_ancillae,
-                    mode="noancilla",
-                    use_basis_gates=False,
-                )
-            elif gate.name == "rz":
-                controlled_circ.mcrz(
-                    gate.definition.data[0].operation.params[0],
-                    q_control,
-                    q_target[bit_indices[qargs[0]]],
-                    use_basis_gates=False,
-                )
-                continue
-            elif gate.name == "p":
-                from qiskit.circuit.library import MCPhaseGate
 
-                controlled_circ.append(
-                    MCPhaseGate(gate.params[0], num_ctrl_qubits),
-                    q_control[:] + [q_target[bit_indices[qargs[0]]]],
-                )
-            elif gate.name == "cx":
-                controlled_circ.mcx(
-                    q_control[:] + [q_target[bit_indices[qargs[0]]]],
-                    q_target[bit_indices[qargs[1]]],
-                    q_ancillae,
-                )
-            elif gate.name == "u":
-                theta, phi, lamb = gate.params
-                if num_ctrl_qubits == 1:
-                    if theta == 0 and phi == 0:
-                        controlled_circ.cp(lamb, q_control[0], q_target[bit_indices[qargs[0]]])
-                    else:
-                        controlled_circ.cu(
-                            theta, phi, lamb, 0, q_control[0], q_target[bit_indices[qargs[0]]]
-                        )
-                else:
-                    if phi == -pi / 2 and lamb == pi / 2:
-                        controlled_circ.mcrx(
-                            theta, q_control, q_target[bit_indices[qargs[0]]], use_basis_gates=True
-                        )
-                    elif phi == 0 and lamb == 0:
-                        controlled_circ.mcry(
-                            theta,
-                            q_control,
-                            q_target[bit_indices[qargs[0]]],
-                            q_ancillae,
-                            use_basis_gates=True,
-                        )
-                    elif theta == 0 and phi == 0:
-                        controlled_circ.mcp(lamb, q_control, q_target[bit_indices[qargs[0]]])
-                    else:
-                        controlled_circ.mcp(lamb, q_control, q_target[bit_indices[qargs[0]]])
-                        controlled_circ.mcry(
-                            theta,
-                            q_control,
-                            q_target[bit_indices[qargs[0]]],
-                            q_ancillae,
-                            use_basis_gates=True,
-                        )
-                        controlled_circ.mcp(phi, q_control, q_target[bit_indices[qargs[0]]])
-            elif gate.name == "z":
-                controlled_circ.h(q_target[bit_indices[qargs[0]]])
-                controlled_circ.mcx(q_control, q_target[bit_indices[qargs[0]]], q_ancillae)
-                controlled_circ.h(q_target[bit_indices[qargs[0]]])
+            if len(qargs) == 1:
+                target = q_target[bit_indices[qargs[0]]]
             else:
-                raise CircuitError(f"gate contains non-controllable instructions: {gate.name}")
-            if gate.definition is not None and gate.definition.global_phase:
+                target = [q_target[bit_indices[qarg]] for qarg in qargs]
+
+            apply_basic_controlled_gate(controlled_circ, gate, q_control, target)
+
+            if gate.definition is not None and gate.definition.global_phase and gate.name != "rz":
                 global_phase += gate.definition.global_phase
+
     # apply controlled global phase
     if global_phase:
         if len(q_control) < 2:
@@ -228,6 +159,7 @@ def control(
         new_ctrl_state = ctrl_state
         base_name = operation.name
         base_gate = operation
+
     # In order to maintain some backward compatibility with gate names this
     # uses a naming convention where if the number of controls is <=2 the gate
     # is named like "cc<base_gate.name>", else it is named like
@@ -250,15 +182,101 @@ def control(
     return cgate
 
 
+def apply_basic_controlled_gate(circuit, gate, controls, target):
+    """Apply a controlled version of ``gate`` to the circuit.
+
+    This implements multi-control operations for the following basis gates:
+
+        ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
+
+    """
+    num_ctrl_qubits = len(controls)
+
+    if gate.name == "x":
+        circuit.mcx(controls, target)
+
+    elif gate.name == "rx":
+        circuit.mcrx(
+            gate.definition.data[0].operation.params[0],
+            controls,
+            target,
+            use_basis_gates=False,
+        )
+    elif gate.name == "ry":
+        circuit.mcry(
+            gate.definition.data[0].operation.params[0],
+            controls,
+            target,
+            mode="noancilla",
+            use_basis_gates=False,
+        )
+    elif gate.name == "rz":
+        circuit.mcrz(
+            gate.definition.data[0].operation.params[0],
+            controls,
+            target,
+            use_basis_gates=False,
+        )
+        # continue
+    elif gate.name == "p":
+        from qiskit.circuit.library import MCPhaseGate
+
+        circuit.append(
+            MCPhaseGate(gate.params[0], num_ctrl_qubits),
+            controls[:] + [target],
+        )
+    elif gate.name == "cx":
+        circuit.mcx(
+            controls[:] + [target[0]],  # CX has two targets
+            target[1],
+        )
+    elif gate.name == "u":
+        theta, phi, lamb = gate.params
+        if num_ctrl_qubits == 1:
+            if theta == 0 and phi == 0:
+                circuit.cp(lamb, controls[0], target)
+            else:
+                circuit.cu(theta, phi, lamb, 0, controls[0], target)
+        else:
+            if phi == -pi / 2 and lamb == pi / 2:
+                circuit.mcrx(theta, controls, target, use_basis_gates=True)
+            elif phi == 0 and lamb == 0:
+                circuit.mcry(
+                    theta,
+                    controls,
+                    target,
+                    use_basis_gates=True,
+                )
+            elif theta == 0 and phi == 0:
+                circuit.mcp(lamb, controls, target)
+            else:
+                circuit.mcp(lamb, controls, target)
+                circuit.mcry(
+                    theta,
+                    controls,
+                    target,
+                    use_basis_gates=True,
+                )
+                circuit.mcp(phi, controls, target)
+
+    elif gate.name == "z":
+        circuit.h(target)
+        circuit.mcx(controls, target)
+        circuit.h(target)
+
+    else:
+        raise CircuitError(f"Gate {gate} not in supported basis.")
+
+
 def _gate_to_circuit(operation):
     """Converts a gate instance to a QuantumCircuit"""
     if hasattr(operation, "definition") and operation.definition is not None:
         return operation.definition
-    else:
-        qr = QuantumRegister(operation.num_qubits)
-        qc = QuantumCircuit(qr, name=operation.name)
-        qc.append(operation, qr)
-        return qc
+
+    qr = QuantumRegister(operation.num_qubits)
+    qc = QuantumCircuit(qr, name=operation.name)
+    qc.append(operation, qr)
+    return qc
 
 
 def _unroll_gate(operation, basis_gates):

qiskit/circuit/library/arithmetic/adders/adder.py

@@ -116,6 +116,15 @@ class HalfAdderGate(Gate):
         """
         return self._num_state_qubits
 
+    def _define(self):
+        """Populates self.definition with some decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_qft_d00
+
+        # This particular decomposition does not use any ancilla qubits.
+        # Note that the transpiler may choose a different decomposition
+        # based on the number of ancilla qubits available.
+        self.definition = adder_qft_d00(self.num_state_qubits, kind="half")
+
 
 class ModularAdderGate(Gate):
     r"""Compute the sum modulo :math:`2^n` of two :math:`n`-sized qubit registers.
@@ -162,6 +171,15 @@ class ModularAdderGate(Gate):
         """
         return self._num_state_qubits
 
+    def _define(self):
+        """Populates self.definition with some decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_qft_d00
+
+        # This particular decomposition does not use any ancilla qubits.
+        # Note that the transpiler may choose a different decomposition
+        # based on the number of ancilla qubits available.
+        self.definition = adder_qft_d00(self.num_state_qubits, kind="fixed")
+
 
 class FullAdderGate(Gate):
     r"""Compute the sum of two :math:`n`-sized qubit registers, including carry-in and -out bits.
@@ -208,3 +226,10 @@ class FullAdderGate(Gate):
             The number of state qubits.
         """
         return self._num_state_qubits
+
+    def _define(self):
+        """Populates self.definition with a decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_ripple_c04
+
+        # In the case of a full adder, this method does not use any ancilla qubits
+        self.definition = adder_ripple_c04(self.num_state_qubits, kind="full")

qiskit/circuit/library/arithmetic/multipliers/multiplier.py

@@ -190,3 +190,12 @@ class MultiplierGate(Gate):
             The number of result qubits.
         """
         return self._num_result_qubits
+
+    def _define(self):
+        """Populates self.definition with some decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import multiplier_qft_r17
+
+        # This particular decomposition does not use any ancilla qubits.
+        # Note that the transpiler may choose a different decomposition
+        # based on the number of ancilla qubits available.
+        self.definition = multiplier_qft_r17(self.num_state_qubits)

qiskit/qpy/__init__.py

@@ -447,10 +447,10 @@ characters:
    * - ``u``
      - substitution
 
-If the type value is ``f`` ,``c`` or ``i``, the corresponding ``lhs`` or `rhs``
+If the type value is ``f``, ``c``, or ``i``, the corresponding ``lhs`` or ``rhs``
 field widths are 128 bits each. In the case of floats, the literal value is encoded as a double
 with 0 padding, while complex numbers are encoded as real part followed by imaginary part,
-taking up 64 bits each. For ``i`, the value is encoded as a 64 bit signed integer with 0 padding
+taking up 64 bits each. For ``i``, the value is encoded as a 64 bit signed integer with 0 padding
 for the full 128 bit width. ``n`` is used to represent a ``None`` and typically isn't directly used
 as it indicates an argument that's not used. For ``p`` the data is the UUID for the
 :class:`.Parameter` which can be looked up in the symbol map described in the
@@ -546,7 +546,7 @@ Type code  Meaning
 Changes to EXPR_VAR
 ~~~~~~~~~~~~~~~~~~~
 
-The EXPR_VAR variable has gained a new type code and payload, in addition to the pre-existing ones:
+The ``EXPR_VAR`` variable has gained a new type code and payload, in addition to the pre-existing ones:
 
 ===========================  =========  ============================================================
 Python class                 Type code  Payload
@@ -693,9 +693,9 @@ Each of these are described in the following table:
 ======================  =========  =======================================================  ========
 Qiskit class            Type code  Payload                                                  Children
 ======================  =========  =======================================================  ========
-:class:`~.expr.Var`     ``x``      One EXPR_VAR.                                            0
+:class:`~.expr.Var`     ``x``      One ``EXPR_VAR``.                                        0
 
-:class:`~.expr.Value`   ``v``      One EXPR_VALUE.                                          0
+:class:`~.expr.Value`   ``v``      One ``EXPR_VALUE``.                                      0
 
 :class:`~.expr.Cast`    ``c``      One ``_Bool``  that corresponds to the value of          1
                                    ``implicit``.

qiskit/quantum_info/operators/channel/chi.py

@@ -18,6 +18,8 @@ Chi-matrix representation of a Quantum Channel.
 from __future__ import annotations
 import copy as _copy
 import math
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -31,6 +33,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_chi
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Chi(QuantumChannel):
     r"""Pauli basis Chi-matrix representation of a quantum channel.
@@ -59,21 +64,16 @@ class Chi(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a quantum channel Chi-matrix operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data is not an N-qubit channel or

qiskit/quantum_info/operators/channel/choi.py

@@ -18,6 +18,8 @@ Choi-matrix representation of a Quantum Channel.
 from __future__ import annotations
 import copy as _copy
 import math
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -32,6 +34,9 @@ from qiskit.quantum_info.operators.channel.transformations import _bipartite_ten
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Choi(QuantumChannel):
     r"""Choi-matrix representation of a Quantum Channel.
@@ -64,21 +69,16 @@ class Choi(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a quantum channel Choi matrix operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data cannot be initialized as a

qiskit/quantum_info/operators/channel/ptm.py

@@ -18,6 +18,8 @@ Pauli Transfer Matrix (PTM) representation of a Quantum Channel.
 from __future__ import annotations
 import copy as _copy
 import math
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -30,6 +32,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_ptm
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class PTM(QuantumChannel):
     r"""Pauli Transfer Matrix (PTM) representation of a Quantum Channel.
@@ -67,21 +72,16 @@ class PTM(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a PTM quantum channel operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data is not an N-qubit channel or

qiskit/quantum_info/operators/channel/quantum_channel.py

@@ -53,9 +53,9 @@ class QuantumChannel(LinearOp):
         """Initialize a quantum channel Superoperator operator.
 
         Args:
-            data (array or list): quantum channel data array.
-            op_shape (OpShape): the operator shape of the channel.
-            num_qubits (int): the number of qubits if the channel is N-qubit.
+            data: quantum channel data array.
+            op_shape: the operator shape of the channel.
+            num_qubits: the number of qubits if the channel is N-qubit.
 
         Raises:
             QiskitError: if arguments are invalid.

qiskit/quantum_info/operators/channel/stinespring.py

@@ -17,6 +17,8 @@ from __future__ import annotations
 import copy
 import math
 from numbers import Number
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
@@ -32,6 +34,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_stinesprin
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Stinespring(QuantumChannel):
     r"""Stinespring representation of a quantum channel.
@@ -64,21 +69,16 @@ class Stinespring(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a quantum channel Stinespring operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data cannot be initialized as a

qiskit/quantum_info/operators/channel/superop.py

@@ -33,6 +33,7 @@ from qiskit.quantum_info.operators.op_shape import OpShape
 from qiskit.quantum_info.operators.operator import Operator
 
 if TYPE_CHECKING:
+    from qiskit import circuit
     from qiskit.quantum_info.states.densitymatrix import DensityMatrix
     from qiskit.quantum_info.states.statevector import Statevector
 
@@ -62,21 +63,16 @@ class SuperOp(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: tuple | None = None,
         output_dims: tuple | None = None,
     ):
         """Initialize a quantum channel Superoperator operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data cannot be initialized as a

qiskit/quantum_info/states/densitymatrix.py

@@ -17,6 +17,8 @@ DensityMatrix quantum state class.
 from __future__ import annotations
 import copy as _copy
 from numbers import Number
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -37,27 +39,27 @@ from qiskit.quantum_info.operators.channel.superop import SuperOp
 from qiskit._accelerate.pauli_expval import density_expval_pauli_no_x, density_expval_pauli_with_x
 from qiskit.quantum_info.states.statevector import Statevector
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class DensityMatrix(QuantumState, TolerancesMixin):
     """DensityMatrix class"""
 
     def __init__(
         self,
-        data: np.ndarray | list | QuantumCircuit | Instruction | QuantumState,
+        data: np.ndarray | list | QuantumCircuit | circuit.instruction.Instruction | QuantumState,
         dims: int | tuple | list | None = None,
     ):
         """Initialize a density matrix object.
 
         Args:
-            data (np.ndarray or list or matrix_like or QuantumCircuit or
-                  qiskit.circuit.Instruction):
-                A statevector, quantum instruction or an object with a ``to_operator`` or
+            data: A statevector, quantum instruction or an object with a ``to_operator`` or
                 ``to_matrix`` method from which the density matrix can be constructed.
                 If a vector the density matrix is constructed as the projector of that vector.
                 If a quantum instruction, the density matrix is constructed by assuming all
                 qubits are initialized in the zero state.
-            dims (int or tuple or list): Optional. The subsystem dimension
-                    of the state (See additional information).
+            dims: The subsystem dimension of the state (See additional information).
 
         Raises:
             QiskitError: if input data is not valid.
@@ -303,19 +305,17 @@ class DensityMatrix(QuantumState, TolerancesMixin):
 
     def evolve(
         self,
-        other: Operator | QuantumChannel | Instruction | QuantumCircuit,
+        other: Operator | QuantumChannel | circuit.instruction.Instruction | QuantumCircuit,
         qargs: list[int] | None = None,
     ) -> DensityMatrix:
         """Evolve a quantum state by an operator.
 
         Args:
-            other (Operator or QuantumChannel
-                   or Instruction or Circuit): The operator to evolve by.
-            qargs (list): a list of QuantumState subsystem positions to apply
-                           the operator on.
+            other: The operator to evolve by.
+            qargs: a list of QuantumState subsystem positions to apply the operator on.
 
         Returns:
-            DensityMatrix: the output density matrix.
+            The output density matrix.
 
         Raises:
             QiskitError: if the operator dimension does not match the
@@ -598,7 +598,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         return DensityMatrix(state, dims=dims)
 
     @classmethod
-    def from_instruction(cls, instruction: Instruction | QuantumCircuit) -> DensityMatrix:
+    def from_instruction(
+        cls, instruction: circuit.instruction.Instruction | QuantumCircuit
+    ) -> DensityMatrix:
         """Return the output density matrix of an instruction.
 
         The statevector is initialized in the state :math:`|{0,\\ldots,0}\\rangle` of
@@ -606,10 +608,10 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         by the input instruction, and the output statevector returned.
 
         Args:
-            instruction (qiskit.circuit.Instruction or QuantumCircuit): instruction or circuit
+            instruction: instruction or circuit
 
         Returns:
-            DensityMatrix: the final density matrix.
+            The final density matrix.
 
         Raises:
             QiskitError: if the instruction contains invalid instructions for

qiskit/quantum_info/states/stabilizerstate.py

@@ -17,6 +17,7 @@ Stabilizer state class.
 from __future__ import annotations
 
 from collections.abc import Collection
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -28,6 +29,9 @@ from qiskit.quantum_info.operators.symplectic.clifford_circuits import _append_x
 from qiskit.quantum_info.states.quantum_state import QuantumState
 from qiskit.circuit import QuantumCircuit, Instruction
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class StabilizerState(QuantumState):
     """StabilizerState class.
@@ -79,17 +83,14 @@ class StabilizerState(QuantumState):
 
     def __init__(
         self,
-        data: StabilizerState | Clifford | Pauli | QuantumCircuit | Instruction,
+        data: StabilizerState | Clifford | Pauli | QuantumCircuit | circuit.instruction.Instruction,
         validate: bool = True,
     ):
         """Initialize a StabilizerState object.
 
         Args:
-            data (StabilizerState or Clifford or Pauli or QuantumCircuit or
-                  qiskit.circuit.Instruction):
-                Data from which the stabilizer state can be constructed.
-            validate (boolean): validate that the stabilizer state data is
-                a valid Clifford.
+            data: Data from which the stabilizer state can be constructed.
+            validate: validate that the stabilizer state data is a valid Clifford.
         """
 
         # Initialize from another StabilizerState

qiskit/quantum_info/states/statevector.py

@@ -18,6 +18,7 @@ import copy as _copy
 import math
 import re
 from numbers import Number
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -37,27 +38,34 @@ from qiskit._accelerate.pauli_expval import (
     expval_pauli_with_x,
 )
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Statevector(QuantumState, TolerancesMixin):
     """Statevector class"""
 
     def __init__(
         self,
-        data: np.ndarray | list | Statevector | Operator | QuantumCircuit | Instruction,
+        data: (
+            np.ndarray
+            | list
+            | Statevector
+            | Operator
+            | QuantumCircuit
+            | circuit.instruction.Instruction
+        ),
         dims: int | tuple | list | None = None,
     ):
         """Initialize a statevector object.
 
         Args:
-            data (np.array or list or Statevector or Operator or QuantumCircuit or
-                  qiskit.circuit.Instruction):
-                Data from which the statevector can be constructed. This can be either a complex
+            data: Data from which the statevector can be constructed. This can be either a complex
                 vector, another statevector, a ``Operator`` with only one column or a
                 ``QuantumCircuit`` or ``Instruction``.  If the data is a circuit or instruction,
                 the statevector is constructed by assuming that all qubits are initialized to the
                 zero state.
-            dims (int or tuple or list): Optional. The subsystem dimension of
-                                         the state (See additional information).
+            dims: The subsystem dimension of the state (See additional information).
 
         Raises:
             QiskitError: if input data is not valid.

qiskit/transpiler/passes/basis/decompose.py

@@ -17,8 +17,10 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import Type
 from fnmatch import fnmatch
+import warnings
 
 from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
 from qiskit.dagcircuit.dagnode import DAGOpNode
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
 from qiskit.converters.circuit_to_dag import circuit_to_dag
@@ -58,7 +60,7 @@ class Decompose(TransformationPass):
             output dag where ``gate`` was expanded.
         """
         # We might use HLS to synthesize objects that do not have a definition
-        hls = HighLevelSynthesis() if self.apply_synthesis else None
+        hls = HighLevelSynthesis(qubits_initially_zero=False) if self.apply_synthesis else None
 
         # Walk through the DAG and expand each non-basis node
         for node in dag.op_nodes():
@@ -66,12 +68,18 @@ class Decompose(TransformationPass):
             if not self._should_decompose(node):
                 continue
 
-            if getattr(node.op, "definition", None) is None:
+            if node.is_control_flow():
+                decomposition = control_flow.map_blocks(self.run, node.op)
+                dag.substitute_node(node, decomposition, inplace=True)
+
+            elif getattr(node.op, "definition", None) is None:
                 # if we try to synthesize, turn the node into a DAGCircuit and run HLS
                 if self.apply_synthesis:
+                    # note that node_as_dag does not include the condition, which will
+                    # be propagated in ``substitute_node_with_dag``
                     node_as_dag = _node_to_dag(node)
                     synthesized = hls.run(node_as_dag)
-                    dag.substitute_node_with_dag(node, synthesized)
+                    dag.substitute_node_with_dag(node, synthesized, propagate_condition=True)
 
                 # else: no definition and synthesis not enabled, so we do nothing
             else:
@@ -123,9 +131,21 @@ class Decompose(TransformationPass):
 
 
 def _node_to_dag(node: DAGOpNode) -> DAGCircuit:
+    # Control flow is already handled separately, however that does not capture
+    # c_if, which we are treating here. We explicitly ignore the condition attribute,
+    # which will be handled by ``substitute_node_with_dag``, so we create a copy of the node
+    # and set the condition to None. Once ``c_if`` is removed for 2.0, this block can go, too.
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
+        if getattr(node.op, "condition", None) is not None:
+            op = node.op.copy()
+            op.condition = None
+            node = DAGOpNode(op, node.qargs, node.cargs)
+
+    # create new dag and apply the operation
     dag = DAGCircuit()
     dag.add_qubits(node.qargs)
     dag.add_clbits(node.cargs)
-
     dag.apply_operation_back(node.op, node.qargs, node.cargs)
+
     return dag

qiskit/transpiler/passes/synthesis/hls_plugins.py

@@ -300,6 +300,10 @@ Modular Adder Synthesis
       - :class:`.ModularAdderSynthesisD00`
       - 0
       - a QFT-based adder
+    * - ``"default"``
+      - :class:`~.ModularAdderSynthesisDefault`
+      - any
+      - chooses the best algorithm based on the ancillas available
 
 .. autosummary::
    :toctree: ../stubs/
@@ -307,6 +311,7 @@ Modular Adder Synthesis
    ModularAdderSynthesisC04
    ModularAdderSynthesisD00
    ModularAdderSynthesisV95
+   ModularAdderSynthesisDefault
 
 Half Adder Synthesis
 ''''''''''''''''''''
@@ -330,6 +335,10 @@ Half Adder Synthesis
       - :class:`.HalfAdderSynthesisD00`
       - 0
       - a QFT-based adder
+    * - ``"default"``
+      - :class:`~.HalfAdderSynthesisDefault`
+      - any
+      - chooses the best algorithm based on the ancillas available
 
 .. autosummary::
    :toctree: ../stubs/
@@ -337,6 +346,7 @@ Half Adder Synthesis
    HalfAdderSynthesisC04
    HalfAdderSynthesisD00
    HalfAdderSynthesisV95
+   HalfAdderSynthesisDefault
 
 Full Adder Synthesis
 ''''''''''''''''''''
@@ -356,12 +366,17 @@ Full Adder Synthesis
       - :class:`.FullAdderSynthesisV95`
       - :math:`n-1`, for :math:`n`-bit numbers
       - a ripple-carry adder
+    * - ``"default"``
+      - :class:`~.FullAdderSynthesisDefault`
+      - any
+      - chooses the best algorithm based on the ancillas available
 
 .. autosummary::
    :toctree: ../stubs/
 
    FullAdderSynthesisC04
    FullAdderSynthesisV95
+   FullAdderSynthesisDefault
 
 
 Multiplier Synthesis
@@ -1212,10 +1227,26 @@ class ModularAdderSynthesisDefault(HighLevelSynthesisPlugin):
         if not isinstance(high_level_object, ModularAdderGate):
             return None
 
-        if options.get("num_clean_ancillas", 0) >= 1:
-            return adder_ripple_c04(high_level_object.num_state_qubits, kind="fixed")
+        # For up to 5 qubits, the QFT-based adder is best
+        if high_level_object.num_state_qubits <= 5:
+            decomposition = ModularAdderSynthesisD00().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+            if decomposition is not None:
+                return decomposition
 
-        return adder_qft_d00(high_level_object.num_state_qubits, kind="fixed")
+        # Otherwise, the following decomposition is best (if there are enough ancillas)
+        if (
+            decomposition := ModularAdderSynthesisC04().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+        ) is not None:
+            return decomposition
+
+        # Otherwise, use the QFT-adder again
+        return ModularAdderSynthesisD00().run(
+            high_level_object, coupling_map, target, qubits, **options
+        )
 
 
 class ModularAdderSynthesisC04(HighLevelSynthesisPlugin):
@@ -1264,8 +1295,8 @@ class ModularAdderSynthesisV95(HighLevelSynthesisPlugin):
 
         num_state_qubits = high_level_object.num_state_qubits
 
-        # for more than 1 state qubit, we need an ancilla
-        if num_state_qubits > 1 > options.get("num_clean_ancillas", 1):
+        # The synthesis method needs n-1 clean ancilla qubits
+        if num_state_qubits - 1 > options.get("num_clean_ancillas", 0):
             return None
 
         return adder_ripple_v95(num_state_qubits, kind="fixed")
@@ -1309,10 +1340,26 @@ class HalfAdderSynthesisDefault(HighLevelSynthesisPlugin):
         if not isinstance(high_level_object, HalfAdderGate):
             return None
 
-        if options.get("num_clean_ancillas", 0) >= 1:
-            return adder_ripple_c04(high_level_object.num_state_qubits, kind="half")
+        # For up to 3 qubits, ripple_v95 is better (if there are enough ancilla qubits)
+        if high_level_object.num_state_qubits <= 3:
+            decomposition = HalfAdderSynthesisV95().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+            if decomposition is not None:
+                return decomposition
 
-        return adder_qft_d00(high_level_object.num_state_qubits, kind="half")
+        # The next best option is to use ripple_c04 (if there are enough ancilla qubits)
+        if (
+            decomposition := HalfAdderSynthesisC04().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+        ) is not None:
+            return decomposition
+
+        # The QFT-based adder does not require ancilla qubits and should always succeed
+        return HalfAdderSynthesisD00().run(
+            high_level_object, coupling_map, target, qubits, **options
+        )
 
 
 class HalfAdderSynthesisC04(HighLevelSynthesisPlugin):
@@ -1360,8 +1407,8 @@ class HalfAdderSynthesisV95(HighLevelSynthesisPlugin):
 
         num_state_qubits = high_level_object.num_state_qubits
 
-        # for more than 1 state qubit, we need an ancilla
-        if num_state_qubits > 1 > options.get("num_clean_ancillas", 1):
+        # The synthesis method needs n-1 clean ancilla qubits
+        if num_state_qubits - 1 > options.get("num_clean_ancillas", 0):
             return None
 
         return adder_ripple_v95(num_state_qubits, kind="half")
@@ -1381,18 +1428,38 @@ class HalfAdderSynthesisD00(HighLevelSynthesisPlugin):
         return adder_qft_d00(high_level_object.num_state_qubits, kind="half")
 
 
-class FullAdderSynthesisC04(HighLevelSynthesisPlugin):
+class FullAdderSynthesisDefault(HighLevelSynthesisPlugin):
     """A ripple-carry adder with a carry-in and a carry-out bit.
 
-    This plugin name is:``FullAdder.ripple_c04`` which can be used as the key on
+    This plugin name is:``FullAdder.default`` which can be used as the key on
     an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
 
-    This plugin requires at least one clean auxiliary qubit.
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, FullAdderGate):
+            return None
 
-    The plugin supports the following plugin-specific options:
+        # FullAdderSynthesisC04 requires no ancilla qubits and returns better results
+        # than FullAdderSynthesisV95 in all cases except for n=1.
+        if high_level_object.num_state_qubits == 1:
+            decomposition = FullAdderSynthesisV95().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+            if decomposition is not None:
+                return decomposition
+
+        return FullAdderSynthesisC04().run(
+            high_level_object, coupling_map, target, qubits, **options
+        )
 
-    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
 
+class FullAdderSynthesisC04(HighLevelSynthesisPlugin):
+    """A ripple-carry adder with a carry-in and a carry-out bit.
+
+    This plugin name is:``FullAdder.ripple_c04`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    This plugin requires no auxiliary qubits.
     """
 
     def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
@@ -1409,7 +1476,7 @@ class FullAdderSynthesisV95(HighLevelSynthesisPlugin):
     an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
 
     For an adder on 2 registers with :math:`n` qubits each, this plugin requires at
-    least :math:`n-1` clean auxiliary qubit.
+    least :math:`n-1` clean auxiliary qubits.
 
     The plugin supports the following plugin-specific options:
 
@@ -1422,8 +1489,8 @@ class FullAdderSynthesisV95(HighLevelSynthesisPlugin):
 
         num_state_qubits = high_level_object.num_state_qubits
 
-        # for more than 1 state qubit, we need an ancilla
-        if num_state_qubits > 1 > options.get("num_clean_ancillas", 1):
+        # The synthesis method needs n-1 clean ancilla qubits
+        if num_state_qubits - 1 > options.get("num_clean_ancillas", 0):
             return None
 
         return adder_ripple_v95(num_state_qubits, kind="full")

{qiskit-1.3.0.dist-info → qiskit-1.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qiskit
-Version: 1.3.0
+Version: 1.3.1
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0
@@ -124,7 +124,7 @@ from qiskit.primitives import StatevectorSampler
 sampler = StatevectorSampler()
 job = sampler.run([qc_measured], shots=1000)
 result = job.result()
-print(f" > Counts: {result[0].meas.get_counts()}")
+print(f" > Counts: {result[0].data["meas"].get_counts()}")
 ```
 Running this will give an outcome similar to `{'000': 497, '111': 503}` which is `000` 50% of the time and `111` 50% of the time up to statistical fluctuations.
 To illustrate the power of Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note the Estimator requires a circuit _**without**_ measurement, so we use the `qc_example` circuit we created earlier.

{qiskit-1.3.0.dist-info → qiskit-1.3.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
 qiskit/version.py,sha256=MiraFeJt5GQEspFyvP3qJedHen2C1e8dNEttzg0u7YU,2498
 qiskit/__init__.py,sha256=MHSxG7bMhoESBIzoz9DdWdolCdPTwnwHJ80zjWMoRd4,7483
-qiskit/_accelerate.abi3.so,sha256=52drVWFkqE78EDnD5vbQu2zjxMADEE_jHJQbBjbpyPw,9498736
+qiskit/_accelerate.abi3.so,sha256=RMO66v3IrohUFG-LRG-Akp8SmERAtPuJXMwNTgJr5DY,9496568
 qiskit/user_config.py,sha256=I7QCF9W2IDpleWunxDjgYGySsVUlq57gfj_137o0Dac,10109
 qiskit/_numpy_compat.py,sha256=ZlnDTF2KBTKcVF489ZuxoBk6r9KLsMuhAlozFhOn0a8,2815
 qiskit/exceptions.py,sha256=78bbfww9680_v4CaNgepavY5DwGTN7_j47Ckob3lLPM,5619
-qiskit/VERSION.txt,sha256=ZNI_hY71Gw-Zbklm1OJ8A3G0N-LSeHiQsfetItTsVmM,6
+qiskit/VERSION.txt,sha256=EOLhF7AVI4kconGmFa426dXlI0j9fWQvZnJ2AsG43L4,6
 qiskit/visualization/circuit_visualization.py,sha256=6R-A96Uwb_RZOovsSB0LGVsC7lP5IhtLNp6VP2yVBwE,698
 qiskit/visualization/counts_visualization.py,sha256=rgoEqV0gucL9Auz33wf1LiRWR3yFQzjK94zzBF830iY,16791
 qiskit/visualization/pass_manager_visualization.py,sha256=19m4pUdYG0csZgQbuxfFP-zfoVGnk0pJr0HVToD1Y04,10886
@@ -181,7 +181,7 @@ qiskit/transpiler/passes/utils/gates_basis.py,sha256=9AQ8uKi4CmiGF0CBnLQfc07ca_H
 qiskit/transpiler/passes/utils/barrier_before_final_measurements.py,sha256=1N8OMvteNo9UpRPn7aST62D56u8ikSTYK8ZFZWKOYGE,1530
 qiskit/transpiler/passes/utils/fixed_point.py,sha256=AiwkNvu-SLHvodddJRKfFEl7FPC62u1f3CB9lRne9eY,1773
 qiskit/transpiler/passes/synthesis/solovay_kitaev_synthesis.py,sha256=xM0KHNaH8N9-tn5rhC5tAGc5-faID8GvVFbH6HCqnsE,11052
-qiskit/transpiler/passes/synthesis/hls_plugins.py,sha256=cuQ6-6qDfks_oA8afqvP3u3hIw6fRXzi7-swGrPf9L0,58255
+qiskit/transpiler/passes/synthesis/hls_plugins.py,sha256=4iWj6k4UDBTtRjjPU-mbXUzCuDXLJepb2JHqWmo4-Zg,60946
 qiskit/transpiler/passes/synthesis/__init__.py,sha256=VYO9Sl_SJyoZ_bLronrkvK9u8kL-LW9G93LbWyWNEaM,925
 qiskit/transpiler/passes/synthesis/plugin.py,sha256=LnvGzGJ8Q5gSPKSJNmJ7fvnUub8lzG5iGGTqOTODpes,30806
 qiskit/transpiler/passes/synthesis/linear_functions_synthesis.py,sha256=Q1r-52HMETK_7iWTMmJKGU39rNws-MrmGDHh7TgQVj4,1407
@@ -205,7 +205,7 @@ qiskit/transpiler/passes/routing/algorithms/util.py,sha256=0mZFWUKp8z-8K2HjPRxwu
 qiskit/transpiler/passes/routing/algorithms/__init__.py,sha256=xqgItNZmE9Asul94FzsBbUdU2d6h7j9bOY5p7q0QKYc,1403
 qiskit/transpiler/passes/routing/algorithms/types.py,sha256=9yX3_8JFvA4T5_tXWb3T304EscCnETkoFY0_Q_Gzr-A,1708
 qiskit/transpiler/passes/routing/algorithms/token_swapper.py,sha256=_Xxnk5rasIJ5DIQqR6AwMVdxTe5xgJ_bA_RL2FCGfs0,4118
-qiskit/transpiler/passes/basis/decompose.py,sha256=eGGAiuA3ugeFytkTnkK6cnFzGZKtKfc5iEtF3hk1EP4,4967
+qiskit/transpiler/passes/basis/decompose.py,sha256=_P9TuT8Ui75OhTi-iROcdtGKrThvY-FcatS05gjT6dc,6123
 qiskit/transpiler/passes/basis/translate_parameterized.py,sha256=jNekE2530Pj-WGlxDPfCa8bErISDFhRUsC3j0GtrxCs,7425
 qiskit/transpiler/passes/basis/__init__.py,sha256=JF0s79eUZOJo-8T8rFUlq0nvF7Q-FS7sqjB1A2Jy7Yo,783
 qiskit/transpiler/passes/basis/unroll_3q_or_more.py,sha256=g2Fsuv5WCgufdh7tw0hMQUUQFkyeExIU9ENaWGqTZpo,3726
@@ -267,7 +267,7 @@ qiskit/circuit/classicalregister.py,sha256=oLKotR8jFREs6i2M1K7Jrvm5rrfG7TzLgaB0-
 qiskit/circuit/operation.py,sha256=ecfuw_bkQYFsHyEPdf1z-vJhY99NYSFLYps_X1DF3jc,2015
 qiskit/circuit/quantumregister.py,sha256=S_4lTalKmDI0LiVq3WJUyqDQwrx7-7mVDOMO-YIs4qI,2032
 qiskit/circuit/parameterexpression.py,sha256=INJe0jYbeujGltUQIoJ-70s3nRmCtd1ECL_gLUJ_adA,27041
-qiskit/circuit/add_control.py,sha256=F1l4ZiZum3CtCAtE_bSkZvd0dBCchqN83DirtBoBC9g,11369
+qiskit/circuit/add_control.py,sha256=jT_PaSowKSFa3g_upN0PP0qCLIKsFpkP4h11H-T55js,10308
 qiskit/circuit/delay.py,sha256=4tWlJU86nifIvZfb0q5m6F25Ckf9kRQPIBxh6IYm1hc,4926
 qiskit/circuit/twirling.py,sha256=HmpR4EzfKEkI5hW50gstzg2S6f464jF6MbtGquyGbG8,6213
 qiskit/circuit/gate.py,sha256=62_KeRCnxEk1m7WffSWSmEaONuNTkiNi5pB7uISLPYU,10242
@@ -354,8 +354,8 @@ qiskit/circuit/library/arithmetic/adders/vbe_ripple_carry_adder.py,sha256=hSk8Yi
 qiskit/circuit/library/arithmetic/adders/cdkm_ripple_carry_adder.py,sha256=6_t_r2qB9Ancp24EnrZ8bOB0k9W-_akT7rcRDmPz-CE,7460
 qiskit/circuit/library/arithmetic/adders/__init__.py,sha256=PRrSLxGAtAMm-9L6UIFnL3ta0NSYUIhEklpf_i9bE5s,743
 qiskit/circuit/library/arithmetic/adders/draper_qft_adder.py,sha256=bUV7q1nbQoftKVjX0D-HcW_kyJqWrJpP8muXnV7SeRU,6039
-qiskit/circuit/library/arithmetic/adders/adder.py,sha256=nE-I8_yAB7_CLSIIm_LcRH-_r72wVnd5N9JnlSilc9Q,6669
-qiskit/circuit/library/arithmetic/multipliers/multiplier.py,sha256=ie_IV_oX4axsjJyI6tdr0p69w28pdvBBrxlOzxuPBNY,6967
+qiskit/circuit/library/arithmetic/adders/adder.py,sha256=DM0FmgeGK8S9cOmX_E_Nyk9Q1H_fnJ3vxUMvwp1Ar-E,7887
+qiskit/circuit/library/arithmetic/multipliers/multiplier.py,sha256=L487WCWB6YN9EAACm2Aih6e0GhuQaYk-mbA_ACWeP9Q,7409
 qiskit/circuit/library/arithmetic/multipliers/__init__.py,sha256=vRtcHF2PRcyK_lfBQFqsWlpeaGwkcK3PK1KeduHvfOE,672
 qiskit/circuit/library/arithmetic/multipliers/hrs_cumulative_multiplier.py,sha256=oJIWVc2wFLz-GbU06jurKU3xcyxWdd7AbsH7SVMu0-c,6850
 qiskit/circuit/library/arithmetic/multipliers/rg_qft_multiplier.py,sha256=fhFUM0wTyK8X8CLDQEKs05Ezzos5uS_kybCoj9zSeuw,6215
@@ -737,7 +737,7 @@ qiskit/primitives/base/estimator_result.py,sha256=YUNMS8uKaHVGBn4j2QKJBijh3nsQkE
 qiskit/primitives/base/base_primitive_job.py,sha256=E9JZPlHeDU-Zx2ccje73dpEAkt0rCYD1yrMb-WEmgbk,2834
 qiskit/primitives/base/validation.py,sha256=KMWbPhGUSyr1XYSoh11YgNBabjgtgVpbTFYu9-0TvjU,8846
 qiskit/qpy/interface.py,sha256=Cd089X6aInCjNEz3GA3Ea75A_Lo09Vkx43aQBsEVdkU,14131
-qiskit/qpy/__init__.py,sha256=i74jxPkXR1oX9zGxDElxtLQ7rDkUNC6_IajmZ_g24HA,63066
+qiskit/qpy/__init__.py,sha256=pG7qBgFVy8vtin_5adA6mrgcANR1AXcXaLe4MqesLz8,63073
 qiskit/qpy/common.py,sha256=kKcrLZAdEbXssanEPCHQ693FznmtNmucmmApDnd1e9I,12258
 qiskit/qpy/type_keys.py,sha256=_2FKRgX1H6B5L6UOt3RCBzbeecNh0LPISZUr75felQg,15761
 qiskit/qpy/formats.py,sha256=E9I8sxK1Zj5Nhk5-BbyHbSaBrdsj15AR3DGoVvTrL0k,11520
@@ -806,31 +806,31 @@ qiskit/quantum_info/operators/utils/anti_commutator.py,sha256=mn8j5qsW4ZRED8OMcZ
 qiskit/quantum_info/operators/utils/__init__.py,sha256=E-Z7NJUaWRxqJN1lcYdDqSupLLKE1QUejl9ttQ8_04U,704
 qiskit/quantum_info/operators/utils/double_commutator.py,sha256=fXW2YPgzPyzHOSbPW0HQZ6WYzjHHD1zd0sJunMzpvOc,1978
 qiskit/quantum_info/operators/utils/commutator.py,sha256=BR7lgW4tD6SZKxiQIQE7CQSCYGKRaqPFzWaO03QLuY8,957
-qiskit/quantum_info/operators/channel/ptm.py,sha256=U0Ybr8NBvh4zVGXgaQuwX4EzwqRshXWjCsP36pSzv0s,7911
+qiskit/quantum_info/operators/channel/ptm.py,sha256=23HzPAj5ondGqxSnunQJaSbL1ogtVJjWef1-oHIVQcc,7790
 qiskit/quantum_info/operators/channel/transformations.py,sha256=vtNroGYrTtABB1ERI8dNjSBwM3FzaI-nLNSwyoVXGGA,17624
-qiskit/quantum_info/operators/channel/choi.py,sha256=zy5y7HIGAUd8VA74flqASVpbAFBKv0ymEuS8BAYMZXk,8582
-qiskit/quantum_info/operators/channel/stinespring.py,sha256=pWOhoD50zpEjaduIXZp68GaoUkp0xwQPclf4If7Y35g,11560
+qiskit/quantum_info/operators/channel/choi.py,sha256=O_8a2M2zL8z_mxcq0LChINwrl2XzGMHsM5D8vmU681Q,8461
+qiskit/quantum_info/operators/channel/stinespring.py,sha256=QgSMgc6ZFs_dUu3rFgTS43G468SU4arLZKxErQEkUvk,11439
 qiskit/quantum_info/operators/channel/__init__.py,sha256=CeahSP9rvIa-dgQNQkTqI7MTRMLebR19jmLhOEhr5Ps,940
-qiskit/quantum_info/operators/channel/superop.py,sha256=qf90bicH9QzmBitdXEbbX65n_TLw0jzd1wn1pQpyBqE,15859
+qiskit/quantum_info/operators/channel/superop.py,sha256=1UvaRfApud0rOw2QyuD-u5J-OIyBfdWQxDTnCgS-sSQ,15685
 qiskit/quantum_info/operators/channel/kraus.py,sha256=P_pB739LfvC9n13L9LwMVzLXLmsNoOk53CaD3pEsENo,13259
-qiskit/quantum_info/operators/channel/chi.py,sha256=uyEetmFAOZaft22AfhNPrUIPfdNXDRnXkxBw4jSsouM,7782
-qiskit/quantum_info/operators/channel/quantum_channel.py,sha256=T8ohen29CZUyrnAWvt_uRpu_ETU7w3P1HfR9U5oVKWY,13981
-qiskit/quantum_info/states/stabilizerstate.py,sha256=XX2iNbTXtyelFOc4smcFz1nqytgcJdYoDzX__e4T-AI,29713
-qiskit/quantum_info/states/statevector.py,sha256=t1g8uhLhuKxXImWJuH2Fp3KyyLML8Z9mU8sA1o_j4tE,36811
+qiskit/quantum_info/operators/channel/chi.py,sha256=eGgaPgaVXe38LLdPdJuep6uRnxJzv4PIg3uv3ngDXMk,7661
+qiskit/quantum_info/operators/channel/quantum_channel.py,sha256=eRVP5rBJ_TdURD83UrU7YSY7hLDkGosLm3N03c9tFUQ,13949
+qiskit/quantum_info/states/stabilizerstate.py,sha256=7af0aYkdH1f8mAKDvhLNH_x_OJFKtQLymCUddhWQkoQ,29669
+qiskit/quantum_info/states/statevector.py,sha256=_SwAGdUOmzwu__VSCNBOPywU4vS1GnIRb4G28S12iGs,36796
 qiskit/quantum_info/states/__init__.py,sha256=Zepc7tCs93UIRVkLJYks3FH3pCoIe48f-rVtQ0X6qoQ,897
 qiskit/quantum_info/states/random.py,sha256=oxQWWdCpZVxTnbrBUfdRodVKhRhhFD-pW4zcxUt5dM0,5062
 qiskit/quantum_info/states/measures.py,sha256=9YvouvJ5I9D8_BZBe3oiyrQwdtOIapV12bhCYCuWZUo,9753
 qiskit/quantum_info/states/utils.py,sha256=Trw5T6EX3FHpjgKoQm6788wZwe4JtFJIvD4V-MA0Qwg,8758
-qiskit/quantum_info/states/densitymatrix.py,sha256=fvupK0BPPVYO5ONQX1CqPFnq-OrcFqU2QXgTP5DJyHs,32892
+qiskit/quantum_info/states/densitymatrix.py,sha256=fTpAa2Cq1hspA1vWCe8cdJsGSShZLu6jQPNfKD2EsGg,32694
 qiskit/quantum_info/states/quantum_state.py,sha256=v__EAFkAu2aJwafAfaVDce5_525fTkTrTaJdrdQhAr0,17774
 qiskit/compiler/sequencer.py,sha256=uvwF1e3R8gLpf91zD3Fr7UzgfQw9mcv_orHsYVhSOz0,3210
 qiskit/compiler/__init__.py,sha256=Far4-zXOyDGCqdNmFP4Q8zV47meApMw6sbIdd1t_wM4,989
 qiskit/compiler/assembler.py,sha256=nsF7XRgHJVgBrJ5BIj44YsGpNsN5OpqvTYCrGVl9IlY,27813
 qiskit/compiler/transpiler.py,sha256=dJ_MpUw1COntDag6pefwoVB09zk4sg-5taNEaKiQzO8,26504
 qiskit/compiler/scheduler.py,sha256=RYwAaSym3Y4GwRhbx356FtsvF_JN_rhOLwKP84nUp9E,4532
-qiskit-1.3.0.dist-info/RECORD,,
-qiskit-1.3.0.dist-info/WHEEL,sha256=fPibiktQBtnf1UkmTu0XozqWjXXNjrtDnO8fj2jMx3k,109
-qiskit-1.3.0.dist-info/entry_points.txt,sha256=5Xf0jdIYmLoQN2KoTrdTAfJm9FSd0-w4O0fckxQl7KQ,5669
-qiskit-1.3.0.dist-info/top_level.txt,sha256=_vjFXLv7qrHyJJOC2-JXfG54o4XQygW9GuQPxgtSt9Q,7
-qiskit-1.3.0.dist-info/LICENSE.txt,sha256=IXrBXbzaJ4LgBPUVKIbYR5iMY2eqoMT8jDVTY8Ib0iQ,11416
-qiskit-1.3.0.dist-info/METADATA,sha256=PK2oVEBWOMAprG23iYxs88LBans3HdIh35cJUOf_iQg,12940
+qiskit-1.3.1.dist-info/RECORD,,
+qiskit-1.3.1.dist-info/WHEEL,sha256=fPibiktQBtnf1UkmTu0XozqWjXXNjrtDnO8fj2jMx3k,109
+qiskit-1.3.1.dist-info/entry_points.txt,sha256=8f4O6ZbFAIr5AzsP3wWosbp6n4_WI-sYGkgID9Y9JSE,5673
+qiskit-1.3.1.dist-info/top_level.txt,sha256=_vjFXLv7qrHyJJOC2-JXfG54o4XQygW9GuQPxgtSt9Q,7
+qiskit-1.3.1.dist-info/LICENSE.txt,sha256=IXrBXbzaJ4LgBPUVKIbYR5iMY2eqoMT8jDVTY8Ib0iQ,11416
+qiskit-1.3.1.dist-info/METADATA,sha256=3u8vll5ehxG_o8KlC2Im1VjUmXlI7BOWnkyZngPjk_s,12948

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

@@ -1,5 +1,5 @@
 [qiskit.synthesis]
-FullAdder.default = qiskit.transpiler.passes.synthesis.hls_plugins:FullAdderSynthesisC04
+FullAdder.default = qiskit.transpiler.passes.synthesis.hls_plugins:FullAdderSynthesisDefault
 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