qiskit 1.3.0rc1__cp39-abi3-win_amd64.whl → 1.3.1__cp39-abi3-win_amd64.whl

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.
@@ -476,7 +484,7 @@ class Statevector(QuantumState, TolerancesMixin):
         pauli_phase = (-1j) ** pauli.phase if pauli.phase else 1
 
         if x_mask + z_mask == 0:
-            return pauli_phase * np.linalg.norm(self.data)
+            return pauli_phase * np.linalg.norm(self.data) ** 2
 
         if x_mask == 0:
             return pauli_phase * expval_pauli_no_x(self.data, self.num_qubits, z_mask)

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/optimization/consolidate_blocks.py

@@ -12,9 +12,11 @@
 
 """Replace each block of consecutive gates by a single Unitary node."""
 from __future__ import annotations
+from math import pi
 
 from qiskit.synthesis.two_qubit import TwoQubitBasisDecomposer
-from qiskit.circuit.library.standard_gates import CXGate, CZGate, iSwapGate, ECRGate
+from qiskit.circuit.library.standard_gates import CXGate, CZGate, iSwapGate, ECRGate, RXXGate
+
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passmanager import PassManager
 from qiskit._accelerate.consolidate_blocks import consolidate_blocks
@@ -27,6 +29,7 @@ KAK_GATE_NAMES = {
     "cz": CZGate(),
     "iswap": iSwapGate(),
     "ecr": ECRGate(),
+    "rxx": RXXGate(pi / 2),
 }
 
 
@@ -70,7 +73,6 @@ class ConsolidateBlocks(TransformationPass):
         if basis_gates is not None:
             self.basis_gates = set(basis_gates)
         self.force_consolidate = force_consolidate
-
         if kak_basis_gate is not None:
             self.decomposer = TwoQubitBasisDecomposer(kak_basis_gate)
         elif basis_gates is not None:
@@ -79,8 +81,12 @@ class ConsolidateBlocks(TransformationPass):
                 self.decomposer = TwoQubitBasisDecomposer(
                     KAK_GATE_NAMES[kak_gates.pop()], basis_fidelity=approximation_degree or 1.0
                 )
+            elif "rzx" in basis_gates:
+                self.decomposer = TwoQubitBasisDecomposer(
+                    CXGate(), basis_fidelity=approximation_degree or 1.0
+                )
             else:
-                self.decomposer = TwoQubitBasisDecomposer(CXGate())
+                self.decomposer = None
         else:
             self.decomposer = TwoQubitBasisDecomposer(CXGate())
 
@@ -103,6 +109,7 @@ class ConsolidateBlocks(TransformationPass):
         consolidate_blocks(
             dag,
             self.decomposer._inner_decomposer,
+            self.decomposer.gate.name,
             self.force_consolidate,
             target=self.target,
             basis_gates=self.basis_gates,

qiskit/transpiler/passes/optimization/inverse_cancellation.py

@@ -19,6 +19,7 @@ from qiskit.circuit import Gate
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.passes.utils import control_flow
 
 from qiskit._accelerate.inverse_cancellation import inverse_cancellation
 
@@ -74,6 +75,7 @@ class InverseCancellation(TransformationPass):
 
         super().__init__()
 
+    @control_flow.trivial_recurse
     def run(self, dag: DAGCircuit):
         """Run the InverseCancellation pass on `dag`.
 

qiskit/transpiler/passes/synthesis/high_level_synthesis.py

@@ -382,7 +382,7 @@ class HighLevelSynthesis(TransformationPass):
 
             # If the synthesis changed the operation (i.e. it is not None), store the result.
             if synthesized is not None:
-                synthesized_nodes[node] = (synthesized, synthesized_context)
+                synthesized_nodes[node._node_id] = (synthesized, synthesized_context)
 
             # If the synthesis did not change anything, just update the qubit tracker.
             elif not processed:
@@ -407,8 +407,9 @@ class HighLevelSynthesis(TransformationPass):
         outer_to_local = context.to_local_mapping()
 
         for node in dag.topological_op_nodes():
-            if node in synthesized_nodes:
-                op, op_context = synthesized_nodes[node]
+
+            if op_tuple := synthesized_nodes.get(node._node_id, None):
+                op, op_context = op_tuple
 
                 if isinstance(op, Operation):
                     out.apply_operation_back(op, node.qargs, node.cargs)
@@ -813,6 +814,7 @@ class HighLevelSynthesis(TransformationPass):
             dag._has_calibration_for(node)
             or len(node.qargs) < self._min_qubits
             or node.is_directive()
+            or (self._instruction_supported(node.name, qubits) and not node.is_control_flow())
         ):
             return True
 
@@ -830,15 +832,12 @@ class HighLevelSynthesis(TransformationPass):
             # If all the above constraints hold, and it's already supported or the basis translator
             # can handle it, we'll leave it be.
             and (
-                self._instruction_supported(node.name, qubits)
                 # This uses unfortunately private details of `EquivalenceLibrary`, but so does the
                 # `BasisTranslator`, and this is supposed to just be temporary til this is moved
                 # into Rust space.
-                or (
-                    self._equiv_lib is not None
-                    and equivalence.Key(name=node.name, num_qubits=node.num_qubits)
-                    in self._equiv_lib.keys()
-                )
+                self._equiv_lib is not None
+                and equivalence.Key(name=node.name, num_qubits=node.num_qubits)
+                in self._equiv_lib.keys()
             )
         )