classiq 0.89.0__py3-none-any.whl → 0.91.0__py3-none-any.whl

classiq/model_expansions/scope.py

@@ -3,7 +3,7 @@ from collections import UserDict
 from collections.abc import Iterator
 from dataclasses import dataclass
 from functools import singledispatch
-from typing import TYPE_CHECKING, Any, NoReturn, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 import sympy
 
@@ -15,15 +15,11 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
-    ClassicalScalarProxy,
-)
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     GeneralHandle,
@@ -43,6 +39,9 @@ from classiq.interface.model.quantum_type import (
     QuantumType,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import get_sympy_val
+
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
@@ -69,7 +68,7 @@ class QuantumSymbol(QuantumVariable):
         return self.handle
 
     def __getitem__(
-        self, item: Union[slice, int, ClassicalScalarProxy]
+        self, item: Union[slice, int, QmodAnnotatedExpression]
     ) -> "QuantumSymbol":
         if isinstance(item, slice):
             return self._slice(item.start, item.stop)
@@ -77,8 +76,8 @@ class QuantumSymbol(QuantumVariable):
 
     def _slice(
         self,
-        start: Union[int, ClassicalScalarProxy],
-        end: Union[int, ClassicalScalarProxy],
+        start: Union[int, QmodAnnotatedExpression],
+        end: Union[int, QmodAnnotatedExpression],
     ) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
@@ -100,19 +99,27 @@ class QuantumSymbol(QuantumVariable):
                 f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
                 f"length {self.quantum_type.length_value})"
             )
+        start_expr = Expression(expr=str(start))
+        start_expr._evaluated_expr = EvaluatedExpression(value=start)
+        end_expr = Expression(expr=str(end))
+        end_expr._evaluated_expr = EvaluatedExpression(value=end)
+        if isinstance(start, int) and isinstance(end, int):
+            length_expr = Expression(expr=str(end - start))
+        else:
+            length_expr = None
         return QuantumSymbol(
             handle=SlicedHandleBinding(
                 base_handle=self.handle,
-                start=Expression(expr=str(start)),
-                end=Expression(expr=str(end)),
+                start=start_expr,
+                end=end_expr,
             ),
             quantum_type=QuantumBitvector(
                 element_type=self.quantum_type.element_type,
-                length=Expression(expr=str(end - start)),
+                length=length_expr,
             ),
         )
 
-    def _subscript(self, index: Union[int, ClassicalScalarProxy]) -> "QuantumSymbol":
+    def _subscript(self, index: Union[int, QmodAnnotatedExpression]) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
@@ -135,11 +142,10 @@ class QuantumSymbol(QuantumVariable):
                 f"{self.quantum_type.type_name.lower()} {str(self.handle)!r}"
                 f"{length_suffix}"
             )
+        index_expr = Expression(expr=str(index))
+        index_expr._evaluated_expr = EvaluatedExpression(value=index)
         return QuantumSymbol(
-            handle=SubscriptHandleBinding(
-                base_handle=self.handle,
-                index=Expression(expr=str(index)),
-            ),
+            handle=SubscriptHandleBinding(base_handle=self.handle, index=index_expr),
             quantum_type=self.quantum_type.element_type,
         )
 
@@ -204,11 +210,15 @@ class QuantumSymbolList(QuantumVariable):
 
 
 @dataclass(frozen=True)
-class ClassicalSymbol:
-    handle: HandleBinding
+class ClassicalVariable:
     classical_type: ClassicalType
 
 
+@dataclass(frozen=True)
+class ClassicalSymbol(ClassicalVariable):
+    handle: HandleBinding
+
+
 @singledispatch
 def evaluated_to_str(value: Any) -> str:
     return str(value)
@@ -224,35 +234,23 @@ def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
     return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={evaluated_to_str(v)}' for k, v in value.fields.items())})"
 
 
-def _raise_type_error(val: Any, t: type, location_hint: Optional[str]) -> NoReturn:
-    if isinstance(val, sympy.Basic) and len(val.free_symbols) > 0:
-        symbolic_vars = sorted(map(str, val.free_symbols))
-        suffix = f" {location_hint}" if location_hint is not None else ""
-        raise ClassiqExpansionError(
-            f"Cannot use execution parameter{s(symbolic_vars)} {readable_list(symbolic_vars, quote=True)} in a compile-time context{suffix}"
-        )
-    raise ClassiqExpansionError(f"Invalid access to expression {val!r} as {t}")
-
-
 @dataclass(frozen=True)
 class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     value: Any
     defining_function: Optional["FunctionClosure"] = None
 
