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

classiq/applications/combinatorial_helpers/transformations/fixed_variables.py

@@ -0,0 +1,143 @@
+import copy
+from typing import Union
+
+from pyomo.core import ConcreteModel, Var
+from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.expr.relational_expr import EqualityExpression
+from pyomo.core.expr.visitor import identify_variables
+from pyomo.repn.standard_repn import _GeneralVarData
+
+from classiq.interface.exceptions import (
+    ClassiqCombOptNoSolutionError,
+    ClassiqCombOptTrivialProblemError,
+)
+
+from classiq.applications.combinatorial_helpers import (
+    encoding_utils,
+    pyomo_utils,
+    sympy_utils,
+)
+from classiq.applications.combinatorial_helpers.arithmetic.isolation import isolate
+from classiq.applications.combinatorial_helpers.encoding_utils import (
+    deal_with_trivial_boolean_constraint,
+)
+from classiq.applications.combinatorial_helpers.sympy_utils import (
+    sympyify_expression,
+    sympyify_vars,
+)
+
+
+def remove_fixed_variables(model: ConcreteModel) -> ConcreteModel:
+    _should_iterate_fixing = _should_start_fixing(model)
+
+    while _should_iterate_fixing:
+        _change_fixing_constraints_to_fixed_value(model)
+        variables = pyomo_utils.extract(model, Var)
+
+        substitution_dict = {id(var): _get_value_if_exists(var) for var in variables}
+
+        encoding_utils.encode_constraints(model, substitution_dict)
+        encoding_utils.encode_objective(model, substitution_dict)
+        _remove_empty_constraints(model)
+
+        _should_iterate_fixing = _should_continue_fixing(model)
+
+    assigned_model = copy.deepcopy(model)
+    _check_empty_model(assigned_model)
+    _remove_assigned_variables(model)
+
+    return assigned_model
+
+
+def _should_continue_fixing(model: ConcreteModel) -> bool:
+    return bool(len(_get_fixing_constraints(model)))
+
+
+def _should_start_fixing(model: ConcreteModel) -> bool:
+    variables = pyomo_utils.extract(model, Var)
+    is_some_var_fixed = any(var.value is not None for var in variables)
+
+    return is_some_var_fixed or _should_continue_fixing(model)
+
+
+def _change_fixing_constraints_to_fixed_value(model: ConcreteModel) -> None:
+    for constraint in _get_fixing_constraints(model):
+        var, var_value = _get_var_and_value_from_fixing_constraint(constraint)
+
+        if var.value is not None and var.value != var_value:
+            raise ClassiqCombOptNoSolutionError
+
+        if int(var_value) != var_value or var_value < var.lb or var_value > var.ub:
+            raise ClassiqCombOptNoSolutionError
+
+        var.fix(int(var_value))
+        pyomo_utils.delete_component(model, constraint)
+
+
+def _get_fixing_constraints(model: ConcreteModel) -> list[_GeneralConstraintData]:
+    constraints = pyomo_utils.extract(model, _GeneralConstraintData)
+    return list(filter(_is_fixing_constraint, constraints))
+
+
+def _get_var_and_value_from_fixing_constraint(
+    constraint: _GeneralConstraintData,
+) -> tuple[_GeneralVarData, float]:
+    var = next(identify_variables(constraint.body))
+
+    if isinstance(constraint.body, _GeneralVarData):
+        return var, constraint.upper.value
+
+    symbols_map = sympyify_vars([var])
+    sympy_exp = sympyify_expression(constraint.expr, symbols_map)
+    sympy_var = symbols_map.getSympySymbol(var)
+
+    isolated_exp = isolate(sympy_exp, sympy_var)
+
+    return var, float(isolated_exp.args[1])
+
+
+def _remove_assigned_variables(model: ConcreteModel) -> None:
+    for var in pyomo_utils.extract(model, Var):
+        if var.value is not None:
+            pyomo_utils.delete_component(model, var)
+
+
+def _remove_empty_constraints(model: ConcreteModel) -> None:
+    # (reduces number of slack variables and potential errors)
+    for constraint in pyomo_utils.extract(model, _GeneralConstraintData):
+        sympyified_expression = sympy_utils.sympyify_expression(constraint.expr)
+        deal_with_trivial_boolean_constraint(constraint, sympyified_expression, model)
+
+
+def add_fixed_variables_to_solution(
+    original_model: ConcreteModel, solution: list[int]
+) -> list[int]:
+    variables = pyomo_utils.extract(original_model, Var)
+    solution_iter = iter(solution)
+    # var.value might be 0 as well
+    solution_with_fixed = []
+    for var in variables:
+        if var.value is not None:
+            solution_with_fixed.append(var.value)
+        else:
+            solution_with_fixed.append(next(solution_iter, 0))
+    solution_with_fixed.extend(list(solution_iter))
+    return solution_with_fixed
+
+
+def _get_value_if_exists(var: _GeneralVarData) -> Union[int, _GeneralVarData]:
+    return var.value if var.value is not None else var
+
+
+def _is_fixing_constraint(constraint: _GeneralConstraintData) -> bool:
+    return (
+        isinstance(constraint.expr, EqualityExpression)
+        and len(list(identify_variables(constraint.body))) == 1
+    )
+
+
+def _check_empty_model(model: ConcreteModel) -> None:
+    variables = pyomo_utils.extract(model, Var)
+    if all(var.value is not None for var in variables):
+        solution = add_fixed_variables_to_solution(original_model=model, solution=[])
+        raise ClassiqCombOptTrivialProblemError(solution)

classiq/applications/combinatorial_helpers/transformations/ising_converter.py

@@ -0,0 +1,120 @@
+import pyomo
+import sympy as sp
+from pyomo.core.base import _GeneralVarData
+
+from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.exceptions import ClassiqCombOptNotSupportedProblemError
+from classiq.interface.helpers import custom_pydantic_types
+
+from classiq.applications.combinatorial_helpers import memory
+from classiq.applications.combinatorial_helpers.memory import InternalQuantumReg
+from classiq.applications.combinatorial_helpers.sympy_utils import (
+    sympyify_expression,
+    sympyify_vars,
+)
+
+PYOMO_PARSING_ERROR_MESAGE = "Parsing of this pyomo model is not supported."
+
+
+def convert_pyomo_to_hamiltonian(
+    pyomo_expr: pyomo.core.Expression,
+    ordered_pyomo_vars: list[_GeneralVarData],
+    qregs: list[InternalQuantumReg],
+) -> PauliOperator:
+    symbols_map = sympyify_vars(ordered_pyomo_vars)
+    sympy_expr = sympyify_expression(pyomo_expr, symbols_map)
+    if not sympy_expr.is_polynomial():
+        raise ClassiqCombOptNotSupportedProblemError(PYOMO_PARSING_ERROR_MESAGE)
+
+    ordered_sympy_vars = [
+        symbols_map.pyomo2sympy[pyomo_var] for pyomo_var in ordered_pyomo_vars
+    ]
+    ising_expr = _to_ising_symbolic_objective_function(sympy_expr)
+    ising_expr = _refine_ising_expr(ising_expr)
+
+    operator = _convert_ising_sympy_to_operator(ising_expr, ordered_sympy_vars)
+    operator = _add_auxiliary_qubits_to_operator(operator, qregs)
+
+    return PauliOperator(pauli_list=operator)
+
+
+def _convert_ising_sympy_to_operator(
+    ising_expr: sp.Expr, ordered_sympy_vars: list[sp.Symbol]
+) -> custom_pydantic_types.PydanticPauliList:
+    pauli_op_list: custom_pydantic_types.PydanticPauliList = []
+    for expr_term in ising_expr.args:
+        expr_vars = _get_vars(expr_term)
+        z_vec = _find_sub_list_items(ordered_sympy_vars, expr_vars)
+        pauli_string_list = ["I"] * len(z_vec)
+        for index, is_z_op in enumerate(z_vec):
+            if is_z_op:
+                pauli_string_list[len(z_vec) - index - 1] = (
+                    "Z"  # reminder: Pauli reverses the order!
+                )
+        pauli_string = "".join(pauli_string_list)
+        coeff = _get_coeff_from_expr(expr_term)
+        pauli_op_list.append((pauli_string, complex(coeff)))
+    return pauli_op_list
+
+
+def _refine_ising_expr(ising_expr: sp.Expr) -> sp.Expr:
+    # The variables here are assumed to be either 1 or -1 (ising variables).
+    # Therefore x^a can replaced with 1 if a is even, and with x is a is odd.
+    # Change the expression recursively.
+    def update_expr(expr: sp.Expr) -> sp.Expr:
+        if isinstance(expr, sp.Pow):
+            if expr.args[1] % 2:  # odd power: x**a -> x
+                expr = expr.args[0]
+            else:  # even power: x**a -> 1
+                expr = sp.Float(1)
+        if hasattr(expr, "args") and expr.args:
+            new_args = [update_expr(arg) for arg in expr.args]
+            expr_class = type(expr)
+            return expr_class(*new_args)
+        else:
+            return expr
+
+    return update_expr(ising_expr)
+
+
+def _to_ising_symbolic_objective_function(objective: sp.Expr) -> sp.Expr:
+    # cost-function to Hamiltonian conversion explanation:
+    # https://qiskit.org/textbook/ch-applications/qaoa.html#1.1-Diagonal-Hamiltonians
+    subs_vars_dict = {var: (1 - var) / 2 for var in objective.free_symbols}
+    objective_ising = objective.subs(subs_vars_dict)
+    return sp.expand(objective_ising)
+
+
+def _get_vars(expr_term: sp.AtomicExpr) -> list[sp.Symbol]:
+    if isinstance(expr_term, sp.Symbol):
+        return [expr_term]
+    else:
+        return expr_term.args
+
+
+def _find_sub_list_items(
+    long_list: list[sp.Symbol], sub_list: list[sp.Symbol]
+) -> list[bool]:
+    return [x in sub_list for x in long_list]
+
+
+def _get_coeff_from_expr(expr: sp.Expr) -> float:
+    if isinstance(expr, sp.Number):
+        return float(expr)
+    if isinstance(expr, sp.Symbol):
+        return 1
+    if all(isinstance(arg, sp.Symbol) for arg in expr.args):
+        return 1
+    return float(expr.args[0])
+
+
+def _add_auxiliary_qubits_to_operator(
+    operator: custom_pydantic_types.PydanticPauliList, qregs: list[InternalQuantumReg]
+) -> custom_pydantic_types.PydanticPauliList:
+    # TODO: handle the case when the auxiliary are in the middle of the circuit
+    for qreg in qregs:
+        if qreg.name == memory.AUXILIARY_NAME:
+            operator = [
+                ("I" * qreg.size + monomial[0], monomial[1]) for monomial in operator
+            ]
+    return operator

classiq/applications/combinatorial_helpers/transformations/penalty.py

@@ -0,0 +1,31 @@
+import itertools
+
+from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.expr.relational_expr import EqualityExpression
+from pyomo.environ import Expression
+
+
+def get_penalty_expression(
+    flat_constraints: list[_GeneralConstraintData],
+) -> Expression:
+    return sum(
+        _convert_constraint_to_penalty_term(constraint)
+        for constraint in flat_constraints
+    )
+
+
+def _convert_constraint_to_penalty_term(
+    constraint: _GeneralConstraintData,
+) -> Expression:
+    if isinstance(constraint.expr, EqualityExpression):
+        return (constraint.expr.args[0] - constraint.expr.args[1]) ** 2
+
+    # we can assume that isinstance(constraint.expr, InequalityExpression) and constraint.expr.args[1] == 1
+    # due to _is_constraint_penalty_supported method
+    else:
+        index = 0
+        if isinstance(constraint.expr.args[0], int):
+            index = 1
+        constraint_variables = constraint.expr.args[index].args
+        var_pairs = list(itertools.combinations(constraint_variables, 2))
+        return sum(var1 * var2 for var1, var2 in var_pairs)

classiq/applications/combinatorial_helpers/transformations/penalty_support.py

@@ -0,0 +1,37 @@
+from pyomo.core import ConcreteModel
+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.combinatorial_helpers import (
+    allowed_constraints,
+    encoding_utils,
+)
+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:
+    variables = extract(model, _GeneralVarData)
+    is_vars_supported = all(is_var_penalty_supported(var) for var in variables)
+
+    constraints = extract(model, _GeneralConstraintData)
+    is_constraints_supported = all(
+        is_constraint_penalty_supported(constraint) for constraint in constraints
+    )
+    return is_vars_supported and is_constraints_supported
+
+
+def is_var_penalty_supported(var: _GeneralVarData) -> bool:
+    return encoding_utils.is_var_binary(var) or encoding_utils.is_var_span_power_of_2(
+        var
+    )
+
+
+def is_constraint_penalty_supported(constraint: _GeneralConstraintData) -> bool:
+    if isinstance(constraint.expr, EqualityExpression):
+        return True
+
+    sympy_expr = sympyify_expression(constraint.expr)
+
+    return allowed_constraints.is_constraint_sum_less_than_one(sympy_expr)

classiq/applications/combinatorial_helpers/transformations/sign_seperation.py

@@ -0,0 +1,74 @@
+from itertools import filterfalse
+
+from sympy import (
+    Add,
+    Expr,
+    GreaterThan,
+    LessThan,
+    Mul,
+    Number,
+    Symbol,
+    expand,
+    simplify,
+)
+
+from classiq.interface.exceptions import ClassiqCombOptError
+
+
+def sign_separation(expr: Expr) -> LessThan:
+    expr = simplify(expr)
+    expr = expand(expr)
+
+    if not isinstance(expr, (LessThan, GreaterThan)):
+        raise ClassiqCombOptError("sign separation didn't worked out")
+
+    if isinstance(expr, GreaterThan):
+        expr = LessThan(expr.args[1], expr.args[0])
+
+    expr_body = expr.args[0]
+    expr_bound = expr.args[1]
+
+    positive_body_args, negative_body_args = _get_positive_and_negative_args(expr_body)
+
+    positive_bound_args, negative_bound_args = _get_positive_and_negative_args(
+        expr_bound
+    )
+
+    modified_expr = LessThan(
+        Add(*positive_body_args) - Add(*negative_bound_args),
+        Add(*positive_bound_args) - Add(*negative_body_args),
+    )
+
+    return modified_expr
+
+
+def _get_positive_and_negative_args(expr: Expr) -> tuple[list[Expr], list[Expr]]:
+    positive_args = []
+    negative_args = []
+
+    if isinstance(expr, Add):
+        positive_args += list(filter(_is_positive_expr, expr.args))
+        negative_args += list(filterfalse(_is_positive_expr, expr.args))
+
+    elif _is_positive_expr(expr):
+        positive_args.append(expr)
+    else:
+        negative_args.append(expr)
+
+    if not positive_args and not negative_args:
+        raise ClassiqCombOptError("sign separation didn't worked out")
+
+    return positive_args, negative_args
+
+
+def _is_positive_expr(expr: Expr) -> bool:
+    return (
+        (isinstance(expr, Number) and expr > 0)
+        or isinstance(expr, Symbol)
+        or (
+            isinstance(expr, Mul)
+            and isinstance(expr.args[0], Number)
+            and expr.args[0] > 0
+            and isinstance(expr.args[1], Symbol)
+        )
+    )

classiq/applications/combinatorial_helpers/transformations/slack_variables.py

@@ -0,0 +1,87 @@
+import math
+from functools import cached_property
+from itertools import filterfalse
+
+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.combinatorial_helpers import pyomo_utils
+from classiq.applications.combinatorial_helpers.arithmetic.arithmetic_expression import (
+    multivariate_extremum,
+)
+from classiq.applications.combinatorial_helpers.transformations import penalty_support
+from classiq.applications.combinatorial_helpers.transformations.sign_seperation import (
+    sign_separation,
+)
+
+
+def slack_vars_convert(model: pyo.ConcreteModel) -> pyo.ConcreteModel:
+    constraints = pyomo_utils.extract(model, pyo.Constraint)
+    converted_constraints = list(
+        filterfalse(penalty_support.is_constraint_penalty_supported, constraints)
+    )
+
+    for constraint in converted_constraints:
+        convertor = ConstraintConvertor(constraint)
+        setattr(model, convertor.slack_var_name, convertor.slack_var)
+        setattr(model, convertor.slack_constraint_name, convertor.slack_constraint)
+
+        pyomo_utils.delete_component(model, constraint)
+
+    return model
+
+
+_SLACK_VAR_SUFFIX = "_slack_var"
+_SLACK_SUFFIX = "_slack"
+
+
+def is_obj_slacked(var: _ComponentBase) -> bool:
+    return _SLACK_SUFFIX in var.name
+
+
+class ConstraintConvertor:
+    def __init__(self, constraint: pyo.Constraint) -> None:
+        self._symbols_map, self._expr = sympyify_expression(constraint.expr)
+        self._expr = sign_separation(self._expr)
+        self._expr_lower, self._expr_upper = self._expr.args
+
+        self._name = pyomo_utils.get_name(constraint)
+
+        self.slack_var_name = self._name + _SLACK_VAR_SUFFIX
+        self.slack_var_idxs = range(self._bound_int.bit_length())
+        self.slack_var = pyo.Var(self.slack_var_idxs, domain=pyo.Binary)
+        self.slack_var.construct()
+
+        self.slack_constraint_name = self._name + _SLACK_SUFFIX
+
+    @cached_property
+    def _bound_int(self) -> int:
+        max_upper = math.ceil(
+            multivariate_extremum(self._expr_upper, self._symbols_map, is_min=False)
+        )
+        min_lower = math.floor(
+            multivariate_extremum(self._expr_lower, self._symbols_map, is_min=True)
+        )
+        return max_upper - min_lower
+
+    @cached_property
+    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
+
+    @cached_property
+    def _slack_expr(self) -> pyo.Expression:
+        return sum(
+            coeff * self.slack_var[num] for num, coeff in enumerate(self._slack_coeffs)
+        )
+
+    @cached_property
+    def slack_constraint(self) -> pyo.Constraint:
+        expr_lower_pyomo = sympy2pyomo_expression(self._expr_lower, self._symbols_map)
+        expr_upper_pyomo = sympy2pyomo_expression(self._expr_upper, self._symbols_map)
+
+        return pyo.Constraint(
+            expr=expr_lower_pyomo + self._slack_expr == expr_upper_pyomo
+        )

classiq/applications/combinatorial_optimization/__init__.py

@@ -1,17 +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.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/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -0,0 +1,137 @@
+from typing import Optional
+
+from pyomo import environ as pyo
+from pyomo.core import Objective, maximize
+
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    Real,
+)
+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_helpers.combinatorial_problem_utils import (
+    compute_qaoa_initial_point,
+    convert_pyomo_to_global_presentation,
+    pyo_model_to_hamiltonian,
+)
+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(
+    pyo_model: pyo.ConcreteModel,
+    qaoa_config: Optional[QAOAConfig] = None,
+    optimizer_config: Optional[OptimizerConfig] = None,
+) -> Model:
+    if qaoa_config is None:
+        qaoa_config = QAOAConfig()
+
+    if optimizer_config is None:
+        optimizer_config = OptimizerConfig()
+
+    max_iteration = 0
+    if optimizer_config.max_iteration is not None:
+        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)
+    pauli_qmod = _pauli_terms_to_qmod(hamiltonian)
+
+    initial_point_expression = (
+        f"{optimizer_config.initial_point}"
+        if optimizer_config.initial_point is not None
+        else f"{qaoa_initial_point}"
+    )
+
+    return Model(
+        constants=[
+            Constant(
+                name="hamiltonian",
+                const_type=ClassicalList(element_type=Struct(name="PauliTerm")),
+                value=Expression(expr=f"[{pauli_qmod}]"),
+            )
+        ],
+        functions=[
+            NativeFunctionDefinition(
+                name="main",
+                positional_arg_declarations=[
+                    ClassicalParameterDeclaration(
+                        name="params_list",
+                        classical_type=ClassicalArray(
+                            element_type=Real(), size=qaoa_config.num_layers * 2
+                        ),
+                    ),
+                    PortDeclaration(
+                        name="target",
+                        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="qaoa_penalty",
+                        positional_args=[
+                            Expression(expr="get_field(target, 'len')"),
+                            Expression(expr="params_list"),
+                            Expression(expr="hamiltonian"),
+                            HandleBinding(name="target"),
+                        ],
+                    ),
+                ],
+            ),
+            *[f for f in qaoa_penalty.create_model().functions if f.name != "main"],
+        ],
+        classical_execution_code=f"""
+vqe_result = vqe(
+hamiltonian=hamiltonian,
+maximize={next(pyo_model.component_objects(Objective)).sense == maximize},
+initial_point={initial_point_expression},
+optimizer=Optimizer.{optimizer_config.opt_type},
+max_iteration={max_iteration},
+tolerance={optimizer_config.tolerance},
+step_size={optimizer_config.step_size},
+skip_compute_variance={optimizer_config.skip_compute_variance},
+alpha_cvar={optimizer_config.alpha_cvar}
+)
+
+save({{"vqe_result": vqe_result, "hamiltonian": hamiltonian}})
+""".strip(),
+    )
+
+
+def construct_combinatorial_optimization_model(
+    pyo_model: pyo.ConcreteModel,
+    qaoa_config: Optional[QAOAConfig] = None,
+    optimizer_config: Optional[OptimizerConfig] = None,
+) -> SerializedModel:
+    converted_pyo_model = convert_pyomo_to_global_presentation(pyo_model)
+    model = construct_combi_opt_py_model(
+        converted_pyo_model, qaoa_config, optimizer_config
+    )
+    return model.get_model()