classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/applications/chemistry/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
     SummedFermionicOperator,
@@ -15,22 +13,28 @@ from classiq.interface.chemistry.operator import PauliOperator, PauliOperators
 from . import ground_state_problem
 from .ansatz_parameters import HEAParameters, HVAParameters, UCCParameters
 from .chemistry_execution_parameters import ChemistryExecutionParameters
+from .chemistry_model_constructor import (
+    construct_chemistry_model,
+    molecule_problem_to_qmod,
+)
 
 __all__ = [
-    "Molecule",
-    "MoleculeProblem",
+    "ChemistryExecutionParameters",
+    "FermionicOperator",
     "GroundStateProblem",
+    "HEAParameters",
+    "HVAParameters",
     "HamiltonianProblem",
-    "PauliOperators",
+    "Molecule",
+    "MoleculeProblem",
     "PauliOperator",
-    "FermionicOperator",
+    "PauliOperators",
     "SummedFermionicOperator",
     "UCCParameters",
-    "HVAParameters",
-    "HEAParameters",
-    "ChemistryExecutionParameters",
+    "construct_chemistry_model",
+    "molecule_problem_to_qmod",
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/chemistry/ansatz_parameters.py

@@ -1,5 +1,5 @@
 import dataclasses
-from typing import List, Tuple, Union
+from typing import Union
 
 from classiq.interface.generator.excitations import EXCITATIONS_TYPE_EXACT
 from classiq.interface.generator.ucc import default_excitation_factory
@@ -21,9 +21,9 @@ class HVAParameters:
 class HEAParameters:
     reps: int
     num_qubits: int
-    connectivity_map: List[Tuple[int, int]]
-    one_qubit_gates: List[str]
-    two_qubit_gates: List[str]
+    connectivity_map: list[tuple[int, int]]
+    one_qubit_gates: list[str]
+    two_qubit_gates: list[str]
 
 
 AnsatzParameters = Union[UCCParameters, HVAParameters, HEAParameters]

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,12 +29,14 @@ 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
@@ -42,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",
 }
@@ -62,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: 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(
@@ -271,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}"
@@ -286,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(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:
@@ -297,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={
-            f"{problem_prefix}_problem": Expression(
+        positional_args=[
+            Expression(
                 expr=_convert_library_problem_to_qmod_problem(chemistry_problem)
             ),
-            **(ansatz_parameters_expressions or dict()),
-        },
-        inouts=inouts,
+            *(ansatz_parameters_expressions or []),
+            *inouts.values(),
+        ],
     )
 
 
@@ -325,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]}"
             ),
-            "angle_params": Expression(expr="t"),
-            "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}"),
-        },
-        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"),
+        ],
     )
 
 
@@ -360,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()
-        },
+        ],
     )
 
 
@@ -385,13 +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)},{_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 _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(
@@ -405,7 +404,7 @@ def _get_execution_result_post_processing_statements(
         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)
 
 
@@ -420,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:
@@ -440,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:
@@ -459,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,
     )
 
@@ -476,14 +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)}
 )
 save({{{_EXECUTION_RESULT!r}: {_EXECUTION_RESULT}}})
-""" + _get_execution_result_post_processing_statements(
-        chemistry_problem
-    )
+"""
+        + _get_execution_result_post_processing_statements(chemistry_problem)
+    ).strip()
 
 
 def construct_chemistry_model(
@@ -492,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_model_constructors → applications}/combinatorial_helpers/allowed_constraints.py

@@ -15,6 +15,9 @@ def is_constraint_sum_less_than_one(
         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
+        and (
+            expression.args[1] == _INEQUALITY_UPPER_LIMIT
+            or expression.args[1] == float(_INEQUALITY_UPPER_LIMIT)
+        )
         and encoding_type is None
     )

classiq/{applications_model_constructors → applications}/combinatorial_helpers/arithmetic/arithmetic_expression.py

@@ -5,7 +5,7 @@ from pyomo.core.expr.sympy_tools import PyomoSympyBimap
 from scipy.optimize import differential_evolution
 from sympy import Expr
 
-from classiq.applications_model_constructors.combinatorial_helpers import encoding_utils
+from classiq.applications.combinatorial_helpers import encoding_utils
 
 
 def sympy_lambdify(*args: Any, **kwargs: Any) -> Any: