classiq 0.86.0__py3-none-any.whl → 0.87.0__py3-none-any.whl

classiq/interface/backend/backend_preferences.py

@@ -209,23 +209,6 @@ class AwsBackendPreferences(BackendPreferences):
     )
 
 
-class IBMBackendProvider(BaseModel):
-    """
-
-    Represents the provider specs for identifying an IBM Quantum backend.
-
-    Attributes:
-        hub (str): hub parameter of IBM Quantum provider. Defaults to `"ibm-q"`.
-        group (str): group parameter of IBM Quantum provider. Defaults to `"open"`.
-        project (str): project parameter of IBM Quantum provider. Defaults to `"main"`.
-
-    """
-
-    hub: str = "ibm-q"
-    group: str = "open"
-    project: str = "main"
-
-
 class IBMBackendPreferences(BackendPreferences):
     """
     Represents the backend preferences specific to IBM Quantum services.
@@ -234,30 +217,28 @@ class IBMBackendPreferences(BackendPreferences):
     specific to IBM Quantum backends.
 
     Attributes:
-        backend_service_provider (ProviderTypeVendor.IBM_QUANTUM): Indicates the backend service provider as IBM Quantum.
-        access_token (Optional[str]): The IBM Quantum access token to be used with IBM Quantum hosted backends. Defaults to `None`.
-        provider (IBMBackendProvider): Specifications for identifying a single IBM Quantum provider. Defaults to a new `IBMBackendProvider`.
-        qctrl_api_key (Optional[str]): QCTRL API key to access QCTRL optimization abilities.
+        backend_service_provider (ProviderTypeVendor.IBM_CLOUD): Indicates the backend service provider as IBM Cloud.
+        access_token (Optional[str]): 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.
         run_through_classiq (bool): Run through Classiq's credentials. Defaults to `False`.
 
     See examples in the [IBM Quantum Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/ibm-backends/?h=).
     """
 
