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

classiq/qmod/builtins/functions.py

@@ -1,15 +1,117 @@
 # This file was generated automatically - do not edit manually
 
-from typing import List, Literal
+from classiq.interface.generator.expressions.enums.pauli import Pauli
 
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 
 from .structs import *
 
 
+@qfunc(external=True)
+def permute(
+    functions: QCallableList,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def apply(
+    operand: QCallable,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def molecule_ucc(
+    molecule_problem: MoleculeProblem,
+    excitations: CArray[CInt],
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def molecule_hva(
+    molecule_problem: MoleculeProblem,
+    reps: CInt,
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def molecule_hartree_fock(
+    molecule_problem: MoleculeProblem,
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_ucc(
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    excitations: CArray[CInt],
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_hva(
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    reps: CInt,
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_hartree_fock(
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def log_normal_finance(
+    finance_model: LogNormalModel,
+    finance_function: FinanceFunction,
+    func_port: QArray[QBit],
+    obj_port: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def gaussian_finance(
+    finance_model: GaussianModel,
+    finance_function: FinanceFunction,
+    func_port: QArray[QBit],
+    obj_port: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def pauli_feature_map(
+    feature_map: QSVMFeatureMapPauli,
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def bloch_sphere_feature_map(
+    feature_dimension: CInt,
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
 @qfunc(external=True)
 def H(
     target: QBit,
@@ -75,7 +177,7 @@ def TDG(
 
 @qfunc(external=True)
 def PHASE(
-    theta: QParam[float],
+    theta: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -83,7 +185,7 @@ def PHASE(
 
 @qfunc(external=True)
 def RX(
-    theta: QParam[float],
+    theta: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -91,7 +193,7 @@ def RX(
 
 @qfunc(external=True)
 def RY(
-    theta: QParam[float],
+    theta: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -99,7 +201,7 @@ def RY(
 
 @qfunc(external=True)
 def RZ(
-    theta: QParam[float],
+    theta: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -107,8 +209,8 @@ def RZ(
 
 @qfunc(external=True)
 def R(
-    theta: QParam[float],
-    phi: QParam[float],
+    theta: CReal,
+    phi: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -116,24 +218,24 @@ def R(
 
 @qfunc(external=True)
 def RXX(
-    theta: QParam[float],
-    target: QArray[QBit, Literal[2]],
+    theta: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def RYY(
-    theta: QParam[float],
-    target: QArray[QBit, Literal[2]],
+    theta: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def RZZ(
-    theta: QParam[float],
-    target: QArray[QBit, Literal[2]],
+    theta: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
@@ -172,7 +274,7 @@ def CZ(
 
 @qfunc(external=True)
 def CRX(
-    theta: QParam[float],
+    theta: CReal,
     control: QBit,
     target: QBit,
 ) -> None:
@@ -181,7 +283,7 @@ def CRX(
 
 @qfunc(external=True)
 def CRY(
-    theta: QParam[float],
+    theta: CReal,
     control: QBit,
     target: QBit,
 ) -> None:
@@ -190,7 +292,7 @@ def CRY(
 
 @qfunc(external=True)
 def CRZ(
-    theta: QParam[float],
+    theta: CReal,
     control: QBit,
     target: QBit,
 ) -> None:
@@ -199,7 +301,7 @@ def CRZ(
 
 @qfunc(external=True)
 def CPHASE(
-    theta: QParam[float],
+    theta: CReal,
     control: QBit,
     target: QBit,
 ) -> None:
@@ -223,26 +325,26 @@ def IDENTITY(
 
 @qfunc(external=True)
 def prepare_state(
-    probabilities: QParam[List[float]],
-    bound: QParam[float],
-    out: Output[QArray[QBit, Literal["log(len(probabilities), 2)"]]],
+    probabilities: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def prepare_amplitudes(
-    amplitudes: QParam[List[float]],
-    bound: QParam[float],
-    out: Output[QArray[QBit, Literal["log(len(amplitudes), 2)"]]],
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def unitary(
-    elements: QParam[List[List[float]]],
-    target: QArray[QBit, Literal["log(len(elements[0]), 2)"]],
+    elements: CArray[CArray[CReal]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
@@ -251,7 +353,7 @@ def unitary(
 def add(
     left: QArray[QBit],
     right: QArray[QBit],
-    result: Output[QArray[QBit, Literal["Max(len(left), len(right)) + 1"]]],
+    result: Output[QArray[QBit]],
 ) -> None:
     pass
 
@@ -274,10 +376,10 @@ def integer_xor(
 
 @qfunc(external=True)
 def U(
-    theta: QParam[float],
-    phi: QParam[float],
-    lam: QParam[float],
-    gam: QParam[float],
+    theta: CReal,
+    phi: CReal,
+    lam: CReal,
+    gam: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -285,7 +387,7 @@ def U(
 
 @qfunc(external=True)
 def CCX(
-    control: QArray[QBit, Literal[2]],
+    control: QArray[QBit],
     target: QBit,
 ) -> None:
     pass
@@ -293,8 +395,8 @@ def CCX(
 
 @qfunc(external=True)
 def allocate(
-    num_qubits: QParam[int],
-    out: Output[QArray[QBit, Literal["num_qubits"]]],
+    num_qubits: CInt,
+    out: Output[QArray[QBit]],
 ) -> None:
     pass
 
@@ -308,7 +410,7 @@ def free(
 
 @qfunc(external=True)
 def randomized_benchmarking(
-    num_of_cliffords: QParam[int],
+    num_of_cliffords: CInt,
     target: QArray[QBit],
 ) -> None:
     pass
@@ -316,58 +418,58 @@ def randomized_benchmarking(
 
 @qfunc(external=True)
 def inplace_prepare_state(
-    probabilities: QParam[List[float]],
-    bound: QParam[float],
-    target: QArray[QBit, Literal["log(len(probabilities), 2)"]],
+    probabilities: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def inplace_prepare_amplitudes(
-    amplitudes: QParam[List[float]],
-    bound: QParam[float],
-    target: QArray[QBit, Literal["log(len(amplitudes), 2)"]],
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def single_pauli_exponent(
-    pauli_string: QParam[List[int]],
-    coefficient: QParam[float],
-    qbv: QArray[QBit, Literal["len(pauli_string)"]],
+    pauli_string: CArray[Pauli],
+    coefficient: CReal,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def suzuki_trotter(
-    pauli_operator: QParam[List[PauliTerm]],
-    evolution_coefficient: QParam[float],
-    order: QParam[int],
-    repetitions: QParam[int],
-    qbv: QArray[QBit, Literal["len(get_field(pauli_operator[0], 'pauli'))"]],
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def qdrift(
-    pauli_operator: QParam[List[PauliTerm]],
-    evolution_coefficient: QParam[float],
-    num_qdrift: QParam[int],
-    qbv: QArray[QBit, Literal["len(get_field(pauli_operator[0], 'pauli'))"]],
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    num_qdrift: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def exponentiation_with_depth_constraint(
-    pauli_operator: QParam[List[PauliTerm]],
-    evolution_coefficient: QParam[float],
-    max_depth: QParam[int],
-    qbv: QArray[QBit, Literal["len(get_field(pauli_operator[0], 'pauli'))"]],
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    max_depth: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -388,7 +490,7 @@ def qft(
 
 @qfunc(external=True)
 def qpe_flexible(
-    unitary_with_power: QCallable[QParam[int]],
+    unitary_with_power: QCallable[CInt],
     phase: QNum,
 ) -> None:
     pass
@@ -402,20 +504,11 @@ def qpe(
     pass
 
 
-@qfunc(external=True)
-def standard_qpe(
-    precision: QParam[int],
-    unitary: QCallable,
-    phase: QArray[QBit, Literal["precision"]],
-) -> None:
-    pass
-
-
 @qfunc(external=True)
 def single_pauli(
-    slope: QParam[float],
-    offset: QParam[float],
-    q1_qfunc: QCallable[QParam[float], QBit],
+    slope: CReal,
+    offset: CReal,
+    q1_qfunc: QCallable[CReal, QBit],
     x: QArray[QBit],
     q: QBit,
 ) -> None:
@@ -424,9 +517,9 @@ def single_pauli(
 
 @qfunc(external=True)
 def linear_pauli_rotations(
-    bases: QParam[List[int]],
-    slopes: QParam[List[float]],
-    offsets: QParam[List[float]],
+    bases: CArray[Pauli],
+    slopes: CArray[CReal],
+    offsets: CArray[CReal],
     x: QArray[QBit],
     q: QArray[QBit],
 ) -> None:
@@ -435,12 +528,10 @@ def linear_pauli_rotations(
 
 @qfunc(external=True)
 def amplitude_estimation(
-    num_phase_qubits: QParam[int],
-    num_unitary_qubits: QParam[int],
-    sp_op: QCallable[QParam[int], QArray[QBit, Literal["num_unitary_qubits"]]],
-    oracle_op: QCallable[QParam[int], QArray[QBit, Literal["num_unitary_qubits"]]],
-    phase_port: Output[QNum],
-    unitary_port: Output[QArray[QBit, Literal["num_unitary_qubits"]]],
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    phase: QNum,
+    packed_vars: QArray[QBit],
 ) -> None:
     pass
 
@@ -479,7 +570,7 @@ def grover_operator(
 
 @qfunc(external=True)
 def grover_search(
-    reps: QParam[int],
+    reps: CInt,
     oracle: QCallable[QArray[QBit]],
     packed_vars: QArray[QBit],
 ) -> None:
@@ -502,322 +593,229 @@ def apply_to_all(
 
 
 @qfunc(external=True)
-def allocate_num(
-    num_qubits: QParam[int],
-    is_signed: QParam[bool],
-    fraction_digits: QParam[int],
-    out: Output[QNum],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def qaoa_mixer_layer(
-    b: QParam[float],
-    target: QArray[QBit],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def qaoa_cost_layer(
-    g: QParam[float],
-    hamiltonian: QParam[List[PauliTerm]],
-    target: QArray[QBit],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def qaoa_layer(
-    g: QParam[float],
-    b: QParam[float],
-    hamiltonian: QParam[List[PauliTerm]],
-    target: QArray[QBit],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def qaoa_init(
-    target: QArray[QBit],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def qaoa_penalty(
-    num_qubits: QParam[int],
-    params_list: QParam[List[float]],
-    hamiltonian: QParam[List[PauliTerm]],
-    target: QArray[QBit, Literal["num_qubits"]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def full_hea(
-    num_qubits: QParam[int],
-    is_parametrized: QParam[List[int]],
-    angle_params: QParam[List[float]],
-    connectivity_map: QParam[List[List[int]]],
-    reps: QParam[int],
-    operands_1qubit: QCallableList[QParam[float], QBit],
-    operands_2qubit: QCallableList[QParam[float], QBit, QBit],
-    x: QArray[QBit, Literal["num_qubits"]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def swap_test(
-    state1: QArray[QBit],
-    state2: QArray[QBit],
-    test: Output[QArray[QBit]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def prepare_ghz_state(
-    size: QParam[int],
-    q: Output[QArray[QBit]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def prepare_exponential_state(
-    rate: QParam[int],
-    q: QArray[QBit],
+def qft_no_swap(
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def prepare_bell_state(
-    state_num: QParam[int],
-    q: Output[QArray[QBit]],
+def _check_msb(
+    ref: CInt,
+    x: QArray[QBit],
+    aux: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def inplace_prepare_int(
-    value: QParam[int],
-    target: QArray[QBit],
+def _ctrl_x(
+    ref: CInt,
+    ctrl: QArray[QBit],
+    aux: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def prepare_int(
-    value: QParam[int],
-    out: Output[QNum],
+def qft_space_add_const(
+    value: CInt,
+    phi_b: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def switch(
-    selector: QParam[int],
-    cases: QCallableList,
+def cc_modular_add(
+    n: CInt,
+    a: CInt,
+    phi_b: QArray[QBit],
+    c1: QArray[QBit],
+    c2: QArray[QBit],
+    aux: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def repeat(
-    count: QParam[int],
-    iteration: QCallable[QParam[int]],
+def c_modular_multiply(
+    n: CInt,
+    a: CInt,
+    b: QArray[QBit],
+    x: QArray[QBit],
+    ctrl: QArray[QBit],
+    aux: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def invert(
-    operand: QCallable,
+def multiswap(
+    x: QArray[QBit],
+    y: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def control(
-    operand: QCallable,
+def inplace_c_modular_multiply(
+    n: CInt,
+    a: CInt,
+    x: QArray[QBit],
     ctrl: QArray[QBit],
+    aux: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def if_(
-    condition: QParam[bool],
-    then: QCallable,
-    else_: QCallable,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def permute(
-    functions: QCallableList,
+def modular_exp(
+    n: CInt,
+    a: CInt,
+    x: QArray[QBit],
+    power: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def power(
-    power: QParam[int],
-    operand: QCallable,
+def allocate_num(
+    num_qubits: CInt,
+    is_signed: CBool,
+    fraction_digits: CInt,
+    out: Output[QNum],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def apply(
-    operand: QCallable,
+def qaoa_mixer_layer(
+    b: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def compute(
-    operand: QCallable,
+def qaoa_cost_layer(
+    g: CReal,
+    hamiltonian: CArray[PauliTerm],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def uncompute(
-    operand: QCallable,
+def qaoa_layer(
+    g: CReal,
+    b: CReal,
+    hamiltonian: CArray[PauliTerm],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def molecule_ucc(
-    molecule_problem: QParam[MoleculeProblem],
-    excitations: QParam[List[int]],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
+def qaoa_init(
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def molecule_hva(
-    molecule_problem: QParam[MoleculeProblem],
-    reps: QParam[int],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
+def qaoa_penalty(
+    num_qubits: CInt,
+    params_list: CArray[CReal],
+    hamiltonian: CArray[PauliTerm],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def molecule_hartree_fock(
-    molecule_problem: QParam[MoleculeProblem],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
+def full_hea(
+    num_qubits: CInt,
+    is_parametrized: CArray[CInt],
+    angle_params: CArray[CReal],
+    connectivity_map: CArray[CArray[CInt]],
+    reps: CInt,
+    operands_1qubit: QCallableList[CReal, QBit],
+    operands_2qubit: QCallableList[CReal, QBit, QBit],
+    x: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def fock_hamiltonian_ucc(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    excitations: QParam[List[int]],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
+def swap_test(
+    state1: QArray[QBit],
+    state2: QArray[QBit],
+    test: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def fock_hamiltonian_hva(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    reps: QParam[int],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
+def prepare_ghz_state(
+    size: CInt,
+    q: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def fock_hamiltonian_hartree_fock(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
+def prepare_exponential_state(
+    rate: CInt,
+    q: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def log_normal_finance(
-    finance_model: QParam[LogNormalModel],
-    finance_function: QParam[FinanceFunction],
-    func_port: QArray[QBit, Literal["get_field(finance_model, 'num_qubits')"]],
-    obj_port: QBit,
+def prepare_bell_state(
+    state_num: CInt,
+    q: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def gaussian_finance(
-    finance_model: QParam[GaussianModel],
-    finance_function: QParam[FinanceFunction],
-    func_port: QArray[
-        QBit,
-        Literal[
-            "get_field(finance_model, 'num_qubits') + len(get_field(finance_model, 'rhos')) + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1"
-        ],
-    ],
-    obj_port: QBit,
+def inplace_prepare_int(
+    value: CInt,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def pauli_feature_map(
-    feature_map: QParam[QSVMFeatureMapPauli],
-    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
+def prepare_int(
+    value: CInt,
+    out: Output[QNum],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
-def bloch_sphere_feature_map(
-    feature_dimension: QParam[int],
-    qbv: QArray[QBit, Literal["ceiling(feature_dimension/2)"]],
+def switch(
+    selector: CInt,
+    cases: QCallableList,
 ) -> None:
     pass
 
 
 __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",
@@ -866,7 +864,6 @@ __all__ = [
     "qft",
     "qpe_flexible",
     "qpe",
-    "standard_qpe",
     "single_pauli",
     "linear_pauli_rotations",
     "amplitude_estimation",
@@ -877,6 +874,15 @@ __all__ = [
     "grover_search",
     "hadamard_transform",
     "apply_to_all",
+    "qft_no_swap",
+    "_check_msb",
+    "_ctrl_x",
+    "qft_space_add_const",
+    "cc_modular_add",
+    "c_modular_multiply",
+    "multiswap",
+    "inplace_c_modular_multiply",
+    "modular_exp",
     "allocate_num",
     "qaoa_mixer_layer",
     "qaoa_cost_layer",
@@ -891,23 +897,4 @@ __all__ = [
     "inplace_prepare_int",
     "prepare_int",
     "switch",
-    "repeat",
-    "invert",
-    "control",
-    "if_",
-    "permute",
-    "power",
-    "apply",
-    "compute",
-    "uncompute",
-    "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",
 ]