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

classiq/__init__.py

@@ -34,6 +34,7 @@ from classiq.applications.chemistry import (
 )
 from classiq.applications.combinatorial_optimization import (
     construct_combinatorial_optimization_model,
+    pyo_model_to_hamiltonian,
 )
 from classiq.applications.finance import construct_finance_model
 from classiq.applications.grover import construct_grover_model

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -446,7 +446,7 @@ def _get_chemistry_quantum_main(
             function="allocate",
             positional_args=[
                 Expression(
-                    expr=f"len(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'))"
+                    expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
                 ),
                 HandleBinding(name="qbv"),
             ],

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -9,6 +9,7 @@ from classiq.interface.combinatorial_optimization.solver_types import QSolver
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 
+from classiq import Pauli
 from classiq.applications.combinatorial_helpers.optimization_model import (
     OptimizationModel,
 )
@@ -16,14 +17,13 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_sparsing imp
     SparsePauliOp,
 )
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
-    PauliTerm,
     get_pauli_operator,
     pauli_operator_to_hamiltonian,
-    pauli_string_to_int,
 )
 from classiq.applications.combinatorial_helpers.pyomo_utils import (
     convert_pyomo_to_global_presentation,
 )
+from classiq.qmod.builtins import PauliTerm
 
 
 def compute_qaoa_initial_point(
@@ -58,10 +58,9 @@ def pyo_model_to_hamiltonian(
     pauli_operator = get_pauli_operator(hamiltonian).pauli_list
     pauli_terms = []
     for item in pauli_operator:
-        term = PauliTerm()
-        term.pauli, term.coefficient = (
-            pauli_string_to_int(item[0]),
-            cast(complex, item[1]).real,
+        term = PauliTerm(
+            [Pauli[p] for p in item[0]],  # type:ignore[arg-type]
+            cast(complex, item[1]).real,  # type:ignore[arg-type]
         )
         pauli_terms.append(term)
 

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -45,22 +45,23 @@ class OptimizationModel:
         encoding_type: Optional[EncodingType] = None,
     ) -> None:
         assert model.nobjectives() == 1, "model must have a single objective"
-        self._model_original = copy.deepcopy(model)
-        self._assigned_model = remove_fixed_variables(model)
+        model_copy = copy.deepcopy(model)
+        self._model_original = model
+        self._assigned_model = remove_fixed_variables(model_copy)
         self.qsolver = qsolver
         self._encoding_type = encoding_type
 
-        self.is_encoded = encoding_utils.is_model_encodable(model)
+        self.is_encoded = encoding_utils.is_model_encodable(model_copy)
         if self.is_encoded:
             if self._encoding_type is None:
                 self._encoding_type = EncodingType.BINARY
             self._model_encoder = encoding.ModelEncoder(
-                model, qsolver, self._encoding_type
+                model_copy, qsolver, self._encoding_type
             )
             self._model = self._model_encoder.encoded_model
             self._vars_encoding_mapping = self._model_encoder.vars_encoding_mapping
         else:
-            self._model = model
+            self._model = model_copy
             # TODO How to handle encoding_type == None
             self._vars_encoding_mapping = EncodingMapping(self._encoding_type)  # type: ignore[arg-type]
 
@@ -70,7 +71,7 @@ class OptimizationModel:
             self.vars_not_encoded, self._vars_encoding_mapping
         )
 
-        self.is_maximization = sense.is_maximization(model)
+        self.is_maximization = sense.is_maximization(model_copy)
         self.objective = next(self._model.component_objects(pyo.Objective))
 
         self.penalty_energy = penalty_energy

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -12,16 +12,6 @@ from classiq.exceptions import (
 )
 
 
-class PauliTerm:
-    pauli: List[int]
-    coefficient: float
-
-
-def pauli_string_to_int(pauli_str: str) -> List[int]:
-    pauli_map = {"I": 0, "X": 1, "Y": 2, "Z": 3}
-    return [pauli_map[char] for char in pauli_str]
-
-
 def _pauli_str_to_enums(pauli_str: str) -> str:
     return ", ".join(f"Pauli.{pauli_term}" for pauli_term in pauli_str)
 

classiq/applications/combinatorial_optimization/__init__.py

@@ -6,6 +6,7 @@ from classiq.interface.combinatorial_optimization.solver_types import QSolver
 
 from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
     get_optimization_solution_from_pyo,
+    pyo_model_to_hamiltonian,
 )
 
 from .combinatorial_optimization_config import OptimizerConfig, QAOAConfig
