classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

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__

classiq/{applications_model_constructors → applications/finance}/finance_model_constructor.py

@@ -1,36 +1,30 @@
 from math import floor, log
 from typing import Union
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.finance.function_input import FinanceFunctionInput
 from classiq.interface.finance.gaussian_model_input import GaussianModelInput
 from classiq.interface.finance.log_normal_model_input import LogNormalModelInput
-from classiq.interface.generator.expressions.enums.finance_functions import (
-    FINANCE_FUNCTION_STRING,
-    FinanceFunctionType,
-)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 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,
-    QuantumLambdaFunction,
-)
+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 QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
-from classiq.applications_model_constructors.libraries.ampltitude_estimation_library import (
-    AE_CLASSICAL_LIBRARY,
-)
-from classiq.applications_model_constructors.libraries.qmci_library import QMCI_LIBRARY
-from classiq.exceptions import ClassiqError
+from classiq.applications.libraries.qmci_library import QMCI_LIBRARY
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
-_OUTPUT_VARIABLE_NAME = "result"
+_OUTPUT_VARIABLE_NAME = "payoff_estimation"
 
 
 def construct_finance_model(
@@ -56,13 +50,6 @@ def construct_finance_model(
     else:
         raise ClassiqError(f"Invalid model input: {finance_model_input}")
 
-    if isinstance(finance_function_input.f, FinanceFunctionType):
-        finance_function_f = finance_function_input.f
-    elif isinstance(finance_function_input.f, str):
-        finance_function_f = FINANCE_FUNCTION_STRING[finance_function_input.f]
-    else:
-        finance_function_f = FinanceFunctionType(finance_function_input.f)
-
     polynomial_degree = 0
     if finance_function_input.polynomial_degree is not None:
         polynomial_degree = finance_function_input.polynomial_degree
@@ -71,7 +58,7 @@ def construct_finance_model(
     if finance_function_input.tail_probability is not None:
         tail_probability = finance_function_input.tail_probability
 
-    finance_function_object = f"struct_literal(FinanceFunction, f={finance_function_f}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
+    finance_function_object = f"struct_literal(FinanceFunction, f={qmod_val_to_expr_str(finance_function_input.f)}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
     num_unitary_qubits = total_num_qubits + 1
 
     model = Model(
@@ -79,57 +66,63 @@ def construct_finance_model(
             *QMCI_LIBRARY,
             NativeFunctionDefinition(
                 name="main",
-                port_declarations={
-                    "phase_port": PortDeclaration(
+                positional_arg_declarations=[
+                    PortDeclaration(
                         name="phase_port",
-                        size=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,
                     ),
-                },
+                ],
                 body=[
                     VariableDeclarationStatement(name="unitary_port"),
+                    Allocate(
+                        size=Expression(expr=f"{num_unitary_qubits}"),
+                        target=HandleBinding(name="unitary_port"),
+                    ),
+                    Allocate(
+                        size=Expression(expr=f"{phase_port_size}"),
+                        target=HandleBinding(name="phase_port"),
+                    ),
                     QuantumFunctionCall(
                         function="qmci",
-                        params={
-                            "num_unitary_qubits": Expression(
-                                expr=f"{num_unitary_qubits}"
-                            ),
-                            "num_phase_qubits": Expression(expr=f"{phase_port_size}"),
-                        },
-                        operands={
-                            "sp_op": QuantumLambdaFunction(
+                        positional_args=[
+                            QuantumLambdaFunction(
+                                pos_rename_params=["state", "ind"],
                                 body=[
                                     QuantumFunctionCall(
                                         function=finance_function,
-                                        params={
-                                            "finance_model": Expression(
-                                                expr=finance_model
-                                            ),
-                                            "finance_function": Expression(
-                                                expr=finance_function_object
-                                            ),
-                                        },
-                                        inouts={
-                                            "func_port": HandleBinding(name="reg"),
-                                            "obj_port": HandleBinding(name="ind"),
-                                        },
+                                        positional_args=[
+                                            Expression(expr=finance_model),
+                                            Expression(expr=finance_function_object),
+                                            HandleBinding(name="state"),
+                                            HandleBinding(name="ind"),
+                                        ],
                                     ),
                                 ],
                             ),
-                        },
-                        outputs={
-                            "phase_port": HandleBinding(name="phase_port"),
-                            "unitary_port": HandleBinding(name="unitary_port"),
-                        },
+                            HandleBinding(name="phase_port"),
+                            HandleBinding(name="unitary_port"),
+                        ],
                     ),
                 ],
             ),
         ],
-        classical_execution_code=AE_CLASSICAL_LIBRARY
-        + f"""
-estimation = execute_amplitude_estimation({phase_port_size})
-{_OUTPUT_VARIABLE_NAME} = {post_process_function}({finance_model}, {finance_function_object}, estimation)
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""",
+        classical_execution_code=f"""
+phase_port_size = {phase_port_size}
+counts = sample()
+save({{"counts": counts}})
+probability_estimation = qae_with_qpe_result_post_processing(
+    estimation_register_size=phase_port_size,
+    estimation_method=1,
+    result=counts
+)
+save({{"probability_estimation": probability_estimation}})
+{_OUTPUT_VARIABLE_NAME} = {post_process_function}({finance_model}, {finance_function_object}, probability_estimation)
+save({{"{_OUTPUT_VARIABLE_NAME}": {_OUTPUT_VARIABLE_NAME}}})
+""".strip(),
     )
     return model.get_model()

classiq/applications/grover/__init__.py

@@ -0,0 +1,9 @@
+from .grover_model_constructor import construct_grover_model
+
+__all__ = [
+    "construct_grover_model",
+]
+
+
+def __dir__() -> list[str]:
+    return __all__

classiq/applications/grover/grover_model_constructor.py

@@ -0,0 +1,157 @@
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
+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_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+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, QuantumNumeric
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq import RegisterUserInput
+from classiq.open_library.functions.grover import grover_search, phase_oracle
+
+_OUTPUT_VARIABLE_NAME = "result"
+
+_PREDICATE_FUNCTION_NAME = "expr_predicate"
+
+
+def _arithmetic_oracle_ios(
+    definitions: list[tuple[str, RegisterUserInput]], handle_name: str
+) -> list[HandleBinding]:
+    cursor = 0
+    ios: list[HandleBinding] = []
+    for _, reg in definitions:
+        ios.append(
+            SlicedHandleBinding(
+                base_handle=HandleBinding(name=handle_name),
+                start=Expression(expr=f"{cursor}"),
+                end=Expression(expr=f"{cursor + reg.size}"),
+            )
+        )
+        cursor += reg.size
+    return ios
+
+
+def _construct_arithmetic_oracle(
+    predicate_function: str,
+    definitions: list[tuple[str, RegisterUserInput]],
+) -> QuantumFunctionCall:
+    predicate_var_binding = _arithmetic_oracle_ios(definitions, "state")
+    predicate_var_binding.append(HandleBinding(name="oracle"))
+    return QuantumFunctionCall(
+        function="phase_oracle",
+        positional_args=[
+            QuantumLambdaFunction(
+                pos_rename_params=["state", "oracle"],
+                body=[
+                    QuantumFunctionCall(
+                        function=predicate_function,
+                        positional_args=predicate_var_binding,
+                    ),
+                ],
+            ),
+            HandleBinding(name="packed_vars"),
+        ],
+    )
+
+
+def grover_main_port_declarations(
+    definitions: list[tuple[str, RegisterUserInput]],
+    direction: PortDeclarationDirection,
+) -> list[PortDeclaration]:
+    return [
+        PortDeclaration(
+            name=name,
+            quantum_type=QuantumNumeric(
+                size=Expression(expr=f"{reg.size}"),
+                is_signed=Expression(expr=f"{reg.is_signed}"),
+                fraction_digits=Expression(expr=f"{reg.fraction_places}"),
+            ),
+            direction=direction,
+        )
+        for name, reg in definitions
+    ]
+
+
+def construct_grover_model(
+    definitions: list[tuple[str, RegisterUserInput]],
+    expression: str,
+    num_reps: int = 1,
+) -> SerializedModel:
+    predicate_port_decls = grover_main_port_declarations(
+        definitions, PortDeclarationDirection.Inout
+    )
+    predicate_port_decls.append(
+        PortDeclaration(
+            name="res",
+            quantum_type=QuantumBitvector(length=Expression(expr="1")),
+            direction=PortDeclarationDirection.Inout,
+        )
+    )
+    num_qubits = sum(reg.size for _, reg in definitions)
+
+    grover_model = Model(
+        functions=[
+            NativeFunctionDefinition(
+                name=_PREDICATE_FUNCTION_NAME,
+                positional_arg_declarations=predicate_port_decls,
+                body=[
+                    ArithmeticOperation(
+                        expression=Expression(expr=expression),
+                        result_var=HandleBinding(name="res"),
+                        operation_kind=ArithmeticOperationKind.InplaceXor,
+                    ),
+                ],
+            ),
+            NativeFunctionDefinition(
+                name="main",
+                positional_arg_declarations=grover_main_port_declarations(
+                    definitions, PortDeclarationDirection.Output
+                ),
+                body=[
+                    VariableDeclarationStatement(name="packed_vars"),
+                    Allocate(
+                        size=Expression(expr=f"{num_qubits}"),
+                        target=HandleBinding(name="packed_vars"),
+                    ),
+                    QuantumFunctionCall(
+                        function="grover_search",
+                        positional_args=[
+                            Expression(expr=f"{num_reps}"),
+                            QuantumLambdaFunction(
+                                pos_rename_params=["packed_vars"],
+                                body=[
+                                    _construct_arithmetic_oracle(
+                                        _PREDICATE_FUNCTION_NAME,
+                                        definitions,
+                                    )
+                                ],
+                            ),
+                            HandleBinding(name="packed_vars"),
+                        ],
+                    ),
+                    BindOperation(
+                        in_handles=[HandleBinding(name="packed_vars")],
+                        out_handles=[
+                            HandleBinding(name=name) for name, _ in definitions
+                        ],
+                    ),
+                ],
+            ),
+            *[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()