classiq 0.45.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

classiq/qmod/builtins/enums.py

@@ -1,7 +1,7 @@
-# This file was generated automatically - do not edit manually
-
 from enum import IntEnum
 
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+
 
 class Element(IntEnum):
     H = 0
@@ -152,10 +152,28 @@ class Optimizer(IntEnum):
 
 
 class Pauli(IntEnum):
+    """
+    Enumeration for the Pauli matrices used in quantum computing.
+
+    The Pauli matrices are fundamental operations in quantum computing, and this
+    enum assigns integer values to represent each matrix.
+    """
+
     I = 0  # noqa: E741
+    """I (int): Identity matrix, represented by the integer 0. \n
+    $I = \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$"""
+
     X = 1
+    """X (int): Pauli-X matrix, represented by the integer 1. \n
+    $X = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}$"""
+
     Y = 2
+    """Y (int): Pauli-Y matrix, represented by the integer 2. \n
+    $Y = \\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}$"""
+
     Z = 3
+    """Z (int): Pauli-Z matrix, represented by the integer 3. \n
+    $Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$"""
 
 
 class QSVMFeatureMapEntanglement(IntEnum):
@@ -166,6 +184,19 @@ class QSVMFeatureMapEntanglement(IntEnum):
     PAIRWISE = 4
 
 
