feat: add dynamic qft benchmark

Assisted-by: GPT-5 via Codex

Author: gshaowei6

src/mqt/bench/benchmarks/dynamic_qft.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2023 - 2026 Chair for Design Automation, TUM
+# Copyright (c) 2025 - 2026 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+"""Dynamic QFT benchmark definition."""
+
+from __future__ import annotations
+
+import math
+
+from qiskit.circuit import ClassicalRegister, QuantumCircuit, QuantumRegister
+
+from ._registry import register_benchmark
+
+_MAX_NUM_QUBITS = 64
+
+
+@register_benchmark("dynamic_qft", description="Dynamic QFT")
+def create_circuit(num_qubits: int) -> QuantumCircuit:
+    """Return a circuit implementing the Dynamic QFT.
+
+    This benchmark follows the semiclassical Quantum Fourier Transform by
+    Griffiths and Niu. Each qubit is transformed with a Hadamard gate, measured
+    immediately, and then its classical result controls phase rotations on the
+    remaining qubits. This replaces the usual controlled-phase gates with
+    mid-circuit measurements and classical feed-forward while keeping the same
+    triangular phase-angle structure as the standard QFT.
+
+    Arguments:
+        num_qubits: number of qubits of the returned quantum circuit. Must be at most 64.
+
+    Returns:
+        QuantumCircuit: a quantum circuit implementing the Dynamic QFT.
+
+    Raises:
+        ValueError: if more than 64 qubits are requested.
+    """
+    if num_qubits > _MAX_NUM_QUBITS:
+        msg = "Dynamic QFT supports at most 64 qubits."
+        raise ValueError(msg)
+
+    q = QuantumRegister(num_qubits, "q")
+    c = ClassicalRegister(num_qubits, "c")
+    qc = QuantumCircuit(q, c, name="dynamic_qft")
+
+    for measured_qubit in range(num_qubits):
+        qc.h(q[measured_qubit])
+        qc.measure(q[measured_qubit], c[measured_qubit])
+
+        for offset in range(1, num_qubits - measured_qubit):
+            with qc.if_test((c[measured_qubit], 1)):
+                qc.p(math.pi / (2**offset), q[measured_qubit + offset])
+
+    return qc

tests/test_bench.py

@@ -14,6 +14,7 @@
 import datetime
 import functools
 import io
+import math
 import re
 from enum import Enum
 from importlib import metadata
@@ -252,7 +253,55 @@ def test_graphstate_seed() -> None:
     assert qc_no_seed.name == "graphstate"
 
 
-# Test the dynamic GHZ circuit
+# Test the dynamic circuits
+def _conditional_phase_angles(qc: QuantumCircuit) -> list[float]:
+    """Return phase angles applied inside conditional blocks."""
+    angles = []
+    for instruction in qc.data:
+        operation = instruction.operation
+        if isinstance(operation, IfElseOp):
+            angles.extend(
+                float(conditional_instruction.operation.params[0])
+                for conditional_instruction in operation.blocks[0].data
+                if conditional_instruction.operation.name == "p"
+            )
+    return angles
+
+
+def test_dynamic_qft_description() -> None:
+    """Verify that the Dynamic QFT benchmark is registered with its canonical name."""
+    description = get_benchmark_description("dynamic_qft")
+    assert "Dynamic QFT" in description
+    assert "Dynamical" not in description
+
+
+def test_dynamic_qft_circuit_structure() -> None:
+    """Verify the structure of the Dynamic QFT benchmark."""
+    qc = create_circuit("dynamic_qft", 5)
+
+    assert qc.name == "dynamic_qft"
+    assert qc.num_qubits == 5
+    assert len(qc.cregs) == 1
+    assert qc.cregs[0].name == "c"
+    assert qc.cregs[0].size == 5
+
+    ops = qc.count_ops()
+    assert ops.get("h", 0) == 5
+    assert ops.get("measure", 0) == 5
+    assert ops.get("if_else", 0) == 10
+    assert ops.get("cp", 0) == 0
+
+    expected_angles = sorted(round(math.pi / (2**shift), 12) for shift in range(1, 5) for _ in range(5 - shift))
+    actual_angles = sorted(round(angle, 12) for angle in _conditional_phase_angles(qc))
+    assert actual_angles == expected_angles
+
+
+def test_dynamic_qft_rejects_too_many_qubits() -> None:
+    """Verify that Dynamic QFT rejects instances with impractically small phase shifts."""
+    with pytest.raises(ValueError, match="at most 64 qubits"):
+        create_circuit("dynamic_qft", 65)
+
+
 @pytest.mark.parametrize("num_qubits", [1, 2, 3, 7, 10])
 def test_dynamic_ghz_circuit_structure(num_qubits: int) -> None:
     """Verify the structure of the dynamic GHZ circuit for various qubit counts."""