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

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/__init__.py

@@ -101,6 +101,7 @@ __all__ = [
     "inplace_c_modular_multiply",
     "inplace_prepare_complex_amplitudes",
     "inplace_prepare_int",
+    "inplace_prepare_sparse_amplitudes",
     "lcu",
     "lcu_pauli",
     "linear_pauli_rotations",
@@ -117,6 +118,7 @@ __all__ = [
     "prepare_ghz_state",
     "prepare_int",
     "prepare_linear_amplitudes",
+    "prepare_sparse_amplitudes",
     "prepare_uniform_interval_state",
     "prepare_uniform_trimmed_state",
     "projector_controlled_double_phase",

classiq/open_library/functions/state_preparation.py

@@ -24,6 +24,7 @@ from classiq.qmod.builtins.operations import (
     control,
     if_,
     inplace_add,
+    inplace_xor,
     repeat,
     within_apply,
 )
@@ -326,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))
 
@@ -343,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:
     """
 
@@ -358,14 +359,15 @@ def inplace_prepare_complex_amplitudes(
         target: The quantum variable to act upon.
     """
     inplace_prepare_amplitudes(magnitudes, 0, target)
-    apply_phase_table(phases, target)
+    if not np.allclose(phases, 0, atol=1e-12):
+        apply_phase_table(phases, target)
 
 
 @qfunc
 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:
     """
 
@@ -486,7 +488,7 @@ def _zero_ctrl_rot(ctrl: QNum, target: QBit, theta: CReal) -> None:
 
 @qfunc
 def prepare_linear_amplitudes(x: QArray) -> None:
-    """ "
+    """
     [Qmod Classiq-library function]
 
     Initializes a quantum variable in a state with linear amplitudes:
@@ -511,3 +513,136 @@ def prepare_linear_amplitudes(x: QArray) -> None:
             _zero_ctrl_rot(x[0:k], x[k], thetas[k])
 
     hadamard_transform(x)
+
+
+@qfunc
+def swap_states(a: int, b: int, target: QArray) -> None:
+    """
+    Swap 2 computational basis states a and b, leave all other states untouched.
+
+    Args:
+        a: 1st state number.
+        b: 2nd state number.
+        target: The quantum variable to act upon.
+    """
+    assert a != b, "a and b should be different"
+    diff = a ^ b
+    diff_indices = [i for i in range(target.len) if (diff >> i) & 1]
+    anchor = diff_indices[0]
+    anchor_bit = (a >> anchor) & 1
+
+    # a hack for the binding (should be improved after we have cast
+    target_without_anchor = []
+    if anchor > 0:
+        target_without_anchor.append(target[0:anchor])
+    if anchor < target.len - 1:
+        target_without_anchor.append(target[anchor + 1 : target.len])
+
+    @qfunc
+    def _xor_if_equal(n: CInt, ctrl: QNum, target: QBit) -> None:
+        target ^= ctrl == n
+
+    def _remove_bit(x: int, j: int) -> int:
+        """
+        Remove bit j from integer x (0 = least significant bit)
+        and shift higher bits down.
+        """
+        low = x & ((1 << j) - 1)  # bits below j
+        high = x >> (j + 1)  # bits above j
+        return low | (high << j)
+
+    within_apply(
+        # make the states equal except the anchor qubit
+        lambda: [
+            inplace_xor(target[anchor] != anchor_bit, target[i])
+            for i in diff_indices[1:]
+        ],
+        # do the actual swapping
+        lambda: _xor_if_equal(
+            _remove_bit(a, anchor), target_without_anchor, target[anchor]
+        ),
+    )
+
+
+@qfunc
+def inplace_prepare_sparse_amplitudes(
+    states: list[int], amplitudes: list[complex], target: QArray
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Prepares a quantum state with the given (complex) amplitudes. The input is given sparse format, as a list of non-zero states and their corresponding amplitudes.
+    Notice that the function is only suitable sparse states. Inspired by https://arxiv.org/abs/2310.19309.
+
+    For example, `inplace_prepare_sparse_amplitudes([1, 8], [np.sqrt(0.5), np.sqrt(0.5)], target)` will prepare the state sqrt(0.5)|1> + sqrt(0.5)|8>
+    on the target variable, assuming it starts in the |0> state.
+
+    Complexity: Asymptotic gate complexity is $O(dn)$ where d is the number of states and n is the target number of qubits.
+
+    Args:
+        states: A list of distinct computational basis indices to populate. Each integer corresponds to the basis state in the computational basis.
+        amplitudes: A list of complex amplitudes for the corresponding entries in `states`. Must have the same length as `states`.
+        target: The quantum variable on which the state is to be prepared. Its size must be sufficient to represent all states in `states`.
+    """
+    assert len(amplitudes) == len(
+        states
+    ), "amplitudes and states should have the same size"
+    assert (
+        max(list(states)) <= 2**target.len
+    ), "the target quantum variable is not large enough to populate all states"
+    assert len(set(states)) == len(states), "all states should be distinct"
+
+    # prepare a dense state
+    dense_size = max(int(np.ceil(np.log2(len(states)))), 1)
+    dense_amplitudes = np.zeros(2**dense_size, dtype=complex)
+
+    ## make sure the states with number smaller than the dense state size are located in their place already
+    for i, state in enumerate(states):
+        if state < len(dense_amplitudes):
+            dense_amplitudes[state] = amplitudes[i]
+
+    ## make a swap list for all other states
+    swap_list = []
+    free_index = 0
+    for i, state in enumerate(states):
+        if state < len(dense_amplitudes):
+            continue  # already populated
+        while dense_amplitudes[free_index]:
+            free_index += 1  # index is not free
+
+        dense_amplitudes[free_index] = amplitudes[i]
+        swap_list.append((free_index, state))
+        free_index += 1
+
+    inplace_prepare_complex_amplitudes(
+        np.abs(dense_amplitudes), np.angle(dense_amplitudes), target[0:dense_size]
+    )
+
+    # swap all required states
+    sparse_size = max(int(np.ceil(np.log2(max(list(states) + [1])))), 1)
+    for a, b in swap_list:
+        swap_states(a, b, target[0:sparse_size])
+
+
+@qfunc
+def prepare_sparse_amplitudes(
+    states: list[int], amplitudes: list[complex], out: Output[QArray]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Initializes and prepares a quantum state with the given (complex) amplitudes. The input is given sparse format, as a list of non-zero states and their corresponding amplitudes.
+    Notice that the function is only suitable sparse states. Inspired by https://arxiv.org/abs/2310.19309.
+
+    For example, `prepare_sparse_amplitudes([1, 8], [np.sqrt(0.5), np.sqrt(0.5)], out)` will and allocate it to be of size 4 qubits, and
+    prepare it in the state sqrt(0.5)|1> + sqrt(0.5)|8>.
+
+    Complexity: Asymptotic gate complexity is $O(dn)$ where d is the number of states and n is the required number of qubits.
+
+    Args:
+        states: A list of distinct computational basis indices to populate. Each integer corresponds to the basis state in the computational basis.
+        amplitudes: A list of complex amplitudes for the corresponding entries in `states`. Must have the same length as `states`.
+        out: The allocated quantum variable.
+    """
+    allocate(max(int(np.ceil(np.log2(max(states)))), 1), out)
+    inplace_prepare_sparse_amplitudes(states, amplitudes, out)

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