classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/open_library/functions/grover.py

@@ -0,0 +1,157 @@
+from classiq.open_library.functions.utility_functions import hadamard_transform
+from classiq.qmod.builtins.functions.standard_gates import H, U, X
+from classiq.qmod.builtins.operations import (
+    allocate,
+    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, QNum
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import pi
+
+
+@qfunc
+def phase_oracle(
+    predicate: QCallable[QArray[QBit], QBit], target: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Creates a phase oracle operator based on a predicate function.
+
+    Applies a predicate function and marks "good" and "bad" states with a phase flip.
+    If the predicate is marked as $\\chi$, and the oracle is marked as $S_\\chi$, then:
+
+
+    $$
+    S_\\chi\\lvert x \rangle =
+    \begin{cases}
+    -\\lvert x \rangle & \text{if } \\chi(x) = 1 \\
+     \\phantom{-} \\lvert x \rangle & \text{if } \\chi(x) = 0
+    \\end{cases}
+    $$
+
+    Args:
+        predicate: A predicate function that takes a QArray of QBits and sets a single QBit |1> if the predicate is true, and |0> otherwise.
+        target: The target QArray of QBits to apply the phase oracle to.
+    """
+    aux = QBit("aux")
+    within_apply(
+        within=lambda: (allocate(1, aux), X(aux), H(aux)),  # type:ignore[arg-type]
+        apply=lambda: predicate(target, aux),
+    )
+
+
+@qfunc
+def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Reflects the state about the |0> state (i.e. applies a (-1) phase to all states
+    besides the |0> state). Implements the operator $S_0$:
+
+    $$
+    \begin{equation}
+    S_0|{x}\rangle = (-1)^{(x\ne0)}|{x}\rangle= (2|{0}\rangle\\langle{0}|-I)|{x}\rangle
+    \\end{equation}
+    $$
+
+    Args:
+        packed_vars: The quantum state to reflect.
+    """
+    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
+def grover_diffuser(
+    space_transform: QCallable[QArray[QBit]], packed_vars: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Reflects the given state about the A|0> state, where A
+    is the `space_transform` parameter. It is defined as:
+
+    $$
+    \begin{equation}
+    D = A S_0 A^{\\dagger}
+    \\end{equation}
+    $$
+
+    where $S_0$ is the reflection about the |0> state (see `reflect_about_zero`).
+
+    Args:
+        space_transform: The operator which encodes the axis of reflection.
+        packed_vars: The state to which to apply the diffuser.
+    """
+    within_apply(
+        lambda: invert(lambda: space_transform(packed_vars)),
+        lambda: reflect_about_zero(packed_vars),
+    )
+
+
+@qfunc
+def grover_operator(
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    packed_vars: QArray[QBit],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the grover operator, defined by:
+
+    $$
+    Q=S_{\\psi_0}S_{\\psi_1}
+    $$
+
+    where $S_{\\psi_1}$ is a reflection about marked states, and $S_{\\psi_0}$ is a reflection
+    about a given state defined by $|\\psi_0\rangle = A|0\rangle$.
+
+    Args:
+        oracle: A unitary operator which adds a phase of (-1) to marked states.
+        space_transform: The operator which creates $|\\psi_0\rangle$, the initial state, used by the diffuser to reflect about it.
+        packed_vars: The state to which to apply the grover operator.
+    """
+    oracle(packed_vars)
+    grover_diffuser(lambda qba: space_transform(qba), packed_vars)
+    U(0, 0, 0, pi, packed_vars[0])
+
+
+@qfunc
+def grover_search(
+    reps: CInt, oracle: QCallable[QArray[QBit]], packed_vars: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies Grover search algorithm.
+
+    Args:
+        reps: Number of repetitions of the grover operator.
+        oracle: An oracle that marks the solution.
+        packed_vars: Packed form of the variable to apply the grover operator on.
+
+    Returns: None
+    """
+    hadamard_transform(packed_vars)
+    power(
+        reps,
+        lambda: grover_operator(
+            lambda qba: oracle(qba),
+            lambda qba: hadamard_transform(qba),
+            packed_vars,
+        ),
+    )

classiq/open_library/functions/hea.py

@@ -0,0 +1,115 @@
+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
+def full_hea(
+    num_qubits: CInt,
+    is_parametrized: CArray[CInt],
+    angle_params: CArray[CReal],
+    connectivity_map: CArray[CArray[CInt]],
+    reps: CInt,
+    operands_1qubit: QCallableList[Annotated[CReal, "angle"], Annotated[QBit, "q"]],
+    operands_2qubit: QCallableList[
+        Annotated[CReal, "angle"], Annotated[QBit, "q1"], Annotated[QBit, "q2"]
+    ],
+    x: QArray[QBit, Literal["num_qubits"]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Implements an ansatz on a qubit array `x` with the given 1-qubit and 2-qubit operations.
+
+    The number of ansatz layers is given in argument `reps`.
+    Each layer applies the 1-qubit operands in `operands_1qubit` to all the qubits in `x`.
+    Next, it applies the 2-qubit operands in `operands_2qubit` to qubits (i, j) for each
+    pair of indices (i, j) in `connectivity_map`.
+
+    The list `is_parametrized` specifies whether the operands in `operands_1qubit` and
+    `operands_2qubit` are parametric (expect a classical argument).
+    `is_parametrized` is a list of flags (0 and 1 integers) of length
+    `len(operands_1qubit) + len(operands_2qubit)`.
+    The first `len(operands_1qubit)` flags refer to the `operands_1qubit` operands and
+    the next `len(operands_2qubit)` flags refer to the `operands_2qubit` operands.
+
+    The classical arguments to the parametric operands are given in argument
+    `angle_params`.
+    `angle_params` concatenates a set of arguments for each ansatz layer.
+    Each set contains an argument for each qubit in `x` times the number
+    of parametric operands in `operands_1qubit`.
+    These are followed by an argument for each mapping pair in `connectivity_map` times
+    the number of parametric operands in `operands_2qubit`.
+
+    Args:
+        num_qubits: The length of qubit array x
+        is_parametrized: A list of 0 and 1 flags
+        angle_params A list of arguments to gate
+        connectivity_map: A list of pairs of qubit indices
+        reps: The number of ansatz layers
+        operands_1qubit: A list of operations on a single qubit
+        operands_2qubit: A list of operations on two qubits
+        x: The quantum object to be transformed by the ansatz
+    """
+    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/open_library/functions/linear_pauli_rotation.py

@@ -0,0 +1,82 @@
+from typing import Annotated
+
+from classiq.open_library.functions.utility_functions import switch
+from classiq.qmod.builtins.enums import Pauli
+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
+from classiq.qmod.quantum_callable import QCallable
+
+
+@qfunc
+def _single_pauli(
+    slope: CReal,
+    offset: CReal,
+    q1_qfunc: QCallable[Annotated[CReal, "theta"], Annotated[QBit, "target"]],
+    x: QArray[QBit],
+    q: QBit,
+) -> None:
+    repeat(
+        x.len, lambda index: control(x[index], lambda: q1_qfunc(2**index * slope, q))
+    )
+    q1_qfunc(offset, q)
+
+
+@qfunc
+def linear_pauli_rotations(
+    bases: CArray[Pauli],
+    slopes: CArray[CReal],
+    offsets: CArray[CReal],
+    x: QArray[QBit],
+    q: QArray[QBit],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Performs a rotation on a series of $m$ target qubits,
+    where the rotation angle is a linear function of an $n$-qubit
+    control register.
+
+    Corresponds to the braket notation:
+
+    $$
+    \\left|x\right\rangle _{n}\\left|q\right\rangle
+    _{m}\rightarrow\\left|x\right\rangle
+    _{n}\\prod_{k=1}^{m}\\left(\\cos\\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)-
+    i\\sin\\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)P_{k}\right)\\left|q_{k}\right\rangle
+    $$
+
+    where $\\left|x\right\rangle$ is the control register,
+    $\\left|q\right\rangle$ is the target register, each $P_{k}$ is one of
+    the three Pauli matrices $X$, $Y$, or $Z$, and $a_{k}$, $b_{k}$ are
+    the user given slopes and offsets, respectively.
+
+    Args:
+        bases: List of Pauli Enums.
+        slopes: Rotation slopes for each of the given Pauli bases.
+        offsets:  Rotation offsets for each of the given Pauli bases.
+        x: Quantum state to apply the rotation based on its value.
+        q: List of indicator qubits for each of the given Pauli bases.
+
+    Notice that bases, slopes, offset and q should be of the same size.
+    """
+    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/open_library/functions/modular_exponentiation.py

@@ -0,0 +1,201 @@
+from classiq.open_library.functions.qft_functions import qft, qft_no_swap
+from classiq.qmod.builtins.classical_functions import qft_const_adder_phase
+from classiq.qmod.builtins.functions.standard_gates import PHASE, SWAP, X
+from classiq.qmod.builtins.operations import (
+    allocate,
+    bind,
+    control,
+    invert,
+    repeat,
+    within_apply,
+)
+from classiq.qmod.cparam import CInt
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.symbolic import min, mod_inverse
+
+
+@qfunc
+def _check_msb(ref: CInt, x: QArray[QBit], aux: QBit) -> None:
+    within_apply(
+        lambda: invert(lambda: qft_no_swap(x)), lambda: _ctrl_x(ref, x[0], aux)
+    )
+
+
+@qfunc
+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
+def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Adds a constant to a quantum number (in the Fourier space) using the Quantum Fourier Transform (QFT) Adder algorithm.
+    Assuming that the input `phi_b` has `n` qubits, the result will be $\\phi_b+=value \\mod 2^n$.
+
+    To perform the full algorithm, use:
+    within_apply(lambda: QFT(phi_b), qft_space_add_const(value, phi_b))
+
+    Args:
+        value: The constant to add to the quantum number.
+        phi_b: The quantum number (at the aft space) to which the constant is added.
+
+    """
+    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
+def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Adds a constant `a` to a quantum number `phi_b` modulo the constant `n`, controlled by 2 qubits.
+    The quantum number `phi_b` and the constant `a` are assumed to be in the QFT space.
+
+    Args:
+        n: The modulo number.
+        a: The constant to add to the quantum number.
+        phi_b: The quantum number to which the constant is added.
+        c1: a control qubit.
+        c2: a control qubit.
+
+    """
+    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
+def c_modular_multiply(
+    n: CInt, a: CInt, b: QArray[QBit], x: QArray[QBit], ctrl: QBit
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Performs out-of-place multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
+    controlled by a quantum bit `ctrl` and adds the result to a quantum array `b`. Applies $b += xa \\mod n$ if `ctrl=1`, and the identity otherwise.
+
+    Args:
+        n: The modulo number. Should be non-negative.
+        a: The classical factor. Should be non-negative.
+        b: The quantum number added to the multiplication result. Stores the result of the multiplication.
+        x: The quantum factor.
+        ctrl: The control bit.
+    """
+    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
+def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Swaps the qubit states between two arrays.
+    Qubits of respective indices are swapped, and additional qubits in the longer array are left unchanged.
+
+    Args:
+        x: The first array
+        y: The second array
+
+    """
+    repeat(
+        count=min(x.len, y.len),
+        iteration=lambda index: SWAP(x[index], y[index]),
+    )
+
+
+@qfunc
+def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Performs multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
+    controlled by a quantum bit `ctrl`. Applies $x=xa \\mod n$ if `ctrl=1`, and the identity otherwise.
+
+    Args:
+        n: The modulo number. Should be non-negative.
+        a: The classical factor. Should be non-negative.
+        x: The quantum factor.
+        ctrl: The control bit.
+    """
+    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
+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 `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: 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.
+    """
+    repeat(
+        count=power.len,
+        iteration=lambda index: inplace_c_modular_multiply(
+            n, (a ** (2**index)) % n, x, power[index]
+        ),
+    )

classiq/open_library/functions/qaoa_penalty.py

@@ -0,0 +1,117 @@
+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
+from classiq.qmod.qmod_variable import QArray, QBit
+
+
+@qfunc
+def qaoa_mixer_layer(b: CReal, target: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the mixer layer for the QAOA algorithm.
+    The mixer layer is a sequence of `X` gates applied to each qubit in the target quantum
+    array variable.
+
+    Args:
+        b: The rotation parameter for the mixer layer.
+        target: The target quantum array.
+    """
+    repeat(target.len, lambda index: RX(b, target[index]))
+
+
+@qfunc
+def qaoa_cost_layer(
+    g: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the cost layer to the QAOA model.
+
+    This function integrates the problem-specific cost function into the QAOA model's objective function.
+    The cost layer represents the primary objective that the QAOA algorithm seeks to optimize, such as
+    minimizing energy or maximizing profit, depending on the application.
+
+    Args:
+        g: The rotation parameter for the cost layer (prefactor).
+        hamiltonian: The Hamiltonian terms for the QAOA model.
+        target: The target quantum array variable.
+    """
+    suzuki_trotter(hamiltonian, g, 1, 1, target)
+
+
+@qfunc
+def qaoa_layer(
+    g: CReal, b: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the QAOA layer, which concatenates the cost layer and the mixer layer.
+
+    The `qaoa_layer` function integrates both the cost and mixer layers, essential components of the
+    Quantum Approximate Optimization Algorithm (QAOA). The cost layer encodes the problem's objective,
+    while the mixer layer introduces quantum superposition and drives the search across the solution space.
+
+    Args:
+           g: The rotation parameter for the cost layer.
+           b: The rotation parameter for the mixer layer.
+           hamiltonian: The Hamiltonian terms for the QAOA model.
+           target: The target quantum array variable.
+
+    """
+    qaoa_cost_layer(g, hamiltonian, target)
+    qaoa_mixer_layer(b, target)
+
+
+@qfunc
+def qaoa_init(target: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Initializes the QAOA circuit by applying the Hadamard gate to all qubits.
+
+    In the Quantum Approximate Optimization Algorithm (QAOA), the initial state is a uniform superposition
+    created by applying the Hadamard gate to each qubit. This function prepares the qubits for the subsequent
+    application of the cost and mixer layers by preparing them in an equal superposition state.
+
+    Args:
+           target: The target quantum array variable.
+    """
+    repeat(target.len, lambda index: H(target[index]))
+
+
+@qfunc
+def qaoa_penalty(
+    num_qubits: CInt,
+    params_list: CArray[CReal],
+    hamiltonian: CArray[PauliTerm],
+    target: QArray[QBit, Literal["num_qubits"]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the penalty layer to the QAOA model.
+
+    This function adds a penalty term to the objective function of the QAOA model to
+    enforce certain constraints (e.g., binary or integer variables) during the
+    optimization process.
+
+    Args:
+        num_qubits: The number of qubits in the quantum circuit.
+        params_list The list of QAOA parameters.
+        hamiltonian: The Hamiltonian terms for the QAOA model.
+        target: The target quantum array variable.
+    """
+    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
+        ),
+    )