classiq 0.92.0__py3-none-any.whl → 0.94.0__py3-none-any.whl

classiq-0.94.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.15
+Root-Is-Purelib: true
+Tag: py3-none-any

classiq-0.94.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,27 @@
+LICENSE AGREEMENT
+
+By clicking the "accept" or "ok" button and/or by using the Software (as defined below) you expressly acknowledge and agree that you, on behalf of yourself or your organization ("Licensee", "you"), are entering into a legal agreement with Classiq Technologies Ltd., a company incorporated under the laws of the State of Israel having its principal place of business at 3 Daniel Frisch Street, Tel Aviv-Yafo, Israel ("Classiq") (each, a "Party" and collectively, the "Parties"), and have understood and agree to comply with, and be legally bound by, the terms and conditions of this Evaluation Agreement ("Agreement"). You hereby waive any applicable rights to require an original (non-electronic) signature or delivery or retention of non-electronic records, to the extent not prohibited under applicable law. If you do not agree to be bound by this Agreement, please do not use the Software.
+
+1.	License.
+
+1.1.	Subject to the terms of this Agreement, Classiq grants Licensee a limited, nonexclusive, non-assignable and nontransferable, fully revocable license to install, access and use Classiq's quantum algorithm design platform ("Software"), during the Evaluation Period (as defined below), solely for internal evaluation purposes ("Evaluation License"). Notwithstanding anything to the contrary, Classiq may, at its sole discretion, deny access to the Software or part thereof at any time.
+
+1.2.	During the Evaluation Period, Licensee may allow its employees who are explicitly authorized by Licensee to use the Software, solely for the Licensee's evaluation of the Software (each, a "Permitted User"). Each Permitted User shall be bound by the terms and conditions in writing at least as restrictive as those contained in this Agreement and Licensee shall be liable for any breach of the terms of this Agreement by a Permitted User. Licensee shall immediately report any unauthorized access or use of the Software to Classiq. During the Evaluation Period, Classiq may collect, record and save information about Permitted Users' use and interaction with the Software, for the purposes of improving Classiq's services to you in relation to your use of the Software ("Interaction Information"). Subject to the terms of this Section 1.2, Classiq shall destroy all Interaction Information at the expiry or termination of this Agreement. Notwithstanding anything to the contrary, Classiq may save, store and retain Interaction Information for internal purposes such as (but not limited to) improving or developing products, provision of services to all clients and collaborating with partners, provided that such Interaction Information is aggregated and anonymized ("Anonymized Aggregated Information"). Classiq shall not be required to destroy any Anonymized Aggregated Information at the expiry or termination of this Agreement. Licensee represents and warrants that it has obtained the necessary consents from each Permitted User to allow Classiq to collect record and save the Interaction Information and to retain the Anonymized Aggregated Information in accordance with this Section 1.2.
+
+2.	Title and Ownership. Other than the Evaluation License granted under this Agreement to Licensee during the Evaluation Period, all intellectual property rights, ownership rights, and proprietary rights in and to: (a) the Software, including any and all derivatives, updates, upgrades, changes and improvements thereof; and (b) Feedback (as defined below), lie and remain exclusively with Classiq and/or its licensors. Nothing herein constitutes a waiver of Classiq's intellectual property rights under any law. All rights not expressly granted hereunder are reserved by Classiq.
+
+3.	Feedback. As a condition of the Evaluation License, Licensee shall provide Classiq with detailed Feedback (defined below), which may be used by Classiq at its sole discretion. "Feedback" means ideas, suggestions, or similar feedback about performance of the Software and/or for improving the Software, as well as the results of the evaluation. All Feedback shall be provided 'as is' with no warranty on behalf of Licensee and shall be deemed the exclusive property of Classiq, and Licensee hereby irrevocably transfers and assigns to Classiq all intellectual property rights to the Feedback and waives any and all moral rights or economic rights that Licensee may have with respect thereto.
+
+4.	Restricted Use. Unless otherwise explicitly specified and permitted under this Agreement, without the prior written consent of Classiq, Licensee may not, directly or indirectly (i) copy, modify, create derivative works of or distribute any part of the Software (including by incorporation into its products); (ii) sell, license (or sub-license), lease, assign, transfer, pledge, or share Licensee's rights under this Agreement with any third party; (iii) use any "open source" or "copyleft software" in a manner that would require Classiq to disclose the source code of the Software to any third party; (iv) disclose the results of any testing or benchmarking of the Software to any third party; (v) disassemble, decompile, reverse engineer or attempt to discover the Software's source code or underlying algorithms; (vi) use the Software in a manner that violates or infringes any rights of any third party, including but not limited to, privacy rights, publicity rights or intellectual property rights; (vii) remove or alter any trademarks or other proprietary notices related to the Software; (viii) circumvent, disable or otherwise interfere with security-related features of the Software or features that enforce use limitations; (ix) export, make available or use the Software in any manner prohibited by applicable laws (including without limitation export control laws); and/or (x) transmit any malicious code (i.e., software viruses, Trojan horses, worms, malware or other computer instructions, devices, or techniques that erase data or programming, infect, disrupt, damage, disable, or shut down a computer system or any component of such computer system) or other unlawful material in connection with the Software.
+
+5.	Open Source Components. The Software may use or include third party open source software, files, libraries or components that may be distributed to Licensee and are subject to third party open source license terms. If there is a conflict between any open source license and the terms of this Agreement, then the open source license terms shall prevail but solely in connection with the related third party open source software. Classiq makes no warranty or indemnity hereunder with respect to any third party open source software.
+
+6.	Disclaimer of Warranties. EXCEPT AS EXPLICITLY SET FORTH IN THIS AGREEMENT THE SOFTWARE AND ANY OUTPUT WHICH MAY BE PROVIDED TO LICENSEE HEREUNDER ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND FOR INTERNAL EVALUATION PURPOSES ONLY. CLASSIQ DISCLAIMS ALL WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON INFRINGEMENT, WITH RESPECT TO THE SOFTWARE AND ANY OTHER OUTPUT WHICH MAY BE PROVIDED TO LICENSEE HEREUNDER.
+
+7.	Limitation of Liability. GIVEN THE NATURE OF THIS PILOT AGREEMENT AND THE FACT THAT THIS AGREEMENT IS FOR EVALUATION PURPOSES, TO THE MAXIMUM EXTENT PERMITTED BY LAW: (I) CLASSIQ SHALL NOT BE LIABLE FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING WITHOUT LIMITATION, ANY LOST PROFITS OR GOODWILL, LOST OR DAMAGED DATA OR DOCUMENTATION, LOST SAVINGS OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THIS AGREEMENT, THE SOFTWARE, OR LICENSEE'S USE OF THE SOFTWARE; AND (II) IN NO EVENT SHALL CLASSIQ'S AGGREGATE LIABILITY FOR ANY DAMAGES ARISING OUT OF OR RELATED TO THIS AGREEMENT, WHETHER IN CONTRACT OR TORT, OR OTHERWISE EXCEED $100.
+
+8.	Confidentiality. Each Party may have access to certain non-public information of the other Party, in any form or media, including without limitation trade secrets and other information related to the products, software, technology, data, know-how, or business of the other Party, and any other information that a reasonable person should have reason to believe is proprietary, confidential, or competitively sensitive (the "Confidential Information"). Each Party shall take reasonable measures, at least as protective as those taken to protect its own confidential information, but in no event less than reasonable care, to protect the other Party's Confidential Information from disclosure to a third party. The receiving party's obligations under this Section, with respect to any Confidential Information of the disclosing party, shall not apply to and/or shall terminate if such information: (a) was already lawfully known to the receiving party at the time of disclosure by the disclosing party; (b) was disclosed to the receiving party by a third party who had the right to make such disclosure without any confidentiality restrictions; (c) is, or through no fault of the receiving party has become, generally available to the public; or (d) was independently developed by the receiving party without access to, or use of, the disclosing party's Confidential Information. Neither Party shall use or disclose the Confidential Information of the other Party except for performance of its obligations under this Agreement. The receiving party shall only permit access to the disclosing party's Confidential Information to its respective employees, consultants, affiliates, agents and subcontractors having a need to know such information in connection with the abovementioned purpose, who either (i) have signed a non-disclosure agreement with the receiving party containing terms at least as restrictive as those contained herein or (ii) are otherwise bound by a duty of confidentiality to the receiving party at least as restrictive as the terms set forth herein. The receiving party will be allowed to disclose Confidential Information to the extent that such disclosure is required by law or by the order or a court of similar judicial or administrative body, provided that it notifies the disclosing Party of such required disclosure to enable disclosing party to seek a protective order or otherwise prevent or restrict such disclosure. All right, title and interest in and to Confidential Information are and shall remain the sole and exclusive property of the disclosing Party.
+
+9.	Term and Termination. This Agreement shall commence on the date you accept the terms of this Agreement and shall expire ninety (90) days later ("Evaluation Period"), unless earlier terminated by either Party in writing on three (3) days' prior written notice to the other Party. Licensee's unauthorized use of the Software or otherwise failure to comply with the terms of this Agreement shall result in automatic immediate termination of this Agreement, upon notice by Classiq. Upon expiration or termination, (a) each Party shall promptly return or destroy all Confidential Information received from the other Party, and all copes thereof, (b) Licensee shall: (i) immediately cease access to and use of the Software; (ii) return the Software and all copies thereof, as well as it related documentation in Licensee or any of its Permitted Users' possession or control to Classiq; (iii) erase or otherwise destroy all copies of the Software in its possession, which are fixed or resident in the memory or hard disks of its devices; and (iv) return to Classiq any and all of Classiq's Confidential Information then in its possession. The following provisions shall survive the expiration or termination of this Agreement: 2 (Title and Ownership), 6 (Disclaimer of Warranties), 7 (Limitation of Liability), 8 (Confidentiality), 9 (Term and Termination) and 10 (Miscellaneous).
+
+10.	Miscellaneous. This Agreement shall be governed by and construed under the laws of the State of Israel. The competent courts of Tel Aviv-Yafo, Israel shall have the exclusive jurisdiction with respect to any dispute and action arising under or in relation to this Agreement. Licensee shall not assign this Agreement without the prior written consent of Classiq. Any prohibited assignment shall be null and void. No waiver of rights arising under this Agreement shall be effective unless in writing and signed by the Party against whom such waiver is sought to be enforced. No failure or delay by either Party in exercising any right, power or remedy under this Agreement shall operate as a waiver of any such right, power or remedy and/or prejudice any rights of such Party. This Agreement does not, and shall not be construed to create any relationship, partnership, joint venture, employer-employee, agency, or franchisor-franchisee relationship between the Parties. Nothing in this Agreement shall be construed to limit or delay either Classiq's or Licensee's ability to seek immediate relief at law or in equity for any breach by the other. This Agreement constitutes the complete and entire agreement of the Parties and supersedes all previous communications between them, oral or written, relating to the subject matter hereof. This Agreement may be executed in two or more counterparts, each of which shall be deemed an original and all of which shall together be deemed to constitute one and the same agreement.

classiq/applications/chemistry/ansatz_parameters.py

@@ -1,29 +0,0 @@
-import dataclasses
-from typing import Union
-
-from classiq.interface.generator.excitations import EXCITATIONS_TYPE_EXACT
-from classiq.interface.generator.ucc import default_excitation_factory
-
-
-@dataclasses.dataclass
-class UCCParameters:
-    excitations: EXCITATIONS_TYPE_EXACT = dataclasses.field(
-        default_factory=default_excitation_factory
-    )
-
-
-@dataclasses.dataclass
-class HVAParameters:
-    reps: int
-
-
-@dataclasses.dataclass
-class HEAParameters:
-    reps: int
-    num_qubits: int
-    connectivity_map: list[tuple[int, int]]
-    one_qubit_gates: list[str]
-    two_qubit_gates: list[str]
-
-
-AnsatzParameters = Union[UCCParameters, HVAParameters, HEAParameters]

classiq/applications/chemistry/chemistry_execution_parameters.py

@@ -1,16 +0,0 @@
-import dataclasses
-from typing import Optional
-
-import numpy as np
-
-from classiq.interface.executor.optimizer_preferences import OptimizerType
-
-
-@dataclasses.dataclass
-class ChemistryExecutionParameters:
-    optimizer: OptimizerType
-    max_iteration: int
-    initial_point: Optional[np.ndarray] = dataclasses.field(default=None)
-    tolerance: float = dataclasses.field(default=0.0)
-    step_size: float = dataclasses.field(default=0.0)
-    skip_compute_variance: bool = dataclasses.field(default=False)

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -1,532 +0,0 @@
-import warnings
-from collections.abc import Mapping
-from typing import Optional, cast
-
-from classiq.interface.chemistry.fermionic_operator import (
-    FermionicOperator,
-    SummedFermionicOperator,
-)
-from classiq.interface.chemistry.ground_state_problem import (
-    CHEMISTRY_PROBLEMS_TYPE,
-    HamiltonianProblem,
-    MoleculeProblem,
-)
-from classiq.interface.chemistry.molecule import Atom
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
-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,
-    Real,
-)
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.generator.functions.type_modifier import TypeModifier
-from classiq.interface.model.allocate import Allocate
-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
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
-from classiq.interface.model.quantum_statement import QuantumStatement
-
-from classiq.applications.chemistry.ansatz_parameters import (
-    AnsatzParameters,
-    HEAParameters,
-    HVAParameters,
-    UCCParameters,
-)
-from classiq.applications.chemistry.chemistry_execution_parameters import (
-    ChemistryExecutionParameters,
-)
-from classiq.qmod.builtins.enums import (
-    Element,
-    FermionMapping,
-)
-from classiq.qmod.builtins.structs import (
-    ChemistryAtom as QmodChemistryAtom,
-    Molecule as QmodMolecule,
-    MoleculeProblem as QmodMoleculeProblem,
-    Position as QmodPosition,
-)
-from classiq.qmod.global_declarative_switch import set_global_declarative_switch
-from classiq.qmod.utilities import qmod_val_to_expr_str
-
-# isort: split
-
-# This import causes a circular import if done earlier. We use isort: split to avoid it
-from classiq.open_library.functions.hea import full_hea
-
-with set_global_declarative_switch():
-    _FULL_HEA = cast(
-        NativeFunctionDefinition, full_hea.create_model().function_dict["full_hea"]
-    )
-
-_LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {
-    "+": "PLUS",
-    "-": "MINUS",
-}
-
-_CHEMISTRY_PROBLEM_PREFIX_MAPPING: dict[type[CHEMISTRY_PROBLEMS_TYPE], str] = {
-    MoleculeProblem: "molecule",
-    HamiltonianProblem: "fock_hamiltonian",
-}
-
-_ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING: dict[type[AnsatzParameters], str] = {
-    UCCParameters: "ucc",
-    HVAParameters: "hva",
-}
-
-_EXECUTION_RESULT = "vqe_result"
-_MOLECULE_PROBLEM_RESULT = "molecule_result"
-
-_HAE_GATE_MAPPING: dict[str, QuantumFunctionCall] = {
-    "h": QuantumFunctionCall(
-        function="H",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "x": QuantumFunctionCall(
-        function="X",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "y": QuantumFunctionCall(
-        function="Y",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "z": QuantumFunctionCall(
-        function="Z",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "i": QuantumFunctionCall(
-        function="I",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "s": QuantumFunctionCall(
-        function="S",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "t": QuantumFunctionCall(
-        function="T",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "sdg": QuantumFunctionCall(
-        function="SDG",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "tdg": QuantumFunctionCall(
-        function="TDG",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "p": QuantumFunctionCall(
-        function="PHASE",
-        positional_args=[HandleBinding(name="q")],
-    ),
-    "rx": QuantumFunctionCall(
-        function="RX",
-        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
-    ),
-    "ry": QuantumFunctionCall(
-        function="RY",
-        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
-    ),
-    "rz": QuantumFunctionCall(
-        function="RZ",
-        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
-    ),
-    "rxx": QuantumFunctionCall(
-        function="RXX",
-        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
-    ),
-    "ryy": QuantumFunctionCall(
-        function="RYY",
-        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
-    ),
-    "rzz": QuantumFunctionCall(
-        function="RZZ",
-        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
-    ),
-    "ch": QuantumFunctionCall(
-        function="CH",
-        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
-    ),
-    "cx": QuantumFunctionCall(
-        function="CX",
-        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
-    ),
-    "cy": QuantumFunctionCall(
-        function="CY",
-        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
-    ),
-    "cz": QuantumFunctionCall(
-        function="CZ",
-        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
-    ),
-    "crx": QuantumFunctionCall(
-        function="CRX",
-        positional_args=[
-            Expression(expr="angle"),
-            HandleBinding(name="q1"),
-            HandleBinding(name="q2"),
-        ],
-    ),
-    "cry": QuantumFunctionCall(
-        function="CRY",
-        positional_args=[
-            Expression(expr="angle"),
-            HandleBinding(name="q1"),
-            HandleBinding(name="q2"),
-        ],
-    ),
-    "crz": QuantumFunctionCall(
-        function="CRZ",
-        positional_args=[
-            Expression(expr="angle"),
-            HandleBinding(name="q1"),
-            HandleBinding(name="q2"),
-        ],
-    ),
-    "cp": QuantumFunctionCall(
-        function="CPHASE",
-        positional_args=[
-            Expression(expr="angle"),
-            HandleBinding(name="q1"),
-            HandleBinding(name="q2"),
-        ],
-    ),
-    "swap": QuantumFunctionCall(
-        function="SWAP",
-        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
-    ),
-}
-
-
-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
-    ]
-
-
-def molecule_problem_to_qmod(
-    molecule_problem: MoleculeProblem,
-) -> 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(
-    fermionic_operator: FermionicOperator,
-) -> str:
-    return "\n\t\t\t\t\t".join(
-        [
-            f"struct_literal(LadderOp, op=LadderOperator.{_LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING[ladder_op[0]]}, index={ladder_op[1]}),"
-            for ladder_op in fermionic_operator.op_list
-        ]
-    )[:-1]
-
-
-def _summed_fermionic_operator_to_qmod_lader_terms(
-    hamiltonian: SummedFermionicOperator,
-) -> str:
-    return "\t\t".join(
-        [
-            f"""
-            struct_literal(LadderTerm,
-                coefficient={fermionic_operator[1]},
-                ops=[
-                    {_fermionic_operator_to_qmod_ladder_ops(fermionic_operator[0])}
-                ]
-            ),"""
-            for fermionic_operator in hamiltonian.op_list
-        ]
-    )[:-1]
-
-
-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={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}"
-        ")"
-        # fmt: on
-    )
-
-
-def _convert_library_problem_to_qmod_problem(problem: CHEMISTRY_PROBLEMS_TYPE) -> str:
-    if isinstance(problem, MoleculeProblem):
-        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:
-        raise ClassiqError(f"Invalid problem type: {problem}")
-
-
-def _get_chemistry_function(
-    chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
-    chemistry_function_name: str,
-    inouts: Mapping[IOName, HandleBinding],
-    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}",
-        positional_args=[
-            Expression(
-                expr=_convert_library_problem_to_qmod_problem(chemistry_problem)
-            ),
-            *(ansatz_parameters_expressions or []),
-            *inouts.values(),
-        ],
-    )
-
-
-def _get_hartree_fock(
-    chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
-) -> QuantumFunctionCall:
-    return _get_chemistry_function(
-        chemistry_problem,
-        "hartree_fock",
-        {"qbv": HandleBinding(name="qbv")},
-    )
-
-
-def _get_hea_function(hea_parameters: HEAParameters) -> QuantumFunctionCall:
-    return QuantumFunctionCall(
-        function="full_hea",
-        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]}"
-            ),
-            Expression(expr="t"),
-            Expression(
-                expr=f"{[list(connectivity_pair) for connectivity_pair in hea_parameters.connectivity_map]}"
-            ),
-            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
-            ],
-            [
-                QuantumLambdaFunction(
-                    pos_rename_params=["angle", "q1", "q2"],
-                    body=[_HAE_GATE_MAPPING[gate]],
-                )
-                for gate in hea_parameters.two_qubit_gates
-            ],
-            HandleBinding(name="qbv"),
-        ],
-    )
-
-
-def _get_ansatz(
-    chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
-    ansatz_parameters: AnsatzParameters,
-) -> QuantumFunctionCall:
-    if isinstance(ansatz_parameters, HEAParameters):
-        return _get_hea_function(ansatz_parameters)
-    return _get_chemistry_function(
-        chemistry_problem,
-        _ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING[type(ansatz_parameters)],
-        {"qbv": HandleBinding(name="qbv")},
-        [
-            Expression(expr=str(param_value))
-            for param_name, param_value in ansatz_parameters.__dict__.items()
-        ],
-    )
-
-
-def _get_chemistry_vqe_additional_params(
-    execution_parameters: ChemistryExecutionParameters,
-) -> str:
-    return f"""maximize=False,
-initial_point={execution_parameters.initial_point or list()},
-optimizer=Optimizer.{execution_parameters.optimizer.value},
-max_iteration={execution_parameters.max_iteration},
-tolerance={execution_parameters.tolerance or 0},
-step_size={execution_parameters.step_size or 0},
-skip_compute_variance={execution_parameters.skip_compute_variance},
-alpha_cvar=1.0,
-"""
-
-
-def _get_molecule_problem_execution_post_processing(
-    molecule_problem: MoleculeProblem,
-) -> str:
-    return f"""
-{_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:
-    # 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(
-    problem: CHEMISTRY_PROBLEMS_TYPE,
-) -> str:
-    if isinstance(problem, MoleculeProblem):
-        return _get_molecule_problem_execution_post_processing(problem)
-    elif isinstance(problem, HamiltonianProblem):
-        return ""
-    else:
-        raise ClassiqError(f"Invalid problem type: {problem}")
-
-
-def _count_parametric_gates(gates: list[str]) -> int:
-    return sum(_is_parametric_gate(_HAE_GATE_MAPPING[gate]) for gate in gates)
-
-
-def _get_hea_port_size(hea_parameters: HEAParameters) -> int:
-    return hea_parameters.reps * (
-        hea_parameters.num_qubits
-        * _count_parametric_gates(hea_parameters.one_qubit_gates)
-        + len(hea_parameters.connectivity_map)
-        * _count_parametric_gates(hea_parameters.two_qubit_gates)
-    )
-
-
-def _get_chemistry_quantum_main_params(
-    ansatz_parameters: AnsatzParameters,
-) -> list[ClassicalParameterDeclaration]:
-    if not isinstance(ansatz_parameters, HEAParameters):
-        return []
-    return [
-        ClassicalParameterDeclaration(
-            name="t",
-            classical_type=ClassicalArray(
-                element_type=Real(),
-                length=Expression(expr=str(_get_hea_port_size(ansatz_parameters))),
-            ),
-        ),
-    ]
-
-
-def _get_problem_to_hamiltonian_name(chemistry_problem: CHEMISTRY_PROBLEMS_TYPE) -> str:
-    problem_prefix = _CHEMISTRY_PROBLEM_PREFIX_MAPPING[type(chemistry_problem)]
-    return f"{problem_prefix}_problem_to_hamiltonian"
-
-
-def _get_chemistry_quantum_main(
-    chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
-    use_hartree_fock: bool,
-    ansatz_parameters: AnsatzParameters,
-) -> NativeFunctionDefinition:
-    body: list[QuantumStatement] = []
-    body.append(
-        Allocate(
-            size=Expression(
-                expr=f"{_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:
-        body.append(_get_hartree_fock(chemistry_problem))
-
-    body.append(_get_ansatz(chemistry_problem, ansatz_parameters))
-
-    return NativeFunctionDefinition(
-        name="main",
-        positional_arg_declarations=_get_chemistry_quantum_main_params(
-            ansatz_parameters
-        )
-        + [
-            PortDeclaration(
-                name="qbv",
-                direction=PortDeclarationDirection.Output,
-                type_modifier=TypeModifier.Mutable,
-            )
-        ],
-        body=body,
-    )
-
-
-def _get_chemistry_classical_code(
-    chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
-    execution_parameters: ChemistryExecutionParameters,
-) -> str:
-    qmod_problem = _convert_library_problem_to_qmod_problem(chemistry_problem)
-    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)
-    ).strip()
-
-
-def construct_chemistry_model(
-    chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
-    use_hartree_fock: bool,
-    ansatz_parameters: AnsatzParameters,
-    execution_parameters: ChemistryExecutionParameters,
-) -> SerializedModel:
-    warnings.warn(
-        (
-            "The function `construct_chemistry_model` is deprecated and will no "
-            "longer be supported starting on 2025-09-18 at the earliest. "
-            "For more information on Classiq's chemistry application, see "
-            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
-        ),
-        category=ClassiqDeprecationWarning,
-        stacklevel=2,
-    )
-
-    chemistry_functions = [
-        _get_chemistry_quantum_main(
-            chemistry_problem,
-            use_hartree_fock,
-            ansatz_parameters,
-        )
-    ]
-    if isinstance(ansatz_parameters, HEAParameters):
-        chemistry_functions.append(_FULL_HEA)
-    model = Model(
-        functions=chemistry_functions,
-        classical_execution_code=_get_chemistry_classical_code(
-            chemistry_problem, execution_parameters
-        ),
-    )
-    return model.get_model()

classiq/applications/chemistry/ground_state_problem.py

@@ -1,42 +0,0 @@
-from typing import Optional
-
-from classiq.interface.chemistry import ground_state_problem
-from classiq.interface.chemistry.ground_state_problem import (
-    CHEMISTRY_PROBLEMS_TYPE,
-    HamiltonianProblem,
-)
-from classiq.interface.chemistry.operator import PauliOperator
-
-from classiq._internals import async_utils
-from classiq._internals.api_wrapper import ApiWrapper
-
-
-async def generate_hamiltonian_async(
-    problem: CHEMISTRY_PROBLEMS_TYPE,
-) -> PauliOperator:
-    return await ApiWrapper.call_generate_hamiltonian_task(problem)
-
-
-ground_state_problem.GroundStateProblem.generate_hamiltonian = async_utils.syncify_function(generate_hamiltonian_async)  # type: ignore[attr-defined]
-ground_state_problem.GroundStateProblem.generate_hamiltonian_async = generate_hamiltonian_async  # type: ignore[attr-defined]
-
-
-async def _get_num_qubits(problem: CHEMISTRY_PROBLEMS_TYPE) -> int:
-    if isinstance(problem, HamiltonianProblem) and not problem.z2_symmetries:
-        return problem.hamiltonian.num_qubits
-    hamiltonian = await generate_hamiltonian_async(problem)
-    return hamiltonian.num_qubits
-
-
-async def update_problem_async(
-    problem: CHEMISTRY_PROBLEMS_TYPE, num_qubits: Optional[int] = None
-) -> CHEMISTRY_PROBLEMS_TYPE:
-    if num_qubits is None:
-        num_qubits = await _get_num_qubits(problem)
-    return problem.model_copy(update={"num_qubits": num_qubits})
-
-
-ground_state_problem.GroundStateProblem.update_problem = async_utils.syncify_function(  # type: ignore[attr-defined]
-    update_problem_async
-)
-ground_state_problem.GroundStateProblem.update_problem_async = update_problem_async  # type: ignore[attr-defined]