qiskit 1.3.0b1__cp39-abi3-win32.whl → 1.3.0rc2__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, QuantumRegister, QuantumCircuit
-from qiskit.exceptions import QiskitError
-
-# pylint: disable=cyclic-import
-from ..standard_gates import XGate, YGate, ZGate, HGate, TGate, TdgGate, SGate, SdgGate
+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
 
 
 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:
 
-    .. parsed-literal::
+    .. code-block:: text
 
         ───■────
            │
@@ -49,6 +49,7 @@ 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],
@@ -71,77 +72,41 @@ class MCMT(QuantumCircuit):
         if num_ctrl_qubits == 0 or num_target_qubits == 0:
             raise AttributeError("Need at least one control and one target qubit.")
 
-        # set the internal properties and determine the number of qubits
-        self.gate = self._identify_gate(gate)
+        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)
         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):
-        """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, [])
+        gate = MCMTGate(self.gate, self.num_ctrl_qubits, self.num_target_qubits)
+        self.append(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:
@@ -191,66 +156,161 @@ 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):
-        """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]
+        # pylint: disable=cyclic-import
+        from qiskit.synthesis.multi_controlled import synth_mcmt_vchain
 
-        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)
+        synthesized = synth_mcmt_vchain(self.gate, self.num_ctrl_qubits, self.num_target_qubits)
+        self.compose(synthesized, inplace=True, copy=False)
 
     @property
     def num_ancilla_qubits(self):
         """Return the number of ancilla qubits required."""
         return max(0, self.num_ctrl_qubits - 1)
 
-    def _ccx_v_chain_rule(
+    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__(
         self,
-        control_qubits: QuantumRegister | list[circuit.Qubit],
-        ancilla_qubits: QuantumRegister | list[circuit.Qubit],
-        reverse: bool = False,
+        gate: Gate,
+        num_ctrl_qubits: int,
+        num_target_qubits: int,
+        ctrl_state: int | str | None = None,
+        label: str | None = None,
     ) -> None:
-        """Get the rule for the CCX V-chain.
+        """
+        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.")
 
-        The CCX V-chain progressively computes the CCX of the control qubits and puts the final
-        result in the last ancillary qubit.
+        if num_ctrl_qubits < 1:
+            raise ValueError("Need at least one control qubit.")
 
-        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.
+        self.num_target_qubits = num_target_qubits
 
-        Returns:
-            The rule for the (reversed) CCX V-chain.
+        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())}"
+                )
 
-        Raises:
-            QiskitError: If an insufficient number of ancilla qubits was provided.
-        """
-        if len(ancilla_qubits) == 0:
-            return
+        # 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)}.")
+
+        if base_gate.num_qubits != 1:
+            raise ValueError(
+                f"MCMTGate requires a base gate with a single qubit, but got {base_gate.num_qubits}."
+            )
 
-        if len(ancilla_qubits) < len(control_qubits) - 1:
-            raise QiskitError("Insufficient number of ancilla qubits.")
+        return base_gate
 
-        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])
+    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,
+            )
         else:
-            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])
+            gate = super().control(num_ctrl_qubits, label, ctrl_state, annotated=annotated)
+
+        return gate
 
     def inverse(self, annotated: bool = False):
-        return MCMTVChain(self.gate, self.num_ctrl_qubits, self.num_target_qubits)
+        """Return the inverse MCMT circuit."""
+        return MCMTGate(
+            self.base_gate.inverse(), self.num_ctrl_qubits, self.num_target_qubits, self.ctrl_state
+        )

qiskit/circuit/library/generalized_gates/permutation.py

@@ -22,11 +22,13 @@ 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,
@@ -117,11 +119,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::
@@ -129,7 +131,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])
@@ -141,7 +143,7 @@ class PermutationGate(Gate):
             raise CircuitError(
                 "Permutation pattern must be some ordering of 0..num_qubits-1 in a list."
             )
-        pattern = np.array(pattern)
+        pattern = np.array(pattern, dtype=np.int32)
 
         super().__init__(name="permutation", num_qubits=num_qubits, params=[pattern])
 
@@ -168,11 +170,11 @@ class PermutationGate(Gate):
         return parameter
 
     @property
-    def pattern(self):
+    def pattern(self) -> np.ndarray[bool]:
         """Returns the permutation pattern defining this permutation."""
         return self.params[0]
 
-    def inverse(self, annotated: bool = False):
+    def inverse(self, annotated: bool = False) -> PermutationGate:
         """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:**
 
-    .. parsed-literal::
+    .. code-block:: text
 
              ┌─────────────────┐
         q_0: ┤ RV(v_x,v_y,v_z) ├
@@ -51,14 +51,13 @@ class RVGate(Gate):
                 \end{pmatrix}
     """
 
-    def __init__(self, v_x, v_y, v_z, basis="U"):
-        """Create new rv single-qubit gate.
-
+    def __init__(self, v_x: float, v_y: float, v_z: float, basis: str = "U"):
+        """
         Args:
-            v_x (float): x-component
-            v_y (float): y-component
-            v_z (float): z-component
-            basis (str, optional): basis (see
+            v_x: x-component
+            v_y: y-component
+            v_z: z-component
+            basis: basis (see
                 :class:`~qiskit.synthesis.one_qubit.one_qubit_decompose.OneQubitEulerDecomposer`)
         """
         # pylint: disable=cyclic-import
@@ -80,7 +79,7 @@ class RVGate(Gate):
         vx, vy, vz = self.params
         return RVGate(-vx, -vy, -vz)
 
-    def to_matrix(self):
+    def to_matrix(self) -> numpy.ndarray:
         """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, 2020.
+# (C) Copyright IBM 2017, 2024.
 #
 # 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,13 +10,14 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Graph State circuit."""
+"""Graph State circuit and gate."""
 
 from __future__ import annotations
 
 import numpy as np
-from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumcircuit import QuantumCircuit, Gate
 from qiskit.circuit.exceptions import CircuitError
+from qiskit.utils.deprecation import deprecate_func
 
 
 class GraphState(QuantumCircuit):
@@ -56,6 +57,11 @@ 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.
 
@@ -73,14 +79,91 @@ 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}")
 
-        circuit.h(range(num_qubits))
-        for i in range(num_qubits):
-            for j in range(i + 1, num_qubits):
+        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):
                 if adjacency_matrix[i][j] == 1:
                     circuit.cz(i, j)
-
-        super().__init__(*circuit.qregs, name=circuit.name)
-        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+        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)
+        )