Adding QFT gate to natively reason about Quantum Fourier Transforms

pyproject.toml

@@ -88,6 +88,9 @@ sk = "qiskit.transpiler.passes.synthesis.solovay_kitaev_synthesis:SolovayKitaevS
 "permutation.kms" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation"
 "permutation.basic" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation"
 "permutation.acg" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation"
+"qft.full" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:QftSynthesisFull"
+"qft.line" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:QftSynthesisLine"
+"qft.default" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:QftSynthesisFull"
 "permutation.token_swapper" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:TokenSwapperSynthesisPermutation"
 
 [project.entry-points."qiskit.transpiler.init"]

qiskit/circuit/library/__init__.py

@@ -206,6 +206,7 @@
    UCRXGate
    UCRYGate
    UCRZGate
+   QftGate
 
 Boolean Logic Circuits
 ======================
@@ -524,6 +525,7 @@
     UCRXGate,
     UCRYGate,
     UCRZGate,
+    QftGate,
 )
 from .pauli_evolution import PauliEvolutionGate
 from .hamiltonian_gate import HamiltonianGate

qiskit/circuit/library/generalized_gates/__init__.py

@@ -28,3 +28,4 @@
 from .ucrz import UCRZGate
 from .unitary import UnitaryGate
 from .mcg_up_to_diagonal import MCGupDiag
+from .qft import QftGate

qiskit/circuit/library/generalized_gates/qft.py

@@ -0,0 +1,72 @@
+# 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.
+
+"""QftGate: gate class for natively reasoning about Quantum Fourier Transforms."""
+
+from __future__ import annotations
+import numpy as np
+from qiskit.circuit.quantumcircuit import Gate
+
+
+class QftGate(Gate):
+    r"""Quantum Fourier Transform Circuit.
+
+    The Quantum Fourier Transform (QFT) on :math:`n` qubits is the operation
+
+    .. math::
+
+        |j\rangle \mapsto \frac{1}{2^{n/2}} \sum_{k=0}^{2^n - 1} e^{2\pi ijk / 2^n} |k\rangle
+
+    """
+
+    def __init__(
+        self,
+        num_qubits: int,
+    ):
+        """Construct a new QFT gate.
+
+        Args:
+            num_qubits: The number of qubits on which the QFT acts.
+        """
+        super().__init__(name="qft", num_qubits=num_qubits, params=[])
+
+    def __array__(self, dtype=complex):
+        """Return a numpy array for the QftGate."""
+        num_qubits = self.num_qubits
+        mat = np.empty((2**num_qubits, 2**num_qubits), dtype=dtype)
+        for i in range(2**num_qubits):
+            i_index = int(bin(i)[2:].zfill(num_qubits), 2)
+            for j in range(i, 2**num_qubits):
+                entry = np.exp(2 * np.pi * 1j * i * j / 2**num_qubits) / 2 ** (num_qubits / 2)
+                j_index = int(bin(j)[2:].zfill(num_qubits), 2)
+                mat[i_index, j_index] = entry
+                if i != j:
+                    mat[j_index, i_index] = entry
+        return mat
+
+    def _basic_decomposition(self):
+        """Provide a specific decomposition of the QFT gate into a quantum circuit.
+
+        Returns:
+            QuantumCircuit: A circuit implementing the evolution.
+        """
+        from qiskit.synthesis.qft import synth_qft_full
+
+        decomposition = synth_qft_full(num_qubits=self.num_qubits)
+        return decomposition
+
+    def _define(self):
+        """Populate self.definition with a specific decomposition of the gate.
+        This is used for constructing Operators from QftGates, creating qasm
+        representations and more.
+        """
+        self.definition = self._basic_decomposition()

qiskit/qpy/binary_io/circuits.py

@@ -340,6 +340,8 @@ def _read_instruction(
             "DiagonalGate",
         }:
             gate = gate_class(params)
+        elif gate_name == "QftGate":
+            gate = gate_class(len(qargs), *params)
         else:
             if gate_name == "Barrier":
                 params = [len(qargs)]

qiskit/synthesis/qft/__init__.py

@@ -13,3 +13,4 @@
 """Module containing stabilizer QFT circuit synthesis."""
 
 from .qft_decompose_lnn import synth_qft_line
+from .qft_decompose_full import synth_qft_full

qiskit/synthesis/qft/qft_decompose_full.py

@@ -0,0 +1,61 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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
+# 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.
+"""
+Circuit synthesis for a QFT circuit.
+"""
+
+from typing import Optional
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+
+def synth_qft_full(
+    num_qubits: int,
+    do_swaps: bool = True,
+    approximation_degree: int = 0,
+    insert_barriers: bool = False,
+    inverse: bool = False,
+    name: Optional[str] = None,
+) -> QuantumCircuit:
+    """Construct a QFT circuit using all-to-all connectivity.
+
+    Args:
+        num_qubits: The number of qubits on which the QFT acts.
+        do_swaps: Whether to include the final swaps in the QFT.
+        approximation_degree: The degree of approximation (0 for no approximation).
+        insert_barriers: If True, barriers are inserted as visualization improvement.
+        inverse: If True, the inverse Fourier transform is constructed.
+        name: The name of the circuit.
+    """
+
+    circuit = QuantumCircuit(num_qubits, name=name)
+
+    for j in reversed(range(num_qubits)):
+        circuit.h(j)
+        num_entanglements = max(0, j - max(0, approximation_degree - (num_qubits - j - 1)))
+        for k in reversed(range(j - num_entanglements, j)):
+            # Use negative exponents so that the angle safely underflows to zero, rather than
+            # using a temporary variable that overflows to infinity in the worst case.
+            lam = np.pi * (2.0 ** (k - j))
+            circuit.cp(lam, j, k)
+
+        if insert_barriers:
+            circuit.barrier()
+
+    if do_swaps:
+        for i in range(num_qubits // 2):
+            circuit.swap(i, num_qubits - i - 1)
+
+    if inverse:
+        circuit = circuit.inverse()
+
+    return circuit

qiskit/transpiler/passes/synthesis/high_level_synthesis.py

@@ -35,6 +35,7 @@
     ControlModifier,
     PowerModifier,
 )
+from qiskit.circuit.library import QftGate
 from qiskit.synthesis.clifford import (
     synth_clifford_full,
     synth_clifford_layers,
@@ -49,6 +50,10 @@
     synth_permutation_acg,
     synth_permutation_depth_lnn_kms,
 )
+from qiskit.synthesis.qft import (
+    synth_qft_full,
+    synth_qft_line,
+)
 
 from .plugin import HighLevelSynthesisPluginManager, HighLevelSynthesisPlugin
 
@@ -661,6 +666,90 @@ def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **
         return decomposition
 
 
