classiq 0.60.1__py3-none-any.whl → 0.61.0__py3-none-any.whl

classiq/__init__.py

@@ -28,8 +28,10 @@ from classiq.applications.chemistry import (
     molecule_problem_to_qmod,
 )
 from classiq.applications.combinatorial_optimization import (
+    CombinatorialProblem,
     compute_qaoa_initial_point,
     construct_combinatorial_optimization_model,
+    execute_qaoa,
     pyo_model_to_hamiltonian,
 )
 from classiq.applications.finance import construct_finance_model

classiq/_internals/client.py

@@ -290,7 +290,12 @@ class Client:
         if http_client is None:
             return self.async_client()
         else:
-            return _AsyncNullContext(enter_result=http_client)
+            if sys.version_info[0:2] < (3, 10):
+                # remove this `if` and the `_AsyncNullContext` class when we stop
+                # supporting python 3.9
+                return _AsyncNullContext(enter_result=http_client)
+            else:
+                return contextlib.nullcontext(enter_result=http_client)
 
     def sync_call_api(
         self,

classiq/applications/__init__.py

@@ -1,8 +1,8 @@
 from classiq.applications import chemistry, combinatorial_optimization, finance, qsvm
 
 __all__ = [
-    "combinatorial_optimization",
     "chemistry",
+    "combinatorial_optimization",
     "finance",
     "qsvm",
 ]

classiq/applications/chemistry/__init__.py

@@ -19,18 +19,18 @@ from .chemistry_model_constructor import (
 )
 
 __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",
 ]

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -1,6 +1,6 @@
 # flake8: noqa
 
-from typing import Optional
+from typing import Optional, cast
 from collections.abc import Mapping
 
 from classiq.interface.chemistry.fermionic_operator import (
@@ -53,6 +53,7 @@ from classiq.applications.chemistry.chemistry_execution_parameters import (
 )
 from classiq.interface.exceptions import ClassiqError
 from classiq.qmod.utilities import qmod_val_to_expr_str
+from classiq.qmod.builtins.functions.hea import full_hea
 
 _LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {
     "+": "PLUS",
@@ -489,12 +490,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/combinatorial_optimization/__init__.py

@@ -12,17 +12,23 @@ from .combinatorial_optimization_config import OptimizerConfig, QAOAConfig
 from .combinatorial_optimization_model_constructor import (
     construct_combinatorial_optimization_model,
 )
+from .combinatorial_problem import (
+    CombinatorialProblem,
+    execute_qaoa,
+)
 
 __all__ = [
+    "CombinatorialProblem",
     "EncodingType",
     "OptimizerConfig",
     "QAOAConfig",
     "QSolver",
+    "compute_qaoa_initial_point",
     "construct_combinatorial_optimization_model",
     "examples",
+    "execute_qaoa",
     "get_optimization_solution_from_pyo",
     "pyo_model_to_hamiltonian",
-    "compute_qaoa_initial_point",
 ]
 
 

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -33,6 +33,7 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
     _pauli_terms_to_qmod,
 )
 from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
+from classiq.qmod.builtins.functions import qaoa_penalty
 
 
 def construct_combi_opt_py_model(
@@ -106,6 +107,7 @@ def construct_combi_opt_py_model(
                     ),
                 ],
             ),
