classiq 0.67.0__py3-none-any.whl → 0.69.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/bind.py

@@ -16,7 +16,7 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 
 class BindEmitter(Emitter[BindOperation]):
-    def emit(self, bind: BindOperation, /) -> None:
+    def emit(self, bind: BindOperation, /) -> bool:
         inputs, outputs = self._get_inputs_outputs(bind)
         validate_bind_targets(bind, self._current_scope)
         unsized_outputs = [
@@ -56,6 +56,7 @@ class BindEmitter(Emitter[BindOperation]):
                 back_ref=bind.uuid,
             )
         )
+        return True
 
     def _get_inputs_outputs(
         self, bind: BindOperation

classiq/model_expansions/quantum_operations/block_evaluator.py

@@ -0,0 +1,76 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
+
+from classiq.model_expansions.closure import Closure
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Scope
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+_BLOCK_RENAMES = {
+    "compute": "within",
+    "action": "apply",
+}
+_REVERSE_BLOCK_RENAMES = {rename: name for name, rename in _BLOCK_RENAMES.items()}
+
+
+class BlockEvaluator(Emitter[QuantumOperation]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", operation_name: str, *block_names: str
+    ) -> None:
+        super().__init__(interpreter)
+        self._operation_name = operation_name
+        self._block_names: Sequence[str] = block_names
+
+    def emit(self, op: QuantumOperation, /) -> bool:
+        expanded_blocks: dict[str, list[QuantumStatement]] = {}
+        blocks = [
+            block
+            for block in self._block_names
+            if hasattr(op, block) and getattr(op, block) is not None
+        ]
+
+        if len(blocks) > 0:
+            if op.is_generative():
+                expanded_blocks = self.expand_generative_blocks(op)
+            else:
+                expanded_blocks = self.expand_blocks(op, blocks)
+            expanded_blocks.update(expanded_blocks)
+
+        op = op.model_copy(update={**expanded_blocks, "back_ref": op.uuid})
+        self._builder.emit_statement(op)
+        return True
+
+    def expand_blocks(
+        self, op: QuantumOperation, block_names: list[str]
+    ) -> dict[str, list[QuantumStatement]]:
+        blocks = {
+            _BLOCK_RENAMES.get(block, block): getattr(op, block)
+            for block in block_names
+        }
+        block_closure = Closure(
+            name=self._operation_name,
+            scope=Scope(parent=self._current_scope),
+            blocks=blocks,
+        )
+        context = self._expand_operation(block_closure)
+        return {
+            block: context.statements(_BLOCK_RENAMES.get(block, block))
+            for block in block_names
+        }
+
+    def expand_generative_blocks(
+        self, op: QuantumOperation
+    ) -> dict[str, list[QuantumStatement]]:
+        blocks = [
+            block for block in self._block_names if op.has_generative_block(block)
+        ]
+        context = self._expand_generative_context(op, self._operation_name, blocks)
+        return {
+            _REVERSE_BLOCK_RENAMES.get(block, block): context.statements(block)
+            for block in blocks
+        }

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -13,9 +13,6 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.generated_circuit_data import OperationLevel
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -162,11 +159,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             back_ref=self._get_back_ref(propagated_debug_info),
         )
         is_allocate_or_free = new_call.func_name == free.func_decl.name
-        parameters = {
-            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
-            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
-            if isinstance(arg_decl, ClassicalParameterDeclaration)
-        }
 
         port_to_passed_variable_map = {
             arg_decl.name: str(evaluated_arg.value.handle)
@@ -176,11 +168,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self._debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             level=OperationLevel.QMOD_FUNCTION_CALL,
-            parameters=(
-                parameters
-                if propagated_debug_info is None or propagated_debug_info.name == ""
-                else propagated_debug_info.parameters
-            ),
             is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
             node=new_call._as_back_ref(),

classiq/model_expansions/quantum_operations/classicalif.py

@@ -18,7 +18,7 @@ def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
 
 
 class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
-    def emit(self, classical_if: ClassicalIf, /) -> None:
+    def emit(self, classical_if: ClassicalIf, /) -> bool:
         condition = self._interpreter.evaluate(classical_if.condition).as_type(bool)
         op_name = "then" if condition else "else"
         is_generative = classical_if.is_generative()
@@ -26,7 +26,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
         body: Sequence[QuantumStatement]
         if is_generative:
             if not classical_if.has_generative_block(op_name):
-                return
+                return True
             context = self._expand_generative_context(classical_if, op_name, op_name)
             context.blocks["body"] = context.blocks[op_name]
             context.blocks.pop(op_name)
@@ -35,7 +35,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
             body = classical_if.then if condition else classical_if.else_
 
         if _is_all_identity_calls(body):
-            return
+            return True
 
         if is_generative or not self._should_wrap(body):
             for stmt in body:
@@ -43,7 +43,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
                     self._interpreter._builder.emit_statement(stmt)
                 else:
                     self._interpreter.emit_statement(stmt)
-            return
+            return True
 
         then_else_func = FunctionClosure.create(
             name=self._counted_name_allocator.allocate("then" if condition else "else"),
@@ -54,3 +54,4 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
         self._emit_quantum_function_call(
             then_else_func, list(), new_function_debug_info_by_node(classical_if)
         )
+        return True

classiq/model_expansions/quantum_operations/composite_emitter.py

@@ -0,0 +1,27 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Generic
+
+from classiq.model_expansions.quantum_operations.emitter import (
+    Emitter,
+    QuantumStatementT,
+)
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class CompositeEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT]):
+    def __init__(
+        self,
+        interpreter: "BaseInterpreter",
+        emitters: Sequence[Emitter[QuantumStatementT]],
+    ) -> None:
+        super().__init__(interpreter)
+        self._emitters = emitters
+
+    def emit(self, statement: QuantumStatementT, /) -> bool:
+        for emitter in self._emitters:
+            if emitter.emit(statement):
+                return True
+        self._builder.emit_statement(statement)
+        return True

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,3 +1,4 @@
+import ast
 from abc import ABC, abstractmethod
 from typing import (
     TYPE_CHECKING,
@@ -39,12 +40,15 @@ from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     translate_sympy_quantum_expression,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
-QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
+QuantumStatementT = TypeVar(
+    "QuantumStatementT", bound=QuantumStatement, contravariant=True
+)
 
 
 class Emitter(Generic[QuantumStatementT], ABC):
@@ -60,7 +64,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
         )
 
     @abstractmethod
-    def emit(self, statement: QuantumStatementT, /) -> None:
+    def emit(self, statement: QuantumStatementT, /) -> bool:
         pass
 
     def _expand_operation(self, closure: Closure) -> OperationContext:
@@ -173,3 +177,13 @@ class Emitter(Generic[QuantumStatementT], ABC):
             defining_function=defining_function,
             direction=direction,
         )
+
+    def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expr.expr))
+        handles = dict.fromkeys(
+            handle
+            for handle in vrc.var_handles
+            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+        )
+        return [self._interpreter.evaluate(handle).value for handle in handles]

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class ExpressionEvaluator(Emitter[QuantumOperation]):
+    def __init__(self, interpreter: "BaseInterpreter", expression_name: str) -> None:
+        super().__init__(interpreter)
+        self._expression_name = expression_name
+
+    def emit(self, op: QuantumOperation, /) -> bool:
+        expression = getattr(op, self._expression_name)
+        if not isinstance(expression, Expression) or expression.is_evaluated():
+            return False
+        evaluated_expression = self._evaluate_expression(
+            expression, preserve_bool_ops=True
+        )
+        for symbol in self._get_symbols_in_expression(evaluated_expression):
+            self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)
+        op = op.model_copy(
+            update={self._expression_name: evaluated_expression, "back_ref": op.uuid}
+        )
+        self._interpreter.emit(op)
+        return True

classiq/model_expansions/quantum_operations/handle_evaluator.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class HandleEvaluator(Emitter[QuantumOperation]):
+    def __init__(self, interpreter: "BaseInterpreter", handle_name: str) -> None:
+        super().__init__(interpreter)
+        self._handle_name = handle_name
+
+    def emit(self, op: QuantumOperation, /) -> bool:
+        handle = getattr(op, self._handle_name)
+        if not isinstance(handle, HandleBinding):
+            return False
+        evaluated_handle = self._interpreter.evaluate(handle).value.handle
+        if handle == evaluated_handle:
+            return False
+        op = op.model_copy(
+            update={self._handle_name: evaluated_handle, "back_ref": op.uuid}
+        )
+        self._interpreter.emit(op)
+        return True

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -28,16 +28,17 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         super().__init__(interpreter)
         self._model = self._interpreter._model
 
-    def emit(self, call: QuantumFunctionCall, /) -> None:
+    def emit(self, call: QuantumFunctionCall, /) -> bool:
         if call.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
             self._allocate_compatibility(call)
-            return
+            return True
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name):
             self._emit_quantum_function_call(
                 function, args, self._debug_info.get(call.uuid)
             )
