classiq 0.93.0__py3-none-any.whl → 0.94.1__py3-none-any.whl

classiq/open_library/functions/modular_exponentiation.py

@@ -8,11 +8,12 @@ from classiq.qmod.builtins.operations import (
     control,
     invert,
     repeat,
+    skip_control,
     within_apply,
 )
 from classiq.qmod.cparam import CInt
-from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit
+from classiq.qmod.qfunc import qfunc, qperm
+from classiq.qmod.qmod_variable import Const, QArray, QBit
 from classiq.qmod.symbolic import min, mod_inverse
 
 
@@ -51,9 +52,9 @@ def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     )
 
 
-@qfunc(unchecked=["phi_b"])
+@qperm(disable_perm_check=True)
 def cc_modular_add(
-    n: CInt, a: CInt, phi_b: Permutable[QArray[QBit]], c1: Const[QBit], c2: Const[QBit]
+    n: CInt, a: CInt, phi_b: QArray[QBit], c1: Const[QBit], c2: Const[QBit]
 ) -> None:
     """
     [Qmod Classiq-library function]
@@ -91,11 +92,11 @@ def cc_modular_add(
     free(aux)
 
 
-@qfunc(unchecked=["b"])
+@qperm(disable_perm_check=True)
 def c_modular_multiply(
     n: CInt,
     a: CInt,
-    b: Permutable[QArray[QBit]],
+    b: QArray[QBit],
     x: Const[QArray[QBit]],
     ctrl: Const[QBit],
 ) -> None:
@@ -123,8 +124,8 @@ def c_modular_multiply(
     )
 
 
-@qfunc
-def multiswap(x: Permutable[QArray[QBit]], y: Permutable[QArray[QBit]]) -> None:
+@qperm
+def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -164,6 +165,93 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
     free(b)
 
 
+@qperm(disable_perm_check=True)
+def modular_add_qft_space(n: CInt, a: CInt, phi_b: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Adds a constant `a` to a quantum number `phi_b` modulo the constant `n`.
+    The quantum number `phi_b` is 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.
+
+    """
+    aux = QBit()
+
+    allocate(aux)
+    qft_space_add_const(a, phi_b),
+    skip_control(
+        lambda: (
+            invert(lambda: qft_space_add_const(n, phi_b)),
+            _check_msb(1, phi_b, aux),
+            control(aux, lambda: qft_space_add_const(n, phi_b)),
+        )
+    )
+    invert(lambda: qft_space_add_const(a, phi_b))
+    skip_control(lambda: _check_msb(0, phi_b, aux))
+    qft_space_add_const(a, phi_b)
+    free(aux)
+
+
+@qperm(disable_perm_check=True)
+def modular_multiply(
+    n: CInt,
+    a: CInt,
+    b: QArray[QBit],
+    x: Const[QArray[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`,
+    and adds the result to a quantum array `b` (Applies $b += xa \\mod n$).
+
+    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.
+    """
+    within_apply(
+        lambda: qft(b),
+        lambda: repeat(
+            count=x.len,
+            iteration=lambda index: control(
+                x[index], lambda: modular_add_qft_space(n, (a * (2**index)) % n, b)
+            ),
+        ),
+    )
+
+
+@qfunc
+def inplace_modular_multiply(n: CInt, a: CInt, x: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Performs multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`
+    (Applies $x=xa \\mod n$).
+
+    Args:
+        n: The modulo number. Should be non-negative.
+        a: The classical factor. Should be non-negative.
+        x: The quantum factor.
+
+    Comment: It is assumed that `a` has an inverse modulo `n`
+    """
+    b: QArray[QBit] = QArray(length=x.len + 1)
+    within_apply(
+        lambda: allocate(b),
+        lambda: (
+            modular_multiply(n, a, b, x),
+            multiswap(x, b),
+            invert(lambda: modular_multiply(n, mod_inverse(a, n), b, x)),
+        ),
+    )
+
+
 @qfunc
 def modular_exp(n: CInt, a: CInt, x: QArray[QBit], power: QArray[QBit]) -> None:
     """

classiq/qmod/__init__.py

@@ -4,11 +4,11 @@ from .cfunc import cfunc
 from .classical_variable import measure
 from .create_model_function import create_model
 from .expression_query import get_expression_numeric_attributes
-from .qfunc import qfunc
+from .qfunc import qfunc, qperm
 from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
 from .qmod_variable import Const, Input, Output, Permutable, QArray, QBit, QNum, QStruct
-from .quantum_callable import QCallable, QCallableList
+from .quantum_callable import QCallable, QCallableList, QPerm, QPermList
 from .write_qmod import write_qmod
 
 __all__ = [
@@ -27,11 +27,14 @@ __all__ = [
     "QCallable",
     "QCallableList",
     "QConstant",
+    "QPerm",
+    "QPermList",
     "QStruct",
     "cfunc",
     "create_model",
     "measure",
     "get_expression_numeric_attributes",
     "qfunc",
+    "qperm",
     "write_qmod",
 ] + _builtins_all

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from classiq.interface.applications.iqae.iqae_result import IQAEResult
 from classiq.interface.exceptions import ClassiqError
@@ -32,7 +32,7 @@ def save(values_to_save: dict) -> None:
 
 
 def sample(  # type: ignore[return]
-    execution_params: Optional[ExecutionParams] = None,
+    execution_params: ExecutionParams | None = None,
 ) -> ExecutionDetails:
     _raise_error("sample")
 
@@ -44,7 +44,7 @@ def batch_sample(  # type: ignore[return]
 
 
 def estimate(  # type: ignore[return]
-    hamiltonian: list[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
+    hamiltonian: list[QmodPyStruct], execution_params: ExecutionParams | None = None
 ) -> EstimationResult:
     _raise_error("estimate")
 
@@ -91,23 +91,16 @@ def qsvm_full_run(  # type: ignore[return]
 def iqae(  # type: ignore[return]
     epsilon: float,
     alpha: float,
-    execution_params: Optional[ExecutionParams] = None,
+    execution_params: ExecutionParams | None = None,
 ) -> IQAEResult:
     _raise_error("iqae")
 
 
-def molecule_ground_state_solution_post_process(  # type: ignore[return]
-    problem: QmodPyStruct, vqe_result: VQESolverResult
-) -> QmodPyStruct:
-    _raise_error("molecule_ground_state_solution_post_process")
-
-
 __all__ = [
     "batch_estimate",
     "batch_sample",
     "estimate",
     "iqae",
-    "molecule_ground_state_solution_post_process",
     "qae_with_qpe_result_post_processing",
     "qsvm_full_run",
     "sample",

classiq/qmod/builtins/classical_functions.py

@@ -1,7 +1,7 @@
 # This file was generated automatically - do not edit manually
 
 
-from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
+from classiq.qmod.qmod_parameter import CInt, CReal
 from classiq.qmod.symbolic import symbolic_function
 
 from .structs import *
@@ -17,47 +17,6 @@ def qft_const_adder_phase(
     )
 
 
-def fock_hamiltonian_problem_to_hamiltonian(
-    problem: FockHamiltonianProblem,
-) -> CArray[PauliTerm]:
-    return symbolic_function(
-        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
-    )
-
-
-def molecule_problem_to_hamiltonian(
-    problem: MoleculeProblem,
-) -> CArray[PauliTerm]:
-    return symbolic_function(
-        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
-    )
-
-
-def grid_entangler_graph(
-    num_qubits: CInt,
-    schmidt_rank: CInt,
-    grid_randomization: CBool,
-) -> CArray[CArray[CInt]]:
-    return symbolic_function(
-        num_qubits,
-        schmidt_rank,
-        grid_randomization,
-        return_type=CArray[CArray[CInt]],  # type:ignore[type-abstract]
-    )
-
-
-def hypercube_entangler_graph(
-    num_qubits: CInt,
-) -> CArray[CArray[CInt]]:
-    return symbolic_function(
-        num_qubits, return_type=CArray[CArray[CInt]]  # type:ignore[type-abstract]
-    )
-
-
 __all__ = [
     "qft_const_adder_phase",
-    "fock_hamiltonian_problem_to_hamiltonian",
-    "molecule_problem_to_hamiltonian",
-    "grid_entangler_graph",
-    "hypercube_entangler_graph",
 ]

classiq/qmod/builtins/enums.py

@@ -7,139 +7,6 @@ if TYPE_CHECKING:
     from classiq.qmod.builtins.structs import SparsePauliOp
 
 
-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 LadderOperator(IntEnum):
-    PLUS = 0
-    MINUS = 1
-
-
 class Optimizer(IntEnum):
     COBYLA = 1
     SPSA = 2
@@ -229,9 +96,6 @@ BUILTIN_ENUM_DECLARATIONS = {
 }
 
 __all__ = [
-    "Element",
-    "FermionMapping",
-    "LadderOperator",
     "Optimizer",
     "Pauli",
     "QSVMFeatureMapEntanglement",

classiq/qmod/builtins/functions/__init__.py

@@ -1,7 +1,6 @@
 from .allocation import *
 from .arithmetic import *
 from .benchmarking import *
-from .chemistry import *
 from .exponentiation import *
 from .mid_circuit_measurement import *
 from .operators import *
@@ -11,12 +10,6 @@ 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,
         pauli_feature_map,
         bloch_sphere_feature_map,
         H,
@@ -114,9 +107,6 @@ __all__ = [  # noqa: RUF022
     "apply",
     "bloch_sphere_feature_map",
     "exponentiation_with_depth_constraint",
-    "fock_hamiltonian_hartree_fock",
-    "fock_hamiltonian_hva",
-    "fock_hamiltonian_ucc",
     "free",
     "inplace_prepare_amplitudes",
     "inplace_prepare_amplitudes_approx",
@@ -125,9 +115,6 @@ __all__ = [  # noqa: RUF022
     "integer_xor",
     "modular_add",
     "modular_add_constant",
-    "molecule_hartree_fock",
-    "molecule_hva",
-    "molecule_ucc",
     "multi_suzuki_trotter",
     "parametric_suzuki_trotter",
     "pauli_feature_map",

classiq/qmod/builtins/functions/allocation.py

@@ -1,12 +1,12 @@
 from typing import Literal
 
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_parameter import CArray, CReal
-from classiq.qmod.qmod_variable import Input, Output, Permutable, QArray, QBit
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
 
 
-@qfunc(external=True)
-def free(in_: Permutable[Input[QArray[QBit]]]) -> None:
+@qperm(external=True)
+def free(in_: Input[QArray[QBit]]) -> None:
     """
     [Qmod core-library function]
 

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,12 +1,11 @@
 from typing import Literal
 
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_parameter import CArray, CBool, CReal
 from classiq.qmod.qmod_variable import (
     Const,
     Input,
     Output,
-    Permutable,
     QArray,
     QBit,
     QNum,
@@ -30,17 +29,15 @@ def unitary(
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def add(
     left: Const[QNum],
     right: Const[QNum],
-    result: Permutable[
-        Output[
-            QNum[
-                Literal["result_size"],
-                Literal["result_is_signed"],
-                Literal["result_fraction_places"],
-            ]
+    result: Output[
+        QNum[
+            Literal["result_size"],
+            Literal["result_is_signed"],
+            Literal["result_fraction_places"],
         ]
     ],
     result_size: CReal,
@@ -50,17 +47,15 @@ def add(
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def add_inplace_right(
     left: Const[QNum],
-    right: Permutable[Input[QNum]],
-    result: Permutable[
-        Output[
-            QNum[
-                Literal["result_size"],
-                Literal["result_is_signed"],
-                Literal["result_fraction_places"],
-            ]
+    right: Input[QNum],
+    result: Output[
+        QNum[
+            Literal["result_size"],
+            Literal["result_is_signed"],
+            Literal["result_fraction_places"],
         ]
     ],
     result_size: CReal,
@@ -70,21 +65,21 @@ def add_inplace_right(
     pass
 
 
-@qfunc(external=True)
-def modular_add(left: Const[QArray[QBit]], right: Permutable[QArray[QBit]]) -> None:
+@qperm(external=True)
+def modular_add(left: Const[QArray[QBit]], right: QArray[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
-def modular_add_constant(left: CReal, right: Permutable[QNum]) -> None:
+@qperm(external=True)
+def modular_add_constant(left: CReal, right: QNum) -> None:
     pass
 
 
-@qfunc(external=True)
-def integer_xor(left: Const[QArray[QBit]], right: Permutable[QArray[QBit]]) -> None:
+@qperm(external=True)
+def integer_xor(left: Const[QArray[QBit]], right: QArray[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
-def real_xor_constant(left: CReal, right: Permutable[QNum]) -> None:
+@qperm(external=True)
+def real_xor_constant(left: CReal, right: QNum) -> None:
     pass