@@ -21,6 +22,7 @@ __all__ = [
     "construct_combinatorial_optimization_model",
     "examples",
     "get_optimization_solution_from_pyo",
+    "pyo_model_to_hamiltonian",
 ]
 
 

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -88,14 +88,14 @@ def construct_combi_opt_py_model(
                     QuantumFunctionCall(
                         function="allocate",
                         positional_args=[
-                            Expression(expr="len(target)"),
+                            Expression(expr="target.len"),
                             HandleBinding(name="target"),
                         ],
                     ),
                     QuantumFunctionCall(
                         function="qaoa_penalty",
                         params={
-                            "num_qubits": Expression(expr="len(target)"),
+                            "num_qubits": Expression(expr="target.len"),
                             "params_list": Expression(expr="params_list"),
                             "hamiltonian": Expression(expr="hamiltonian"),
                         },

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.39.0'
+SEMVER_VERSION = '0.40.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -12,8 +12,8 @@ from classiq.interface.backend.quantum_backend_providers import (
     AliceBobBackendNames,
     AmazonBraketBackendNames,
     AzureQuantumBackendNames,
-    ClassiqAerBackendNames,
     ClassiqNvidiaBackendNames,
+    ClassiqSimulatorBackendNames,
     IonqBackendNames,
     OQCBackendNames,
     ProviderTypeVendor,
@@ -56,7 +56,7 @@ class BackendPreferences(BaseModel):
         return False
 
 
-AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=5).total_seconds())
+AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=240).total_seconds())
 
 
 class AliceBobBackendPreferences(BackendPreferences):
