classiq 0.102.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

classiq/interface/generator/function_param_list.py

@@ -1,12 +1,15 @@
 import itertools
 
-from classiq.interface.generator.amplitude_loading import AmplitudeLoading
 from classiq.interface.generator.arith.arithmetic import Arithmetic
 from classiq.interface.generator.arith.binary_ops import (
     Adder,
     BitwiseAnd,
     BitwiseOr,
     BitwiseXor,
+    CanonicalAdder,
+    CanonicalConstantAdder,
+    CanonicalConstantMultiplier,
+    CanonicalMultiplier,
     Equal,
     GreaterEqual,
     GreaterThan,
@@ -58,6 +61,8 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             BitwiseXor,
             BitwiseInvert,
             Adder,
+            CanonicalAdder,
+            CanonicalConstantAdder,
             Arithmetic,
             Sign,
             Equal,
@@ -79,6 +84,8 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             HardwareEfficientAnsatz,
             UnitaryGate,
             Multiplier,
+            CanonicalMultiplier,
+            CanonicalConstantMultiplier,
             Power,
             Min,
             Max,
@@ -88,7 +95,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             Identity,
             RandomizedBenchmarking,
             UGate,
-            AmplitudeLoading,
             HadamardTransform,
             Copy,
             Reset,

classiq/interface/generator/function_params.py

@@ -46,7 +46,7 @@ END_BAD_REGISTER_ERROR_MSG = (
 )
 
 ALPHANUM_AND_UNDERSCORE = r"[0-9a-zA-Z_]*"
-NAME_REGEX = rf"_?[a-zA-Z]{ALPHANUM_AND_UNDERSCORE}"
+NAME_REGEX = rf"_{{0,2}}[a-zA-Z]{ALPHANUM_AND_UNDERSCORE}"
 
 _UNVALIDATED_FUNCTIONS = ["Arithmetic", "CustomFunction"]
 

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -1,7 +1,8 @@
 CTRL_VAR_PREFIX = "ctrl__"
 CONTROL_OPERATOR_NAME = "control"
 SKIP_CONTROL_OPERATOR_NAME = "skip_control"
-INVERT_OPERATOR_NAME = "invert"
+COMPOUND_INVERT_OPERATOR_NAME = "compound_invert"
+SINGLE_CALL_INVERT_OPERATOR_NAME = "single_call_invert"
 REPEAT_OPERATOR_NAME = "iteration"
 CLASSICAL_IF_OPERATOR_NAME = "classical_if"
 POWER_OPERATOR_NAME = "power"
@@ -9,12 +10,7 @@ UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"
 BLOCK_OPERATOR_NAME = "block"
 
-All_BUILTINS_OPERATORS = {
-    CONTROL_OPERATOR_NAME,
-    INVERT_OPERATOR_NAME,
-    REPEAT_OPERATOR_NAME,
-    POWER_OPERATOR_NAME,
-    UNCOMPUTE_OPERATOR_NAME,
-    WITHIN_APPLY_NAME,
-    BLOCK_OPERATOR_NAME,
+INVERT_OPERATOR_NAMES = {
+    COMPOUND_INVERT_OPERATOR_NAME,
+    SINGLE_CALL_INVERT_OPERATOR_NAME,
 }

classiq/interface/generator/functions/classical_type.py

@@ -61,6 +61,10 @@ class ClassicalType(HashableASTNode):
     def raw_qmod_type_name(self) -> str:
         return self.qmod_type_name
 
+    @property
+    def python_type_name(self) -> str:
+        raise NotImplementedError
+
     @property
     def expressions(self) -> list[Expression]:
         return []
@@ -76,6 +80,12 @@ class ClassicalType(HashableASTNode):
     def without_symbolic_attributes(self) -> Self:
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        return {}
+
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {}
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -89,6 +99,10 @@ class Integer(ClassicalType):
     def qmod_type_name(self) -> str:
         return "CInt"
 
+    @property
+    def python_type_name(self) -> str:
+        return "int"
+
 
 class Real(ClassicalType):
     kind: Literal["real"]
@@ -102,6 +116,10 @@ class Real(ClassicalType):
     def qmod_type_name(self) -> str:
         return "CReal"
 
+    @property
+    def python_type_name(self) -> str:
+        return "float"
+
 
 class Bool(ClassicalType):
     kind: Literal["bool"]
@@ -115,6 +133,10 @@ class Bool(ClassicalType):
     def qmod_type_name(self) -> str:
         return "CBool"
 
+    @property
+    def python_type_name(self) -> str:
+        return "bool"
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -201,6 +223,10 @@ class ClassicalArray(ClassicalType):
     def raw_qmod_type_name(self) -> str:
         return "CArray"
 
+    @property
+    def python_type_name(self) -> str:
+        return f"list[{self.element_type.python_type_name}]"
+
     def without_symbolic_attributes(self) -> "ClassicalArray":
         length = (
             None
@@ -213,6 +239,19 @@ class ClassicalArray(ClassicalType):
             element_type=self.element_type.without_symbolic_attributes(), length=length
         )
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_constant_length:
+            attrs[f"{path_expr_prefix}.len"] = self.length_value
+        return attrs | self.element_type.get_compile_time_attributes(
+            f"{path_expr_prefix}[0]"
+        )
+
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {
+            f"{prefix}.len": int
+        } | self.element_type.get_compile_time_attribute_types(f"{prefix}[0]")
+
 
 class ClassicalTuple(ClassicalType):
     kind: Literal["tuple"]
@@ -283,6 +322,13 @@ class ClassicalTuple(ClassicalType):
     def raw_qmod_type_name(self) -> str:
         return "CArray"
 
+    @property
+    def python_type_name(self) -> str:
+        raw_type = self.get_raw_type(preserve_length=True)
+        if isinstance(raw_type, ClassicalTuple):
+            return "list"
+        return raw_type.python_type_name
+
     def without_symbolic_attributes(self) -> "ClassicalTuple":
         return ClassicalTuple(
             element_types=[
@@ -291,6 +337,20 @@ class ClassicalTuple(ClassicalType):
             ]
         )
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        raw_type = self.get_raw_type(preserve_length=True)
+        attrs = {f"{path_expr_prefix}.len": len(self.element_types)}
+        if isinstance(raw_type, ClassicalTuple):
+            return attrs
+        return attrs | raw_type.get_compile_time_attributes(path_expr_prefix)
+
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        raw_type = self.get_raw_type(preserve_length=True)
+        attrs: dict[str, type] = {f"{prefix}.len": int}
+        if isinstance(raw_type, ClassicalTuple):
+            return attrs
+        return attrs | raw_type.get_compile_time_attribute_types(prefix)
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/type_name.py

@@ -60,6 +60,10 @@ class TypeName(ClassicalType, QuantumType):
     def qmod_type_name(self) -> str:
         return self.name
 
+    @property
+    def python_type_name(self) -> str:
+        return self.name
+
     @property
     def type_name(self) -> str:
         return self.name
@@ -202,6 +206,38 @@ class TypeName(ClassicalType, QuantumType):
             return type_name
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_fields:
+            for field_name, field_type in self.fields.items():
+                field_prefix = f"{path_expr_prefix}.{field_name}"
+                attrs |= field_type.get_compile_time_attributes(field_prefix)
+        elif self.has_classical_struct_decl:
+            for (
+                field_name,
+                classical_field_type,
+            ) in self.classical_struct_decl.variables.items():
+                field_prefix = f"{path_expr_prefix}.{field_name}"
+                attrs |= classical_field_type.get_compile_time_attributes(field_prefix)
+        return attrs
+
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        attrs: dict[str, type] = {}
+        if self.has_fields:
+            for field_name, field_type in self.fields.items():
+                field_prefix = f"{prefix}.{field_name}"
+                attrs |= field_type.get_compile_time_attribute_types(field_prefix)
+        elif self.has_classical_struct_decl:
+            for (
+                field_name,
+                classical_field_type,
+            ) in self.classical_struct_decl.variables.items():
+                field_prefix = f"{prefix}.{field_name}"
+                attrs |= classical_field_type.get_compile_time_attribute_types(
+                    field_prefix
+                )
+        return attrs
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -140,7 +140,6 @@ class StatementType(StrEnum):
     WITHIN = "within"
     APPLY = "apply"
     ASSIGN = "assign"
-    ASSIGN_AMPLITUDE = "assign amplitude"
     PHASE = "phase"
     INPLACE_XOR = "inplace xor"
     INPLACE_ADD = "inplace add"
@@ -163,7 +162,6 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     "Uncompute": StatementType.WITHIN,
     ArithmeticOperationKind.Assignment.value: StatementType.ASSIGN,
     "InplaceBinaryOperation": StatementType.ASSIGN,
-    "AmplitudeLoadingOperation": StatementType.ASSIGN_AMPLITUDE,
     "PhaseOperation": StatementType.PHASE,
     ArithmeticOperationKind.InplaceXor.value: StatementType.INPLACE_XOR,
     ArithmeticOperationKind.InplaceAdd.value: StatementType.INPLACE_ADD,

classiq/interface/generator/transpiler_basis_gates.py

@@ -59,6 +59,7 @@ EXTRA_TWO_QUBIT_GATES: BasisGates = frozenset(
         "cu",
         "ch",
         "cp",
+        "iswap",
     )
 )
 

classiq/interface/generator/types/compilation_metadata.py

@@ -5,6 +5,8 @@ class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
     occurrences_number: NonNegativeInt = Field(default=0)
     _occupation_number: NonNegativeInt = PrivateAttr(default=0)
+    _min_required_clean_qubit: NonNegativeInt = PrivateAttr(default=0)
+    _max_required_clean_qubit: NonNegativeInt = PrivateAttr(default=0)
     disable_perm_check: bool = Field(default=False)
     disable_const_checks: list[str] | bool = Field(default=False)
 
@@ -16,6 +18,22 @@ class CompilationMetadata(BaseModel):
     def occupation_number(self, value: NonNegativeInt) -> None:
         self._occupation_number = value
 
+    @property
+    def min_required_clean_qubit(self) -> NonNegativeInt:
+        return self._min_required_clean_qubit
+
+    @min_required_clean_qubit.setter
+    def min_required_clean_qubit(self, value: NonNegativeInt) -> None:
+        self._min_required_clean_qubit = value
+
+    @property
+    def max_required_clean_qubit(self) -> NonNegativeInt:
+        return self._max_required_clean_qubit
+
+    @max_required_clean_qubit.setter
+    def max_required_clean_qubit(self, value: NonNegativeInt) -> None:
+        self._max_required_clean_qubit = value
+
     @property
     def has_user_directives(self) -> bool:
         return bool(self.disable_perm_check or self.disable_const_checks)

classiq/interface/hardware.py

@@ -33,6 +33,8 @@ class Provider(StrEnum):
     INTEL = "Intel"
     AQT = "AQT"
     CINECA = "CINECA"
+    SOFTBANK = "Softbank"
+    C12 = "C12"
 
     @property
     def id(self) -> "ProviderIDEnum":

classiq/interface/helpers/model_normalizer.py

@@ -6,16 +6,31 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.visitor import Transformer, Visitor
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.port_declaration import AnonPortDeclaration
+from classiq.interface.model.port_declaration import (
+    PortDeclaration,
+)
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
 
 class ModelNormalizer(Visitor):
-    def __init__(self, normalize_names: bool = False) -> None:
-        self._normalize_names = normalize_names
+    def __init__(
+        self,
+        normalize_func_names: bool = False,
+        normalize_quantum_var_names: bool = False,
+    ) -> None:
+        self._normalize_func_names = normalize_func_names
+        self._normalize_quantum_var_names = normalize_quantum_var_names
         self._funcs_renames: dict[str, str] = {}
+        self._count_name = CountedNameAllocator()
+        self.original_names: dict[str, str] = {}
 
     def visit(self, node: Any) -> None:
         if isinstance(node, ASTNode):
@@ -35,12 +50,12 @@ class ModelNormalizer(Visitor):
         self.generic_visit(model)
 
     def visit_NativeFunctionDefinition(self, func: NativeFunctionDefinition) -> None:
-        if self._normalize_names:
+        if self._normalize_func_names:
             func.name = self._funcs_renames[func.name]
         self.generic_visit(func)
 
     def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
-        if self._normalize_names:
+        if self._normalize_func_names:
             if isinstance(call.function, str):
                 if call.function in self._funcs_renames:
                     call.function = self._funcs_renames[call.function]
@@ -49,8 +64,29 @@ class ModelNormalizer(Visitor):
                     call.function.name = self._funcs_renames[call.function.name]
         self.generic_visit(call)
 
-    def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
+    def visit_PortDeclaration(self, decl: PortDeclaration) -> None:
         decl.type_modifier = TypeModifier.Mutable
+        self._rename_quantum_var(decl, "_port")
+
+    def visit_VariableDeclarationStatement(
+        self, var: VariableDeclarationStatement
+    ) -> None:
+        self._rename_quantum_var(var, "_var")
+
+    def _rename_quantum_var(
+        self, var: VariableDeclarationStatement | PortDeclaration, new_name_prefix: str
+    ) -> None:
+        if self._normalize_quantum_var_names:
+            old_name = var.name
+            var.name = self._count_name.allocate(new_name_prefix)
+            self.original_names[old_name] = var.name
+
+    def visit_HandleBinding(self, handle: HandleBinding) -> None:
+        if self._normalize_quantum_var_names:
+            # this is a hack use just for testing, do not use in production
+            object.__setattr__(
+                handle, "name", self.original_names.get(handle.name, handle.name)
+            )
 
 
 class ClearModelInternals(Transformer):

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "15"
+INTERFACE_VERSION = "17"

classiq/interface/model/invert.py

@@ -2,6 +2,8 @@ from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -25,3 +27,9 @@ class Invert(QuantumOperation):
     @property
     def blocks(self) -> dict[str, "StatementBlock"]:
         return {"body": self.body}
+
+    def validate_node(self) -> None:
+        if self.block_kind == BlockKind.SingleCall and (
+            len(self.body) != 1 or not isinstance(self.body[0], QuantumFunctionCall)
+        ):
+            raise ClassiqInternalExpansionError("Malformed single-call invert")

classiq/interface/model/model.py

@@ -10,6 +10,7 @@ from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.function_params import ArithmeticIODict
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -28,6 +29,10 @@ from classiq.interface.model.native_function_definition import (
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
+from classiq.interface.model.quantum_type import (
+    RegisterQuantumTypeDict,
+    quantum_type_to_register_quantum_type,
+)
 from classiq.interface.model.statement_block import StatementBlock
 
 USER_MODEL_MARKER = "user"
@@ -237,3 +242,17 @@ class Model(VersionedModel, ASTNode):
             self.compressed_debug_info = None
         else:
             self.compressed_debug_info = compress_pydantic(self._debug_info)
+
+    @property
+    def measured_registers(self) -> ArithmeticIODict:
+        return self.main_func.outputs_dict
+
+    @property
+    def measured_registers_type(self) -> RegisterQuantumTypeDict:
+        return {
+            key: quantum_type_to_register_quantum_type(
+                self.main_func.port_declarations_dict[key].quantum_type,
+                self.main_func.port_declarations_dict[key].quantum_type.size_in_bits,
+            )
+            for key in self.measured_registers.keys()
+        }

classiq/interface/model/model_visitor.py

@@ -10,8 +10,10 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 
 
 class ModelVisitor(Visitor):
-    def visit_DebugInfoCollection(self, debug_info: DebugInfoCollection) -> None:
-        return
+    def visit_DebugInfoCollection(
+        self, debug_info: DebugInfoCollection
+    ) -> RetType | None:
+        return None
 
 
 class ModelStatementsVisitor(ModelVisitor):

classiq/interface/model/quantum_type.py

@@ -78,6 +78,12 @@ class QuantumType(HashableASTNode):
     def without_symbolic_attributes(self) -> Self:
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        return {}
+
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {}
+
 
 class QuantumScalar(QuantumType):
     @property
@@ -262,6 +268,19 @@ class QuantumBitvector(QuantumType):
             length = 1
         return length * self.element_type.minimal_size_in_bits
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_constant_length:
+            attrs[f"{path_expr_prefix}.len"] = self.length_value
+        return attrs | self.element_type.get_compile_time_attributes(
+            f"{path_expr_prefix}[0]"
+        )
+
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {
+            f"{prefix}.len": int
+        } | self.element_type.get_compile_time_attribute_types(f"{prefix}[0]")
+
     def without_symbolic_attributes(self) -> "QuantumBitvector":
         length = (
             None
@@ -301,6 +320,23 @@ class QuantumNumeric(QuantumScalar):
             )
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_size_in_bits:
+            attrs[f"{path_expr_prefix}.size"] = self.size_in_bits
+        if self.has_constant_sign:
+            attrs[f"{path_expr_prefix}.is_signed"] = self.sign_value
+        if self.has_constant_fraction_digits:
+            attrs[f"{path_expr_prefix}.fraction_digits"] = self.fraction_digits_value
+        return attrs
+
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {
+            f"{prefix}.size": int,
+            f"{prefix}.is_signed": bool,
+            f"{prefix}.fraction_digits": int,
+        }
+
     def set_size_in_bits(self, val: int) -> None:
         super().set_size_in_bits(val)
         if self.size is not None:

classiq/interface/model/statement_block.py

@@ -13,9 +13,6 @@ from classiq.interface.model.invert import Invert
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
@@ -38,7 +35,6 @@ ConcreteQuantumStatement = Annotated[
         QuantumFunctionCall,
         Allocate,
         ArithmeticOperation,
-        AmplitudeLoadingOperation,
         VariableDeclarationStatement,
         BindOperation,
         InplaceBinaryOperation,

classiq/interface/qubits_mapping/__init__.py

@@ -0,0 +1,4 @@
+from .qubits_mapping import FunctionScope, QubitsMapping
+from .slices import Slices
+
+__all__ = ["FunctionScope", "QubitsMapping", "Slices"]

classiq/interface/qubits_mapping/path_expr_range.py

@@ -0,0 +1,69 @@
+from functools import singledispatch
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_type import QuantumBitvector
+
+
+def get_path_expr_range(
+    var: HandleBinding, quantum_type: ConcreteQuantumType
+) -> tuple[int, int]:
+    start = 0
+    stop = quantum_type.size_in_bits
+    for var_prefix in var.prefixes()[1:]:
+        start, stop, quantum_type = _pop_var_range(var_prefix, quantum_type, start)
+    return start, stop
+
+
+@singledispatch
+def _pop_var_range(
+    var_prefix: HandleBinding, quantum_type: ConcreteQuantumType, start: int
+) -> tuple[int, int, ConcreteQuantumType]:
+    raise ClassiqInternalExpansionError("Unexpected path expression")
+
+
+@_pop_var_range.register
+def _(
+    var_prefix: SubscriptHandleBinding, quantum_type: ConcreteQuantumType, start: int
+) -> tuple[int, int, ConcreteQuantumType]:
+    if not isinstance(quantum_type, QuantumBitvector):
+        raise ClassiqInternalExpansionError("Unexpected path expression")
+    index = var_prefix.index.to_int_value()
+    element_type = quantum_type.element_type
+    start += element_type.size_in_bits * index
+    stop = start + element_type.size_in_bits
+    return start, stop, element_type
+
+
+@_pop_var_range.register
+def _(
+    var_prefix: SlicedHandleBinding, quantum_type: ConcreteQuantumType, start: int
+) -> tuple[int, int, ConcreteQuantumType]:
+    if not isinstance(quantum_type, QuantumBitvector):
+        raise ClassiqInternalExpansionError("Unexpected path expression")
+    slice_start = var_prefix.start.to_int_value()
+    slice_stop = var_prefix.end.to_int_value()
+    stop = start + quantum_type.element_type.size_in_bits * slice_stop
+    start += quantum_type.element_type.size_in_bits * slice_start
+    return start, stop, quantum_type
+
+
+@_pop_var_range.register
+def _(
+    var_prefix: FieldHandleBinding, quantum_type: ConcreteQuantumType, start: int
+) -> tuple[int, int, ConcreteQuantumType]:
+    if not isinstance(quantum_type, TypeName) or not quantum_type.has_fields:
+        raise ClassiqInternalExpansionError("Unexpected path expression")
+    for field, field_type in quantum_type.fields.items():
+        if field == var_prefix.field:
+            stop = start + field_type.size_in_bits
+            return start, stop, field_type
+        start += field_type.size_in_bits
+    raise ClassiqInternalExpansionError("Unexpected path expression")