classiq 0.46.1__py3-none-any.whl → 0.47.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -1,5 +1,5 @@
 import json
-from typing import Dict, List, Optional, Protocol, Type, TypeVar
+from typing import Any, Dict, List, Optional, Protocol, Type, TypeVar
 
 import pydantic
 
@@ -7,6 +7,7 @@ import classiq.interface.executor.execution_result
 import classiq.interface.pyomo_extension
 from classiq.interface.analyzer import analysis_params, result as analysis_result
 from classiq.interface.analyzer.analysis_params import AnalysisRBParams
+from classiq.interface.analyzer.result import GraphStatus
 from classiq.interface.chemistry import ground_state_problem, operator
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError, ClassiqValueError
@@ -16,7 +17,7 @@ from classiq.interface.execution.jobs import (
 )
 from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
-from classiq.interface.hardware import HardwareInformation
+from classiq.interface.hardware import HardwareInformation, Provider
 from classiq.interface.jobs import JobDescription, JobID, JSONObject
 from classiq.interface.model.model import Model
 from classiq.interface.server import routes
@@ -36,6 +37,7 @@ class HTTPMethod(StrEnum):
     GET = "GET"
     POST = "POST"
     PATCH = "PATCH"
+    PUT = "PUT"
 
 
 class StatusType(Protocol):
@@ -80,8 +82,9 @@ class ApiWrapper:
         params: Optional[Dict] = None,
         use_versioned_url: bool = True,
         headers: Optional[Dict[str, str]] = None,
+        allow_none: bool = False,
     ) -> dict:
-        res = await client().call_api(
+        res: Any = await client().call_api(
             http_method=http_method,
             url=url,
             body=body,
@@ -89,6 +92,8 @@ class ApiWrapper:
             params=params,
             use_versioned_url=use_versioned_url,
         )
+        if allow_none and res is None:
+            return {}
         if not isinstance(res, dict):
             raise ClassiqValueError(f"Unexpected returned value: {res}")
         return res
@@ -169,6 +174,18 @@ class ApiWrapper:
         )
         return ExecutionJobDetailsV1.parse_obj(data)
 
+    @classmethod
+    async def call_cancel_execution_job(
+        cls,
+        job_id: JobID,
+    ) -> None:
+        await cls._call_task(
+            http_method=HTTPMethod.PUT,
+            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/cancel",
+            use_versioned_url=False,
+            allow_none=True,
+        )
+
     @classmethod
     async def call_query_execution_jobs(
         cls,
@@ -267,12 +284,32 @@ class ApiWrapper:
         cls,
         params: analysis_params.AnalysisOptionalDevicesParams,
     ) -> analysis_result.DevicesResult:
-        data = await cls._call_task(
-            http_method=HTTPMethod.POST,
-            url=routes.ANALYZER_OPTIONAL_DEVICES_FULL_PATH,
-            body=params.dict(),
+        hardware_info = await cls.call_get_all_hardware_devices()
+        return cls._get_devices_from_hardware_info(hardware_info, params)
+
+    @staticmethod
+    def _get_devices_from_hardware_info(
+        hardware_info: List[HardwareInformation],
+        params: analysis_params.AnalysisOptionalDevicesParams,
+    ) -> analysis_result.DevicesResult:
+        available_hardware: Dict[Provider, Dict[str, bool]] = {
+            Provider.IBM_QUANTUM: {},
+            Provider.AMAZON_BRAKET: {},
+            Provider.AZURE_QUANTUM: {},
+        }
+        for info in hardware_info:
+            if info.provider not in available_hardware:
+                continue
+            is_available = info.number_of_qubits >= params.qubit_count
+            available_hardware[info.provider][info.display_name] = is_available
+        return analysis_result.DevicesResult(
+            devices=analysis_result.AvailableHardware(
+                ibm_quantum=available_hardware[Provider.IBM_QUANTUM],
+                azure_quantum=available_hardware[Provider.AZURE_QUANTUM],
+                amazon_braket=available_hardware[Provider.AMAZON_BRAKET],
+            ),
+            status=GraphStatus.SUCCESS,
         )
-        return analysis_result.DevicesResult.parse_obj(data)
 
     @classmethod
     async def call_get_all_hardware_devices(cls) -> List[HardwareInformation]:

classiq/execution/execution_session.py

@@ -2,13 +2,11 @@ import json
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
 from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
-from classiq.interface.executor.execution_result import ResultsCollection
 from classiq.interface.executor.result import (
     EstimationResult,
-    EstimationResults,
     ExecutionDetails,
-    MultipleExecutionDetails,
 )
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.generator.quantum_program import QuantumProgram
@@ -17,6 +15,7 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
     _pauli_dict_to_str,
     _pauli_terms_to_qmod,
 )
+from classiq.execution.jobs import ExecutionJob
 from classiq.executor import execute
 from classiq.qmod.builtins import PauliTerm
 from classiq.qmod.builtins.classical_execution_primitives import (
@@ -165,14 +164,6 @@ class ExecutionSession:
         if execution_preferences is not None:
             self.program.model.execution_preferences = execution_preferences
 
-    def _execute_quantum_program(
-        self, operation: str, **kwargs: Any
-    ) -> ResultsCollection:
-        self.program.model.classical_execution_code = generate_code_snippet(
-            operation, **kwargs
-        )
-        return execute(SerializedQuantumProgram(self.qprog)).result()
-
     def sample(self, parameters: Optional[ExecutionParams] = None) -> ExecutionDetails:
         """
         Samples the quantum program with the given parameters, if any.
@@ -180,16 +171,34 @@ class ExecutionSession:
         Args:
             parameters: The values to set for the parameters of the quantum program when sampling. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
 
+        Returns:
+            The result of the sampling.
+        """
+        job = self.submit_sample(parameters=parameters)
+        return job.get_sample_result()
+
+    def submit_sample(
+        self, parameters: Optional[ExecutionParams] = None
+    ) -> ExecutionJob:
+        """
+        Initiates an execution job with the `sample` primitive.
+
+        This is a non-blocking version of `sample`: it gets the same parameters and initiates the same execution job, but instead
+        of waiting for the result, it returns the job object immediately.
+
+        Args:
+            parameters: The values to set for the parameters of the quantum program when sampling. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
 
         Returns:
-            ExecutionDetails: The result of the sampling.
+            The execution job.
         """
-        return cast(
-            ExecutionDetails,
-            self._execute_quantum_program(
-                SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
-            )[0].value,
+        self.program.model.classical_execution_code = generate_code_snippet(
+            SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
+        )
+        self.program.execution_primitives_input = PrimitivesInput(
+            sample=[parameters] if parameters is not None else [{}]
         )
+        return execute(SerializedQuantumProgram(self.qprog))
 
     def batch_sample(self, parameters: List[ExecutionParams]) -> List[ExecutionDetails]:
         """
@@ -201,13 +210,27 @@ class ExecutionSession:
         Returns:
             List[ExecutionDetails]: The results of all the sampling iterations.
         """
-        return cast(
-            MultipleExecutionDetails,
-            self._execute_quantum_program(
-                SupportedPrimitives.BATCH_SAMPLE,
-                parameters=format_parameters(parameters),
-            )[0].value,
-        ).details
+        job = self.submit_batch_sample(parameters=parameters)
+        return job.get_batch_sample_result()
+
+    def submit_batch_sample(self, parameters: List[ExecutionParams]) -> ExecutionJob:
+        """
+        Initiates an execution job with the `batch_sample` primitive.
+
+        This is a non-blocking version of `batch_sample`: it gets the same parameters and initiates the same execution job, but instead
+        of waiting for the result, it returns the job object immediately.
+
+        Args:
+            parameters: A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            The execution job.
+        """
+        self.program.model.classical_execution_code = generate_code_snippet(
+            SupportedPrimitives.BATCH_SAMPLE, parameters=format_parameters(parameters)
+        )
+        self.program.execution_primitives_input = PrimitivesInput(sample=parameters)
+        return execute(SerializedQuantumProgram(self.qprog))
 
     def estimate(
         self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
@@ -222,14 +245,31 @@ class ExecutionSession:
         Returns:
             EstimationResult: The result of the estimation.
         """
-        return cast(
-            EstimationResult,
-            self._execute_quantum_program(
-                SupportedPrimitives.ESTIMATE,
-                parameters=format_parameters(parameters),
-                hamiltonian=to_hamiltonian_str(hamiltonian),
-            )[0].value,
+        job = self.submit_estimate(hamiltonian=hamiltonian, parameters=parameters)
+        return job.get_estimate_result()
+
+    def submit_estimate(
+        self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
+    ) -> ExecutionJob:
+        """
+        Initiates an execution job with the `estimate` primitive.
+
+        This is a non-blocking version of `estimate`: it gets the same parameters and initiates the same execution job, but instead
+        of waiting for the result, it returns the job object immediately.
+
+        Args:
+            hamiltonian: The Hamiltonian to estimate the expectation value of.
+            parameters: The values to set for the parameters of the quantum program when estimating.  Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            The execution job.
+        """
+        self.program.model.classical_execution_code = generate_code_snippet(
+            SupportedPrimitives.ESTIMATE,
+            parameters=format_parameters(parameters),
+            hamiltonian=to_hamiltonian_str(hamiltonian),
         )
+        return execute(SerializedQuantumProgram(self.qprog))
 
     def batch_estimate(
         self, hamiltonian: Hamiltonian, parameters: List[ExecutionParams]
@@ -244,11 +284,28 @@ class ExecutionSession:
         Returns:
             List[EstimationResult]: The results of all the estimation iterations.
         """
-        return cast(
-            EstimationResults,
-            self._execute_quantum_program(
-                SupportedPrimitives.BATCH_ESTIMATE,
-                parameters=format_parameters(parameters),
-                hamiltonian=to_hamiltonian_str(hamiltonian),
-            )[0].value,
-        ).results
+        job = self.submit_batch_estimate(hamiltonian=hamiltonian, parameters=parameters)
+        return job.get_batch_estimate_result()
+
+    def submit_batch_estimate(
+        self, hamiltonian: Hamiltonian, parameters: List[ExecutionParams]
+    ) -> ExecutionJob:
+        """
+        Initiates an execution job with the `batch_estimate` primitive.
+
+        This is a non-blocking version of `batch_estimate`: it gets the same parameters and initiates the same execution job, but instead
+        of waiting for the result, it returns the job object immediately.
+
+        Args:
+            hamiltonian: The Hamiltonian to estimate the expectation value of.
+            parameters: A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            The execution job.
+        """
+        self.program.model.classical_execution_code = generate_code_snippet(
+            SupportedPrimitives.BATCH_ESTIMATE,
+            parameters=format_parameters(parameters),
+            hamiltonian=to_hamiltonian_str(hamiltonian),
+        )
+        return execute(SerializedQuantumProgram(self.qprog))

classiq/execution/jobs.py

@@ -3,10 +3,19 @@ from datetime import datetime
 from typing import Any, List, Optional, Union
 from urllib.parse import urljoin
 
-from classiq.interface.exceptions import ClassiqAPIError
+from classiq.interface.exceptions import (
+    ClassiqAPIError,
+    ClassiqError,
+)
 from classiq.interface.execution.jobs import ExecutionJobDetailsV1
 from classiq.interface.executor.execution_request import ExecutionJobDetails
 from classiq.interface.executor.execution_result import ResultsCollection
+from classiq.interface.executor.result import (
+    EstimationResult,
+    EstimationResults,
+    ExecutionDetails,
+    MultipleExecutionDetails,
+)
 from classiq.interface.jobs import JobStatus, JSONObject
 from classiq.interface.server.routes import EXECUTION_JOBS_NON_VERSIONED_FULL_PATH
 
@@ -21,6 +30,13 @@ _JOB_DETAILS_VERSION = "v1"
 _JOB_RESULT_VERSION = "v1"
 
 
+class ClassiqExecutionResultError(ClassiqError):
+    def __init__(self, primitive: str) -> None:
+        super().__init__(
+            f"Execution job does not contain a single {primitive!r} result, make sure you use the 'get_*_result' method matching the primitive you executed. You can use the 'result' method to see the general result."
+        )
+
+
 class ExecutionJob:
     _details: _JobDetails
     _result: Optional[ResultsCollection]
@@ -112,6 +128,84 @@ class ExecutionJob:
     def result_value(self, *args: Any, **kwargs: Any) -> Any:
         return self.result(*args, **kwargs)[0].value
 
+    def get_sample_result(self) -> ExecutionDetails:
+        """
+        Returns the job's result as a single sample result after validation. If the result is not yet available, waits for it.
+
+        Returns:
+            The sample result of the execution job.
+
+        Raises:
+            ClassiqExecutionResultError: In case the result does not contain a single sample result.
+            ClassiqAPIError: In case the job has failed.
+        """
+        results = self.result()
+        if len(results) != 1:
+            raise ClassiqExecutionResultError("sample")
+
+        result = results[0].value
+        if isinstance(result, ExecutionDetails):
+            return result
+        if isinstance(result, MultipleExecutionDetails) and len(result.details) == 1:
+            return result.details[0]
+        raise ClassiqExecutionResultError("sample")
+
+    def get_batch_sample_result(self) -> List[ExecutionDetails]:
+        """
+        Returns the job's result as a single batch_sample result after validation. If the result is not yet available, waits for it.
+
+        Returns:
+            The batch_sample result of the execution job.
+
+        Raises:
+            ClassiqExecutionResultError: In case the result does not contain a single batch_sample result.
+            ClassiqAPIError: In case the job has failed.
+        """
+        results = self.result()
+        if len(results) != 1 or not isinstance(
+            results[0].value, MultipleExecutionDetails
+        ):
+            raise ClassiqExecutionResultError("batch_sample")
+        return results[0].value.details
+
+    def get_estimate_result(self) -> EstimationResult:
+        """
+        Returns the job's result as a single estimate result after validation. If the result is not yet available, waits for it.
+
+        Returns:
+            The estimate result of the execution job.
+
+        Raises:
+            ClassiqExecutionResultError: In case the result does not contain a single estimate result.
+            ClassiqAPIError: In case the job has failed.
+        """
+        results = self.result()
+        if len(results) != 1:
+            raise ClassiqExecutionResultError("estimate")
+
+        result = results[0].value
+        if isinstance(result, EstimationResult):
+            return result
+        if isinstance(result, EstimationResults) and len(result.results) == 1:
+            return result.results[0]
+        raise ClassiqExecutionResultError("estimate")
+
+    def get_batch_estimate_result(self) -> List[EstimationResult]:
+        """
+        Returns the job's result as a single batch_estimate result after validation. If the result is not yet available, waits for it.
+
+        Returns:
+            The batch_estimate result of the execution job.
+
+        Raises:
+            ClassiqExecutionResultError: In case the result does not contain a single batch_estimate result.
+            ClassiqAPIError: In case the job has failed.
+        """
+        results = self.result()
+        if len(results) != 1 or not isinstance(results[0].value, EstimationResults):
+            raise ClassiqExecutionResultError("batch_estimate")
+        return results[0].value.results
+
     async def poll_async(self, timeout_sec: Optional[float] = None) -> None:
         if not self.status.is_final():
             await self._poll_job(timeout_sec=timeout_sec)
@@ -141,6 +235,19 @@ class ExecutionJob:
 
     rename = syncify_function(rename_async)
 
+    async def cancel_async(self) -> None:
+        """
+        Cancels the execution job. This implies the cancellation of any ongoing jobs
+        sent to the provider during this execution job.
+
+        The function returns without waiting to the actual cancellation. It is possible
+        to continue polling the job in order to ensure its cancellation, which might
+        not be immediate.
+        """
+        await ApiWrapper.call_cancel_execution_job(self._job_id)
+
+    cancel = syncify_function(cancel_async)
+
     @property
     def ide_url(self) -> str:
         base_url = client().config.ide

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

classiq/interface/backend/quantum_backend_providers.py

@@ -68,7 +68,6 @@ class AzureQuantumBackendNames(StrEnum):
     IONQ_SIMULATOR = "ionq.simulator"
     MICROSOFT_ESTIMATOR = "microsoft.estimator"
     MICROSOFT_FULLSTATE_SIMULATOR = "microsoft.simulator.fullstate"
-    RIGETTI_ASPEN3 = "rigetti.qpu.aspen-m-3"
     RIGETTI_SIMULATOR = "rigetti.sim.qvm"
     RIGETTI_ANKAA2 = "rigetti.qpu.ankaa-2"
     RIGETTI_ANKAA9 = "rigetti.qpu.ankaa-9q-1"

classiq/interface/debug_info/debug_info.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Mapping, Optional, Tuple, Union
 from uuid import UUID
 
 from pydantic import BaseModel, Field
@@ -14,10 +14,12 @@ ParameterValue = Union[float, int, str, None]
 
 class FunctionDebugInfo(BaseModel):
     name: str
+    # Parameters describe classical parameters passed to function
     # ParameterValue appears in type only for backwards compatibility
     parameters: Dict[str, str] = Field(type=Dict[str, ParameterValue])
     level: OperationLevel
     is_allocate_or_free: bool = Field(default=False)
+    port_to_passed_variable_map: Dict[str, str] = Field(default_factory=dict)
 
     @staticmethod
     def param_controller(value: Any) -> str:
@@ -26,6 +28,26 @@ class FunctionDebugInfo(BaseModel):
         except TypeError:
             return repr(value)
 
+    def update_map_from_port_mapping(self, port_mapping: Mapping[str, str]) -> None:
+        new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
+        for old_key, new_key in port_mapping.items():
+            if old_key in new_port_to_passed_variable_map:
+                new_port_to_passed_variable_map[new_key] = (
+                    new_port_to_passed_variable_map.pop(old_key)
+                )
+        self.port_to_passed_variable_map = new_port_to_passed_variable_map
+
+    def update_map_from_inout_port_mapping(
+        self, port_mapping: Mapping[str, Tuple[str, str]]
+    ) -> None:
+        new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
+        for old_key, (new_key1, new_key2) in port_mapping.items():
+            if old_key in new_port_to_passed_variable_map:
+                value = new_port_to_passed_variable_map.pop(old_key)
+                new_port_to_passed_variable_map[new_key1] = value
+                new_port_to_passed_variable_map[new_key2] = value
+        self.port_to_passed_variable_map = new_port_to_passed_variable_map
+
 
 class DebugInfoCollection(BaseModel):
     # Pydantic only started supporting UUID as keys in Pydantic V2

classiq/interface/execution/primitives.py

@@ -0,0 +1,9 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from classiq.interface.executor.quantum_code import Arguments
+
+
+class PrimitivesInput(BaseModel):
+    sample: Optional[List[Arguments]] = Field(default=None)

classiq/interface/generator/arith/arithmetic_operations.py

@@ -1,5 +1,5 @@
 import abc
-from typing import ClassVar, Iterable, Optional, Tuple
+from typing import ClassVar, Final, Iterable, Optional, Tuple
 
 import pydantic
 
@@ -9,7 +9,10 @@ from classiq.interface.generator.arith.machine_precision import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import FunctionParams
 
-DEFAULT_GARBAGE_OUT_NAME: str = "extra_qubits"
+DEFAULT_GARBAGE_OUT_NAME: Final[str] = "extra_qubits"
+MODULO_WITH_FRACTION_PLACES_ERROR_MSG: Final[str] = (
+    "Modulo with fraction places not supported"
+)
 
 
 class ArithmeticOperationParams(FunctionParams):

classiq/interface/generator/arith/binary_ops.py

@@ -21,6 +21,7 @@ from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.ast_node_rewrite import (
@@ -391,17 +392,20 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
             arg=self.effective_right_arg,
             output_size=self.negation_output_size,
             inplace=self.should_inplace_negation,
+            bypass_bounds_validation=True,
         )
         negation_result = negation_params.result_register
         if self.output_size is None and max(self.effective_right_arg.bounds) > 0:
-            negation_result = negation_result.copy(
-                update=dict(
-                    is_signed=True,
-                    bounds=(
-                        -max(self.effective_right_arg.bounds),
-                        -min(self.effective_right_arg.bounds),
-                    ),
-                )
+            bounds = (
+                -max(self.effective_right_arg.bounds),
+                -min(self.effective_right_arg.bounds),
+            )
+            negation_result = RegisterArithmeticInfo(
+                size=negation_result.size,
+                fraction_places=negation_result.fraction_places,
+                is_signed=True,
+                bounds=bounds,
+                bypass_bounds_validation=True,
             )
         adder_params = Adder(
             left_arg=self.effective_left_arg,
@@ -465,12 +469,8 @@ class Multiplier(BinaryOpWithFloatInputs):
             for right in argument_utils.bounds(args[1])
         ]
         return (
-            number_utils.limit_fraction_places(
-                min(extremal_values), machine_precision=machine_precision
-            ),
-            number_utils.limit_fraction_places(
-                max(extremal_values), machine_precision=machine_precision
-            ),
+            number_utils.limit_fraction_places(min(extremal_values), machine_precision),
+            number_utils.limit_fraction_places(max(extremal_values), machine_precision),
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
@@ -482,6 +482,13 @@ class Multiplier(BinaryOpWithFloatInputs):
             self.right_arg, self.machine_precision
         )
         bounds = self._get_bounds((left_arg, right_arg), self.machine_precision)
+        if self.output_size:
+            if fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
 
         return RegisterArithmeticInfo(
             size=self.output_size

classiq/interface/generator/arith/extremum_operations.py

@@ -4,9 +4,10 @@ from typing import Any, Dict, Iterable
 import pydantic
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.arith import argument_utils
+from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.binary_ops import (
@@ -108,6 +109,13 @@ class Extremum(ArithmeticOperationParams):
                 argument_utils.upper_bound(eff_right_arg),
             ),
         )
+        if self.output_size:
+            if fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
         return RegisterArithmeticInfo(
             size=self.output_size or required_size,
             fraction_places=fraction_places,

classiq/interface/generator/arith/number_utils.py

@@ -110,3 +110,9 @@ def limit_fraction_places(number: float, machine_precision: int) -> float:
         fraction_part_size=orig_fractions - removed_fractions,
         is_signed=number < 0,
     )
+
+
+def bounds_cut(
+    bounds1: Tuple[float, float], bounds2: Tuple[float, float]
+) -> Tuple[float, float]:
+    return max(min(bounds1), min(bounds2)), min(max(bounds1), max(bounds2))