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

classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py

@@ -1,15 +1,85 @@
+from classiq.qmod.builtins.functions.arithmetic import modular_increment
+from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.functions.utility_functions import apply_to_all
+from classiq.qmod.builtins.operations import bind, control, invert, repeat, within_apply
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.symbolic import pi
+
+
+def _b_operator(q: QBit) -> None:
+    S(q)
+    H(q)
 
 
 @qfunc(external=True)
 def _qct_d_operator(x: QNum, q: QBit) -> None:
-    pass
+    _b_operator(q)
+    control(x == 0, lambda: invert(lambda: _b_operator(q)))
 
 
 @qfunc(external=True)
 def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
-    pass
+    control(q == 1, lambda: apply_to_all(X, x))
+    control(q == 1, lambda: modular_increment(1, x))
+
+
+def _t_operator(x: QArray) -> None:
+    _qct_d_operator(x[0 : x.len - 1], x[x.len - 1])
+    _qct_pi_operator(x[0 : x.len - 1], x[x.len - 1])
+
+
+def _vn_operator(x: QArray[QBit], q: QBit) -> None:
+    H(q)
+    control(q == 1, lambda: apply_to_all(X, x))
+
+
+def _d1_operator(x: QArray[QBit], q: QBit) -> None:
+    omega_exp = 2 * pi / (4 * 2**x.len)
+
+    # Li
+    control(q == 0, lambda: repeat(x.len, lambda k: PHASE(omega_exp * (2**k), x[k])))
+    # Ki
+    control(
+        q == 1,
+        lambda: repeat(
+            x.len,
+            lambda k: within_apply(
+                lambda: X(x[k]), lambda: PHASE(-omega_exp * (2**k), x[k])
+            ),
+        ),
+    )
+    PHASE(-omega_exp, q)
+
+
+def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
+    control(q == 1, lambda: modular_increment(1, x))
+
+
+def _j_operator(q: QBit) -> None:
+    within_apply(lambda: Z(q), lambda: (S(q), H(q), S(q)))  # type:ignore[arg-type]
+
+
+def _b_t_operator(q: QBit) -> None:
+    H(q)
+    S(q)
+
+
+def _d0dt_operator(x: QArray, q: QBit) -> None:
+    x_num: QNum = QNum("x_num", x.len, False, 0)
+    bind(x, x_num)
+    _b_t_operator(q)
+    control(x_num == 0, lambda: _j_operator(q))
+    bind(x_num, x)
+
+
+def _un_dag_operator(x: QArray[QBit], q: QBit) -> None:
+    _d1_operator(x, q)
+    invert(lambda: _qct_pi_operator(x, q))
+    _d0dt_operator(x, q)
+    invert(lambda: _pi2_operator(x, q))
 
 
 @qfunc(external=True)
@@ -39,7 +109,7 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    within_apply(lambda: _t_operator(x), lambda: qft(x))
 
 
 @qfunc(external=True)
@@ -68,7 +138,12 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    extended_state: QArray = QArray("extended_state")
+    _vn_operator(x, q)
+    bind([x, q], extended_state)
+    qft(extended_state)
+    bind(extended_state, [x, q])
+    _un_dag_operator(x, q)
 
 
 @qfunc(external=True)
@@ -85,7 +160,8 @@ def qct_type2(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    q = QBit("q")
+    within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
 
 
 @qfunc(external=True)
@@ -102,4 +178,8 @@ def qst_type2(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    q = QBit("q")
+    within_apply(
+        lambda: (allocate(1, q), X(q)),  # type:ignore[arg-type]
+        lambda: qct_qst_type2(x, q),
+    )

classiq/qmod/builtins/functions/grover.py

@@ -1,9 +1,18 @@
-from typing_extensions import Annotated
-
+from classiq.qmod.builtins.functions.standard_gates import H, U, X
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.functions.utility_functions import hadamard_transform
+from classiq.qmod.builtins.operations import (
+    bind,
+    control,
+    invert,
+    power,
+    within_apply,
+)
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CInt
-from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import pi
 
 
 @qfunc(external=True)
@@ -36,7 +45,11 @@ def phase_oracle(
 
         [Hidden shift](https://docs.classiq.io/latest/explore/algorithms/algebraic/hidden_shift/hidden_shift/)
     """
-    pass
+    aux = QBit("aux")
+    within_apply(
+        within=lambda: (allocate(1, aux), X(aux), H(aux)),  # type:ignore[arg-type]
+        apply=lambda: predicate(target, aux),
+    )
 
 
 @qfunc(external=True)
@@ -56,7 +69,14 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     Args:
         packed_vars: The quantum state to reflect.
     """
-    pass
+    msbs: QNum = QNum("msbs", packed_vars.len - 1, False, 0)
+    lsb = QBit("lsb")
+    bind(packed_vars, [msbs, lsb])
+    within_apply(
+        lambda: (X(lsb), H(lsb)),  # type:ignore[arg-type]
+        lambda: control(msbs == 0, lambda: X(lsb)),
+    )
+    bind([msbs, lsb], packed_vars)
 
 
 @qfunc(external=True)
@@ -81,7 +101,10 @@ def grover_diffuser(
         space_transform: The operator which encodes the axis of reflection.
         packed_vars: The state to which to apply the diffuser.
     """
-    pass
+    within_apply(
+        lambda: invert(lambda: space_transform(packed_vars)),
+        lambda: reflect_about_zero(packed_vars),
+    )
 
 
 @qfunc(external=True)
@@ -115,7 +138,9 @@ def grover_operator(
     - [Wikipedia page](https://en.wikipedia.org/wiki/Grover%27s_algorithm).
 
     """
-    pass
+    oracle(packed_vars)
+    grover_diffuser(lambda qba: space_transform(qba), packed_vars)
+    U(0, 0, 0, pi, packed_vars[0])
 
 
 @qfunc(external=True)
@@ -138,41 +163,12 @@ def grover_search(
          [Grover Algorithm](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator/)
 
     """
-    pass
-
-
-@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.
-
-    """
-    pass
-
-
-@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.
-    """
-    pass
+    hadamard_transform(packed_vars)
+    power(
+        reps,
+        lambda: grover_operator(
+            lambda qba: oracle(qba),
+            lambda qba: hadamard_transform(qba),
+            packed_vars,
+        ),
+    )

classiq/qmod/builtins/functions/hea.py

@@ -1,11 +1,11 @@
-from typing import Literal
-
-from typing_extensions import Annotated
+from typing import Annotated, Literal
 
+from classiq.qmod.builtins.operations import if_, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CInt, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.symbolic import floor, sum
 
 
 @qfunc(external=True)
@@ -56,4 +56,60 @@ def full_hea(
         operands_2qubit: A list of operations on two qubits
         x: The quantum object to be transformed by the ansatz
     """
-    pass
+    repeat(
+        reps,
+        lambda r: [  # type:ignore[arg-type]
+            repeat(  # type:ignore[func-returns-value]
+                operands_1qubit.len,
+                lambda i1: repeat(
+                    num_qubits,
+                    lambda index: if_(
+                        condition=is_parametrized[i1] == 1,
+                        then=lambda: operands_1qubit[i1](
+                            angle_params[
+                                sum(is_parametrized[0:i1])  # type:ignore[index]
+                                + floor((angle_params.len / reps) * r)
+                                + index
+                            ],
+                            x[index],
+                        ),
+                        else_=lambda: operands_1qubit[i1](0, x[index]),
+                    ),
+                ),
+            ),
+            repeat(  # type:ignore[func-returns-value]
+                operands_2qubit.len,
+                lambda i2: repeat(
+                    connectivity_map.len,
+                    lambda index: if_(
+                        condition=is_parametrized[operands_1qubit.len + i2] == 1,
+                        then=lambda: operands_2qubit[i2](
+                            angle_params[
+                                num_qubits
+                                * sum(
+                                    is_parametrized[
+                                        0 : operands_1qubit.len
+                                    ]  # type:ignore[index]
+                                )
+                                + connectivity_map.len
+                                * sum(
+                                    is_parametrized[
+                                        operands_1qubit.len : operands_1qubit.len + i2
+                                    ]
+                                )
+                                + floor((angle_params.len / reps) * r)
+                                + index
+                            ],
+                            x[connectivity_map[index][0]],
+                            x[connectivity_map[index][1]],
+                        ),
+                        else_=lambda: operands_2qubit[i2](
+                            0,
+                            x[connectivity_map[index][0]],
+                            x[connectivity_map[index][1]],
+                        ),
+                    ),
+                ),
+            ),
+        ],
+    )

classiq/qmod/builtins/functions/linear_pauli_rotation.py

@@ -1,6 +1,9 @@
-from typing_extensions import Annotated
+from typing import Annotated
 
 from classiq.qmod.builtins.enums import Pauli
+from classiq.qmod.builtins.functions.operators import switch
+from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RX, RY, RZ
+from classiq.qmod.builtins.operations import control, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
@@ -15,7 +18,10 @@ def _single_pauli(
     x: QArray[QBit],
     q: QBit,
 ) -> None:
-    pass
+    repeat(
+        x.len, lambda index: control(x[index], lambda: q1_qfunc(2**index * slope, q))
+    )
+    q1_qfunc(offset, q)
 
 
 @qfunc(external=True)
@@ -61,5 +67,21 @@ def linear_pauli_rotations(
     Links:
        [linear_pauli_rotations](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations)
     """
-
-    pass
+    repeat(
+        q.len,
+        lambda index: _single_pauli(
+            slope=slopes[index],
+            offset=offsets[index],
+            q1_qfunc=lambda theta, target: switch(
+                bases[index],
+                [
+                    lambda: IDENTITY(target),
+                    lambda: RX(theta, target),
+                    lambda: RY(theta, target),
+                    lambda: RZ(theta, target),
+                ],
+            ),
+            x=x,
+            q=q[index],
+        ),
+    )

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)