qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/generalized_gates/mcg_up_to_diagonal.py

@@ -0,0 +1,143 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# 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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+# pylint: disable=unused-variable
+
+"""Multi controlled single-qubit unitary up to diagonal."""
+
+# ToDo: This code should be merged wth the implementation of MCGs
+# ToDo: (introducing a decomposition mode "up_to_diagonal").
+
+import numpy as np
+
+from qiskit.circuit import Gate
+from qiskit.circuit.quantumcircuit import QuantumRegister, QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.operators.predicates import is_isometry
+
+from .uc import UCGate
+
+_EPS = 1e-10  # global variable used to chop very small numbers to zero
+
+
+class MCGupDiag(Gate):
+    r"""
+    Decomposes a multi-controlled gate :math:`U` up to a diagonal :math:`D` acting on the control
+    and target qubit (but not on the ancilla qubits), i.e., it implements a circuit corresponding to
+    a unitary :math:`U'`, such that :math:`U = D U'`.
+    """
+
+    def __init__(
+        self, gate: np.ndarray, num_controls: int, num_ancillas_zero: int, num_ancillas_dirty: int
+    ) -> None:
+        r"""
+        Args:
+            gate: :math:`2 \times 2` unitary given as a (complex) ``ndarray``.
+            num_controls: Number of control qubits.
+            num_ancillas_zero: Number of ancilla qubits that start in the state zero.
+            num_ancillas_dirty: Number of ancilla qubits that are allowed to start in an
+                arbitrary state.
+
+        Raises:
+            QiskitError: if the input format is wrong; if the array gate is not unitary
+        """
+
+        self.num_controls = num_controls
+        self.num_ancillas_zero = num_ancillas_zero
+        self.num_ancillas_dirty = num_ancillas_dirty
+        # Check if the gate has the right dimension
+        if not gate.shape == (2, 2):
+            raise QiskitError("The dimension of the controlled gate is not equal to (2,2).")
+        # Check if the single-qubit gate is unitary
+        if not is_isometry(gate, _EPS):
+            raise QiskitError("The controlled gate is not unitary.")
+        # Create new gate.
+        num_qubits = 1 + num_controls + num_ancillas_zero + num_ancillas_dirty
+        super().__init__("MCGupDiag", num_qubits, [gate])
+
+    def _define(self):
+        mcg_up_diag_circuit, _ = self._dec_mcg_up_diag()
+        gate = mcg_up_diag_circuit.to_instruction()
+        q = QuantumRegister(self.num_qubits, "q")
+        mcg_up_diag_circuit = QuantumCircuit(q, name="mcg_up_to_diagonal")
+        mcg_up_diag_circuit.append(gate, q[:])
+        self.definition = mcg_up_diag_circuit
+
+    def inverse(self, annotated: bool = False) -> Gate:
+        """Return the inverse.
+
+        Note that the resulting Gate object has an empty ``params`` property.
+        """
+        if not annotated:
+            inverse_gate = Gate(
+                name=self.name + "_dg", num_qubits=self.num_qubits, params=[]
+            )  # removing the params because arrays are deprecated
+
+            definition = QuantumCircuit(*self.definition.qregs)
+            for inst in reversed(self._definition):
+                definition._append(
+                    inst.replace(operation=inst.operation.inverse(annotated=annotated))
+                )
+            inverse_gate.definition = definition
+        else:
+            inverse_gate = super().inverse(annotated=annotated)
+        return inverse_gate
+
+    # Returns the diagonal up to which the gate is implemented.
+    def _get_diagonal(self):
+        # Important: for a control list q_controls = [q[0],...,q_[k-1]] the diagonal gate is
+        # provided in the computational basis of the qubits q[k-1],...,q[0],q_target, decreasingly
+        # ordered with respect to the significance of the qubit in the computational basis
+        _, diag = self._dec_mcg_up_diag()
+        return diag
+
+    def _dec_mcg_up_diag(self):
+        """
+        Call to create a circuit with gates that implement the MCG up to a diagonal gate.
+        Remark: The qubits the gate acts on are ordered in the following way:
+            q=[q_target,q_controls,q_ancilla_zero,q_ancilla_dirty]
+        """
+        diag = np.ones(2 ** (self.num_controls + 1)).tolist()
+        q = QuantumRegister(self.num_qubits, "q")
+        circuit = QuantumCircuit(q, name="mcg_up_to_diagonal")
+        (q_target, q_controls, q_ancillas_zero, q_ancillas_dirty) = self._define_qubit_role(q)
+        # ToDo: Keep this threshold updated such that the lowest gate count is achieved:
+        # ToDo: we implement the MCG with a UCGate up to diagonal if the number of controls is
+        # ToDo: smaller than the threshold.
+        threshold = float("inf")
+        if self.num_controls < threshold:
+            # Implement the MCG as a UCGate (up to diagonal)
+            gate_list = [np.eye(2, 2) for i in range(2**self.num_controls)]
+            gate_list[-1] = self.params[0]
+            ucg = UCGate(gate_list, up_to_diagonal=True)
+            circuit.append(ucg, [q_target] + q_controls)
+            diag = ucg._get_diagonal()
+            # else:
+            # ToDo: Use the best decomposition for MCGs up to diagonal gates here
+            # ToDo: (with all available ancillas)
+        return circuit, diag
+
+    def _define_qubit_role(self, q):
+        # Define the role of the qubits
+        q_target = q[0]
+        q_controls = q[1 : self.num_controls + 1]
+        q_ancillas_zero = q[self.num_controls + 1 : self.num_controls + 1 + self.num_ancillas_zero]
+        q_ancillas_dirty = q[self.num_controls + 1 + self.num_ancillas_zero :]
+        return q_target, q_controls, q_ancillas_zero, q_ancillas_dirty
+
+    def validate_parameter(self, parameter):
+        """Multi controlled single-qubit unitary gate parameter has to be an ndarray."""
+        if isinstance(parameter, np.ndarray):
+            return parameter
+        else:
+            raise CircuitError(f"invalid param type {type(parameter)} in gate {self.name}")

