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

qiskit/circuit/library/generalized_gates/mcmt.py

@@ -14,14 +14,14 @@
 
 from __future__ import annotations
 
-import warnings
 from collections.abc import Callable
 
 from qiskit import circuit
-from qiskit.circuit import ControlledGate, Gate, QuantumCircuit
-from qiskit.circuit._utils import _ctrl_state_to_int
-from qiskit.utils.deprecation import deprecate_func
-from ..standard_gates import get_standard_gate_name_mapping
+from qiskit.circuit import ControlledGate, Gate, QuantumRegister, QuantumCircuit
+from qiskit.exceptions import QiskitError
+
+# pylint: disable=cyclic-import
+from ..standard_gates import XGate, YGate, ZGate, HGate, TGate, TdgGate, SGate, SdgGate
 
 
 class MCMT(QuantumCircuit):
@@ -29,7 +29,7 @@ class MCMT(QuantumCircuit):
 
     For example, the H gate controlled on 3 qubits and acting on 2 target qubit is represented as:
 
-    .. code-block:: text
+    .. parsed-literal::
 
         ───■────
            │
@@ -49,7 +49,6 @@ class MCMT(QuantumCircuit):
     :class:`~qiskit.circuit.library.MCMTVChain`.
     """
 
-    @deprecate_func(since="1.3", additional_msg="Use MCMTGate instead.", pending=True)
     def __init__(
         self,
         gate: Gate | Callable[[QuantumCircuit, circuit.Qubit, circuit.Qubit], circuit.Instruction],
@@ -72,41 +71,77 @@ class MCMT(QuantumCircuit):
         if num_ctrl_qubits == 0 or num_target_qubits == 0:
             raise AttributeError("Need at least one control and one target qubit.")
 
-        if callable(gate):
-            warnings.warn(
-                "Passing a callable to MCMT is pending deprecation since Qiskit 1.3. Pass a "
-                "gate instance or the gate name instead, e.g. pass 'h' instead of QuantumCircuit.h.",
-                category=PendingDeprecationWarning,
-                stacklevel=2,
-            )
-            gate = gate.__name__
-        elif isinstance(gate, QuantumCircuit):
-            warnings.warn(
-                "Passing a QuantumCircuit is pending deprecation since Qiskit 1.3. Pass a gate "
-                "or turn the circuit into a gate using the ``to_gate`` method, instead.",
-                category=PendingDeprecationWarning,
-                stacklevel=2,
-            )
-            gate = gate.to_gate()
-
-        self.gate = MCMTGate._identify_base_gate(gate)
+        # set the internal properties and determine the number of qubits
+        self.gate = self._identify_gate(gate)
         self.num_ctrl_qubits = num_ctrl_qubits
         self.num_target_qubits = num_target_qubits
+        num_qubits = num_ctrl_qubits + num_target_qubits + self.num_ancilla_qubits
 
         # initialize the circuit object
-        num_qubits = num_ctrl_qubits + num_target_qubits + self.num_ancilla_qubits
         super().__init__(num_qubits, name="mcmt")
+        self._label = f"{num_target_qubits}-{self.gate.name.capitalize()}"
+
+        # build the circuit
         self._build()
 
     def _build(self):
-        gate = MCMTGate(self.gate, self.num_ctrl_qubits, self.num_target_qubits)
-        self.append(gate, self.qubits)
+        """Define the MCMT gate without ancillas."""
+        if self.num_target_qubits == 1:
+            # no broadcasting needed (makes for better circuit diagrams)
+            broadcasted_gate = self.gate
+        else:
+            broadcasted = QuantumCircuit(self.num_target_qubits, name=self._label)
+            for target in list(range(self.num_target_qubits)):
+                broadcasted.append(self.gate, [target], [])
+            broadcasted_gate = broadcasted.to_gate()
+
+        mcmt_gate = broadcasted_gate.control(self.num_ctrl_qubits)
+        self.append(mcmt_gate, self.qubits, [])
 
     @property
     def num_ancilla_qubits(self):
         """Return the number of ancillas."""
         return 0
 
+    def _identify_gate(self, gate):
+        """Case the gate input to a gate."""
+        valid_gates = {
+            "ch": HGate(),
+            "cx": XGate(),
+            "cy": YGate(),
+            "cz": ZGate(),
+            "h": HGate(),
+            "s": SGate(),
+            "sdg": SdgGate(),
+            "x": XGate(),
+            "y": YGate(),
+            "z": ZGate(),
+            "t": TGate(),
+            "tdg": TdgGate(),
+        }
+        if isinstance(gate, ControlledGate):
+            base_gate = gate.base_gate
+        elif isinstance(gate, Gate):
+            if gate.num_qubits != 1:
+                raise AttributeError("Base gate must act on one qubit only.")
+            base_gate = gate
+        elif isinstance(gate, QuantumCircuit):
+            if gate.num_qubits != 1:
+                raise AttributeError(
+                    "The circuit you specified as control gate can only have one qubit!"
+                )
+            base_gate = gate.to_gate()  # raises error if circuit contains non-unitary instructions
+        else:
+            if callable(gate):  # identify via name of the passed function
+                name = gate.__name__
+            elif isinstance(gate, str):
+                name = gate
+            else:
+                raise AttributeError(f"Invalid gate specified: {gate}")
+            base_gate = valid_gates[name]
+
+        return base_gate
+
     def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None, annotated=False):
         """Return the controlled version of the MCMT circuit."""
         if not annotated and ctrl_state is None:
@@ -156,161 +191,66 @@ class MCMTVChain(MCMT):
                   └───┘          └───┘
     """
 
-    @deprecate_func(
-        since="1.3",
-        additional_msg="Use MCMTGate with the V-chain synthesis plugin instead.",
-        pending=True,
-    )
-    def __init__(
-        self,
-        gate: Gate | Callable[[QuantumCircuit, circuit.Qubit, circuit.Qubit], circuit.Instruction],
-        num_ctrl_qubits: int,
-        num_target_qubits: int,
-    ) -> None:
-        super().__init__(gate, num_ctrl_qubits, num_target_qubits)
-
     def _build(self):
-        # pylint: disable=cyclic-import
-        from qiskit.synthesis.multi_controlled import synth_mcmt_vchain
+        """Define the MCMT gate."""
+        control_qubits = self.qubits[: self.num_ctrl_qubits]
+        target_qubits = self.qubits[
+            self.num_ctrl_qubits : self.num_ctrl_qubits + self.num_target_qubits
+        ]
+        ancilla_qubits = self.qubits[self.num_ctrl_qubits + self.num_target_qubits :]
+
+        if len(ancilla_qubits) > 0:
+            master_control = ancilla_qubits[-1]
+        else:
+            master_control = control_qubits[0]
 
-        synthesized = synth_mcmt_vchain(self.gate, self.num_ctrl_qubits, self.num_target_qubits)
-        self.compose(synthesized, inplace=True, copy=False)
+        self._ccx_v_chain_rule(control_qubits, ancilla_qubits, reverse=False)
+        for qubit in target_qubits:
+            self.append(self.gate.control(), [master_control, qubit], [])
+        self._ccx_v_chain_rule(control_qubits, ancilla_qubits, reverse=True)
 
     @property
     def num_ancilla_qubits(self):
         """Return the number of ancilla qubits required."""
         return max(0, self.num_ctrl_qubits - 1)
 
