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

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -0,0 +1,245 @@
+import json
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
+
+import pydantic
+import pyomo.core.expr.numeric_expr as pyo_expr
+import pyomo.environ as pyo
+import sympy
+from pyomo.core import ConcreteModel, Constraint, Objective, Var, maximize
+from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.component import ComponentData
+from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.base.indexed_component import IndexedComponent
+from pyomo.core.base.objective import ScalarObjective
+from pyomo.core.expr.sympy_tools import (
+    Pyomo2SympyVisitor,
+    PyomoSympyBimap,
+    Sympy2PyomoVisitor,
+)
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+
+from classiq.exceptions import ClassiqValueError
+
+ListVars = List[_GeneralVarData]
+
+
+class ObjectiveType(Enum):
+    Min = "Min"
+    Max = "Max"
+
+
+class CombinatorialOptimizationStructDeclaration(StructDeclaration):
+    variable_lower_bound: int = pydantic.Field(default=0)
+    variable_upper_bound: int = pydantic.Field(default=1)
+    constraints: List[Expression] = pydantic.Field(
+        default_factory=list, description="List of constraint expressions"
+    )
+    objective_type: ObjectiveType = pydantic.Field(
+        description="Specify whether the optimization problem is Min or Max"
+    )
+    objective_function: Expression = pydantic.Field(
+        description="The expression to optimize, according to the objective type"
+    )
+
+
+def contains(var_data: _GeneralVarData, vars_data: ListVars) -> bool:
+    # HACK: standard "__containts__ (in)" method doesn't work, because pyomo overrode the __eq__ method (IMO)
+    return any(var_data is var_data_temp for var_data_temp in vars_data)
+
+
+def remove(var_data: _GeneralVarData, vars_data: ListVars) -> ListVars:
+    # HACK: standard "list method remove" method doesn't work, because pyomo overrode the __eq__ method (IMO)
+    assert contains(var_data, vars_data), "var not in list"
+    vars_data = vars_data.copy()
+    for idx, var_data_temp in enumerate(vars_data):
+        if var_data_temp is var_data:
+            del vars_data[idx]
+            break
+    return vars_data
+
+
+def index(var_data: _GeneralVarData, vars_data: ListVars) -> int:
+    # HACK: standard "index method" doesn't work.
+    assert contains(var_data, vars_data), "var not in list"
+    idxs = [
+        idx for idx, var_data_temp in enumerate(vars_data) if var_data is var_data_temp
+    ]
+    return idxs[0]
+
+
+T = TypeVar("T")
+
+
+def extract(model: ConcreteModel, type_: Type[T]) -> List[T]:
+    if type_ == _GeneralVarData:
+        type_ = Var
+
+    elif type_ == _GeneralConstraintData:
+        type_ = Constraint
+
+    components = model.component_objects(type_)
+    return [
+        component[component_idx]
+        for component in components
+        for component_idx in component
+    ]
+
+
+def delete_component(model: ConcreteModel, component: ComponentData) -> None:
+    parent_ref = component._component
+
+    if parent_ref is None:
+        return
+
+    parent_component = parent_ref()
+
+    if component is parent_component:
+        model.del_component(component)
+    else:
+        _delete_element_by_value(parent_component, component)
+
+        if not parent_component:
+            model.del_component(parent_component)
+
+
+def _delete_element_by_value(dict_: Dict, value: Any) -> None:
+    iter_dict = {**dict_}
+    for k, v in iter_dict.items():
+        if v is value and k in dict_:
+            del dict_[k]
+
+
+def get_name(component: Union[IndexedComponent, ComponentData]) -> str:
+    if isinstance(component, IndexedComponent):
+        return component._name  # constraint.name returns "'{name}'"
+    else:
+        return component.name
+
+
+class FixedSympy2PyomoVisitor(Sympy2PyomoVisitor):
+    def beforeChild(  # noqa: N802
+        self, node: Optional[sympy.Expr], child: sympy.Expr, child_idx: Optional[int]
+    ) -> Tuple[bool, Union[int, float, None]]:
+        if not child._args:
+            item = self.object_map.getPyomoSymbol(child, None)
+            if item is None:
+                if isinstance(child, sympy.Integer):  # addition to base implementation
+                    item = int(child.evalf())
+                else:
+                    item = float(child.evalf())
+            return False, item
+        return True, None
+
+
+def sympy2pyomo_expression(
+    expr: sympy.core.Basic, object_map: PyomoSympyBimap
+) -> pyo_expr.ExpressionBase:
+    return FixedSympy2PyomoVisitor(object_map).walk_expression(expr)
+
+
+def convert_pyomo_to_global_presentation(
+    pyo_model: pyo.ConcreteModel,
+) -> pyo.ConcreteModel:
+    pyo_model_str = pyomo2qmod("nativePyoModel", pyo_model)
+    problem_struct = CombinatorialOptimizationStructDeclaration.parse_raw(pyo_model_str)
+
+    pyomo_model = pyo.ConcreteModel()
+
+    var_names = list(problem_struct.variables.keys())
+    pyomo_model.var_set = pyo.Var(
+        var_names,
+        domain=pyo.NonNegativeIntegers,
+        bounds=(
+            problem_struct.variable_lower_bound,
+            problem_struct.variable_upper_bound,
+        ),
+    )
+    obj_map = PyomoSympyBimap()
+    var_dict = {
+        var_name: obj_map.getSympySymbol(pyomo_model.var_set[var_name])
+        for var_name in var_names
+    }
+
+    def expr2pyomo(expr: Expression) -> pyo_expr.ExpressionBase:
+        sp_expr = sympy.sympify(expr.expr, locals=var_dict)
+        if isinstance(sp_expr, sympy.core.relational.Equality):
+            return sympy2pyomo_expression(
+                sp_expr.args[0], obj_map
+            ) == sympy2pyomo_expression(sp_expr.args[1], obj_map)
+
+        # Note that strict greater/less than are not supported by Pyomo
+        return sympy2pyomo_expression(sp_expr, obj_map)
+
+    pyomo_model.constraints = pyo.Constraint(
+        pyo.RangeSet(0, len(problem_struct.constraints) - 1),
+        rule=lambda model, i: expr2pyomo(problem_struct.constraints[i]),
+    )
+    pyomo_model.objective = pyo.Objective(
+        expr=expr2pyomo(problem_struct.objective_function),
+        sense=(
+            pyo.maximize
+            if problem_struct.objective_type == ObjectiveType.Max
+            else pyo.minimize
+        ),
+    )
+
+    return pyomo_model
+
+
+def pyomo2qmod(struct_name: str, pyo_model: ConcreteModel) -> str:
+    symbols_map = PyomoSympyBimap()
+
+    variables: List[sympy.Symbol] = []
+
+    bounds_set = False
+    lower_bound = None
+    upper_bound = None
+
+    for var_dict in pyo_model.component_objects(Var):
+        for key in var_dict:
+            var = Pyomo2SympyVisitor(symbols_map).walk_expression(var_dict[key])
+            var.name = var.name.replace(",", "_")
+            variables.append(var)
+            if bounds_set:
+                if lower_bound != var_dict[key].lb:
+                    raise ClassiqValueError(
+                        "All problem variables must agree on lower bound"
+                    )
+                if upper_bound != var_dict[key].ub:
+                    raise ClassiqValueError(
+                        "All problem variables must agree on upper bound"
+                    )
+            else:
+                lower_bound = var_dict[key].lb
+                upper_bound = var_dict[key].ub
+                bounds_set = True
+
+    constraint_exprs: List[sympy.Expr] = []
+
+    constraint_exprs.extend(
+        Pyomo2SympyVisitor(symbols_map).walk_expression(constraint_dict[key].expr)
+        for constraint_dict in pyo_model.component_objects(Constraint)
+        for key in constraint_dict
+    )
+
+    pyo_objective: ScalarObjective = next(pyo_model.component_objects(Objective))
+    objective_type_str = "Max" if pyo_objective.sense == maximize else "Min"
+    objective_expr: sympy.Expr = Pyomo2SympyVisitor(symbols_map).walk_expression(
+        pyo_objective
+    )
+
+    combi_struct_decl = {
+        "name": struct_name,
+        "variables": {str(variable): {"kind": "int"} for variable in variables},
+        "variable_lower_bound": lower_bound,
+        "variable_upper_bound": upper_bound,
+        "constraints": [
+            {"expr": str(constraint_expr)} for constraint_expr in constraint_exprs
+        ],
+        "objective_type": objective_type_str,
+        "objective_function": {"expr": str(objective_expr)},
+    }
+    return json.dumps(combi_struct_decl, indent=2)

classiq/applications/combinatorial_helpers/sympy_utils.py

@@ -0,0 +1,22 @@
+from typing import List, Optional
+
+import pyomo.core as pyo
+from pyomo.core.base import _GeneralVarData
+from pyomo.core.expr.sympy_tools import Pyomo2SympyVisitor, PyomoSympyBimap
+from sympy import Expr
+
+
+def sympyify_vars(variables: List[_GeneralVarData]) -> PyomoSympyBimap:
+    symbols_map = PyomoSympyBimap()
+    for var in variables:
+        Pyomo2SympyVisitor(symbols_map).walk_expression(var)
+    return symbols_map
+
+
+def sympyify_expression(
+    expression: pyo.Expression, symbols_map: Optional[PyomoSympyBimap] = None
+) -> Expr:
+    if symbols_map is None:
+        symbols_map = PyomoSympyBimap()
+
+    return Pyomo2SympyVisitor(symbols_map).walk_expression(expression)

classiq/applications/combinatorial_helpers/transformations/encoding.py

@@ -0,0 +1,187 @@
+import copy
+from itertools import chain, product
+from typing import Callable, Dict, List, Tuple, Union
+
+import pyomo.environ as pyo
+from pyomo.core.base import _GeneralVarData
+from pyomo.core.expr.numeric_expr import ExpressionBase
+from pyomo.core.expr.relational_expr import EqualityExpression
+
+from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
+from classiq.interface.combinatorial_optimization.solver_types import QSolver
+
+from classiq.applications.combinatorial_helpers import encoding_utils, pyomo_utils
+from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
+from classiq.applications.combinatorial_helpers.encoding_utils import ONE_HOT_SUFFIX
+from classiq.exceptions import ClassiqCombOptInvalidEncodingTypeError
+
+
+def _make_invalid_encoding_type_error(
+    encoding_type: EncodingType,
+) -> ClassiqCombOptInvalidEncodingTypeError:
+    return ClassiqCombOptInvalidEncodingTypeError(
+        encoding_type=encoding_type,
+        valid_types=EncodingType.__members__.keys(),
+    )
+
+
+def encoding_length(
+    var: _GeneralVarData, encoding_type: Union[EncodingType, None]
+) -> int:
+    if encoding_type is None:
+        return 1
+
+    var_span = encoding_utils.get_var_span(var)
+
+    if encoding_type == EncodingType.BINARY:
+        return var_span.bit_length()
+
+    elif encoding_type == EncodingType.ONE_HOT:
+        return var_span + 1
+
+    else:
+        raise _make_invalid_encoding_type_error(encoding_type)
+
+
+class ModelEncoder:
+    def __init__(
+        self,
+        model: pyo.ConcreteModel,
+        qsolver: QSolver,
+        encoding_type: EncodingType = EncodingType.BINARY,
+    ) -> None:
+        self.encoding_type = encoding_type
+        self.encoded_model = copy.deepcopy(model)
+        self.qsolver = qsolver
+        self.vars_original = list(self.encoded_model.component_objects(pyo.Var))
+        self.vars_encoding_mapping = self._encode_variables()
+        if self.encoding_type == EncodingType.ONE_HOT:
+            self._add_one_hot_constraints()
+        self._encode_constraints()
+        self._encode_objective()
+
+    @property
+    def _shift_substitution_dict(self) -> Dict[int, pyo.Expression]:
+        variables = pyomo_utils.extract(self.encoded_model, pyo.Var)
+        return {id(var): var + var.lb for var in variables}
+
+    def _encode_variables(self) -> EncodingMapping:
+        vars_encoding_mapping = EncodingMapping(self.encoding_type)
+        for variable in self.vars_original:
+            # encode variables
+            encoded_var_name = encoding_utils.encoded_obj_name(variable.name)
+            encoded_var = pyo.Var(self._get_encoding_idxs(variable), domain=pyo.Binary)
+            setattr(self.encoded_model, encoded_var_name, encoded_var)
+
+            # create mapping between original variables and their encodings
+            for var_idx, var_data in variable.items():
+                encoding_vars = [
+                    encoded_var[var_idx, encoding_idx]
+                    for encoding_idx in range(
+                        encoding_length(var_data, self.encoding_type)
+                    )
+                ]
+
+                encoding_expr = self._get_encoding_expr(var_data, encoding_vars)
+
+                self._add_expr_constraint(
+                    constraint_name=var_data.name + encoding_utils.ENCODED_SUFFIX,
+                    expr=EqualityExpression(args=[var_data, encoding_expr]),
+                )
+
+                vars_encoding_mapping.add(
+                    original_var=var_data,
+                    encoding_expr=encoding_expr,
+                    encodings_vars=encoding_vars,
+                )
+        return vars_encoding_mapping
+
+    def _get_encoding_expr(
+        self, var_data: _GeneralVarData, encoding_vars: List[_GeneralVarData]
+    ) -> pyo.Expression:
+        if self.encoding_type == EncodingType.BINARY:
+            var_span = encoding_utils.get_var_span(var_data)
+            coeffs = self._get_binary_coeffs(encoding_vars, var_span)
+
+        elif self.encoding_type == EncodingType.ONE_HOT:
+            coeffs = list(range(len(encoding_vars)))
+        else:
+            raise _make_invalid_encoding_type_error(self.encoding_type)
+
+        encoding_expr = sum(
+            coeff * encoding_var for coeff, encoding_var in zip(coeffs, encoding_vars)
+        )
+
+        # Encodes variable shift
+        encoding_expr += var_data.lb
+        return encoding_expr
+
+    def _get_binary_coeffs(
+        self, encoding_vars: List[_GeneralVarData], var_span: int
+    ) -> List[int]:
+        num_vars = len(encoding_vars)
+        if self.qsolver == QSolver.QAOAMixer:
+            return [2**idx for idx in range(num_vars)]
+
+        else:  # self.qsolver == QSolver.QAOAPenalty:
+            coeffs = [2**idx for idx in range(num_vars - 1)]
+            coeffs += [var_span - sum(coeffs)]
+            return coeffs
+
+    def _get_encoding_idxs(self, variable: pyo.Var) -> List[Tuple[int, int]]:
+        return list(
+            chain(
+                *[
+                    product(
+                        [var_idx], range(encoding_length(var_data, self.encoding_type))
+                    )
+                    for var_idx, var_data in variable.items()
+                ]
+            )
+        )
+
+    def _add_one_hot_constraints(self) -> None:
+        for variable in self.vars_original:
+            # potential bug with creating function inside a loop.
+            # solved with early binding - https://stackoverflow.com/questions/3431676/creating-functions-in-a-loop
+            def one_hot_rule(var_idx: int, var: pyo.Var = variable) -> ExpressionBase:
+                var_data = var[var_idx]
+                return sum(self.vars_encoding_mapping.get_encoding_vars(var_data)) == 1
+
+            self._add_rule_constraint(
+                constraint_name=variable.name + ONE_HOT_SUFFIX,
+                idxs=getattr(self.encoded_model, variable.index),
+                rule=one_hot_rule,
+            )
+
+    def _add_rule_constraint(
+        self, constraint_name: str, idxs: List[int], rule: Callable
+    ) -> None:
+        encoding_constraint = pyo.Constraint(idxs, rule=rule)
+
+        setattr(self.encoded_model, constraint_name, encoding_constraint)
+
+    def _add_expr_constraint(self, constraint_name: str, expr: ExpressionBase) -> None:
+        setattr(self.encoded_model, constraint_name, pyo.Constraint(expr=expr))
+
+    def _encode_objective(self) -> None:
+        encoding_utils.encode_objective(
+            self.encoded_model, self.vars_encoding_mapping.substitution_dict
+        )
+
+    def encode_expr(
+        self,
+        expr: pyo.Expression,
+        substitution_dict: Union[Dict[int, pyo.Expression], None] = None,
+    ) -> pyo.Expression:
+        if substitution_dict is None:
+            substitution_dict = self.vars_encoding_mapping.substitution_dict
+        return encoding_utils.encode_expr(expr, substitution_dict)
+
+    def _encode_constraints(self) -> None:
+        if self.qsolver == QSolver.QAOAPenalty:
+            return
+
+        encoding_utils.encode_constraints(
+            self.encoded_model, self._shift_substitution_dict
+        )

classiq/applications/combinatorial_helpers/transformations/fixed_variables.py

@@ -0,0 +1,142 @@
+import copy
+from typing import List, Tuple, 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.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,
+)
+from classiq.exceptions import (
+    ClassiqCombOptNoSolutionError,
+    ClassiqCombOptTrivialProblemError,
+)
+
+
+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)