-    def as_type(self, t: type[T], location_hint: Optional[str] = None) -> T:
-        if t is int:
-            return self._as_int(location_hint)  # type: ignore[return-value]
-
-        if not isinstance(self.value, t):
-            _raise_type_error(self.value, t, location_hint)
-
-        return self.value
-
-    def _as_int(self, location_hint: Optional[str]) -> int:
-        if not isinstance(self.value, (int, float)):
-            _raise_type_error(self.value, int, location_hint)
+    def as_type(self, t: type[T]) -> T:
+        value = self.value
+        if isinstance(value, sympy.Basic):
+            value = get_sympy_val(value)
+        if t is int and isinstance(value, float):
+            value = int(value)
+        if not isinstance(value, t):
+            raise ClassiqExpansionError(
+                f"Invalid access to expression {self.value!r} as {t}"
+            )
 
-        return int(self.value)
+        return value
 
     def emit(self, param: Optional[AnonPositionalArg] = None) -> ArgValue:
         from classiq.model_expansions.closure import FunctionClosure

classiq/model_expansions/scope_initialization.py

@@ -11,9 +11,7 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import PositionalArg
 
-from classiq.evaluators.classical_expression import (
-    evaluate_classical_expression,
-)
+from classiq.evaluators.classical_expression import evaluate_classical_expression
 from classiq.evaluators.parameter_types import (
     evaluate_type_in_quantum_symbol,
 )
@@ -33,9 +31,8 @@ from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 
 def add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
     for constant in constants:
-        scope[constant.name] = Evaluated(
-            value=evaluate_classical_expression(constant.value, scope).value
-        )
+        expr_val = evaluate_classical_expression(constant.value, scope).value
+        scope[constant.name] = Evaluated(value=expr_val)
 
 
 def add_functions_to_scope(

classiq/model_expansions/transformers/model_renamer.py

@@ -1,26 +1,27 @@
-import ast
 import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
-from functools import cmp_to_key
 from typing import TypeVar, cast
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    CLASSICAL_ATTRIBUTES,
+)
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
 from classiq.interface.generator.visitor import NodeType
-from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
 from classiq.interface.model.model_visitor import ModelTransformer
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
 
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_renamer import (
+    replace_expression_type_attrs,
+    replace_expression_vars,
+)
 
 AST_NODE = TypeVar("AST_NODE", bound=NodeType)
 
@@ -39,31 +40,6 @@ def _handle_contains_handle(handle: HandleBinding, other_handle: HandleBinding)
     return 0
 
 
-class ExprNormalizer(ast.NodeTransformer):
-    def visit_Call(self, node: ast.Call) -> ast.AST:
-        if not isinstance(node.func, ast.Name):
-            return self.generic_visit(node)
-        if node.func.id == "get_field":
-            if (
-                len(node.args) != 2
-                or not isinstance(node.args[1], ast.Constant)
-                or not isinstance(node.args[1].value, str)
-            ):
-                raise ClassiqInternalExpansionError("Unexpected 'get_field' arguments")
-            return ast.Attribute(
-                value=self.visit(node.args[0]), attr=node.args[1].value
-            )
-        if node.func.id == "do_subscript":
-            if len(node.args) != 2:
-                raise ClassiqInternalExpansionError(
-                    "Unexpected 'do_subscript' arguments"
-                )
-            return ast.Subscript(
-                value=self.visit(node.args[0]), slice=self.visit(node.args[1])
-            )
-        return self.generic_visit(node)
-
-
 @dataclass(frozen=True)
 class HandleRenaming:
     source_handle: HandleBinding
