classiq 0.60.1__py3-none-any.whl → 0.62.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_helpers/optimization_model.py

@@ -23,7 +23,10 @@ from classiq.applications.combinatorial_helpers import (
 )
 from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
 from classiq.applications.combinatorial_helpers.memory import InternalQuantumReg
-from classiq.applications.combinatorial_helpers.pyomo_utils import get_field_name
+from classiq.applications.combinatorial_helpers.pyomo_utils import (
+    get_field_name,
+    is_index_var,
+)
 from classiq.applications.combinatorial_helpers.transformations import (
     encoding,
     ising_converter,
@@ -176,7 +179,11 @@ class OptimizationModel:
             for key, value in penalty_map.pyomo2sympy.items():
                 objective_map.pyomo2sympy[key] = value
         sympy_mapping = {
-            sympy_var: get_field_name(pyomo_var)
+            sympy_var: (
+                get_field_name(pyomo_var)
+                if not is_index_var(pyomo_var)
+                else (get_field_name(pyomo_var.parent_component()), pyomo_var.index())
+            )
             for pyomo_var, sympy_var in objective_map.pyomo2sympy.items()
         }
         self.objective_not_encoded_sympy = sympy_mapping, objective_expr

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -1,5 +1,6 @@
 import math
 import re
+from collections import defaultdict
 from enum import Enum
 from typing import Any, Optional, TypeVar, Union
 
@@ -24,7 +25,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import Integer
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
-from classiq.qmod.qmod_variable import QBit, QNum, QStruct, QVar
+from classiq.qmod.qmod_variable import QArray, QBit, QNum, QStruct, QVar
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 ListVars = list[_GeneralVarData]
@@ -262,14 +263,51 @@ def pyomo_to_qmod_qstruct(
     struct_name: str, vars: list[_GeneralVarData]
 ) -> type[QStruct]:
     qmod_struct = type(struct_name, (QStruct,), {})
-    var_names = {get_field_name(var): var for var in vars}
-    qmod_struct.__annotations__ = {
-        var_name: _get_qmod_field_type(var_name, var_data)
-        for var_name, var_data in var_names.items()
-    }
+    qmod_struct.__annotations__ = _get_qstruct_fields(vars)
     return qmod_struct
 
 
+def _get_qstruct_fields(vars: list[_GeneralVarData]) -> dict[str, type[QVar]]:
+    array_types = _get_array_types(vars)
+    array_type_sizes = _get_array_sizes(array_types)
+    fields: dict[str, type[QVar]] = {}
+    for var in vars:
+        _add_qmod_field(var, array_type_sizes, fields)
+    return fields
+
+
+def _get_array_types(vars: list[_GeneralVarData]) -> dict[str, set[int]]:
+    array_types: dict[str, set[int]] = defaultdict(set)
+    for var in vars:
+        if is_index_var(var):
+            array_types[var.parent_component().name].add(var.index())
+    return array_types
+
+
+def _get_array_sizes(array_types: dict[str, set[int]]) -> dict[str, int]:
+    return {
+        name: array_size
+        for name, indices in array_types.items()
+        if indices == set(range(array_size := len(indices)))
+    }
+
+
+def _add_qmod_field(
+    var: _GeneralVarData,
+    array_type_sizes: dict[str, int],
+    fields: dict[str, type[QVar]],
+) -> None:
+    parent_name = var.parent_component().name
+    if parent_name not in array_type_sizes:
+        var_name = get_field_name(var)
+        fields[var_name] = _get_qmod_field_type(var_name, var)
+    elif var.index() == 0:
+        fields[parent_name] = QArray[  # type:ignore[misc]
+            _get_qmod_field_type(parent_name, var),
+            array_type_sizes[parent_name],
+        ]
+
+
 def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]:
     if var_data.domain not in SUPPORTED_TYPES:
         raise ClassiqValueError(
@@ -294,11 +332,17 @@ def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]
 
 
 def evaluate_objective(
-    var_mapping: dict, sympy_expr: sympy.Expr, struct_obj: Any
+    var_mapping: dict[Any, Union[str, tuple[str, int]]],
+    sympy_expr: sympy.Expr,
+    struct_obj: Any,
 ) -> Any:
     sympy_assignment = {
-        sympy_var: getattr(struct_obj, field_name)
-        for sympy_var, field_name in var_mapping.items()
+        sympy_var: (
+            getattr(struct_obj, field_accessor)
+            if isinstance(field_accessor, str)
+            else getattr(struct_obj, field_accessor[0])[field_accessor[1]]
+        )
+        for sympy_var, field_accessor in var_mapping.items()
     }
 
     # classical objective evaluation
@@ -315,3 +359,10 @@ def evaluate_objective(
 
 def get_field_name(var: _GeneralVarData) -> str:
     return var.local_name.replace("[", "_").replace("]", "")
+
+
+def is_index_var(var: _GeneralVarData) -> bool:
+    return (
+        isinstance(var.index(), int)
+        and "[" not in var.parent_component().name  # nested arrays not supported
+    )

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,230 @@
+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 tqdm import tqdm
+
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.executor.result import ExecutionDetails
+from classiq.interface.model.model import SerializedModel
+
+from classiq import Constraints, Preferences
+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
+        self.params_trace_: list[np.ndarray] = []
+        self.cost_trace_: list = []
+
+    @property
+    def cost_trace(self) -> list:
+        return self.cost_trace_
+
+    @property
+    def params_trace(self) -> list[np.ndarray]:
+        return self.params_trace_
+
+    @property
+    def optimized_params(self) -> list:
+        return self.optimized_params_  # type:ignore[return-value]
+
+    def get_model(
+        self,
+        constraints: Optional[Constraints] = None,
+        preferences: Optional[Preferences] = None,
+    ) -> 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, constraints=constraints, preferences=preferences
+        )  # 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,
+        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]
+        )
+        self.params_trace_ = []
+        self.cost_trace_ = []
+
+        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,
+            )
+            self.cost_trace_.append(cost)
+            self.params_trace_.append(params)
+            return cost
+
+        initial_params = (
+            np.concatenate(
+                (
+                    np.linspace(1 / self.num_layers_, 1, self.num_layers_),
+                    np.linspace(1, 1 / self.num_layers_, self.num_layers_),
+                )
+            )
+            * math.pi
+        )
+
+        with tqdm(total=maxiter, desc="Optimization Progress", leave=True) as pbar:
+
+            def _minimze_callback(xk: np.ndarray) -> None:
+                pbar.update(1)  # increment progress bar
+                self.optimized_params_ = xk.tolist()  # save recent optimized value
+
+            self.optimized_params_ = scipy.optimize.minimize(
+                estimate_cost_wrapper,
+                callback=_minimze_callback,
+                x0=initial_params,
+                method="COBYLA",
+                options={"maxiter": maxiter},
+            ).x.tolist()
+
+        return self.optimized_params_  # type:ignore[return-value]
+
+    def sample_uniform(self) -> pd.DataFrame:
+        return self.sample([0] * self.num_layers_ * 2)
+
+    def sample(self, params: list) -> pd.DataFrame:
+        assert self.es_ is not None
+        res = self.es_.sample(  # type:ignore[unreachable]
+            {"params": 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(