classiq 0.53.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/qmod/builtins/functions/modular_exponentiation.py

@@ -1,30 +1,26 @@
+from classiq.qmod.builtins.classical_functions import qft_const_adder_phase
+from classiq.qmod.builtins.functions.qft_functions import qft, qft_no_swap
+from classiq.qmod.builtins.functions.standard_gates import PHASE, SWAP, X
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.operations import bind, control, invert, repeat, within_apply
+from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CInt
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
-
-
-@qfunc(external=True)
-def qft_no_swap(qbv: QArray[QBit]) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Applies the Quantum Fourier Transform (QFT) without the swap gates.
-
-    Args:
-        qbv: The quantum number to which the QFT is applied.
-
-    """
-    pass
+from classiq.qmod.symbolic import min, mod_inverse
 
 
 @qfunc(external=True)
 def _check_msb(ref: CInt, x: QArray[QBit], aux: QBit) -> None:
-    pass
+    within_apply(
+        lambda: invert(lambda: qft_no_swap(x)), lambda: _ctrl_x(ref, x[0], aux)
+    )
 
 
 @qfunc(external=True)
-def _ctrl_x(ref: CInt, ctrl: QNum, aux: QBit) -> None:
-    pass
+def _ctrl_x(
+    ref: CInt, ctrl: QNum, aux: QBit
+) -> None:  # TODO: remove qfunc when expressions of QBit is supported
+    control(ctrl == ref, lambda: X(aux))
 
 
 @qfunc(external=True)
@@ -43,7 +39,15 @@ def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
         phi_b: The quantum number (at the aft space) to which the constant is added.
 
     """