-    def inverse(self, annotated: bool = False):
-        return MCMTVChain(self.gate, self.num_ctrl_qubits, self.num_target_qubits)
-
-
-class MCMTGate(ControlledGate):
-    """The multi-controlled multi-target gate, for an arbitrary singly controlled target gate.
-
-    For example, the H gate controlled on 3 qubits and acting on 2 target qubit is represented as:
-
-    .. parsed-literal::
-
-        ───■────
-           │
-        ───■────
-           │
-        ───■────
-        ┌──┴───┐
-        ┤0     ├
-        │  2-H │
-        ┤1     ├
-        └──────┘
-
-    Depending on the number of available auxiliary qubits, this operation can be synthesized
-    using different methods. For example, if :math:`n - 1` clean auxiliary qubits are available
-    (where :math:`n` is the number of control qubits), a V-chain decomposition can be used whose
-    depth is linear in :math:`n`. See also :func:`.synth_mcmt_chain`.
-    """
-
-    def __init__(
+    def _ccx_v_chain_rule(
         self,
-        gate: Gate,
-        num_ctrl_qubits: int,
-        num_target_qubits: int,
-        ctrl_state: int | str | None = None,
-        label: str | None = None,
+        control_qubits: QuantumRegister | list[circuit.Qubit],
+        ancilla_qubits: QuantumRegister | list[circuit.Qubit],
+        reverse: bool = False,
     ) -> None:
-        """
-        Args:
-            gate: The base gate to apply on multiple target qubits, controlled by other qubits.
-                This must be a single-qubit gate or a controlled single-qubit gate.
-            num_ctrl_qubits: The number of control qubits.
-            num_target_qubits: The number of target qubits.
-            ctrl_state: The control state of the control qubits. Defaults to all closed controls.
-            label: The gate label.
-        """
-        if num_target_qubits < 1:
-            raise ValueError("Need at least one target qubit.")
+        """Get the rule for the CCX V-chain.
 
-        if num_ctrl_qubits < 1:
-            raise ValueError("Need at least one control qubit.")
+        The CCX V-chain progressively computes the CCX of the control qubits and puts the final
+        result in the last ancillary qubit.
 
-        self.num_target_qubits = num_target_qubits
-
-        base_gate = self._identify_base_gate(gate)
-        num_qubits = num_ctrl_qubits + num_target_qubits
-
-        if label is None:
-            label = f"{num_target_qubits}-{gate.name.capitalize()}"
-
-        super().__init__(
-            "mcmt",
-            base_gate=base_gate,
-            num_qubits=num_qubits,
-            params=gate.params,
-            num_ctrl_qubits=num_ctrl_qubits,
-            ctrl_state=ctrl_state,
-            label=label,
-        )
-
-    def _define(self):
-        """Default definition relying on gate.control. Control state is handled by superclass."""
-        # pylint: disable=cyclic-import
-        from qiskit.transpiler.passes.synthesis.hls_plugins import MCMTSynthesisDefault
-
-        self.definition = MCMTSynthesisDefault().run(self)
-
-    @staticmethod
-    def _identify_base_gate(gate):
-        """Get the control base gate. Note this must be a single qubit gate."""
-
-        # try getting the standard name from the string
-        if isinstance(gate, str):
-            standard_gates = get_standard_gate_name_mapping()
-            if gate in standard_gates:
-                gate = standard_gates[gate]
-            else:
-                raise AttributeError(
-                    f"Unknown gate {gate}. Available: {list(get_standard_gate_name_mapping.keys())}"
-                )
+        Args:
+            control_qubits: The control qubits.
+            ancilla_qubits: The ancilla qubits.
+            reverse: If True, compute the chain down to the qubit. If False, compute upwards.
 
-        # extract the base gate
-        if isinstance(gate, ControlledGate):
-            warnings.warn(
-                "Passing a controlled gate to MCMT is pending deprecation since Qiskit 1.3. Pass a "
-                "single-qubit gate instance or the gate name instead, e.g. pass 'h' instead of 'ch'.",
-                category=PendingDeprecationWarning,
-                stacklevel=2,
-            )
-            base_gate = gate.base_gate
-        elif isinstance(gate, Gate):
-            base_gate = gate
-        else:
-            raise TypeError(f"Invalid gate type {type(gate)}.")
+        Returns:
+            The rule for the (reversed) CCX V-chain.
 
-        if base_gate.num_qubits != 1:
-            raise ValueError(
-                f"MCMTGate requires a base gate with a single qubit, but got {base_gate.num_qubits}."
-            )
+        Raises:
+            QiskitError: If an insufficient number of ancilla qubits was provided.
+        """
+        if len(ancilla_qubits) == 0:
+            return
 
-        return base_gate
+        if len(ancilla_qubits) < len(control_qubits) - 1:
+            raise QiskitError("Insufficient number of ancilla qubits.")
 
-    def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None, annotated=False):
-        """Return the controlled version of the MCMT circuit."""
-        if not annotated:
-            ctrl_state = _ctrl_state_to_int(ctrl_state, num_ctrl_qubits)
-            new_ctrl_state = (self.ctrl_state << num_ctrl_qubits) | ctrl_state
-
-            gate = MCMTGate(
-                self.base_gate,
-                self.num_ctrl_qubits + num_ctrl_qubits,
-                self.num_target_qubits,
-                ctrl_state=new_ctrl_state,
-            )
+        iterations = list(enumerate(range(2, len(control_qubits))))
+        if not reverse:
+            self.ccx(control_qubits[0], control_qubits[1], ancilla_qubits[0])
+            for i, j in iterations:
+                self.ccx(control_qubits[j], ancilla_qubits[i], ancilla_qubits[i + 1])
         else:
-            gate = super().control(num_ctrl_qubits, label, ctrl_state, annotated=annotated)
-
-        return gate
+            for i, j in reversed(iterations):
+                self.ccx(control_qubits[j], ancilla_qubits[i], ancilla_qubits[i + 1])
+            self.ccx(control_qubits[0], control_qubits[1], ancilla_qubits[0])
 
     def inverse(self, annotated: bool = False):