+class QftSynthesisFull(HighLevelSynthesisPlugin):
+    """Synthesis plugin for QFT gates using all-to-all connectivity.
+
+    This plugin name is :``qft.full`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    The plugin supports the following additional options:
+
+    * do_swaps (bool): Whether to include Swap gates at the end of the synthesized
+        circuit. Some implementation of the ``QftGate`` include a layer of Swap gates
+        at the end of the synthesized circuit, which cna in principle be dropped if
+        the ``QftGate`` itself is the last gate in the circuit.
+    * approximation_degree (int): The degree of approximation (0 for no approximation).
+        It is impossible ti implement the QFT approximately by ignoring
+        controlled-phase rotations with the angle is beneath a threshold. This is discussed
+        in more detail in https://arxiv.org/abs/quant-ph/9601018 or
+        https://arxiv.org/abs/quant-ph/0403071.
+    * insert_barriers (bool): If True, barriers are inserted as visualization improvement.
+    * inverse (bool): If True, the inverse Fourier transform is constructed.
+    * name (str): The name of the circuit.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given QftGate."""
+        if not isinstance(high_level_object, QftGate):
+            raise TranspilerError(
+                "The synthesis plugin 'qft.full` only applies to objects of type QftGate."
+            )
+
+        do_swaps = options.get("do_swaps", True)
+        approximation_degree = options.get("approximation_degree", 0)
+        insert_barriers = options.get("insert_barriers", False)
+        inverse = options.get("inverse", False)
+        name = options.get("name", None)
+
+        decomposition = synth_qft_full(
+            num_qubits=high_level_object.num_qubits,
+            do_swaps=do_swaps,
+            approximation_degree=approximation_degree,
+            insert_barriers=insert_barriers,
+            inverse=inverse,
+            name=name,
+        )
+        return decomposition
+
+
+class QftSynthesisLine(HighLevelSynthesisPlugin):
+    """Synthesis plugin for QFT gates using linear connectivity.
+
+    This plugin name is :``qft.line`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    The plugin supports the following additional options:
+
+    * do_swaps (bool): whether to include Swap gates at the end of the synthesized
+        circuit. Some implementation of the ``QftGate`` include a layer of Swap gates
+        at the end of the synthesized circuit, which cna in principle be dropped if
+        the ``QftGate`` itself is the last gate in the circuit.
+    * approximation_degree (int): the degree of approximation (0 for no approximation).
+        It is impossible ti implement the QFT approximately by ignoring
+        controlled-phase rotations with the angle is beneath a threshold. This is discussed
+        in more detail in https://arxiv.org/abs/quant-ph/9601018 or
+        https://arxiv.org/abs/quant-ph/0403071.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given QftGate."""
+        if not isinstance(high_level_object, QftGate):
+            raise TranspilerError(
+                "The synthesis plugin 'qft.line` only applies to objects of type QftGate."
+            )
+
+        do_swaps = options.get("do_swaps", True)
+        approximation_degree = options.get("approximation_degree", 0)
+
+        decomposition = synth_qft_line(
+            num_qubits=high_level_object.num_qubits,
+            do_swaps=do_swaps,
+            approximation_degree=approximation_degree,
+        )
+        return decomposition
+
+
 class TokenSwapperSynthesisPermutation(HighLevelSynthesisPlugin):
     """The permutation synthesis plugin based on the token swapper algorithm.
 
@@ -691,7 +780,6 @@ class TokenSwapperSynthesisPermutation(HighLevelSynthesisPlugin):
 
     For more details on the token swapper algorithm, see to the paper:
     `arXiv:1902.09102 <https://arxiv.org/abs/1902.09102>`__.
-
     """
 
     def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

releasenotes/notes/add-qft-gate-fd4e08f6721a9da4.yaml

@@ -0,0 +1,22 @@
+---
+features:
+  - |
+    Added a new class :class:`~qiskit.circuit.library.QftGate` for
+    natively representing Quantum Fourier Transforms (QFTs). The older way
+    of representing QFTs via quantum circuits, see
+    :class:`~qiskit.circuit.library.QFT`, remains for backward compatibility.
+    The new way of representing a QFT via a gate avoids synthesizing its
+    definition circuit when the gate is declared, delaying the actual synthesis to
+    the transpiler. It also allows to easily choose between several different
+    algorithms for synthesizing QFTs, which are available as high-level-synthesis
+    plugins.
+  - |
+    Added a synthesis method :func:`.synth_qft_full` for constructing a QFT circuit
+    assuming a fully-connected architecture.
+  - |
+    Added two high-level-synthesis plugins for synthesizing a
+    :class:`~qiskit.circuit.library.QftGate`.
+    The class :class:`.QftSynthesisFull` is based on :func:`.synth_qft_full` and synthesizes
+    a QFT gate assuming all-to-all connectivity.
+    The class :class:`.QftSynthesisLine` is based on :func:`.synth_qft_line` and synthesizes
+    a QFT gate assuming linear nearest neighbor connectivity.