classiq 0.68.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

classiq/model_expansions/scope_initialization.py

@@ -1,20 +1,17 @@
 from collections.abc import Sequence
-from typing import Any
 
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqError, ClassiqInternalExpansionError
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.expressions.expression_constants import (
-    CPARAM_EXECUTION_SUFFIX,
-    RESERVED_EXPRESSIONS,
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    PositionalArg,
-)
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.evaluators.classical_expression import (
@@ -129,37 +126,27 @@ def init_builtin_types() -> None:
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
 
 
-def _rename_exec_param(param_name: str) -> str:
-    if param_name in RESERVED_EXPRESSIONS:
-        return param_name
-    return param_name + CPARAM_EXECUTION_SUFFIX
-
-
-def _add_exec_param_parts_to_scope(param_val: Any, scope: Scope) -> None:
-    if not isinstance(param_val, list):
-        scope[str(param_val)] = Evaluated(value=param_val)
-        return
-    for param_part in param_val:
-        _add_exec_param_parts_to_scope(param_part, scope)
-
-
 def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalType]:
     if model.execution_parameters is not None:
-        exec_params = {
-            param_name: (param_name, param_type)
-            for param_name, param_type in model.execution_parameters.items()
-        }
+        exec_params = model.execution_parameters
     else:
         exec_params = {
-            param.name: (_rename_exec_param(param.name), param.classical_type)
+            param.name: param.classical_type
             for param in model.function_dict.get(
                 "_dec_main", model.main_func
             ).param_decls
         }
-    for param_name, (param_rename, param_type) in exec_params.items():
-        param_val = param_type.as_symbolic(param_rename)
+    for param_name, param_type in exec_params.items():
+        param_val = param_type.get_classical_proxy(
+            handle=HandleBinding(name=param_name)
+        )
         scope[param_name] = Evaluated(value=param_val)
-        scope[param_rename] = Evaluated(value=param_val)
-        if isinstance(param_val, list):
-            _add_exec_param_parts_to_scope(param_val, scope)
-    return dict(exec_params.values())
+    return exec_params
+
+
+def _get_shape(classical_type: ConcreteClassicalType) -> tuple[int, ...]:
+    if isinstance(classical_type, ClassicalList):
+        raise ClassiqInternalExpansionError("Unexpected classical list")
+    if isinstance(classical_type, ClassicalArray):
+        return classical_type.size, *_get_shape(classical_type.element_type)
+    return ()

classiq/model_expansions/transformers/model_renamer.py

@@ -1,4 +1,5 @@
 import ast
+import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from typing import TypeVar, cast
@@ -16,6 +17,12 @@ from classiq.model_expansions.visitors.variable_references import VarRefCollecto
 AST_NODE = TypeVar("AST_NODE", bound=NodeType)
 
 
+def _replace_full_word(pattern: str, substitution: str, target: str) -> str:
+    return re.sub(
+        rf"(^|\b|\W)({re.escape(pattern)})($|\b|\W)", rf"\1{substitution}\3", target
+    )
+
+
 @dataclass(frozen=True)
 class HandleRenaming:
     source_handle: HandleBinding
@@ -74,7 +81,7 @@ class ModelRenamer:
         symbol_mapping: SymbolRenaming,
         expression: Expression,
     ) -> Expression:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, ignore_sympy_symbols=True)
         vrc.visit(ast.parse(expression.expr))
 
         handle_names = {
@@ -87,10 +94,12 @@ class ModelRenamer:
             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))
+            new_expr_str = _replace_full_word(
+                str(handle), str(new_handle), new_expr_str
+            )
             if handle.qmod_expr != str(handle):