-        """Return the inverse MCMT circuit."""
-        return MCMTGate(
-            self.base_gate.inverse(), self.num_ctrl_qubits, self.num_target_qubits, self.ctrl_state
-        )
+        return MCMTVChain(self.gate, self.num_ctrl_qubits, self.num_target_qubits)

qiskit/circuit/library/generalized_gates/permutation.py

@@ -22,13 +22,11 @@ import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumcircuit import Gate
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.utils.deprecation import deprecate_func
 
 
 class Permutation(QuantumCircuit):
     """An n_qubit circuit that permutes qubits."""
 
-    @deprecate_func(since="1.3", pending=True, additional_msg="Use PermutationGate instead.")
     def __init__(
         self,
         num_qubits: int,
@@ -119,11 +117,11 @@ class PermutationGate(Gate):
 
                 from qiskit.circuit.quantumcircuit import QuantumCircuit
                 from qiskit.circuit.library import PermutationGate
-                A = [2, 4, 3, 0, 1]
+                A = [2,4,3,0,1]
                 permutation = PermutationGate(A)
                 circuit = QuantumCircuit(5)
                 circuit.append(permutation, [0, 1, 2, 3, 4])
-                circuit.draw("mpl")
+                circuit.draw('mpl')
 
         Expanded Circuit:
             .. plot::
@@ -131,7 +129,7 @@ class PermutationGate(Gate):
                 from qiskit.circuit.quantumcircuit import QuantumCircuit
                 from qiskit.circuit.library import PermutationGate
                 from qiskit.visualization.library import _generate_circuit_library_visualization
-                A = [2, 4, 3, 0, 1]
+                A = [2,4,3,0,1]
                 permutation = PermutationGate(A)
                 circuit = QuantumCircuit(5)
                 circuit.append(permutation, [0, 1, 2, 3, 4])
@@ -143,7 +141,7 @@ class PermutationGate(Gate):
             raise CircuitError(
                 "Permutation pattern must be some ordering of 0..num_qubits-1 in a list."
             )
-        pattern = np.array(pattern, dtype=np.int32)
+        pattern = np.array(pattern)
 
         super().__init__(name="permutation", num_qubits=num_qubits, params=[pattern])
 
@@ -170,11 +168,11 @@ class PermutationGate(Gate):
         return parameter
 
     @property
-    def pattern(self) -> np.ndarray[bool]:
+    def pattern(self):
         """Returns the permutation pattern defining this permutation."""
         return self.params[0]
 
-    def inverse(self, annotated: bool = False) -> PermutationGate:
+    def inverse(self, annotated: bool = False):
         """Returns the inverse of the permutation."""
 
         # pylint: disable=cyclic-import

qiskit/circuit/library/generalized_gates/rv.py

@@ -27,7 +27,7 @@ class RVGate(Gate):
 
     **Circuit symbol:**
 
-    .. code-block:: text
+    .. parsed-literal::
 
              ┌─────────────────┐
         q_0: ┤ RV(v_x,v_y,v_z) ├
@@ -51,13 +51,14 @@ class RVGate(Gate):
                 \end{pmatrix}
     """
 
-    def __init__(self, v_x: float, v_y: float, v_z: float, basis: str = "U"):
-        """
+    def __init__(self, v_x, v_y, v_z, basis="U"):
+        """Create new rv single-qubit gate.
+
         Args:
-            v_x: x-component
-            v_y: y-component
-            v_z: z-component
-            basis: basis (see
+            v_x (float): x-component
+            v_y (float): y-component
+            v_z (float): z-component
+            basis (str, optional): basis (see
                 :class:`~qiskit.synthesis.one_qubit.one_qubit_decompose.OneQubitEulerDecomposer`)
         """
         # pylint: disable=cyclic-import
@@ -79,7 +80,7 @@ class RVGate(Gate):
         vx, vy, vz = self.params
         return RVGate(-vx, -vy, -vz)
 
-    def to_matrix(self) -> numpy.ndarray:
+    def to_matrix(self):
         """Return a numpy.array for the R(v) gate."""
         v = numpy.asarray(self.params, dtype=float)
         angle = math.sqrt(v.dot(v))

qiskit/circuit/library/graph_state.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2017, 2024.
+# (C) Copyright IBM 2017, 2020.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -10,14 +10,13 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Graph State circuit and gate."""
+"""Graph State circuit."""
 
 from __future__ import annotations
 
 import numpy as np
-from qiskit.circuit.quantumcircuit import QuantumCircuit, Gate
+from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.utils.deprecation import deprecate_func
 
 
 class GraphState(QuantumCircuit):
@@ -57,11 +56,6 @@ class GraphState(QuantumCircuit):
         `arXiv:1512.07892 <https://arxiv.org/pdf/1512.07892.pdf>`_
     """
 
-    @deprecate_func(
-        since="1.3",
-        additional_msg="Use qiskit.circuit.library.GraphStateGate instead.",
-        pending=True,
-    )
     def __init__(self, adjacency_matrix: list | np.ndarray) -> None:
         """Create graph state preparation circuit.
 
@@ -79,91 +73,14 @@ class GraphState(QuantumCircuit):
         if not np.allclose(adjacency_matrix, adjacency_matrix.transpose()):
             raise CircuitError("The adjacency matrix must be symmetric.")
 
-        graph_state_gate = GraphStateGate(adjacency_matrix)
-        super().__init__(graph_state_gate.num_qubits, name=f"graph: {adjacency_matrix}")
-        self.compose(graph_state_gate, qubits=self.qubits, inplace=True)
-
-
-class GraphStateGate(Gate):
-    r"""A gate representing a graph state.
-
-    Given a graph G = (V, E), with the set of vertices V and the set of edges E,
-    the corresponding graph state is defined as
-
-    .. math::
-
-        |G\rangle = \prod_{(a,b) \in E} CZ_{(a,b)} {|+\rangle}^{\otimes V}
-
-    Such a state can be prepared by first preparing all qubits in the :math:`+`
-    state, then applying a :math:`CZ` gate for each corresponding graph edge.
-
-    Graph state preparation circuits are Clifford circuits, and thus
-    easy to simulate classically. However, by adding a layer of measurements
-    in a product basis at the end, there is evidence that the circuit becomes
-    hard to simulate [2].
-
-    **Reference Circuit:**
-
-    .. plot::
-        :include-source:
-
-        from qiskit.circuit import QuantumCircuit
-        from qiskit.circuit.library import GraphStateGate
-        import rustworkx as rx
-
-        G = rx.generators.cycle_graph(5)
-        circuit = QuantumCircuit(5)
-        circuit.append(GraphStateGate(rx.adjacency_matrix(G)), [0, 1, 2, 3, 4])
-        circuit.decompose().draw('mpl')
-
-    **References:**
-
-    [1] M. Hein, J. Eisert, H.J. Briegel, Multi-party Entanglement in Graph States,
-        `arXiv:0307130 <https://arxiv.org/pdf/quant-ph/0307130.pdf>`_
-    [2] D. Koh, Further Extensions of Clifford Circuits & their Classical Simulation Complexities.
-        `arXiv:1512.07892 <https://arxiv.org/pdf/1512.07892.pdf>`_
-    """
-
-    def __init__(self, adjacency_matrix: list | np.ndarray) -> None:
-        """
-        Args:
-            adjacency_matrix: input graph as n-by-n list of 0-1 lists
-
-        Raises:
-            CircuitError: If adjacency_matrix is not symmetric.
-
-        The gate represents a graph state with the given adjacency matrix.
-        """
-
-        adjacency_matrix = np.asarray(adjacency_matrix)
-        if not np.allclose(adjacency_matrix, adjacency_matrix.transpose()):
-            raise CircuitError("The adjacency matrix must be symmetric.")
         num_qubits = len(adjacency_matrix)
+        circuit = QuantumCircuit(num_qubits, name=f"graph: {adjacency_matrix}")
 
-        super().__init__(name="graph_state", num_qubits=num_qubits, params=[adjacency_matrix])
-
-    def _define(self):
-        adjacency_matrix = self.adjacency_matrix
-        circuit = QuantumCircuit(self.num_qubits, name=self.name)
-        circuit.h(range(self.num_qubits))
-        for i in range(self.num_qubits):
-            for j in range(i + 1, self.num_qubits):
+        circuit.h(range(num_qubits))
+        for i in range(num_qubits):
+            for j in range(i + 1, num_qubits):
                 if adjacency_matrix[i][j] == 1:
                     circuit.cz(i, j)
-        self.definition = circuit
-
-    def validate_parameter(self, parameter):
-        """Parameter validation"""
-        return parameter
-
-    @property
-    def adjacency_matrix(self):
-        """Returns the adjacency matrix."""
-        return self.params[0]
-
-    def __eq__(self, other):
-        return (
-            isinstance(other, GraphStateGate)
-            and self.num_qubits == other.num_qubits
-            and np.all(self.adjacency_matrix == other.adjacency_matrix)
-        )
+
+        super().__init__(*circuit.qregs, name=circuit.name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)