-    pass
+    repeat(
+        count=phi_b.len,
+        iteration=lambda index: PHASE(
+            theta=qft_const_adder_phase(
+                index, value, phi_b.len  # type:ignore[arg-type]
+            ),
+            target=phi_b[index],
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -62,7 +66,33 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
         c2: a control qubit.
 
     """
-    pass
+    ctrl: QArray[QBit] = QArray("ctrl")
+    aux = QBit("aux")
+
+    within_apply(
+        lambda: (  # type:ignore[arg-type]
+            allocate(1, aux),
+            bind([c1, c2], ctrl),  # type:ignore[func-returns-value]
+        ),
+        lambda: (  # type:ignore[arg-type]
+            control(  # type:ignore[func-returns-value]
+                ctrl, lambda: qft_space_add_const(a, phi_b)
+            ),
+            invert(  # type:ignore[func-returns-value]
+                lambda: qft_space_add_const(n, phi_b)
+            ),
+            _check_msb(1, phi_b, aux),
+            control(  # type:ignore[func-returns-value]
+                aux, lambda: qft_space_add_const(n, phi_b)
+            ),
+            within_apply(
+                lambda: invert(  # type:ignore[func-returns-value]
+                    lambda: control(ctrl, lambda: qft_space_add_const(a, phi_b))
+                ),
+                lambda: _check_msb(0, phi_b, aux),
+            ),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -82,7 +112,15 @@ def c_modular_multiply(
         x: The quantum factor.
         ctrl: The control bit.
     """
-    pass
+    within_apply(
+        lambda: qft(b),
+        lambda: repeat(
+            count=x.len,
+            iteration=lambda index: cc_modular_add(
+                n, (a * (2**index)) % n, b, x[index], ctrl
+            ),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -98,7 +136,10 @@ def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
         y: The second array
 
     """
-    pass
+    repeat(
+        count=min(x.len, y.len),
+        iteration=lambda index: SWAP(x[index], y[index]),
+    )
 
 
 @qfunc(external=True)
@@ -115,7 +156,20 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
         x: The quantum factor.
         ctrl: The control bit.
     """
-    pass
+    b: QArray[QBit] = QArray("b")
+
+    within_apply(
+        lambda: allocate(x.len + 1, b),
+        lambda: (  # type:ignore[arg-type]
+            c_modular_multiply(n, a, b, x, ctrl),
+            control(  # type:ignore[func-returns-value]
+                ctrl, lambda: multiswap(x, b)
+            ),
+            invert(  # type:ignore[func-returns-value]
+                lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)
+            ),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -123,15 +177,22 @@ def modular_exp(n: CInt, a: CInt, x: QArray[QBit], power: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
 
-    Raises a classical integer `a` to the power of a quantum number `x` modulo classical integer `n`
-    times a quantum number `power`. Performs $power=(a^x \\mod n)*power$ in-place.
-    (and specifically if at the input $power=1$, at the output $power=a^x \\mod n$).
+    Raises a classical integer `a` to the power of a quantum number `power` modulo classical integer `n`
+    times a quantum number `x`. Performs $x=(a^{power} \\mod n)*x$ in-place.
+    (and specifically if at the input $x=1$, at the output $x=a^{power} \\mod n$).
 
     Args:
         n: The modulus number. Should be non-negative.
         a: The base of the exponentiation. Should be non-negative.
-        x: The power of the exponentiation.
-        power: A quantum number which multiplies the modular exponentiation and holds the output.
+        x: A quantum number that multiplies the modular exponentiation and holds the output. It should be at least the size of $\\lceil \\log(n) \rceil$.
+        power: The power of the exponentiation.
 
+    Usage Example:
+        [Modular Exponentiation](https://docs.classiq.io/latest/explore/functions/function_usage_examples/arithmetic/modular_exp/modular_exp_example)
     """
-    pass
+    repeat(
+        count=power.len,
+        iteration=lambda index: inplace_c_modular_multiply(
+            n, (a ** (2**index)) % n, x, power[index]
+        ),
+    )

classiq/qmod/builtins/functions/operators.py

@@ -19,4 +19,4 @@ def apply(
 
 @qfunc(external=True)
 def switch(selector: CInt, cases: QCallableList) -> None:
-    pass
+    cases[selector]()

classiq/qmod/builtins/functions/qaoa_penalty.py

@@ -1,5 +1,7 @@
 from typing import Literal
 
+from classiq.qmod.builtins.functions import RX, H, suzuki_trotter
+from classiq.qmod.builtins.operations import repeat
 from classiq.qmod.builtins.structs import PauliTerm
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CInt, CReal
@@ -22,7 +24,7 @@ def qaoa_mixer_layer(b: CReal, target: QArray[QBit]) -> None:
         b: The rotation parameter for the mixer layer.
         target: The target quantum array.
     """
-    pass
+    repeat(target.len, lambda index: RX(b, target[index]))
 
 
 @qfunc(external=True)
@@ -44,7 +46,7 @@ def qaoa_cost_layer(
         hamiltonian: The Hamiltonian terms for the QAOA model.
         target: The target quantum array variable.
     """
-    pass
+    suzuki_trotter(hamiltonian, g, 1, 1, target)
 
 
 @qfunc(external=True)
@@ -68,7 +70,8 @@ def qaoa_layer(
            target: The target quantum array variable.
 
     """
-    pass
+    qaoa_cost_layer(g, hamiltonian, target)
+    qaoa_mixer_layer(b, target)
 
 
 @qfunc(external=True)
@@ -85,7 +88,7 @@ def qaoa_init(target: QArray[QBit]) -> None:
     Args:
            target: The target quantum array variable.
     """
-    pass
+    repeat(target.len, lambda index: H(target[index]))
 
 
 @qfunc(external=True)
@@ -113,4 +116,10 @@ def qaoa_penalty(
         hamiltonian: The Hamiltonian terms for the QAOA model.
         target: The target quantum array variable.
     """
-    pass
+    qaoa_init(target)
+    repeat(
+        params_list.len / 2,  # type:ignore[arg-type]
+        lambda index: qaoa_layer(
+            params_list[2 * index], params_list[(2 * index) + 1], hamiltonian, target
+        ),
+    )

classiq/qmod/builtins/functions/qft_functions.py

@@ -0,0 +1,57 @@
+from classiq.qmod.builtins.functions.standard_gates import CPHASE, SWAP, H
+from classiq.qmod.builtins.operations import repeat
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.symbolic import pi
+
+
+@qfunc(external=True)
+def qft_no_swap(qbv: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the Quantum Fourier Transform (QFT) without the swap gates.
+
+    Args:
+        qbv: The quantum number to which the QFT is applied.
+
+    """
+    repeat(
+        qbv.len,
+        lambda i: (  # type:ignore[arg-type]
+            H(qbv[i]),
+            repeat(  # type:ignore[func-returns-value]
+                qbv.len - i - 1,
+                lambda j: CPHASE(
+                    theta=pi / (2 ** (j + 1)),
+                    ctrl=qbv[i + j + 1],
+                    target=qbv[i],
+                ),
+            ),
+        ),
+    )
+
+
+@qfunc(external=True)
+def qft(target: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Performs the Quantum Fourier Transform (QFT) on `target` in-place.
+    Implements the following transformation:
+
+    $$
+    y_{k} = \\frac{1}{\\sqrt{N}} \\sum_{j=0}^{N-1} x_j e^{2\\pi i \\frac{jk}{N}}
+    $$
+
+    Args:
+        target: The quantum object to be transformed
+
+    Further reading in Classiq Library:
+    Link: [qft library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qft/qft.ipynb)
+    """
+    repeat(
+        target.len / 2,  # type:ignore[arg-type]
+        lambda index: SWAP(target[index], target[(target.len - 1) - index]),
+    )
+    qft_no_swap(target)

classiq/qmod/builtins/functions/qpe.py

@@ -1,6 +1,10 @@
+from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import H
+from classiq.qmod.builtins.functions.utility_functions import apply_to_all
+from classiq.qmod.builtins.operations import bind, control, invert, power, repeat
+from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CInt
-from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.qmod_variable import QArray, QNum
 from classiq.qmod.quantum_callable import QCallable
 
 
@@ -19,7 +23,19 @@ def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
     Further reading in Classiq Library:
     Link: [qpe library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb)
     """
-    pass
+    phase_array: QArray = QArray("phase_array")
+    bind(phase, phase_array)
+    apply_to_all(H, phase_array)
+
+    repeat(
+        count=phase_array.len,
+        iteration=lambda index: control(
+            ctrl=phase_array[index], stmt_block=lambda: unitary_with_power(2**index)
+        ),
+    )
+
+    invert(lambda: qft(phase_array))
+    bind(phase_array, phase)
 
 
 @qfunc(external=True)
@@ -36,4 +52,4 @@ def qpe(unitary: QCallable, phase: QNum) -> None:
     Further reading in Classiq Library:
     Link: [qpe library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb)
     """
-    pass
+    qpe_flexible(unitary_with_power=lambda k: power(k, unitary), phase=phase)

classiq/qmod/builtins/functions/qsvt.py

@@ -1,7 +1,10 @@
+from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RZ, H
+from classiq.qmod.builtins.operations import if_, invert, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import floor
 
 
 @qfunc(external=True)
@@ -35,7 +38,10 @@ def qsvt_step(
     Further reading in Classiq Library:
         [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
     """
-    pass
+    u(qvar)
+    projector_controlled_phase(phase1, proj_cnot_2, qvar, aux)
+    invert(lambda: u(qvar))
+    projector_controlled_phase(phase2, proj_cnot_1, qvar, aux)
 
 
 @qfunc(external=True)
@@ -78,7 +84,37 @@ def qsvt(
     Further reading in Classiq Library:
         [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
     """
-    pass
+    H(aux)
+
+    projector_controlled_phase(phase_seq[0], proj_cnot_1, qvar, aux)
+    repeat(
+        count=floor((phase_seq.len - 1) / 2),
+        iteration=lambda index: qsvt_step(
+            phase_seq[2 * index + 1],
+            phase_seq[2 * index + 2],
+            proj_cnot_1,
+            proj_cnot_2,
+            u,
+            qvar,
+            aux,
+        ),
+    )
+
+    if_(
+        condition=phase_seq.len % 2 == 1,
+        then=lambda: IDENTITY(qvar),
+        else_=lambda: (  # type:ignore[arg-type]
+            u(qvar),  # type:ignore[func-returns-value]
+            projector_controlled_phase(
+                phase_seq[phase_seq.len - 1],
+                proj_cnot_2,
+                qvar,
+                aux,
+            ),
+        ),
+    )
+
+    H(aux)
 
 
 @qfunc(external=True)
@@ -106,7 +142,9 @@ def projector_controlled_phase(
     Further reading in Classiq Library:
         [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
     """
-    pass
+    proj_cnot(qvar, aux)
+    RZ(phase, aux)
+    proj_cnot(qvar, aux)
 
 
 @qfunc(external=True)
@@ -133,4 +171,11 @@ def qsvt_inversion(
     For usage example, see:
         [QSVT matrix inversion example](https://docs.classiq.io/latest/explore/algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion)
     """
-    pass
+    qsvt(
+        phase_seq,
+        block_encoding_cnot,
+        block_encoding_cnot,
+        lambda x: invert(lambda: u(x)),
+        qvar,
+        aux,
+    )

classiq/qmod/builtins/functions/standard_gates.py

@@ -560,7 +560,7 @@ def CRY(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the RY gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -588,7 +588,7 @@ def CRZ(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the RZ gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -616,7 +616,7 @@ def CPHASE(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the PHASE gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -731,7 +731,7 @@ def CCX(ctrl: QArray[QBit, Literal[2]], target: QBit) -> None:
     More information can be found on [Wikipedia](https://en.wikipedia.org/wiki/Toffoli_gate).
 
     Args:
-        control (QArray[QBit, Literal[2]]): The control qubits.
+        ctrl (QArray[QBit, Literal[2]]): The control qubits.
         target (QBit): The qubit to apply the conditioned Pauli-X gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)

classiq/qmod/builtins/functions/state_preparation.py

@@ -1,8 +1,24 @@
 from typing import Literal
 
-from classiq.qmod.cparam import CArray, CBool, CInt, CReal
+from classiq.qmod.builtins.functions.arithmetic import modular_increment
+from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
+from classiq.qmod.builtins.functions.utility_functions import hadamard_transform
+from classiq.qmod.builtins.operations import control, if_, repeat
+from classiq.qmod.cparam import CBool, CInt
 from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum
+from classiq.qmod.symbolic import (
+    asin,
+    atan,
+    exp,
+    floor,
+    log,
+    max as qmax,
+    min as qmin,
+    pi,
+    sqrt,
+)
 
 
 @qfunc(external=True)
@@ -53,7 +69,7 @@ def allocate_num(
     Further reading is available on the [reference manual](https://docs.classiq.io/latest/reference-manual/qmod/language-reference/quantum-types#allocate-num)
 
     """
-    pass
+    allocate(num_qubits, out)
 
 
 @qfunc(external=True)
@@ -178,11 +194,31 @@ def inplace_prepare_amplitudes(
     pass
 
 
+def prepare_uniform_trimmed_state_apply_rotation(
+    size_lsb: CInt, lsbs_val: CInt, rotation_var: QBit
+) -> None:
+    # max hold for the case where the value is on the left side
+    # the fraction in the sqrt is the wanted amount of probability
+    # in the left side divided by the total amount
+    RY(
+        -2 * (asin(sqrt(qmin((2 ** (size_lsb)) / lsbs_val, 1))) + pi / 4) + pi,
+        rotation_var,
+    )
+
+
 @qfunc(external=True)
 def _prepare_uniform_trimmed_state_step(
     size_lsb: CInt, ctrl_val: CInt, lsbs_val: CInt, ctrl_var: QNum, rotation_var: QBit
 ) -> None:
-    pass
+    if_(
+        lsbs_val != 0,  # stop condition
+        lambda: control(
+            ctrl_var == ctrl_val,
+            lambda: prepare_uniform_trimmed_state_apply_rotation(
+                size_lsb, lsbs_val, rotation_var
+            ),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -207,7 +243,28 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
         1. If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
-    pass
+    hadamard_transform(q)
+
+    if_(
+        m < 2**q.len,
+        # initial step without control
+        lambda: prepare_uniform_trimmed_state_apply_rotation(
+            q.len - 1,  # type:ignore[arg-type]
+            m,
+            q[q.len - 1],
+        ),
+    )
+
+    repeat(
+        qmax(q.len - 1, 0),
+        lambda i: _prepare_uniform_trimmed_state_step(
+            q.len - i - 2,
+            floor(m / (2 ** (q.len - i - 1))),
+            m % (2 ** (q.len - i - 1)),
+            q[q.len - i - 1 : q.len],
+            q[q.len - i - 2],
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -232,7 +289,8 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
         1. If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
-    pass
+    prepare_uniform_trimmed_state(end - start, q)
+    modular_increment(start, q)
 
 
 @qfunc(external=True)
@@ -251,7 +309,20 @@ def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
 
 
     """
-    pass
+
+    def inner_lop(step: CInt) -> None:
+        repeat(
+            count=2**step,
+            iteration=lambda control_index: if_(
+                condition=control_index + 2**step >= size,
+                then=lambda: IDENTITY(q[0]),
+                else_=lambda: CX(q[control_index], q[control_index + 2**step]),
+            ),
+        )
+
+    allocate(size, q)
+    H(q[0])
+    repeat(floor(log(size - 1, 2)) + 1, inner_lop)  # type:ignore[arg-type]
 
 
 @qfunc(external=True)
@@ -272,7 +343,7 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
 
     Further reading is available on the [reference manual](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state)
     """
-    pass
+    repeat(q.len, lambda i: RY(2.0 * atan(exp((-rate * 2.0**i) / 2.0)), q[i]))
 
 
 @qfunc(external=True)
@@ -318,7 +389,10 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
 
     """
-    pass
+    allocate(2, q)
+    inplace_prepare_int(state_num, q)
+    H(q[0])
+    CX(q[0], q[1])
 
 
 @qfunc(external=True)
@@ -336,7 +410,14 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     Note:
         If the value cannot fit into the quantum variable, it is truncated, i.e. treated as the value modulo $2^\\text{target.size}$.
     """
-    pass
+    repeat(
+        target.len,
+        lambda index: if_(
+            (floor(value / (2**index)) % 2) == 1,
+            lambda: X(target[index]),
+            lambda: IDENTITY(target[index]),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -357,4 +438,5 @@ def prepare_int(
     Note:
         If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
     """
-    pass
+    allocate(floor(log(value, 2)) + 1, out)
+    inplace_prepare_int(value, out)

classiq/qmod/builtins/functions/swap_test.py

@@ -1,3 +1,6 @@
+from classiq.qmod.builtins.functions.standard_gates import SWAP, H
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.operations import control, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit
 
@@ -22,4 +25,7 @@ def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) ->
     Example:
         Further reading in the Classiq library is found [here](https://docs.classiq.io/latest/explore/algorithms/swap_test/swap_test/).
     """
-    pass
+    allocate(1, test)
+    H(test)
+    control(test, lambda: repeat(state1.len, lambda i: SWAP(state1[i], state2[i])))
+    H(test)

classiq/qmod/builtins/functions/utility_functions.py

@@ -0,0 +1,43 @@
+from typing import Annotated
+
+from classiq.qmod.builtins.functions.standard_gates import H
+from classiq.qmod.builtins.operations import repeat
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QCallable
+
+
+@qfunc(external=True)
+def apply_to_all(
+    gate_operand: QCallable[Annotated[QBit, "target"]], target: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the single-qubit operand `gate_operand` to each qubit in the qubit
+    array `target`.
+
+    Args:
+        gate_operand: The single-qubit gate to apply to each qubit in the array.
+        target: The qubit array to apply the gate to.
+    """
+    repeat(target.len, lambda index: gate_operand(target[index]))
+
+
+@qfunc(external=True)
+def hadamard_transform(target: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies Hadamard transform to the target qubits.
+
+    Corresponds to the braket notation:
+
+    $$
+     H^{\\otimes n} |x\rangle = \frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^n - 1} (-1)^{x \\cdot y} |y\rangle
+    $$
+
+    Args:
+        target:  qubits to apply to Hadamard transform to.
+
+    """
+    apply_to_all(H, target)