classiq 0.92.0__py3-none-any.whl → 0.94.0__py3-none-any.whl

classiq/interface/server/routes.py

@@ -1,5 +1,4 @@
 ANALYZER_PREFIX = "/analyzer"
-CHEMISTRY_PREFIX = "/chemistry"
 EXECUTION_PREFIX = "/execution"
 EXECUTION_SESSIONS_PREFIX = EXECUTION_PREFIX + "/sessions"
 CONVERSION_PREFIX = "/conversion"
@@ -62,9 +61,6 @@ ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
 
 TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
 
-GENERATE_HAMILTONIAN_SUFFIX = "/generate_hamiltonian"
-GENERATE_HAMILTONIAN_FULL_PATH = CHEMISTRY_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
-
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX

classiq/interface/source_reference.py

@@ -1,7 +1,6 @@
 import os
 import re
 from pathlib import Path
-from typing import Optional
 
 import pydantic
 
@@ -30,7 +29,7 @@ class SourceReference(HashablePydanticBaseModel):
     start_column: int
     end_line: int
     end_column: int
-    file_name: Optional[str] = pydantic.Field(default=None)
+    file_name: str | None = pydantic.Field(default=None)
 
     def __str__(self) -> str:
         return f"{self.file_string()}{self.ref_inside_file()}"
@@ -47,8 +46,8 @@ class SourceReference(HashablePydanticBaseModel):
 
 class SourceReferencedError(pydantic.BaseModel):
     error: str
-    source_ref: Optional[SourceReference] = None
-    function: Optional[str] = None
+    source_ref: SourceReference | None = None
+    function: str | None = None
 
     def __str__(self) -> str:
         source_referenced_error = (

classiq/model_expansions/arithmetic.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional, Union
 
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
@@ -23,7 +22,7 @@ class NumericAttributes:
         size: int,
         is_signed: bool,
         fraction_digits: int,
-        bounds: Optional[tuple[float, float]] = None,
+        bounds: tuple[float, float] | None = None,
         trim_bounds: bool = False,
     ) -> None:
         self.size = size
@@ -108,7 +107,7 @@ class NumericAttributes:
     def from_constant(
         cls,
         value: float,
-        machine_precision: Optional[int] = None,
+        machine_precision: int | None = None,
     ) -> "NumericAttributes":
         if machine_precision is not None:
             value = number_utils.limit_fraction_places(value, machine_precision)
@@ -124,7 +123,7 @@ class NumericAttributes:
     def from_quantum_scalar(
         cls,
         quantum_type: QuantumScalar,
-        machine_precision: Optional[int] = None,
+        machine_precision: int | None = None,
     ) -> "NumericAttributes":
         return cls(
             size=quantum_type.size_in_bits,
@@ -137,7 +136,7 @@ class NumericAttributes:
     def from_register_arithmetic_info(
         cls,
         register: RegisterArithmeticInfo,
-        machine_precision: Optional[int] = None,
+        machine_precision: int | None = None,
     ) -> "NumericAttributes":
         return cls.from_quantum_scalar(
             quantum_type=register_info_to_quantum_type(register),
@@ -147,8 +146,8 @@ class NumericAttributes:
     @classmethod
     def from_type_or_constant(
         cls,
-        from_: Union[float, QuantumScalar, RegisterArithmeticInfo],
-        machine_precision: Optional[int] = None,
+        from_: float | QuantumScalar | RegisterArithmeticInfo,
+        machine_precision: int | None = None,
     ) -> "NumericAttributes":
         if isinstance(from_, QuantumScalar):
             return cls.from_quantum_scalar(from_, machine_precision)

classiq/model_expansions/arithmetic_compute_result_attrs.py

@@ -1,6 +1,5 @@
 import math
 from collections.abc import Sequence
-from typing import Union
 
 from classiq.interface.exceptions import ClassiqValueError
 
@@ -153,7 +152,7 @@ def compute_result_attrs_multiply(
 
 def compute_result_attrs_power(
     left: NumericAttributes,
-    right: Union[int, float],
+    right: int | float,
     machine_precision: int,
 ) -> NumericAttributes:
     if not float(right).is_integer() or right <= 0:
@@ -174,7 +173,7 @@ def compute_result_attrs_power(
 
 def compute_result_attrs_lshift(
     left: NumericAttributes,
-    right: Union[int, float],
+    right: int | float,
     machine_precision: int,
 ) -> NumericAttributes:
     if not float(right).is_integer() or right < 0:
@@ -196,7 +195,7 @@ def compute_result_attrs_lshift(
 
 def compute_result_attrs_rshift(
     left: NumericAttributes,
-    right: Union[int, float],
+    right: int | float,
     machine_precision: int,
 ) -> NumericAttributes:
     if not float(right).is_integer() or right < 0:
@@ -219,7 +218,7 @@ def compute_result_attrs_rshift(
 
 def compute_result_attrs_modulo(
     left: NumericAttributes,
-    right: Union[int, float],
+    right: int | float,
     machine_precision: int,
 ) -> NumericAttributes:
     if not float(right).is_integer() or right < 2:

classiq/model_expansions/capturing/captured_vars.py

@@ -1,8 +1,8 @@
 import ast
 import dataclasses
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable, Union, cast
+from typing import TYPE_CHECKING, cast
 
 from typing_extensions import Self
 
@@ -297,7 +297,7 @@ class CapturedVars:
 
     def _conjugate_direction(
         self,
-        source_direction: Union[PortDirection, bool],
+        source_direction: PortDirection | bool,
         target_direction: PortDirection,
         var_name: str,
     ) -> PortDirection:

classiq/model_expansions/capturing/mangling_utils.py

@@ -1,5 +1,4 @@
 import re
-from typing import Optional
 
 from classiq.interface.generator.compiler_keywords import CAPTURE_SUFFIX
 from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
@@ -17,7 +16,7 @@ def mangle_captured_var_name(
     return f"{var_name}{CAPTURE_SUFFIX}{function_name}__{function_depth}"
 
 
-def _match_capture_pattern(name: str) -> Optional[re.Match[str]]:
+def _match_capture_pattern(name: str) -> re.Match[str] | None:
     return re.match(CAPTURE_PATTERN, name)
 
 

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

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)

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,
@@ -245,7 +247,9 @@ class GenerativeInterpreter(BaseInterpreter):
     def emit_variable_declaration(
         self, variable_declaration: VariableDeclarationStatement
     ) -> None:
-        VariableDeclarationStatementEmitter(self).emit(variable_declaration)
+        VariableDeclarationStatementEmitter(
+            self, allow_symbolic_vars=self._symbolic_parameters_switch
+        ).emit(variable_declaration)
 
     @emit.register
     def emit_classical_if(self, classical_if: ClassicalIf) -> None:

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
@@ -62,6 +62,12 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         if isinstance(result_symbol, ClassicalSymbol):
             return False
         result_type = result_symbol.quantum_type
+        if not isinstance(result_type, QuantumScalar):
+            raise ClassiqExpansionError(
+                f"Cannot assign into a non-scalar quantum variable "
+                f"{str(result_symbol.handle)!r} of type "
+                f"{result_type.raw_qmod_type_name}"
+            )
 
         if not (
             isinstance(op, ArithmeticOperation)
@@ -105,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)
                 ],
@@ -394,6 +391,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
                 function,
                 evaluated_args,
             ),
+            permutation=function.permutation,
         )
 
     def _validate_call_args(
@@ -425,27 +423,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 +467,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: