classiq 0.102.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

classiq/interface/qubits_mapping/qubits_mapping.py

@@ -0,0 +1,231 @@
+import dataclasses
+import itertools
+from collections.abc import Iterable, Iterator
+from contextlib import contextmanager
+from typing import Any, Generic, TypeGuard, TypeVar, cast
+
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.generator.visitor import RetType
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.model import Model
+from classiq.interface.model.model_visitor import ModelStatementsVisitor
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    QuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_type import QuantumType
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from .path_expr_range import get_path_expr_range
+from .slices import Slices
+
+
+@dataclasses.dataclass
+class FunctionScope:
+    variables: dict[str, ConcreteQuantumType] = dataclasses.field(default_factory=dict)
+    allocated_variables: dict[str, Slices] = dataclasses.field(default_factory=dict)
+    total_resources: int = dataclasses.field(default=0)
+
+    def add_new_var(self, var_name: str, quantum_type: ConcreteQuantumType) -> None:
+        self.variables[var_name] = quantum_type
+
+    def allocate_new_var(self, var_name: str, var_size: int) -> None:
+        new_total_resources = self.total_resources + var_size
+        self.allocated_variables[var_name] = Slices(
+            [(self.total_resources, new_total_resources)]
+        )
+        self.total_resources = new_total_resources
+
+    def bind_slices_to_var(self, var_name: str, slices: Slices) -> None:
+        self.allocated_variables[var_name] = slices
+
+
+T = TypeVar("T", bound=FunctionScope)
+
+FREE_NAME = "free"
+
+
+class QubitsMapping(Generic[T], ModelStatementsVisitor):
+    """
+    Visitor that maps quantum variables to virtual qubit slices in a quantum model.
+
+    This visitor traverses the model's quantum functions and tracks the mapping of
+    quantum variables to their virtual qubit allocations. It maintains scopes for each
+    function, tracks the call stack, and maps variables to slices representing ranges
+    of qubits. This class assumes that the visited model is a compiled qmod, which mainly
+    means that all allocations are in the main function, and the model does not contain within_apply.
+    """
+
+    def __init__(self, scope_type: type[FunctionScope] = FunctionScope) -> None:
+        super().__init__()
+        self._scope_type: type[T] = cast(type[T], scope_type)
+        self.scopes: dict[str, T] = {}
+        self._main_func_name: str
+        self._current_function: str
+
+    @property
+    def _current_scope(self) -> T:
+        return self.scopes[self._current_function]
+
+    @contextmanager
+    def _function_scoping(
+        self, func_def: NamedParamsQuantumFunctionDeclaration
+    ) -> Iterator[T]:
+        func_name = func_def.name
+        _previous_function = self._current_function
+        self._current_function = func_name
+        self.scopes[func_name] = self._initialize_function_scope(func_def)
+        yield self.scopes[func_name]
+        self._current_function = _previous_function
+
+    def _is_entry_point(self, func_name: str) -> bool:
+        return func_name == self._main_func_name
+
+    def _is_free_function_call(self, call: QuantumFunctionCall) -> bool:
+        return call.func_decl.name == FREE_NAME
+
+    def _is_function_with_definition(
+        self, func_decl: QuantumFunctionDeclaration
+    ) -> TypeGuard[NativeFunctionDefinition]:
+        return isinstance(func_decl, NativeFunctionDefinition)
+
+    def visit_Model(self, model: Model) -> RetType | None:
+        self._main_func_name = model.main_func.name
+        self._current_function = self._main_func_name
+        self.visit_BaseModel(model)
+        return None
+
+    def visit_NativeFunctionDefinition(
+        self, func: NativeFunctionDefinition
+    ) -> RetType | None:
+        if func.name in self.scopes:
+            return None
+        with self._function_scoping(func):
+            self.visit(func.body)
+        return None
+
+    def visit_Allocate(self, stat: Allocate) -> RetType | None:
+        if not self._is_entry_point(self._current_function):
+            raise ClassiqInternalError(
+                "compiled qmod can't have allocation outside of main function"
+            )
+        var_name = stat.target.name
+        var_type = self._current_scope.variables[var_name]
+        self._current_scope.allocate_new_var(stat.target.name, var_type.size_in_bits)
+        return None
+
+    def visit_VariableDeclarationStatement(
+        self, stat: VariableDeclarationStatement
+    ) -> RetType | None:
+        if isinstance(stat.qmod_type, QuantumType):
+            self._current_scope.add_new_var(stat.name, stat.qmod_type)
+        return None
+
+    def _visit_free_function_call(self, stat: QuantumFunctionCall) -> None | Any:
+        if not self._is_entry_point(self._current_function):
+            raise ClassiqInternalError(
+                "compiled qmod can't have free outside of main function"
+            )
+        input_name = stat.inputs[0].name
+        self._current_scope.allocated_variables.pop(input_name)
+        return None
+
+    def _visit_quantum_function_call(self, stat: QuantumFunctionCall) -> None | Any:
+        if self._is_free_function_call(stat):
+            self._visit_free_function_call(stat)
+            return None
+        func_decl = stat.func_decl
+        if not self._is_function_with_definition(func_decl):
+            return None
+        input_slices = self.get_call_input_slices(stat)
+        end_call_scope = self.scopes[stat.func_decl.name]
+        for port, handle in zip(func_decl.port_declarations, stat.ports):
+            if port.direction == PortDeclarationDirection.Input:
+                new_slices = Slices()
+            else:
+                relative_output = end_call_scope.allocated_variables[port.name]
+                new_slices = input_slices.mapping_virtual_slices(relative_output)
+            self._update_by_handle(handle, new_slices, port.direction)
+        return None
+
+    def visit_QuantumFunctionCall(self, stat: QuantumFunctionCall) -> RetType | None:
+        if self._is_free_function_call(stat):
+            self._visit_free_function_call(stat)
+            return None
+        self._visit_quantum_function_call(stat)
+        return None
+
+    def visit_BindOperation(self, stat: BindOperation) -> RetType | None:
+        input_slices = self._handles_to_slices(stat.in_handles)
+        for in_handle in stat.in_handles:
+            self._current_scope.allocated_variables.pop(in_handle.name)
+        start_index, end_index = 0, 0
+        for out in stat.out_handles:
+            out_var = self._current_scope.variables[out.name]
+            end_index += out_var.size_in_bits
+            new_slices = input_slices.get_virtual_slice(start_index, end_index)
+            self._update_by_handle(out, new_slices, PortDeclarationDirection.Output)
+            start_index = end_index
+        return None
+
+    def get_call_input_slices(self, stat: QuantumFunctionCall) -> Slices:
+        input_handles = (
+            handle
+            for inp, handle in zip(stat.func_decl.port_declarations, stat.ports)
+            if inp.direction.is_input
+        )
+        return self._handles_to_slices(input_handles)
+
+    def _handles_to_slices(self, handles: Iterable[ConcreteHandleBinding]) -> Slices:
+        return Slices(
+            itertools.chain.from_iterable(
+                self._handle_to_slices(handle) for handle in handles
+            )
+        )
+
+    def _handle_to_slices(self, handle: HandleBinding) -> Slices:
+        quantum_type = self._current_scope.variables[handle.name]
+        var_mapping = self._current_scope.allocated_variables[handle.name]
+        start, stop = get_path_expr_range(handle, quantum_type)
+        return var_mapping.get_virtual_slice(start, stop)
+
+    def _update_by_handle(
+        self,
+        handle: HandleBinding,
+        new_slices: Slices,
+        direction: PortDeclarationDirection,
+    ) -> None:
+        if direction == PortDeclarationDirection.Input:
+            self._current_scope.allocated_variables.pop(handle.name)
+        elif direction == PortDeclarationDirection.Output:
+            pass
+        else:
+            quantum_type = self._current_scope.variables[handle.name]
+            start, stop = get_path_expr_range(handle, quantum_type)
+            var_mapping = self._current_scope.allocated_variables[handle.name].copy()
+            var_mapping.update_virtual_slice(start, stop, new_slices)
+            new_slices = var_mapping
+        self._current_scope.bind_slices_to_var(handle.name, new_slices)
+
+    def _initialize_function_scope(
+        self, func_def: NamedParamsQuantumFunctionDeclaration
+    ) -> T:
+        function_variables = self._scope_type()
+        ports = func_def.port_declarations
+        for port in ports:
+            function_variables.add_new_var(port.name, port.quantum_type)
+            if port.direction != PortDeclarationDirection.Output:
+                function_variables.allocate_new_var(
+                    port.name, port.quantum_type.size_in_bits
+                )
+        return function_variables

