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

classiq/model_expansions/closure.py

@@ -2,7 +2,7 @@ import dataclasses
 from collections.abc import Sequence
 from copy import deepcopy
 from dataclasses import dataclass, field
-from typing import Any, Optional
+from typing import Any
 
 from typing_extensions import Self
 
@@ -47,7 +47,8 @@ class FunctionClosure(Closure):
     is_lambda: bool = False
     is_atomic: bool = False
     signature_scope: Scope = field(default_factory=Scope)
-    _depth: Optional[int] = None
+    permutation: bool = False
+    _depth: int | None = None
 
     @property
     def depth(self) -> int:
@@ -67,9 +68,9 @@ class FunctionClosure(Closure):
         cls,
         name: str,
         scope: Scope,
-        body: Optional[Sequence[QuantumStatement]] = None,
+        body: Sequence[QuantumStatement] | None = None,
         positional_arg_declarations: Sequence[PositionalArg] = tuple(),
-        lambda_external_vars: Optional[CapturedVars] = None,
+        lambda_external_vars: CapturedVars | None = None,
         is_atomic: bool = False,
         **kwargs: Any,
     ) -> Self:
@@ -78,13 +79,13 @@ class FunctionClosure(Closure):
         if lambda_external_vars is not None:
             captured_vars.set_parent(lambda_external_vars)
         return cls(
-            name,
-            blocks,
-            scope,
-            positional_arg_declarations,
-            captured_vars,
-            lambda_external_vars is not None,
-            is_atomic,
+            name=name,
+            blocks=blocks,
+            scope=scope,
+            positional_arg_declarations=positional_arg_declarations,
+            captured_vars=captured_vars,
+            is_lambda=lambda_external_vars is not None,
+            is_atomic=is_atomic,
             **kwargs,
         )
 

classiq/model_expansions/function_builder.py

@@ -1,7 +1,7 @@
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -13,6 +13,7 @@ from classiq.interface.generator.compiler_keywords import (
 )
 from classiq.interface.generator.functions.builtins.internal_operators import (
     BLOCK_OPERATOR_NAME,
+    SKIP_CONTROL_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
@@ -39,7 +40,11 @@ from classiq.model_expansions.utils.counted_name_allocator import CountedNameAll
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
-BLOCKS_ALLOWED_CAPTURING = (WITHIN_APPLY_NAME, BLOCK_OPERATOR_NAME)
+BLOCKS_ALLOWED_CAPTURING = (
+    WITHIN_APPLY_NAME,
+    BLOCK_OPERATOR_NAME,
+    SKIP_CONTROL_OPERATOR_NAME,
+)
 
 
 @dataclass
@@ -87,6 +92,10 @@ class FunctionContext(OperationContext[FunctionClosure]):
     def is_lambda(self) -> bool:
         return self.closure.is_lambda
 
+    @property
+    def permutation(self) -> bool:
+        return self.closure.permutation
+
 
 class OperationBuilder:
     def __init__(
@@ -95,7 +104,7 @@ class OperationBuilder:
         self._operations: list[OperationContext] = []
         self._blocks: list[str] = []
         self._functions_scope = functions_scope
-        self._current_source_ref: Optional[SourceReference] = None
+        self._current_source_ref: SourceReference | None = None
         self._counted_name_allocator = counted_name_allocator
 
     @property
@@ -201,9 +210,7 @@ class OperationBuilder:
         parent_block.captured_vars.update(captured_vars)
 
     @contextmanager
-    def source_ref_context(
-        self, source_ref: Optional[SourceReference]
-    ) -> Iterator[None]:
+    def source_ref_context(self, source_ref: SourceReference | None) -> Iterator[None]:
         previous_source_ref = self._current_source_ref
         self._current_source_ref = source_ref
         yield
@@ -218,6 +225,7 @@ class OperationBuilder:
             name=name,
             body=function_context.body,
             positional_arg_declarations=params,
+            permutation=function_context.permutation,
         )
 
     def _get_expanded_function_name(self, function_context: FunctionContext) -> str:

classiq/model_expansions/generative_functions.py

@@ -113,10 +113,7 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, value: Any) -> Any:
     if isinstance(param, PortDeclaration):
         return _create_qvar_for_qtype(value.quantum_type, value.handle)
     if isinstance(param, QuantumOperandDeclaration):
-        if not param.is_list or not param.is_generative:
-            return QTerminalCallable(param)
-        inner_decl = param.model_copy(update={"is_list": False})
-        return [QTerminalCallable(inner_decl, index_=idx) for idx in range(len(value))]
+        return QTerminalCallable(param)
     if (
         isinstance(value, QmodStructInstance)
         and not param.classical_type.is_purely_generative
@@ -175,20 +172,18 @@ class _InterpreterExpandable(QFunc):
         scope_func_decls: dict[str, QuantumFunctionDeclaration] = {}
         for name, evaluated in self._interpreter._builder.current_scope.items():
             value = evaluated.value
+            if (
+                isinstance(value, list)
+                and len(value) > 0
+                and isinstance(value[0], FunctionClosure)
+            ):
+                value = value[0]
             if isinstance(value, FunctionClosure):
                 scope_func_decls[name] = QuantumFunctionDeclaration(
                     name=name,
                     positional_arg_declarations=value.positional_arg_declarations,
                 )
                 continue
-            op_param = self._interpreter._builder.current_function.parameters_dict.get(
-                name
-            )
-            if isinstance(op_param, QuantumOperandDeclaration):
-                scope_func_decls[name] = QuantumFunctionDeclaration(
-                    name=name,
-                    positional_arg_declarations=op_param.positional_arg_declarations,
-                )
         return (
             nameables_to_dict(self._interpreter._get_function_declarations())
             | scope_func_decls

classiq/model_expansions/interpreters/base_interpreter.py

@@ -1,10 +1,10 @@
 import ast
 from abc import abstractmethod
 from collections import defaultdict
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from contextlib import nullcontext
 from functools import singledispatchmethod
-from typing import Any, Callable, cast
+from typing import Any, cast
 
 from pydantic import ValidationError
 
@@ -42,9 +42,6 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.evaluators.classical_expression import process_scope_val
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_expression_visitors.qmod_expression_bwc import (
-    QmodExpressionBwc,
-)
 from classiq.evaluators.qmod_expression_visitors.qmod_expression_evaluator import (
     evaluate_qmod_expression,
 )
@@ -214,7 +211,6 @@ class BaseInterpreter:
         if expression.is_evaluated():
             return Evaluated(value=expression.value.value)
         expr_ast = ast.parse(expression.expr, mode="eval").body
-        expr_ast = QmodExpressionBwc().visit(expr_ast)
         expr_val = self._eval_expr(ast.unparse(expr_ast), treat_qnum_as_float)
         if simplify and not expr_val.has_value(expr_val.root):
             simplified_expr = simplify_qmod_expression(expr_val)
@@ -328,7 +324,7 @@ class BaseInterpreter:
     def emit_statement(self, statement: QuantumStatement) -> None:
         source_ref = statement.source_ref
         error_context = (
-            self._error_manager.node_context(statement)
+            self._error_manager.source_ref_context(statement.source_ref)
             if source_ref is not None
             else nullcontext()
         )

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -41,7 +41,8 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
             if module is None or not module.__name__.startswith("classiq."):
                 file_name = os.path.split(frame.filename)[-1]
                 if (
-                    frame.positions is not None
+                    hasattr(frame, "positions")
+                    and frame.positions is not None
                     and frame.positions.lineno is not None
                     and frame.positions.col_offset is not None
                     and frame.positions.end_lineno is not None

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -1,5 +1,5 @@
 from functools import singledispatchmethod
-from typing import Any, Optional
+from typing import Any
 
 import numpy as np
 from numpy.random import permutation
@@ -119,9 +119,9 @@ class GenerativeInterpreter(BaseInterpreter):
     def infer_symbolic_parameters(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: Optional[
+        additional_signatures: None | (
             list[NamedParamsQuantumFunctionDeclaration]
-        ] = None,
+        ) = None,
     ) -> None:
         pass
 
@@ -134,6 +134,7 @@ class GenerativeInterpreter(BaseInterpreter):
                 function.func_decl.name or "<lambda>"
             ),
             positional_arg_declarations=function.named_func_decl.positional_arg_declarations,
+            permutation=function.named_func_decl.permutation,
         )
 
         closure_class: type[FunctionClosure]
@@ -152,6 +153,7 @@ class GenerativeInterpreter(BaseInterpreter):
         closure = closure_class.create(
             name=func_decl.name,
             positional_arg_declarations=func_decl.positional_arg_declarations,
+            permutation=func_decl.permutation,
             body=function.body,
             scope=Scope(parent=self._builder.current_scope),
             lambda_external_vars=self._builder.current_block.captured_vars,

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any
 
 import sympy
 
@@ -193,7 +193,7 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_size(
         self, size: Expression, var_name: str
-    ) -> Union[int, float, sympy.Basic, QmodAnnotatedExpression]:
+    ) -> int | float | sympy.Basic | QmodAnnotatedExpression:
         size_value = self._interpreter.evaluate(size).value
         if not (
             (
@@ -221,7 +221,7 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_is_signed(
         self, is_signed: Expression
-    ) -> Union[bool, sympy.Basic, QmodAnnotatedExpression]:
+    ) -> bool | sympy.Basic | QmodAnnotatedExpression:
         is_signed_value = self._interpreter.evaluate(is_signed).value
         if not self._allow_symbolic_attrs and not (
             isinstance(is_signed_value, bool)
@@ -238,7 +238,7 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_fraction_digits(
         self, fraction_digits: Expression
-    ) -> Union[int, float, sympy.Expr, QmodAnnotatedExpression]:
+    ) -> int | float | sympy.Expr | QmodAnnotatedExpression:
         fraction_digits_value = self._interpreter.evaluate(fraction_digits).value
         if not self._allow_symbolic_attrs and not (
             isinstance(fraction_digits_value, (int, float))

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.expression import Expression
@@ -111,9 +111,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self._assign_to_inferred_var_and_bind(op, result_type, expression_type)
         return True
 
-    def _infer_expression_type(
-        self, op: ArithmeticOperation
-    ) -> Optional[QuantumScalar]:
+    def _infer_expression_type(self, op: ArithmeticOperation) -> QuantumScalar | None:
         expr = self._evaluate_expression(op.expression)
         expr_val = expr.value.value
         if isinstance(expr_val, QmodAnnotatedExpression):

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -2,7 +2,6 @@ from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
     Generic,
-    Optional,
     cast,
 )
 from uuid import UUID
@@ -16,9 +15,7 @@ from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.helpers.text_utils import are, readable_list, s
 from classiq.interface.model.block import Block
 from classiq.interface.model.classical_parameter_declaration import (
@@ -72,8 +69,8 @@ from classiq.model_expansions.scope import (
     Scope,
 )
 from classiq.model_expansions.transformers.model_renamer import ModelRenamer
-from classiq.model_expansions.transformers.type_modifier_inference import (
-    TypeModifierValidation,
+from classiq.model_expansions.visitors.uncomputation_signature_inference import (
+    infer_and_validate_uncomputation_signature,
 )
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.semantics.validation.signature_validation import (
@@ -106,7 +103,7 @@ def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
 def _validate_gen_args(
     function: FunctionClosure, evaluated_args: list[Evaluated]
 ) -> None:
-    for param, arg in zip_strict(
+    for param, arg in zip(
         function.positional_arg_declarations, evaluated_args, strict=True
     ):
         if (
@@ -158,7 +155,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         self,
         name: str,
         body: Sequence[QuantumStatement],
-        debug_info: Optional[FunctionDebugInfo] = None,
+        debug_info: FunctionDebugInfo | None = None,
     ) -> QuantumFunctionCall:
         wrapping_function = FunctionClosure.create(
             name=self._counted_name_allocator.allocate(name),
@@ -172,7 +169,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: Optional[FunctionDebugInfo],
+        propagated_debug_info: FunctionDebugInfo | None,
     ) -> QuantumFunctionCall:
         call = self._create_quantum_function_call(
             function, args, propagated_debug_info=propagated_debug_info
@@ -182,8 +179,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
 
     @staticmethod
     def _get_back_ref(
-        propagated_debug_info: Optional[FunctionDebugInfo],
-    ) -> Optional[UUID]:
+        propagated_debug_info: FunctionDebugInfo | None,
+    ) -> UUID | None:
         if propagated_debug_info is None:
             return None
         if propagated_debug_info.node is None:
@@ -194,7 +191,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: Optional[FunctionDebugInfo],
+        propagated_debug_info: FunctionDebugInfo | None,
     ) -> QuantumFunctionCall:
         function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
@@ -218,7 +215,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
             new_positional_arg_decls = new_declaration.positional_arg_declarations
             evaluated_args = [
                 arg
-                for param, arg in zip_strict(
+                for param, arg in zip(
                     function.positional_arg_declarations, evaluated_args, strict=True
                 )
                 if isinstance(arg.value, QuantumVariable)
@@ -235,7 +232,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         )
         new_positional_args = [
             arg.emit(param)
-            for param, arg in zip_strict(
+            for param, arg in zip(
                 new_positional_arg_decls[
                     : len(new_positional_arg_decls) - len(captured_args)
                 ],
@@ -289,9 +286,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         if cache_key in self._expanded_functions:
             function_def = self._expanded_functions[cache_key]
             self._expand_cached_function(function, function_def)
-            self._expanded_functions_compilation_metadata[
-                function_def.name
-            ].occurrences_number += 1
             return function_def
 
         context = self._expand_operation(function)
@@ -394,6 +388,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
                 function,
                 evaluated_args,
             ),
+            permutation=function.permutation,
         )
 
     def _validate_call_args(
@@ -425,27 +420,30 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
     def _validate_type_modifiers(
         self, func_context: FunctionContext, func_def: NativeFunctionDefinition
     ) -> None:
-        if self._should_override_type_modifiers(func_context):
-            self._override_type_modifiers(func_def)
-
-        unchecked = self._functions_compilation_metadata.get(
+        compilation_metadata = self._functions_compilation_metadata.get(
             func_context.name, CompilationMetadata()
-        ).unchecked
-        TypeModifierValidation(
-            skip_validation=self._interpreter.skip_type_modifier_validation
-        ).run(func_def, unchecked)
+        )
+        infer_and_validate_uncomputation_signature(
+            func_def,
+            disable_perm_check=self._interpreter.skip_type_modifier_validation
+            or compilation_metadata.disable_perm_check,
+            disable_const_checks=self._interpreter.skip_type_modifier_validation
+            or compilation_metadata.disable_const_checks,
+            tighten_signature=self._should_tighten_signature(func_context),
+        )
 
     @staticmethod
-    def _should_override_type_modifiers(func_context: FunctionContext) -> bool:
+    def _should_tighten_signature(func_context: FunctionContext) -> bool:
         """
-        The type modifier can be changed according to the operand passed to the
-        function. For example,
-        apply_to_all(X, q) --> q will be Permutable after expansion
-        apply_to_all(H, q) --> q will be Quantum after expansion
-        This also holds for the intermediate lambda created during the expansion.
-
-        We don't override the type modifier if it's explicitly specified (Permutable or
-        Const), neither in the function declaration nor in the operand declaration.
+        In some cases we want to tighten the function signature (adding "const" or
+        "permutation" modifiers) when possible:
+            - Lambda functions (which are defined without modifiers)
+            - Functions which receive operands and their modifiers depend on the operand
+
+        For example:
+            - apply_to_all(Z, q) --> q will become `const` and the function will become `permutation`
+            - apply_to_all(X, q) --> the function will become `permutation`
+            - apply_to_all(H, q) --> no change
         """
 
         if func_context.is_lambda:
@@ -466,10 +464,3 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
                 for param_decl in orig_func.positional_arg_declarations
             )
         )
-
-    @staticmethod
-    def _override_type_modifiers(func_def: NativeFunctionDefinition) -> None:
-        # only override the modifier if it's unspecified (not Permutable or Const)
-        for port in func_def.port_declarations:
-            if port.type_modifier is TypeModifier.Mutable:
-                port.type_modifier = TypeModifier.Inferred

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -1,5 +1,5 @@
 from itertools import chain
-from typing import TYPE_CHECKING, Generic, Optional
+from typing import TYPE_CHECKING, Generic
 
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -41,7 +41,7 @@ class DeclarativeCallEmitter(
         return True
 
     def _is_function_purely_declarative(
-        self, function: FunctionClosure, seen_funcs: Optional[set[str]] = None
+        self, function: FunctionClosure, seen_funcs: set[str] | None = None
     ) -> bool:
         if seen_funcs is None:
             seen_funcs = set()

classiq/model_expansions/quantum_operations/emitter.py

@@ -3,9 +3,7 @@ from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Generic,
-    Optional,
     TypeVar,
-    Union,
 )
 
 from classiq.interface.debug_info.debug_info import (
@@ -113,9 +111,9 @@ class Emitter(Generic[QuantumStatementT], ABC):
         self,
         op: QuantumOperation,
         context_name: str,
-        block_names: Union[None, str, list[str]] = None,
-        params: Optional[Sequence[PositionalArg]] = None,
-        scope: Optional[Scope] = None,
+        block_names: None | str | list[str] = None,
+        params: Sequence[PositionalArg] | None = None,
+        scope: Scope | None = None,
     ) -> OperationContext:
         if isinstance(block_names, str):
             block_names = [block_names]

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -24,7 +24,7 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         interpreter: "BaseInterpreter",
         expression_name: str,
         *,
-        readable_expression_name: Optional[str] = None,
+        readable_expression_name: str | None = None,
         simplify: bool = False,
         treat_qnum_as_float: bool = False,
         allow_link_time_vars: bool = True,
@@ -73,7 +73,7 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
                 link_time_vars.append(var_name)
             self._capture_classical_var(var_name, var_type)
         if not self._allow_link_time_vars and len(link_time_vars) > 0:
-            link_time_message = f"link-time variable{s(link_time_vars)} {readable_list(link_time_vars, quote=True)}"
+            link_time_message = f"execution parameter{s(link_time_vars)} {readable_list(link_time_vars, quote=True)}"
         else:
             link_time_message = None
         if not self._allow_runtime_vars and len(runtime_vars) > 0:

classiq/model_expansions/quantum_operations/skip_control_verifier.py

@@ -1,5 +1,4 @@
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.skip_control import SkipControl
 
 from classiq.model_expansions.function_builder import FunctionContext
@@ -9,7 +8,7 @@ from classiq.model_expansions.quantum_operations.emitter import Emitter
 class SkipControlVerifier(Emitter[SkipControl]):
     def emit(self, skip_control: SkipControl, /) -> bool:
         for op, block in list(
-            zip_strict(self._builder._operations, self._builder._blocks, strict=True)
+            zip(self._builder._operations, self._builder._blocks, strict=True)
         )[::-1]:
             if isinstance(op, FunctionContext):
                 break

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Union, cast
+from typing import TYPE_CHECKING, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.classical_type import ClassicalType
@@ -38,7 +38,7 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
             raise ClassiqExpansionError(
                 f"Variable {variable_declaration.name!r} is already defined"
             )
-        var_value: Union[QuantumSymbol, ClassicalSymbol]
+        var_value: QuantumSymbol | ClassicalSymbol
         if variable_declaration.is_quantum:
             var_value = self._get_quantum_var(var_decl)
         else:

classiq/model_expansions/scope.py

@@ -68,7 +68,7 @@ class QuantumSymbol(QuantumVariable):
         return self.handle
 
     def __getitem__(
-        self, item: Union[slice, int, QmodAnnotatedExpression]
+        self, item: slice | int | QmodAnnotatedExpression
     ) -> "QuantumSymbol":
         if isinstance(item, slice):
             return self._slice(item.start, item.stop)
@@ -76,8 +76,8 @@ class QuantumSymbol(QuantumVariable):
 
     def _slice(
         self,
-        start: Union[int, QmodAnnotatedExpression],
-        end: Union[int, QmodAnnotatedExpression],
+        start: int | QmodAnnotatedExpression,
+        end: int | QmodAnnotatedExpression,
     ) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
@@ -119,7 +119,7 @@ class QuantumSymbol(QuantumVariable):
             ),
         )
 
-    def _subscript(self, index: Union[int, QmodAnnotatedExpression]) -> "QuantumSymbol":
+    def _subscript(self, index: int | QmodAnnotatedExpression) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
@@ -188,7 +188,7 @@ class QuantumSymbolList(QuantumVariable):
         )
         if len(handles) == 0:
             raise ClassiqExpansionError("Empty concatenation expression")
-        length: Optional[Expression]
+        length: Expression | None
         if any(not symbol.quantum_type.has_size_in_bits for symbol in symbols):
             length = None
         else:
@@ -252,7 +252,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
 
         return value
 
-    def emit(self, param: Optional[AnonPositionalArg] = None) -> ArgValue:
+    def emit(self, param: AnonPositionalArg | None = None) -> ArgValue:
         from classiq.model_expansions.closure import FunctionClosure
 
         if isinstance(self.value, (QuantumVariable, FunctionClosure)):
@@ -278,7 +278,7 @@ else:
 class Scope(EvaluatedUserDict):
     def __init__(
         self,
-        data: Optional[dict[str, Evaluated]] = None,
+        data: dict[str, Evaluated] | None = None,
         /,
         *,
         parent: Optional["Scope"] = None,

classiq/model_expansions/scope_initialization.py

@@ -44,6 +44,7 @@ def add_functions_to_scope(
                 value=FunctionClosure.create(
                     name=function.name,
                     positional_arg_declarations=function.positional_arg_declarations,
+                    permutation=function.permutation,
                     body=function.body,
                     scope=Scope(parent=scope),
                 )
@@ -64,6 +65,7 @@ def add_generative_functions_to_scope(
                 value=GenerativeFunctionClosure.create(
                     name=name,
                     positional_arg_declarations=function.func_decl.positional_arg_declarations,
+                    permutation=function.permutation,
                     scope=Scope(parent=scope),
                     generative_blocks={"body": function},
                 )
@@ -76,6 +78,7 @@ def _init_builtins_scope(scope: Scope) -> None:
             value=FunctionClosure.create(
                 name=builtin_function.name,
                 positional_arg_declarations=builtin_function.positional_arg_declarations,
+                permutation=builtin_function.permutation,
                 scope=Scope(parent=scope),
                 is_atomic=True,
             )
@@ -85,6 +88,7 @@ def _init_builtins_scope(scope: Scope) -> None:
             value=FunctionClosure.create(
                 name=builtin_function.name,
                 positional_arg_declarations=builtin_function.positional_arg_declarations,
+                permutation=builtin_function.permutation,
                 scope=Scope(parent=scope),
             )
         )