@@ -221,13 +221,13 @@ def is_exact_simulator(backend_preferences: BackendPreferences) -> bool:
 
 
 def default_backend_preferences(
-    backend_name: str = ClassiqAerBackendNames.AER_SIMULATOR,
+    backend_name: str = ClassiqSimulatorBackendNames.SIMULATOR,
 ) -> BackendPreferences:
     return ClassiqBackendPreferences(backend_name=backend_name)
 
 
 def backend_preferences_field(
-    backend_name: str = ClassiqAerBackendNames.AER_SIMULATOR,
+    backend_name: str = ClassiqSimulatorBackendNames.SIMULATOR,
 ) -> Any:
     return pydantic.Field(
         default_factory=lambda: default_backend_preferences(backend_name),
@@ -252,7 +252,7 @@ __all__ = [
     "AzureCredential",
     "AzureQuantumBackendNames",
     "ClassiqBackendPreferences",
-    "ClassiqAerBackendNames",
+    "ClassiqSimulatorBackendNames",
     "IBMBackendPreferences",
     "IBMBackendProvider",
     "AwsBackendPreferences",

classiq/interface/backend/quantum_backend_providers.py

@@ -31,11 +31,11 @@ class ProviderTypeVendor:
     OQC = Literal[ProviderVendor.OQC]
 
 
-class ClassiqAerBackendNames(StrEnum):
-    AER_SIMULATOR = "aer_simulator"
-    AER_SIMULATOR_STATEVECTOR = "aer_simulator_statevector"
-    AER_SIMULATOR_DENSITY_MATRIX = "aer_simulator_density_matrix"
-    AER_SIMULATOR_MATRIX_PRODUCT_STATE = "aer_simulator_matrix_product_state"
+class ClassiqSimulatorBackendNames(StrEnum):
+    SIMULATOR = "simulator"
+    SIMULATOR_STATEVECTOR = "simulator_statevector"
+    SIMULATOR_DENSITY_MATRIX = "simulator_density_matrix"
+    SIMULATOR_MATRIX_PRODUCT_STATE = "simulator_matrix_product_state"
 
 
 class IonqBackendNames(StrEnum):
@@ -141,7 +141,7 @@ class ClassiqNvidiaBackendNames(StrEnum):
     SIMULATOR = "nvidia_state_vector_simulator"
 
 
-AllClassiqBackendNames = Union[ClassiqAerBackendNames, ClassiqNvidiaBackendNames]
+AllClassiqBackendNames = Union[ClassiqSimulatorBackendNames, ClassiqNvidiaBackendNames]
 
 
 class GoogleNvidiaBackendNames(StrEnum):
@@ -166,7 +166,7 @@ EXACT_SIMULATORS = {
     AmazonBraketBackendNames.AMAZON_BRAKET_SV1,
     AmazonBraketBackendNames.AMAZON_BRAKET_TN1,
     AmazonBraketBackendNames.AMAZON_BRAKET_DM1,
-    *ClassiqAerBackendNames,
+    *ClassiqSimulatorBackendNames,
     *ClassiqNvidiaBackendNames,
 }
 

classiq/interface/executor/execution_preferences.py

@@ -10,8 +10,9 @@ from classiq.interface.backend.backend_preferences import (
     backend_preferences_field,
 )
 from classiq.interface.backend.pydantic_backend import MAX_EXECUTION_TIMEOUT_SECONDS
-from classiq.interface.backend.quantum_backend_providers import ClassiqAerBackendNames
-from classiq.interface.executor.error_mitigation import ErrorMitigationMethod
+from classiq.interface.backend.quantum_backend_providers import (
+    ClassiqSimulatorBackendNames,
+)
 from classiq.interface.executor.optimizer_preferences import (
     OptimizerPreferences,
     OptimizerType,
@@ -51,11 +52,6 @@ class ExecutionPreferences(pydantic.BaseModel):
         default_factory=None,
         description="Settings related to VQE execution.",
     )
-    error_mitigation_method: Optional[ErrorMitigationMethod] = pydantic.Field(
-        default=None,
-        description="Error mitigation method. Currently supports complete and tensored "
-        "measurement calibration.",
-    )
     noise_properties: Optional[NoiseProperties] = pydantic.Field(
         default=None, description="Properties of the noise in the circuit"
     )
@@ -64,7 +60,7 @@ class ExecutionPreferences(pydantic.BaseModel):
         description="The random seed used for the execution",
     )
     backend_preferences: BackendPreferencesTypes = backend_preferences_field(
-        backend_name=ClassiqAerBackendNames.AER_SIMULATOR
+        backend_name=ClassiqSimulatorBackendNames.SIMULATOR
     )
     num_shots: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
     transpile_to_hardware: TranspilationOption = pydantic.Field(
@@ -151,7 +147,6 @@ def _choose_original_or_optimizer_attribute(
 
 __all__ = [
     "ExecutionPreferences",
-    "ErrorMitigationMethod",
     "NoiseProperties",
     "OptimizerPreferences",
     "OptimizerType",

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -24,9 +24,7 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 
 MOLECULE_PROBLEM_PARAM = {"molecule_problem": Struct(name="MoleculeProblem")}
-MOLECULE_PROBLEM_SIZE = (
-    "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-)
+MOLECULE_PROBLEM_SIZE = "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
 MOLECULE_PROBLEM_PORT = {
     "qbv": PortDeclaration(
         name="qbv",
@@ -40,7 +38,7 @@ MOLECULE_PROBLEM_PORT = {
 FOCK_HAMILTONIAN_PROBLEM_PARAM = {
     "fock_hamiltonian_problem": Struct(name="FockHamiltonianProblem")
 }
-FOCK_HAMILTONIAN_SIZE = "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
+FOCK_HAMILTONIAN_SIZE = "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
 
 FOCK_HAMILTONIAN_PROBLEM_PORT = {
     "qbv": PortDeclaration(

classiq/interface/generator/application_apis/finance_declarations.py

@@ -31,7 +31,7 @@ class FinanceModelType(Enum):
 
 
 FINANCE_FUNCTION_PORT_SIZE_MAPPING: Mapping[FinanceModelType, str] = {
-    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + len(get_field(finance_model, 'rhos')) + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
+    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + get_field(get_field(finance_model, 'rhos'), 'len') + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
     FinanceModelType.LogNormal: "get_field(finance_model, 'num_qubits')",
 }
 

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.arith.ast_node_rewrite import AstNodeRewrite
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 
 from classiq.exceptions import ClassiqArithmeticError, ClassiqValueError
 
@@ -174,6 +175,7 @@ class ExpressionValidator(ast.NodeVisitor):
         if not (
             isinstance(node.value, ast.Name)
             and node.value.id in self._supported_attr_values
+            or node.attr in CLASSICAL_ATTRIBUTES.keys()
         ):
             raise ClassiqValueError(
                 f"Attribute is not supported for value {node.value}"

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -0,0 +1,82 @@
+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)

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,12 @@ 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,
+            "len": self.size,
+        }

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/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')"
+            ),
         )
     },
 )