classiq/interface/qubits_mapping/slices.py

@@ -0,0 +1,112 @@
+from collections import deque
+from collections.abc import Iterable, Reversible
+from itertools import chain
+
+from typing_extensions import override
+
+
+class Slices(deque[tuple[int, int]]):
+    """A deque of slice objects that automatically merges adjacent slices.
+
+    Slices represent a collection of non-overlapping, potentially non-contiguous
+    slice ranges. When slices are appended or prepended, adjacent slices are
+    automatically merged to maintain a compact representation. Methods use virtual
+    notation, access the elements in the object as if all slices were explicitly
+    written out contiguously.
+
+    The class is primarily used for managing qubit allocations and mappings in
+    quantum circuit synthesis, where it tracks which physical qubit ranges
+    correspond to logical variable ranges.
+    """
+
+    @override
+    def append(self, physical_slice: tuple[int, int]) -> None:
+        if self and self[-1][1] == physical_slice[0]:
+            last_physical_slice = self.pop()
+            new_physical_slice = (last_physical_slice[0], physical_slice[1])
+        else:
+            new_physical_slice = physical_slice
+        super().append(new_physical_slice)
+
+    @override
+    def appendleft(self, physical_slice: tuple[int, int]) -> None:
+        if self and self[0][0] == physical_slice[1]:
+            first_physical_slice = self.popleft()
+            new_physical_slice = (physical_slice[0], first_physical_slice[1])
+        else:
+            new_physical_slice = physical_slice
+        super().appendleft(new_physical_slice)
+
+    def _multiple_appendleft(
+        self, physical_slices: Reversible[tuple[int, int]]
+    ) -> None:
+        for physical_slice in reversed(physical_slices):
+            self.appendleft(physical_slice)
+
+    @override
+    def extend(self, physical_slices: Iterable[tuple[int, int]]) -> None:
+        for physical_slice in physical_slices:
+            self.append(physical_slice)
+
+    def pop_prefix_virtual_slice(self, virtual_end: int) -> "Slices":
+        result = Slices()
+        current_virtual_end, result_physical_end, physical_slice_end = 0, 0, 0
+        while current_virtual_end < virtual_end:
+            physical_slice_start, physical_slice_end = self.popleft()
+            current_virtual_end += physical_slice_end - physical_slice_start
+            overlap_virtual_end = min(virtual_end, current_virtual_end)
+            result_physical_end = physical_slice_end + (
+                overlap_virtual_end - current_virtual_end
+            )
+            result.append((physical_slice_start, result_physical_end))
+        if result_physical_end != physical_slice_end:
+            self.appendleft((result_physical_end, physical_slice_end))
+        return result
+
+    def get_virtual_slice(self, virtual_start: int, virtual_end: int) -> "Slices":
+        result = Slices()
+        current_virtual_start = 0
+        for physical_slice in self:
+            physical_slice_start, physical_slice_end = physical_slice
+            current_virtual_end = current_virtual_start + (
+                physical_slice_end - physical_slice_start
+            )
+            overlap_virtual_start = max(virtual_start, current_virtual_start)
+            overlap_virtual_end = min(virtual_end, current_virtual_end)
+            if overlap_virtual_start < overlap_virtual_end:
+                new_physical_start = physical_slice_start + (
+                    overlap_virtual_start - current_virtual_start
+                )
+                new_physical_end = physical_slice_end + (
+                    overlap_virtual_end - current_virtual_end
+                )
+                result.append((new_physical_start, new_physical_end))
+            if current_virtual_end >= virtual_end:
+                break
+            current_virtual_start = current_virtual_end
+        return result
+
+    def update_virtual_slice(
+        self, virtual_start: int, virtual_end: int, new: "Slices"
+    ) -> None:
+        start = self.pop_prefix_virtual_slice(virtual_start)
+        self.pop_prefix_virtual_slice(virtual_end - virtual_start)
+        self._multiple_appendleft(new)
+        self._multiple_appendleft(start)
+
+    def mapping_virtual_slices(self, virtual_slices: "Slices") -> "Slices":
+        mappings = Slices()
+        for virtual_slice in virtual_slices:
+            virtual_start, virtual_end = virtual_slice
+            for mapped_slice in self.get_virtual_slice(virtual_start, virtual_end):
+                mappings.append(mapped_slice)
+        return mappings
+
+    def size(self) -> int:
+        return sum(_slice[1] - _slice[0] for _slice in self)
+
+    @property
+    def indices(self) -> tuple[int, ...]:
+        return tuple(
+            chain.from_iterable(range(_slice[0], _slice[1]) for _slice in self)
+        )