-    backend_service_provider: ProviderTypeVendor.IBM_QUANTUM = pydantic.Field(
+    backend_service_provider: ProviderTypeVendor.IBM_CLOUD = pydantic.Field(
         default=ProviderVendor.IBM_QUANTUM
     )
     access_token: Optional[str] = pydantic.Field(
         default=None,
-        description="IBM Quantum access token to be used"
+        description="IBM Cloud access token to be used"
         " with IBM Quantum hosted backends",
     )
-    provider: IBMBackendProvider = pydantic.Field(
-        default_factory=IBMBackendProvider,
-        description="Provider specs. for identifying a single IBM Quantum provider.",
+    channel: Optional[str] = pydantic.Field(
+        default=None, description="Channel to use for IBM cloud backends."
     )
-    qctrl_api_key: Optional[str] = pydantic.Field(
-        default=None,
-        description="QCTRL API key to access QCTRL optimization abilities",
+    instance_crn: Optional[str] = pydantic.Field(
+        default=None, description="IBM Cloud instance CRN."
     )
     run_through_classiq: bool = pydantic.Field(
         default=False,
@@ -544,7 +525,6 @@ __all__ = [
     "ClassiqSimulatorBackendNames",
     "GCPBackendPreferences",
     "IBMBackendPreferences",
-    "IBMBackendProvider",
     "IQCCBackendPreferences",
     "IntelBackendNames",
     "IntelBackendPreferences",

classiq/interface/backend/quantum_backend_providers.py

@@ -26,7 +26,7 @@ class ProviderVendor(StrEnum):
 
 class ProviderTypeVendor:
     CLASSIQ = Literal[ProviderVendor.CLASSIQ]
-    IBM_QUANTUM = Literal[ProviderVendor.IBM_QUANTUM]
+    IBM_CLOUD = Literal[ProviderVendor.IBM_QUANTUM]
     AZURE_QUANTUM = Literal[ProviderVendor.AZURE_QUANTUM]
     AMAZON_BRAKET = Literal[ProviderVendor.AMAZON_BRAKET]
     IONQ = Literal[ProviderVendor.IONQ]
@@ -108,63 +108,74 @@ class AmazonBraketBackendNames(StrEnum):
 
 
 # The IBM devices were taken from:
-#   from qiskit.providers.fake_provider import FakeProvider
-#   provider = FakeProvider()
+#   from qiskit_ibm_runtime.fake_provider import FakeProviderForBackendV2
+#   provider = FakeProviderForBackendV2()
 #   backends_list = provider.backends()
-#   # Using _normalize_backend_name from `ibm_hardware_graphs.py`
-#   the_devices = [_normalize_backend_name(str(backend)) for backend in backends_list]
+#   the_devices = ["ibm_" + backend.name.split('_')[1] for backend in backends_list.backends()]
 class IBMQHardwareNames(StrEnum):
     """
     IBM backend names which Classiq Supports running on.
     """
 
-    ALMADEN = "Almaden"
-    ARMONK = "Armonk"
-    ATHENS = "Athens"
-    BELEM = "Belem"
-    BOEBLINGEN = "Boeblingen"
-    BOGOTA = "Bogota"
-    BROOKLYN = "Brooklyn"
-    BURLINGTON = "Burlington"
-    CAIRO = "Cairo"
-    CAMBRIDGE = "Cambridge"
-    # CAMBRIDGEALTERNATIVEBASIS = "CambridgeAlternativeBasis"
-    CASABLANCA = "Casablanca"
-    ESSEX = "Essex"
-    GUADALUPE = "Guadalupe"
-    HANOI = "Hanoi"
-    JAKARTA = "Jakarta"
-    JOHANNESBURG = "Johannesburg"
-    KOLKATA = "Kolkata"
-    LAGOS = "Lagos"
-    LIMA = "Lima"
-    LONDON = "London"
-    MANHATTAN = "Manhattan"
-    MANILA = "Manila"
-    MELBOURNE = "Melbourne"
-    MONTREAL = "Montreal"
-    MUMBAI = "Mumbai"
-    NAIROBI = "Nairobi"
-    OPENPULSE2Q = "OpenPulse_2Q"
-    OPENPULSE3Q = "OpenPulse_3Q"
-    OURENSE = "Ourense"
-    PARIS = "Paris"
-    POUGHKEEPSIE = "Poughkeepsie"
-    QASM_SIMULATOR = "qasm_simulator"
-    QUITO = "Quito"
-    ROCHESTER = "Rochester"
-    ROME = "Rome"
-    RUESCHLIKON = "Rueschlikon"
-    SANTIAGO = "Santiago"
-    SINGAPORE = "Singapore"
-    SYDNEY = "Sydney"
-    TENERIFE = "Tenerife"
-    TOKYO = "Tokyo"
-    TORONTO = "Toronto"
-    VALENCIA = "Valencia"
-    VIGO = "Vigo"
-    WASHINGTON = "Washington"
-    YORKTOWN = "Yorktown"
+    IBM_ALGIERS = "ibm_algiers"
+    IBM_ALMADEN = "ibm_almaden"
+    IBM_ARMONK = "ibm_armonk"
+    IBM_ATHENS = "ibm_athens"
+    IBM_AUCKLAND = "ibm_auckland"
+    IBM_BELEM = "ibm_belem"
+    IBM_BOEBLINGEN = "ibm_boeblingen"
+    IBM_BOGOTA = "ibm_bogota"
+    IBM_BRISBANE = "ibm_brisbane"
+    IBM_BROOKLYN = "ibm_brooklyn"
+    IBM_BURLINGTON = "ibm_burlington"
+    IBM_CAIRO = "ibm_cairo"
+    IBM_CAMBRIDGE = "ibm_cambridge"
+    IBM_CASABLANCA = "ibm_casablanca"
+    IBM_CUSCO = "ibm_cusco"
+    IBM_ESSEX = "ibm_essex"
+    IBM_FEZ = "ibm_fez"
+    IBM_FRACTIONAL = "ibm_fractional"
+    IBM_GENEVA = "ibm_geneva"
+    IBM_GUADALUPE = "ibm_guadalupe"
+    IBM_HANOI = "ibm_hanoi"
+    IBM_JAKARTA = "ibm_jakarta"
+    IBM_JOHANNESBURG = "ibm_johannesburg"
+    IBM_KAWASAKI = "ibm_kawasaki"
+    IBM_KOLKATA = "ibm_kolkata"
+    IBM_KYIV = "ibm_kyiv"
+    IBM_KYOTO = "ibm_kyoto"
+    IBM_LAGOS = "ibm_lagos"
+    IBM_LIMA = "ibm_lima"
+    IBM_LONDON = "ibm_london"
+    IBM_MANHATTAN = "ibm_manhattan"
+    IBM_MANILA = "ibm_manila"
+    IBM_MELBOURNE = "ibm_melbourne"
+    IBM_MARRAKESH = "ibm_marrakesh"
+    IBM_MONTREAL = "ibm_montreal"
+    IBM_MUMBAI = "ibm_mumbai"
+    IBM_NAIROBI = "ibm_nairobi"
+    IBM_OSAKA = "ibm_osaka"
+    IBM_OSLO = "ibm_oslo"
+    IBM_OURENSE = "ibm_ourense"
+    IBM_PARIS = "ibm_paris"
+    IBM_PEEKSKILL = "ibm_peekskill"
+    IBM_PERTH = "ibm_perth"
+    IBM_PRAGUE = "ibm_prague"
+    IBM_POUGHKEEPSIE = "ibm_poughkeepsie"
+    IBM_QUEBEC = "ibm_quebec"
+    IBM_QUITO = "ibm_quito"
+    IBM_ROCHESTER = "ibm_rochester"
+    IBM_ROME = "ibm_rome"
+    IBM_SANTIAGO = "ibm_santiago"
+    IBM_SHERBROOKE = "ibm_sherbrooke"
+    IBM_SINGAPORE = "ibm_singapore"
+    IBM_SYDNEY = "ibm_sydney"
+    IBM_TORINO = "ibm_torino"
+    IBM_TORONTO = "ibm_toronto"
+    IBM_VALENCIA = "ibm_valencia"
+    IBM_VIGO = "ibm_vigo"
+    IBM_WASHINGTON = "ibm_washington"
+    IBM_YORKTOWN = "ibm_yorktown"
 
 
 class ClassiqNvidiaBackendNames(StrEnum):

classiq/interface/generator/arith/binary_ops.py

@@ -36,6 +36,14 @@ from classiq.model_expansions.arithmetic import NumericAttributes
 from classiq.model_expansions.arithmetic_compute_result_attrs import (
     compute_result_attrs_add,
     compute_result_attrs_assign,
+    compute_result_attrs_bitwise_and,
+    compute_result_attrs_bitwise_or,
+    compute_result_attrs_bitwise_xor,
+    compute_result_attrs_lshift,
+    compute_result_attrs_modulo,
+    compute_result_attrs_multiply,
+    compute_result_attrs_power,
+    compute_result_attrs_rshift,
     compute_result_attrs_subtract,
 )
 
@@ -225,31 +233,6 @@ class BinaryOpWithIntInputs(BinaryOpParams[RegisterOrInt, RegisterOrInt]):
             raise ClassiqValueError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
         return self
 
-    @staticmethod
-    def _is_signed(arg: Union[int, RegisterArithmeticInfo]) -> bool:
-        if isinstance(arg, RegisterArithmeticInfo):
-            return arg.is_signed
-        return arg < 0
-
-    def _get_result_register(self) -> RegisterArithmeticInfo:
-        required_size = self._aligned_inputs_max_length()
-        is_signed = self._include_sign and (
-            self._is_signed(self.left_arg) or self._is_signed(self.right_arg)
-        )
-        return RegisterArithmeticInfo(
-            size=self.output_size or required_size, is_signed=is_signed
-        )
-
-    def _aligned_inputs_max_length(self) -> int:
-        left_signed: bool = argument_utils.is_signed(self.left_arg)
-        right_signed: bool = argument_utils.is_signed(self.right_arg)
-        return max(
-            argument_utils.integer_part_size(self.right_arg)
-            + int(left_signed and not right_signed),
-            argument_utils.integer_part_size(self.left_arg)
-            + int(right_signed and not left_signed),
-        )
-
 
 class BinaryOpWithFloatInputs(BinaryOpParams[RegisterOrConst, RegisterOrConst]):
     pass
@@ -258,10 +241,42 @@ class BinaryOpWithFloatInputs(BinaryOpParams[RegisterOrConst, RegisterOrConst]):
 class BitwiseAnd(BinaryOpWithIntInputs):
     output_name = "bitwise_and"
 
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        left_attrs = NumericAttributes.from_type_or_constant(
+            self.left_arg, self.machine_precision
+        )
+        right_attrs = NumericAttributes.from_type_or_constant(
+            self.right_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_bitwise_and(
+            left_attrs, right_attrs, self.machine_precision
+        )
+        return RegisterArithmeticInfo(
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+        )
+
 
 class BitwiseOr(BinaryOpWithIntInputs):
     output_name = "bitwise_or"
 
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        left_attrs = NumericAttributes.from_type_or_constant(
+            self.left_arg, self.machine_precision
+        )
+        right_attrs = NumericAttributes.from_type_or_constant(
+            self.right_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_bitwise_or(
+            left_attrs, right_attrs, self.machine_precision
+        )
+        return RegisterArithmeticInfo(
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+        )
+
 
 # TODO: fix diamond inheritance
 class BitwiseXor(
@@ -269,6 +284,22 @@ class BitwiseXor(
 ):
     output_name = "bitwise_xor"
 
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        left_attrs = NumericAttributes.from_type_or_constant(
+            self.left_arg, self.machine_precision
+        )
+        right_attrs = NumericAttributes.from_type_or_constant(
+            self.right_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_bitwise_xor(
+            left_attrs, right_attrs, self.machine_precision
+        )
+        return RegisterArithmeticInfo(
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+        )
+
 
 class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "sum"
@@ -467,29 +498,18 @@ class Multiplier(BinaryOpWithFloatInputs):
             argument_utils.limit_fraction_places(self.right_arg, self.machine_precision)
         )
 
-    @staticmethod
-    def _get_bounds(
-        args: tuple[RegisterOrConst, RegisterOrConst], machine_precision: int
-    ) -> tuple[float, float]:
-        extremal_values = [
-            left * right
-            for left in argument_utils.bounds(args[0])
-            for right in argument_utils.bounds(args[1])
-        ]
-        return (
-            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:
-        fraction_places = min(self.machine_precision, self.expected_fraction_places())
-        left_arg = argument_utils.limit_fraction_places(
+        left_attrs = NumericAttributes.from_type_or_constant(
             self.left_arg, self.machine_precision
         )
-        right_arg = argument_utils.limit_fraction_places(
+        right_attrs = NumericAttributes.from_type_or_constant(
             self.right_arg, self.machine_precision
         )
-        bounds = self._get_bounds((left_arg, right_arg), self.machine_precision)
+        result_attrs = compute_result_attrs_multiply(
+            left_attrs, right_attrs, self.machine_precision
+        )
+        fraction_places = result_attrs.fraction_digits
+        bounds = result_attrs.bounds
         if self.output_size:
             if fraction_places:
                 raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
@@ -498,10 +518,8 @@ class Multiplier(BinaryOpWithFloatInputs):
             )
             bounds = number_utils.bounds_cut(bounds, max_bounds)
 
-        size = self.output_size or self._get_output_size(
-            bounds, fraction_places, left_arg, right_arg
-        )
-        is_signed = self._include_sign and min(bounds) < 0
+        size = self.output_size or result_attrs.size
+        is_signed = self._include_sign and result_attrs.is_signed
         return RegisterArithmeticInfo(
             size=size,
             fraction_places=fraction_places,
@@ -514,25 +532,6 @@ class Multiplier(BinaryOpWithFloatInputs):
             ),
         )
 
-    @staticmethod
-    def _get_output_size(
-        bounds: tuple[float, float],
-        fraction_places: int,
-        left_arg: Union[RegisterArithmeticInfo, float],
-        right_arg: Union[RegisterArithmeticInfo, float],
-    ) -> int:
-        if isinstance(left_arg, float) and left_arg == 1.0:
-            assert isinstance(right_arg, RegisterArithmeticInfo)
-            return right_arg.size
-        elif isinstance(right_arg, float) and right_arg == 1.0:
-            assert isinstance(left_arg, RegisterArithmeticInfo)
-            return left_arg.size
-        if bounds[0] == 0 and bounds[1] == 0:
-            return max(1, fraction_places)
-
-        integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
-        return integer_part_size + fraction_places
-
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         return max(
             0, self.expected_fraction_places() - self.result_register.fraction_places
@@ -592,43 +591,22 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
             * self.right_arg
         )
 
-    def _get_result_bounds(self) -> tuple[float, float]:
-        bounds = [
-            number_utils.limit_fraction_places(
-                bound, machine_precision=self.machine_precision
-            )
-            for bound in self.left_arg.bounds
-        ]
-        if (self.right_arg % 2) or min(bounds) >= 0 or max(bounds) <= 0:
-            return (
-                number_utils.limit_fraction_places(
-                    bounds[0] ** self.right_arg,
-                    machine_precision=self.machine_precision,
-                ),
-                number_utils.limit_fraction_places(
-                    bounds[1] ** self.right_arg,
-                    machine_precision=self.machine_precision,
-                ),
-            )
-        return 0.0, number_utils.limit_fraction_places(
-            max(abs(bound) for bound in bounds) ** self.right_arg,
-            machine_precision=self.machine_precision,
-        )
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
         if self.output_size:
             return RegisterArithmeticInfo(size=self.output_size)
 
-        fraction_places = min(self.machine_precision, self.expected_fraction_places())
-        bounds = self._get_result_bounds()
-        size = number_utils.bounds_to_integer_part_size(*bounds) + fraction_places
-        if bounds[0] == 0 and bounds[1] == 0:
-            size = max(1, fraction_places)
+        left_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.left_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_power(
+            left_attrs, self.right_arg, self.machine_precision
+        )
+
         return RegisterArithmeticInfo(
-            size=size,
-            is_signed=self.left_arg.is_signed and (self.right_arg % 2 == 1),
-            fraction_places=fraction_places,
-            bounds=bounds,
+            size=result_attrs.size,
+            is_signed=result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+            bounds=result_attrs.bounds,
         )
 
     def _get_inner_action_garbage_size(
@@ -709,13 +687,17 @@ class LShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
         return max(self.left_arg.size + extra_result_lsbs - self.output_size, 0)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        new_fraction_places = max(self.left_arg.fraction_places - self.right_arg, 0)
-        new_integer_part_size = self.left_arg.integer_part_size + self.right_arg
-        required_size = new_integer_part_size + new_fraction_places
+        left_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.left_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_lshift(
+            left_attrs, self.right_arg, self.machine_precision
+        )
         return RegisterArithmeticInfo(
-            size=self.output_size or required_size,
-            is_signed=self._include_sign and self.left_arg.is_signed,
-            fraction_places=new_fraction_places,
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+            bounds=result_attrs.bounds if not self.output_size else None,
         )
 
 
@@ -755,15 +737,17 @@ class RShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        min_size: int = max(self.left_arg.size - self.right_arg, 1)
-        new_fraction_places = self._shifted_fraction_places(
-            arg=self.left_arg, shift=self.right_arg
+        left_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.left_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_rshift(
+            left_attrs, self.right_arg, self.machine_precision
         )
-        required_size = max(min_size, new_fraction_places)
         return RegisterArithmeticInfo(
-            size=self.output_size or required_size,
-            is_signed=self._include_sign and self.left_arg.is_signed,
-            fraction_places=new_fraction_places,
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+            bounds=result_attrs.bounds if not self.output_size else None,
         )
 
 
@@ -822,7 +806,15 @@ class Modulo(EffectiveUnaryOpParams[int]):
         return 2 ** (repr_qubits)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        size = round(math.log2(self.right_arg))
-        if size <= 0:
-            raise ClassiqValueError("Cannot use a quantum expression with zero size")
-        return RegisterArithmeticInfo(size=size, is_signed=False, fraction_places=0)
+        left_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.left_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_modulo(
+            left_attrs, self.right_arg, self.machine_precision
+        )
+        return RegisterArithmeticInfo(
+            size=result_attrs.size,
+            is_signed=result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+            bounds=result_attrs.bounds,
+        )

classiq/interface/generator/arith/extremum_operations.py

@@ -18,6 +18,12 @@ from classiq.interface.generator.arith.binary_ops import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_max,
+    compute_result_attrs_min,
+)
+
 Numeric = (float, int)
 
 
@@ -55,11 +61,6 @@ class Extremum(ArithmeticOperationParams):
     def get_params_inplace_options(self) -> Iterable["Extremum"]:
         return ()
 
-    @classmethod
-    @abc.abstractmethod
-    def _bound_calculator(cls, arg1: float, arg2: float) -> float:
-        pass
-
     @staticmethod
     def _less_qubits_arg(
         arg1: RegisterOrConst, arg2: RegisterOrConst
@@ -78,40 +79,15 @@ class Extremum(ArithmeticOperationParams):
         pass
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        eff_left_arg = argument_utils.limit_fraction_places(
+        left_attrs = NumericAttributes.from_type_or_constant(
             self.left_arg, self.machine_precision
         )
-        eff_right_arg = argument_utils.limit_fraction_places(
+        right_attrs = NumericAttributes.from_type_or_constant(
             self.right_arg, self.machine_precision
         )
-        if argument_utils.arg_bounds_overlap((eff_left_arg, eff_right_arg)):
-            return self._get_general_case_result_register(eff_left_arg, eff_right_arg)
-        return argument_utils.as_arithmetic_info(
-            self.preferred_arg(eff_left_arg, eff_right_arg)
-        )
-
-    def _get_general_case_result_register(
-        self, eff_left_arg: RegisterOrConst, eff_right_arg: RegisterOrConst
-    ) -> RegisterArithmeticInfo:
-        integer_part_size = max(
-            argument_utils.integer_part_size(eff_left_arg),
-            argument_utils.integer_part_size(eff_right_arg),
-        )
-        fraction_places = max(
-            argument_utils.fraction_places(eff_left_arg),
-            argument_utils.fraction_places(eff_right_arg),
-        )
-        required_size = integer_part_size + fraction_places
-        bounds = (
-            self._bound_calculator(
-                argument_utils.lower_bound(eff_left_arg),
-                argument_utils.lower_bound(eff_right_arg),
-            ),
-            self._bound_calculator(
-                argument_utils.upper_bound(eff_left_arg),
-                argument_utils.upper_bound(eff_right_arg),
-            ),
-        )
+        result_attrs = self._compute_result_attrs(left_attrs, right_attrs)
+        bounds = result_attrs.bounds
+        fraction_places = result_attrs.fraction_digits
         if self.output_size:
             if fraction_places:
                 raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
@@ -119,8 +95,8 @@ class Extremum(ArithmeticOperationParams):
                 size=self.output_size, is_signed=False, fraction_places=0
             )
             bounds = number_utils.bounds_cut(bounds, max_bounds)
-        size = self.output_size or required_size
-        is_signed = self._include_sign and min(bounds) < 0
+        size = self.output_size or result_attrs.size
+        is_signed = self._include_sign and result_attrs.is_signed
         return RegisterArithmeticInfo(
             size=size,
             fraction_places=fraction_places,
@@ -133,14 +109,16 @@ class Extremum(ArithmeticOperationParams):
             ),
         )
 
+    @abc.abstractmethod
+    def _compute_result_attrs(
+        self, left_attrs: NumericAttributes, right_attrs: NumericAttributes
+    ) -> NumericAttributes:
+        pass
+
 
 class Min(Extremum):
     output_name = "min_value"
 
-    @classmethod
-    def _bound_calculator(cls, arg1: float, arg2: float) -> float:
-        return min(arg1, arg2)
-
     @classmethod
     def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
@@ -152,14 +130,17 @@ class Min(Extremum):
             return arg2
         return cls._less_qubits_arg(arg1, arg2)
 
+    def _compute_result_attrs(
+        self, left_attrs: NumericAttributes, right_attrs: NumericAttributes
+    ) -> NumericAttributes:
+        return compute_result_attrs_min(
+            [left_attrs, right_attrs], self.machine_precision
+        )
+
 
 class Max(Extremum):
     output_name = "max_value"
 
-    @classmethod
-    def _bound_calculator(cls, arg1: float, arg2: float) -> float:
-        return max(arg1, arg2)
-
     @classmethod
     def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
@@ -170,3 +151,10 @@ class Max(Extremum):
         if max2 > max1:
             return arg2
         return cls._less_qubits_arg(arg1, arg2)
+
+    def _compute_result_attrs(
+        self, left_attrs: NumericAttributes, right_attrs: NumericAttributes
+    ) -> NumericAttributes:
+        return compute_result_attrs_max(
+            [left_attrs, right_attrs], self.machine_precision
+        )

classiq/interface/generator/arith/number_utils.py

@@ -105,7 +105,10 @@ def bounds_to_attributes(
     lb: float, ub: float, fraction_places: int, machine_precision: int
 ) -> tuple[int, bool, int]:
     fraction_places = min(fraction_places, machine_precision)
-    integers = bounds_to_integer_part_size(lb, ub)
+    if lb == ub == 0:
+        integers = 0
+    else:
+        integers = bounds_to_integer_part_size(lb, ub)
     return max(1, integers + fraction_places), lb < 0, fraction_places