@@ -80,38 +56,33 @@ SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 def rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
-    normalized_expr = ExprNormalizer().visit(ast.parse(expression.expr))
-    vrc = VarRefCollector(
-        ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
-    )
-    vrc.visit(normalized_expr)
-
-    handle_names = {
-        part.source_handle: part.target_var_handle
-        for source, parts in symbol_mapping.items()
-        if source.name in expression.expr
-        for part in parts
+    if len(symbol_mapping) == 0:
+        return expression
+    expr_val = expression.value.value
+    if not isinstance(expr_val, QmodAnnotatedExpression):
+        return expression
+
+    type_attr_mapping = {
+        (source_handle.base_handle, source_attr): renaming.target_var_handle
+        for renamings in symbol_mapping.values()
+        for renaming in renamings
+        if isinstance(source_handle := renaming.source_handle, FieldHandleBinding)
+        and (source_attr := source_handle.field) in CLASSICAL_ATTRIBUTES
     }
-    new_expr_str = ast.unparse(normalized_expr)
-    sorted_handles = sorted(
-        vrc.var_handles,
-        key=cmp_to_key(  # type:ignore[misc]
-            lambda handle, other_handle: _handle_contains_handle(other_handle, handle)
-        ),
-    )
-    for handle in sorted_handles:
-        new_handle = handle.collapse()
-        for handle_to_replace, replacement in handle_names.items():
-            if new_handle.name == handle_to_replace.name:
-                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
-        new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
-
-    new_expr = Expression(expr=new_expr_str)
-    if not new_expr.is_evaluated():
-        new_expr._evaluated_expr = EvaluatedExpression(
-            value=AnyClassicalValue(new_expr_str)
-        )
-    return new_expr
+    expr_val = replace_expression_type_attrs(expr_val, type_attr_mapping)
+
+    var_mapping = {
+        source_handle: renaming.target_var_handle
+        for renamings in symbol_mapping.values()
+        for renaming in renamings
+        if not isinstance(source_handle := renaming.source_handle, FieldHandleBinding)
+        or source_handle.field not in CLASSICAL_ATTRIBUTES
+    }
+    expr_val = replace_expression_vars(expr_val, var_mapping)
+
+    renamed_expr = Expression(expr=str(expr_val))
+    renamed_expr._evaluated_expr = EvaluatedExpression(value=expr_val)
+    return renamed_expr
 
 
 class _ReplaceSplitVarsHandles(ModelTransformer):

classiq/model_expansions/transformers/type_modifier_inference.py

@@ -1,4 +1,3 @@
-import ast
 import functools
 import itertools
 import warnings
@@ -37,7 +36,7 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.within_apply_operation import WithinApply
 from classiq.interface.source_reference import SourceReference
 
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 
 
 def _inconsistent_type_modifier_error(
@@ -302,11 +301,12 @@ class TypeModifierValidation(ModelVisitor):
 
     @staticmethod
     def _extract_expr_vars(expr_op: QuantumExpressionOperation) -> list[str]:
-        vrc = VarRefCollector(
-            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        expr_val = expr_op.expression.value.value
+        if not isinstance(expr_val, QmodAnnotatedExpression):
+            return []
+        return list(
+            dict.fromkeys(var.name for var in expr_val.get_quantum_vars().values())
         )
-        vrc.visit(ast.parse(expr_op.expression.expr))
-        return [handle.name for handle in vrc.var_handles]
 
     def visit_ArithmeticOperation(self, arith: ArithmeticOperation) -> None:
         with self.source_reference_context(arith.source_ref):

classiq/model_expansions/utils/handles_collector.py

@@ -7,6 +7,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 
@@ -18,6 +19,12 @@ class _HandlesCollector(Visitor):
         self.handles.append(handle)
 
     def visit_Expression(self, expression: Expression) -> None:
+        if expression.is_evaluated():
+            expr_val = expression.value.value
+            if isinstance(expr_val, QmodAnnotatedExpression):
+                self.handles.extend(expr_val.get_classical_vars().values())
+                self.handles.extend(expr_val.get_quantum_vars().values())
+            return
         vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(expression.expr))
         self.handles.extend(vrc.var_handles)

classiq/model_expansions/visitors/boolean_expression_transformers.py

@@ -1,11 +1,9 @@
 import ast
 import copy
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 
-from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import LogicalXor
-
 
 class BooleanExpressionOptimizer(ast.NodeTransformer):
     """
@@ -36,13 +34,13 @@ class BooleanExpressionOptimizer(ast.NodeTransformer):
         self._is_convertible = False
         return node
 
-    def visit_BinOp(self, node: ast.BinOp) -> Union[ast.BinOp, ast.BoolOp]:
+    def visit_BinOp(self, node: ast.BinOp) -> ast.AST:
         self.generic_visit(node)
         self._is_convertible = self._is_bool(node)
         if not self._is_convertible:
             return node
 
-        return self.visit(self._convert_bin_op_to_bool_op(node))
+        return self._convert_bin_op_to_bool_op(node)
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.AST:
         self.generic_visit(node)
@@ -70,9 +68,7 @@ class BooleanExpressionOptimizer(ast.NodeTransformer):
         return self._simplify_trivial_equality(node)
 
     def visit_Call(self, node: ast.Call) -> ast.Call:
-        self._is_convertible = (
-            isinstance(node.func, ast.Name) and node.func.id == LogicalXor.__name__
-        )
+        self._is_convertible = False
         return node
 
     def _is_bool(self, node: ast.AST) -> bool:
@@ -97,9 +93,7 @@ class BooleanExpressionOptimizer(ast.NodeTransformer):
                 and isinstance(node.ops[0], (ast.Eq, ast.NotEq))
             )
         if isinstance(node, ast.Call):
-            return (
-                isinstance(node.func, ast.Name) and node.func.id == LogicalXor.__name__
-            )
+            return False
         return False
 
     def _convert_bin_op_to_bool_op(self, node: ast.BinOp) -> ast.AST:
@@ -116,11 +110,7 @@ class BooleanExpressionOptimizer(ast.NodeTransformer):
         if not (
             isinstance(node.left, ast.Constant) or isinstance(node.right, ast.Constant)
         ):
-            return ast.Call(
-                func=ast.Name(LogicalXor.__name__),
-                args=[node.left, node.right],
-                keywords=[],
-            )
+            return ast.BinOp(left=node.left, op=ast.BitXor(), right=node.right)
 
         if isinstance(node.left, ast.Constant):
             constant = node.left.value
@@ -128,10 +118,7 @@ class BooleanExpressionOptimizer(ast.NodeTransformer):
         else:
             if TYPE_CHECKING:
                 assert isinstance(node.right, ast.Constant)
-            try:
-                constant = node.right.value
-            except AttributeError as e:
-                raise e
+            constant = node.right.value
             other = node.left
 
         return other if constant == 0 else ast.UnaryOp(op=ast.Not(), operand=other)
@@ -201,14 +188,3 @@ class BooleanExpressionFuncLibAdapter(ast.NodeTransformer):
             return node
         self.generic_visit(node)
         return ast.UnaryOp(op=ast.Not(), operand=node.operand)
-
-    def visit_BinOp(self, node: ast.BinOp) -> Union[ast.BinOp, ast.Call]:
-        """Due to Sympy crap, we need to translate the Xor nodes to our LogicalXor"""
-        if not (self._is_boolean_optimized and isinstance(node.op, ast.BitXor)):
-            return node
-        self.generic_visit(node)
-        return ast.Call(
-            func=ast.Name(LogicalXor.__name__),
-            args=[node.left, node.right],
-            keywords=[],
-        )

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -100,6 +100,7 @@ class SymbolicParamInference(ModelVisitor):
         )
         self._inferred_funcs: set[str] = set()
         self._scope: Mapping[str, ClassicalType] = {}
+        self._quantum_scope: set[str] = set()
         self._scope_operands: dict[str, QuantumOperandDeclaration] = {}
 
     def infer(self) -> None:
@@ -109,16 +110,19 @@ class SymbolicParamInference(ModelVisitor):
     @contextmanager
     def function_context(
         self,
-        func_name: Optional[str],
         scope: Mapping[str, ClassicalType],
+        quantum_scope: set[str],
         scope_operands: dict[str, QuantumOperandDeclaration],
     ) -> Iterator[None]:
         prev_scope = self._scope
         self._scope = scope
+        prev_quantum_scope = self._quantum_scope
+        self._quantum_scope = quantum_scope
         prev_scope_ops = self._scope_operands
         self._scope_operands = scope_operands
         yield
         self._scope = prev_scope
+        self._quantum_scope = prev_quantum_scope
         self._scope_operands = prev_scope_ops
 
     def _infer_func_params(self, func: NativeFunctionDefinition) -> None:
@@ -126,8 +130,9 @@ class SymbolicParamInference(ModelVisitor):
             return
         self._inferred_funcs.add(func.name)
         scope = {param.name: param.classical_type for param in func.param_decls}
+        quantum_scope = set(func.port_names)
         scope_operands = func.operand_declarations_dict
-        with self.function_context(func.name, scope, scope_operands):
+        with self.function_context(scope, quantum_scope, scope_operands):
             for param in func.positional_arg_declarations:
                 for expr in _get_param_expressions(param):
                     self._process_compile_time_expression(expr.expr)
@@ -139,13 +144,14 @@ class SymbolicParamInference(ModelVisitor):
             cast(str, param.name): param.classical_type
             for param in func.named_func_decl.param_decls
         }
+        quantum_scope = set(self._quantum_scope) | set(func.named_func_decl.port_names)
         scope_operands = self._scope_operands | nameables_to_dict(
             cast(
                 Sequence[QuantumOperandDeclaration],
                 func.named_func_decl.operand_declarations,
             )
         )
-        with self.function_context(None, scope, scope_operands):
+        with self.function_context(scope, quantum_scope, scope_operands):
             self.visit(func.body)
 
     def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:

classiq/open_library/functions/state_preparation.py

@@ -327,7 +327,7 @@ def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
 @qfunc
 def apply_phase_table(
     phases: list[float],
-    target: QArray[QBit, Literal["log(get_field(phases, 'len'), 2)"]],
+    target: QArray[QBit, Literal["log(phases.len, 2)"]],
 ) -> None:
     alphas = -2 * _classical_hadamard_transform(phases) / np.sqrt(len(phases))
 
@@ -344,7 +344,7 @@ def apply_phase_table(
 def inplace_prepare_complex_amplitudes(
     magnitudes: CArray[CReal],
     phases: list[float],
-    target: QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]],
+    target: QArray[QBit, Literal["log(magnitudes.len, 2)"]],
 ) -> None:
     """
 
@@ -367,7 +367,7 @@ def inplace_prepare_complex_amplitudes(
 def prepare_complex_amplitudes(
     magnitudes: CArray[CReal],
     phases: list[float],
-    out: Output[QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]]],
+    out: Output[QArray[QBit, Literal["log(magnitudes.len, 2)"]]],
 ) -> None:
     """
 

classiq/qmod/builtins/functions/allocation.py

@@ -25,7 +25,7 @@ def free(in_: Permutable[Input[QArray[QBit]]]) -> None:
 def prepare_state(
     probabilities: CArray[CReal],
     bound: CReal,
-    out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
+    out: Output[QArray[QBit, Literal["log(probabilities.len, 2)"]]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -54,7 +54,7 @@ def prepare_state(
 def prepare_amplitudes(
     amplitudes: CArray[CReal],
     bound: CReal,
-    out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
+    out: Output[QArray[QBit, Literal["log(amplitudes.len, 2)"]]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -83,7 +83,7 @@ def prepare_amplitudes(
 def inplace_prepare_state(
     probabilities: CArray[CReal],
     bound: CReal,
-    target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
+    target: QArray[QBit, Literal["log(probabilities.len, 2)"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -106,7 +106,7 @@ def inplace_prepare_state(
 def inplace_prepare_amplitudes(
     amplitudes: CArray[CReal],
     bound: CReal,
-    target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
+    target: QArray[QBit, Literal["log(amplitudes.len, 2)"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -129,7 +129,7 @@ def inplace_prepare_amplitudes(
 def inplace_prepare_amplitudes_approx(
     amplitudes: CArray[CReal],
     bound: CReal,
-    target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
+    target: QArray[QBit, Literal["log(amplitudes.len, 2)"]],
 ) -> None:
     pass
 
@@ -138,7 +138,7 @@ def inplace_prepare_amplitudes_approx(
 def prepare_amplitudes_approx(
     amplitudes: CArray[CReal],
     bound: CReal,
-    out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
+    out: Output[QArray[QBit, Literal["log(amplitudes.len, 2)"]]],
 ) -> None:
     pass
 
@@ -147,7 +147,7 @@ def prepare_amplitudes_approx(
 def inplace_prepare_state_approx(
     probabilities: CArray[CReal],
     bound: CReal,
-    target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
+    target: QArray[QBit, Literal["log(probabilities.len, 2)"]],
 ) -> None:
     pass
 
@@ -156,6 +156,6 @@ def inplace_prepare_state_approx(
 def prepare_state_approx(
     probabilities: CArray[CReal],
     bound: CReal,
-    out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
+    out: Output[QArray[QBit, Literal["log(probabilities.len, 2)"]]],
 ) -> None:
     pass

classiq/qmod/builtins/functions/arithmetic.py

@@ -16,7 +16,7 @@ from classiq.qmod.qmod_variable import (
 @qfunc(external=True)
 def unitary(
     elements: CArray[CArray[CReal]],
-    target: QArray[QBit, Literal["log(get_field(elements[0], 'len'), 2)"]],
+    target: QArray[QBit, Literal["log(elements[0].len, 2)"]],
 ) -> None:
     """
     [Qmod core-library function]