classiq/model_expansions/arithmetic.py

@@ -88,6 +88,12 @@ class NumericAttributes:
             return self.lb
         return None
 
+    def fits_in(self, other: "NumericAttributes") -> bool:
+        return (
+            self.integer_digits <= other.integer_digits
+            and self.fraction_digits <= other.fraction_digits
+        )
+
     @classmethod
     def from_bounds(
         cls,

classiq/model_expansions/capturing/captured_vars.py

@@ -56,8 +56,8 @@ if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
 
-INITIALIZED_VAR_MESSAGE = "Variable '{}' should be uninitialized here"
-UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
+_INITIALIZED_VAR_MESSAGE = "Variable '{}' should be uninitialized here"
+_UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
 
 
 def _get_symbol_expr(symbol: str, classical_type: ClassicalType) -> Expression:
@@ -311,7 +311,7 @@ class CapturedVars:
                 return PortDirection.Inout
             if target_direction == PortDirection.Outin:
                 return PortDirection.Input
-            raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+            raise ClassiqExpansionError(_UNINITIALIZED_VAR_MESSAGE.format(var_name))
 
         if source_direction == PortDirection.Output:
             if target_direction == PortDirection.Input:
@@ -320,18 +320,18 @@ class CapturedVars:
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+                raise ClassiqExpansionError(_INITIALIZED_VAR_MESSAGE.format(var_name))
             return PortDirection.Output
 
         if source_direction == PortDirection.Inout:
             if target_direction in (PortDirection.Input, PortDirection.Inout):
                 return target_direction
-            raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+            raise ClassiqExpansionError(_INITIALIZED_VAR_MESSAGE.format(var_name))
 
         if source_direction == PortDirection.Outin:
             if target_direction in (PortDirection.Output, PortDirection.Outin):
                 return target_direction
-            raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+            raise ClassiqExpansionError(_UNINITIALIZED_VAR_MESSAGE.format(var_name))
 
         raise ClassiqInternalExpansionError(f"Unexpected direction {source_direction}")
 
@@ -346,7 +346,7 @@ class CapturedVars:
                 PortDirection.Outin,
             ):
                 raise ClassiqExpansionError(
-                    UNINITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
+                    _UNINITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
                 )
             return existing_captured_handle
 