qiskit/circuit/library/generalized_gates/mcmt.py

@@ -0,0 +1,316 @@
+# This code is part of Qiskit.
+#
+# (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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Multiple-Control, Multiple-Target Gate."""
+
+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
+
+
+class MCMT(QuantumCircuit):
+    """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:
+
+    .. code-block:: text
+
+        ───■────
+           │
+        ───■────
+           │
+        ───■────
+        ┌──┴───┐
+        ┤0     ├
+        │  2-H │
+        ┤1     ├
+        └──────┘
+
+    This default implementations requires no ancilla qubits, by broadcasting the target gate
+    to the number of target qubits and using Qiskit's generic control routine to control the
+    broadcasted target on the control qubits. If ancilla qubits are available, a more efficient
+    variant using the so-called V-chain decomposition can be used. This is implemented in
+    :class:`~qiskit.circuit.library.MCMTVChain`.
+    """
+
+    @deprecate_func(since="1.4", additional_msg="Use MCMTGate instead.")
+    def __init__(
+        self,
+        gate: Gate | Callable[[QuantumCircuit, circuit.Qubit, circuit.Qubit], circuit.Instruction],
+        num_ctrl_qubits: int,
+        num_target_qubits: int,
+    ) -> None:
+        """Create a new multi-control multi-target gate.
+
+        Args:
+            gate: The gate to be applied controlled on the control qubits and applied to the target
+                qubits. Can be either a Gate or a circuit method.
+                If it is a callable, it will be casted to a Gate.
+            num_ctrl_qubits: The number of control qubits.
+            num_target_qubits: The number of target qubits.
+
+        Raises:
+            AttributeError: If the gate cannot be casted to a controlled gate.
+            AttributeError: If the number of controls or targets is 0.
+        """
+        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=DeprecationWarning,
+                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=DeprecationWarning,
+                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
+
+        # initialize the circuit object
+        num_qubits = num_ctrl_qubits + num_target_qubits + self.num_ancilla_qubits
+        super().__init__(num_qubits, name="mcmt")
+        self._build()
+
+    def _build(self):
+        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 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:
+            gate = MCMT(self.gate, self.num_ctrl_qubits + num_ctrl_qubits, self.num_target_qubits)
+        else:
+            gate = super().control(num_ctrl_qubits, label, ctrl_state, annotated=annotated)
+        return gate
+
+    def inverse(self, annotated: bool = False):
+        """Return the inverse MCMT circuit, which is itself."""
+        return MCMT(self.gate, self.num_ctrl_qubits, self.num_target_qubits)
+
+
+class MCMTVChain(MCMT):
+    """The MCMT implementation using the CCX V-chain.
+
+    This implementation requires ancillas but is decomposed into a much shallower circuit
+    than the default implementation in :class:`~qiskit.circuit.library.MCMT`.
+
+    **Expanded Circuit:**
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit.library import MCMTVChain, ZGate
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       circuit = MCMTVChain(ZGate(), 2, 2)
+       _generate_circuit_library_visualization(circuit.decompose())
+
+    **Examples:**
+
+        >>> from qiskit.circuit.library import HGate
+        >>> MCMTVChain(HGate(), 3, 2).draw()
+
+        q_0: ──■────────────────────────■──
+               │                        │
+        q_1: ──■────────────────────────■──
+               │                        │
+        q_2: ──┼────■──────────────■────┼──
+               │    │  ┌───┐       │    │
+        q_3: ──┼────┼──┤ H ├───────┼────┼──
+               │    │  └─┬─┘┌───┐  │    │
+        q_4: ──┼────┼────┼──┤ H ├──┼────┼──
+             ┌─┴─┐  │    │  └─┬─┘  │  ┌─┴─┐
+        q_5: ┤ X ├──■────┼────┼────■──┤ X ├
+             └───┘┌─┴─┐  │    │  ┌─┴─┐└───┘
+        q_6: ─────┤ X ├──■────■──┤ X ├─────
+                  └───┘          └───┘
+    """
+
+    @deprecate_func(
+        since="1.4",
+        additional_msg="Use MCMTGate with the V-chain synthesis plugin instead.",
+    )
+    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
+
+        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 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,
+        gate: Gate,
+        num_ctrl_qubits: int,
+        num_target_qubits: int,
+        ctrl_state: int | str | None = None,
+        label: str | None = None,
+    ) -> 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.")
+
+        if num_ctrl_qubits < 1:
+            raise ValueError("Need at least one control 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())}"
+                )
+
+        # 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=DeprecationWarning,
+                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}."
+            )
+
+        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:
+            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:
+            gate = super().control(num_ctrl_qubits, label, ctrl_state, annotated=annotated)
+
+        return gate
+
+    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
+        )

