classiq 0.45.1__py3-none-any.whl → 0.46.1__py3-none-any.whl

classiq/qmod/builtins/functions/exponentiation.py

@@ -0,0 +1,111 @@
+from typing import Literal
+
+from classiq.qmod.builtins.enums import Pauli
+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(external=True)
+def single_pauli_exponent(
+    pauli_string: CArray[Pauli],
+    coefficient: CReal,
+    qbv: QArray[QBit, Literal["get_field(pauli_string, 'len')"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Exponentiates the specified single Pauli operator multiplied by some coefficient.
+
+    Args:
+        pauli_string: The Pauli operator to be exponentiated.
+        coefficient: A coefficient multiplying the Pauli operator.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
+@qfunc(external=True)
+def suzuki_trotter(
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray[
+        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
+    ],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Applies the Suzuki-Trotter decomposition to a Pauli operator. The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    The Suzuki-Trotter decomposition of a given order nullifies the error of the Taylor series expansion of the product of exponentials up to that order.
+    The error of a Suzuki-Trotter decomposition decreases as the order and number of repetitions increase.
+
+    See [N. Hatano and M. Suzuki, Finding Exponential Product Formulas of Higher Orders (2005)](https://arxiv.org/abs/math-ph/0506007).
+
+    Args:
+        pauli_operator: The Pauli operator to be exponentiated.
+        evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
+        order: The order of the Suzuki-Trotter decomposition.
+        repetitions: The number of repetitions of the Suzuki-Trotter decomposition.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
+@qfunc(external=True)
+def qdrift(
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    num_qdrift: CInt,
+    qbv: QArray[
+        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
+    ],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Exponentiates a Pauli operator using the QDrift method. The QDrift method is a stochastic method based on the Trotter decomposition for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    The QDrift method randomizes the order of the operators in the product of exponentials to stochastically reduce the error of the approximation.
+    The error of the QDrift method decreases as the number of QDrift steps increases.
+
+    See [E. Campbell, Random Compiler for Fast Hamiltonian Simulation (2019)](https://arxiv.org/abs/1811.08017).
+
+    Args:
+        pauli_operator: The Pauli operator to be exponentiated.
+        evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
+        num_qdrift : The number of QDrift steps.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
+@qfunc(external=True)
+def exponentiation_with_depth_constraint(
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    max_depth: CInt,
+    qbv: QArray[
+        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
+    ],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Exponentiates a Pauli operator via the Suzuki-Trotter decomposition with a depth constraint.
+    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    This function automatically determines the order and number of repetitions of the Suzuki-Trotter decomposition to minimize the error given a depth constraint.
+
+    See [A. M. Childs et al., Toward the first quantum simulation with quantum speedup (2017)](https://arxiv.org/abs/1711.10980).
+
+    Args:
+        pauli_operator: The Pauli operator to be exponentiated.
+        evolution_coefficient: A global coefficient multiplying the Pauli operator.
+        max_depth: The maximum depth of the exponentiation.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass

classiq/qmod/builtins/functions/finance.py

@@ -0,0 +1,34 @@
+from typing import Literal
+
+from classiq.qmod.builtins.structs import (
+    FinanceFunction,
+    GaussianModel,
+    LogNormalModel,
+)
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit
+
+
+@qfunc(external=True)
+def log_normal_finance(
+    finance_model: LogNormalModel,
+    finance_function: FinanceFunction,
+    func_port: QArray[QBit, Literal["get_field(finance_model, 'num_qubits')"]],
+    obj_port: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def gaussian_finance(
+    finance_model: GaussianModel,
+    finance_function: FinanceFunction,
+    func_port: QArray[
+        QBit,
+        Literal[
+            "get_field(finance_model, 'num_qubits') + get_field(get_field(finance_model, 'rhos'), 'len') + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1"
+        ],
+    ],
+    obj_port: QBit,
+) -> None:
+    pass

classiq/qmod/builtins/functions/grover.py

@@ -0,0 +1,178 @@
+from typing_extensions import Annotated
+
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CInt
+from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.quantum_callable import QCallable
+
+
+@qfunc(external=True)
+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.
+
+    Usage Examples:
+        [Grover Algorithm](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator/)
+
+        [Hidden shift](https://docs.classiq.io/latest/explore/algorithms/algebraic/hidden_shift/hidden_shift/)
+    """
+    pass
+
+
+@qfunc(external=True)
+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.
+    """
+    pass
+
+
+@qfunc(external=True)
+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.
+    """
+    pass
+
+
+@qfunc(external=True)
+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.
+
+
+    For further reading, see:
+
+    - [The Grover Operator notebook](../explore/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator/)
+    - [Wikipedia page](https://en.wikipedia.org/wiki/Grover%27s_algorithm).
+
+    """
+    pass
+
+
+@qfunc(external=True)
+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
+
+    Links:
+         [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

classiq/qmod/builtins/functions/hea.py

@@ -0,0 +1,59 @@
+from typing import Literal
+
+from typing_extensions import Annotated
+
+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
+
+
+@qfunc(external=True)
+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
+    """
+    pass

classiq/qmod/builtins/functions/linear_pauli_rotation.py

@@ -0,0 +1,65 @@
+from typing_extensions import Annotated
+
+from classiq.qmod.builtins.enums import Pauli
+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(external=True)
+def _single_pauli(
+    slope: CReal,
+    offset: CReal,
+    q1_qfunc: QCallable[Annotated[CReal, "theta"], Annotated[QBit, "target"]],
+    x: QArray[QBit],
+    q: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+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.
+
+
+
+    Links:
+       [linear_pauli_rotations](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations)
+    """
+
+    pass

classiq/qmod/builtins/functions/modular_exponentiation.py

@@ -0,0 +1,137 @@
+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
+
+
+@qfunc(external=True)
+def _check_msb(ref: CInt, x: QArray[QBit], aux: QBit) -> None:
+    pass
+
+
+@qfunc(external=True)
+def _ctrl_x(ref: CInt, ctrl: QNum, aux: QBit) -> None:
+    pass
+
+
+@qfunc(external=True)
+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.
+
+    """
+    pass
+
+
+@qfunc(external=True)
+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.
+
+    """
+    pass
+
+
+@qfunc(external=True)
+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.
+    """
+    pass
+
+
+@qfunc(external=True)
+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
+
+    """
+    pass
+
+
+@qfunc(external=True)
+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.
+    """
+    pass
+
+
+@qfunc(external=True)
+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$).
+
+    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.
+
+    """
+    pass

classiq/qmod/builtins/functions/operators.py

@@ -0,0 +1,22 @@
+from classiq.qmod.cparam import CInt
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.quantum_callable import QCallable, QCallableList
+
+
+@qfunc(external=True)
+def permute(
+    functions: QCallableList,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def apply(
+    operand: QCallable,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def switch(selector: CInt, cases: QCallableList) -> None:
+    pass