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

classiq/qmod/builtins/classical_functions.py

@@ -1,78 +1,74 @@
 # This file was generated automatically - do not edit manually
 
-from typing import List
 
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.symbolic import symbolic_function
 
 from .structs import *
 
 
-def molecule_problem_to_hamiltonian(
-    problem: QParam[MoleculeProblem],
-) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem, return_type=QParam[List[PauliTerm]])
+def qft_const_adder_phase(
+    bit_index: CInt,
+    value: CInt,
+    reg_len: CInt,
+) -> CReal:
+    return symbolic_function(bit_index, value, reg_len, return_type=CReal)
 
 
 def fock_hamiltonian_problem_to_hamiltonian(
-    problem: QParam[FockHamiltonianProblem],
-) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem, return_type=QParam[List[PauliTerm]])
+    problem: FockHamiltonianProblem,
+) -> CArray[PauliTerm]:
+    return symbolic_function(problem, return_type=CArray[PauliTerm])
+
+
+def molecule_problem_to_hamiltonian(
+    problem: MoleculeProblem,
+) -> CArray[PauliTerm]:
+    return symbolic_function(problem, return_type=CArray[PauliTerm])
 
 
 def grid_entangler_graph(
-    num_qubits: QParam[int],
-    schmidt_rank: QParam[int],
-    grid_randomization: QParam[bool],
-) -> QParam[List[List[int]]]:
+    num_qubits: CInt,
+    schmidt_rank: CInt,
+    grid_randomization: CBool,
+) -> CArray[CArray[CInt]]:
     return symbolic_function(
-        num_qubits,
-        schmidt_rank,
-        grid_randomization,
-        return_type=QParam[List[List[int]]],
+        num_qubits, schmidt_rank, grid_randomization, return_type=CArray[CArray[CInt]]
     )
 
 
 def hypercube_entangler_graph(
-    num_qubits: QParam[int],
-) -> QParam[List[List[int]]]:
-    return symbolic_function(num_qubits, return_type=QParam[List[List[int]]])
+    num_qubits: CInt,
+) -> CArray[CArray[CInt]]:
+    return symbolic_function(num_qubits, return_type=CArray[CArray[CInt]])
 
 
-def log_normal_finance_post_process(
-    finance_model: QParam[LogNormalModel],
-    estimation_method: QParam[FinanceFunction],
-    probability: QParam[float],
-) -> QParam[float]:
+def gaussian_finance_post_process(
+    finance_model: GaussianModel,
+    estimation_method: FinanceFunction,
+    probability: CReal,
+) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=QParam[float]
+        finance_model, estimation_method, probability, return_type=CReal
     )
 
 
-def gaussian_finance_post_process(
-    finance_model: QParam[GaussianModel],
-    estimation_method: QParam[FinanceFunction],
-    probability: QParam[float],
-) -> QParam[float]:
+def log_normal_finance_post_process(
+    finance_model: LogNormalModel,
+    estimation_method: FinanceFunction,
+    probability: CReal,
+) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=QParam[float]
+        finance_model, estimation_method, probability, return_type=CReal
     )
 
 
-def qft_const_adder_phase(
-    bit_index: QParam[int],
-    value: QParam[int],
-    reg_len: QParam[int],
-) -> QParam[float]:
-    return symbolic_function(bit_index, value, reg_len, return_type=QParam[float])
-
-
 __all__ = [
-    "molecule_problem_to_hamiltonian",
+    "qft_const_adder_phase",
     "fock_hamiltonian_problem_to_hamiltonian",
+    "molecule_problem_to_hamiltonian",
     "grid_entangler_graph",
     "hypercube_entangler_graph",
-    "log_normal_finance_post_process",
     "gaussian_finance_post_process",
-    "qft_const_adder_phase",
+    "log_normal_finance_post_process",
 ]

classiq/qmod/builtins/constants.py

@@ -0,0 +1,10 @@
+from classiq.qmod.cparam import CBool
+from classiq.qmod.qmod_constant import QConstant
+
+SIGNED = QConstant("SIGNED", CBool, True)
+UNSIGNED = QConstant("UNSIGNED", CBool, False)
+
+__all__ = [
+    "SIGNED",
+    "UNSIGNED",
+]

classiq/qmod/builtins/enums.py