qiskit/circuit/library/generalized_gates/pauli.py

@@ -0,0 +1,84 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Simulator command to perform multiple pauli gates in a single pass
+"""
+from qiskit.circuit.quantumcircuitdata import CircuitInstruction
+from qiskit.circuit.library.standard_gates.x import XGate
+from qiskit.circuit.library.standard_gates.y import YGate
+from qiskit.circuit.library.standard_gates.z import ZGate
+
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.exceptions import CircuitError
+
+
+class PauliGate(Gate):
+    r"""A multi-qubit Pauli gate.
+
+    This gate exists for optimization purposes for the
+    quantum statevector simulation, since applying multiple
+    pauli gates to different qubits at once can be done via
+    a single pass on the statevector.
+
+    The functionality is equivalent to applying
+    the pauli gates sequentially using standard Qiskit gates.
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.pauli` method.
+    """
+
+    def __init__(self, label):
+        super().__init__("pauli", len(label), [label])
+
+    def _define(self):
+        """
+        gate pauli (p1 a1,...,pn an) { p1 a1; ... ; pn an; }
+        """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
+
+        gates = {"X": XGate, "Y": YGate, "Z": ZGate}
+        q = QuantumRegister(len(self.params[0]), "q")
+        qc = QuantumCircuit(q, name=f"{self.name}({self.params[0]})")
+
+        paulis = self.params[0]
+        for i, p in enumerate(reversed(paulis)):
+            if p == "I":
+                continue
+            qc._append(CircuitInstruction(gates[p](), (q[i],), ()))
+        self.definition = qc
+
+    def inverse(self, annotated: bool = False):
+        r"""Return inverted pauli gate (itself)."""
+        return PauliGate(self.params[0])  # self-inverse
+
+    def __array__(self, dtype=None, copy=None):
+        """Return a Numpy.array for the pauli gate.
+        i.e. tensor product of the paulis"""
+        # pylint: disable=cyclic-import
+        from qiskit.quantum_info.operators import Pauli
+
+        return Pauli(self.params[0]).__array__(dtype=dtype, copy=copy)
+
+    def validate_parameter(self, parameter):
+        if isinstance(parameter, str):
+            if all(c in ["I", "X", "Y", "Z"] for c in parameter):
+                return parameter
+            else:
+                raise CircuitError(
+                    f"Parameter string {parameter} should contain only 'I', 'X', 'Y', 'Z' characters"
+                )
+        else:
+            raise CircuitError(
+                f"Parameter {parameter} should be a string of 'I', 'X', 'Y', 'Z' characters"
+            )