classiq 0.37.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

classiq/qmod/builtins/functions.py

@@ -2,78 +2,215 @@
 
 from typing import List, Literal
 
+from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import QParam
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable, QCallableList
-from classiq.qmod.quantum_function import ExternalQFunc
 
 from .structs import *
 
 
-@ExternalQFunc
+@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: QParam[MoleculeProblem],
+    excitations: QParam[List[int]],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
+        ],
+    ],
+) -> 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'))"
+        ],
+    ],
+) -> 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'))"
+        ],
+    ],
+) -> 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'))"
+        ],
+    ],
+) -> 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'))"
+        ],
+    ],
+) -> 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'))"
+        ],
+    ],
+) -> 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,
+) -> 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,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def pauli_feature_map(
+    feature_map: QParam[QSVMFeatureMapPauli],
+    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def bloch_sphere_feature_map(
+    feature_dimension: QParam[int],
+    qbv: QArray[QBit, Literal["ceiling(feature_dimension/2)"]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
 def H(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def X(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def Y(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def Z(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def I(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def S(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def T(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def SDG(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def TDG(
     target: QBit,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def PHASE(
     theta: QParam[float],
     target: QBit,
@@ -81,7 +218,7 @@ def PHASE(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RX(
     theta: QParam[float],
     target: QBit,
@@ -89,7 +226,7 @@ def RX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RY(
     theta: QParam[float],
     target: QBit,
@@ -97,7 +234,7 @@ def RY(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RZ(
     theta: QParam[float],
     target: QBit,
@@ -105,7 +242,7 @@ def RZ(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def R(
     theta: QParam[float],
     phi: QParam[float],
@@ -114,7 +251,7 @@ def R(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RXX(
     theta: QParam[float],
     target: QArray[QBit, Literal[2]],
@@ -122,7 +259,7 @@ def RXX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RYY(
     theta: QParam[float],
     target: QArray[QBit, Literal[2]],
@@ -130,7 +267,7 @@ def RYY(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RZZ(
     theta: QParam[float],
     target: QArray[QBit, Literal[2]],
@@ -138,7 +275,7 @@ def RZZ(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CH(
     control: QBit,
     target: QBit,
@@ -146,7 +283,7 @@ def CH(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CX(
     control: QBit,
     target: QBit,
@@ -154,7 +291,7 @@ def CX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CY(
     control: QBit,
     target: QBit,
@@ -162,7 +299,7 @@ def CY(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CZ(
     control: QBit,
     target: QBit,
@@ -170,7 +307,7 @@ def CZ(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CRX(
     theta: QParam[float],
     control: QBit,
@@ -179,7 +316,7 @@ def CRX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CRY(
     theta: QParam[float],
     control: QBit,
@@ -188,7 +325,7 @@ def CRY(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CRZ(
     theta: QParam[float],
     control: QBit,
@@ -197,7 +334,7 @@ def CRZ(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CPHASE(
     theta: QParam[float],
     control: QBit,
@@ -206,7 +343,7 @@ def CPHASE(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def SWAP(
     qbit0: QBit,
     qbit1: QBit,
@@ -214,14 +351,14 @@ def SWAP(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def IDENTITY(
     target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def prepare_state(
     probabilities: QParam[List[float]],
     bound: QParam[float],
@@ -230,7 +367,7 @@ def prepare_state(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def prepare_amplitudes(
     amplitudes: QParam[List[float]],
     bound: QParam[float],
@@ -239,7 +376,7 @@ def prepare_amplitudes(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def unitary(
     elements: QParam[List[List[float]]],
     target: QArray[QBit, Literal["log(len(elements[0]), 2)"]],
@@ -247,7 +384,7 @@ def unitary(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def add(
     left: QArray[QBit],
     right: QArray[QBit],
@@ -256,7 +393,7 @@ def add(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def modular_add(
     left: QArray[QBit],
     right: QArray[QBit],
@@ -264,7 +401,7 @@ def modular_add(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def integer_xor(
     left: QArray[QBit],
     right: QArray[QBit],
@@ -272,7 +409,7 @@ def integer_xor(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def U(
     theta: QParam[float],
     phi: QParam[float],
@@ -283,7 +420,7 @@ def U(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CCX(
     control: QArray[QBit, Literal[2]],
     target: QBit,
@@ -291,7 +428,7 @@ def CCX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def allocate(
     num_qubits: QParam[int],
     out: Output[QArray[QBit, Literal["num_qubits"]]],
@@ -299,14 +436,14 @@ def allocate(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def free(
     in_: Input[QArray[QBit]],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def randomized_benchmarking(
     num_of_cliffords: QParam[int],
     target: QArray[QBit],
@@ -314,7 +451,7 @@ def randomized_benchmarking(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def inplace_prepare_state(
     probabilities: QParam[List[float]],
     bound: QParam[float],
@@ -323,7 +460,7 @@ def inplace_prepare_state(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def inplace_prepare_amplitudes(
     amplitudes: QParam[List[float]],
     bound: QParam[float],
@@ -332,7 +469,7 @@ def inplace_prepare_amplitudes(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def single_pauli_exponent(
     pauli_string: QParam[List[int]],
     coefficient: QParam[float],
@@ -341,7 +478,7 @@ def single_pauli_exponent(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def suzuki_trotter(
     pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
@@ -352,7 +489,7 @@ def suzuki_trotter(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qdrift(
     pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
@@ -362,7 +499,7 @@ def qdrift(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def exponentiation_with_depth_constraint(
     pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
@@ -372,21 +509,21 @@ def exponentiation_with_depth_constraint(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qft_step(
     target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qft(
     target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qpe_flexible(
     unitary_with_power: QCallable[QParam[int]],
     phase: QNum,
@@ -394,7 +531,7 @@ def qpe_flexible(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qpe(
     unitary: QCallable,
     phase: QNum,
@@ -402,16 +539,7 @@ def qpe(
     pass
 
 
-@ExternalQFunc
-def standard_qpe(
-    precision: QParam[int],
-    unitary: QCallable,
-    phase: QArray[QBit, Literal["precision"]],
-) -> None:
-    pass
-
-
-@ExternalQFunc
+@qfunc(external=True)
 def single_pauli(
     slope: QParam[float],
     offset: QParam[float],
@@ -422,7 +550,7 @@ def single_pauli(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def linear_pauli_rotations(
     bases: QParam[List[int]],
     slopes: QParam[List[float]],
@@ -433,78 +561,73 @@ def linear_pauli_rotations(
     pass
 
 
-@ExternalQFunc
+@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[QArray[QBit, Literal["num_phase_qubits"]]],
-    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
 
 
-@ExternalQFunc
-def simple_oracle(
-    predicate: QCallable[QArray[QBit, Literal["len(target)"]], QBit],
+@qfunc(external=True)
+def phase_oracle(
+    predicate: QCallable[QArray[QBit], QArray[QBit]],
     target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def grover_diffuser(
-    num_qubits: QParam[int],
-    p: QArray[QBit, Literal["num_qubits"]],
+@qfunc(external=True)
+def reflect_about_zero(
+    packed_vars: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def grover_operator(
-    num_qubits: QParam[int],
-    sp_op: QCallable[QParam[int], QArray[QBit, Literal["num_qubits"]]],
-    oracle_op: QCallable[QParam[int], QArray[QBit, Literal["num_qubits"]]],
-    p: QArray[QBit, Literal["num_qubits"]],
+@qfunc(external=True)
+def grover_diffuser(
+    space_transform: QCallable[QArray[QBit]],
+    packed_vars: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def hadamard_transform(
-    target: QArray[QBit],
+@qfunc(external=True)
+def grover_operator(
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    packed_vars: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def apply_to_all(
-    gate_operand: QCallable[QBit],
-    target: QArray[QBit],
+@qfunc(external=True)
+def grover_search(
+    reps: QParam[int],
+    oracle: QCallable[QArray[QBit]],
+    packed_vars: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def grover_search(
-    num_qubits: QParam[int],
-    reps: QParam[int],
-    oracle_op: QCallable[QParam[int], QArray[QBit, Literal["num_qubits"]]],
-    gsq: QArray[QBit, Literal["num_qubits"]],
+@qfunc(external=True)
+def hadamard_transform(
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def prepare_int(
-    val: QParam[int],
-    out: Output[QNum],
+@qfunc(external=True)
+def apply_to_all(
+    gate_operand: QCallable[QBit],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def allocate_num(
     num_qubits: QParam[int],
     is_signed: QParam[bool],
@@ -514,7 +637,7 @@ def allocate_num(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qaoa_mixer_layer(
     b: QParam[float],
     target: QArray[QBit],
@@ -522,46 +645,43 @@ def qaoa_mixer_layer(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qaoa_cost_layer(
     g: QParam[float],
     hamiltonian: QParam[List[PauliTerm]],
-    is_st: QParam[bool],
     target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qaoa_layer(
     g: QParam[float],
     b: QParam[float],
     hamiltonian: QParam[List[PauliTerm]],
-    is_st: QParam[bool],
     target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qaoa_init(
     target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qaoa_penalty(
     num_qubits: QParam[int],
     params_list: QParam[List[float]],
     hamiltonian: QParam[List[PauliTerm]],
-    is_st: QParam[bool],
     target: QArray[QBit, Literal["num_qubits"]],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def full_hea(
     num_qubits: QParam[int],
     is_parametrized: QParam[List[int]],
@@ -575,7 +695,7 @@ def full_hea(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def swap_test(
     state1: QArray[QBit],
     state2: QArray[QBit],
@@ -584,226 +704,67 @@ def swap_test(
     pass
 
 
-@ExternalQFunc
-def repeat(
-    count: QParam[int],
-    iteration: QCallable[QParam[int]],
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def invert(
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def control(
-    operand: QCallable,
-    ctrl: QArray[QBit],
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def if_(
-    condition: QParam[bool],
-    then: QCallable,
-    else_: QCallable,
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def switch(
-    selector: QParam[int],
-    cases: QCallableList,
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def join(
-    in1: Input[QArray[QBit]],
-    in2: Input[QArray[QBit]],
-    out: Output[QArray[QBit, Literal["len(in1)+len(in2)"]]],
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def split(
-    out1_size: QParam[int],
-    out2_size: QParam[int],
-    in_: Input[QArray[QBit, Literal["out1_size+out2_size"]]],
-    out1: Output[QArray[QBit, Literal["out1_size"]]],
-    out2: Output[QArray[QBit, Literal["out2_size"]]],
+@qfunc(external=True)
+def prepare_ghz_state(
+    size: QParam[int],
+    q: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def permute(
-    functions: QCallableList,
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def power(
-    power: QParam[int],
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def apply(
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def compute(
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def uncompute(
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@ExternalQFunc
-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'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@ExternalQFunc
-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'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@ExternalQFunc
-def molecule_hartree_fock(
-    molecule_problem: QParam[MoleculeProblem],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@ExternalQFunc
-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'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@ExternalQFunc
-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'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@ExternalQFunc
-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'))"
-        ],
-    ],
+@qfunc(external=True)
+def prepare_exponential_state(
+    rate: QParam[int],
+    q: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-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,
+@qfunc(external=True)
+def prepare_bell_state(
+    state_num: QParam[int],
+    q: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-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,
+@qfunc(external=True)
+def inplace_prepare_int(
+    value: QParam[int],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def pauli_feature_map(
-    feature_map: QParam[QSVMFeatureMapPauli],
-    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
+@qfunc(external=True)
+def prepare_int(
+    value: QParam[int],
+    out: Output[QNum],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def bloch_sphere_feature_map(
-    feature_dimension: QParam[int],
-    qbv: QArray[QBit, Literal["ceiling(feature_dimension/2)"]],
+@qfunc(external=True)
+def switch(
+    selector: QParam[int],
+    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",
@@ -852,17 +813,16 @@ __all__ = [
     "qft",
     "qpe_flexible",
     "qpe",
-    "standard_qpe",
     "single_pauli",
     "linear_pauli_rotations",
     "amplitude_estimation",
-    "simple_oracle",
+    "phase_oracle",
+    "reflect_about_zero",
     "grover_diffuser",
     "grover_operator",
+    "grover_search",
     "hadamard_transform",
     "apply_to_all",
-    "grover_search",
-    "prepare_int",
     "allocate_num",
     "qaoa_mixer_layer",
     "qaoa_cost_layer",
@@ -871,26 +831,10 @@ __all__ = [
     "qaoa_penalty",
     "full_hea",
     "swap_test",
-    "repeat",
-    "invert",
-    "control",
-    "if_",
+    "prepare_ghz_state",
+    "prepare_exponential_state",
+    "prepare_bell_state",
+    "inplace_prepare_int",
+    "prepare_int",
     "switch",
-    "join",
-    "split",
-    "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",
 ]