qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/circuit/library/generalized_gates/linear_function.py

@@ -0,0 +1,302 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# 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.
+
+"""Linear Function."""
+
+from __future__ import annotations
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit, Gate
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.synthesis.linear import check_invertible_binary_matrix
+from qiskit.circuit.library.generalized_gates.permutation import PermutationGate
+
+
+class LinearFunction(Gate):
+    r"""A linear reversible circuit on n qubits.
+
+    Internally, a linear function acting on n qubits is represented
+    as a n x n matrix of 0s and 1s in numpy array format.
+
+    A linear function can be synthesized into CX and SWAP gates using the Patel–Markov–Hayes
+    algorithm, as implemented in :func:`~qiskit.transpiler.synthesis.cnot_synth`
+    based on reference [1].
+
+    For efficiency, the internal n x n matrix is stored in the format expected
+    by cnot_synth, which is the big-endian (and not the little-endian) bit-ordering convention.
+
+    **Example:** the circuit
+
+    .. parsed-literal::
+
+        q_0: ──■──
+             ┌─┴─┐
+        q_1: ┤ X ├
+             └───┘
+        q_2: ─────
+
+    is represented by a 3x3 linear matrix
+
+    .. math::
+
+            \begin{pmatrix}
+                1 & 0 & 0 \\
+                1 & 1 & 0 \\
+                0 & 0 & 1
+            \end{pmatrix}
+
+
+    **References:**
+
+    [1] Ketan N. Patel, Igor L. Markov, and John P. Hayes,
+    Optimal synthesis of linear reversible circuits,
+    Quantum Inf. Comput. 8(3) (2008).
+    `Online at umich.edu. <https://web.eecs.umich.edu/~imarkov/pubs/jour/qic08-cnot.pdf>`_
+    """
+
+    def __init__(self, linear, validate_input=False):
+        """Create a new linear function.
+
+        Args:
+            linear (list[list] or ndarray[bool] or QuantumCircuit or LinearFunction
+                or PermutationGate or Clifford): data from which a linear function
+                can be constructed. It can be either a nxn matrix (describing the
+                linear transformation), a permutation (which is a special case of
+                a linear function), another linear function, a clifford (when it
+                corresponds to a linear function), or a quantum circuit composed of
+                linear gates (CX and SWAP) and other objects described above, including
+                nested subcircuits.
+
+            validate_input: if True, performs more expensive input validation checks,
+                such as checking that a given n x n matrix is invertible.
+
+        Raises:
+            CircuitError: if the input is invalid:
+                either the input matrix is not square or not invertible,
+                or the input quantum circuit contains non-linear objects
+                (for example, a Hadamard gate, or a Clifford that does
+                not correspond to a linear function).
+        """
+
+        # pylint: disable=cyclic-import
+        from qiskit.quantum_info import Clifford
+
+        original_circuit = None
+
+        if isinstance(linear, (list, np.ndarray)):
+            # Normalize to numpy array (coercing entries to 0s and 1s)
+            try:
+                linear = np.array(linear, dtype=bool, copy=True)
+            except ValueError:
+                raise CircuitError(
+                    "A linear function must be represented by a square matrix."
+                ) from None
+
+            # Check that the matrix is square
+            if len(linear.shape) != 2 or linear.shape[0] != linear.shape[1]:
+                raise CircuitError("A linear function must be represented by a square matrix.")
+
+            # Optionally, check that the matrix is invertible
+            if validate_input:
+                if not check_invertible_binary_matrix(linear):
+                    raise CircuitError(
+                        "A linear function must be represented by an invertible matrix."
+                    )
+
+        elif isinstance(linear, QuantumCircuit):
+            # The following function will raise a CircuitError if there are nonlinear gates.
+            original_circuit = linear
+            linear = LinearFunction._circuit_to_mat(linear)
+
+        elif isinstance(linear, LinearFunction):
+            linear = linear.linear.copy()
+
+        elif isinstance(linear, PermutationGate):
+            linear = LinearFunction._permutation_to_mat(linear)
+
+        elif isinstance(linear, Clifford):
+            # The following function will raise a CircuitError if clifford does not correspond
+            # to a linear function.
+            linear = LinearFunction._clifford_to_mat(linear)
+
+        # Note: if we wanted, we could also try to construct a linear function from a
+        # general operator, by first attempting to convert it to clifford, and then to
+        # a linear function.
+
+        else:
+            raise CircuitError("A linear function cannot be successfully constructed.")
+
+        super().__init__(
+            name="linear_function", num_qubits=len(linear), params=[linear, original_circuit]
+        )
+
+    @staticmethod
+    def _circuit_to_mat(qc: QuantumCircuit):
+        """This creates a nxn matrix corresponding to the given quantum circuit."""
+        nq = qc.num_qubits
+        mat = np.eye(nq, nq, dtype=bool)
+
+        for instruction in qc.data:
+            if instruction.operation.name in ("barrier", "delay"):
+                # can be ignored
+                continue
+            if instruction.operation.name == "cx":
+                # implemented directly
+                cb = qc.find_bit(instruction.qubits[0]).index
+                tb = qc.find_bit(instruction.qubits[1]).index
+                mat[tb, :] = (mat[tb, :]) ^ (mat[cb, :])
+                continue
+            if instruction.operation.name == "swap":
+                # implemented directly
+                cb = qc.find_bit(instruction.qubits[0]).index
+                tb = qc.find_bit(instruction.qubits[1]).index
+                mat[[cb, tb]] = mat[[tb, cb]]
+                continue
+
+            # In all other cases, we construct the linear function for the operation.
+            # and compose (multiply) linear matrices.
+
+            if getattr(instruction.operation, "definition", None) is not None:
+                other = LinearFunction(instruction.operation.definition)
+            else:
+                other = LinearFunction(instruction.operation)
+
+            positions = [qc.find_bit(q).index for q in instruction.qubits]
+            other = other.extend_with_identity(len(mat), positions)
+            mat = np.dot(other.linear.astype(int), mat.astype(int)) % 2
+            mat = mat.astype(bool)
+
+        return mat
+
+    @staticmethod
+    def _clifford_to_mat(cliff):
+        """This creates a nxn matrix corresponding to the given Clifford, when Clifford
+        can be converted to a linear function. This is possible when the clifford has
+        tableau of the form [[A, B], [C, D]], with B = C = 0 and D = A^{-1}^t, and zero
+        phase vector. In this case, the required matrix is A^t.
+        Raises an error otherwise.
+        """
+        # Note: since cliff is a valid Clifford, then the condition D = A^{-1}^t
+        # holds automatically once B = C = 0.
+        if cliff.phase.any() or cliff.destab_z.any() or cliff.stab_x.any():
+            raise CircuitError("The given clifford does not correspond to a linear function.")
+        return np.transpose(cliff.destab_x)
+
+    @staticmethod
+    def _permutation_to_mat(perm):
+        """This creates a nxn matrix from a given permutation gate."""
+        nq = len(perm.pattern)
+        mat = np.zeros((nq, nq), dtype=bool)
+        for i, j in enumerate(perm.pattern):
+            mat[i, j] = True
+        return mat
+
+    def __eq__(self, other):
+        """Check if two linear functions represent the same matrix."""
+        if not isinstance(other, LinearFunction):
+            return False
+        return (self.linear == other.linear).all()
+
+    def validate_parameter(self, parameter):
+        """Parameter validation"""
+        return parameter
+
+    def _define(self):
+        """Populates self.definition with a decomposition of this gate."""
+        self.definition = self.synthesize()
+
+    def synthesize(self):
+        """Synthesizes the linear function into a quantum circuit.
+
+        Returns:
+            QuantumCircuit: A circuit implementing the evolution.
+        """
+        from qiskit.synthesis.linear import synth_cnot_count_full_pmh
+
+        return synth_cnot_count_full_pmh(self.linear)
+
+    @property
+    def linear(self):
+        """Returns the n x n matrix representing this linear function."""
+        return self.params[0]
+
+    @property
+    def original_circuit(self):
+        """Returns the original circuit used to construct this linear function
+        (including None, when the linear function is not constructed from a circuit).
+        """
+        return self.params[1]
+
+    def is_permutation(self) -> bool:
+        """Returns whether this linear function is a permutation,
+        that is whether every row and every column of the n x n matrix
+        has exactly one 1.
+        """
+        linear = self.linear
+        perm = np.all(np.sum(linear, axis=0) == 1) and np.all(np.sum(linear, axis=1) == 1)
+        return perm
+
+    def permutation_pattern(self):
+        """This method first checks if a linear function is a permutation and raises a
+        `qiskit.circuit.exceptions.CircuitError` if not. In the case that this linear function
+        is a permutation, returns the permutation pattern.
+        """
+        if not self.is_permutation():
+            raise CircuitError("The linear function is not a permutation")
+
+        linear = self.linear
+        locs = np.where(linear == 1)
+        return locs[1]
+
+    def extend_with_identity(self, num_qubits: int, positions: list[int]) -> LinearFunction:
+        """Extend linear function to a linear function over nq qubits,
+        with identities on other subsystems.
+
+        Args:
+            num_qubits: number of qubits of the extended function.
+
+            positions: describes the positions of original qubits in the extended
+                function's qubits.
+
+        Returns:
+            LinearFunction: extended linear function.
+        """
+        extended_mat = np.eye(num_qubits, dtype=bool)
+
+        for i, pos in enumerate(positions):
+            extended_mat[positions, pos] = self.linear[:, i]
+
+        return LinearFunction(extended_mat)
+
+    def mat_str(self):
+        """Return string representation of the linear function
+        viewed as a matrix with 0/1 entries.
+        """
+        return str(self.linear.astype(int))
+
+    def function_str(self):
+        """Return string representation of the linear function
+        viewed as a linear transformation.
+        """
+        out = "("
+        mat = self.linear
+        for row in range(self.num_qubits):
+            first_entry = True
+            for col in range(self.num_qubits):
+                if mat[row, col]:
+                    if not first_entry:
+                        out += " + "
+                    out += "x_" + str(col)
+                    first_entry = False
+            if row != self.num_qubits - 1:
+                out += ", "
+        out += ")\n"
+        return out

