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

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/penalty.py

@@ -1,5 +1,4 @@
 import itertools
-from typing import List
 
 from pyomo.core.base.constraint import _GeneralConstraintData
 from pyomo.core.expr.relational_expr import EqualityExpression
@@ -7,7 +6,7 @@ from pyomo.environ import Expression
 
 
 def get_penalty_expression(
-    flat_constraints: List[_GeneralConstraintData],
+    flat_constraints: list[_GeneralConstraintData],
 ) -> Expression:
     return sum(
         _convert_constraint_to_penalty_term(constraint)

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/penalty_support.py

@@ -3,16 +3,12 @@ from pyomo.core.base.constraint import _GeneralConstraintData
 from pyomo.core.expr.relational_expr import EqualityExpression
 from pyomo.repn.standard_repn import _GeneralVarData
 
-from classiq.applications_model_constructors.combinatorial_helpers import (
+from classiq.applications.combinatorial_helpers import (
     allowed_constraints,
     encoding_utils,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pyomo_utils import (
-    extract,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.sympy_utils import (
-    sympyify_expression,
-)
+from classiq.applications.combinatorial_helpers.pyomo_utils import extract
+from classiq.applications.combinatorial_helpers.sympy_utils import sympyify_expression
 
 
 def is_model_penalty_supported(model: ConcreteModel) -> bool:

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/sign_seperation.py

@@ -1,5 +1,4 @@
 from itertools import filterfalse
-from typing import List, Tuple
 
 from sympy import (
     Add,
@@ -13,7 +12,7 @@ from sympy import (
     simplify,
 )
 
-from classiq.exceptions import ClassiqCombOptError
+from classiq.interface.exceptions import ClassiqCombOptError
 
 
 def sign_separation(expr: Expr) -> LessThan:
@@ -43,7 +42,7 @@ def sign_separation(expr: Expr) -> LessThan:
     return modified_expr
 
 
-def _get_positive_and_negative_args(expr: Expr) -> Tuple[List[Expr], List[Expr]]:
+def _get_positive_and_negative_args(expr: Expr) -> tuple[list[Expr], list[Expr]]:
     positive_args = []
     negative_args = []
 

classiq/{applications_model_constructors → applications}/combinatorial_helpers/transformations/slack_variables.py

@@ -1,20 +1,17 @@
 import math
 from functools import cached_property
 from itertools import filterfalse
-from typing import List
 
 import pyomo.core as pyo
 from pyomo.core.base.component import _ComponentBase
 from pyomo.core.expr.sympy_tools import sympy2pyomo_expression, sympyify_expression
 
-from classiq.applications_model_constructors.combinatorial_helpers import pyomo_utils
-from classiq.applications_model_constructors.combinatorial_helpers.arithmetic.arithmetic_expression import (
+from classiq.applications.combinatorial_helpers import pyomo_utils
+from classiq.applications.combinatorial_helpers.arithmetic.arithmetic_expression import (
     multivariate_extremum,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.transformations import (
-    penalty_support,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.transformations.sign_seperation import (
+from classiq.applications.combinatorial_helpers.transformations import penalty_support
+from classiq.applications.combinatorial_helpers.transformations.sign_seperation import (
     sign_separation,
 )
 
@@ -69,7 +66,7 @@ class ConstraintConvertor:
         return max_upper - min_lower
 
     @cached_property
-    def _slack_coeffs(self) -> List[int]:
+    def _slack_coeffs(self) -> list[int]:
         coeffs = [2**idx for idx in self.slack_var_idxs[:-1]]
         coeffs += [self._bound_int - sum(coeffs)]
         return coeffs

classiq/applications/combinatorial_optimization/__init__.py

@@ -1,22 +1,36 @@
-from typing import List
-
 from classiq.interface.combinatorial_optimization import examples
+from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
 
-from classiq.applications_model_constructors.combinatorial_helpers.combinatorial_problem_utils import (
+from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
+    compute_qaoa_initial_point,
     get_optimization_solution_from_pyo,
+    pyo_model_to_hamiltonian,
 )
 
 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",
-    "QAOAConfig",
-    "OptimizerConfig",
+    "execute_qaoa",
     "get_optimization_solution_from_pyo",
+    "pyo_model_to_hamiltonian",
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/combinatorial_optimization/combinatorial_optimization_config.py

@@ -1,6 +1,6 @@
 import dataclasses
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 from classiq.interface.executor.optimizer_preferences import CostType, OptimizerType
 
@@ -20,4 +20,4 @@ class OptimizerConfig:
     skip_compute_variance: bool = False
     cost_type: CostType = CostType.CVAR
     alpha_cvar: float = 1.0
-    initial_point: Optional[List[float]] = dataclasses.field(default=None)
+    initial_point: Optional[list[float]] = dataclasses.field(default=None)

classiq/{applications_model_constructors → applications/combinatorial_optimization}/combinatorial_optimization_model_constructor.py

@@ -9,30 +9,32 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
     Real,
-    Struct,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import Struct
+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_type import QuantumBitvector
 
-from classiq.applications.combinatorial_optimization.combinatorial_optimization_config import (
-    OptimizerConfig,
-    QAOAConfig,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.combinatorial_problem_utils import (
+from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
     compute_qaoa_initial_point,
     convert_pyomo_to_global_presentation,
     pyo_model_to_hamiltonian,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_utils import (
-    _pauli_operator_to_qmod,
-    get_pauli_operator,
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    _pauli_terms_to_qmod,
 )
+from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
+from classiq.open_library.functions.qaoa_penalty import qaoa_penalty
 
 
 def construct_combi_opt_py_model(
@@ -51,10 +53,9 @@ def construct_combi_opt_py_model(
         max_iteration = optimizer_config.max_iteration
 
     hamiltonian = pyo_model_to_hamiltonian(pyo_model, qaoa_config.penalty_energy)
+    len_hamiltonian = len(hamiltonian[0].pauli)  # type: ignore[arg-type]
     qaoa_initial_point = compute_qaoa_initial_point(hamiltonian, qaoa_config.num_layers)
-    len_hamiltonian = len(hamiltonian[0]["pauli"])
-    pauli_oper = get_pauli_operator(hamiltonian)
-    pauli_qmod = _pauli_operator_to_qmod(pauli_oper)
+    pauli_qmod = _pauli_terms_to_qmod(hamiltonian)
 
     initial_point_expression = (
         f"{optimizer_config.initial_point}"
@@ -73,37 +74,38 @@ def construct_combi_opt_py_model(
         functions=[
             NativeFunctionDefinition(
                 name="main",
-                param_decls={
-                    "params_list": ClassicalArray(
-                        element_type=Real(), size=qaoa_config.num_layers * 2
-                    )
-                },
-                port_declarations={
-                    "target": PortDeclaration(
+                positional_arg_declarations=[
+                    ClassicalParameterDeclaration(
+                        name="params_list",
+                        classical_type=ClassicalArray(
+                            element_type=Real(), size=qaoa_config.num_layers * 2
+                        ),
+                    ),
+                    PortDeclaration(
                         name="target",
-                        size=Expression(expr=f"{len_hamiltonian}"),
+                        quantum_type=QuantumBitvector(
+                            length=Expression(expr=f"{len_hamiltonian}"),
+                        ),
                         direction=PortDeclarationDirection.Output,
                     ),
-                },
+                ],
                 body=[
+                    Allocate(
+                        size=Expression(expr="get_field(target, 'len')"),
+                        target=HandleBinding(name="target"),
+                    ),
                     QuantumFunctionCall(
-                        function="allocate",
+                        function="qaoa_penalty",
                         positional_args=[
-                            Expression(expr="len(target)"),
+                            Expression(expr="get_field(target, 'len')"),
+                            Expression(expr="params_list"),
+                            Expression(expr="hamiltonian"),
                             HandleBinding(name="target"),
                         ],
                     ),
-                    QuantumFunctionCall(
-                        function="qaoa_penalty",
-                        params={
-                            "num_qubits": Expression(expr="len(target)"),
-                            "params_list": Expression(expr="params_list"),
-                            "hamiltonian": Expression(expr="hamiltonian"),
-                        },
-                        inouts={"target": HandleBinding(name="target")},
-                    ),
                 ],
             ),
+            *[f for f in qaoa_penalty.create_model().functions if f.name != "main"],
         ],
         classical_execution_code=f"""
 vqe_result = vqe(
@@ -119,7 +121,7 @@ alpha_cvar={optimizer_config.alpha_cvar}
 )
 
 save({{"vqe_result": vqe_result, "hamiltonian": hamiltonian}})
-""",
+""".strip(),
     )
 
 

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -0,0 +1,229 @@
+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.open_library.functions.utility_functions import (
+    apply_to_all,
+    hadamard_transform,
+)
+from classiq.qmod.builtins.functions import RX
+from classiq.qmod.builtins.operations import allocate, 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/combinatorial_optimization/examples/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.combinatorial_optimization.examples.ascending_sequence import (
     ascending_sequence,
 )
@@ -47,5 +45,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/finance/__init__.py

@@ -1,19 +1,18 @@
-from typing import List
-
 from classiq.interface.finance import (
     function_input,
     gaussian_model_input,
     log_normal_model_input,
-    model_input,
 )
 
+from .finance_model_constructor import construct_finance_model
+
 __all__ = [
+    "construct_finance_model",
     "function_input",
     "gaussian_model_input",
     "log_normal_model_input",
-    "model_input",
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__