+            *[f for f in qaoa_penalty.create_model().functions if f.name != "main"],
         ],
         classical_execution_code=f"""
 vqe_result = vqe(

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -0,0 +1,197 @@
+import math
+import re
+from typing import Callable, Optional
+
+import numpy as np
+import pandas as pd
+import pyomo.core as pyo
+import scipy
+
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.executor.result import ExecutionDetails
+from classiq.interface.model.model import SerializedModel
+
+from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
+    pyo_model_to_qmod_problem,
+)
+from classiq.execution import ExecutionSession
+from classiq.qmod.builtins.functions import (
+    RX,
+    allocate,
+    apply_to_all,
+    hadamard_transform,
+)
+from classiq.qmod.builtins.operations import phase, repeat
+from classiq.qmod.cparam import CReal
+from classiq.qmod.create_model_function import create_model
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray
+from classiq.qmod.qmod_variable import Output, QVar
+from classiq.synthesis import SerializedQuantumProgram, synthesize
+
+
+class CombinatorialProblem:
+    def __init__(
+        self,
+        pyo_model: pyo.ConcreteModel,
+        num_layers: int,
+        penalty_factor: int = 1,
+    ):
+        self.problem_vars_, self.cost_func_ = pyo_model_to_qmod_problem(
+            pyo_model, penalty_factor
+        )
+        self.num_layers_ = num_layers
+        self.model_ = None
+        self.qprog_ = None
+        self.es_ = None
+        self.optimized_params_ = None
+
+    def get_model(self) -> SerializedModel:
+        @qfunc
+        def main(
+            params: CArray[CReal, self.num_layers_ * 2],  # type:ignore[valid-type]
+            v: Output[self.problem_vars_],  # type:ignore[name-defined]
+        ) -> None:
+            allocate(v.size, v)
+            hadamard_transform(v)
+            repeat(
+                self.num_layers_,
+                lambda i: [  # type:ignore[arg-type]
+                    phase(
+                        -self.cost_func_(v), params[i]
+                    ),  # type:ignore[func-returns-value]
+                    apply_to_all(lambda q: RX(params[self.num_layers_ + i], q), v),
+                ],
+            )
+
+        self.model_ = create_model(main)  # type:ignore[assignment]
+        return self.model_  # type:ignore[return-value]
+
+    def get_qprog(self) -> SerializedQuantumProgram:
+        if self.model_ is None:
+            self.get_model()
+        self.qprog_ = synthesize(self.model_)  # type:ignore[assignment,arg-type]
+        return self.qprog_  # type:ignore[return-value]
+
+    def optimize(
+        self,
+        execution_preferences: Optional[ExecutionPreferences] = None,
+        maxiter: int = 20,
+        cost_trace: Optional[list[float]] = None,
+        quantile: float = 1.0,
+    ) -> list[float]:
+        if self.qprog_ is None:
+            self.get_qprog()
+        self.es_ = ExecutionSession(
+            self.qprog_, execution_preferences  # type:ignore[assignment,arg-type]
+        )
+
+        def estimate_cost_wrapper(params: np.ndarray) -> float:
+            cost = self.es_.estimate_cost(  # type:ignore[attr-defined]
+                lambda state: self.cost_func_(state["v"]),
+                {"params": params.tolist()},
+                quantile=quantile,
+            )
+            if cost_trace is not None:
+                cost_trace.append(cost)
+            return cost
+
+        initial_params = (
+            np.concatenate(
+                (
+                    np.linspace(0, 1, self.num_layers_),
+                    np.linspace(1, 0, self.num_layers_),
+                )
+            )
+            * math.pi
+        )
+        self.optimized_params_ = scipy.optimize.minimize(
+            estimate_cost_wrapper,
+            x0=initial_params,
+            method="COBYLA",
+            options={"maxiter": maxiter},
+        ).x.tolist()
+        return self.optimized_params_  # type:ignore[return-value]
+
+    def get_results(self) -> pd.DataFrame:
+        if self.optimized_params_ is None:
+            self.optimize()
+        assert self.es_ is not None
+        res = self.es_.sample(  # type:ignore[unreachable]
+            {"params": self.optimized_params_}
+        )
+        parsed_result = [
+            {
+                "solution": {
+                    key: value
+                    for key, value in sampled.state["v"].items()
+                    if not re.match(".*_slack_var_.*", key)
+                },
+                "probability": sampled.shots / res.num_shots,
+                "cost": self.cost_func_(sampled.state["v"]),
+            }
+            for sampled in res.parsed_counts
+        ]
+        return pd.DataFrame.from_records(parsed_result)
+
+
+def execute_qaoa(
+    problem_vars: type[QVar],
+    cost_func: Callable,
+    num_layers: int,
+    maxiter: int,
+    execution_preferences: Optional[ExecutionPreferences] = None,
+) -> tuple[SerializedModel, SerializedQuantumProgram, ExecutionDetails]:
+    """
+    Implements a simple QAOA algorithm, including the creation and synthesis of the QAOA
+    ansatz and the classical optimization loop.
+
+    Args:
+        problem_vars: the quantum type (scalar, array, or struct) of the problem variable(s)
+        cost_func: the arithmetic expression that evaluates the cost given an instance of the problem_vars type
+        num_layers: the number of layers of the QAOA ansatz
+        maxiter: the maximum number of iterations for the classical optimization loop
+        execution_preferences: the execution settings for running the QAOA ansatz
+
+    Returns:
+        a tuple containing the model of the QAOA ansatz, the corresponding synthesized quantum program,
+        and the result of the execution with the optimized parameters
+    """
+
+    @qfunc
+    def main(
+        params: CArray[CReal, num_layers * 2],  # type:ignore[valid-type]
+        v: Output[problem_vars],  # type:ignore[valid-type]
+    ) -> None:
+        allocate(v.size, v)  # type:ignore[attr-defined]
+        hadamard_transform(v)
+        repeat(
+            num_layers,
+            lambda i: [  # type:ignore[arg-type]
+                phase(-cost_func(v), params[i]),  # type:ignore[func-returns-value]
+                apply_to_all(lambda q: RX(params[num_layers + i], q), v),
+            ],
+        )
+
+    model = create_model(main)
+    qprog = synthesize(model)
+
+    with ExecutionSession(qprog, execution_preferences) as es:
+        initial_params = (
+            np.concatenate(
+                (np.linspace(0, 1, num_layers), np.linspace(1, 0, num_layers))
+            )
+            * math.pi
+        )
+        final_params = scipy.optimize.minimize(
+            lambda params: es.estimate_cost(
+                lambda state: cost_func(state["v"]),
+                {"params": params.tolist()},
+            ),
+            x0=initial_params,
+            method="COBYLA",
+            options={"maxiter": maxiter},
+        ).x.tolist()
+        result = es.sample({"params": final_params})
+
+    return model, qprog, result

classiq/applications/finance/finance_model_constructor.py

@@ -15,7 +15,7 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 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_type import QuantumBitvector
+from classiq.interface.model.quantum_type import QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -68,8 +68,10 @@ def construct_finance_model(
                 positional_arg_declarations=[
                     PortDeclaration(
                         name="phase_port",
-                        quantum_type=QuantumBitvector(
-                            length=Expression(expr=f"{phase_port_size}")
+                        quantum_type=QuantumNumeric(
+                            size=Expression(expr=f"{phase_port_size}"),
+                            is_signed=Expression(expr="False"),
+                            fraction_digits=Expression(expr=f"{phase_port_size}"),
                         ),
                         direction=PortDeclarationDirection.Output,
                     ),
@@ -84,10 +86,8 @@ def construct_finance_model(
                         ],
                     ),
                     QuantumFunctionCall(
-                        function="allocate_num",
+                        function="allocate",
                         positional_args=[
-                            Expression(expr=f"{phase_port_size}"),
-                            Expression(expr="False"),
                             Expression(expr=f"{phase_port_size}"),
                             HandleBinding(name="phase_port"),
                         ],

classiq/applications/grover/grover_model_constructor.py

@@ -19,6 +19,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 
 from classiq import RegisterUserInput
+from classiq.qmod.builtins.functions.grover import grover_search, phase_oracle
 
 _OUTPUT_VARIABLE_NAME = "result"
 
@@ -151,6 +152,8 @@ def construct_grover_model(
                     ),
                 ],
             ),
+            *[f for f in grover_search.create_model().functions if f.name != "main"],
+            *[f for f in phase_oracle.create_model().functions if f.name != "main"],
         ],
     )
     return grover_model.get_model()

classiq/applications/libraries/qmci_library.py

@@ -1,7 +1,3 @@
-from typing import cast
-
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-
 from classiq.qmod.builtins.functions import Z, amplitude_estimation
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
@@ -22,9 +18,4 @@ def qmci(
     )
 
 
-QMCI_LIBRARY = [
-    cast(
-        NativeFunctionDefinition,
-        qmci.create_model().function_dict["qmci"],
-    ),
-]
+QMCI_LIBRARY = [func for func in qmci.create_model().functions if func.name != "main"]

classiq/applications/qnn/__init__.py

@@ -8,7 +8,7 @@ except ImportError as exc:
 from ..qnn import datasets, types
 from ..qnn.qlayer import QLayer
 
-__all__ = ["datasets", "types", "QLayer"]
+__all__ = ["QLayer", "datasets", "types"]
 
 
 def __dir__() -> list[str]:

classiq/applications/qnn/datasets/__init__.py

@@ -13,19 +13,19 @@ from ..datasets.dataset_xor import DatasetXor
 from ..datasets.datasets_utils import state_to_label, state_to_weights
 
 __all__ = [
-    "builtin_datasets",
-    "DatasetNot",
-    "DATASET_NOT",
     "DATALOADER_NOT",
-    "DatasetXor",
-    "DATASET_XOR",
+    "DATALOADER_SUBSET_PARITY",
     "DATALOADER_XOR",
-    "DatasetSubsetParity",
+    "DATASET_NOT",
     "DATASET_SUBSET_PARITY",
-    "DATALOADER_SUBSET_PARITY",
+    "DATASET_XOR",
+    "DatasetNot",
     "DatasetParity",
-    "state_to_weights",
+    "DatasetSubsetParity",
+    "DatasetXor",
+    "builtin_datasets",
     "state_to_label",
+    "state_to_weights",
 ]
 
 

classiq/applications/qsvm/qsvm.py

@@ -1,9 +1,9 @@
 from classiq.interface.applications.qsvm import Data, Labels, QSVMData
 
 __all__ = [
-    "QSVMData",
     "Data",
     "Labels",
+    "QSVMData",
 ]
 
 

classiq/execution/__init__.py

@@ -10,7 +10,6 @@ from ..interface.executor.vqe_result import VQESolverResult
 from .execution_session import ExecutionSession
 from .iqcc import generate_iqcc_token, generate_iqcc_token_async
 from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
-from .qaoa import execute_qaoa
 from .qnn import execute_qnn
 
 __all__ = (
@@ -25,7 +24,6 @@ __all__ = (
         "get_execution_jobs",
         "get_execution_jobs_async",
         "ExecutionSession",
-        "execute_qaoa",
         "execute_qnn",
         "generate_iqcc_token",
         "generate_iqcc_token_async",

classiq/execution/execution_session.py

@@ -1,4 +1,5 @@
 import json
+import random
 from functools import cached_property
 from types import TracebackType
 from typing import Any, Callable, Optional, Union, cast
@@ -168,6 +169,9 @@ class ExecutionSession:
         # because cmain is expected in some cases
         self.program.model.classical_execution_code = "dummy"
 
+        self._random_seed = self.program.model.execution_preferences.random_seed
+        self._rng = random.Random(self._random_seed)  # noqa: S311
+
         self._async_client = client().async_client()
 
     def __enter__(self) -> "ExecutionSession":
@@ -197,6 +201,8 @@ class ExecutionSession:
         self, classical_execution_code: str, primitives_input: PrimitivesInput
     ) -> ExecutionJob:
         execution_input = self._execution_input.copy()
+        execution_input["execution_preferences"]["random_seed"] = self._random_seed
+        self._random_seed = self._rng.randint(0, 2**32 - 1)
         execution_input["classical_execution_code"] = classical_execution_code
         # The use of `model_dump_json` is necessary for complex numbers serialization
         execution_input["primitives_input"] = json.loads(

classiq/executor.py

@@ -62,8 +62,8 @@ def set_quantum_program_execution_preferences(
 
 
 __all__ = [
+    "OperatorsEstimation",
     "QuantumCode",
     "QuantumInstructionSet",
-    "OperatorsEstimation",
     "set_quantum_program_execution_preferences",
 ]

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.60.1'
+SEMVER_VERSION = '0.61.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -513,25 +513,25 @@ BackendPreferencesTypes = Union[
 ]
 
 __all__ = [
+    "AQTBackendPreferences",
+    "AliceBobBackendNames",
+    "AliceBobBackendPreferences",
+    "AmazonBraketBackendNames",
+    "AwsBackendPreferences",
     "AzureBackendPreferences",
     "AzureCredential",
     "AzureQuantumBackendNames",
     "ClassiqBackendPreferences",
+    "ClassiqNvidiaBackendNames",
     "ClassiqSimulatorBackendNames",
+    "GCPBackendPreferences",
     "IBMBackendPreferences",
     "IBMBackendProvider",
-    "AwsBackendPreferences",
-    "AmazonBraketBackendNames",
-    "IonqBackendPreferences",
-    "IonqBackendNames",
-    "ClassiqNvidiaBackendNames",
+    "IQCCBackendPreferences",
     "IntelBackendNames",
-    "GCPBackendPreferences",
-    "AliceBobBackendPreferences",
-    "AliceBobBackendNames",
-    "OQCBackendPreferences",
-    "OQCBackendNames",
     "IntelBackendPreferences",
-    "AQTBackendPreferences",
-    "IQCCBackendPreferences",
+    "IonqBackendNames",
+    "IonqBackendPreferences",
+    "OQCBackendNames",
+    "OQCBackendPreferences",
 ]

classiq/interface/executor/execution_preferences.py

@@ -65,7 +65,7 @@ class ExecutionPreferences(pydantic.BaseModel):
 
 __all__ = [
     "ExecutionPreferences",
-    "OptimizerType",
     "NoiseProperties",
+    "OptimizerType",
     "QaeWithQpeEstimationMethod",
 ]

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -61,7 +61,7 @@ MOLECULE_GROUND_STATE_SOLUTION_POST_PROCESS = ClassicalFunctionDeclaration(
 )
 
 __all__ = [
-    "MOLECULE_PROBLEM_TO_HAMILTONIAN",
     "FOCK_HAMILTONIAN_PROBLEM_TO_HAMILTONIAN",
     "MOLECULE_GROUND_STATE_SOLUTION_POST_PROCESS",
+    "MOLECULE_PROBLEM_TO_HAMILTONIAN",
 ]

classiq/interface/generator/application_apis/finance_declarations.py

@@ -98,8 +98,8 @@ GAUSSIAN_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
 )
 
 __all__ = [
-    "LOG_NORMAL_FINANCE_FUNCTION",
     "GAUSSIAN_FINANCE_FUNCTION",
-    "LOG_NORMAL_FINANCE_POST_PROCESS",
     "GAUSSIAN_FINANCE_POST_PROCESS",
+    "LOG_NORMAL_FINANCE_FUNCTION",
+    "LOG_NORMAL_FINANCE_POST_PROCESS",
 ]

classiq/interface/generator/arith/arithmetic.py

@@ -9,6 +9,9 @@ from classiq.interface.generator.arith import arithmetic_expression_parser
 from classiq.interface.generator.arith.arithmetic_expression_abc import (
     ArithmeticExpressionABC,
 )
+from classiq.interface.generator.arith.arithmetic_expression_validator import (
+    is_constant,
+)
 from classiq.interface.generator.arith.arithmetic_param_getters import (
     id2op,
     operation_allows_target,
@@ -17,7 +20,9 @@ from classiq.interface.generator.arith.arithmetic_result_builder import (
     ArithmeticResultBuilder,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_type import (
+    QuantumNumeric,
     QuantumType,
     quantum_var_to_register,
     register_info_to_quantum_type,
@@ -28,6 +33,10 @@ ARITHMETIC_EXPRESSION_RESULT_NAME: Final[str] = "expression_result"
 ARITHMETIC_EXPRESSION_GARBAGE_NAME: Final[str] = "expression_garbage"
 
 
+def is_zero(expr: str) -> bool:
+    return is_constant(expr) and float(expr) == 0
+
+
 class Arithmetic(ArithmeticExpressionABC):
     target: Optional[RegisterArithmeticInfo] = None
     inputs_to_save: set[str] = pydantic.Field(default_factory=set)
@@ -99,7 +108,13 @@ def get_arithmetic_params(
 
 def compute_arithmetic_result_type(
     expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
-) -> QuantumType:
+) -> QuantumNumeric:
+    if is_zero(expr_str):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        )
     arith_param = get_arithmetic_params(expr_str, var_types, machine_precision)
     return register_info_to_quantum_type(
         arith_param.outputs[ARITHMETIC_EXPRESSION_RESULT_NAME]