@@ -356,7 +356,7 @@ class CapturedVars:
                 PortDirection.Outin,
             ):
                 raise ClassiqExpansionError(
-                    INITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
+                    _INITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
                 )
             return captured_handle
 
@@ -705,7 +705,9 @@ class CapturedVars:
     def set_parent(self, parent: "CapturedVars") -> None:
         self._handle_states += parent._get_handle_states()
 
-    def get_state(self, var_name: str, defining_function: "FunctionClosure") -> bool:
+    def get_state(
+        self, var_name: str, defining_function: "FunctionClosure"
+    ) -> bool | None:
         for name, func, state in self._handle_states:
             if name == var_name and _same_closure(func, defining_function):
                 return state
@@ -717,9 +719,7 @@ class CapturedVars:
                     PortDirection.Output,
                     PortDirection.Inout,
                 )
-        raise ClassiqInternalExpansionError(
-            f"Cannot find {var_name!r} from {defining_function.name!r}"
-        )
+        return None
 
     def clone(self) -> "CapturedVars":
         return CapturedVars(
@@ -846,6 +846,10 @@ def validate_end_state(func: "FunctionClosure", captured_vars: CapturedVars) ->
     for param in func.positional_arg_declarations:
         if isinstance(param, PortDeclaration):
             state = captured_vars.get_state(param.name, func)
+            if state is None:
+                raise ClassiqInternalExpansionError(
+                    f"Cannot find {param.name!r} from {func.name!r}"
+                )
             expected_state = param.direction in (
                 PortDeclarationDirection.Output,
                 PortDeclarationDirection.Inout,

classiq/model_expansions/function_builder.py

@@ -13,6 +13,8 @@ from classiq.interface.generator.compiler_keywords import (
 )
 from classiq.interface.generator.functions.builtins.internal_operators import (
     BLOCK_OPERATOR_NAME,
+    INVERT_OPERATOR_NAMES,
+    SINGLE_CALL_INVERT_OPERATOR_NAME,
     SKIP_CONTROL_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
@@ -44,6 +46,7 @@ BLOCKS_ALLOWED_CAPTURING = (
     WITHIN_APPLY_NAME,
     BLOCK_OPERATOR_NAME,
     SKIP_CONTROL_OPERATOR_NAME,
+    SINGLE_CALL_INVERT_OPERATOR_NAME,
 )
 
 
@@ -155,6 +158,8 @@ class OperationBuilder:
         self._operations[-1].blocks[block_name] = block
         yield
         captured_vars = self.current_block.captured_vars
+        if self.current_operation.name in INVERT_OPERATOR_NAMES:
+            captured_vars = captured_vars.negate()
         if (
             not isinstance(self.current_operation, FunctionClosure)
             and self.current_operation.name not in BLOCKS_ALLOWED_CAPTURING
@@ -178,7 +183,10 @@ class OperationBuilder:
             context.closure.captured_vars.init_params(original_operation)
         else:
             context = OperationContext(closure=original_operation)
-            context.closure.captured_vars.set_parent(self.current_block.captured_vars)
+            if context.name != SINGLE_CALL_INVERT_OPERATOR_NAME:
+                context.closure.captured_vars.set_parent(
+                    self.current_block.captured_vars
+                )
         self._operations.append(context)
         yield context
         self._finalize_within_apply()

classiq/model_expansions/interpreters/base_interpreter.py

@@ -32,6 +32,7 @@ from classiq.interface.model.handle_binding import (
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
     QuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
@@ -76,6 +77,7 @@ from classiq.model_expansions.scope_initialization import (
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.constants import __all__ as builtin_constants
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.functions import CORE_LIB_DECLS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
@@ -98,7 +100,7 @@ class BaseInterpreter:
     skip_type_modifier_validation: bool = False
 
     def __init__(self, model: Model) -> None:
-        validate_model(model)
+        validate_model(model, self.get_builtin_functions())
         self._model = model
         self._top_level_scope = Scope()
         self._counted_name_allocator = CountedNameAllocator()
@@ -121,6 +123,9 @@ class BaseInterpreter:
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
+    def get_builtin_functions(self) -> list[NamedParamsQuantumFunctionDeclaration]:
+        return CORE_LIB_DECLS
+
     def _expand_main_func(self) -> None:
         main_closure = self._get_main_closure(
             self._top_level_scope[MAIN_FUNCTION_NAME].value
@@ -207,15 +212,14 @@ class BaseInterpreter:
         expression: Expression,
         *,
         simplify: bool = False,
-        treat_qnum_as_float: bool = False,
     ) -> Evaluated:
         if expression.is_evaluated():
             return Evaluated(value=expression.value.value)
         expr_ast = ast.parse(expression.expr, mode="eval").body
-        expr_val = self._eval_expr(ast.unparse(expr_ast), treat_qnum_as_float)
+        expr_val = self._eval_expr(ast.unparse(expr_ast))
         if simplify and not expr_val.has_value(expr_val.root):
             simplified_expr = simplify_qmod_expression(expr_val)
-            expr_val = self._eval_expr(simplified_expr, treat_qnum_as_float)
+            expr_val = self._eval_expr(simplified_expr)
         if expr_val.has_value(expr_val.root):
             value = expr_val.get_value(expr_val.root)
         else:
@@ -223,12 +227,9 @@ class BaseInterpreter:
 
         return Evaluated(value=value)
 
-    def _eval_expr(
-        self, expr: str, treat_qnum_as_float: bool
-    ) -> QmodAnnotatedExpression:
+    def _eval_expr(self, expr: str) -> QmodAnnotatedExpression:
         return evaluate_qmod_expression(
             expr,
-            treat_qnum_as_float=treat_qnum_as_float,
             machine_precision=self._model.preferences.machine_precision,
             classical_struct_declarations=list(QMODULE.type_decls.values()),
             enum_declarations=list(QMODULE.enum_decls.values()),

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -9,10 +9,11 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     BLOCK_OPERATOR_NAME,
     CLASSICAL_IF_OPERATOR_NAME,
+    COMPOUND_INVERT_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
-    INVERT_OPERATOR_NAME,
     POWER_OPERATOR_NAME,
     REPEAT_OPERATOR_NAME,
+    SINGLE_CALL_INVERT_OPERATOR_NAME,
     SKIP_CONTROL_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
@@ -23,14 +24,11 @@ from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.invert import Invert
+from classiq.interface.model.invert import BlockKind, Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
@@ -199,24 +197,6 @@ class GenerativeInterpreter(BaseInterpreter):
             bind
         )
 
-    @emit.register
-    def emit_amplitude_loading_operation(self, op: AmplitudeLoadingOperation) -> None:
-        CompositeEmitter[AmplitudeLoadingOperation](
-            self,
-            [
-                HandleEvaluator(self, "result_var"),
-                ExpressionEvaluator(
-                    self,
-                    "expression",
-                    readable_expression_name="amplitude-encoding expression",
-                    simplify=True,
-                    treat_qnum_as_float=True,
-                    allow_runtime_vars=self._symbolic_parameters_switch,
-                ),
-                AssignmentResultProcessor(self),
-            ],
-        ).emit(op)
-
     @emit.register
     def _emit_arithmetic_operation(self, op: ArithmeticOperation) -> None:
         self.emit_arithmetic_operation(op)
@@ -285,7 +265,12 @@ class GenerativeInterpreter(BaseInterpreter):
 
     @emit.register
     def emit_invert(self, invert: Invert) -> None:
-        BlockEvaluator(self, INVERT_OPERATOR_NAME, "body").emit(invert)
+        match invert.block_kind:
+            case BlockKind.SingleCall:
+                op_name = SINGLE_CALL_INVERT_OPERATOR_NAME
+            case BlockKind.Compound:
+                op_name = COMPOUND_INVERT_OPERATOR_NAME
+        BlockEvaluator(self, op_name, "body").emit(invert)
 
     @emit.register
     def emit_skip_control(self, skip_control: SkipControl) -> None:

classiq/model_expansions/quantum_operations/arithmetic/explicit_boolean_expressions.py

@@ -50,6 +50,7 @@ def convert_inplace_op_bool_expression(
 def _supported_types() -> tuple[str, ...]:
     return (
         QuantumBit().qmod_type_name,
+        QuantumNumeric().qmod_type_name,
         QuantumNumeric(
             size=Expression(expr="1"),
             is_signed=Expression(expr="False"),