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

qiskit/circuit/barrier.py

@@ -19,7 +19,6 @@ 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
 
 
@@ -45,6 +44,5 @@ 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,20 +87,12 @@ 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
@@ -160,7 +152,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(
@@ -208,7 +200,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,
@@ -233,7 +225,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."""
@@ -296,7 +288,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,20 +53,12 @@ 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
@@ -96,7 +88,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,7 +19,6 @@ 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))
@@ -34,12 +33,8 @@ class Delay(Instruction):
         """
         if unit not in {"s", "ms", "us", "ns", "ps", "dt"}:
             raise CircuitError(f"Unknown unit {unit} is specified.")
-        # 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])
+
+        super().__init__("delay", 1, 0, params=[duration], unit=unit)
 
     broadcast_arguments = Gate.broadcast_arguments
 
@@ -47,21 +42,9 @@ 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."""
@@ -98,7 +81,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,24 +12,190 @@
 
 """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 qiskit._accelerate.equivalence import (  # pylint: disable=unused-import
-    BaseEquivalenceLibrary,
-    Key,
-    Equivalence,
-    NodeData,
-    EdgeData,
-)
+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"])
 
 
-class EquivalenceLibrary(BaseEquivalenceLibrary):
+class EquivalenceLibrary:
     """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.
 
@@ -61,13 +227,12 @@ class EquivalenceLibrary(BaseEquivalenceLibrary):
         graph = rx.PyDiGraph()
 
         node_map = {}
-        for key in super().keys():
-            name, num_qubits = key.name, key.num_qubits
+        for key in self._key_to_node_index:
+            name, num_qubits = key
             equivalences = self._get_equivalences(key)
 
             basis = frozenset([f"{name}/{num_qubits}"])
-            for equivalence in equivalences:
-                params, decomp = equivalence.params, equivalence.circuit
+            for params, decomp in equivalences:
                 decomp_basis = frozenset(
                     f"{name}/{num_qubits}"
                     for name, num_qubits in {
@@ -92,3 +257,39 @@ class EquivalenceLibrary(BaseEquivalenceLibrary):
                 )
 
         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,9 +89,7 @@ class Gate(Instruction):
         from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
 
         if not annotated:
-            return UnitaryGate(
-                Operator(self).power(exponent, assume_unitary=True), label=f"{self.name}^{exponent}"
-            )
+            return UnitaryGate(Operator(self).power(exponent), label=f"{self.name}^{exponent}")
         else:
             return AnnotatedOperation(self, PowerModifier(exponent))
 

qiskit/circuit/instruction.py

@@ -103,23 +103,7 @@ 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)
@@ -176,7 +160,6 @@ 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
@@ -358,26 +341,24 @@ 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, value):
+    def duration(self, duration):
         """Set the duration."""
-        self._duration = value
+        self._duration = duration
 
     @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, value):
+    def unit(self, unit):
         """Set the time unit of duration."""
-        self._unit = value
+        self._unit = unit
 
     @deprecate_func(
         since="1.2",
@@ -411,8 +392,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
@@ -518,7 +499,6 @@ 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``.
@@ -634,7 +614,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
@@ -642,19 +622,18 @@ 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,7 +20,6 @@ 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
@@ -106,7 +105,6 @@ 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``.