Source code for qolumbina.programs.is_two_power.is_two_power_phase

# This code is developed through cross-language conversion from 
# https://github.com/MgcosA/Code_of_Testing_Oracle_Quantum_Program_Article/blob/master/qolumbina/programs/Is2Power.qs
# 
# In detail, the raw program is written in Q#, and we rewrite it in Qiskit.

from qiskit import QuantumCircuit

# ---------- benchmark registration ----------
from ..benchmark_registry import register_benchmark
from pathlib import Path
@register_benchmark(
    Path(__file__).stem,
    family=Path(__file__).resolve().parent.name,
    description="Check if input is a power of two (phase version)",
    class_name="Is2PowerPhase",
    source={
        "repo": "https://github.com/MgcosA/Code_of_Testing_Oracle_Quantum_Program_Article/blob/master/",
        "file": "qolumbina/programs/Is2Power.qs",
        "sdk": "Q#",
        "available_doc": True
    },
    testability_refactoring=[
        "Cross-language translation", 
        "Structure reorganization"
    ] 
)
def create_is_two_power_phase(input_qubits):
    return Is2PowerPhase(input_qubits=input_qubits)




class Is2PowerPhase(QuantumCircuit):
    r"""
    Implements Q# operation ``Is2Power_P``:
    Checks if the input qubit register represents a 2-power.
    Uses MultiX (X on all qubits) and MCZ (emulated via H-MCX-H).
    """
    def __init__(self, input_qubits: int, name: str | None = None):
        r"""
        Args:
            input_qubits: Number of qubits in the input register (:math:`n`).
            name: Optional name for the circuit.
        """

        self._input_qubits = input_qubits

        super().__init__(input_qubits, name=name or "Is2PowerPhase")
        self._build()

    def _build(self):
        qs = self.qubits
        n = len(qs)

        # MultiX: X on all qubits -> MultiX(qs)
        for q in qs:
            self.x(q)

        # Loop over each qubit 
        for i in range(n):
            self.x(qs[i])

            # Controlled Z on last qubit controlled by all except last
            # -> Controlled Z(qs[0..N-2], qs[N-1])
            if n > 1:   # only if there is more than 1 qubit
                # Apply H to target, then MCX, then H to emulate MCZ
                self.h(qs[-1])
                self.mcx(qs[0: -1], qs[-1])
                self.h(qs[-1])

            self.x(qs[i])

        # MultiX again -> MultiX(qs)
        for q in qs:
            self.x(q)