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

qiskit/circuit/barrier.py

@@ -19,6 +19,7 @@ with the :meth:`~qiskit.circuit.QuantumCircuit.barrier` method.
 from __future__ import annotations
 
 from qiskit.exceptions import QiskitError
+from qiskit.utils import deprecate_func
 from .instruction import Instruction
 
 
@@ -44,5 +45,6 @@ class Barrier(Instruction):
         """Special case. Return self."""
         return Barrier(self.num_qubits)
 
+    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
     def c_if(self, classical, val):
         raise QiskitError("Barriers are compiler directives and cannot be conditional.")

qiskit/circuit/controlflow/builder.py

@@ -284,7 +284,7 @@ class InstructionPlaceholder(Instruction, abc.ABC):
             The same instruction instance that was passed, but mutated to propagate the tracked
             changes to this class.
         """
-        instruction.condition = self.condition
+        instruction._condition = self._condition
         return instruction
 
     # Provide some better error messages, just in case something goes wrong during development and
@@ -639,8 +639,8 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
                         # a register is already present, so we use our own tracking.
                         self.add_register(register)
                         out.add_register(register)
-            if getattr(op, "condition", None) is not None:
-                for register in condition_resources(op.condition).cregs:
+            if getattr(op, "_condition", None) is not None:
+                for register in condition_resources(op._condition).cregs:
                     if register not in self.registers:
                         self.add_register(register)
                         out.add_register(register)

qiskit/circuit/controlflow/if_else.py

@@ -87,12 +87,20 @@ class IfElseOp(ControlFlowOp):
 
         super().__init__("if_else", num_qubits, num_clbits, [true_body, false_body], label=label)
 
-        self.condition = validate_condition(condition)
+        self._condition = validate_condition(condition)
 
     @property
     def params(self):
         return self._params
 
+    @property
+    def condition(self):
+        return self._condition
+
+    @condition.setter
+    def condition(self, value):
+        self._condition = value
+
     @params.setter
     def params(self, parameters):
         # pylint: disable=cyclic-import
@@ -152,7 +160,7 @@ class IfElseOp(ControlFlowOp):
         true_body, false_body = (
             ablock for ablock, _ in itertools.zip_longest(blocks, range(2), fillvalue=None)
         )
-        return IfElseOp(self.condition, true_body, false_body=false_body, label=self.label)
+        return IfElseOp(self._condition, true_body, false_body=false_body, label=self.label)
 
     def c_if(self, classical, val):
         raise NotImplementedError(
@@ -200,7 +208,7 @@ class IfElsePlaceholder(InstructionPlaceholder):
             "if_else", len(self.__resources.qubits), len(self.__resources.clbits), [], label=label
         )
         # Set the condition after super().__init__() has initialized it to None.
-        self.condition = validate_condition(condition)
+        self._condition = validate_condition(condition)
 
     def with_false_block(self, false_block: ControlFlowBuilderBlock) -> "IfElsePlaceholder":
         """Return a new placeholder instruction, with the false block set to the given value,
@@ -225,7 +233,7 @@ class IfElsePlaceholder(InstructionPlaceholder):
         false_bits = false_block.qubits() | false_block.clbits()
         true_block.add_bits(false_bits - true_bits)
         false_block.add_bits(true_bits - false_bits)
-        return type(self)(self.condition, true_block, false_block, label=self.label)
+        return type(self)(self._condition, true_block, false_block, label=self.label)
 
     def registers(self):
         """Get the registers used by the interior blocks."""
@@ -288,7 +296,7 @@ class IfElsePlaceholder(InstructionPlaceholder):
             )
         return (
             self._copy_mutable_properties(
-                IfElseOp(self.condition, true_body, false_body, label=self.label)
+                IfElseOp(self._condition, true_body, false_body, label=self.label)
             ),
             InstructionResources(
                 qubits=tuple(true_body.qubits),

qiskit/circuit/controlflow/while_loop.py

@@ -53,12 +53,20 @@ class WhileLoopOp(ControlFlowOp):
         num_clbits = body.num_clbits
 
         super().__init__("while_loop", num_qubits, num_clbits, [body], label=label)
-        self.condition = validate_condition(condition)
+        self._condition = validate_condition(condition)
 
     @property
     def params(self):
         return self._params
 
+    @property
+    def condition(self):
+        return self._condition
+
+    @condition.setter
+    def condition(self, value):
+        self._condition = value
+
     @params.setter
     def params(self, parameters):
         # pylint: disable=cyclic-import
@@ -88,7 +96,7 @@ class WhileLoopOp(ControlFlowOp):
 
     def replace_blocks(self, blocks):
         (body,) = blocks
-        return WhileLoopOp(self.condition, body, label=self.label)
+        return WhileLoopOp(self._condition, body, label=self.label)
 
     def c_if(self, classical, val):
         raise NotImplementedError(

qiskit/circuit/delay.py

@@ -19,6 +19,7 @@ from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.gate import Gate
 from qiskit.circuit import _utils
 from qiskit.circuit.parameterexpression import ParameterExpression
+from qiskit.utils import deprecate_func
 
 
 @_utils.with_gate_array(np.eye(2, dtype=complex))
@@ -33,8 +34,12 @@ class Delay(Instruction):
         """
         if unit not in {"s", "ms", "us", "ns", "ps", "dt"}:
             raise CircuitError(f"Unknown unit {unit} is specified.")
-
-        super().__init__("delay", 1, 0, params=[duration], unit=unit)
+        # Double underscore to differentiate from the private attribute in
+        # `Instruction`. This can be changed to `_unit` in 2.0 after we
+        # remove `unit` and `duration` from the standard instruction model
+        # as it only will exist in `Delay` after that point.
+        self.__unit = unit
+        super().__init__("delay", 1, 0, params=[duration])
 
     broadcast_arguments = Gate.broadcast_arguments
 
@@ -42,9 +47,21 @@ class Delay(Instruction):
         """Special case. Return self."""
         return self
 
+    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
     def c_if(self, classical, val):
         raise CircuitError("Conditional Delay is not yet implemented.")
 
+    @property
+    def unit(self):
+
+        return self.__unit
+
+    @unit.setter
+    def unit(self, value):
+        if value not in {"s", "ms", "us", "ns", "ps", "dt"}:
+            raise CircuitError(f"Unknown unit {value} is specified.")
+        self.__unit = value
+
     @property
     def duration(self):
         """Get the duration of this delay."""
@@ -81,7 +98,7 @@ class Delay(Instruction):
                 raise CircuitError(
                     f"Duration for Delay instruction must be positive. Found {parameter}"
                 )
-            if self.unit == "dt":
+            if self.__unit == "dt":
                 parameter_int = int(parameter)
                 if parameter != parameter_int:
                     raise CircuitError("Integer duration is expected for 'dt' unit.")

qiskit/circuit/equivalence.py

@@ -12,190 +12,24 @@
 
 """Gate equivalence library."""
 
-import copy
-from collections import namedtuple
-
 from rustworkx.visualization import graphviz_draw
 import rustworkx as rx
 
-from qiskit.exceptions import InvalidFileError
-from .exceptions import CircuitError
-from .parameter import Parameter
-from .parameterexpression import ParameterExpression
 
-Key = namedtuple("Key", ["name", "num_qubits"])
-Equivalence = namedtuple("Equivalence", ["params", "circuit"])  # Ordered to match Gate.params
-NodeData = namedtuple("NodeData", ["key", "equivs"])
-EdgeData = namedtuple("EdgeData", ["index", "num_gates", "rule", "source"])
+from qiskit.exceptions import InvalidFileError
+from qiskit._accelerate.equivalence import (  # pylint: disable=unused-import
+    BaseEquivalenceLibrary,
+    Key,
+    Equivalence,
+    NodeData,
+    EdgeData,
+)
 
 
-class EquivalenceLibrary:
+class EquivalenceLibrary(BaseEquivalenceLibrary):
     """A library providing a one-way mapping of Gates to their equivalent
     implementations as QuantumCircuits."""
 
-    def __init__(self, *, base=None):
-        """Create a new equivalence library.
-
-        Args:
-            base (Optional[EquivalenceLibrary]):  Base equivalence library to
-                be referenced if an entry is not found in this library.
-        """
-        self._base = base
-
-        if base is None:
-            self._graph = rx.PyDiGraph()
-            self._key_to_node_index = {}
-            # Some unique identifier for rules.
-            self._rule_id = 0
-        else:
-            self._graph = base._graph.copy()
-            self._key_to_node_index = copy.deepcopy(base._key_to_node_index)
-            self._rule_id = base._rule_id
-
-    @property
-    def graph(self) -> rx.PyDiGraph:
-        """Return graph representing the equivalence library data.
-
-        This property should be treated as read-only as it provides
-        a reference to the internal state of the :class:`~.EquivalenceLibrary` object.
-        If the graph returned by this property is mutated it could corrupt the
-        the contents of the object. If you need to modify the output ``PyDiGraph``
-        be sure to make a copy prior to any modification.
-
-        Returns:
-            PyDiGraph: A graph object with equivalence data in each node.
-        """
-        return self._graph
-
-    def _set_default_node(self, key):
-        """Create a new node if key not found"""
-        if key not in self._key_to_node_index:
-            self._key_to_node_index[key] = self._graph.add_node(NodeData(key=key, equivs=[]))
-        return self._key_to_node_index[key]
-
-    def add_equivalence(self, gate, equivalent_circuit):
-        """Add a new equivalence to the library. Future queries for the Gate
-        will include the given circuit, in addition to all existing equivalences
-        (including those from base).
-
-        Parameterized Gates (those including `qiskit.circuit.Parameters` in their
-        `Gate.params`) can be marked equivalent to parameterized circuits,
-        provided the parameters match.
-
-        Args:
-            gate (Gate): A Gate instance.
-            equivalent_circuit (QuantumCircuit): A circuit equivalently
-                implementing the given Gate.
-        """
-
-        _raise_if_shape_mismatch(gate, equivalent_circuit)
-        _raise_if_param_mismatch(gate.params, equivalent_circuit.parameters)
-
-        key = Key(name=gate.name, num_qubits=gate.num_qubits)
-        equiv = Equivalence(params=gate.params.copy(), circuit=equivalent_circuit.copy())
-
-        target = self._set_default_node(key)
-        self._graph[target].equivs.append(equiv)
-
-        sources = {
-            Key(name=instruction.operation.name, num_qubits=len(instruction.qubits))
-            for instruction in equivalent_circuit
-        }
-        edges = [
-            (
-                self._set_default_node(source),
-                target,
-                EdgeData(index=self._rule_id, num_gates=len(sources), rule=equiv, source=source),
-            )
-            for source in sources
-        ]
-        self._graph.add_edges_from(edges)
-        self._rule_id += 1
-
-    def has_entry(self, gate):
-        """Check if a library contains any decompositions for gate.
-
-        Args:
-            gate (Gate): A Gate instance.
-
-        Returns:
-            Bool: True if gate has a known decomposition in the library.
-                False otherwise.
-        """
-        key = Key(name=gate.name, num_qubits=gate.num_qubits)
-
-        return key in self._key_to_node_index
-
-    def set_entry(self, gate, entry):
-        """Set the equivalence record for a Gate. Future queries for the Gate
-        will return only the circuits provided.
-
-        Parameterized Gates (those including `qiskit.circuit.Parameters` in their
-        `Gate.params`) can be marked equivalent to parameterized circuits,
-        provided the parameters match.
-
-        Args:
-            gate (Gate): A Gate instance.
-            entry (List['QuantumCircuit']) : A list of QuantumCircuits, each
-                equivalently implementing the given Gate.
-        """
-        for equiv in entry:
-            _raise_if_shape_mismatch(gate, equiv)
-            _raise_if_param_mismatch(gate.params, equiv.parameters)
-
-        node_index = self._set_default_node(Key(name=gate.name, num_qubits=gate.num_qubits))
-        # Remove previous equivalences of this node, leaving in place any later equivalences that
-        # were added that use `gate`.
-        self._graph[node_index].equivs.clear()
-        for parent, child, _ in self._graph.in_edges(node_index):
-            # `child` should always be ourselves, but there might be parallel edges.
-            self._graph.remove_edge(parent, child)
-        for equivalence in entry:
-            self.add_equivalence(gate, equivalence)
-
-    def get_entry(self, gate):
-        """Gets the set of QuantumCircuits circuits from the library which
-        equivalently implement the given Gate.
-
-        Parameterized circuits will have their parameters replaced with the
-        corresponding entries from Gate.params.
-
-        Args:
-            gate (Gate) - Gate: A Gate instance.
-
-        Returns:
-            List[QuantumCircuit]: A list of equivalent QuantumCircuits. If empty,
-                library contains no known decompositions of Gate.
-
-                Returned circuits will be ordered according to their insertion in
-                the library, from earliest to latest, from top to base. The
-                ordering of the StandardEquivalenceLibrary will not generally be
-                consistent across Qiskit versions.
-        """
-        key = Key(name=gate.name, num_qubits=gate.num_qubits)
-        query_params = gate.params
-
-        return [_rebind_equiv(equiv, query_params) for equiv in self._get_equivalences(key)]
-
-    def keys(self):
-        """Return list of keys to key to node index map.
-
-        Returns:
-            List: Keys to the key to node index map.
-        """
-        return self._key_to_node_index.keys()
-
-    def node_index(self, key):
-        """Return node index for a given key.
-
-        Args:
-            key (Key): Key to an equivalence.
-
-        Returns:
-            Int: Index to the node in the graph for the given key.
-        """
-        return self._key_to_node_index[key]
-
     def draw(self, filename=None):
         """Draws the equivalence relations available in the library.
 
@@ -227,12 +61,13 @@ class EquivalenceLibrary:
         graph = rx.PyDiGraph()
 
         node_map = {}
-        for key in self._key_to_node_index:
-            name, num_qubits = key
+        for key in super().keys():
+            name, num_qubits = key.name, key.num_qubits
             equivalences = self._get_equivalences(key)
 
             basis = frozenset([f"{name}/{num_qubits}"])
-            for params, decomp in equivalences:
+            for equivalence in equivalences:
+                params, decomp = equivalence.params, equivalence.circuit
                 decomp_basis = frozenset(
                     f"{name}/{num_qubits}"
                     for name, num_qubits in {
@@ -257,39 +92,3 @@ class EquivalenceLibrary:
                 )
 
         return graph
-
-    def _get_equivalences(self, key):
-        """Get all the equivalences for the given key"""
-        return (
-            self._graph[self._key_to_node_index[key]].equivs
-            if key in self._key_to_node_index
-            else []
-        )
-
-
-def _raise_if_param_mismatch(gate_params, circuit_parameters):
-    gate_parameters = [p for p in gate_params if isinstance(p, ParameterExpression)]
-
-    if set(gate_parameters) != circuit_parameters:
-        raise CircuitError(
-            "Cannot add equivalence between circuit and gate "
-            f"of different parameters. Gate params: {gate_parameters}. "
-            f"Circuit params: {circuit_parameters}."
-        )
-
-
-def _raise_if_shape_mismatch(gate, circuit):
-    if gate.num_qubits != circuit.num_qubits or gate.num_clbits != circuit.num_clbits:
-        raise CircuitError(
-            "Cannot add equivalence between circuit and gate "
-            f"of different shapes. Gate: {gate.num_qubits} qubits and {gate.num_clbits} clbits. "
-            f"Circuit: {circuit.num_qubits} qubits and {circuit.num_clbits} clbits."
-        )
-
-
-def _rebind_equiv(equiv, query_params):
-    equiv_params, equiv_circuit = equiv
-    param_map = {x: y for x, y in zip(equiv_params, query_params) if isinstance(x, Parameter)}
-    equiv = equiv_circuit.assign_parameters(param_map, inplace=False, flat_input=True)
-
-    return equiv

qiskit/circuit/gate.py

@@ -89,7 +89,9 @@ class Gate(Instruction):
         from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
 
         if not annotated:
-            return UnitaryGate(Operator(self).power(exponent), label=f"{self.name}^{exponent}")
+            return UnitaryGate(
+                Operator(self).power(exponent, assume_unitary=True), label=f"{self.name}^{exponent}"
+            )
         else:
             return AnnotatedOperation(self, PowerModifier(exponent))
 

qiskit/circuit/instruction.py

@@ -103,7 +103,23 @@ class Instruction(Operation):
         # list of instructions (and their contexts) that this instruction is composed of
         # empty definition means opaque or fundamental instruction
         self._definition = None
+        if duration is not None:
+            warnings.warn(
+                "Setting a custom duration per instruction is deprecated as of Qiskit "
+                "1.3.0. It will be removed in Qiskit 2.0.0. An instruction's duration "
+                "is defined in a backend's Target object.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         self._duration = duration
+        if unit is not None and unit != "dt":
+            warnings.warn(
+                "Setting a custom unit for duration per instruction is deprecated as of Qiskit "
+                "1.3.0. It will be removed in Qiskit 2.0.0. An instruction's duration "
+                "is defined in a backend's Target object which has a fixed unit in seconds.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         self._unit = unit
 
         self.params = params  # must be at last (other properties may be required for validation)
@@ -160,6 +176,7 @@ class Instruction(Operation):
         return self.copy()
 
     @property
+    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0", is_property=True)
     def condition(self):
         """The classical condition on the instruction."""
         return self._condition
@@ -341,24 +358,26 @@ class Instruction(Operation):
         sel.add_equivalence(self, decomposition)
 
     @property
+    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0", is_property=True)
     def duration(self):
         """Get the duration."""
         return self._duration
 
     @duration.setter
-    def duration(self, duration):
+    def duration(self, value):
         """Set the duration."""
-        self._duration = duration
+        self._duration = value
 
     @property
+    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0", is_property=True)
     def unit(self):
         """Get the time unit of duration."""
         return self._unit
 
     @unit.setter
-    def unit(self, unit):
+    def unit(self, value):
         """Set the time unit of duration."""
-        self._unit = unit
+        self._unit = value
 
     @deprecate_func(
         since="1.2",
@@ -392,8 +411,8 @@ class Instruction(Operation):
         # Add condition parameters for assembler. This is needed to convert
         # to a qobj conditional instruction at assemble time and after
         # conversion will be deleted by the assembler.
-        if self.condition:
-            instruction._condition = self.condition
+        if self._condition:
+            instruction._condition = self._condition
         return instruction
 
     @property
@@ -499,6 +518,7 @@ class Instruction(Operation):
         inverse_gate.definition = inverse_definition
         return inverse_gate
 
+    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
     def c_if(self, classical, val):
         """Set a classical equality condition on this instruction between the register or cbit
         ``classical`` and value ``val``.
@@ -614,7 +634,7 @@ class Instruction(Operation):
             qargs = tuple(qc.qubits)
             cargs = tuple(qc.clbits)
             base = self.copy()
-            if self.condition:
+            if self._condition:
                 # Condition is handled on the outer instruction.
                 base = base.to_mutable()
                 base.condition = None
@@ -622,18 +642,19 @@ class Instruction(Operation):
                 qc._append(CircuitInstruction(base, qargs, cargs))
 
             instruction.definition = qc
-        if self.condition:
-            instruction = instruction.c_if(*self.condition)
+        if self._condition:
+            instruction = instruction.c_if(*self._condition)
         return instruction
 
     @property
+    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0", is_property=True)
     def condition_bits(self) -> List[Clbit]:
         """Get Clbits in condition."""
         from qiskit.circuit.controlflow import condition_resources  # pylint: disable=cyclic-import
 
-        if self.condition is None:
+        if self._condition is None:
             return []
-        return list(condition_resources(self.condition).clbits)
+        return list(condition_resources(self._condition).clbits)
 
     @property
     def name(self):

qiskit/circuit/instructionset.py

@@ -20,6 +20,7 @@ from collections.abc import MutableSequence
 from typing import Callable
 
 from qiskit.circuit.exceptions import CircuitError
+from qiskit.utils import deprecate_func
 from .classicalregister import Clbit, ClassicalRegister
 from .operation import Operation
 from .quantumcircuitdata import CircuitInstruction
@@ -105,6 +106,7 @@ class InstructionSet:
                 )
         return self
 
+    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
     def c_if(self, classical: Clbit | ClassicalRegister | int, val: int) -> "InstructionSet":
         """Set a classical equality condition on all the instructions in this set between the
         :obj:`.ClassicalRegister` or :obj:`.Clbit` ``classical`` and value ``val``.