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

classiq/execution/functions/util/backend_preferences.py

@@ -0,0 +1,188 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Literal
+
+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.hardware import Provider
+
+from classiq.execution.functions.util.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)

classiq/execution/functions/util/constants.py

@@ -0,0 +1,9 @@
+from enum import auto, unique
+
+from classiq.interface.enum_utils import StrEnum
+
+
+@unique
+class Verbosity(StrEnum):
+    QUIET = auto()
+    INFO = auto()

classiq/execution/functions/util/parse_provider_backend.py

@@ -0,0 +1,90 @@
+from classiq.interface.hardware import Provider
+
+_PROVIDER_BACKEND_SEPARATOR = "/"
+
+_PROVIDER_TO_CANONICAL_NAME: dict[Provider, str] = {
+    Provider.IBM_QUANTUM: "ibm",
+    Provider.AZURE_QUANTUM: "azure",
+    Provider.AMAZON_BRAKET: "braket",
+    Provider.IONQ: "ionq",
+    Provider.CLASSIQ: "classiq",
+    Provider.GOOGLE: "google",
+    Provider.ALICE_AND_BOB: "alice&bob",
+    Provider.OQC: "oqc",
+    Provider.INTEL: "intel",
+    Provider.AQT: "aqt",
+    Provider.CINECA: "cineca",
+    Provider.SOFTBANK: "softbank",
+}
+
+_CANONICAL_NAMES_TO_PROVIDER: dict[str, Provider] = {
+    name: provider for provider, name in _PROVIDER_TO_CANONICAL_NAME.items()
+}
+
+
+def _error_suggested_provider(provider_name: str) -> Provider | None:
+    """
+    In the case that receive an incorrect provider name, return a possible suggestion.
+    """
+    provider_name = provider_name.strip().lower()
+    for canonical_name in _CANONICAL_NAMES_TO_PROVIDER:
+        if canonical_name in provider_name:
+            return _CANONICAL_NAMES_TO_PROVIDER[canonical_name]
+    # Special cases
+    if "gcp" in provider_name:
+        return Provider.GOOGLE
+    if "microsoft" in provider_name:
+        return Provider.AZURE_QUANTUM
+    if "amazon" in provider_name or "aws" in provider_name:
+        return Provider.AMAZON_BRAKET
+    if "oxford" in provider_name:
+        return Provider.OQC
+    if "alice" in provider_name or "bob" in provider_name:
+        return Provider.ALICE_AND_BOB
+    if "alpine" in provider_name:
+        return Provider.AQT
+
+    return None
+
+
+def _parse_provider_backend(spec: str) -> tuple[Provider, str]:
+    """
+    Parse a backend specification into (provider, backend). Provider is case-insensitive.
+    Backend must NOT contain the separator. If provider is not specified, it defaults to
+    Classiq.
+    """
+    if not spec.strip():
+        raise ValueError("Backend specification must be a non-empty string")
+
+    spec = spec.strip()
+
+    if _PROVIDER_BACKEND_SEPARATOR not in spec:
+        return Provider.CLASSIQ, spec
+
+    provider_raw, backend = spec.split(_PROVIDER_BACKEND_SEPARATOR, 1)
+
+    if _PROVIDER_BACKEND_SEPARATOR in backend:
+        raise ValueError(
+            f"Backend name must not contain '{_PROVIDER_BACKEND_SEPARATOR}': '{backend}'"
+        )
+
+    provider_key = provider_raw.strip().lower()
+    backend = backend.strip()
+
+    if not provider_key:
+        raise ValueError("Provider name cannot be empty")
+    if not backend:
+        raise ValueError("Backend name cannot be empty")
+
+    try:
+        provider = _CANONICAL_NAMES_TO_PROVIDER[provider_key]
+    except KeyError:
+        error_message = f"Unrecognized provider '{provider_raw}'."
+        suggested_provider = _error_suggested_provider(provider_key)
+        if suggested_provider is not None:
+            error_message += (
+                f" Did you mean '{_PROVIDER_TO_CANONICAL_NAME[suggested_provider]}'?"
+            )
+        raise ValueError(error_message) from None
+
+    return provider, backend

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 = '1.0.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -454,6 +454,84 @@ 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"
+    )
+
+
+class C12BackendPreferences(BackendPreferences):
+    """
+    Represents the backend preferences specific to C12.
+
+    Attributes:
+        backend_name: Name of the requested backend or target.
+        result_format: Result format of the job; one of "counts",
+            "state_vector", or "density_matrix". Defaults to "counts".
+        inilabel: Initial state specified using a binary label format
+            (e.g. "00", "01"). Mutually exclusive with inistatevector.
+        inistatevector: Initial state vector as a comma-separated list of
+            complex values (e.g. "1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j").
+            Mutually exclusive with inilabel.
+        ininoisy: Whether to use noisy initialization of the circuit.
+    """
+
+    backend_service_provider: ProviderTypeVendor.C12 = pydantic.Field(
+        default=ProviderVendor.C12
+    )
+
+    result_format: str = pydantic.Field(
+        default="counts", description="Result format of the job"
+    )
+
+    inilabel: str | None = pydantic.Field(
+        default=None, description="Initial label of the initial state."
+    )
+
+    inistatevector: str | None = pydantic.Field(
+        default=None, description="Initial state vector of the job."
+    )
+
+    ininoisy: bool | None = pydantic.Field(
+        default=None, description="Whether the initial state is noisy."
+    )
+
+    @pydantic.model_validator(mode="after")
+    def _validate_initial_label_statevector(
+        self: C12BackendPreferences,
+    ) -> C12BackendPreferences:
+        if self.inilabel is not None and self.inistatevector is not None:
+            raise ValueError(
+                f"Cannot specify both inilabel and inistatevector.\n"
+                f"inilabel={self.inilabel}, inistatevector={self.inistatevector}"
+            )
+        return self
+
+    @pydantic.field_validator("result_format")
+    @classmethod
+    def _validate_result_format(cls, result_format: str) -> str:
+        if result_format not in ["density_matrix", "state_vector", "counts"]:
+            raise ValueError(f"Invalid result format: {result_format}")
+        return result_format
+
+    @property
+    def parameters(self) -> dict:
+        data = self.model_dump(exclude_none=True)
+        for field in ["inilabel", "inistatevector", "ininoisy"]:
+            if field in data and data[field] is None:
+                data.pop(field)
+
+        return data
+
+
 def is_exact_simulator(backend_preferences: BackendPreferences) -> bool:
     return backend_preferences.backend_name in EXACT_SIMULATORS
 
