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

classiq/qmod/builtins/functions.py

@@ -2,78 +2,78 @@
 
 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 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 +81,7 @@ def PHASE(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RX(
     theta: QParam[float],
     target: QBit,
@@ -89,7 +89,7 @@ def RX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RY(
     theta: QParam[float],
     target: QBit,
@@ -97,7 +97,7 @@ def RY(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RZ(
     theta: QParam[float],
     target: QBit,
@@ -105,7 +105,7 @@ def RZ(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def R(
     theta: QParam[float],
     phi: QParam[float],
@@ -114,7 +114,7 @@ def R(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RXX(
     theta: QParam[float],
     target: QArray[QBit, Literal[2]],
@@ -122,7 +122,7 @@ def RXX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RYY(
     theta: QParam[float],
     target: QArray[QBit, Literal[2]],
@@ -130,7 +130,7 @@ def RYY(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def RZZ(
     theta: QParam[float],
     target: QArray[QBit, Literal[2]],
@@ -138,7 +138,7 @@ def RZZ(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CH(
     control: QBit,
     target: QBit,
@@ -146,7 +146,7 @@ def CH(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CX(
     control: QBit,
     target: QBit,
@@ -154,7 +154,7 @@ def CX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CY(
     control: QBit,
     target: QBit,
@@ -162,7 +162,7 @@ def CY(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CZ(
     control: QBit,
     target: QBit,
@@ -170,7 +170,7 @@ def CZ(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CRX(
     theta: QParam[float],
     control: QBit,
@@ -179,7 +179,7 @@ def CRX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CRY(
     theta: QParam[float],
     control: QBit,
@@ -188,7 +188,7 @@ def CRY(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CRZ(
     theta: QParam[float],
     control: QBit,
@@ -197,7 +197,7 @@ def CRZ(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CPHASE(
     theta: QParam[float],
     control: QBit,
@@ -206,7 +206,7 @@ def CPHASE(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def SWAP(
     qbit0: QBit,
     qbit1: QBit,
@@ -214,14 +214,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 +230,7 @@ def prepare_state(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def prepare_amplitudes(
     amplitudes: QParam[List[float]],
     bound: QParam[float],
@@ -239,7 +239,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 +247,7 @@ def unitary(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def add(
     left: QArray[QBit],
     right: QArray[QBit],
@@ -256,7 +256,7 @@ def add(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def modular_add(
     left: QArray[QBit],
     right: QArray[QBit],
@@ -264,7 +264,7 @@ def modular_add(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def integer_xor(
     left: QArray[QBit],
     right: QArray[QBit],
@@ -272,7 +272,7 @@ def integer_xor(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def U(
     theta: QParam[float],
     phi: QParam[float],
@@ -283,7 +283,7 @@ def U(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def CCX(
     control: QArray[QBit, Literal[2]],
     target: QBit,
@@ -291,7 +291,7 @@ def CCX(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def allocate(
     num_qubits: QParam[int],
     out: Output[QArray[QBit, Literal["num_qubits"]]],
@@ -299,14 +299,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 +314,7 @@ def randomized_benchmarking(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def inplace_prepare_state(
     probabilities: QParam[List[float]],
     bound: QParam[float],
@@ -323,7 +323,7 @@ def inplace_prepare_state(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def inplace_prepare_amplitudes(
     amplitudes: QParam[List[float]],
     bound: QParam[float],
@@ -332,7 +332,7 @@ def inplace_prepare_amplitudes(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def single_pauli_exponent(
     pauli_string: QParam[List[int]],
     coefficient: QParam[float],
@@ -341,7 +341,7 @@ def single_pauli_exponent(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def suzuki_trotter(
     pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
@@ -352,7 +352,7 @@ def suzuki_trotter(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qdrift(
     pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
@@ -362,7 +362,7 @@ def qdrift(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def exponentiation_with_depth_constraint(
     pauli_operator: QParam[List[PauliTerm]],
     evolution_coefficient: QParam[float],
@@ -372,21 +372,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 +394,7 @@ def qpe_flexible(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qpe(
     unitary: QCallable,
     phase: QNum,
@@ -402,7 +402,7 @@ def qpe(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def standard_qpe(
     precision: QParam[int],
     unitary: QCallable,
@@ -411,7 +411,7 @@ def standard_qpe(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def single_pauli(
     slope: QParam[float],
     offset: QParam[float],
@@ -422,7 +422,7 @@ def single_pauli(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def linear_pauli_rotations(
     bases: QParam[List[int]],
     slopes: QParam[List[float]],
@@ -433,78 +433,75 @@ 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"]]],
+    phase_port: Output[QNum],
     unitary_port: Output[QArray[QBit, Literal["num_unitary_qubits"]]],
 ) -> 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 +511,7 @@ def allocate_num(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def qaoa_mixer_layer(
     b: QParam[float],
     target: QArray[QBit],
@@ -522,46 +519,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 +569,7 @@ def full_hea(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def swap_test(
     state1: QArray[QBit],
     state2: QArray[QBit],
@@ -584,39 +578,47 @@ def swap_test(
     pass
 
 
-@ExternalQFunc
-def repeat(
-    count: QParam[int],
-    iteration: QCallable[QParam[int]],
+@qfunc(external=True)
+def prepare_ghz_state(
+    size: QParam[int],
+    q: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def invert(
-    operand: QCallable,
+@qfunc(external=True)
+def prepare_exponential_state(
+    rate: QParam[int],
+    q: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def control(
-    operand: QCallable,
-    ctrl: QArray[QBit],
+@qfunc(external=True)
+def prepare_bell_state(
+    state_num: QParam[int],
+    q: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
-@ExternalQFunc
-def if_(
-    condition: QParam[bool],
-    then: QCallable,
-    else_: QCallable,
+@qfunc(external=True)
+def inplace_prepare_int(
+    value: QParam[int],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
+def prepare_int(
+    value: QParam[int],
+    out: Output[QNum],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
 def switch(
     selector: QParam[int],
     cases: QCallableList,
@@ -624,34 +626,46 @@ def switch(
     pass
 
 
-@ExternalQFunc
-def join(
-    in1: Input[QArray[QBit]],
-    in2: Input[QArray[QBit]],
-    out: Output[QArray[QBit, Literal["len(in1)+len(in2)"]]],
+@qfunc(external=True)
+def repeat(
+    count: QParam[int],
+    iteration: QCallable[QParam[int]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def invert(
+    operand: QCallable,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def control(
+    operand: QCallable,
+    ctrl: QArray[QBit],
 ) -> 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 if_(
+    condition: QParam[bool],
+    then: QCallable,
+    else_: QCallable,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def permute(
     functions: QCallableList,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def power(
     power: QParam[int],
     operand: QCallable,
@@ -659,28 +673,28 @@ def power(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def apply(
     operand: QCallable,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def compute(
     operand: QCallable,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def uncompute(
     operand: QCallable,
 ) -> None:
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def molecule_ucc(
     molecule_problem: QParam[MoleculeProblem],
     excitations: QParam[List[int]],
@@ -694,7 +708,7 @@ def molecule_ucc(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def molecule_hva(
     molecule_problem: QParam[MoleculeProblem],
     reps: QParam[int],
@@ -708,7 +722,7 @@ def molecule_hva(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def molecule_hartree_fock(
     molecule_problem: QParam[MoleculeProblem],
     qbv: QArray[
@@ -721,7 +735,7 @@ def molecule_hartree_fock(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def fock_hamiltonian_ucc(
     fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
     excitations: QParam[List[int]],
@@ -735,7 +749,7 @@ def fock_hamiltonian_ucc(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def fock_hamiltonian_hva(
     fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
     reps: QParam[int],
@@ -749,7 +763,7 @@ def fock_hamiltonian_hva(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def fock_hamiltonian_hartree_fock(
     fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
     qbv: QArray[
@@ -762,7 +776,7 @@ def fock_hamiltonian_hartree_fock(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def log_normal_finance(
     finance_model: QParam[LogNormalModel],
     finance_function: QParam[FinanceFunction],
@@ -772,7 +786,7 @@ def log_normal_finance(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def gaussian_finance(
     finance_model: QParam[GaussianModel],
     finance_function: QParam[FinanceFunction],
@@ -787,7 +801,7 @@ def gaussian_finance(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def pauli_feature_map(
     feature_map: QParam[QSVMFeatureMapPauli],
     qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
@@ -795,7 +809,7 @@ def pauli_feature_map(
     pass
 
 
-@ExternalQFunc
+@qfunc(external=True)
 def bloch_sphere_feature_map(
     feature_dimension: QParam[int],
     qbv: QArray[QBit, Literal["ceiling(feature_dimension/2)"]],
@@ -856,13 +870,13 @@ __all__ = [
     "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,13 +885,16 @@ __all__ = [
     "qaoa_penalty",
     "full_hea",
     "swap_test",
+    "prepare_ghz_state",
+    "prepare_exponential_state",
+    "prepare_bell_state",
+    "inplace_prepare_int",
+    "prepare_int",
+    "switch",
     "repeat",
     "invert",
     "control",
     "if_",
-    "switch",
-    "join",
-    "split",
     "permute",
     "power",
     "apply",