classiq 0.43.3__py3-none-any.whl → 0.45.0__py3-none-any.whl

classiq/interface/generator/application_apis/finance_declarations.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import TYPE_CHECKING, Callable, Mapping
+from typing import Mapping
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_function_declaration import (
@@ -10,21 +10,20 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
     Real,
-    Struct,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import Struct
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
-if TYPE_CHECKING:
-    from classiq.qmod.builtins.structs import GaussianModel
-    from classiq.qmod.symbolic_expr import SymbolicExpr
-
 FUNCTION_PORT_NAME = "func_port"
 OBJECTIVE_PORT_NAME = "obj_port"
 
@@ -40,44 +39,30 @@ FINANCE_FUNCTION_PORT_SIZE_MAPPING: Mapping[FinanceModelType, str] = {
 }
 
 
-def _get_gaussian_size(finance_model: "GaussianModel") -> "SymbolicExpr":
-    from classiq.qmod.symbolic import floor, log, sum as sym_sum
-
-    return (
-        finance_model.num_qubits
-        + finance_model.rhos.len
-        + floor(log(sym_sum(finance_model.loss), 2))
-        + 1
-    )
-
-
-FINANCE_FUNCTION_PORT_SIZE_FUNCTION_MAPPING: Mapping[FinanceModelType, Callable] = {
-    FinanceModelType.Gaussian: _get_gaussian_size,
-    FinanceModelType.LogNormal: lambda finance_model: finance_model.num_qubits,
-}
-
-
 def _generate_finance_function(
     finance_model: FinanceModelType,
-) -> QuantumFunctionDeclaration:
-    return QuantumFunctionDeclaration(
+) -> NamedParamsQuantumFunctionDeclaration:
+    return NamedParamsQuantumFunctionDeclaration(
         name=f"{finance_model.value}_finance",
-        param_decls={
-            "finance_model": Struct(name=f"{finance_model.name}Model"),
-            "finance_function": Struct(name="FinanceFunction"),
-        },
-        port_declarations={
-            FUNCTION_PORT_NAME: PortDeclaration(
+        positional_arg_declarations=[
+            ClassicalParameterDeclaration(
+                name="finance_model",
+                classical_type=Struct(name=f"{finance_model.name}Model"),
+            ),
+            ClassicalParameterDeclaration(
+                name="finance_function", classical_type=Struct(name="FinanceFunction")
+            ),
+            PortDeclaration(
                 name=FUNCTION_PORT_NAME,
                 direction=PortDeclarationDirection.Inout,
                 size=Expression(expr=FINANCE_FUNCTION_PORT_SIZE_MAPPING[finance_model]),
             ),
-            OBJECTIVE_PORT_NAME: PortDeclaration(
+            PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
                 direction=PortDeclarationDirection.Inout,
                 size=Expression(expr="1"),
             ),
-        },
+        ],
     )
 
 
@@ -118,21 +103,29 @@ FINANCE_FUNCTION = StructDeclaration(
 
 LOG_NORMAL_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
     name="log_normal_finance_post_process",
-    param_decls={
-        "finance_model": Struct(name="LogNormalModel"),
-        "estimation_method": Struct(name="FinanceFunction"),
-        "probability": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="finance_model", classical_type=Struct(name="LogNormalModel")
+        ),
+        ClassicalParameterDeclaration(
+            name="estimation_method", classical_type=Struct(name="FinanceFunction")
+        ),
+        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
+    ],
     return_type=Real(),
 )
 
 GAUSSIAN_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
     name="gaussian_finance_post_process",
-    param_decls={
-        "finance_model": Struct(name="GaussianModel"),
-        "estimation_method": Struct(name="FinanceFunction"),
-        "probability": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="finance_model", classical_type=Struct(name="GaussianModel")
+        ),
+        ClassicalParameterDeclaration(
+            name="estimation_method", classical_type=Struct(name="FinanceFunction")
+        ),
+        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
+    ],
     return_type=Real(),
 )
 

classiq/interface/generator/application_apis/qsvm_declarations.py

@@ -3,18 +3,20 @@ import enum
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
-    Enum,
     Integer,
     Real,
-    Struct,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import Enum, Struct
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
 
@@ -24,29 +26,33 @@ class FeatureMapType(enum.Enum):
 
 
 QSVM_PAULI_FEATURE_MAP_SIZE = "get_field(feature_map, 'feature_dimension')"
-QSVM_PAULI_FEATURE_MAP = QuantumFunctionDeclaration(
+QSVM_PAULI_FEATURE_MAP = NamedParamsQuantumFunctionDeclaration(
     name="pauli_feature_map",
-    param_decls={"feature_map": Struct(name="QSVMFeatureMapPauli")},
-    port_declarations={
-        "qbv": PortDeclaration(
+    positional_arg_declarations=[
+        ClassicalParameterDeclaration(
+            name="feature_map", classical_type=Struct(name="QSVMFeatureMapPauli")
+        ),
+        PortDeclaration(
             name="qbv",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr=QSVM_PAULI_FEATURE_MAP_SIZE),
-        )
-    },
+        ),
+    ],
 )
 
 QSVM_BLOCH_SPHERE_FEATURE_MAP_SIZE = "ceiling(feature_dimension/2)"
-QSVM_BLOCH_SPHERE_FEATURE_MAP = QuantumFunctionDeclaration(
+QSVM_BLOCH_SPHERE_FEATURE_MAP = NamedParamsQuantumFunctionDeclaration(
     name="bloch_sphere_feature_map",
-    param_decls={"feature_dimension": Integer()},
-    port_declarations={
-        "qbv": PortDeclaration(
+    positional_arg_declarations=[
+        ClassicalParameterDeclaration(
+            name="feature_dimension", classical_type=Integer()
+        ),
+        PortDeclaration(
             name="qbv",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr=QSVM_BLOCH_SPHERE_FEATURE_MAP_SIZE),
-        )
-    },
+        ),
+    ],
 )
 
 QSVM_FEATURE_MAP_PAULI = StructDeclaration(

classiq/interface/generator/arith/arithmetic.py

@@ -1,8 +1,9 @@
-from typing import Any, Dict, Optional, Set
+from typing import Any, Dict, Final, Optional, Set
 
 import networkx as nx
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import arithmetic_expression_parser
 from classiq.interface.generator.arith.arithmetic_expression_abc import (
     ArithmeticExpressionABC,
@@ -21,10 +22,9 @@ from classiq.interface.model.quantum_type import (
     register_info_to_quantum_type,
 )
 
-from classiq.exceptions import ClassiqValueError
-
-ARITHMETIC_EXPRESSION_TARGET_NAME: str = "arithmetic_target"
-ARITHMETIC_EXPRESSION_RESULT_NAME: str = "expression_result"
+ARITHMETIC_EXPRESSION_TARGET_NAME: Final[str] = "arithmetic_target"
+ARITHMETIC_EXPRESSION_RESULT_NAME: Final[str] = "expression_result"
+ARITHMETIC_EXPRESSION_GARBAGE_NAME: Final[str] = "expression_garbage"
 
 
 class Arithmetic(ArithmeticExpressionABC):
@@ -64,12 +64,14 @@ class Arithmetic(ArithmeticExpressionABC):
             if name in self._inputs
         }
         # TODO: avoid calling the result builder again, as it is called in validation
-        result_info = ArithmeticResultBuilder(
+        result_builder = ArithmeticResultBuilder(
             graph=arithmetic_expression_parser.parse_expression(self.expression),
             definitions=self.definitions,
             machine_precision=self.machine_precision,
-        ).result
-        self._outputs[ARITHMETIC_EXPRESSION_RESULT_NAME] = result_info
+        )
+        self._outputs[ARITHMETIC_EXPRESSION_RESULT_NAME] = result_builder.result
+        if result_builder.garbage:
+            self._outputs[ARITHMETIC_EXPRESSION_GARBAGE_NAME] = result_builder.garbage
         if self.target:
             self._inputs[ARITHMETIC_EXPRESSION_TARGET_NAME] = self.target
 

classiq/interface/generator/arith/arithmetic_arg_type_validator.py

@@ -2,11 +2,10 @@ from typing import Callable, Dict, List
 
 from typing_extensions import TypeAlias
 
+from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith import argument_utils
 from classiq.interface.generator.arith.binary_ops import BOOLEAN_OP_WITH_FRACTIONS_ERROR
 
-from classiq.exceptions import ClassiqArithmeticError
-
 ArgTypeValidator: TypeAlias = Callable[[List[argument_utils.RegisterOrConst]], None]
 
 

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -7,6 +7,7 @@ import networkx as nx
 import pydantic
 from typing_extensions import TypeAlias
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     parse_expression,
@@ -30,8 +31,6 @@ from classiq.interface.generator.expressions.expression_constants import (
 from classiq.interface.generator.function_params import FunctionParams
 from classiq.interface.helpers.custom_pydantic_types import PydanticExpressionStr
 
-from classiq.exceptions import ClassiqValueError
-
 ValidDefinitions: TypeAlias = Union[
     pydantic.StrictInt, pydantic.StrictFloat, RegisterArithmeticInfo
 ]
@@ -88,7 +87,27 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         cls._validate_ast_obj(ast_obj)
 
         graph = parse_expression(expression)
-        cls._validate_expression_graph(graph, values)
+        try:
+            cls._validate_expression_graph(graph, values)
+        except ClassiqValueError as e:
+            # This flow was created specifically for inplace Boolean XOR operations like q1 ^ q2.
+            # We can't plug equality in previous stages due to SymPy restrictions.
+            # Note that we don't validate that the expression itself is Boolean (passing non-Boolean expressions
+            # as inplace is currently not supported, so it's a bug).
+            if not e.raw_message == "Expression does not support target assignment":
+                raise
+            ast_parsed_expression = ast.parse(expression)
+            ast_expr = ast_parsed_expression.body[0]
+            if (
+                not isinstance(ast_expr, ast.Expr)
+                or not isinstance(ast_expr.value, ast.BinOp)
+                or not isinstance(ast_expr.value.op, ast.BitXor)
+            ):
+                raise
+            expression = f"({expression}) == 1"
+            graph = parse_expression(expression)
+            cls._validate_expression_graph(graph, values)
+
         validate_arithmetic_result_type(
             graph=graph,
             definitions=definitions,

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -4,6 +4,7 @@ from typing import Collection, List, Optional, Set, Tuple, Type, Union, cast
 
 import networkx as nx
 
+from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_EXPRESSION_TYPE,
     DEFAULT_SUPPORTED_FUNC_NAMES,
@@ -16,11 +17,9 @@ from classiq.interface.generator.arith.ast_node_rewrite import (
     AstNodeRewrite,
 )
 
-from classiq.exceptions import ClassiqArithmeticError
-
-_MULTIPLE_RESULTS_ERROR_MESSAGE: str = "Expression cannot contain multiple result"
+_MULTIPLE_RESULTS_ERROR_MESSAGE: str = "Expression cannot contain multiple results"
 _UNEXPECTED_ARITHMETIC_ERROR_MESSAGE: str = (
-    "Unexpected arithmetic error: trivial expression. Please contact support."
+    "Quantum expressions that evaluate to a classical value are not supported"
 )
 _ALLOWED_MULTI_ARGUMENT_FUNCTIONS = ("min", "max")
 Node = Union[str, float, int]

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -5,13 +5,12 @@ from typing import Any, Dict, Optional, Set, Tuple, Type, Union
 
 from typing_extensions import TypeAlias, get_args
 
+from classiq.interface.exceptions import ClassiqArithmeticError, ClassiqValueError
 from classiq.interface.generator.arith.ast_node_rewrite import AstNodeRewrite
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
 
-from classiq.exceptions import ClassiqArithmeticError, ClassiqValueError
-
 DEFAULT_SUPPORTED_FUNC_NAMES: Set[str] = {"CLShift", "CRShift", "min", "max"}
 
 DEFAULT_EXPRESSION_TYPE = "arithmetic"

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -1,5 +1,6 @@
 from typing import Callable, Dict, FrozenSet, List, Optional
 
+from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith.argument_utils import (
     RegisterOrConst as RegisterOrFloat,
 )
@@ -35,8 +36,6 @@ from classiq.interface.generator.arith.logical_ops import LogicalAnd, LogicalOr
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation
 
-from classiq.exceptions import ClassiqArithmeticError
-
 ParamsGetter = Callable[..., ArithmeticOperationParams]  # Argument vary
 
 _TARGET_ERROR_MESSAGE: str = "Target unavailable for the requested operation"

classiq/interface/generator/arith/arithmetic_result_builder.py

@@ -1,14 +1,13 @@
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 import networkx as nx
 
+from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith import arithmetic_param_getters, number_utils
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.ast_node_rewrite import OUTPUT_SIZE
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
-from classiq.exceptions import ClassiqArithmeticError
-
 ArithmeticDefinitions = Dict[str, RegisterOrConst]
 
 
@@ -20,7 +19,7 @@ class ArithmeticResultBuilder:
         definitions: ArithmeticDefinitions,
         machine_precision: int,
     ) -> None:
-        self.result = self._fill_operation_results(
+        self.result, self.garbage = self._fill_operation_results(
             graph=graph,
             result_definitions=definitions,
             machine_precision=machine_precision,
@@ -62,7 +61,7 @@ class ArithmeticResultBuilder:
         graph: nx.DiGraph,
         result_definitions: ArithmeticDefinitions,
         machine_precision: int,
-    ) -> RegisterArithmeticInfo:
+    ) -> Tuple[RegisterArithmeticInfo, Optional[RegisterArithmeticInfo]]:
         inputs_node_set: Set[str] = {
             vertex for vertex, deg in graph.in_degree if deg == 0
         }
@@ -80,29 +79,34 @@ class ArithmeticResultBuilder:
                 for predecessor_node in graph.predecessors(node)
             ]
             if graph.out_degree(node) == 0:
-                return cls._get_node_result(
+                return cls._get_node_result_and_garbage(
                     graph, args, node, machine_precision=machine_precision
                 )
-            node_results[node] = cls._get_node_result(
+            node_results[node], _ = cls._get_node_result_and_garbage(
                 graph, args, node, machine_precision=machine_precision
             )
         raise ClassiqArithmeticError("Expression has no result")
 
     @classmethod
-    def _get_node_result(
+    def _get_node_result_and_garbage(
         cls,
         graph: nx.DiGraph,
         args: List[RegisterOrConst],
         node: str,
         *,
         machine_precision: int,
-    ) -> RegisterArithmeticInfo:
-        return arithmetic_param_getters.get_params(
+    ) -> Tuple[RegisterArithmeticInfo, Optional[RegisterArithmeticInfo]]:
+        node_params = arithmetic_param_getters.get_params(
             node_id=node,
             args=args,
             output_size=graph.nodes[node].get(OUTPUT_SIZE, None),
             machine_precision=machine_precision,
-        ).result_register
+        )
+
+        return (
+            node_params.outputs[node_params.output_name],
+            node_params.outputs.get(node_params.garbage_output_name),
+        )
 
     @staticmethod
     def _convert_int_to_float_str(node: Any) -> str:

classiq/interface/generator/arith/ast_node_rewrite.py

@@ -2,7 +2,7 @@ import ast
 import itertools
 from typing import Any, Iterator, Optional, Union, cast
 
-from classiq.exceptions import ClassiqArithmeticError
+from classiq.interface.exceptions import ClassiqArithmeticError
 
 SEPARATOR: str = "_"
 OUTPUT_SIZE: str = "output_size"

classiq/interface/generator/arith/binary_ops.py

@@ -16,6 +16,8 @@ from typing import (
 import pydantic
 from pydantic.generics import GenericModel
 
+from classiq.interface.enum_utils import StrEnum
+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 (
@@ -28,9 +30,6 @@ from classiq.interface.generator.arith.register_user_input import RegisterArithm
 from classiq.interface.generator.arith.unary_ops import Negation
 from classiq.interface.generator.function_params import get_zero_input_name
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 LeftDataT = TypeVar("LeftDataT")
 RightDataT = TypeVar("RightDataT")
 _NumericArgumentInplaceErrorMessage: str = "Cannot inplace the numeric argument {}"
@@ -617,7 +616,7 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
         *,
         arg: RegisterArithmeticInfo,
         action_right_arg: RegisterOrConst,
-        compute_power: int
+        compute_power: int,
     ) -> pydantic.NonNegativeInt:
         inner_compute_power_params = Power(
             left_arg=arg,
@@ -800,6 +799,7 @@ class Modulo(EffectiveUnaryOpParams[int]):
         return 2 ** (repr_qubits)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        return RegisterArithmeticInfo(
-            size=round(math.log2(self.right_arg)), is_signed=False, fraction_places=0
-        )
+        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)

classiq/interface/generator/arith/endianness.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class Endianness(StrEnum):

classiq/interface/generator/arith/extremum_operations.py

@@ -3,6 +3,7 @@ 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.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.arithmetic_operations import (
@@ -15,8 +16,6 @@ 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.exceptions import ClassiqValueError
-
 Numeric = (float, int)
 
 
@@ -57,38 +56,56 @@ class Extremum(ArithmeticOperationParams):
     def _bound_calculator(cls, arg1: float, arg2: float) -> float:
         pass
 
+    @staticmethod
+    def _less_qubits_arg(
+        arg1: RegisterOrConst, arg2: RegisterOrConst
+    ) -> RegisterOrConst:
+        if not isinstance(arg1, RegisterArithmeticInfo):
+            return arg1
+        if not isinstance(arg2, RegisterArithmeticInfo):
+            return arg2
+        return arg1 if arg1.size <= arg2.size else arg2
+
     @classmethod
     @abc.abstractmethod
-    def _preferred_arg(
+    def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
     ) -> RegisterOrConst:
         pass
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        if argument_utils.arg_bounds_overlap((self.left_arg, self.right_arg)):
-            return self._get_general_case_result_register()
+        eff_left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, self.machine_precision
+        )
+        eff_right_arg = argument_utils.limit_fraction_places(
+            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(self.left_arg, self.right_arg)
+            self.preferred_arg(eff_left_arg, eff_right_arg)
         )
 
-    def _get_general_case_result_register(self) -> RegisterArithmeticInfo:
+    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(self.left_arg),
-            argument_utils.integer_part_size(self.right_arg),
+            argument_utils.integer_part_size(eff_left_arg),
+            argument_utils.integer_part_size(eff_right_arg),
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            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(self.left_arg),
-                argument_utils.lower_bound(self.right_arg),
+                argument_utils.lower_bound(eff_left_arg),
+                argument_utils.lower_bound(eff_right_arg),
             ),
             self._bound_calculator(
-                argument_utils.upper_bound(self.left_arg),
-                argument_utils.upper_bound(self.right_arg),
+                argument_utils.upper_bound(eff_left_arg),
+                argument_utils.upper_bound(eff_right_arg),
             ),
         )
         return RegisterArithmeticInfo(
@@ -107,12 +124,15 @@ class Min(Extremum):
         return min(arg1, arg2)
 
     @classmethod
-    def _preferred_arg(
+    def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
     ) -> RegisterOrConst:
-        if min(argument_utils.bounds(arg1)) < min(argument_utils.bounds(arg2)):
+        min1, min2 = min(argument_utils.bounds(arg1)), min(argument_utils.bounds(arg2))
+        if min1 < min2:
             return arg1
-        return arg2
+        if min2 < min1:
+            return arg2
+        return cls._less_qubits_arg(arg1, arg2)
 
 
 class Max(Extremum):
@@ -123,9 +143,12 @@ class Max(Extremum):
         return max(arg1, arg2)
 
     @classmethod
-    def _preferred_arg(
+    def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
     ) -> RegisterOrConst:
-        if max(argument_utils.bounds(arg1)) > max(argument_utils.bounds(arg2)):
+        max1, max2 = max(argument_utils.bounds(arg1)), max(argument_utils.bounds(arg2))
+        if max1 > max2:
             return arg1
-        return arg2
+        if max2 > max1:
+            return arg2
+        return cls._less_qubits_arg(arg1, arg2)

classiq/interface/generator/arith/logical_ops.py

@@ -2,6 +2,7 @@ from typing import Iterable, List, Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.arithmetic_operations import (
     ArithmeticOperationParams,
@@ -9,8 +10,6 @@ from classiq.interface.generator.arith.arithmetic_operations import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
-from classiq.exceptions import ClassiqValueError
-
 
 def get_arg_name(idx: int) -> str:
     return f"arg_{idx}"

classiq/interface/generator/arith/register_user_input.py

@@ -2,14 +2,13 @@ from typing import Any, Dict, Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 
 class RegisterArithmeticInfo(HashablePydanticBaseModel):
     size: pydantic.PositiveInt

classiq/interface/generator/arith/unary_ops.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Final, Iterable, Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.arithmetic_operations import (
     ArithmeticOperationParams,
@@ -9,8 +10,6 @@ from classiq.interface.generator.arith.arithmetic_operations import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
-from classiq.exceptions import ClassiqValueError
-
 UNARY_ARG_NAME: Final[str] = "arg"