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

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/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]

classiq/qmod/builtins/functions/chemistry.py

@@ -1,3 +1,7 @@
+import warnings
+
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
 from classiq.qmod.builtins.structs import (
     FockHamiltonianProblem,
     MoleculeProblem,
@@ -13,6 +17,16 @@ def molecule_ucc(
     excitations: CArray[CInt],
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `molecule_ucc` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -22,6 +36,16 @@ def molecule_hva(
     reps: CInt,
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `molecule_hva` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -30,6 +54,16 @@ def molecule_hartree_fock(
     molecule_problem: MoleculeProblem,
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `molecule_hartree_fock` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -39,6 +73,16 @@ def fock_hamiltonian_ucc(
     excitations: CArray[CInt],
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `fock_hamiltonian_ucc` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -48,6 +92,16 @@ def fock_hamiltonian_hva(
     reps: CInt,
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `fock_hamiltonian_hva` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -56,4 +110,14 @@ def fock_hamiltonian_hartree_fock(
     fock_hamiltonian_problem: FockHamiltonianProblem,
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `fock_hamiltonian_hartree_fock` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass

classiq/qmod/builtins/functions/exponentiation.py

@@ -14,7 +14,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 def single_pauli_exponent(
     pauli_string: CArray[Pauli],
     coefficient: CReal,
-    qbv: QArray[QBit, Literal["get_field(pauli_string, 'len')"]],
+    qbv: QArray[QBit, Literal["pauli_string.len"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -33,9 +33,7 @@ def single_pauli_exponent(
 def commuting_paulis_exponent(
     pauli_operator: CArray[PauliTerm],
     evolution_coefficient: CReal,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit, Literal["pauli_operator[0].pauli.len"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -113,11 +111,11 @@ def multi_suzuki_trotter(
 @qfunc(external=True)
 def parametric_suzuki_trotter(
     paulis: CArray[CArray[Pauli]],
-    coefficients: CArray[CReal, Literal["get_field(paulis, 'len')"]],
+    coefficients: CArray[CReal, Literal["paulis.len"]],
     evolution_coefficient: CReal,
     order: CInt,
     repetitions: CInt,
-    qbv: QArray[QBit, Literal["get_field(paulis[0], 'len')"]],
+    qbv: QArray[QBit, Literal["paulis[0].len"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -147,7 +145,7 @@ def sparse_suzuki_trotter(
     evolution_coefficient: CReal,
     order: CInt,
     repetitions: CInt,
-    qbv: QArray[QBit, Literal["get_field(pauli_operator, 'num_qubits')"]],
+    qbv: QArray[QBit, Literal["pauli_operator.num_qubits"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -174,9 +172,7 @@ def qdrift(
     pauli_operator: CArray[PauliTerm],
     evolution_coefficient: CReal,
     num_qdrift: CInt,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit, Literal["pauli_operator[0].pauli.len"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -199,9 +195,7 @@ def exponentiation_with_depth_constraint(
     pauli_operator: CArray[PauliTerm],
     evolution_coefficient: CReal,
     max_depth: CInt,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit, Literal["pauli_operator[0].pauli.len"]],
 ) -> None:
     """
     [Qmod core-library function]

classiq/qmod/builtins/functions/qsvm.py

@@ -11,7 +11,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 @qfunc(external=True)
 def pauli_feature_map(
     feature_map: QSVMFeatureMapPauli,
-    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
+    qbv: QArray[QBit, Literal["feature_map.feature_dimension"]],
 ) -> None:
     pass