classiq 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

classiq/model_expansions/function_builder.py

@@ -1,6 +1,7 @@
+from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Dict, Generic, Iterable, Iterator, List, Optional, Sequence, TypeVar
+from typing import Generic, Optional, TypeVar
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -35,14 +36,14 @@ ClosureType = TypeVar("ClosureType", bound=Closure)
 
 @dataclass
 class Block:
-    statements: List[QuantumStatement] = field(default_factory=list)
-    captured_vars: List[PortDeclaration] = field(default_factory=list)
+    statements: list[QuantumStatement] = field(default_factory=list)
+    captured_vars: list[PortDeclaration] = field(default_factory=list)
 
 
 @dataclass
 class OperationContext(Generic[ClosureType]):
     closure: ClosureType
-    blocks: Dict[str, Block] = field(default_factory=dict)
+    blocks: dict[str, Block] = field(default_factory=dict)
 
     @property
     def name(self) -> str:
@@ -52,7 +53,7 @@ class OperationContext(Generic[ClosureType]):
     def positional_arg_declarations(self) -> Sequence[PositionalArg]:
         return self.closure.positional_arg_declarations
 
-    def statements(self, block_name: str) -> List[QuantumStatement]:
+    def statements(self, block_name: str) -> list[QuantumStatement]:
         return self.blocks[block_name].statements
 
 
@@ -63,11 +64,11 @@ class FunctionContext(OperationContext[FunctionClosure]):
         return cls(original_function, {"body": Block()})
 
     @property
-    def body(self) -> List[QuantumStatement]:
+    def body(self) -> list[QuantumStatement]:
         return self.statements("body")
 
     @property
-    def captured_vars(self) -> List[PortDeclaration]:
+    def captured_vars(self) -> list[PortDeclaration]:
         return self.blocks["body"].captured_vars
 
     @property
@@ -77,8 +78,8 @@ class FunctionContext(OperationContext[FunctionClosure]):
 
 class OperationBuilder:
     def __init__(self) -> None:
-        self._operations: List[OperationContext] = []
-        self._blocks: List[str] = []
+        self._operations: list[OperationContext] = []
+        self._blocks: list[str] = []
         self._counter = 0
 
     @property
@@ -93,7 +94,7 @@ class OperationBuilder:
         raise ClassiqInternalExpansionError("No function found")
 
     @property
-    def _current_statements(self) -> List[QuantumStatement]:
+    def _current_statements(self) -> list[QuantumStatement]:
         return self._operations[-1].blocks[self._blocks[-1]].statements
 
     def emit_statement(self, statement: QuantumStatement) -> None:
@@ -160,7 +161,7 @@ class OperationBuilder:
             name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{self._counter}"
             self._counter += 1
 
-        new_parameters: List[PortDeclaration] = [
+        new_parameters: list[PortDeclaration] = [
             param
             for param in function_context.positional_arg_declarations
             if isinstance(param, PortDeclaration)
@@ -173,7 +174,7 @@ class OperationBuilder:
         )
 
 
-def validate_captured_vars(captured_vars: List[PortDeclaration]) -> None:
+def validate_captured_vars(captured_vars: list[PortDeclaration]) -> None:
     if input_captured := [
         demangle_name(var.name)
         for var in captured_vars

classiq/model_expansions/generative_functions.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, List, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.qmod_struct_instance import (
@@ -127,7 +128,7 @@ class _InterpreterExpandable(QFunc):
 def emit_generative_statements(
     interpreter: "Interpreter",
     operation: GenerativeClosure,
-    args: List[Evaluated],
+    args: list[Evaluated],
 ) -> None:
     python_qmod_args = [
         translate_ast_arg_to_python_qmod(param, arg)
@@ -185,7 +186,7 @@ def _expand_operand_as_declarative(
 
 
 def _register_declarative_function(interpreter: "Interpreter", func_name: str) -> None:
-    if func_name in nameables_to_dict(interpreter._expanded_functions):
+    if func_name in nameables_to_dict(list(interpreter._expanded_functions.values())):
         return
 
     for user_gen_func in interpreter._generative_functions:
@@ -198,7 +199,7 @@ def _register_declarative_function(interpreter: "Interpreter", func_name: str) -
         dec_func = QFunc(user_gen_func._py_callable)
         dec_func.expand()
         dec_func_def = QMODULE.native_defs[func_name]
-        interpreter._expanded_functions.append(dec_func_def)
+        interpreter._expanded_functions[func_name] = dec_func_def
         _DecFuncVisitor(interpreter).visit(dec_func_def)
 
 

classiq/model_expansions/interpreter.py

@@ -1,7 +1,8 @@
 import copy
+from collections.abc import Iterator, Sequence
 from contextlib import contextmanager, nullcontext
 from functools import singledispatchmethod
-from typing import Any, Iterator, List, Optional, Sequence, Tuple, Type, cast
+from typing import Any, Optional, cast
 
 import numpy as np
 from numpy.random import permutation
@@ -11,6 +12,7 @@ from classiq.interface.exceptions import (
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -88,7 +90,7 @@ from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
-STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: Tuple[Type[QuantumStatement], ...] = (
+STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: tuple[type[QuantumStatement], ...] = (
     QuantumFunctionCall,
     VariableDeclarationStatement,
     QuantumAssignmentOperation,
@@ -99,14 +101,14 @@ class Interpreter:
     def __init__(
         self,
         model: Model,
-        generative_functions: Optional[List[GenerativeQFunc]] = None,
+        generative_functions: Optional[list[GenerativeQFunc]] = None,
         is_frontend: bool = False,
     ) -> None:
         self._is_frontend = is_frontend
         self._model = model
         self._current_scope = Scope()
         self._builder = OperationBuilder()
-        self._expanded_functions: List[NativeFunctionDefinition] = []
+        self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
         self._propagated_var_stack = PropagatedVarStack(
             self._current_scope, self._builder
         )
@@ -117,7 +119,9 @@ class Interpreter:
             generative_functions = []
         self._generative_functions = generative_functions
         init_top_level_scope(model, generative_functions, self._current_scope)
-
+        self._expanded_functions_compilation_metadata: dict[
+            str, CompilationMetadata
+        ] = dict()
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
@@ -150,7 +154,7 @@ class Interpreter:
             main_closure.positional_arg_declarations, main_closure
         )
         context = self._expand_operation(main_closure)
-        self._expanded_functions.append(
+        self._expanded_functions[main_closure.closure_id] = (
             self._builder.create_definition(cast(FunctionContext, context))
         )
 
@@ -173,12 +177,13 @@ class Interpreter:
             preferences=self._model.preferences,
             classical_execution_code=self._model.classical_execution_code,
             execution_preferences=self._model.execution_preferences,
-            functions=self._expanded_functions,
+            functions=list(self._expanded_functions.values()),
             constants=self._model.constants,
             enums=self._model.enums,
             types=self._model.types,
             qstructs=self._model.qstructs,
             debug_info=self._model.debug_info,
+            functions_compilation_metadata=self._expanded_functions_compilation_metadata,
         )
 
     @singledispatchmethod
@@ -196,7 +201,7 @@ class Interpreter:
     @evaluate.register
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         renamed_params = [
-            param.rename(function.get_rename_params()[idx])
+            param.rename(function.pos_rename_params[idx])
             for idx, param in enumerate(function.func_decl.positional_arg_declarations)
         ]
         func_decl = NamedParamsQuantumFunctionDeclaration(
@@ -204,7 +209,7 @@ class Interpreter:
             positional_arg_declarations=renamed_params,
         )
 
-        closure_class: Type[FunctionClosure]
+        closure_class: type[FunctionClosure]
         extra_args: dict[str, Any]
         if function.is_generative():
             closure_class = GenerativeFunctionClosure
@@ -339,7 +344,11 @@ class Interpreter:
 
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
-            if isinstance(operation, FunctionClosure) and operation.name == "permute":
+            if isinstance(operation, FunctionClosure) and (
+                self._expanded_functions.get(operation.closure_id) is not None
+            ):
+                pass
+            elif isinstance(operation, FunctionClosure) and operation.name == "permute":
                 # special expansion since permute is generative
                 with self._scope_guard(operation.scope):
                     self._expand_permute()
@@ -373,5 +382,5 @@ class Interpreter:
         return (
             self._model.functions
             + [gen_func.func_decl for gen_func in self._generative_functions]
-            + self._expanded_functions  # type:ignore[operator]
+            + list(self._expanded_functions.values())
         )

classiq/model_expansions/model_tables.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from enum import IntEnum
-from typing import ClassVar, Dict, Generic, List, Optional, TypeVar
+from typing import ClassVar, Generic, Optional, TypeVar
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
 from classiq.interface.generator.functions.classical_type import QmodPyObject
@@ -18,15 +18,15 @@ DeclarationType = TypeVar(
 
 
 class TypeTable(Generic[DeclarationType], ABC):
-    def __init__(self, user_types: List[DeclarationType]) -> None:
-        self._all_types: Dict[str, DeclarationType] = self.builtins.copy()
+    def __init__(self, user_types: list[DeclarationType]) -> None:
+        self._all_types: dict[str, DeclarationType] = self.builtins.copy()
         for t in user_types:
             assert t.name not in self._all_types  # FIXME: issue user error (CAD-7856)
             self._all_types[t.name] = t
 
     @property
     @abstractmethod
-    def builtins(self) -> Dict[str, DeclarationType]:
+    def builtins(self) -> dict[str, DeclarationType]:
         pass
 
     def __getitem__(self, key: str) -> DeclarationType:
@@ -38,20 +38,20 @@ class TypeTable(Generic[DeclarationType], ABC):
     def __contains__(self, key: str) -> bool:
         return key in self._all_types
 
-    def all_types(self) -> Dict[str, DeclarationType]:
+    def all_types(self) -> dict[str, DeclarationType]:
         return self._all_types
 
 
 class EnumTable(TypeTable[EnumDeclaration]):
-    def __init__(self, user_types: List[EnumDeclaration]) -> None:
+    def __init__(self, user_types: list[EnumDeclaration]) -> None:
         super().__init__(user_types)
 
     @property
-    def builtins(self) -> Dict[str, EnumDeclaration]:
+    def builtins(self) -> dict[str, EnumDeclaration]:
         return BUILTIN_ENUM_DECLARATIONS
 
     @property
-    def enums(self) -> Dict[str, IntEnum]:
+    def enums(self) -> dict[str, IntEnum]:
         return {
             enum_decl.name: enum_decl.create_enum()
             for enum_decl in self.all_types().values()
@@ -60,13 +60,13 @@ class EnumTable(TypeTable[EnumDeclaration]):
 
 class StructTable(TypeTable[StructDeclaration]):
     @property
-    def builtins(self) -> Dict[str, StructDeclaration]:
+    def builtins(self) -> dict[str, StructDeclaration]:
         return BUILTIN_STRUCT_DECLARATIONS
 
 
 class QStructTable(TypeTable[QStructDeclaration]):
     @property
-    def builtins(self) -> Dict[str, QStructDeclaration]:
+    def builtins(self) -> dict[str, QStructDeclaration]:
         return {}
 
 
@@ -76,15 +76,15 @@ class SymbolTable:
     qstruct_table: ClassVar[QStructTable] = QStructTable([])
 
     @classmethod
-    def init_user_enums(cls, user_enums: List[EnumDeclaration]) -> None:
+    def init_user_enums(cls, user_enums: list[EnumDeclaration]) -> None:
         cls.enum_table = EnumTable(user_enums)
 
     @classmethod
-    def init_user_types(cls, user_types: List[StructDeclaration]) -> None:
+    def init_user_types(cls, user_types: list[StructDeclaration]) -> None:
         cls.type_table = StructTable(user_types)
 
     @classmethod
-    def init_user_qstructs(cls, user_qstructs: List[QStructDeclaration]) -> None:
+    def init_user_qstructs(cls, user_qstructs: list[QStructDeclaration]) -> None:
         cls.qstruct_table = QStructTable(user_qstructs)
         QMODULE.qstruct_decls = {
             qstruct_decl.name: qstruct_decl for qstruct_decl in user_qstructs
@@ -92,7 +92,7 @@ class SymbolTable:
 
 
 class HandleTable:
-    _handle_map: Dict[HandleIdentifier, QmodPyObject] = {}
+    _handle_map: dict[HandleIdentifier, QmodPyObject] = {}
 
     @classmethod
     def get_handle_object(cls, hid: HandleIdentifier) -> Optional[QmodPyObject]:

classiq/model_expansions/quantum_operations/bind.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.bind_operation import BindOperation
 
@@ -18,11 +16,11 @@ class BindEmitter(Emitter[BindOperation]):
     def emit(self, bind: BindOperation, /) -> None:
         with self._propagated_var_stack.capture_variables(bind):
             pass
-        inputs: List[QuantumSymbol] = [
+        inputs: list[QuantumSymbol] = [
             self._interpreter.evaluate(arg).as_type(QuantumSymbol)
             for arg in bind.in_handles
         ]
-        outputs: List[QuantumSymbol] = [
+        outputs: list[QuantumSymbol] = [
             self._interpreter.evaluate(arg).as_type(QuantumSymbol)
             for arg in bind.out_handles
         ]

classiq/model_expansions/quantum_operations/classicalif.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall

classiq/model_expansions/quantum_operations/control.py

@@ -1,5 +1,3 @@
-from typing import List, Tuple
-
 from sympy import Equality
 from sympy.logic.boolalg import Boolean
 from typing_extensions import TypeGuard
@@ -11,6 +9,7 @@ from classiq.interface.exceptions import (
 from classiq.interface.generator.compiler_keywords import INPLACE_ARITH_AUX_VAR_PREFIX
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.generator.functions.builtins.internal_operators import (
@@ -23,6 +22,7 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -42,6 +42,7 @@ from classiq.model_expansions.quantum_operations.expression_operation import (
     ExpressionOperationEmitter,
 )
 from classiq.model_expansions.scope import Scope
+from classiq.qmod.builtins.functions.standard_gates import X
 
 ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 
@@ -49,22 +50,42 @@ ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
         condition = self._evaluate_op_expression(control)
-        control = control.model_copy(update=dict(expression=condition))
 
         arrays_with_subscript = self._get_symbols_to_split(condition)
         if len(arrays_with_subscript) > 0:
             self._emit_with_split(control, condition, arrays_with_subscript)
             return
 
+        control = self._evaluate_types_in_expression(control, condition)
         condition_val = condition.value.value
         if isinstance(condition_val, QmodSizedProxy):
-            self._validate_canonical_condition(condition_val)
-            self._emit_canonical_control(control)
-            return
+            if control.else_block is None:
+                self._validate_canonical_condition(condition_val)
+                self._emit_canonical_control(control)
+                return
+            else:
+                self._interpreter.emit_statement(
+                    control.model_copy(
+                        update=dict(
+                            expression=self._uncanonize_condition(condition_val)
+                        )
+                    )
+                )
+                return
 
-        self._validate_condition(condition_val)
+        self._validate_condition(control)
         self._emit_with_boolean(control)
 
+    def _uncanonize_condition(self, condition_val: QmodSizedProxy) -> Expression:
+        lhs = (
+            " & ".join(
+                f"{condition_val.handle}[{idx}]" for idx in range(condition_val.size)
+            )
+            if isinstance(condition_val, QmodQArrayProxy)
+            else condition_val.handle
+        )
+        return Expression(expr=f"{lhs} == 1")
+
     def _emit_canonical_control(self, control: Control) -> None:
         # canonical means control(q, body) where q is a single quantum variable
         control = self._evaluate_types_in_expression(control, control.expression)
@@ -131,9 +152,10 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         condition_val = control.expression.value.value
         if self._is_simple_equality(condition_val):
             ctrl, ctrl_state = resolve_num_condition(condition_val)
-            self._emit_with_x_gates(control, ctrl, ctrl_state)
-        else:
-            self._emit_with_arithmetic(control)
+            if control.else_block is None or ctrl.size == 1:
+                self._emit_with_x_gates(control, ctrl, ctrl_state)
+                return
+        self._emit_with_arithmetic(control)
 
     @staticmethod
     def _is_simple_equality(condition_val: ExpressionValue) -> TypeGuard[Equality]:
@@ -153,14 +175,38 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
 
     def _create_canonical_control_op(
         self, control: Control, handle_name: str
-    ) -> Control:
+    ) -> list[ConcreteQuantumStatement]:
         handle_expr = self._interpreter.evaluate(Expression(expr=handle_name)).emit()
-        return control.model_copy(update=dict(expression=handle_expr))
+        control_then = control.model_copy(
+            update=dict(expression=handle_expr, else_block=None)
+        )
+        if control.else_block is None:
+            return [control_then]
+        else_compute_call = QuantumFunctionCall(
+            function="X", positional_args=[HandleBinding(name=handle_name)]
+        )
+        else_compute_call.set_func_decl(X.func_decl)
+        control_else_inner = control.model_copy(
+            update=dict(
+                expression=handle_expr, body=control.else_block, else_block=None
+            ),
+            deep=True,
+        )
+        control_else = WithinApply(
+            compute=[else_compute_call],
+            action=[control_else_inner],
+        )
+        if control_else_inner.is_generative():
+            control_else_inner.set_generative_block(
+                "body", control_else_inner.get_generative_block("else_block")
+            )
+            control_else_inner.remove_generative_block("else_block")
+        return [control_then, control_else]
 
-    def _emit_with_x_gates(
+    def _control_with_x_gates(
         self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
-    ) -> None:
-        compute_op: List[ConcreteQuantumStatement] = []
+    ) -> ConcreteQuantumStatement:
+        compute_op: list[ConcreteQuantumStatement] = []
 
         x_gate_value = self._get_x_gate_value(ctrl_state)
         if x_gate_value != 0:
@@ -177,12 +223,19 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             cast_decl, bind_op = self._get_array_cast_ops(ctrl)
             self._interpreter.emit_statement(cast_decl)
             compute_op.append(bind_op)
-            control_op = self._create_canonical_control_op(control, str(cast_decl.name))
+            control_ops = self._create_canonical_control_op(
+                control, str(cast_decl.name)
+            )
         else:
-            control_op = self._create_canonical_control_op(control, str(ctrl.handle))
+            control_ops = self._create_canonical_control_op(control, str(ctrl.handle))
+
+        return WithinApply(compute=compute_op, action=control_ops)
 
+    def _emit_with_x_gates(
+        self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
+    ) -> None:
         self._interpreter.emit_statement(
-            WithinApply(compute=compute_op, action=[control_op])
+            self._control_with_x_gates(control, ctrl, ctrl_state)
         )
 
     @staticmethod
@@ -194,7 +247,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
 
     def _get_array_cast_ops(
         self, ctrl: QmodQNumProxy
-    ) -> Tuple[VariableDeclarationStatement, BindOperation]:
+    ) -> tuple[VariableDeclarationStatement, BindOperation]:
         array_cast = self._counted_name_allocator.allocate(
             f"{ctrl.handle}{ARRAY_CAST_SUFFIX}"
         )
@@ -219,14 +272,18 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         self._interpreter.emit_statement(
             WithinApply(
                 compute=[arith_expression],
-                action=[self._create_canonical_control_op(control, aux_var)],
+                action=self._create_canonical_control_op(control, aux_var),
             )
         )
 
-    @staticmethod
-    def _validate_condition(condition_val: ExpressionValue) -> None:
-        if not isinstance(condition_val, Boolean):
-            raise ClassiqExpansionError(_condition_err_msg(condition_val))
+    def _validate_condition(self, control: Control) -> None:
+        condition_value = control.expression.value.value
+        if not (
+            isinstance(condition_value, Boolean)
+            or self._all_vars_boolean(control)
+            and self._is_res_boolean(control)
+        ):
+            raise ClassiqExpansionError(_condition_err_msg(condition_value))
 
     @staticmethod
     def _validate_canonical_condition(condition_val: ExpressionValue) -> None: