classiq 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

classiq/model_expansions/transformers/var_splitter.py

@@ -44,7 +44,7 @@ class SymbolPart:
         return HandleBinding(name=self.target_var_name)
 
 
-SymbolParts = dict[QuantumSymbol, list[SymbolPart]]
+SymbolParts = dict[HandleBinding, list[SymbolPart]]
 PartNamer = Callable[[str], str]
 
 
@@ -78,7 +78,7 @@ class VarSplitter:
         }
 
         return {
-            symbol: [
+            symbol.handle: [
                 SymbolPart(
                     source_handle=part.handle,
                     target_var_name=namer(part.handle.identifier),
@@ -165,10 +165,10 @@ class VarSplitter:
     def get_bind_ops(symbol_parts: SymbolParts) -> list[BindOperation]:
         return [
             BindOperation(
-                in_handles=[symbol.handle],
+                in_handles=[handle],
                 out_handles=[part.target_var_handle for part in parts],
             )
-            for symbol, parts in symbol_parts.items()
+            for handle, parts in symbol_parts.items()
         ]
 
     @staticmethod
@@ -229,21 +229,20 @@ class VarSplitter:
         vrc.visit(ast.parse(expression.expr))
 
         handle_names = {
-            part.source_handle: part.target_var_name
+            part.source_handle: part.target_var_handle
             for parts in symbol_mapping.values()
             for part in parts
         }
         new_expr_str = expression.expr
         for handle in vrc.var_handles:
-            collapsed_handle = handle.collapse()
-            if collapsed_handle in handle_names:
+            new_handle = handle.collapse()
+            for handle_to_replace, replacement in handle_names.items():
+                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
+            new_expr_str = new_expr_str.replace(str(handle), str(new_handle))
+            if handle.qmod_expr != str(handle):
                 new_expr_str = new_expr_str.replace(
-                    str(handle), handle_names[collapsed_handle]
+                    handle.qmod_expr, new_handle.qmod_expr
                 )
-                if handle.qmod_expr != str(handle):
-                    new_expr_str = new_expr_str.replace(
-                        handle.qmod_expr, handle_names[collapsed_handle]
-                    )
 
         new_expr = Expression(expr=new_expr_str)
         new_expr._evaluated_expr = expression._evaluated_expr

classiq/model_expansions/visitors/variable_references.py

@@ -23,9 +23,12 @@ from classiq.interface.model.handle_binding import (
 
 
 class VarRefCollector(ast.NodeVisitor):
-    def __init__(self, ignore_duplicated_handles: bool = False) -> None:
+    def __init__(
+        self, ignore_duplicated_handles: bool = False, unevaluated: bool = False
+    ) -> None:
         self._var_handles: dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
+        self._unevaluated = unevaluated
         self._is_nested = False
 
     @property
@@ -57,23 +60,28 @@ class VarRefCollector(ast.NodeVisitor):
             return None
 
         handle: Union[SubscriptHandleBinding, SlicedHandleBinding]
-        if isinstance(node.slice, ast.Num):
-            handle = SubscriptHandleBinding(
-                base_handle=base_handle,
-                index=Expression(expr=str(node.slice.value)),
-            )
-        elif isinstance(node.slice, ast.Slice):
-            if not isinstance(node.slice.lower, ast.Num) or not isinstance(
-                node.slice.upper, ast.Num
+        if isinstance(node.slice, ast.Slice):
+            if not self._unevaluated and (
+                not isinstance(node.slice.lower, ast.Num)
+                or not isinstance(node.slice.upper, ast.Num)
             ):
                 raise ClassiqInternalExpansionError("Unevaluated slice bounds.")
+            if node.slice.lower is None or node.slice.upper is None:
+                raise ClassiqExpansionError(
+                    f"{str(base_handle)!r} slice must specify both lower and upper bounds"
+                )
             handle = SlicedHandleBinding(
                 base_handle=base_handle,
-                start=Expression(expr=str(node.slice.lower.value)),
-                end=Expression(expr=str(node.slice.upper.value)),
+                start=Expression(expr=ast.unparse(node.slice.lower)),
+                end=Expression(expr=ast.unparse(node.slice.upper)),
             )
-        else:
+        elif not self._unevaluated and not isinstance(node.slice, ast.Num):
             raise ClassiqInternalExpansionError("Unevaluated slice.")
+        else:
+            handle = SubscriptHandleBinding(
+                base_handle=base_handle,
+                index=Expression(expr=ast.unparse(node.slice)),
+            )
 
         if not self._is_nested:
             self._var_handles[handle] = True

classiq/qmod/builtins/classical_execution_primitives.py

@@ -105,16 +105,16 @@ def molecule_ground_state_solution_post_process(  # type: ignore[return]
 
 __all__ = [
     "ExecutionParams",
-    "save",
-    "sample",
+    "batch_estimate",
     "batch_sample",
     "estimate",
-    "batch_estimate",
-    "vqe",
-    "qae_with_qpe_result_post_processing",
-    "qsvm_full_run",
     "iqae",
     "molecule_ground_state_solution_post_process",
+    "qae_with_qpe_result_post_processing",
+    "qsvm_full_run",
+    "sample",
+    "save",
+    "vqe",
 ]
 
 

classiq/qmod/builtins/classical_functions.py

@@ -15,14 +15,14 @@ def qft_const_adder_phase(
     return symbolic_function(bit_index, value, reg_len, return_type=CReal)
 
 
-def molecule_problem_to_hamiltonian(
-    problem: MoleculeProblem,
+def fock_hamiltonian_problem_to_hamiltonian(
+    problem: FockHamiltonianProblem,
 ) -> CArray[PauliTerm]:
     return symbolic_function(problem, return_type=CArray[PauliTerm])
 
 
-def fock_hamiltonian_problem_to_hamiltonian(
-    problem: FockHamiltonianProblem,
+def molecule_problem_to_hamiltonian(
+    problem: MoleculeProblem,
 ) -> CArray[PauliTerm]:
     return symbolic_function(problem, return_type=CArray[PauliTerm])
 
@@ -43,8 +43,8 @@ def hypercube_entangler_graph(
     return symbolic_function(num_qubits, return_type=CArray[CArray[CInt]])
 
 
-def log_normal_finance_post_process(
-    finance_model: LogNormalModel,
+def gaussian_finance_post_process(
+    finance_model: GaussianModel,
     estimation_method: FinanceFunction,
     probability: CReal,
 ) -> CReal:
@@ -53,8 +53,8 @@ def log_normal_finance_post_process(
     )
 
 
-def gaussian_finance_post_process(
-    finance_model: GaussianModel,
+def log_normal_finance_post_process(
+    finance_model: LogNormalModel,
     estimation_method: FinanceFunction,
     probability: CReal,
 ) -> CReal:
@@ -65,10 +65,10 @@ def gaussian_finance_post_process(
 
 __all__ = [
     "qft_const_adder_phase",
-    "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
+    "molecule_problem_to_hamiltonian",
     "grid_entangler_graph",
     "hypercube_entangler_graph",
-    "log_normal_finance_post_process",
     "gaussian_finance_post_process",
+    "log_normal_finance_post_process",
 ]

classiq/qmod/builtins/functions/__init__.py

@@ -1,6 +1,3 @@
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-
-from ...quantum_function import GenerativeQFunc
 from .amplitude_estimation import *
 from .arithmetic import *
 from .benchmarking import *
@@ -90,7 +87,7 @@ CORE_LIB_DECLS = [
     )
 ]
 
-OPEN_LIBRARY_UNPROCESSED_FUNCTIONS = [
+OPEN_LIBRARY_FUNCTIONS = [
     qpe_flexible,
     qpe,
     _single_pauli,
@@ -112,8 +109,11 @@ OPEN_LIBRARY_UNPROCESSED_FUNCTIONS = [
     modular_exp,
     qsvt_step,
     qsvt,
+    projector_controlled_double_phase,
     projector_controlled_phase,
     qsvt_inversion,
+    qsvt_lcu,
+    qsvt_lcu_step,
     allocate_num,
     qaoa_mixer_layer,
     qaoa_cost_layer,
@@ -145,133 +145,119 @@ OPEN_LIBRARY_UNPROCESSED_FUNCTIONS = [
     encode_on_bloch,
 ]
 
-OPEN_LIBRARY_FUNCTIONS: list[NativeFunctionDefinition] = []
-
-
-def load_open_library_implementations() -> None:
-    OPEN_LIBRARY_FUNCTIONS.extend(
-        [func.get_implementation() for func in OPEN_LIBRARY_UNPROCESSED_FUNCTIONS]
-    )
-
-
-OPEN_LIBRARY_GENERATIVE_FUNCTIONS: list[GenerativeQFunc] = []
-
-OPEN_LIB_DECLS = [
-    func.func_decl
-    for func in OPEN_LIBRARY_GENERATIVE_FUNCTIONS + OPEN_LIBRARY_UNPROCESSED_FUNCTIONS
-]
-
 STD_QMOD_OPERATORS = [func.func_decl for func in (apply, permute)]
 
 BUILTIN_FUNCTION_DECLARATIONS = {
-    func_decl.name: func_decl
-    for func_decl in STD_QMOD_OPERATORS + OPEN_LIB_DECLS + CORE_LIB_DECLS
+    func_decl.name: func_decl for func_decl in STD_QMOD_OPERATORS + CORE_LIB_DECLS
 }
 
-__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",
+__all__ = [  # noqa: RUF022
+    "CCX",
+    "CH",
+    "CPHASE",
+    "CRX",
+    "CRY",
+    "CRZ",
+    "CX",
+    "CY",
+    "CZ",
     "H",
-    "X",
-    "Y",
-    "Z",
     "I",
-    "S",
-    "T",
-    "SDG",
-    "TDG",
+    "IDENTITY",
     "PHASE",
-    "RX",
-    "RY",
-    "RZ",
     "R",
+    "RX",
     "RXX",
+    "RY",
     "RYY",
+    "RZ",
     "RZZ",
-    "CH",
-    "CX",
-    "CY",
-    "CZ",
-    "CRX",
-    "CRY",
-    "CRZ",
-    "CPHASE",
+    "SDG",
+    "S",
     "SWAP",
-    "IDENTITY",
-    "prepare_state",
-    "prepare_amplitudes",
-    "unitary",
-    "add",
-    "modular_add",
-    "integer_xor",
-    "modular_add_constant",
-    "real_xor_constant",
+    "T",
+    "TDG",
     "U",
-    "CCX",
-    "allocate",
-    "free",
-    "randomized_benchmarking",
-    "inplace_prepare_state",
-    "inplace_prepare_amplitudes",
-    "single_pauli_exponent",
-    "suzuki_trotter",
-    "qdrift",
-    "exponentiation_with_depth_constraint",
-    "qpe_flexible",
-    "qpe",
+    "X",
+    "Y",
+    "Z",
     "_single_pauli",
-    "linear_pauli_rotations",
+    "add",
+    "allocate",
+    "allocate_num",
     "amplitude_estimation",
-    "phase_oracle",
-    "reflect_about_zero",
+    "apply",
+    "apply_to_all",
+    "bloch_sphere_feature_map",
+    "c_modular_multiply",
+    "cc_modular_add",
+    "encode_in_angle",
+    "encode_on_bloch",
+    "exponentiation_with_depth_constraint",
+    "fock_hamiltonian_hartree_fock",
+    "fock_hamiltonian_hva",
+    "fock_hamiltonian_ucc",
+    "free",
+    "full_hea",
+    "gaussian_finance",
     "grover_diffuser",
     "grover_operator",
     "grover_search",
     "hadamard_transform",
-    "apply_to_all",
-    "qft_no_swap",
-    "qft_space_add_const",
-    "cc_modular_add",
-    "c_modular_multiply",
-    "multiswap",
     "inplace_c_modular_multiply",
+    "inplace_prepare_amplitudes",
+    "inplace_prepare_int",
+    "inplace_prepare_state",
+    "integer_xor",
+    "linear_pauli_rotations",
+    "log_normal_finance",
+    "modular_add",
+    "modular_add_constant",
     "modular_exp",
-    "qsvt_step",
-    "qsvt",
+    "modular_increment",
+    "molecule_hartree_fock",
+    "molecule_hva",
+    "molecule_ucc",
+    "multiswap",
+    "pauli_feature_map",
+    "permute",
+    "phase_oracle",
+    "prepare_amplitudes",
+    "prepare_bell_state",
+    "prepare_exponential_state",
+    "prepare_ghz_state",
+    "prepare_int",
+    "prepare_state",
+    "prepare_uniform_interval_state",
+    "prepare_uniform_trimmed_state",
+    "projector_controlled_double_phase",
     "projector_controlled_phase",
-    "qsvt_inversion",
-    "allocate_num",
-    "qaoa_mixer_layer",
     "qaoa_cost_layer",
-    "qaoa_layer",
     "qaoa_init",
+    "qaoa_layer",
+    "qaoa_mixer_layer",
     "qaoa_penalty",
-    "full_hea",
-    "swap_test",
-    "prepare_uniform_trimmed_state",
-    "prepare_uniform_interval_state",
-    "prepare_ghz_state",
-    "prepare_exponential_state",
-    "prepare_bell_state",
-    "inplace_prepare_int",
-    "prepare_int",
-    "switch",
     "qct_qst_type1",
     "qct_qst_type2",
     "qct_type2",
-    "qst_type2",
-    "modular_increment",
+    "qdrift",
     "qft",
-    "encode_in_angle",
-    "encode_on_bloch",
+    "qft_no_swap",
+    "qft_space_add_const",
+    "qpe",
+    "qpe_flexible",
+    "qst_type2",
+    "qsvt",
+    "qsvt_inversion",
+    "qsvt_lcu",
+    "qsvt_lcu_step",
+    "qsvt_step",
+    "randomized_benchmarking",
+    "real_xor_constant",
+    "reflect_about_zero",
+    "single_pauli_exponent",
+    "suzuki_trotter",
+    "swap_test",
+    "switch",
+    "unitary",
 ]

classiq/qmod/builtins/functions/amplitude_estimation.py

@@ -5,7 +5,7 @@ from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
 
 
-@qfunc(external=True)
+@qfunc
 def amplitude_estimation(
     oracle: QCallable[QArray[QBit]],
     space_transform: QCallable[QArray[QBit]],

classiq/qmod/builtins/functions/arithmetic.py

@@ -60,7 +60,7 @@ def real_xor_constant(left: CReal, right: QNum) -> None:
     pass
 
 
-@qfunc(external=True)
+@qfunc
 def modular_increment(a: CInt, x: QNum) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py

@@ -14,13 +14,13 @@ def _b_operator(q: QBit) -> None:
     H(q)
 
 
-@qfunc(external=True)
+@qfunc
 def _qct_d_operator(x: QNum, q: QBit) -> None:
     _b_operator(q)
     control(x == 0, lambda: invert(lambda: _b_operator(q)))
 
 
-@qfunc(external=True)
+@qfunc
 def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
     control(q == 1, lambda: apply_to_all(X, x))
     control(q == 1, lambda: modular_increment(1, x))
@@ -82,7 +82,7 @@ def _un_dag_operator(x: QArray[QBit], q: QBit) -> None:
     invert(lambda: _pi2_operator(x, q))
 
 
-@qfunc(external=True)
+@qfunc
 def qct_qst_type1(x: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -109,7 +109,7 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
     within_apply(lambda: _t_operator(x), lambda: qft(x))
 
 
-@qfunc(external=True)
+@qfunc
 def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
     """
     [Qmod Classiq-library function]
@@ -140,7 +140,7 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
     _un_dag_operator(x, q)
 
 
-@qfunc(external=True)
+@qfunc
 def qct_type2(x: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -155,7 +155,7 @@ def qct_type2(x: QArray[QBit]) -> None:
     within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
 
 
-@qfunc(external=True)
+@qfunc
 def qst_type2(x: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/grover.py

@@ -15,7 +15,7 @@ from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.symbolic import pi
 
 
-@qfunc(external=True)
+@qfunc
 def phase_oracle(
     predicate: QCallable[QArray[QBit], QBit], target: QArray[QBit]
 ) -> None:
@@ -47,7 +47,7 @@ def phase_oracle(
     )
 
 
-@qfunc(external=True)
+@qfunc
 def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -74,7 +74,7 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     bind([msbs, lsb], packed_vars)
 
 
-@qfunc(external=True)
+@qfunc
 def grover_diffuser(
     space_transform: QCallable[QArray[QBit]], packed_vars: QArray[QBit]
 ) -> None:
@@ -102,7 +102,7 @@ def grover_diffuser(
     )
 
 
-@qfunc(external=True)
+@qfunc
 def grover_operator(
     oracle: QCallable[QArray[QBit]],
     space_transform: QCallable[QArray[QBit]],
@@ -130,7 +130,7 @@ def grover_operator(
     U(0, 0, 0, pi, packed_vars[0])
 
 
-@qfunc(external=True)
+@qfunc
 def grover_search(
     reps: CInt, oracle: QCallable[QArray[QBit]], packed_vars: QArray[QBit]
 ) -> None:

classiq/qmod/builtins/functions/hea.py

@@ -8,7 +8,7 @@ from classiq.qmod.quantum_callable import QCallableList
 from classiq.qmod.symbolic import floor, sum
 
 
-@qfunc(external=True)
+@qfunc
 def full_hea(
     num_qubits: CInt,
     is_parametrized: CArray[CInt],

classiq/qmod/builtins/functions/linear_pauli_rotation.py

@@ -10,7 +10,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
 
 
-@qfunc(external=True)
+@qfunc
 def _single_pauli(
     slope: CReal,
     offset: CReal,
@@ -24,7 +24,7 @@ def _single_pauli(
     q1_qfunc(offset, q)
 
 
-@qfunc(external=True)
+@qfunc
 def linear_pauli_rotations(
     bases: CArray[Pauli],
     slopes: CArray[CReal],

classiq/qmod/builtins/functions/modular_exponentiation.py

@@ -9,21 +9,21 @@ from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.symbolic import min, mod_inverse
 
 
-@qfunc(external=True)
+@qfunc
 def _check_msb(ref: CInt, x: QArray[QBit], aux: QBit) -> None:
     within_apply(
         lambda: invert(lambda: qft_no_swap(x)), lambda: _ctrl_x(ref, x[0], aux)
     )
 
 
-@qfunc(external=True)
+@qfunc
 def _ctrl_x(
     ref: CInt, ctrl: QNum, aux: QBit
 ) -> None:  # TODO: remove qfunc when expressions of QBit is supported
     control(ctrl == ref, lambda: X(aux))
 
 
-@qfunc(external=True)
+@qfunc
 def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -50,7 +50,7 @@ def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) -> None:
     """
     [Qmod Classiq-library function]
@@ -95,7 +95,7 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
     )
 
 
-@qfunc(external=True)
+@qfunc
 def c_modular_multiply(
     n: CInt, a: CInt, b: QArray[QBit], x: QArray[QBit], ctrl: QBit
 ) -> None:
@@ -123,7 +123,7 @@ def c_modular_multiply(
     )
 
 
-@qfunc(external=True)
+@qfunc
 def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -142,7 +142,7 @@ def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) -> None:
     """
     [Qmod Classiq-library function]
@@ -172,7 +172,7 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
     )
 
 
-@qfunc(external=True)
+@qfunc
 def modular_exp(n: CInt, a: CInt, x: QArray[QBit], power: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/operators.py

@@ -17,6 +17,6 @@ def apply(
     pass
 
 
-@qfunc(external=True)
+@qfunc
 def switch(selector: CInt, cases: QCallableList) -> None:
     cases[selector]()