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

classiq/execution/functions/sample.py

@@ -0,0 +1,257 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
+from classiq.interface.backend.backend_preferences import (
+    AliceBobBackendPreferences,
+    AQTBackendPreferences,
+    AwsBackendPreferences,
+    AzureBackendPreferences,
+    AzureCredential,
+    BackendPreferencesTypes,
+    ClassiqBackendPreferences,
+    GCPBackendPreferences,
+    IBMBackendPreferences,
+    IntelBackendPreferences,
+    IonqBackendPreferences,
+)
+from classiq.interface.backend.provider_config.provider_config import ProviderConfig
+from classiq.interface.backend.provider_config.providers.alice_bob import AliceBobConfig
+from classiq.interface.backend.provider_config.providers.aqt import AQTConfig
+from classiq.interface.backend.provider_config.providers.azure import AzureConfig
+from classiq.interface.backend.provider_config.providers.braket import BraketConfig
+from classiq.interface.backend.provider_config.providers.ibm import IBMConfig
+from classiq.interface.backend.provider_config.providers.ionq import IonQConfig
+from classiq.interface.backend.quantum_backend_providers import (
+    ClassiqNvidiaBackendNames,
+    ClassiqSimulatorBackendNames,
+)
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.generator.model.preferences import create_random_seed
+from classiq.interface.generator.model.preferences.preferences import (
+    TranspilationOption,
+)
+from classiq.interface.hardware import Provider
+
+from classiq import (
+    ExecutionParams,
+    QuantumProgram,
+)
+from classiq.execution import ExecutionSession
+from classiq.execution.functions._logging import _logger
+from classiq.execution.functions.constants import Verbosity
+from classiq.execution.functions.parse_provider_backend import (
+    _PROVIDER_TO_CANONICAL_NAME,
+    _parse_provider_backend,
+)
+
+
+@dataclass
+class _ProviderConfigToBackendPrefSpec:
+    backend_preferences_class: type[BackendPreferencesTypes]
+    config_class: type[ProviderConfig] | None = None
+    # Maps the config dict (either passed in directly or dumped from config class) to a
+    # dict that we can load into the given BackendPreferences class. This is in case
+    # we need to rename fields or change structure.
+    config_dict_to_backend_preferences_dict: (
+        Callable[[dict[str, Any]], dict[str, Any]] | None
+    ) = None
+    # Maps from SDK names to names our backend recognizes, raising a useful error
+    # if the name is unrecognized.
+    backend_name_mapper: Callable[[str], str] | None = None
+
+
+def _classiq_backend_name_mapper(backend_name: str) -> str:
+    backend_name = backend_name.lower()
+    if backend_name in [
+        ClassiqSimulatorBackendNames.SIMULATOR,
+        ClassiqSimulatorBackendNames.SIMULATOR_MATRIX_PRODUCT_STATE,
+        ClassiqSimulatorBackendNames.SIMULATOR_DENSITY_MATRIX,
+    ]:
+        return backend_name
+    if backend_name == "nvidia_simulator":
+        return ClassiqNvidiaBackendNames.SIMULATOR
+    if any(keyword in backend_name for keyword in ["gpu", "nvidia"]):
+        suggested_backend_name = "nvidia_simulator"
+    else:
+        suggested_backend_name = "simulator"
+    raise ValueError(
+        f"Unsupported backend name {backend_name}. Did you mean '{suggested_backend_name}'?"
+    )
+
+
+def _ibm_backend_name_mapper(backend_name: str) -> str:
+    ibm_prefix: Literal["ibm_"] = "ibm_"
+    backend_name = backend_name.lower()
+    if backend_name.startswith(ibm_prefix):
+        backend_name_no_prefix = backend_name.removeprefix(ibm_prefix)
+        raise ValueError(
+            f"IBM backend names shouldn't start with ibm_. Try 'ibm/{backend_name_no_prefix}'."
+        )
+    return ibm_prefix + backend_name
+
+
+def _azure_config_dict_to_backend_preferences_dict(
+    config_dict: dict[str, Any],
+) -> dict[str, Any]:
+    if "location" not in config_dict:
+        raise ValueError("Azure config must have 'location' property")
+    credentials = None
+    if all(
+        config_dict.get(key) is not None
+        for key in ["tenant_id", "client_id", "client_secret", "resource_id"]
+    ):
+        credentials = AzureCredential.model_validate(
+            {
+                "tenant_id": config_dict["tenant_id"],
+                "client_id": config_dict["client_id"],
+                "client_secret": config_dict["client_secret"],
+                "resource_id": config_dict["resource_id"],
+            }
+        )
+    return {
+        "location": config_dict["location"],
+        "credentials": credentials,
+        "ionq_error_mitigation_flag": config_dict.get("ionq_error_mitigation"),
+    }
+
+
+def _braket_config_dict_to_backend_preferences_dict(
+    config_dict: dict[str, Any],
+) -> dict[str, Any]:
+    config_dict["aws_access_key_id"] = config_dict.pop("braket_access_key_id", None)
+    config_dict["aws_secret_access_key"] = config_dict.pop(
+        "braket_secret_access_key", None
+    )
+    return config_dict
+
+
+_PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC = {
+    Provider.CLASSIQ: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=ClassiqBackendPreferences,
+        backend_name_mapper=_classiq_backend_name_mapper,
+    ),
+    Provider.GOOGLE: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=GCPBackendPreferences
+    ),
+    Provider.INTEL: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=IntelBackendPreferences
+    ),
+    Provider.IBM_QUANTUM: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=IBMBackendPreferences,
+        config_class=IBMConfig,
+        backend_name_mapper=_ibm_backend_name_mapper,
+    ),
+    Provider.AMAZON_BRAKET: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=AwsBackendPreferences,
+        config_dict_to_backend_preferences_dict=_braket_config_dict_to_backend_preferences_dict,
+        config_class=BraketConfig,
+    ),
+    Provider.IONQ: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=IonqBackendPreferences,
+        config_class=IonQConfig,
+    ),
+    Provider.ALICE_AND_BOB: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=AliceBobBackendPreferences,
+        config_class=AliceBobConfig,
+    ),
+    Provider.AQT: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=AQTBackendPreferences,
+        config_class=AQTConfig,
+    ),
+    Provider.AZURE_QUANTUM: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=AzureBackendPreferences,
+        config_dict_to_backend_preferences_dict=_azure_config_dict_to_backend_preferences_dict,
+        config_class=AzureConfig,
+    ),
+}
+
+
+def _get_backend_preferences_from_specifier(
+    backend_spec: str, config: dict[str, Any] | ProviderConfig
+) -> BackendPreferencesTypes:
+    provider, backend_name = _parse_provider_backend(backend_spec)
+
+    if provider not in _PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC:
+        raise NotImplementedError(
+            f"Unsupported provider '{_PROVIDER_TO_CANONICAL_NAME.get(provider) or provider}'"
+        )
+
+    provider_spec = _PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC[provider]
+    if isinstance(config, ProviderConfig):
+        if provider_spec.config_class is None:
+            raise ValueError(
+                f"This provider does not support any ProviderConfig classes. Received '{config.__class__.__name__}'"
+            )
+        if not isinstance(config, provider_spec.config_class):
+            raise ValueError(
+                f"{_PROVIDER_TO_CANONICAL_NAME[provider]} devices require {provider_spec.config_class.__name__}, got {config.__class__.__name__}"
+            )
+        config_dict = config.model_dump()
+    else:
+        config_dict = config
+    if provider_spec.backend_name_mapper is not None:
+        backend_name = provider_spec.backend_name_mapper(backend_name)
+
+    if provider_spec.config_dict_to_backend_preferences_dict is not None:
+        config_dict = provider_spec.config_dict_to_backend_preferences_dict(config_dict)
+
+    config_dict["backend_name"] = backend_name
+    return provider_spec.backend_preferences_class.model_validate(config_dict)
+
+
+_DEFAULT_BACKEND_NAME = "simulator"
+
+
+def _new_sample(
+    qprog: QuantumProgram,
+    backend: str | None = None,
+    *,
+    parameters: ExecutionParams | None = None,
+    config: dict[str, Any] | ProviderConfig | None = None,
+    num_shots: int | None = None,
+    random_seed: int | None = None,
+    transpilation_option: TranspilationOption = TranspilationOption.DECOMPOSE,
+    verbosity: Verbosity = Verbosity.INFO,
+) -> "DataFrame":
+    """
+    Sample a quantum program.
+
+    Args:
+        qprog: The quantum program
+        backend: The device (hardware or simulator) on which to run the quantum program. Specified as "provider/device_id"
+        parameters: The classical parameters for the quantum program
+        config: Provider-specific configuration, such as api keys
+        num_shots: The number of times to sample
+        random_seed: The random seed used for transpilation and simulation
+        transpilation_option: Advanced configuration for hardware-specific transpilation
+        verbosity: What level of information should be logged
+
+    Returns: A dataframe containing the histogram
+    """
+    if num_shots is not None and num_shots < 1:
+        raise ValueError(f"Argument num_shots must be greater than 0, got {num_shots}")
+    if config is None:
+        config = {}
+    if backend is None:
+        backend = _DEFAULT_BACKEND_NAME
+    backend_preferences = _get_backend_preferences_from_specifier(backend, config)
+    ep = ExecutionPreferences(
+        backend_preferences=backend_preferences,
+        num_shots=num_shots,
+        random_seed=create_random_seed() if random_seed is None else random_seed,
+        transpile_to_hardware=transpilation_option,
+    )
+    if verbosity != Verbosity.QUIET:
+        _logger.info(f"Submitting job to {backend}")
+    with ExecutionSession(qprog, execution_preferences=ep) as session:
+        job = session.submit_sample(parameters)
+        if verbosity != Verbosity.QUIET:
+            _logger.info(f"Job id: {job.id}")
+        result = job.get_sample_result()
+
+    df = result.dataframe
+    return df

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.102.0'
+SEMVER_VERSION = '0.104.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -454,6 +454,20 @@ class CINECABackendPreferences(BackendPreferences):
     )
 
 
