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

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -0,0 +1,447 @@
+import math
+import re
+from collections import defaultdict
+from collections.abc import Iterator
+from contextlib import contextmanager
+from enum import Enum
+from functools import reduce
+from operator import mul
+from typing import Any, Optional, 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.base import ExpressionBase
+from pyomo.core.expr.sympy_tools import (
+    Pyomo2SympyVisitor,
+    PyomoSympyBimap,
+    Sympy2PyomoVisitor,
+)
+
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import Integer
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+
+from classiq.qmod.qmod_variable import QArray, QBit, QNum, QStruct, QVar
+from classiq.qmod.symbolic_expr import SymbolicExpr
+
+ListVars = list[_GeneralVarData]
+SUPPORTED_TYPES = [
+    pyo.Binary,
+    pyo.Integers,
+    pyo.NegativeIntegers,
+    pyo.NonNegativeIntegers,
+    pyo.NonPositiveIntegers,
+    pyo.PositiveIntegers,
+]
+
+
+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:
+    problem_struct = pyomo2qmod("nativePyoModel", pyo_model)
+
+    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
+) -> CombinatorialOptimizationStructDeclaration:
+    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
+    )
+
+    return CombinatorialOptimizationStructDeclaration(
+        name=struct_name,
+        variables={str(variable): Integer() for variable in variables},
+        variable_lower_bound=lower_bound,
+        variable_upper_bound=upper_bound,
+        constraints=[
+            Expression(expr=str(constraint_expr))
+            for constraint_expr in constraint_exprs
+        ],
+        objective_type=objective_type_str,
+        objective_function=Expression(expr=str(objective_expr)),
+    )
+
+
+def pyomo_to_qmod_qstruct(
+    struct_name: str, vars: list[_GeneralVarData]
+) -> type[QStruct]:
+    qmod_struct = type(struct_name, (QStruct,), {})
+    qmod_struct.__annotations__ = _get_qstruct_fields(vars)
+    return qmod_struct
+
+
+def _get_qstruct_fields(vars: list[_GeneralVarData]) -> dict[str, type[QVar]]:
+    array_type_sizes = _get_array_sizes(vars)
+    fields: dict[str, type[QVar]] = {}
+    for var in vars:
+        _add_qmod_field(var, array_type_sizes, fields)
+    return fields
+
+
+def _get_array_sizes(vars: list[_GeneralVarData]) -> dict[str, tuple[int, ...]]:
+    array_types: dict[str, set[tuple]] = defaultdict(set)
+    for var in vars:
+        if is_index_var(var):
+            array_types[get_field_name(var.parent_component())].add(
+                index_as_tuple(var.index())
+            )
+    return {
+        name: dimensions
+        for name, indices in array_types.items()
+        if (dimensions := _get_indices_dimensions(indices)) is not None
+    }
+
+
+def _get_indices_dimensions(indices: set[tuple[int, ...]]) -> Optional[tuple[int, ...]]:
+    indices_list = list(indices)
+    if len(indices) == 0:
+        return None
+    first_idx = indices_list[0]
+    if len(first_idx) == 0:
+        return None
+    if any(len(idx) != len(first_idx) for idx in indices_list[1:]):
+        return None
+    dimension_bounds = [(idx, idx) for idx in first_idx]
+    for multi_idx in indices_list[1:]:
+        for dim_idx, idx in enumerate(multi_idx):
+            dimension_bounds[dim_idx] = (
+                min(dimension_bounds[dim_idx][0], idx),
+                max(dimension_bounds[dim_idx][1], idx),
+            )
+    if any(lb != 0 for lb, ub in dimension_bounds):
+        return None
+    dimensions = tuple(ub + 1 for _, ub in dimension_bounds)
+    if reduce(mul, dimensions) != len(indices_list):
+        return None
+    return dimensions
+
+
+def _add_qmod_field(
+    var: _GeneralVarData,
+    array_type_sizes: dict[str, tuple[int, ...]],
+    fields: dict[str, type[QVar]],
+) -> None:
+    parent_name = get_field_name(var.parent_component())
+    if parent_name not in array_type_sizes:
+        var_name = get_field_name(var)
+        fields[var_name] = _get_qmod_field_type(var_name, var)
+        return
+    dimensions = array_type_sizes[parent_name]
+    if index_as_tuple(var.index()) == tuple(0 for _ in range(len(dimensions))):
+        qmod_type: type[QVar] = _get_qmod_field_type(parent_name, var)
+        for dim in reversed(dimensions):
+            qmod_type = QArray[qmod_type, dim]  # type:ignore[valid-type]
+        fields[parent_name] = qmod_type
+
+
+def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]:
+    if var_data.domain not in SUPPORTED_TYPES:
+        raise ClassiqValueError(
+            f"Type {str(var_data.domain)!r} of variable {var_name!r} is not supported"
+        )
+
+    if var_data.domain == pyo.Binary:
+        return QBit
+
+    bounds = var_data.bounds
+    if bounds is None:
+        raise ClassiqValueError(f"Variable {var_name!r} has no bounds")
+    lb, ub = bounds
+    if not isinstance(lb, int) or not isinstance(ub, int):
+        raise ClassiqValueError(
+            f"Non-integer bounds for variable {var_name!r} are not supported"
+        )
+    qnum: Any = QNum  # mypy shenanigans
+    return qnum[math.ceil(math.log2(ub - lb + 1)), False, 0]
+
+
+def evaluate_objective(
+    var_mapping: dict[Any, Union[str, tuple[str, tuple[int, ...]]]],
+    sympy_expr: sympy.Expr,
+    struct_obj: Any,
+) -> Any:
+    sympy_assignment = {
+        sympy_var: (
+            getattr(struct_obj, field_accessor)
+            if isinstance(field_accessor, str)
+            else _get_item(getattr(struct_obj, field_accessor[0]), field_accessor[1])
+        )
+        for sympy_var, field_accessor in var_mapping.items()
+    }
+
+    # classical objective evaluation
+    if not isinstance(struct_obj, QStruct):
+        return float(sympy_expr.evalf(subs=sympy_assignment))
+
+    # quantum objective evaluation
+    expr_str = str(sympy_expr).replace("'", "")
+    for var_name, var_value in sympy_assignment.items():
+        var_name = str(var_name).replace("'", "")
+        expr_str = re.sub(rf"\b{var_name}\b", str(var_value), expr_str)
+    return SymbolicExpr(expr=expr_str, is_quantum=True)
+
+
+def _get_item(obj: Any, multi_index: tuple[int, ...]) -> Any:
+    for idx in multi_index:
+        obj = obj[idx]
+    return obj
+
+
+def get_field_name(var: _GeneralVarData) -> str:
+    return var.local_name.replace("[", "_").replace("]", "").replace(",", "_")
+
+
+def is_index_var(var: _GeneralVarData) -> bool:
+    index = var.index()
+    return isinstance(index, int) or (
+        isinstance(index, tuple) and all(isinstance(idx, int) for idx in index)
+    )
+
+
+def index_as_tuple(index: Union[int, tuple[int, ...]]) -> tuple[int, ...]:
+    if isinstance(index, int):
+        return (index,)
+    return index
+
+
+@contextmanager
+def add_var_domain_constraints(model: ConcreteModel) -> Iterator[None]:
+    vars = extract(model, _GeneralVarData)
+    constraints = [
+        constraint
+        for var in vars
+        if (constraint := _get_var_domain_constraint(var)) is not None
+    ]
+    if len(constraints) == 0:
+        yield
+        return
+    model.var_domain_constraints = pyo.ConstraintList()
+    for constraint in constraints:
+        model.var_domain_constraints.add(constraint)
+    yield
+    model.del_component("var_domain_constraints")
+
+
+def _get_var_domain_constraint(var: _GeneralVarData) -> Optional[ExpressionBase]:
+    bounds = var.bounds
+    if (
+        type(bounds) is not tuple
+        or len(bounds) != 2
+        or not all(isinstance(bounds[idx], int) for idx in (0, 1))
+    ):
+        raise ClassiqValueError(
+            f"Missing bounds for variable {var.local_name}. Expected both lower and "
+            f"upper bounds, got {bounds}"
+        )
+    lb, ub = bounds
+    if ub < lb:
+        raise ClassiqValueError(
+            f"Illegal bounds for variable {var.local_name}. The upper bound ({ub}) is "
+            f"lesser than the lower bound ({lb})"
+        )
+    ub_norm = ub - lb + 1
+    if ub_norm & (ub_norm - 1) == 0:
+        return None
+    return var <= ub

classiq/applications/combinatorial_helpers/sympy_utils.py

@@ -0,0 +1,22 @@
+from typing import 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,189 @@
+import copy
+from itertools import chain, product
+from typing import Callable, 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.interface.exceptions import ClassiqCombOptInvalidEncodingTypeError
+
+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
+
+
+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
+                    + encoding_utils.CONSTRAINT_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
+        )