classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/{applications_model_constructors → applications/chemistry}/chemistry_model_constructor.py

@@ -1,18 +1,27 @@
 # flake8: noqa
 
-from typing import Dict, List, Mapping, Optional, Type
+from typing import Optional, cast
+from collections.abc import Mapping
 
 from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
     SummedFermionicOperator,
 )
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.qmod.builtins.structs import (
+    MoleculeProblem as QmodMoleculeProblem,
+    Molecule as QmodMolecule,
+    ChemistryAtom as QmodChemistryAtom,
+    Position as QmodPosition,
+)
 from classiq.interface.chemistry.ground_state_problem import (
     CHEMISTRY_PROBLEMS_TYPE,
     HamiltonianProblem,
     MoleculeProblem,
 )
 from classiq.interface.chemistry.molecule import Atom
-from classiq.interface.generator.expressions.enums.chemistry import (
+from classiq.qmod.builtins.enums import (
     Element,
     FermionMapping,
 )
@@ -20,20 +29,20 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.function_params import IOName
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
-    ClassicalType,
     Real,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
-    QuantumLambdaFunction,
-)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 
 from classiq.applications.chemistry.ansatz_parameters import (
     AnsatzParameters,
@@ -44,19 +53,21 @@ from classiq.applications.chemistry.ansatz_parameters import (
 from classiq.applications.chemistry.chemistry_execution_parameters import (
     ChemistryExecutionParameters,
 )
-from classiq.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqError
+from classiq.qmod.utilities import qmod_val_to_expr_str
+from classiq.open_library.functions.hea import full_hea
 
-_LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: Dict[str, str] = {
+_LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {
     "+": "PLUS",
     "-": "MINUS",
 }
 
-_CHEMISTRY_PROBLEM_PREFIX_MAPPING: Dict[Type[CHEMISTRY_PROBLEMS_TYPE], str] = {
+_CHEMISTRY_PROBLEM_PREFIX_MAPPING: dict[type[CHEMISTRY_PROBLEMS_TYPE], str] = {
     MoleculeProblem: "molecule",
     HamiltonianProblem: "fock_hamiltonian",
 }
 
-_ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING: Dict[Type[AnsatzParameters], str] = {
+_ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING: dict[type[AnsatzParameters], str] = {
     UCCParameters: "ucc",
     HVAParameters: "hva",
 }
@@ -64,180 +75,158 @@ _ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING: Dict[Type[AnsatzParameters], str] = {
 _EXECUTION_RESULT = "vqe_result"
 _MOLECULE_PROBLEM_RESULT = "molecule_result"
 
-_HAE_GATE_MAPPING: Dict[str, QuantumFunctionCall] = {
+_HAE_GATE_MAPPING: dict[str, QuantumFunctionCall] = {
     "h": QuantumFunctionCall(
         function="H",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "x": QuantumFunctionCall(
         function="X",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "y": QuantumFunctionCall(
         function="Y",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "z": QuantumFunctionCall(
         function="Z",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "i": QuantumFunctionCall(
         function="I",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "s": QuantumFunctionCall(
         function="S",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "t": QuantumFunctionCall(
         function="T",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "sdg": QuantumFunctionCall(
         function="SDG",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "tdg": QuantumFunctionCall(
         function="TDG",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "p": QuantumFunctionCall(
         function="PHASE",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "rx": QuantumFunctionCall(
         function="RX",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "ry": QuantumFunctionCall(
         function="RY",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "rz": QuantumFunctionCall(
         function="RZ",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "rxx": QuantumFunctionCall(
         function="RXX",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "ryy": QuantumFunctionCall(
         function="RYY",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "rzz": QuantumFunctionCall(
         function="RZZ",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "ch": QuantumFunctionCall(
         function="CH",
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
     "cx": QuantumFunctionCall(
         function="CX",
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
     "cy": QuantumFunctionCall(
         function="CY",
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
     "cz": QuantumFunctionCall(
         function="CZ",
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
     "crx": QuantumFunctionCall(
         function="CRX",
-        params={"theta": Expression(expr="angle")},
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[
+            Expression(expr="angle"),
+            HandleBinding(name="q1"),
+            HandleBinding(name="q2"),
+        ],
     ),
     "cry": QuantumFunctionCall(
         function="CRY",
-        params={"theta": Expression(expr="angle")},
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[
+            Expression(expr="angle"),
+            HandleBinding(name="q1"),
+            HandleBinding(name="q2"),
+        ],
     ),
     "crz": QuantumFunctionCall(
         function="CRZ",
-        params={"theta": Expression(expr="angle")},
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[
+            Expression(expr="angle"),
+            HandleBinding(name="q1"),
+            HandleBinding(name="q2"),
+        ],
     ),
     "cp": QuantumFunctionCall(
         function="CPHASE",
-        params={"theta": Expression(expr="angle")},
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[
+            Expression(expr="angle"),
+            HandleBinding(name="q1"),
+            HandleBinding(name="q2"),
+        ],
     ),
     "swap": QuantumFunctionCall(
         function="SWAP",
-        inouts={"qbit0": HandleBinding(name="q1"), "qbit1": HandleBinding(name="q2")},
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
 }
 
 
-def _atoms_to_qmod_atoms(atoms: List[Atom]) -> str:
-    # fmt: off
-    atom_struct_literals = [
-        "struct_literal(ChemistryAtom,"
-            f"element={Element[atom.symbol]},"
-            "position=struct_literal(Position,"
-                f"x={atom.x},"
-                f"y={atom.y},"
-                f"z={atom.z}"
-            ")"
-        ")"
+def _atoms_to_qmod_atoms(atoms: list[Atom]) -> list[QmodChemistryAtom]:
+    return [
+        QmodChemistryAtom(
+            element=Element[atom.symbol],  # type:ignore[arg-type]
+            position=QmodPosition(
+                x=atom.x,  # type:ignore[arg-type]
+                y=atom.y,  # type:ignore[arg-type]
+                z=atom.z,  # type:ignore[arg-type]
+            ),
+        )
         for atom in atoms
     ]
-    # fmt: on
-    return ",".join(atom_struct_literals)
 
 
-def _molecule_problem_to_qmod_molecule_problem(
+def molecule_problem_to_qmod(
     molecule_problem: MoleculeProblem,
-) -> str:
-    # fmt: off
-    return (
-        "struct_literal("
-        "MoleculeProblem,"
-        f"mapping={FermionMapping[molecule_problem.mapping.value.upper()]},"
-        f"z2_symmetries={molecule_problem.z2_symmetries},"
-        "molecule=struct_literal("
-        "Molecule,"
-        f"atoms=[{_atoms_to_qmod_atoms(molecule_problem.molecule.atoms)}],"
-        f"spin={molecule_problem.molecule.spin},"
-        f"charge={molecule_problem.molecule.charge}"
-        "),"
-        f"freeze_core={molecule_problem.freeze_core},"
-        f"remove_orbitals={molecule_problem.remove_orbitals}"
-        ")")
-    # fmt: on
+) -> QmodMoleculeProblem:
+    return QmodMoleculeProblem(
+        mapping=FermionMapping[  # type:ignore[arg-type]
+            molecule_problem.mapping.value.upper()
+        ],
+        z2_symmetries=molecule_problem.z2_symmetries,  # type:ignore[arg-type]
+        molecule=QmodMolecule(
+            atoms=_atoms_to_qmod_atoms(
+                molecule_problem.molecule.atoms
+            ),  # type:ignore[arg-type]
+            spin=molecule_problem.molecule.spin,  # type:ignore[arg-type]
+            charge=molecule_problem.molecule.charge,  # type:ignore[arg-type]
+        ),
+        freeze_core=molecule_problem.freeze_core,  # type:ignore[arg-type]
+        remove_orbitals=molecule_problem.remove_orbitals,  # type:ignore[arg-type]
+    )
 
 
 def _fermionic_operator_to_qmod_ladder_ops(
@@ -273,11 +262,12 @@ def _summed_fermionic_operator_to_qmod_lader_terms(
 def _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(
     hamiltonian_problem: HamiltonianProblem,
 ) -> str:
+    mapping = FermionMapping[hamiltonian_problem.mapping.value.upper()]
     return (
         # fmt: off
         "struct_literal("
         "FockHamiltonianProblem,"
-        f"mapping={FermionMapping[hamiltonian_problem.mapping.value.upper()]},"
+        f"mapping={qmod_val_to_expr_str(mapping)},"
         f"z2_symmetries={hamiltonian_problem.z2_symmetries},"
         f"terms=[{_summed_fermionic_operator_to_qmod_lader_terms(hamiltonian_problem.hamiltonian)}],"
         f"num_particles={hamiltonian_problem.num_particles}"
@@ -288,7 +278,7 @@ def _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(
 
 def _convert_library_problem_to_qmod_problem(problem: CHEMISTRY_PROBLEMS_TYPE) -> str:
     if isinstance(problem, MoleculeProblem):
-        return _molecule_problem_to_qmod_molecule_problem(problem)
+        return qmod_val_to_expr_str(molecule_problem_to_qmod(problem))
     elif isinstance(problem, HamiltonianProblem):
         return _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(problem)
     else:
@@ -299,18 +289,18 @@ def _get_chemistry_function(
     chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
     chemistry_function_name: str,
     inouts: Mapping[IOName, HandleBinding],
-    ansatz_parameters_expressions: Optional[Dict[str, Expression]] = None,
+    ansatz_parameters_expressions: Optional[list[Expression]] = None,
 ) -> QuantumFunctionCall:
     problem_prefix = _CHEMISTRY_PROBLEM_PREFIX_MAPPING[type(chemistry_problem)]
     return QuantumFunctionCall(
         function=f"{problem_prefix}_{chemistry_function_name}",
-        params={
-            **(ansatz_parameters_expressions or dict()),
-            f"{problem_prefix}_problem": Expression(
+        positional_args=[
+            Expression(
                 expr=_convert_library_problem_to_qmod_problem(chemistry_problem)
             ),
-        },
-        inouts=inouts,
+            *(ansatz_parameters_expressions or []),
+            *inouts.values(),
+        ],
     )
 
 
@@ -327,28 +317,32 @@ def _get_hartree_fock(
 def _get_hea_function(hea_parameters: HEAParameters) -> QuantumFunctionCall:
     return QuantumFunctionCall(
         function="full_hea",
-        params={
-            "num_qubits": Expression(expr=f"{hea_parameters.num_qubits}"),
-            "is_parametrized": Expression(
+        positional_args=[
+            Expression(expr=f"{hea_parameters.num_qubits}"),
+            Expression(
                 expr=f"{[int(_is_parametric_gate(_HAE_GATE_MAPPING[gate])) for gate in hea_parameters.one_qubit_gates+hea_parameters.two_qubit_gates]}"
             ),
-            "connectivity_map": Expression(
+            Expression(expr="t"),
+            Expression(
                 expr=f"{[list(connectivity_pair) for connectivity_pair in hea_parameters.connectivity_map]}"
             ),
-            "reps": Expression(expr=f"{hea_parameters.reps}"),
-            "angle_params": Expression(expr="t"),
-        },
-        operands={
-            "operands_1qubit": [
-                QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
+            Expression(expr=f"{hea_parameters.reps}"),
+            [
+                QuantumLambdaFunction(
+                    pos_rename_params=["angle", "q"],
+                    body=[_HAE_GATE_MAPPING[gate]],
+                )
                 for gate in hea_parameters.one_qubit_gates
             ],
-            "operands_2qubit": [
-                QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
+            [
+                QuantumLambdaFunction(
+                    pos_rename_params=["angle", "q1", "q2"],
+                    body=[_HAE_GATE_MAPPING[gate]],
+                )
                 for gate in hea_parameters.two_qubit_gates
             ],
-        },
-        inouts={"x": HandleBinding(name="qbv")},
+            HandleBinding(name="qbv"),
+        ],
     )
 
 
@@ -362,10 +356,10 @@ def _get_ansatz(
         chemistry_problem,
         _ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING[type(ansatz_parameters)],
         {"qbv": HandleBinding(name="qbv")},
-        {
-            param_name: Expression(expr=str(param_value))
+        [
+            Expression(expr=str(param_value))
             for param_name, param_value in ansatz_parameters.__dict__.items()
-        },
+        ],
     )
 
 
@@ -387,19 +381,16 @@ def _get_molecule_problem_execution_post_processing(
     molecule_problem: MoleculeProblem,
 ) -> str:
     return f"""
-{_MOLECULE_PROBLEM_RESULT} = molecule_ground_state_solution_post_process({_molecule_problem_to_qmod_molecule_problem(molecule_problem)},{_EXECUTION_RESULT})
+{_MOLECULE_PROBLEM_RESULT} = molecule_ground_state_solution_post_process({qmod_val_to_expr_str(molecule_problem_to_qmod(molecule_problem))},{_EXECUTION_RESULT})
 save({{{_MOLECULE_PROBLEM_RESULT!r}: {_MOLECULE_PROBLEM_RESULT}}})
 """
 
 
-def _get_fock_hamiltonian_problem_execution_post_processing(
-    hamiltonian_problem: HamiltonianProblem,
-) -> str:
-    return f"save({{{_EXECUTION_RESULT!r}: {_EXECUTION_RESULT}}})"
-
-
 def _is_parametric_gate(call: QuantumFunctionCall) -> bool:
-    return len(call.params) > 0
+    # FIXME: call call.params instead (CAD-21568)
+    return any(
+        arg for arg in call.positional_args if isinstance(arg, Expression)
+    ) or any(isinstance(arg, Expression) for arg in call.positional_args)
 
 
 def _get_execution_result_post_processing_statements(
@@ -408,12 +399,12 @@ def _get_execution_result_post_processing_statements(
     if isinstance(problem, MoleculeProblem):
         return _get_molecule_problem_execution_post_processing(problem)
     elif isinstance(problem, HamiltonianProblem):
-        return _get_fock_hamiltonian_problem_execution_post_processing(problem)
+        return ""
     else:
         raise ClassiqError(f"Invalid problem type: {problem}")
 
 
-def _count_parametric_gates(gates: List[str]) -> int:
+def _count_parametric_gates(gates: list[str]) -> int:
     return sum(_is_parametric_gate(_HAE_GATE_MAPPING[gate]) for gate in gates)
 
 
@@ -428,14 +419,18 @@ def _get_hea_port_size(hea_parameters: HEAParameters) -> int:
 
 def _get_chemistry_quantum_main_params(
     ansatz_parameters: AnsatzParameters,
-) -> Dict[str, ClassicalType]:
+) -> list[ClassicalParameterDeclaration]:
     if not isinstance(ansatz_parameters, HEAParameters):
-        return dict()
-    return {
-        "t": ClassicalArray(
-            element_type=Real(), size=_get_hea_port_size(ansatz_parameters)
-        )
-    }
+        return []
+    return [
+        ClassicalParameterDeclaration(
+            name="t",
+            classical_type=ClassicalArray(
+                element_type=Real(),
+                size=_get_hea_port_size(ansatz_parameters),
+            ),
+        ),
+    ]
 
 
 def _get_problem_to_hamiltonian_name(chemistry_problem: CHEMISTRY_PROBLEMS_TYPE) -> str:
@@ -448,16 +443,13 @@ def _get_chemistry_quantum_main(
     use_hartree_fock: bool,
     ansatz_parameters: AnsatzParameters,
 ) -> NativeFunctionDefinition:
-    body = []
+    body: list[QuantumStatement] = []
     body.append(
-        QuantumFunctionCall(
-            function="allocate",
-            positional_args=[
-                Expression(
-                    expr=f"len(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'))"
-                ),
-                HandleBinding(name="qbv"),
-            ],
+        Allocate(
+            size=Expression(
+                expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
+            ),
+            target=HandleBinding(name="qbv"),
         ),
     )
     if use_hartree_fock:
@@ -467,14 +459,10 @@ def _get_chemistry_quantum_main(
 
     return NativeFunctionDefinition(
         name="main",
-        param_decls=_get_chemistry_quantum_main_params(ansatz_parameters),
-        port_declarations=(
-            {
-                "qbv": PortDeclaration(
-                    name="qbv", direction=PortDeclarationDirection.Output
-                )
-            }
-        ),
+        positional_arg_declarations=_get_chemistry_quantum_main_params(
+            ansatz_parameters
+        )
+        + [PortDeclaration(name="qbv", direction=PortDeclarationDirection.Output)],
         body=body,
     )
 
@@ -484,13 +472,15 @@ def _get_chemistry_classical_code(
     execution_parameters: ChemistryExecutionParameters,
 ) -> str:
     qmod_problem = _convert_library_problem_to_qmod_problem(chemistry_problem)
-    return f"""
+    return (
+        f"""
 {_EXECUTION_RESULT} = vqe(
     hamiltonian={_get_problem_to_hamiltonian_name(chemistry_problem)}({qmod_problem}), {_get_chemistry_vqe_additional_params(execution_parameters)}
 )
-""" + _get_execution_result_post_processing_statements(
-        chemistry_problem
-    )
+save({{{_EXECUTION_RESULT!r}: {_EXECUTION_RESULT}}})
+"""
+        + _get_execution_result_post_processing_statements(chemistry_problem)
+    ).strip()
 
 
 def construct_chemistry_model(
@@ -499,12 +489,22 @@ def construct_chemistry_model(
     ansatz_parameters: AnsatzParameters,
     execution_parameters: ChemistryExecutionParameters,
 ) -> SerializedModel:
+    chemistry_functions = [
+        _get_chemistry_quantum_main(
+            chemistry_problem,
+            use_hartree_fock,
+            ansatz_parameters,
+        )
+    ]
+    if isinstance(ansatz_parameters, HEAParameters):
+        chemistry_functions.append(
+            cast(
+                NativeFunctionDefinition,
+                full_hea.create_model().function_dict["full_hea"],
+            )
+        )
     model = Model(
-        functions=[
-            _get_chemistry_quantum_main(
-                chemistry_problem, use_hartree_fock, ansatz_parameters
-            ),
-        ],
+        functions=chemistry_functions,
         classical_execution_code=_get_chemistry_classical_code(
             chemistry_problem, execution_parameters
         ),

classiq/applications/chemistry/ground_state_problem.py

@@ -33,7 +33,7 @@ async def update_problem_async(
 ) -> CHEMISTRY_PROBLEMS_TYPE:
     if num_qubits is None:
         num_qubits = await _get_num_qubits(problem)
-    return problem.copy(update={"num_qubits": num_qubits})
+    return problem.model_copy(update={"num_qubits": num_qubits})
 
 
 ground_state_problem.GroundStateProblem.update_problem = async_utils.syncify_function(  # type: ignore[attr-defined]

classiq/applications/combinatorial_helpers/allowed_constraints.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from sympy import Add, Expr, LessThan, Symbol
+
+from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
+
+_INEQUALITY_UPPER_LIMIT = 1
+
+
+def is_constraint_sum_less_than_one(
+    expression: Expr, encoding_type: Optional[EncodingType] = None
+) -> bool:
+    # tests the case: x_1 + ... + x_n <= 1
+    return (
+        isinstance(expression, LessThan)
+        and isinstance(expression.args[0], Add)
+        and all(isinstance(arg, Symbol) for arg in expression.args[0].args)
+        and (
+            expression.args[1] == _INEQUALITY_UPPER_LIMIT
+            or expression.args[1] == float(_INEQUALITY_UPPER_LIMIT)
+        )
+        and encoding_type is None
+    )

classiq/applications/combinatorial_helpers/arithmetic/arithmetic_expression.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+import sympy
+from pyomo.core.expr.sympy_tools import PyomoSympyBimap
+from scipy.optimize import differential_evolution
+from sympy import Expr
+
+from classiq.applications.combinatorial_helpers import encoding_utils
+
+
+def sympy_lambdify(*args: Any, **kwargs: Any) -> Any:
+    new_kwargs = kwargs
+    new_kwargs["modules"] = ["sympy"]
+    return sympy.lambdify(*args, **new_kwargs)
+
+
+def multivariate_extremum(
+    expr: Expr, symbols_map: PyomoSympyBimap, is_min: bool
+) -> float:
+    if expr.is_number:
+        return float(expr)
+
+    free_symbols = tuple(expr.free_symbols)
+    bounds = [
+        (0, encoding_utils.get_var_span(symbols_map.sympy2pyomo[sym]))
+        for sym in free_symbols
+    ]
+
+    # differential_evolution finds the global minimum, where we looking for the minimum or the maximum
+    extremum_type_coeff = 1 if is_min else -1
+
+    # Should be used only with sanitized imports due to use could be a potential risk to exec function https://docs.sympy.org/latest/modules/utilities/lambdify.html
+    func = sympy_lambdify([free_symbols], expr=extremum_type_coeff * expr)
+    result = differential_evolution(func, bounds)
+    return result.fun * extremum_type_coeff