-                new_expr_str = new_expr_str.replace(
-                    handle.qmod_expr, new_handle.qmod_expr
+                new_expr_str = _replace_full_word(
+                    str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
                 )
 
         new_expr = Expression(expr=new_expr_str)

classiq/model_expansions/visitors/variable_references.py

@@ -24,10 +24,14 @@ from classiq.interface.model.handle_binding import (
 
 class VarRefCollector(ast.NodeVisitor):
     def __init__(
-        self, ignore_duplicated_handles: bool = False, unevaluated: bool = False
+        self,
+        ignore_duplicated_handles: bool = False,
+        unevaluated: bool = False,
+        ignore_sympy_symbols: bool = False,
     ) -> None:
         self._var_handles: dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
+        self._ignore_sympy_symbols = ignore_sympy_symbols
         self._unevaluated = unevaluated
         self._is_nested = False
 
@@ -117,9 +121,9 @@ class VarRefCollector(ast.NodeVisitor):
         return handle
 
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
-        if node.id in set(SYMPY_SUPPORTED_EXPRESSIONS) | set(
-            DEFAULT_SUPPORTED_FUNC_NAMES
-        ):
+        if not self._ignore_sympy_symbols and node.id in set(
+            SYMPY_SUPPORTED_EXPRESSIONS
+        ) | set(DEFAULT_SUPPORTED_FUNC_NAMES):
             return None
         handle = HandleBinding(name=node.id)
         if not self._is_nested:

classiq/open_library/functions/__init__.py

@@ -9,6 +9,7 @@ from .grover import *
 from .hea import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
+from .lookup_table import span_lookup_table
 from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb
 from .qaoa_penalty import *
@@ -131,6 +132,7 @@ __all__ = [
     "qsvt_lcu_step",
     "qsvt_step",
     "reflect_about_zero",
+    "span_lookup_table",
     "suzuki_trotter",
     "swap_test",
     "switch",

classiq/open_library/functions/amplitude_amplification.py

@@ -73,11 +73,9 @@ def exact_amplitude_amplification(
 
     extended_qvars: QArray = QArray()
     within_apply(
-        lambda: [  # type:ignore[arg-type]
+        lambda: [
             allocate(aux),
-            bind(
-                [aux, packed_qvars], extended_qvars
-            ),  # type:ignore[func-returns-value]
+            bind([aux, packed_qvars], extended_qvars),
         ],
         lambda: amplitude_amplification(
             k,
@@ -85,9 +83,7 @@ def exact_amplitude_amplification(
                 qvars_[0] == 0, lambda: oracle(qvars_[1 : qvars_.size])
             ),
             lambda qvars_: [
-                space_transform(  # type:ignore[func-returns-value]
-                    qvars_[1 : qvars_.size]
-                ),
+                space_transform(qvars_[1 : qvars_.size]),
                 RY(rot_phase, qvars_[0]),
             ],
             extended_qvars,

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -30,9 +30,9 @@ def _qct_d_operator(x: QNum, q: QBit) -> None:
 def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
     control(
         q == 1,
-        lambda: [  # type:ignore[arg-type]
+        lambda: [
             apply_to_all(X, x),
-            inplace_add(1, x),  # type:ignore[arg-type, func-returns-value]
+            inplace_add(1, x),  # type:ignore[arg-type]
         ],
     )
 
@@ -70,7 +70,7 @@ def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
 
 
 def _j_operator(q: QBit) -> None:
-    within_apply(lambda: Z(q), lambda: (S(q), H(q), S(q)))  # type:ignore[arg-type]
+    within_apply(lambda: Z(q), lambda: (S(q), H(q), S(q)))
 
 
 def _b_t_operator(q: QBit) -> None:
@@ -179,6 +179,6 @@ def qst_type2(x: QArray[QBit]) -> None:
     """
     q = QBit()
     within_apply(
-        lambda: (allocate(q), X(q)),  # type:ignore[arg-type]
+        lambda: (allocate(q), X(q)),
         lambda: qct_qst_type2(x, q),
     )

classiq/open_library/functions/grover.py

@@ -42,7 +42,7 @@ def phase_oracle(
     """
     aux = QBit()
     within_apply(
-        within=lambda: (allocate(aux), X(aux), H(aux)),  # type:ignore[arg-type]
+        within=lambda: (allocate(aux), X(aux), H(aux)),
         apply=lambda: predicate(target, aux),
     )
 
@@ -68,7 +68,7 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     lsb = QBit()
     bind(packed_vars, [msbs, lsb])
     within_apply(
-        lambda: (X(lsb), H(lsb)),  # type:ignore[arg-type]
+        lambda: (X(lsb), H(lsb)),
         lambda: control(msbs == 0, lambda: X(lsb)),
     )
     bind([msbs, lsb], packed_vars)

classiq/open_library/functions/hea.py

@@ -58,8 +58,8 @@ def full_hea(
     """
     repeat(
         reps,
-        lambda r: [  # type:ignore[arg-type]
-            repeat(  # type:ignore[func-returns-value]
+        lambda r: [
+            repeat(
                 operands_1qubit.len,
                 lambda i1: repeat(
                     num_qubits,
@@ -77,7 +77,7 @@ def full_hea(
                     ),
                 ),
             ),
-            repeat(  # type:ignore[func-returns-value]
+            repeat(
                 operands_2qubit.len,
                 lambda i2: repeat(
                     connectivity_map.len,

classiq/open_library/functions/lookup_table.py

@@ -0,0 +1,58 @@
+from itertools import product
+
+from classiq.interface.exceptions import ClassiqValueError
+
+from classiq.qmod.builtins.operations import assign, bind, within_apply
+from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.symbolic import subscript
+from classiq.qmod.utilities import RealFunction, get_temp_var_name, qnum_values
+
+
+def _get_qnum_values(num: QNum) -> list[float]:
+    size = num.size
+    is_signed = num.is_signed
+    fraction_digits = num.fraction_digits
+    if (
+        not isinstance(size, int)
+        or not isinstance(is_signed, bool)
+        or not isinstance(fraction_digits, int)
+    ):
+        raise ClassiqValueError(
+            "Must call 'span_lookup_table' inside a generative qfunc"
+        )
+
+    return qnum_values(size, is_signed, fraction_digits)
+
+
+def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
+    """
+    Applies a classical function to quantum numbers.
+
+    Works by reducing the function into a lookup table over all the possible values
+    of the quantum numbers.
+
+    Args:
+        func: A Python function
+        *targets: One or more initialized quantum numbers
+
+    Returns:
+        The quantum result of applying func to targets
+
+    Notes:
+        Must be called inside a generative function (`@qfunc(generative=True)`)
+    """
+    if len(targets) == 0:
+        raise ClassiqValueError("No targets specified")
+
+    target_vals = [_get_qnum_values(target) for target in targets]
+    lookup_table = [func(*vals[::-1]) for vals in product(*target_vals[::-1])]
+
+    index_size = sum(target.size for target in targets)
+    index: QNum = QNum(get_temp_var_name(), size=index_size)
+    result: QNum = QNum(get_temp_var_name("result"))
+
+    within_apply(
+        lambda: bind(list(targets), index),
+        lambda: assign(subscript(lookup_table, index), result),
+    )
+    return result

classiq/open_library/functions/modular_exponentiation.py

@@ -70,23 +70,17 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
     aux = QBit()
 
     within_apply(
-        lambda: (  # type:ignore[arg-type]
+        lambda: (
             allocate(aux),
-            bind([c1, c2], ctrl),  # type:ignore[func-returns-value]
+            bind([c1, c2], ctrl),
         ),
-        lambda: (  # type:ignore[arg-type]
-            control(  # type:ignore[func-returns-value]
-                ctrl, lambda: qft_space_add_const(a, phi_b)
-            ),
-            invert(  # type:ignore[func-returns-value]
-                lambda: qft_space_add_const(n, phi_b)
-            ),
+        lambda: (
+            control(ctrl, lambda: qft_space_add_const(a, phi_b)),
+            invert(lambda: qft_space_add_const(n, phi_b)),
             _check_msb(1, phi_b, aux),
-            control(  # type:ignore[func-returns-value]
-                aux, lambda: qft_space_add_const(n, phi_b)
-            ),
+            control(aux, lambda: qft_space_add_const(n, phi_b)),
             within_apply(
-                lambda: invert(  # type:ignore[func-returns-value]
+                lambda: invert(
                     lambda: control(ctrl, lambda: qft_space_add_const(a, phi_b))
                 ),
                 lambda: _check_msb(0, phi_b, aux),
@@ -160,14 +154,10 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
 
     within_apply(
         lambda: allocate(x.len + 1, b),
-        lambda: (  # type:ignore[arg-type]
+        lambda: (
             c_modular_multiply(n, a, b, x, ctrl),
-            control(  # type:ignore[func-returns-value]
-                ctrl, lambda: multiswap(x, b)
-            ),
-            invert(  # type:ignore[func-returns-value]
-                lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)
-            ),
+            control(ctrl, lambda: multiswap(x, b)),
+            invert(lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)),
         ),
     )
 

classiq/open_library/functions/qft_functions.py

@@ -18,9 +18,9 @@ def qft_no_swap(qbv: QArray[QBit]) -> None:
     """
     repeat(
         qbv.len,
-        lambda i: (  # type:ignore[arg-type]
+        lambda i: (
             H(qbv[i]),
-            repeat(  # type:ignore[func-returns-value]
+            repeat(
                 qbv.len - i - 1,
                 lambda j: CPHASE(
                     theta=pi / (2 ** (j + 1)),

classiq/open_library/functions/qsvt.py

@@ -97,8 +97,8 @@ def qsvt(
     if_(
         condition=phase_seq.len % 2 == 1,
         then=lambda: IDENTITY(qvar),
-        else_=lambda: (  # type:ignore[arg-type]
-            u(qvar),  # type:ignore[func-returns-value]
+        else_=lambda: (
+            u(qvar),
             projector_controlled_phase(
                 phase_seq[phase_seq.len - 1],
                 proj_cnot_2,
@@ -297,8 +297,8 @@ def qsvt_lcu(
         condition=phase_seq_odd.len > phase_seq_even.len,
         then=lambda: control(
             lcu == 0,
-            lambda: [  # type:ignore[arg-type]
-                u(qvar),  # type:ignore[func-returns-value]
+            lambda: [
+                u(qvar),
                 projector_controlled_phase(
                     phase_seq_odd[phase_seq_odd.len - 1], proj_cnot_2, qvar, aux
                 ),
@@ -307,8 +307,8 @@ def qsvt_lcu(
     )
     if_(
         condition=phase_seq_odd.len < phase_seq_even.len,
-        then=lambda: (  # type:ignore[arg-type]
-            u(qvar),  # type:ignore[func-returns-value]
+        then=lambda: (
+            u(qvar),
             projector_controlled_double_phase(
                 phase_seq_even[phase_seq_even.len - 1],
                 phase_seq_odd[phase_seq_odd.len - 1],
@@ -319,8 +319,8 @@ def qsvt_lcu(
             ),
             control(
                 lcu,
-                lambda: [  # type:ignore[arg-type]
-                    invert(lambda: u(qvar)),  # type:ignore[func-returns-value]
+                lambda: [
+                    invert(lambda: u(qvar)),
                     projector_controlled_phase(
                         phase_seq_even[phase_seq_even.len - 1], proj_cnot_1, qvar, aux
                     ),

classiq/open_library/functions/utility_functions.py

@@ -79,8 +79,8 @@ def modular_increment(a: CInt, x: QNum) -> None:
     )
     array_cast: QArray = QArray()
     within_apply(
-        lambda: (  # type:ignore[arg-type]
-            bind(x, array_cast),  # type:ignore[func-returns-value]
+        lambda: (
+            bind(x, array_cast),
             qft(array_cast),
         ),
         lambda: repeat(

classiq/qmod/builtins/classical_functions.py

@@ -12,19 +12,25 @@ def qft_const_adder_phase(
     value: CInt,
     reg_len: CInt,
 ) -> CReal:
-    return symbolic_function(bit_index, value, reg_len, return_type=CReal)
+    return symbolic_function(
+        bit_index, value, reg_len, return_type=CReal  # type:ignore[type-abstract]
+    )
 
 
 def fock_hamiltonian_problem_to_hamiltonian(
     problem: FockHamiltonianProblem,
 ) -> CArray[PauliTerm]:
-    return symbolic_function(problem, return_type=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])
+    return symbolic_function(
+        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
+    )
 
 
 def grid_entangler_graph(
@@ -33,14 +39,19 @@ def grid_entangler_graph(
     grid_randomization: CBool,
 ) -> CArray[CArray[CInt]]:
     return symbolic_function(
-        num_qubits, schmidt_rank, grid_randomization, return_type=CArray[CArray[CInt]]
+        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]])
+    return symbolic_function(
+        num_qubits, return_type=CArray[CArray[CInt]]  # type:ignore[type-abstract]
+    )
 
 
 def gaussian_finance_post_process(
@@ -49,7 +60,10 @@ def gaussian_finance_post_process(
     probability: CReal,
 ) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=CReal
+        finance_model,
+        estimation_method,
+        probability,
+        return_type=CReal,  # type:ignore[type-abstract]
     )
 
 
@@ -59,7 +73,10 @@ def log_normal_finance_post_process(
     probability: CReal,
 ) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=CReal
+        finance_model,
+        estimation_method,
+        probability,
+        return_type=CReal,  # type:ignore[type-abstract]
     )
 
 

classiq/qmod/builtins/enums.py

@@ -149,6 +149,7 @@ class Optimizer(IntEnum):
     L_BFGS_B = 3
     NELDER_MEAD = 4
     ADAM = 5
+    SLSQP = 6
 
 
 class Pauli(IntEnum):

classiq/qmod/builtins/functions/__init__.py

@@ -64,6 +64,7 @@ CORE_LIB_DECLS = [
         inplace_prepare_state,
         inplace_prepare_amplitudes,
         single_pauli_exponent,
+        commuting_paulis_exponent,
         suzuki_trotter,
         qdrift,
         exponentiation_with_depth_constraint,
@@ -129,6 +130,7 @@ __all__ = [  # noqa: RUF022
     "randomized_benchmarking",
     "real_xor_constant",
     "single_pauli_exponent",
+    "commuting_paulis_exponent",
     "suzuki_trotter",
     "unitary",
     "RESET",

classiq/qmod/builtins/functions/exponentiation.py

@@ -28,6 +28,30 @@ def single_pauli_exponent(
     pass
 
 
+@qfunc(external=True)
+def commuting_paulis_exponent(
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    qbv: QArray[
+        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
+    ],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Exponentiates the specified commutative Pauli operator.
+    As all the Pauli operator's terms commute, the exponential of the whole operator
+    is exactly the product of exponentials of each term.
+    Calling this funciton with a non-commutative Pauli operator will issue an error.
+
+    Args:
+        pauli_operator: The Pauli operator to be exponentiated.
+        evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
 @qfunc(external=True)
 def suzuki_trotter(
     pauli_operator: CArray[PauliTerm],