@@ -0,0 +1,208 @@
+from enum import IntEnum
+
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+
+
+class Element(IntEnum):
+    H = 0
+    He = 1
+    Li = 2
+    Be = 3
+    B = 4
+    C = 5
+    N = 6
+    O = 7  # noqa: E741
+    F = 8
+    Ne = 9
+    Na = 10
+    Mg = 11
+    Al = 12
+    Si = 13
+    P = 14
+    S = 15
+    Cl = 16
+    Ar = 17
+    K = 18
+    Ca = 19
+    Sc = 20
+    Ti = 21
+    V = 22
+    Cr = 23
+    Mn = 24
+    Fe = 25
+    Co = 26
+    Ni = 27
+    Cu = 28
+    Zn = 29
+    Ga = 30
+    Ge = 31
+    As = 32
+    Se = 33
+    Br = 34
+    Kr = 35
+    Rb = 36
+    Sr = 37
+    Y = 38
+    Zr = 39
+    Nb = 40
+    Mo = 41
+    Tc = 42
+    Ru = 43
+    Rh = 44
+    Pd = 45
+    Ag = 46
+    Cd = 47
+    In = 48
+    Sn = 49
+    Sb = 50
+    Te = 51
+    I = 52  # noqa: E741
+    Xe = 53
+    Cs = 54
+    Ba = 55
+    La = 56
+    Ce = 57
+    Pr = 58
+    Nd = 59
+    Pm = 60
+    Sm = 61
+    Eu = 62
+    Gd = 63
+    Tb = 64
+    Dy = 65
+    Ho = 66
+    Er = 67
+    Tm = 68
+    Yb = 69
+    Lu = 70
+    Hf = 71
+    Ta = 72
+    W = 73
+    Re = 74
+    Os = 75
+    Ir = 76
+    Pt = 77
+    Au = 78
+    Hg = 79
+    Tl = 80
+    Pb = 81
+    Bi = 82
+    Po = 83
+    At = 84
+    Rn = 85
+    Fr = 86
+    Ra = 87
+    Ac = 88
+    Th = 89
+    Pa = 90
+    U = 91
+    Np = 92
+    Pu = 93
+    Am = 94
+    Cm = 95
+    Bk = 96
+    Cf = 97
+    Es = 98
+    Fm = 99
+    Md = 100
+    No = 101
+    Lr = 102
+    Rf = 103
+    Db = 104
+    Sg = 105
+    Bh = 106
+    Hs = 107
+    Mt = 108
+    Ds = 109
+    Rg = 110
+    Cn = 111
+    Nh = 112
+    Fl = 113
+    Mc = 114
+    Lv = 115
+    Ts = 116
+    Og = 117
+
+
+class FermionMapping(IntEnum):
+    JORDAN_WIGNER = 0
+    PARITY = 1
+    BRAVYI_KITAEV = 2
+    FAST_BRAVYI_KITAEV = 3
+
+
+class FinanceFunctionType(IntEnum):
+    VAR = 0
+    SHORTFALL = 1
+    X_SQUARE = 2
+    EUROPEAN_CALL_OPTION = 3
+
+
+class LadderOperator(IntEnum):
+    PLUS = 0
+    MINUS = 1
+
+
+class Optimizer(IntEnum):
+    COBYLA = 1
+    SPSA = 2
+    L_BFGS_B = 3
+    NELDER_MEAD = 4
+    ADAM = 5
+
+
+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):
+    FULL = 0
+    LINEAR = 1
+    CIRCULAR = 2
+    SCA = 3
+    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",
+    "FinanceFunctionType",
+    "LadderOperator",
+    "Optimizer",
+    "Pauli",
+    "QSVMFeatureMapEntanglement",
+]

classiq/qmod/builtins/functions/__init__.py

@@ -0,0 +1,137 @@
+from .allocation import *
+from .arithmetic import *
+from .benchmarking import *
+from .chemistry import *
+from .exponentiation import *
+from .finance import *
+from .operators import *
+from .qsvm import *
+from .standard_gates 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,
+        modular_add_constant,
+        real_xor_constant,
+        U,
+        CCX,
+        allocate,
+        free,
+        randomized_benchmarking,
+        inplace_prepare_state,
+        inplace_prepare_amplitudes,
+        single_pauli_exponent,
+        suzuki_trotter,
+        qdrift,
+        exponentiation_with_depth_constraint,
+    )
+]
+
+STD_QMOD_OPERATORS = [func.func_decl for func in (apply, permute)]
+
+__all__ = [  # noqa: RUF022
+    "CCX",
+    "CH",
+    "CPHASE",
+    "CRX",
+    "CRY",
+    "CRZ",
+    "CX",
+    "CY",
+    "CZ",
+    "H",
+    "I",
+    "IDENTITY",
+    "PHASE",
+    "R",
+    "RX",
+    "RXX",
+    "RY",
+    "RYY",
+    "RZ",
+    "RZZ",
+    "SDG",
+    "S",
+    "SWAP",
+    "T",
+    "TDG",
+    "U",
+    "X",
+    "Y",
+    "Z",
+    "add",
+    "allocate",
+    "apply",
+    "bloch_sphere_feature_map",
+    "exponentiation_with_depth_constraint",
+    "fock_hamiltonian_hartree_fock",
+    "fock_hamiltonian_hva",
+    "fock_hamiltonian_ucc",
+    "free",
+    "gaussian_finance",
+    "inplace_prepare_amplitudes",
+    "inplace_prepare_state",
+    "integer_xor",
+    "log_normal_finance",
+    "modular_add",
+    "modular_add_constant",
+    "molecule_hartree_fock",
+    "molecule_hva",
+    "molecule_ucc",
+    "pauli_feature_map",
+    "permute",
+    "prepare_amplitudes",
+    "prepare_state",
+    "qdrift",
+    "randomized_benchmarking",
+    "real_xor_constant",
+    "single_pauli_exponent",
+    "suzuki_trotter",
+    "unitary",
+]
+BUILTIN_FUNCTION_DECLARATIONS = {
+    func_decl.name: func_decl for func_decl in STD_QMOD_OPERATORS + CORE_LIB_DECLS
+}

classiq/qmod/builtins/functions/allocation.py

@@ -0,0 +1,150 @@
+from typing import Literal
+
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CInt, CReal
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
+
+
+@qfunc(external=True)
+def allocate(
+    num_qubits: CInt, out: Output[QArray[QBit, Literal["num_qubits"]]]
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Allocates the specified number of qubits to a given quantum variable and initializes
+    them in the zero state:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\left|0\\right\\rangle^{\\otimes \\text{num_qubits}}
+    $$
+
+    Args:
+        num_qubits: The number of qubits to allocate. Must be a positive integer.
+        out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def free(in_: Input[QArray[QBit]]) -> None:
+    """
+    [Qmod core-library function]
+
+    Releases the qubits allocated to a quantum variable, allowing them to be reused.
+
+    Args:
+        in_: The quantum variable that will be freed. Must be initialized before.
+
+    Note:
+        This operation does not uncompute the qubits. It is the responsibility of the user to ensure that the qubits are at the zero state before freeing them.
+    """
+    pass
+
+
+@qfunc(external=True)
+def prepare_state(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Initializes a quantum variable in a state corresponding to a given probability distribution:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\sum_{i=0}^{\\text{len(probabilities)}-1} \\sqrt{\\text{probabilities}[i]} \\left|i\\right\\rangle
+    $$
+
+    with $i = 0, 1, 2, ..., \\text{len(amplitudes)}-1$ corresponding to computational basis states.
+
+    Args:
+        probabilities: The probability distribution to initialize the quantum variable. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        out: The quantum variable that will receive the initialized state. Must be uninitialized.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits formed by the distribution must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def prepare_amplitudes(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Initializes a quantum variable in a state corresponding to the given amplitudes:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\sum_{i=0}^{\\text{len(amplitudes)}-1} \\text{amplitudes}[i] \\left|i\\right\\rangle
+    $$
+
+    with $i = 0, 1, 2, ..., \\text{len(amplitudes)}-1$ corresponding to computational basis states.
+
+    Args:
+        amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        out: The quantum variable that will receive the initialized state. Must be uninitialized.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits formed by the distribution must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def inplace_prepare_state(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Transforms a given quantum variable in the state |0> to the state per the specified probability distribution
+    (similar to `prepare_state` but preformed on an initialized variable).
+
+    Args:
+        probabilities: The probability distribution corresponding to the quantum variable state. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        target: The quantum variable to act upon.
+
+    This is useful as part of quantum building blocks like the Grover diffuser operator, $\\left|\\psi\\right\\rangle\\left\\langle\\psi\\right| \\left( 2\\left|0\\right\\rangle\\left\\langle0\\right| - \\mathcal{I} \\right)$, where the output state of the oracle is reflected about this state.
+
+    """
+    pass
+
+
+@qfunc(external=True)
+def inplace_prepare_amplitudes(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Transforms a given quantum variable in the state |0> to the state per the specified amplitudes
+    (similar to `prepare_amplitudes` but preformed on an initialized variable).
+
+    Args:
+        amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        target: The quantum variable to act upon.
+
+    This is useful as part of quantum building blocks like the Grover diffuser operator, $\\left|\\psi\\right\\rangle\\left\\langle\\psi\\right| \\left( 2\\left|0\\right\\rangle\\left\\langle0\\right| - \\mathcal{I} \\right)$, where the output state of the oracle is reflected about this state.
+
+    """
+    pass

classiq/qmod/builtins/functions/arithmetic.py

@@ -0,0 +1,55 @@
+from typing import Literal
+
+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]
+
+    Applies 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.
+    """
+    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 modular_add_constant(left: CReal, right: QNum) -> None:
+    pass
+
+
+@qfunc(external=True)
+def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
+    pass
+
+
+@qfunc(external=True)
+def real_xor_constant(left: CReal, right: QNum) -> None:
+    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