classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/generator/model/preferences/preferences.py

@@ -1,17 +1,24 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from collections.abc import Sequence
+from enum import IntEnum
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
 
 import pydantic
-from typing_extensions import TypeAlias
+from pydantic import Field
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self, TypeAlias
 
 from classiq.interface.backend.backend_preferences import (
     BackendPreferences,
-    validate_backend_service_provider,
 )
 from classiq.interface.backend.quantum_backend_providers import (
     AllBackendsNameByVendor,
     ProviderVendor,
 )
-from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
 from classiq.interface.generator.hardware.hardware_data import (
     BACKEND_VALIDATION_ERROR_MESSAGE,
     CustomHardwareSettings,
@@ -20,19 +27,17 @@ from classiq.interface.generator.model.preferences.randomness import create_rand
 from classiq.interface.hardware import Provider
 from classiq.interface.helpers.custom_pydantic_types import PydanticMachinePrecision
 
-from classiq._internals.enum_utils import StrEnum
-
 if TYPE_CHECKING:
     VisualizationLevel: TypeAlias = Optional[int]
 else:
-    VisualizationLevel: TypeAlias = Optional[pydantic.conint(ge=-1)]
+    VisualizationLevel: TypeAlias = Optional[Annotated[int, Field(ge=-1)]]
 
 if TYPE_CHECKING:
     PydanticBackendName = str
 else:
-    PydanticBackendName = pydantic.constr(
-        strict=True, min_length=1, regex="^([.A-Za-z0-9_-]*)$"
-    )
+    PydanticBackendName = Annotated[
+        str, Field(strict=True, min_length=1, pattern="^([.A-Za-z0-9_-]*)$")
+    ]
 
 
 class QuantumFormat(StrEnum):
@@ -44,7 +49,7 @@ class QuantumFormat(StrEnum):
     QASM_CIRQ_COMPATIBLE = "qasm_cirq_compatible"
 
 
-_SERVICE_PROVIDER_TO_FORMAT: Dict[Provider, QuantumFormat] = {
+_SERVICE_PROVIDER_TO_FORMAT: dict[Provider, QuantumFormat] = {
     Provider.CLASSIQ: QuantumFormat.QASM,
     Provider.IONQ: QuantumFormat.IONQ,
     Provider.AZURE_QUANTUM: QuantumFormat.QSHARP,
@@ -53,11 +58,18 @@ _SERVICE_PROVIDER_TO_FORMAT: Dict[Provider, QuantumFormat] = {
 }
 
 if TYPE_CHECKING:
-    PydanticConstrainedQuantumFormatList = List[QuantumFormat]
+    PydanticConstrainedQuantumFormatList = list[QuantumFormat]
 else:
-    PydanticConstrainedQuantumFormatList = pydantic.conlist(
-        QuantumFormat, min_items=1, max_items=len(QuantumFormat)
-    )
+    PydanticConstrainedQuantumFormatList = Annotated[
+        list[QuantumFormat], Field(min_length=1, max_length=len(QuantumFormat))
+    ]
+
+
+class OptimizationLevel(IntEnum):
+    NONE = 0
+    LIGHT = 1
+    MEDIUM = 2
+    HIGH = 3
 
 
 class TranspilationOption(StrEnum):
@@ -73,11 +85,60 @@ class TranspilationOption(StrEnum):
         return self != TranspilationOption.NONE
 
 
-class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
+class Preferences(pydantic.BaseModel, extra="forbid"):
+    """
+    Preferences for synthesizing a quantum circuit.
+
+    Attributes:
+        machine_precision (int): Specifies the precision used for quantum operations.
+            Defaults to `DEFAULT_MACHINE_PRECISION`.
+        backend_service_provider (str): The provider company or cloud service for the
+            requested backend. Defaults to `None`.
+        backend_name (str): The name of the requested backend or target. Defaults to `None`.
+        custom_hardware_settings (CustomHardwareSettings): Defines custom hardware
+            settings for optimization. This field is ignored if backend preferences are
+            specified.
+        debug_mode (bool): If `True`, debug information is added to the
+            synthesized result, potentially slowing down the synthesis. Useful for
+            executing interactive algorithms. Defaults to `True`.
+        output_format (List[QuantumFormat]): Lists the output format(s)
+            for the quantum circuit. Defaults to `[QuantumFormat.QASM]`.
+            `QuantumFormat` Options:
+                - QASM = "qasm"
+                - QSHARP = "qsharp"
+                - QIR = "qir"
+                - IONQ = "ionq"
+                - CIRQ_JSON = "cirq_json"
+                - QASM_CIRQ_COMPATIBLE = "qasm_cirq_compatible"
+        pretty_qasm (bool): If `True`, formats OpenQASM 2 outputs with line breaks
+            inside gate declarations, improving readability. Defaults to `True`.
+        qasm3 (Optional[bool]): If `True`, outputs OpenQASM 3.0 in addition to 2.0,
+            applicable to relevant attributes in `GeneratedCircuit`. Defaults to `None`.
+        transpilation_option (TranspilationOption): Sets the transpilation option to
+            optimize the circuit. Defaults to `AUTO_OPTIMIZE`. See `TranspilationOption`
+        solovay_kitaev_max_iterations (Optional[int]): Specifies the
+            maximum number of iterations for the Solovay-Kitaev algorithm, if used.
+            Defaults to `None`.
+        timeout_seconds (int): Timeout setting for circuit synthesis
+            in seconds. Defaults to `300`.
+        optimization_timeout_seconds (Optional[int]): Specifies the
+            timeout for optimization in seconds, or `None` for no optimization timeout.
+            This will still adhere to the overall synthesis timeout. Defaults to `None`.
+        random_seed (int): Random seed for circuit synthesis.
+
+    Raises:
+        ClassiqValueError:
+            - If the optimization timeout is greater than or equal to the synthesis timeout.
+            - If the `output_format` contains duplicate entries.
+            - If `backend_name` is provided without `backend_service_provider` or vice versa.
+        ValueError:
+            - If `backend_service_provider` is not valid.
+    """
+
     _backend_preferences: Optional[BackendPreferences] = pydantic.PrivateAttr(
         default=None
     )
-    machine_precision: PydanticMachinePrecision = MAXIMAL_MACHINE_PRECISION
+    machine_precision: PydanticMachinePrecision = DEFAULT_MACHINE_PRECISION
 
     backend_service_provider: Optional[Union[Provider, ProviderVendor, str]] = (
         pydantic.Field(
@@ -101,6 +162,15 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         "Setting this option to False can potentially speed up the synthesis, and is "
         "recommended for executing iterative algorithms.",
     )
+    synthesize_all_separately: bool = pydantic.Field(
+        default=False,
+        description="If true, a heuristic is used to determine if a function should be synthesized separately",
+        deprecated=True,
+    )
+    optimization_level: OptimizationLevel = pydantic.Field(
+        default=OptimizationLevel.HIGH,
+        description="The optimization level used during synthesis; determines the trade-off between synthesis speed and the quality of the results",
+    )
     output_format: PydanticConstrainedQuantumFormatList = pydantic.Field(
         default=[QuantumFormat.QASM],
         description="The quantum circuit output format(s). ",
@@ -124,6 +194,11 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         "transpiled circuit and its depth",
     )
 
+    solovay_kitaev_max_iterations: Optional[pydantic.PositiveInt] = pydantic.Field(
+        None,
+        description="Maximum iterations for the Solovay-Kitaev algorithm (if applied).",
+    )
+
     timeout_seconds: pydantic.PositiveInt = pydantic.Field(
         default=300, description="Generation timeout in seconds"
     )
@@ -133,55 +208,51 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         description="Optimization timeout in seconds, or None for no "
         "optimization timeout (will still timeout when the generation timeout is over)",
     )
-
     random_seed: int = pydantic.Field(
         default_factory=create_random_seed,
         description="The random seed used for the generation",
     )
 
-    @pydantic.validator("backend_service_provider", pre=True)
-    def validate_backend_service_provider(
-        cls, backend_service_provider: Any
-    ) -> Optional[Provider]:
-        if backend_service_provider is None:
-            return None
-        return validate_backend_service_provider(backend_service_provider)
-
-    @pydantic.validator("optimization_timeout_seconds")
+    @pydantic.field_validator("optimization_timeout_seconds", mode="before")
+    @classmethod
     def optimization_timeout_less_than_generation_timeout(
         cls,
         optimization_timeout_seconds: Optional[pydantic.PositiveInt],
-        values: Dict[str, Any],
+        info: ValidationInfo,
     ) -> Optional[pydantic.PositiveInt]:
-        generation_timeout_seconds = values.get("timeout_seconds")
+        generation_timeout_seconds = info.data.get("timeout_seconds")
         if generation_timeout_seconds is None or optimization_timeout_seconds is None:
             return optimization_timeout_seconds
         if optimization_timeout_seconds >= generation_timeout_seconds:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Generation timeout ({generation_timeout_seconds})"
                 f"is greater than or equal to "
                 f"optimization timeout ({optimization_timeout_seconds}) "
             )
         return optimization_timeout_seconds
 
-    @pydantic.validator("output_format", pre=True)
-    def make_output_format_list(cls, output_format: Any) -> List:
-        if not pydantic.utils.sequence_like(output_format):
+    @pydantic.field_validator("output_format", mode="before")
+    @classmethod
+    def make_output_format_list(cls, output_format: Any) -> list:
+        if not isinstance(output_format, Sequence) or isinstance(output_format, str):
             output_format = [output_format]
 
         return output_format
 
-    @pydantic.validator("output_format", always=True)
+    @pydantic.field_validator("output_format", mode="before")
+    @classmethod
     def validate_output_format(
-        cls, output_format: PydanticConstrainedQuantumFormatList, values: Dict[str, Any]
+        cls,
+        output_format: PydanticConstrainedQuantumFormatList,
+        info: ValidationInfo,
     ) -> PydanticConstrainedQuantumFormatList:
         if len(output_format) != len(set(output_format)):
-            raise ValueError(
+            raise ClassiqValueError(
                 f"output_format={output_format}\n"
                 "has at least one format that appears twice or more"
             )
 
-        service_provider = values.get("backend_service_provider")
+        service_provider = info.data.get("backend_service_provider")
         if service_provider is None:
             return output_format
 
@@ -191,16 +262,20 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
 
         return output_format
 
-    @pydantic.root_validator()
-    def validate_backend(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        backend_name = values.get("backend_name")
-        backend_service_provider = values.get("backend_service_provider")
+    @pydantic.model_validator(mode="after")
+    def validate_backend(self) -> Self:
+        backend_name = self.backend_name
+        backend_service_provider = self.backend_service_provider
         if (backend_name is None) != (backend_service_provider is None):
-            raise ValueError(BACKEND_VALIDATION_ERROR_MESSAGE)
-        return values
+            raise ClassiqValueError(BACKEND_VALIDATION_ERROR_MESSAGE)
+        return self
 
     @property
     def backend_preferences(self) -> Optional[BackendPreferences]:
+        """
+        Returns the backend preferences. If the backend preferences are not provided, the function sets the backend preferences according to backend name and provider.
+
+        """
         if self.backend_name is None or self.backend_service_provider is None:
             return None
         if self._backend_preferences is None:

classiq/{quantum_register.py → interface/generator/model/quantum_register.py}

@@ -1,8 +1,15 @@
 import itertools
 import sys
-from typing import _GenericAlias  # type: ignore[attr-defined]
-from typing import Any, Dict, List, Optional, Type, Union
+from collections.abc import Iterator
+from types import GenericAlias as TypesGenericAlias
+from typing import (  # type: ignore[attr-defined]
+    Any,
+    Optional,
+    Union,
+    _GenericAlias,
+)
 
+from classiq.interface.exceptions import ClassiqQRegError
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
     RegisterUserInput,
@@ -10,16 +17,11 @@ from classiq.interface.generator.arith.register_user_input import (
 from classiq.interface.generator.function_params import ArithmeticIODict, IOName
 from classiq.interface.generator.register_role import RegisterRole
 
-from classiq.exceptions import ClassiqQRegError
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias as TypesGenericAlias
-
 
 # This class is used for QReg, to support type-hint initialization
 #   Due to the `size` property of QReg
 class QRegGenericAlias(_GenericAlias, _root=True):  # type: ignore[call-arg]
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         arith_info = {}
         if self.size is not None:
             arith_info["size"] = self.size
@@ -48,13 +50,13 @@ class QRegGenericAlias(_GenericAlias, _root=True):  # type: ignore[call-arg]
 
     @property
     def integer_places(self) -> Optional[int]:
-        if len(self.__args__) in (1, 2) and type(self.__args__[0]) is int:
+        if len(self.__args__) in (1, 2) and isinstance(self.__args__[0], int):
             return self.__args__[0]
         return None
 
     @property
     def fraction_places(self) -> Optional[int]:
-        if len(self.__args__) == 2 and type(self.__args__[1]) is int:
+        if len(self.__args__) == 2 and isinstance(self.__args__[1], int):
             return self.__args__[1]
         return None
 
@@ -73,14 +75,17 @@ class QReg:
         """Initializes a new QReg with the specified number of qubits.
 
         Args:
-            size (int): The number of qubits in the QReg.
+            size: The number of qubits in the QReg.
         """
         if size <= 0:
             raise ClassiqQRegError(f"Cannot create {size} new qubits")
         self._qubits = [Qubit() for _ in range(size)]
 
+    def __hash__(self) -> int:
+        return super.__hash__(self)
+
     @classmethod
-    def _from_qubits(cls, qubits: List[Qubit]) -> "QReg":
+    def _from_qubits(cls, qubits: list[Qubit]) -> "QReg":
         if (
             not isinstance(qubits, list)
             or not all(isinstance(qubit, Qubit) for qubit in qubits)
@@ -102,7 +107,7 @@ class QReg:
             )
         self._qubits[key] = value._qubits[0] if isinstance(key, int) else value._qubits  # type: ignore[call-overload]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator["QReg"]:
         return iter([self[idx] for idx in range(len(self))])
 
     def __eq__(self, other: Any) -> bool:
@@ -131,12 +136,12 @@ class QReg:
         return len(self._qubits)
 
     @property
-    def qubits(self) -> List[Qubit]:
+    def qubits(self) -> list[Qubit]:
         return self._qubits
 
     def __class_getitem__(cls, params: Any) -> QRegGenericAlias:
         # Supporting python 3.7+, thus returning `typing._GenericAlias` instead of `types.GenericAlias`
-        if type(params) is int:
+        if isinstance(params, int):
             return QRegGenericAlias(cls, params)
 
         raise ClassiqQRegError(f"Invalid size: {params} ; int required")
@@ -171,8 +176,8 @@ class QSFixed(QReg):
         if (
             type(params) is tuple
             and len(params) == 2
-            and type(params[0]) is int
-            and type(params[1]) is int
+            and isinstance(params[0], int)
+            and isinstance(params[1], int)
         ):
             return QRegGenericAlias(cls, params)
 
@@ -221,7 +226,7 @@ _PROP_TO_QREG_TYPE = {
 }
 
 
-def _get_qreg_type_from_arithmetic_info(info: RegisterArithmeticInfo) -> Type["QReg"]:
+def _get_qreg_type_from_arithmetic_info(info: RegisterArithmeticInfo) -> type["QReg"]:
     return _PROP_TO_QREG_TYPE[(info.is_signed, info.is_frac)]
 
 
@@ -237,7 +242,7 @@ def _get_qreg_generic_alias_from_arithmetic_info(
 
 def get_type_and_size_dict(
     arithmetic_info_dict: ArithmeticIODict,
-) -> Dict[IOName, QRegGenericAlias]:
+) -> dict[IOName, QRegGenericAlias]:
     return {
         io_name: _get_qreg_generic_alias_from_arithmetic_info(info)
         for io_name, info in arithmetic_info_dict.items()
@@ -245,11 +250,11 @@ def get_type_and_size_dict(
 
 
 __all__ = [
+    "AuxQReg",
     "QReg",
-    "QSInt",
-    "QUInt",
     "QSFixed",
+    "QSInt",
     "QUFixed",
+    "QUInt",
     "ZeroQReg",
-    "AuxQReg",
 ]

classiq/interface/generator/oracles/arithmetic_oracle.py

@@ -1,9 +1,9 @@
 import ast
 import re
-from typing import Dict
 
 import numexpr  # type: ignore[import]
 
+from classiq.interface.exceptions import ClassiqArithmeticError, ClassiqValueError
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.arithmetic import Arithmetic
 from classiq.interface.generator.arith.arithmetic_expression_abc import (
@@ -17,8 +17,6 @@ from classiq.interface.generator.oracles.oracle_abc import (
     VariableTypedResultMap,
 )
 
-from classiq.exceptions import ClassiqArithmeticError, ClassiqValueError
-
 
 class ArithmeticOracle(OracleABC[float], ArithmeticExpressionABC):
     @staticmethod
@@ -62,7 +60,7 @@ class ArithmeticOracle(OracleABC[float], ArithmeticExpressionABC):
 
     @staticmethod
     def _simplify_negations_of_boolean_variables(
-        expression: str, input_definitions: Dict[str, RegisterArithmeticInfo]
+        expression: str, input_definitions: dict[str, RegisterArithmeticInfo]
     ) -> str:
         for var_name in input_definitions:
             if getattr(input_definitions[var_name], "size", 0) == 1:

classiq/interface/generator/oracles/custom_oracle.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict
+from typing import Any
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import parse_function_params_values
 from classiq.interface.generator.oracles.oracle_abc import (
     ArithmeticIODict,
@@ -21,30 +22,33 @@ class CustomOracle(OracleABC[QubitState]):
         default_factory=CustomFunction,
     )
 
-    @pydantic.root_validator(pre=True)
-    def _parse_oracle(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        parse_function_params_values(
-            values=values,
-            params_key="custom_oracle_params",
-            discriminator_key="custom_oracle",
-            param_classes={CustomFunction},
-            default_parser_class=CustomFunction,
-        )
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _parse_oracle(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            parse_function_params_values(
+                values=values,
+                params_key="custom_oracle_params",
+                discriminator_key="custom_oracle",
+                param_classes={CustomFunction},
+                default_parser_class=CustomFunction,
+            )
         return values
 
-    @pydantic.validator("custom_oracle_params")
+    @pydantic.field_validator("custom_oracle_params")
+    @classmethod
     def _validate_names_match_oracle(
         cls, custom_oracle_params: CustomFunction
     ) -> CustomFunction:
         if set(custom_oracle_params.input_decls.keys()) != set(
             custom_oracle_params.output_decls.keys()
         ):
-            raise ValueError("Oracle IO names must be identical")
+            raise ClassiqValueError("Oracle IO names must be identical")
         if any(
             custom_oracle_params.output_decls[name].size != input_decl.size
             for name, input_decl in custom_oracle_params.input_decls.items()
         ):
-            raise ValueError("Oracle IO sizes must be identical")
+            raise ClassiqValueError("Oracle IO sizes must be identical")
         return custom_oracle_params
 
     def _get_register_transputs(self) -> ArithmeticIODict:

classiq/interface/generator/oracles/oracle_abc.py

@@ -1,19 +1,19 @@
 import abc
-from typing import Dict, Generic, List, Optional, Sequence, TypeVar
+from collections.abc import Sequence
+from typing import Generic, Optional, TypeVar
 
 import numpy as np
 
+from classiq.interface.exceptions import ClassiqOracleError
 from classiq.interface.executor.result import State
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import ArithmeticIODict, FunctionParams
 from classiq.interface.generator.generated_circuit_data import IOQubitMapping
 
-from classiq.exceptions import ClassiqOracleError
-
 ProblemResultType = TypeVar("ProblemResultType")
 
-VariableBinResultMap = Dict[str, State]
-VariableTypedResultMap = Dict[str, ProblemResultType]
+VariableBinResultMap = dict[str, State]
+VariableTypedResultMap = dict[str, ProblemResultType]
 
 
 class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
@@ -59,11 +59,11 @@ class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
     ) -> bool:
         pass
 
-    def variables(self) -> List[RegisterUserInput]:
-        return list(
+    def variables(self) -> list[RegisterUserInput]:
+        return [
             RegisterUserInput.from_arithmetic_info(info=info, name=name)
             for name, info in self._inputs.items()
-        )
+        ]
 
     def _check_indices(self, indices: IOQubitMapping) -> None:
         if set(indices.keys()) != {reg.name for reg in self.variables()}:
@@ -72,5 +72,5 @@ class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
             )
 
 
-def _reverse_endianness(indices: Sequence[int], state_length: int) -> List[int]:
+def _reverse_endianness(indices: Sequence[int], state_length: int) -> list[int]:
     return [state_length - 1 - index for index in indices]

classiq/interface/generator/partitioned_register.py

@@ -1,11 +1,11 @@
 import itertools
+from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import Iterator, List, Optional, Tuple
+from typing import Optional
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.slice_parsing_utils import parse_io_slicing
 
-from classiq.exceptions import ClassiqValueError
-
 
 @dataclass(frozen=True)
 class PartitionedRegister:
@@ -13,7 +13,7 @@ class PartitionedRegister:
 
     # There are up to num_qubits qubits within the partitions, with unique values from 0 to num_qubits-1
     num_qubits: int
-    partitions: Tuple[Tuple[int, ...], ...]
+    partitions: tuple[tuple[int, ...], ...]
 
     def __post_init__(self) -> None:
         if not self.partitions:
@@ -48,7 +48,7 @@ class PartitionedRegister:
         return RegisterPartition(self, _index=None)
 
     @property
-    def _leftover_qubits(self) -> Tuple[int, ...]:
+    def _leftover_qubits(self) -> tuple[int, ...]:
         total_qubits = set(itertools.chain.from_iterable(self.partitions))
         return tuple(
             qubit for qubit in range(self.num_qubits) if qubit not in total_qubits
@@ -60,7 +60,7 @@ class PartitionedRegister:
 
     def all_register_partitions(
         self, include_leftover_partition: bool = False
-    ) -> List["RegisterPartition"]:
+    ) -> list["RegisterPartition"]:
         all_partitions = [self.get_partition(i) for i in range(len(self.partitions))]
         if include_leftover_partition:
             all_partitions.append(self.leftover_partition)
@@ -83,7 +83,7 @@ class RegisterPartition:
             raise ClassiqValueError(message)
 
     @property
-    def qubits(self) -> Tuple[int, ...]:
+    def qubits(self) -> tuple[int, ...]:
         if self._index is None:
             return self.partitioned_register._leftover_qubits
         return self.partitioned_register.partitions[self._index]