qiskit/circuit/library/generalized_gates/mcg_up_to_diagonal.py

@@ -0,0 +1,138 @@
+# 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)
+        mcg_up_diag_circuit = QuantumCircuit(q)
+        mcg_up_diag_circuit.append(gate, q[:])
+        self.definition = mcg_up_diag_circuit
+
+    def inverse(self) -> Gate:
+        """Return the inverse.
+
+        Note that the resulting Gate object has an empty ``params`` property.
+        """
+        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()))
+        inverse_gate.definition = definition
+        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)
+        circuit = QuantumCircuit(q)
+        (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,254 @@
+# 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
+
+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
+
+
+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:
+
+    .. parsed-literal::
+
+        ───■────
+           │
+        ───■────
+           │
+        ───■────
+        ┌──┴───┐
+        ┤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`.
+    """
+
+    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.")
+
+        # 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
+        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, [])
+
+    @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):
+        """Return the controlled version of the MCMT circuit."""
+        if ctrl_state is None:  # TODO add ctrl state implementation by adding X gates
+            return MCMT(self.gate, self.num_ctrl_qubits + num_ctrl_qubits, self.num_target_qubits)
+        return super().control(num_ctrl_qubits, label, ctrl_state)
+
+    def inverse(self):
+        """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::
+
+       from qiskit.circuit.library import MCMTVChain, ZGate
+       from qiskit.tools.jupyter.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 ├─────
+                  └───┘          └───┘
+    """
+
+    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]
+
+        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 _ccx_v_chain_rule(
+        self,
+        control_qubits: QuantumRegister | list[circuit.Qubit],
+        ancilla_qubits: QuantumRegister | list[circuit.Qubit],
+        reverse: bool = False,
+    ) -> None:
+        """Get the rule for the CCX V-chain.
+
+        The CCX V-chain progressively computes the CCX of the control qubits and puts the final
+        result in the last ancillary 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.
+
+        Returns:
+            The rule for the (reversed) CCX V-chain.
+
+        Raises:
+            QiskitError: If an insufficient number of ancilla qubits was provided.
+        """
+        if len(ancilla_qubits) == 0:
+            return
+
+        if len(ancilla_qubits) < len(control_qubits) - 1:
+            raise QiskitError("Insufficient number of ancilla qubits.")
+
+        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:
+            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):
+        return MCMTVChain(self.gate, self.num_ctrl_qubits, self.num_target_qubits)