classiq 0.39.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

classiq/interface/generator/arith/binary_ops.py

@@ -154,7 +154,11 @@ class InplacableBinaryOpParams(
         if self.inplace_arg is None:
             return 0
         arg = self.left_arg if self.inplace_arg == ArgToInplace.LEFT else self.right_arg
-        return max(0, arg.integer_part_size - self.result_register.integer_part_size)  # type: ignore[attr-defined]
+        return max(
+            0, arg.integer_part_size - self.result_register.integer_part_size  # type: ignore[attr-defined]
+        ) + max(
+            0, arg.fraction_places - self.result_register.fraction_places  # type: ignore[attr-defined]
+        )
 
     def _carried_arguments(self) -> Tuple[Optional[LeftDataT], Optional[RightDataT]]:
         if self.inplace_arg == ArgToInplace.RIGHT and isinstance(
@@ -259,15 +263,21 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "sum"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        lb = argument_utils.lower_bound(self.left_arg) + argument_utils.lower_bound(
-            self.right_arg
+        left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, machine_precision=self.machine_precision
         )
-        ub = argument_utils.upper_bound(self.left_arg) + argument_utils.upper_bound(
-            self.right_arg
+        right_arg = argument_utils.limit_fraction_places(
+            self.right_arg, machine_precision=self.machine_precision
+        )
+        lb = argument_utils.lower_bound(left_arg) + argument_utils.lower_bound(
+            right_arg
+        )
+        ub = argument_utils.upper_bound(left_arg) + argument_utils.upper_bound(
+            right_arg
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            argument_utils.fraction_places(left_arg),
+            argument_utils.fraction_places(right_arg),
         )
         return RegisterArithmeticInfo(
             size=self.output_size or self._get_output_size(ub, lb, fraction_places),
@@ -291,16 +301,47 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
 class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "difference"
 
+    @staticmethod
+    def _get_effective_arg(
+        arg: RegisterOrConst, machine_precision: int
+    ) -> RegisterOrConst:
+        return argument_utils.limit_fraction_places(
+            arg, machine_precision=machine_precision
+        )
+
+    @property
+    def effective_left_arg(self) -> RegisterOrConst:
+        return self._get_effective_arg(self.left_arg, self.machine_precision)
+
+    @property
+    def effective_right_arg(self) -> RegisterOrConst:
+        return self._get_effective_arg(self.right_arg, self.machine_precision)
+
+    @staticmethod
+    def _is_arg_trimmed_register(arg: RegisterOrConst, machine_precision: int) -> bool:
+        return (
+            isinstance(arg, RegisterArithmeticInfo)
+            and arg.fraction_places > machine_precision
+        )
+
+    @property
+    def left_arg_is_trimmed_register(self) -> bool:
+        return self._is_arg_trimmed_register(self.left_arg, self.machine_precision)
+
+    @property
+    def right_arg_is_trimmed_register(self) -> bool:
+        return self._is_arg_trimmed_register(self.right_arg, self.machine_precision)
+
     def _get_result_register(self) -> RegisterArithmeticInfo:
         bounds = (
-            argument_utils.lower_bound(self.left_arg)
-            - argument_utils.upper_bound(self.right_arg),
-            argument_utils.upper_bound(self.left_arg)
-            - argument_utils.lower_bound(self.right_arg),
+            argument_utils.lower_bound(self.effective_left_arg)
+            - argument_utils.upper_bound(self.effective_right_arg),
+            argument_utils.upper_bound(self.effective_left_arg)
+            - argument_utils.lower_bound(self.effective_right_arg),
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            argument_utils.fraction_places(self.effective_left_arg),
+            argument_utils.fraction_places(self.effective_right_arg),
         )
 
         return RegisterArithmeticInfo(
@@ -313,38 +354,60 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     def _get_output_size(
         self, bounds: Tuple[float, float], fraction_places: int
     ) -> int:
-        if isinstance(self.right_arg, float) and self.right_arg == 0:
-            assert isinstance(self.left_arg, RegisterArithmeticInfo)
-            return self.left_arg.size
+        if isinstance(self.right_arg, float) and self.effective_right_arg == 0:
+            assert isinstance(self.effective_left_arg, RegisterArithmeticInfo)
+            return self.effective_left_arg.size
         integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
         size_needed = integer_part_size + fraction_places
         return size_needed
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
-        if not isinstance(self.right_arg, RegisterArithmeticInfo):
+        if (
+            not self.left_arg_is_trimmed_register
+            and not self.right_arg_is_trimmed_register
+        ):
+            return self._untrimmed_garbage_output_size()
+        if not self.is_inplaced():
+            return 0
+        inplace_arg_name = (
+            self.left_arg_name
+            if self.inplace_arg == ArgToInplace.LEFT
+            else self.right_arg_name
+        )
+        return max(
+            0,
+            self._inputs[inplace_arg_name].fraction_places
+            - self.result_register.fraction_places,
+        )
+
+    def _untrimmed_garbage_output_size(self) -> pydantic.NonNegativeInt:
+        if not isinstance(self.effective_right_arg, RegisterArithmeticInfo):
             adder_params = Adder(
-                left_arg=self.left_arg,
-                right_arg=-self.right_arg,
+                left_arg=self.effective_left_arg,
+                right_arg=-self.effective_right_arg,
                 output_size=self.output_size,
                 inplace_arg=self.inplace_arg,
             )
             return adder_params.garbage_output_size()
 
         negation_params = Negation(
-            arg=self.right_arg,
+            arg=self.effective_right_arg,
             output_size=self.negation_output_size,
             inplace=self.should_inplace_negation,
         )
         negation_result = negation_params.result_register
-        if self.output_size is None and max(self.right_arg.bounds) > 0:
+        if self.output_size is None and max(self.effective_right_arg.bounds) > 0:
             negation_result = negation_result.copy(
                 update=dict(
                     is_signed=True,
-                    bounds=(-max(self.right_arg.bounds), -min(self.right_arg.bounds)),
+                    bounds=(
+                        -max(self.effective_right_arg.bounds),
+                        -min(self.effective_right_arg.bounds),
+                    ),
                 )
             )
         adder_params = Adder(
-            left_arg=self.left_arg,
+            left_arg=self.effective_left_arg,
             right_arg=negation_result,
             output_size=self.output_size,
             inplace_arg=self.arg_to_inplace_adder,
@@ -359,10 +422,10 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         return self.inplace_arg == ArgToInplace.LEFT
 
     def _expected_negation_output_size(self) -> int:
-        return argument_utils.fraction_places(self.right_arg) + min(
+        return argument_utils.fraction_places(self.effective_right_arg) + min(
             self.result_register.integer_part_size,
             number_utils.bounds_to_integer_part_size(
-                *(-bound for bound in argument_utils.bounds(self.right_arg))
+                *(-bound for bound in argument_utils.bounds(self.effective_right_arg))
             ),
         )
 

classiq/interface/generator/arith/unary_ops.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Iterable, Optional
+from typing import TYPE_CHECKING, Final, Iterable, Optional
 
 import pydantic
 
@@ -11,7 +11,7 @@ from classiq.interface.generator.function_params import get_zero_input_name
 
 from classiq.exceptions import ClassiqValueError
 
-UNARY_ARG_NAME: str = "arg"
+UNARY_ARG_NAME: Final[str] = "arg"
 
 
 class UnaryOpParams(ArithmeticOperationParams):
@@ -19,17 +19,16 @@ class UnaryOpParams(ArithmeticOperationParams):
     inplace: bool = False
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
-        return int(self.is_inplaced()) * max(
-            self.arg.size - self.result_register.size, 0
+        return int(self.is_inplaced()) * (
+            max(self.arg.integer_part_size - self.result_register.integer_part_size, 0)
+            + max(self.arg.fraction_places - self.result_register.fraction_places, 0)
         )
 
     def should_add_zero_inputs(self) -> bool:
-        return not self.is_inplaced() or self.should_add_zero_input_for_extension()
+        return not self.is_inplaced() or self.zero_input_for_extension() > 0
 
-    def should_add_zero_input_for_extension(
-        self, output_size: Optional[int] = None
-    ) -> bool:
-        return (output_size or self.result_register.size) > self.arg.size
+    def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
+        return max(0, self.result_register.size - self.arg.size)
 
     def _create_ios(self) -> None:
         self._inputs = {UNARY_ARG_NAME: self.arg}
@@ -41,8 +40,8 @@ class UnaryOpParams(ArithmeticOperationParams):
             zero_input_register = self.result_register
             self._zero_inputs = {zero_input_name: zero_input_register}
             return
-        if self.should_add_zero_input_for_extension():
-            output_extension_size = self.result_register.size - self.arg.size
+        if self.zero_input_for_extension() > 0:
+            output_extension_size = self.zero_input_for_extension()
             self._create_zero_input_registers({zero_input_name: output_extension_size})
         if self.garbage_output_size() > 0:
             self._outputs[self.garbage_output_name] = RegisterArithmeticInfo(
@@ -80,23 +79,33 @@ class BitwiseInvert(UnaryOpParams):
 class Negation(UnaryOpParams):
     output_name = "negated"
 
-    def _expected_result_size(self) -> pydantic.PositiveInt:
-        if self.arg.size == 1:
+    @staticmethod
+    def _expected_result_size(arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
+        if arg.size == 1:
             return 1
-        return self.arg.fraction_places + number_utils.bounds_to_integer_part_size(
-            *(-bound for bound in self.arg.bounds)
+        return arg.fraction_places + number_utils.bounds_to_integer_part_size(
+            *(-bound for bound in arg.bounds)
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        is_signed = max(self.arg.bounds) > 0 and self._include_sign
-        bounds = (-max(self.arg.bounds), -min(self.arg.bounds))
+        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
+        is_signed = max(eff_arg.bounds) > 0 and self._include_sign
+        bounds = (-max(eff_arg.bounds), -min(eff_arg.bounds))
         return RegisterArithmeticInfo(
-            size=self.output_size or self._expected_result_size(),
-            fraction_places=self.arg.fraction_places,
+            size=self.output_size or self._expected_result_size(eff_arg),
+            fraction_places=eff_arg.fraction_places,
             is_signed=is_signed,
             bounds=bounds if (is_signed or min(bounds) >= 0) else None,
         )
 
+    def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
+        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
+        if (self.output_size or eff_arg.size) == 1:
+            return 0
+        return (
+            self.output_size or self._expected_result_size(self.arg)
+        ) - self.arg.size
+
 
 class Sign(UnaryOpParams):
     output_name = "sign"

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,3 +1,5 @@
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
+
 SUPPORTED_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
@@ -9,8 +11,6 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "get_type",
     "struct_literal",
     "get_field",
-    "fraction_digits",
-    "is_signed",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
@@ -20,3 +20,7 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "BitwiseOr",
     *SUPPORTED_BUILTIN_FUNCTIONS,
 }
+
+SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD = (
+    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS - CLASSICAL_ATTRIBUTES
+)

classiq/interface/generator/expressions/enums/__init__.py

@@ -8,3 +8,13 @@ from .pauli import Pauli
 from .qsvm_feature_map_entanglement import QSVMFeatureMapEntanglement
 
 BUILTIN_ENUMS = dict(filter(lambda pair: isinstance(pair[1], EnumMeta), vars().items()))
+
+__all__ = [
+    "Element",
+    "FermionMapping",
+    "FinanceFunctionType",
+    "LadderOperator",
+    "Optimizer",
+    "Pauli",
+    "QSVMFeatureMapEntanglement",
+]

classiq/interface/generator/expressions/enums/classical_enum.py

@@ -2,4 +2,8 @@ import enum
 
 
 class ClassicalEnum(int, enum.Enum):
-    pass
+    def __str__(self) -> str:
+        return f"{type(self).__name__}.{self.name}"
+
+    def __repr__(self) -> str:
+        return str(self)

classiq/interface/generator/expressions/expression.py

@@ -1,4 +1,5 @@
 import ast
+import sys
 from typing import Any, Mapping, Optional, Type
 
 import pydantic
@@ -9,7 +10,7 @@ from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
 )
 from classiq.interface.generator.expressions.atomic_expression_functions import (
-    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS,
+    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD,
 )
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
@@ -34,13 +35,19 @@ class Expression(HashableASTNode):
     @pydantic.validator("expr")
     def validate_expression(cls, expr: str) -> str:
         supported_functions = (
-            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS
+            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD
             | set(SYMPY_SUPPORTED_EXPRESSIONS)
             | set(DEFAULT_SUPPORTED_FUNC_NAMES)
         )
         validate_expression_str(expr, supported_functions=supported_functions)
         return expr
 
+    @pydantic.validator("expr")
+    def format_expression(cls, expr: str) -> str:
+        if sys.version_info >= (3, 9):
+            expr = ast.unparse(ast.parse(expr))
+        return expr
+
     def is_evaluated(self) -> bool:
         return self._evaluated_expr is not None
 

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -0,0 +1,89 @@
+from typing import Optional, Tuple, Union
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+
+from classiq.exceptions import ClassiqValueError
+
+ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
+SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
+QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
+
+
+class QmodQArrayProxy(QmodSizedProxy):
+    def __init__(
+        self,
+        name: str,
+        size: int,
+        slice_: Optional[Tuple[int, int]] = None,
+        index_: Optional[int] = None,
+    ) -> None:
+        super().__init__(size)
+        self._name = name
+        self._slice = slice_
+        self._index = index_
+
+    def __getitem__(self, key: Union[slice, int]) -> "QmodQArrayProxy":
+        if self._index is not None:
+            raise ClassiqValueError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
+
+        new_index: Optional[int] = None
+
+        if isinstance(key, slice):
+            if key.step is not None:
+                raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+            new_slice = self._get_new_slice(key.start, key.stop)
+        else:
+            new_slice = self._get_new_slice(key, key + 1)
+            new_index = new_slice[0]
+
+        if (self._slice is not None and new_slice[1] > self._slice[1]) or new_slice[
+            1
+        ] > self._size:
+            raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
+
+        return QmodQArrayProxy(
+            self._name, self._size, slice_=new_slice, index_=new_index
+        )
+
+    def _get_new_slice(self, start: int, end: int) -> Tuple[int, int]:
+        if self._slice is not None:
+            return self._slice[0] + start, self._slice[0] + end
+        return start, end
+
+    @property
+    def index(self) -> Optional[int]:
+        return self._index
+
+    @property
+    def slice(self) -> Optional[Tuple[int, int]]:
+        return self._slice
+
+    @property
+    def handle(self) -> HandleBinding:
+        if self._index is not None:
+            return SubscriptHandleBinding(
+                name=self._name,
+                index=Expression(expr=str(self._index)),
+            )
+
+        if self._slice is not None:
+            return SlicedHandleBinding(
+                name=self._name,
+                start=Expression(expr=str(self._slice[0])),
+                end=Expression(expr=str(self._slice[1])),
+            )
+
+        return HandleBinding(name=self._name)
+
+    def __len__(self) -> int:
+        if (slice_ := self.slice) is not None:
+            return slice_[1] - slice_[0]
+        elif self.index is not None:
+            return 1
+        return self._size

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -1,6 +1,9 @@
+from typing import Any, Mapping
+
 from sympy import Symbol
 
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import HandleBinding
 
 
 class QmodQScalarProxy(Symbol, QmodSizedProxy):
@@ -9,6 +12,11 @@ class QmodQScalarProxy(Symbol, QmodSizedProxy):
 
     def __init__(self, name: str, size: int) -> None:
         super().__init__(size)
+        self.name = name
+
+    @property
+    def handle(self) -> HandleBinding:
+        return HandleBinding(name=self.name)
 
 
 class QmodQBitProxy(QmodQScalarProxy):
@@ -24,6 +32,10 @@ class QmodQNumProxy(QmodQScalarProxy):
         self._fraction_digits = fraction_digits
         self._is_signed = is_signed
 
+    @property
+    def size(self) -> int:
+        return self._size
+
     @property
     def fraction_digits(self) -> int:
         return self._fraction_digits
@@ -31,3 +43,11 @@ class QmodQNumProxy(QmodQScalarProxy):
     @property
     def is_signed(self) -> bool:
         return self._is_signed
+
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {
+            "size": self.size,
+            "is_signed": self.is_signed,
+            "fraction_digits": self.fraction_digits,
+        }

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,6 +1,28 @@
+from typing import TYPE_CHECKING, Any, Mapping
+
+from classiq.exceptions import ClassiqNotImplementedError
+
+if TYPE_CHECKING:
+    from classiq.interface.model.handle_binding import HandleBinding
+
+
 class QmodSizedProxy:
     def __init__(self, size: int) -> None:
         self._size = size
 
     def __len__(self) -> int:
         return self._size
+
+    @property
+    def handle(self) -> "HandleBinding":
+        raise ClassiqNotImplementedError("cannot compute handle")
+
+    @property
+    def len(self) -> int:
+        return self._size
+
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {
+            "len": self.len,
+        }

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -58,7 +58,16 @@ SPECIAL_FUNCTIONS: List[str] = [
     "catalan",
 ]
 PIECEWISE_FUNCTIONS: List[str] = ["Piecewise", "Heaviside"]
-CONSTANTS: List[str] = ["pi", "E", "I", "GoldenRatio", "EulerGamma", "Catalan"]
+NUMERIC_CONSTANTS: List[str] = [
+    "pi",
+    "E",
+    "I",
+    "GoldenRatio",
+    "EulerGamma",
+    "Catalan",
+]
+CONSTANTS: List[str] = NUMERIC_CONSTANTS + ["true", "false"]
+
 DATA_TYPES: List[str] = ["Matrix"]
 LOGIC_OPERATORS: List[str] = [
     "And",

classiq/interface/generator/functions/builtins/core_library/atomic_quantum_functions.py

@@ -423,7 +423,7 @@ UNITARY_FUNCTION = QuantumFunctionDeclaration(
         DEFAULT_TARGET_NAME: PortDeclaration(
             name=DEFAULT_TARGET_NAME,
             direction=PortDeclarationDirection.Inout,
-            size=Expression(expr="log(len(elements[0]), 2)"),
+            size=Expression(expr="log(get_field(elements[0], 'len'), 2)"),
         )
     },
 )
@@ -436,7 +436,7 @@ PREPARE_STATE_FUNCTION = QuantumFunctionDeclaration(
         "out": PortDeclaration(
             name="out",
             direction=PortDeclarationDirection.Output,
-            size=Expression(expr="log(len(probabilities), 2)"),
+            size=Expression(expr="log(get_field(probabilities, 'len'), 2)"),
         )
     },
 )
@@ -448,7 +448,7 @@ PREPARE_AMPLITUDES_FUNCTION = QuantumFunctionDeclaration(
         "out": PortDeclaration(
             name="out",
             direction=PortDeclarationDirection.Output,
-            size=Expression(expr="log(len(amplitudes), 2)"),
+            size=Expression(expr="log(get_field(amplitudes, 'len'), 2)"),
         )
     },
 )
@@ -467,7 +467,9 @@ ADD_FUNCTION = QuantumFunctionDeclaration(
         "result": PortDeclaration(
             name="result",
             direction=PortDeclarationDirection.Output,
-            size=Expression(expr="Max(len(left), len(right)) + 1"),
+            size=Expression(
+                expr="Max(get_field(left, 'len'), get_field(right, 'len')) + 1"
+            ),
         ),
     },
 )
@@ -578,7 +580,7 @@ INPLACE_PREPARE_STATE = QuantumFunctionDeclaration(
         "target": PortDeclaration(
             name="target",
             direction=PortDeclarationDirection.Inout,
-            size=Expression(expr="log(len(probabilities), 2)"),
+            size=Expression(expr="log(get_field(probabilities, 'len'), 2)"),
         )
     },
 )
@@ -591,7 +593,7 @@ INPLACE_PREPARE_AMPLITUDES = QuantumFunctionDeclaration(
         "target": PortDeclaration(
             name="target",
             direction=PortDeclarationDirection.Inout,
-            size=Expression(expr="log(len(amplitudes), 2)"),
+            size=Expression(expr="log(get_field(amplitudes, 'len'), 2)"),
         )
     },
 )

classiq/interface/generator/functions/builtins/core_library/exponentiation_functions.py

@@ -26,7 +26,7 @@ SINGLE_PAULI_EXPONENT_FUNCTION = QuantumFunctionDeclaration(
         "qbv": PortDeclaration(
             name="qbv",
             direction=PortDeclarationDirection.Inout,
-            size=Expression(expr="len(pauli_string)"),
+            size=Expression(expr="get_field(pauli_string, 'len')"),
         )
     },
 )
@@ -44,7 +44,9 @@ SUZUKI_TROTTER_FUNCTION = QuantumFunctionDeclaration(
         "qbv": PortDeclaration(
             name="qbv",
             direction=PortDeclarationDirection.Inout,
-            size=Expression(expr="len(get_field(pauli_operator[0], 'pauli'))"),
+            size=Expression(
+                expr="get_field(get_field(pauli_operator[0], 'pauli'), 'len')"
+            ),
         )
     },
 )
@@ -60,7 +62,9 @@ QDRIFT_FUNCTION = QuantumFunctionDeclaration(
         "qbv": PortDeclaration(
             name="qbv",
             direction=PortDeclarationDirection.Inout,
-            size=Expression(expr="len(get_field(pauli_operator[0], 'pauli'))"),
+            size=Expression(
+                expr="get_field(get_field(pauli_operator[0], 'pauli'), 'len')"
+            ),
         )
     },
 )
@@ -76,7 +80,9 @@ EXPONENTIATION_WITH_DEPTH_CONSTRAINT = QuantumFunctionDeclaration(
         "qbv": PortDeclaration(
             name="qbv",
             direction=PortDeclarationDirection.Inout,
-            size=Expression(expr="len(get_field(pauli_operator[0], 'pauli'))"),
+            size=Expression(
+                expr="get_field(get_field(pauli_operator[0], 'pauli'), 'len')"
+            ),
         )
     },
 )