+BUILTIN_ENUM_DECLARATIONS = {
+    enum_def.__name__: EnumDeclaration(
+        name=enum_def.__name__,
+        members={enum_val.name: enum_val.value for enum_val in enum_def},
+    )
+    for enum_def in vars().values()
+    if (
+        isinstance(enum_def, type)
+        and issubclass(enum_def, IntEnum)
+        and enum_def is not IntEnum
+    )
+}
+
 __all__ = [
     "Element",
     "FermionMapping",

classiq/qmod/builtins/functions/__init__.py

@@ -0,0 +1,251 @@
+from .amplitude_estimation import *
+from .arithmetic import *
+from .benchmarking import *
+from .chemistry import *
+from .discrete_sine_cosine_transform import *
+from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
+from .exponentiation import *
+from .finance import *
+from .grover import *
+from .hea import *
+from .linear_pauli_rotation import *
+from .linear_pauli_rotation import _single_pauli
+from .modular_exponentiation import *
+from .modular_exponentiation import _check_msb, _ctrl_x
+from .operators import *
+from .qaoa_penalty import *
+from .qft import *
+from .qpe import *
+from .qsvm import *
+from .qsvt import *
+from .standard_gates import *
+from .state_preparation import *
+from .state_preparation import _prepare_uniform_trimmed_state_step
+from .swap_test import *
+
+CORE_LIB_DECLS = [
+    func.func_decl
+    for func in (
+        molecule_ucc,
+        molecule_hva,
+        molecule_hartree_fock,
+        fock_hamiltonian_ucc,
+        fock_hamiltonian_hva,
+        fock_hamiltonian_hartree_fock,
+        log_normal_finance,
+        gaussian_finance,
+        pauli_feature_map,
+        bloch_sphere_feature_map,
+        H,
+        X,
+        Y,
+        Z,
+        I,
+        S,
+        T,
+        SDG,
+        TDG,
+        PHASE,
+        RX,
+        RY,
+        RZ,
+        R,
+        RXX,
+        RYY,
+        RZZ,
+        CH,
+        CX,
+        CY,
+        CZ,
+        CRX,
+        CRY,
+        CRZ,
+        CPHASE,
+        SWAP,
+        IDENTITY,
+        prepare_state,
+        prepare_amplitudes,
+        unitary,
+        add,
+        modular_add,
+        integer_xor,
+        U,
+        CCX,
+        allocate,
+        free,
+        randomized_benchmarking,
+        inplace_prepare_state,
+        inplace_prepare_amplitudes,
+        single_pauli_exponent,
+        suzuki_trotter,
+        qdrift,
+        exponentiation_with_depth_constraint,
+    )
+]
+
+OPEN_LIB_DECLS = [
+    func.func_decl
+    for func in (
+        qpe_flexible,
+        qpe,
+        _single_pauli,
+        linear_pauli_rotations,
+        amplitude_estimation,
+        phase_oracle,
+        reflect_about_zero,
+        grover_diffuser,
+        grover_operator,
+        grover_search,
+        hadamard_transform,
+        apply_to_all,
+        qft_no_swap,
+        qft_space_add_const,
+        cc_modular_add,
+        c_modular_multiply,
+        multiswap,
+        inplace_c_modular_multiply,
+        modular_exp,
+        qsvt_step,
+        qsvt,
+        projector_controlled_phase,
+        qsvt_inversion,
+        allocate_num,
+        qaoa_mixer_layer,
+        qaoa_cost_layer,
+        qaoa_layer,
+        qaoa_init,
+        qaoa_penalty,
+        full_hea,
+        swap_test,
+        prepare_uniform_trimmed_state,
+        prepare_uniform_interval_state,
+        prepare_ghz_state,
+        prepare_exponential_state,
+        prepare_bell_state,
+        inplace_prepare_int,
+        prepare_int,
+        switch,
+        qct_qst_type1,
+        qct_qst_type2,
+        qct_type2,
+        qst_type2,
+        modular_increment,
+        qft,
+        _ctrl_x,
+        _prepare_uniform_trimmed_state_step,
+        _qct_d_operator,
+        _qct_pi_operator,
+        _check_msb,
+    )
+]
+
+STD_QMOD_OPERATORS = [func.func_decl for func in (apply, permute)]
+
+BUILTIN_FUNCTION_DECLARATIONS = {
+    func_decl.name: func_decl
+    for func_decl in STD_QMOD_OPERATORS + OPEN_LIB_DECLS + CORE_LIB_DECLS
+}
+
+__all__ = [
+    "permute",
+    "apply",
+    "molecule_ucc",
+    "molecule_hva",
+    "molecule_hartree_fock",
+    "fock_hamiltonian_ucc",
+    "fock_hamiltonian_hva",
+    "fock_hamiltonian_hartree_fock",
+    "log_normal_finance",
+    "gaussian_finance",
+    "pauli_feature_map",
+    "bloch_sphere_feature_map",
+    "H",
+    "X",
+    "Y",
+    "Z",
+    "I",
+    "S",
+    "T",
+    "SDG",
+    "TDG",
+    "PHASE",
+    "RX",
+    "RY",
+    "RZ",
+    "R",
+    "RXX",
+    "RYY",
+    "RZZ",
+    "CH",
+    "CX",
+    "CY",
+    "CZ",
+    "CRX",
+    "CRY",
+    "CRZ",
+    "CPHASE",
+    "SWAP",
+    "IDENTITY",
+    "prepare_state",
+    "prepare_amplitudes",
+    "unitary",
+    "add",
+    "modular_add",
+    "integer_xor",
+    "U",
+    "CCX",
+    "allocate",
+    "free",
+    "randomized_benchmarking",
+    "inplace_prepare_state",
+    "inplace_prepare_amplitudes",
+    "single_pauli_exponent",
+    "suzuki_trotter",
+    "qdrift",
+    "exponentiation_with_depth_constraint",
+    "qpe_flexible",
+    "qpe",
+    "_single_pauli",
+    "linear_pauli_rotations",
+    "amplitude_estimation",
+    "phase_oracle",
+    "reflect_about_zero",
+    "grover_diffuser",
+    "grover_operator",
+    "grover_search",
+    "hadamard_transform",
+    "apply_to_all",
+    "qft_no_swap",
+    "qft_space_add_const",
+    "cc_modular_add",
+    "c_modular_multiply",
+    "multiswap",
+    "inplace_c_modular_multiply",
+    "modular_exp",
+    "qsvt_step",
+    "qsvt",
+    "projector_controlled_phase",
+    "qsvt_inversion",
+    "allocate_num",
+    "qaoa_mixer_layer",
+    "qaoa_cost_layer",
+    "qaoa_layer",
+    "qaoa_init",
+    "qaoa_penalty",
+    "full_hea",
+    "swap_test",
+    "prepare_uniform_trimmed_state",
+    "prepare_uniform_interval_state",
+    "prepare_ghz_state",
+    "prepare_exponential_state",
+    "prepare_bell_state",
+    "inplace_prepare_int",
+    "prepare_int",
+    "switch",
+    "qct_qst_type1",
+    "qct_qst_type2",
+    "qct_type2",
+    "qst_type2",
+    "modular_increment",
+    "qft",
+]

classiq/qmod/builtins/functions/amplitude_estimation.py

@@ -0,0 +1,26 @@
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.quantum_callable import QCallable
+
+
+@qfunc(external=True)
+def amplitude_estimation(
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    phase: QNum,
+    packed_vars: QArray[QBit],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+    Amplitude estimation function is used to estimate the probability of a state being marked by the operand `oracle` as a "good state."
+
+    The algorithm prepares the state in the `packed_vars` register and estimates the probability of this state being marked by the oracle as a "good state."
+    This is done using the Quantum Phase Estimation (QPE) algorithm, where the unitary for QPE is the Grover operator, which is composed of the `oracle` and `space_transform` operators.
+
+    Args:
+        oracle: The oracle operator that marks the "good" state. This operator should flip the sign of the amplitude of the "good" state.
+        space_transform: The space transform operator (which is known also the state preparation operator), which is first applied to prepare the state before the QPE, and then used inside the Grover operator.
+        phase: Assuming this variable starts from the zero state -this variable output holds the $phase=\\theta$ result in the [0,1] domain, which relates to the estimated probability $a$ through $a=\\sin^2(\\pi \\theta)$.
+        packed_vars: The variable that holds the state to be estimated. Assumed to be in the zero state at the beginning of the algorithm.
+    """
+    pass

classiq/qmod/builtins/functions/arithmetic.py

@@ -0,0 +1,68 @@
+from typing import Literal
+
+from classiq.qmod.cparam import CInt
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CReal
+from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
+
+
+@qfunc(external=True)
+def unitary(
+    elements: CArray[CArray[CReal]],
+    target: QArray[QBit, Literal["log(get_field(elements[0], 'len'), 2)"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Apply a unitary matrix on a quantum state.
+
+    Args:
+        elements:  A 2d array of complex numbers representing the unitary matrix. This matrix must be unitary.
+        target: The quantum state to apply the unitary on. Should be of corresponding size.
+
+    Links: [Reference Manual](https://docs.classiq.io/qmod/builtins/functions/standard_gates/unitary)
+    """
+    pass
+
+
+@qfunc(external=True)
+def add(
+    left: QArray[QBit],
+    right: QArray[QBit],
+    result: Output[
+        QArray[
+            QBit, Literal["Max(get_field(left, 'len'), get_field(right, 'len')) + 1"]
+        ]
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def modular_add(left: QArray[QBit], right: QArray[QBit]) -> None:
+    pass
+
+
+@qfunc(external=True)
+def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
+    pass
+
+
+@qfunc(external=True)
+def modular_increment(a: CInt, x: QNum) -> None:
+    """
+    Qmod Classiq-library function.
+
+    Adds $a$ to $x$ modulo the range of $x$, assumed that $x$ is a non-negative integer and $a$ is an integer.
+    Mathematically it is described as:
+
+    $$
+        x = (x+a)\\ \\mod \\ 2^{x.size}-1
+    $$
+
+    Args:
+        a: A classical integer to be added to x.
+        x: A quantum number that is assumed to be non-negative integer.
+
+    """
+    pass

classiq/qmod/builtins/functions/benchmarking.py

@@ -0,0 +1,8 @@
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CInt
+from classiq.qmod.qmod_variable import QArray, QBit
+
+
+@qfunc(external=True)
+def randomized_benchmarking(num_of_cliffords: CInt, target: QArray[QBit]) -> None:
+    pass

classiq/qmod/builtins/functions/chemistry.py

@@ -0,0 +1,91 @@
+from typing import Literal
+
+from classiq.qmod.builtins.structs import (
+    FockHamiltonianProblem,
+    MoleculeProblem,
+)
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CInt
+from classiq.qmod.qmod_variable import QArray, QBit
+
+
+@qfunc(external=True)
+def molecule_ucc(
+    molecule_problem: MoleculeProblem,
+    excitations: CArray[CInt],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def molecule_hva(
+    molecule_problem: MoleculeProblem,
+    reps: CInt,
+    qbv: QArray[
+        QBit,
+        Literal[
+            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def molecule_hartree_fock(
+    molecule_problem: MoleculeProblem,
+    qbv: QArray[
+        QBit,
+        Literal[
+            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_ucc(
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    excitations: CArray[CInt],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_hva(
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    reps: CInt,
+    qbv: QArray[
+        QBit,
+        Literal[
+            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_hartree_fock(
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    qbv: QArray[
+        QBit,
+        Literal[
+            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
+        ],
+    ],
+) -> None:
+    pass

classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py

@@ -0,0 +1,105 @@
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+
+
+@qfunc(external=True)
+def _qct_d_operator(x: QNum, q: QBit) -> None:
+    pass
+
+
+@qfunc(external=True)
+def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qct_qst_type1(x: QArray[QBit]) -> None:
+    r"""
+    Qmod Classiq-library function.
+
+    Applies the quantum discrete cosine (DCT) and sine (DST)
+    transform of type 1 to the qubit array `x`.
+    Corresponds to the matrix (with $n\equiv$`x.len`):
+
+    $$
+    \left(
+    \begin{array}{ccc|c}
+    {} &{} &{} \\
+      {}&{\rm DCT}^{(1)}(2^{n-1}+1) & {}& 0\\
+      {} &{} &{} \\
+      \hline
+      {} & 0 & {} & i{\rm DST}^{(1)}(2^{n-1}-1)
+    \end{array}
+    \right)
+    $$
+
+    Args:
+        x: The qubit array to apply the transform to.
+
+    Links:
+        - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
+    """
+    pass
+
+
+@qfunc(external=True)
+def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
+    r"""
+    Qmod Classiq-library function.
+
+    Applies the quantum discrete cosine (DCT) and sine (DST)
+    transform of type 2 to the qubit array `x` concatenated with `q`, with `q` being the MSB.
+    Corresponds to the matrix (with $n\equiv$`x.len`+1):
+
+    $$
+    \left(
+    \begin{array}{c|c}
+      {\rm DCT}^{(2)}(2^{n-1}) & 0\\
+      \hline
+      0 & -{\rm DST}^{(2)}(2^{n-1})
+    \end{array}
+    \right)
+    $$
+
+    Args:
+        x: The LSB part of the qubit array to apply the transform to.
+        q: The MSB of the qubit array to apply the transform to.
+
+    Links:
+        - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
+    """
+    pass
+
+
+@qfunc(external=True)
+def qct_type2(x: QArray[QBit]) -> None:
+    r"""
+    Qmod Classiq-library function.
+
+    Applies the quantum discrete cosine (DCT)
+    transform of type 2, ${\rm DCT}^{(2)}$, to the qubit array `x`.
+
+    Args:
+        x: The qubit array to apply the transform to.
+
+    Links:
+        - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
+    """
+    pass
+
+
+@qfunc(external=True)
+def qst_type2(x: QArray[QBit]) -> None:
+    r"""
+    Qmod Classiq-library function.
+
+    Applies the quantum discrete sine (DST)
+    transform of type 2, ${\rm DST}^{(2)}$, to the qubit array `x`.
+
+    Args:
+        x: The qubit array to apply the transform to.
+
+    Links:
+        - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
+    """
+    pass