+        return True
 
     def _allocate_compatibility(self, call: QuantumFunctionCall) -> None:
         if len(call.positional_args) != 2:

classiq/model_expansions/quantum_operations/repeat.py

@@ -17,7 +17,7 @@ from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 class RepeatEmitter(CallEmitter[Repeat]):
-    def emit(self, repeat: Repeat, /) -> None:
+    def emit(self, repeat: Repeat, /) -> bool:
         count = self._interpreter.evaluate(repeat.count).as_type(int)
         if count < 0:
             raise ClassiqExpansionError(
@@ -26,6 +26,7 @@ class RepeatEmitter(CallEmitter[Repeat]):
         op_name = self._counted_name_allocator.allocate(REPEAT_OPERATOR_NAME)
         for i in range(count):
             self._emit_iteration(repeat, i, op_name)
+        return True
 
     def _emit_iteration(self, repeat: Repeat, i: int, op_name: str) -> None:
         closure_constructor: type[FunctionClosure]

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -12,7 +12,7 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
-    def emit(self, variable_declaration: VariableDeclarationStatement, /) -> None:
+    def emit(self, variable_declaration: VariableDeclarationStatement, /) -> bool:
         var_decl = variable_declaration.model_copy(
             update=dict(back_ref=variable_declaration.uuid)
         )
@@ -36,3 +36,4 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
             var_decl.name, self._builder.current_function
         )
         self.emit_statement(var_decl)
+        return True

classiq/model_expansions/scope_initialization.py

@@ -3,10 +3,6 @@ from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
 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.concrete_types import ConcreteClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
@@ -129,12 +125,6 @@ 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)
@@ -145,21 +135,17 @@ def _add_exec_param_parts_to_scope(param_val: Any, scope: Scope) -> None:
 
 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.as_symbolic(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

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -174,6 +174,6 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
     def visit_Attribute(self, node: ast.Attribute) -> ast.Call:
         return ast.Call(
             func=ast.Name("get_field"),
-            args=[node.value, ast.Constant(value=node.attr)],
+            args=[self.visit(node.value), ast.Constant(value=node.attr)],
             keywords=[],
         )

classiq/open_library/functions/__init__.py

@@ -10,7 +10,7 @@ from .hea import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
 from .modular_exponentiation import *
-from .modular_exponentiation import _check_msb, _ctrl_x
+from .modular_exponentiation import _check_msb
 from .qaoa_penalty import *
 from .qft_functions import *
 from .qpe import *
@@ -72,7 +72,6 @@ OPEN_LIBRARY_FUNCTIONS = [
     qst_type2,
     modular_increment,
     qft,
-    _ctrl_x,
     _prepare_uniform_trimmed_state_step,
     _qct_d_operator,
     _qct_pi_operator,

classiq/open_library/functions/amplitude_amplification.py

@@ -4,7 +4,7 @@ from classiq.qmod.builtins.operations import (
     allocate,
     bind,
     control,
-    repeat,
+    power,
     within_apply,
 )
 from classiq.qmod.cparam import CInt, CReal
@@ -24,7 +24,7 @@ def amplitude_amplification(
     """
     [Qmod Classiq-library function]
 
-    Applies the Amplitude Amplification algorithm (QAE); Prepares a state using the given `space_transform` function, and applies `reps` repetititions
+    Applies the Amplitude Amplification algorithm; Prepares a state using the given `space_transform` function, and applies `reps` repetititions
     of the grover operator, using the given `oracle` functions which marks the "good" states.
 
     Args:
@@ -34,7 +34,10 @@ def amplitude_amplification(
         packed_vars: The variable that holds the state to be amplified. Assumed to be in the zero state at the beginning of the algorithm.
     """
     space_transform(packed_qvars)
-    repeat(reps, lambda index: grover_operator(oracle, space_transform, packed_qvars))
+    power(
+        reps,
+        lambda: grover_operator(oracle, space_transform, packed_qvars),
+    )
 
 
 @qfunc
@@ -47,7 +50,7 @@ def exact_amplitude_amplification(
     """
     [Qmod Classiq-library function]
 
-    Applies an exact version of the Amplitude Amplification algorithm (QAE), assuming knowledge of the amplitude of the marked state.
+    Applies an exact version of the Amplitude Amplification algorithm, assuming knowledge of the amplitude of the marked state.
     The function should be applied on the zero state, and it takes care for preparing the initial state before amplification using the `space_transform`.
 
     Based on the algorithm in [Quantum state preparation without coherent arithmetic](https://arxiv.org/abs/2210.14892).
@@ -68,13 +71,11 @@ def exact_amplitude_amplification(
     theta = pi / (4 * k + 2)
     rot_phase = 2 * acos(sin(theta) / amplitude)
 
-    extended_qvars: QArray = QArray("extended_qvars")
+    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,
@@ -82,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

@@ -1,13 +1,11 @@
 from classiq.open_library.functions.qft_functions import qft
-from classiq.open_library.functions.utility_functions import (
-    apply_to_all,
-    modular_increment,
-)
+from classiq.open_library.functions.utility_functions import apply_to_all
 from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
 from classiq.qmod.builtins.operations import (
     allocate,
     bind,
     control,
+    inplace_add,
     invert,
     repeat,
     within_apply,
@@ -30,8 +28,13 @@ def _qct_d_operator(x: QNum, q: QBit) -> None:
 
 @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))
+    control(
+        q == 1,
+        lambda: [
+            apply_to_all(X, x),
+            inplace_add(1, x),  # type:ignore[arg-type]
+        ],
+    )
 
 
 def _t_operator(x: QArray) -> None:
@@ -63,11 +66,11 @@ def _d1_operator(x: QArray[QBit], q: QBit) -> None:
 
 
 def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
-    control(q == 1, lambda: modular_increment(1, x))
+    control(q == 1, lambda: inplace_add(1, x))  # type:ignore[arg-type]
 
 
 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:
@@ -76,7 +79,7 @@ def _b_t_operator(q: QBit) -> None:
 
 
 def _d0dt_operator(x: QArray, q: QBit) -> None:
-    x_num: QNum = QNum("x_num", x.len, False, 0)
+    x_num: QNum = QNum(size=x.len)
     bind(x, x_num)
     _b_t_operator(q)
     control(x_num == 0, lambda: _j_operator(q))
@@ -140,7 +143,7 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
         x: The LSB part of the qubit array to apply the transform to.
         q: The MSB of the qubit array to apply the transform to.
     """
-    extended_state: QArray = QArray("extended_state")
+    extended_state: QArray = QArray()
     _vn_operator(x, q)
     bind([x, q], extended_state)
     qft(extended_state)
@@ -159,8 +162,8 @@ def qct_type2(x: QArray[QBit]) -> None:
     Args:
         x: The qubit array to apply the transform to.
     """
-    q = QBit("q")
-    within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
+    q = QBit()
+    within_apply(lambda: allocate(q), lambda: qct_qst_type2(x, q))
 
 
 @qfunc
@@ -174,8 +177,8 @@ def qst_type2(x: QArray[QBit]) -> None:
     Args:
         x: The qubit array to apply the transform to.
     """
-    q = QBit("q")
+    q = QBit()
     within_apply(
-        lambda: (allocate(1, q), X(q)),  # type:ignore[arg-type]
+        lambda: (allocate(q), X(q)),
         lambda: qct_qst_type2(x, q),
     )

classiq/open_library/functions/grover.py

@@ -40,9 +40,9 @@ def phase_oracle(
         predicate: A predicate function that takes a QArray of QBits and sets a single QBit |1> if the predicate is true, and |0> otherwise.
         target: The target QArray of QBits to apply the phase oracle to.
     """
-    aux = QBit("aux")
+    aux = QBit()
     within_apply(
-        within=lambda: (allocate(1, aux), X(aux), H(aux)),  # type:ignore[arg-type]
+        within=lambda: (allocate(aux), X(aux), H(aux)),
         apply=lambda: predicate(target, aux),
     )
 
@@ -64,11 +64,11 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     Args:
         packed_vars: The quantum state to reflect.
     """
-    msbs: QNum = QNum("msbs", packed_vars.len - 1, False, 0)
-    lsb = QBit("lsb")
+    msbs: QNum = QNum(size=packed_vars.len - 1)
+    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)
@@ -126,7 +126,7 @@ def grover_operator(
         packed_vars: The state to which to apply the grover operator.
     """
     oracle(packed_vars)
-    grover_diffuser(lambda qba: space_transform(qba), packed_vars)
+    grover_diffuser(space_transform, packed_vars)
     U(0, 0, 0, pi, packed_vars[0])
 
 
@@ -149,9 +149,5 @@ def grover_search(
     hadamard_transform(packed_vars)
     power(
         reps,
-        lambda: grover_operator(
-            lambda qba: oracle(qba),
-            lambda qba: hadamard_transform(qba),
-            packed_vars,
-        ),
+        lambda: grover_operator(oracle, hadamard_transform, 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,