+class SoftbankBackendPreferences(BackendPreferences):
+    """
+    Represents the backend preferences specific to Softbank.
+    """
+
+    backend_service_provider: ProviderTypeVendor.SOFTBANK = pydantic.Field(
+        default=ProviderVendor.SOFTBANK
+    )
+
+    priority: int | None = pydantic.Field(
+        default=None, description="Priority of the job"
+    )
+
+
 def is_exact_simulator(backend_preferences: BackendPreferences) -> bool:
     return backend_preferences.backend_name in EXACT_SIMULATORS
 
@@ -486,6 +500,7 @@ BackendPreferencesTypes = Union[
     IntelBackendPreferences,
     AQTBackendPreferences,
     CINECABackendPreferences,
+    SoftbankBackendPreferences,
 ]
 
 __all__ = [

classiq/interface/backend/provider_config/providers/aqt.py

@@ -12,5 +12,5 @@ class AQTConfig(ProviderConfig):
         workspace: The AQT workspace where the simulator/hardware is located.
     """
 
-    api_key: str | None = pydantic.Field(default=None, description="AQT API key")
+    api_key: str = pydantic.Field(description="AQT API key")
     workspace: str = pydantic.Field(description="AQT workspace")

classiq/interface/backend/provider_config/providers/azure.py

@@ -1,6 +1,5 @@
 import pydantic
 
-from classiq.interface.backend import pydantic_backend
 from classiq.interface.backend.provider_config.provider_config import ProviderConfig
 
 
@@ -26,7 +25,7 @@ class AzureConfig(ProviderConfig):
     client_secret: str | None = pydantic.Field(
         default=None, description="Azure Client Secret"
     )
-    resource_id: pydantic_backend.PydanticAzureResourceIDType | None = pydantic.Field(
+    resource_id: str | None = pydantic.Field(
         default=None,
         description="Azure Resource ID (including Azure subscription ID, resource "
         "group and workspace), for personal resource",

classiq/interface/backend/provider_config/providers/ibm.py

@@ -10,7 +10,7 @@ class IBMConfig(ProviderConfig):
     Attributes:
         access_token (str | None): The IBM Cloud access token to be used with IBM Quantum hosted backends. Defaults to `None`.
         channel (str): Channel to use for IBM cloud backends. Defaults to `"ibm_cloud"`.
-        instance_crn (str): The IBM Cloud instance CRN (Cloud Resource Name) for the IBM Quantum service.
+        instance_crn (str | None): The IBM Cloud instance CRN (Cloud Resource Name) for the IBM Quantum service.
     """
 
     access_token: str | None = pydantic.Field(

classiq/interface/backend/quantum_backend_providers.py

@@ -27,6 +27,7 @@ class ProviderVendor(StrEnum):
     INTEL = "Intel"
     AQT = "AQT"
     CINECA = "CINECA"
+    SOFTBANK = "Softbank"
 
 
 class ProviderTypeVendor:
@@ -41,6 +42,7 @@ class ProviderTypeVendor:
     INTEL = Literal[ProviderVendor.INTEL]
     AQT = Literal[ProviderVendor.AQT]
     CINECA = Literal[ProviderVendor.CINECA]
+    SOFTBANK = Literal[ProviderVendor.SOFTBANK]
 
 
 PROVIDER_NAME_MAPPER = {
@@ -54,6 +56,7 @@ PROVIDER_NAME_MAPPER = {
     ProviderVendor.INTEL: "INTEL",
     ProviderVendor.AQT: "AQT",
     ProviderVendor.CLASSIQ: "CLASSIQ",
+    ProviderVendor.SOFTBANK: "SOFTBANK",
 }
 
 

classiq/interface/executor/result.py

@@ -47,7 +47,7 @@ StateVector: TypeAlias = Optional[dict[str, Complex]]
 BITSTRING = "bitstring"
 PROBABILITY = "probability"
 AMPLITUDE = "amplitude"
-COUNT = "count"
+COUNTS = "counts"
 MAGNITUDE = "magnitude"
 PHASE = "phase"
 
@@ -374,7 +374,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
         for bitstring, count in self.counts.items():
             data[BITSTRING].append(bitstring)
-            data[COUNT].append(count)
+            # TODO CLS-4767: delete "count"
+            data["count"].append(count)
+            data[COUNTS].append(count)
             if self.probabilities:
                 data[PROBABILITY].append(self.probabilities[bitstring])
             elif self.num_shots:
@@ -383,7 +385,8 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             for name, value in self.parsed_states[bitstring].items():
                 data[name].append(value)
 
-        final_columns = [COUNT, PROBABILITY, BITSTRING]
+        # TODO CLS-4767: delete "count"
+        final_columns = [COUNTS, "count", PROBABILITY, BITSTRING]
         columns = [
             col for col in data.keys() if col not in final_columns
         ] + final_columns
@@ -419,8 +422,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @functools.cached_property
     def dataframe(self) -> "pd.DataFrame":
+        # TODO CLS-4767: remove "count"
         reserved_words = frozenset(
-            [BITSTRING, PROBABILITY, COUNT, AMPLITUDE, PHASE, MAGNITUDE]
+            ["count", BITSTRING, PROBABILITY, COUNTS, AMPLITUDE, PHASE, MAGNITUDE]
         )
         _invalid_output_names = reserved_words.intersection(
             self.output_qubits_map.keys()
@@ -436,7 +440,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             df = self._counts_df()
 
         df.sort_values(
-            by=[AMPLITUDE if self.state_vector else COUNT, BITSTRING],
+            by=[AMPLITUDE if self.state_vector else COUNTS, BITSTRING],
             inplace=True,
             ascending=[False, True],
             ignore_index=True,

classiq/interface/generator/arith/binary_ops.py

@@ -29,7 +29,10 @@ from classiq.interface.generator.arith.ast_node_rewrite import (
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.arith.unary_ops import Negation
-from classiq.interface.generator.function_params import get_zero_input_name
+from classiq.interface.generator.function_params import (
+    FunctionParams,
+    get_zero_input_name,
+)
 
 from classiq.model_expansions.arithmetic import NumericAttributes
 from classiq.model_expansions.arithmetic_compute_result_attrs import (
@@ -533,10 +536,43 @@ class Multiplier(BinaryOpWithFloatInputs):
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         return max(
-            0, self.expected_fraction_places() - self.result_register.fraction_places
+            0,
+            self.expected_fraction_places() - self.result_register.fraction_places - 1,
         )
 
 
+class CanonicalMultiplier(FunctionParams):
+    left_size: pydantic.PositiveInt
+    extend_left: bool
+    right_size: pydantic.PositiveInt
+    extend_right: bool
+    result_size: pydantic.PositiveInt
+    trim_result_lsb: bool
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            "left": RegisterArithmeticInfo(size=self.left_size),
+            "right": RegisterArithmeticInfo(size=self.right_size),
+            "result": RegisterArithmeticInfo(size=self.result_size),
+        }
+        self._outputs = {**self._inputs}
+
+
+class CanonicalConstantMultiplier(FunctionParams):
+    left: int
+    right_size: pydantic.PositiveInt
+    extend_right: bool
+    result_size: pydantic.PositiveInt
+    trim_result_lsb: bool
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            "right": RegisterArithmeticInfo(size=self.right_size),
+            "result": RegisterArithmeticInfo(size=self.result_size),
+        }
+        self._outputs = {**self._inputs}
+
+
 class Comparator(BinaryOpWithFloatInputs):
     output_size: Literal[1] = 1
 

classiq/interface/generator/function_param_list.py

@@ -1,12 +1,13 @@
 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,
+    CanonicalConstantMultiplier,
+    CanonicalMultiplier,
     Equal,
     GreaterEqual,
     GreaterThan,
@@ -79,6 +80,8 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             HardwareEfficientAnsatz,
             UnitaryGate,
             Multiplier,
+            CanonicalMultiplier,
+            CanonicalConstantMultiplier,
             Power,
             Min,
             Max,
@@ -88,7 +91,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             Identity,
             RandomizedBenchmarking,
             UGate,
-            AmplitudeLoading,
             HadamardTransform,
             Copy,
             Reset,

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,9 @@ 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 {}
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -89,6 +96,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 +113,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 +130,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 +220,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 +236,14 @@ 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]"
+        )
+
 
 class ClassicalTuple(ClassicalType):
     kind: Literal["tuple"]
@@ -283,6 +314,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 +329,13 @@ 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)
+
 
 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,25 @@ 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_prefix] = 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[field_prefix] = classical_field_type.get_compile_time_attributes(
+                    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,