classiq 0.100.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

classiq/interface/helpers/model_normalizer.py

@@ -6,11 +6,32 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.visitor import Transformer, Visitor
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model
-from classiq.interface.model.port_declaration import AnonPortDeclaration
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import (
+    PortDeclaration,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
 
 class ModelNormalizer(Visitor):
+    def __init__(
+        self,
+        normalize_func_names: bool = False,
+        normalize_quantum_var_names: bool = False,
+    ) -> None:
+        self._normalize_func_names = normalize_func_names
+        self._normalize_quantum_var_names = normalize_quantum_var_names
+        self._funcs_renames: dict[str, str] = {}
+        self._count_name = CountedNameAllocator()
+        self.original_names: dict[str, str] = {}
+
     def visit(self, node: Any) -> None:
         if isinstance(node, ASTNode):
             node.model_config["frozen"] = False
@@ -23,10 +44,49 @@ class ModelNormalizer(Visitor):
     def visit_Model(self, model: Model) -> None:
         model.debug_info = DebugInfoCollection()
         model.functions.sort(key=lambda x: x.name)
+        self._funcs_renames = {
+            func.name: f"___func_{index}" for index, func in enumerate(model.functions)
+        }
         self.generic_visit(model)
 
-    def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
+    def visit_NativeFunctionDefinition(self, func: NativeFunctionDefinition) -> None:
+        if self._normalize_func_names:
+            func.name = self._funcs_renames[func.name]
+        self.generic_visit(func)
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        if self._normalize_func_names:
+            if isinstance(call.function, str):
+                if call.function in self._funcs_renames:
+                    call.function = self._funcs_renames[call.function]
+            else:
+                if call.function.name in self._funcs_renames:
+                    call.function.name = self._funcs_renames[call.function.name]
+        self.generic_visit(call)
+
+    def visit_PortDeclaration(self, decl: PortDeclaration) -> None:
         decl.type_modifier = TypeModifier.Mutable
+        self._rename_quantum_var(decl, "_port")
+
+    def visit_VariableDeclarationStatement(
+        self, var: VariableDeclarationStatement
+    ) -> None:
+        self._rename_quantum_var(var, "_var")
+
+    def _rename_quantum_var(
+        self, var: VariableDeclarationStatement | PortDeclaration, new_name_prefix: str
+    ) -> None:
+        if self._normalize_quantum_var_names:
+            old_name = var.name
+            var.name = self._count_name.allocate(new_name_prefix)
+            self.original_names[old_name] = var.name
+
+    def visit_HandleBinding(self, handle: HandleBinding) -> None:
+        if self._normalize_quantum_var_names:
+            # this is a hack use just for testing, do not use in production
+            object.__setattr__(
+                handle, "name", self.original_names.get(handle.name, handle.name)
+            )
 
 
 class ClearModelInternals(Transformer):

classiq/interface/helpers/text_utils.py

@@ -1,22 +1,33 @@
-def s(items: list | int) -> str:
-    if isinstance(items, list):
+from collections.abc import Sequence, Sized
+
+
+def s(items: Sized | int) -> str:
+    if isinstance(items, Sized):
         items = len(items)
     return "" if items == 1 else "s"
 
 
-def are(items: list) -> str:
+def are(items: Sized) -> str:
     return "is" if len(items) == 1 else "are"
 
 
-def they(items: list) -> str:
+def were(items: Sized) -> str:
+    return "was" if len(items) == 1 else "were"
+
+
+def an(items: Sized) -> str:
+    return "an " if len(items) == 1 else ""
+
+
+def they(items: Sized) -> str:
     return "it" if len(items) == 1 else "they"
 
 
-def conj(items: list) -> str:
+def conj(items: Sized) -> str:
     return "s" if len(items) == 1 else ""
 
 
-def readable_list(items: list, quote: bool = False) -> str:
+def readable_list(items: Sequence, quote: bool = False) -> str:
     if quote:
         items = [repr(str(item)) for item in items]
     if len(items) == 1:

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "15"
+INTERFACE_VERSION = "16"

classiq/interface/model/invert.py

@@ -1,16 +1,25 @@
 from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.ast_node import ASTNodeType, reset_lists
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
 
+class BlockKind(StrEnum):
+    SingleCall = "single_call"
+    Compound = "compound"
+
+
 class Invert(QuantumOperation):
     kind: Literal["Invert"]
 
     body: "StatementBlock"
+    block_kind: BlockKind = BlockKind.Compound
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
@@ -18,3 +27,9 @@ class Invert(QuantumOperation):
     @property
     def blocks(self) -> dict[str, "StatementBlock"]:
         return {"body": self.body}
+
+    def validate_node(self) -> None:
+        if self.block_kind == BlockKind.SingleCall and (
+            len(self.body) != 1 or not isinstance(self.body[0], QuantumFunctionCall)
+        ):
+            raise ClassiqInternalExpansionError("Malformed single-call invert")

classiq/interface/model/model.py

@@ -5,6 +5,7 @@ from typing import Annotated, Any, Literal, NewType
 import pydantic
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.compression_utils import compress_pydantic, decompress
 from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -96,9 +97,9 @@ class Model(VersionedModel, ASTNode):
     )
     preferences: Preferences = pydantic.Field(default_factory=Preferences)
 
-    debug_info: DebugInfoCollection = pydantic.Field(
-        default_factory=DebugInfoCollection
-    )
+    _debug_info: DebugInfoCollection | None = pydantic.PrivateAttr(default=None)
+    compressed_debug_info: bytes | None = pydantic.Field(default=None)
+
     functions_compilation_metadata: defaultdict[
         str,
         Annotated[
@@ -198,3 +199,41 @@ class Model(VersionedModel, ASTNode):
         return model.model_dump(
             exclude={"constraints", "execution_preferences", "preferences"},
         )
+
+    # TODO (CLS-4966): remove
+    @pydantic.model_validator(mode="wrap")
+    @classmethod
+    def get_deprecated_debug_info(
+        cls, data: Any, handler: pydantic.ModelWrapValidatorHandler
+    ) -> "Model":
+        model = handler(data)
+        if isinstance(data, dict) and "debug_info" in data:
+            model._debug_info = DebugInfoCollection.model_validate(data["debug_info"])
+        return model
+
+    @property
+    def debug_info(self) -> DebugInfoCollection:
+        if self._debug_info is None:
+            if self.compressed_debug_info is None:
+                self._debug_info = DebugInfoCollection()
+            else:
+                self._debug_info = DebugInfoCollection.model_validate(
+                    decompress(self.compressed_debug_info)
+                )
+
+        return self._debug_info
+
+    @debug_info.setter
+    def debug_info(self, value: DebugInfoCollection) -> None:
+        self._debug_info = value
+        self.compressed_debug_info = None
+
+    def clear_debug_info(self) -> None:
+        self._debug_info = None
+        self.compressed_debug_info = None
+
+    def compress_debug_info(self) -> None:
+        if self._debug_info is None:
+            self.compressed_debug_info = None
+        else:
+            self.compressed_debug_info = compress_pydantic(self._debug_info)

classiq/interface/model/model_visitor.py

@@ -10,8 +10,10 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 
 
 class ModelVisitor(Visitor):
-    def visit_DebugInfoCollection(self, debug_info: DebugInfoCollection) -> None:
-        return
+    def visit_DebugInfoCollection(
+        self, debug_info: DebugInfoCollection
+    ) -> RetType | None:
+        return None
 
 
 class ModelStatementsVisitor(ModelVisitor):

classiq/interface/model/quantum_function_call.py

@@ -29,6 +29,13 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
+
+def _split_concatenation(var: HandleBinding | HandlesList) -> list[HandleBinding]:
+    if isinstance(var, HandleBinding):
+        return [var]
+    return list(chain.from_iterable(_split_concatenation(item) for item in var.handles))
+
+
 ArgValue = Union[
     Expression,
     QuantumOperand,
@@ -221,18 +228,23 @@ class QuantumFunctionCall(QuantumOperation):
     def _get_handles_with_declarations(
         self,
     ) -> Iterable[tuple[int, AnonPortDeclaration, HandleBinding]]:
+        """
+        Get variable arguments attached to their position and parameter declaration.
+        Splits concatenations into variables.
+        """
         return [
-            (idx, port, handle)
-            for idx, (port, handle) in enumerate(
+            (positional_idx, port, var)
+            for positional_idx, (port, var_or_concatenation) in enumerate(
                 zip(
                     (port_decl for port_decl in self.func_decl.port_declarations),
                     (
-                        param
-                        for param in self.positional_args
-                        if isinstance(param, HandleBinding)
+                        arg
+                        for arg in self.positional_args
+                        if isinstance(arg, (HandleBinding, HandlesList))
                     ),
                 )
             )
+            for var in _split_concatenation(var_or_concatenation)
         ]
 
     def _get_readable_location(

classiq/interface/model/quantum_type.py

@@ -78,6 +78,9 @@ class QuantumType(HashableASTNode):
     def without_symbolic_attributes(self) -> Self:
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        return {}
+
 
 class QuantumScalar(QuantumType):
     @property
@@ -262,6 +265,14 @@ class QuantumBitvector(QuantumType):
             length = 1
         return length * self.element_type.minimal_size_in_bits
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_constant_length:
+            attrs[f"{path_expr_prefix}.len"] = self.length_value
+        return attrs | self.element_type.get_compile_time_attributes(
+            f"{path_expr_prefix}[0]"
+        )
+
     def without_symbolic_attributes(self) -> "QuantumBitvector":
         length = (
             None
@@ -301,6 +312,16 @@ class QuantumNumeric(QuantumScalar):
             )
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_size_in_bits:
+            attrs[f"{path_expr_prefix}.size"] = self.size_in_bits
+        if self.has_constant_sign:
+            attrs[f"{path_expr_prefix}.is_signed"] = self.sign_value
+        if self.has_constant_fraction_digits:
+            attrs[f"{path_expr_prefix}.fraction_digits"] = self.fraction_digits_value
+        return attrs
+
     def set_size_in_bits(self, val: int) -> None:
         super().set_size_in_bits(val)
         if self.size is not None:

classiq/interface/model/statement_block.py

@@ -13,9 +13,6 @@ from classiq.interface.model.invert import Invert
 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,
 )
@@ -38,7 +35,6 @@ ConcreteQuantumStatement = Annotated[
         QuantumFunctionCall,
         Allocate,
         ArithmeticOperation,
-        AmplitudeLoadingOperation,
         VariableDeclarationStatement,
         BindOperation,
         InplaceBinaryOperation,

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
@@ -159,7 +164,7 @@ class BaseInterpreter:
         finally:
             self._error_manager.report_errors(ClassiqExpansionError)
 
-        return Model(
+        model = Model(
             constraints=self._model.constraints,
             preferences=self._model.preferences,
             classical_execution_code=self._model.classical_execution_code,
@@ -181,9 +186,10 @@ class BaseInterpreter:
                 if name not in BUILTIN_STRUCT_DECLARATIONS
             ],
             qstructs=list(QMODULE.qstruct_decls.values()),
-            debug_info=self._model.debug_info,
             functions_compilation_metadata=self._expanded_functions_compilation_metadata,
         )
+        model.debug_info = self._model.debug_info
+        return model
 
     def process_exception(self, e: Exception) -> None:
         if not isinstance(e, (ClassiqError, ValidationError)):
@@ -206,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:
@@ -222,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"),