@@ -486,6 +564,8 @@ BackendPreferencesTypes = Union[
     IntelBackendPreferences,
     AQTBackendPreferences,
     CINECABackendPreferences,
+    SoftbankBackendPreferences,
+    C12BackendPreferences,
 ]
 
 __all__ = [
@@ -497,6 +577,7 @@ __all__ = [
     "AzureBackendPreferences",
     "AzureCredential",
     "AzureQuantumBackendNames",
+    "C12BackendPreferences",
     "ClassiqBackendPreferences",
     "ClassiqNvidiaBackendNames",
     "ClassiqSimulatorBackendNames",

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,8 @@ class ProviderVendor(StrEnum):
     INTEL = "Intel"
     AQT = "AQT"
     CINECA = "CINECA"
+    SOFTBANK = "Softbank"
+    C12 = "C12"
 
 
 class ProviderTypeVendor:
@@ -41,6 +43,8 @@ class ProviderTypeVendor:
     INTEL = Literal[ProviderVendor.INTEL]
     AQT = Literal[ProviderVendor.AQT]
     CINECA = Literal[ProviderVendor.CINECA]
+    SOFTBANK = Literal[ProviderVendor.SOFTBANK]
+    C12 = Literal[ProviderVendor.C12]
 
 
 PROVIDER_NAME_MAPPER = {
@@ -54,6 +58,8 @@ PROVIDER_NAME_MAPPER = {
     ProviderVendor.INTEL: "INTEL",
     ProviderVendor.AQT: "AQT",
     ProviderVendor.CLASSIQ: "CLASSIQ",
+    ProviderVendor.SOFTBANK: "SOFTBANK",
+    ProviderVendor.C12: "C12",
 }
 
 
@@ -245,6 +251,11 @@ class OQCBackendNames(StrEnum):
     LUCY = "Lucy"
 
 
+class C12BackendNames(StrEnum):
+    SIMULATOR = "c12sim-iswap"
+    SQUARED = "squared-iswap"
+
+
 EXACT_SIMULATORS = {
     IonqBackendNames.SIMULATOR,
     AzureQuantumBackendNames.IONQ_SIMULATOR,
@@ -255,6 +266,7 @@ EXACT_SIMULATORS = {
     *ClassiqSimulatorBackendNames,
     *IntelBackendNames,
     *ClassiqNvidiaBackendNames,
+    *C12BackendNames,
 }
 
 AllIBMQBackendNames = IBMQHardwareNames
@@ -268,6 +280,7 @@ AllBackendsNameByVendor = Union[
     ClassiqNvidiaBackendNames,
     AliceBobBackendNames,
     OQCBackendNames,
+    C12BackendNames,
 ]
 
 AllBackendsNameEnums = [
@@ -279,4 +292,5 @@ AllBackendsNameEnums = [
     IntelBackendNames,
     ClassiqNvidiaBackendNames,
     OQCBackendNames,
+    C12BackendNames,
 ]

classiq/interface/exceptions.py

@@ -39,10 +39,6 @@ class ClassiqAnalyzerError(ClassiqError):
     pass
 
 
-class ClassiqAnalyzerVisualizationError(ClassiqError):
-    pass
-
-
 class ClassiqAPIError(ClassiqError):
     def __init__(self, message: str, status_code: int | None = None) -> None:
         self.status_code = status_code

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 (
@@ -335,6 +338,30 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         return isinstance(arg, float) and arg == 0
 
 
+class CanonicalAdder(FunctionParams):
+    left_size: pydantic.PositiveInt
+    extend_left: bool
+    right_size: pydantic.PositiveInt
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            DEFAULT_LEFT_ARG_NAME: RegisterArithmeticInfo(size=self.left_size),
+            DEFAULT_RIGHT_ARG_NAME: RegisterArithmeticInfo(size=self.right_size),
+        }
+        self._outputs = {**self._inputs}
+
+
+class CanonicalConstantAdder(FunctionParams):
+    left: int
+    right_size: pydantic.PositiveInt
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            "right_arg": RegisterArithmeticInfo(size=self.right_size),
+        }
+        self._outputs = {**self._inputs}
+
+
 class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "difference"
 
@@ -533,10 +560,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/arith/number_utils.py

@@ -3,13 +3,22 @@ from typing import Final
 MAXIMAL_MACHINE_PRECISION: Final[int] = 20
 
 
-def signed_int_to_unsigned(number: int) -> int:
+def signed_int_to_unsigned(number: int, reg_size: int | None = None) -> int:
     """Return the integer value of a signed int if it would we read as un-signed in binary representation"""
-    if number >= 0:
-        return number
-
-    not_power2 = abs(number) & (abs(number) - 1) != 0
-    return number + 2 ** (number.bit_length() + 1 * not_power2)
+    signed: bool = False
+    if number < 0:
+        signed = True
+        not_power2 = abs(number) & (abs(number) - 1) != 0
+        number = number + 2 ** (number.bit_length() + 1 * not_power2)
+
+    if reg_size is not None:
+        bits = bin(number)[2:][::-1]
+        bits = bits[:reg_size]
+        if signed and len(bits) < reg_size:
+            bits += "1" * (reg_size - len(bits))
+        number = int(bits[::-1], 2)
+
+    return number
 
 
 def binary_to_int(bin_rep: str, is_signed: bool = False) -> int:

classiq/interface/generator/compiler_keywords.py

@@ -2,6 +2,7 @@ EXPANDED_KEYWORD = "expanded__"
 CAPTURE_SUFFIX = "_captured__"
 LAMBDA_KEYWORD = "lambda__"
 INPLACE_ARITH_AUX_VAR_PREFIX = "_tmp"
+INPLACE_CONTROL_AUX_VAR_PREFIX = "_ctmp"
 THEN_KEYWORD = "then"
 ELSE_KEYWORD = "else"