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

classiq/applications/combinatorial_helpers/arithmetic/isolation.py

@@ -0,0 +1,42 @@
+from sympy import Eq, Expr, GreaterThan, LessThan, Rational, Symbol, solve
+from sympy.core.relational import Relational
+
+from classiq.interface.exceptions import ClassiqCombOptNoSolutionError
+
+
+def isolate(expression: Expr, var: Symbol) -> Expr:
+    isolated_exp = solve(expression, var)
+    # This converts Rationals to Floats which is needed since we don't support division in arithmetic
+    if isinstance(isolated_exp, Relational) and _has_rational_atom(isolated_exp):
+        isolated_exp = isolated_exp.evalf()
+
+    if isinstance(expression, Eq):
+        if len(isolated_exp) == 1:
+            isolated_exp = type(expression)(var, isolated_exp[0])
+        elif len(isolated_exp) > 1:
+            # sympy didn't manage to isolate an expression
+            isolated_exp = expression
+        else:
+            raise ClassiqCombOptNoSolutionError
+
+    else:
+        if _is_symbol_in_right_hand_side(isolated_exp):
+            isolated_exp = _reverse_ineq_exp(isolated_exp)
+
+    return isolated_exp
+
+
+def _has_rational_atom(expression: Relational) -> bool:
+    return any(type(atom) is Rational for atom in expression.atoms())
+
+
+def _is_symbol_in_right_hand_side(expression: Expr) -> bool:
+    return isinstance(expression.args[1], Symbol) and not isinstance(
+        expression.args[0], Symbol
+    )
+
+
+def _reverse_ineq_exp(expression: Expr) -> Expr:
+    original_relation = type(expression)
+    reverse_relation = LessThan if original_relation is GreaterThan else GreaterThan
+    return reverse_relation(expression.args[1], expression.args[0])

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -0,0 +1,166 @@
+import itertools
+from functools import partial
+from typing import Callable, Union
+
+import numpy as np
+import pyomo.environ as pyo
+
+from classiq.interface.combinatorial_optimization.sense import is_maximization
+from classiq.interface.combinatorial_optimization.solver_types import QSolver
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.executor.vqe_result import VQESolverResult
+from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
+
+from classiq.applications.combinatorial_helpers.optimization_model import (
+    OptimizationModel,
+)
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_sparsing import (
+    SparsePauliOp,
+)
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    pauli_operator_to_hamiltonian,
+)
+from classiq.applications.combinatorial_helpers.pyomo_utils import (
+    add_var_domain_constraints,
+    convert_pyomo_to_global_presentation,
+    evaluate_objective,
+    pyomo_to_qmod_qstruct,
+)
+from classiq.qmod.builtins.structs import PauliTerm
+from classiq.qmod.qmod_variable import QStruct
+
+
+def compute_qaoa_initial_point(
+    hamiltonian: list[PauliTerm],
+    repetitions: int,
+) -> list[float]:
+    coeffs_ising = [pauli_term.coefficient for pauli_term in hamiltonian[1:]]
+    # the first coeff is the II...I term
+    coeffs_abs = np.abs(coeffs_ising)  # type: ignore[arg-type]
+    coeffs_largest = np.sort(coeffs_abs)[len(coeffs_ising) // 2 :]
+    operator_norm = np.mean(coeffs_largest)
+    time_step = 1 / (2 * operator_norm)  # adapted such that for MAXCUT time_step = 1
+
+    beta_params: np.ndarray = np.linspace(1, 0, repetitions) * time_step
+    gamma_params: np.ndarray = np.linspace(0, 1, repetitions) * time_step
+    return list(itertools.chain(*zip(gamma_params, beta_params)))
+
+
+def pyo_model_to_hamiltonian(
+    pyo_model: pyo.ConcreteModel, penalty_energy: float
+) -> list[PauliTerm]:
+    pauli_list = OptimizationModel(
+        pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
+    ).ising.pauli_list
+    return pauli_operator_to_hamiltonian(pauli_list)
+
+
+def pyo_model_to_qmod_problem(
+    pyo_model: pyo.ConcreteModel, penalty_energy: float
+) -> tuple[type[QStruct], Callable]:
+    with add_var_domain_constraints(pyo_model):
+        optimization_model = OptimizationModel(
+            pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
+        )
+        _validate_var_domains(optimization_model)
+        qmod_struct = pyomo_to_qmod_qstruct(
+            "QAOAVars", optimization_model.vars_not_encoded
+        )
+        cost_func = partial(
+            evaluate_objective, *optimization_model.objective_not_encoded_sympy
+        )
+        return qmod_struct, cost_func
+
+
+def _validate_var_domains(model: OptimizationModel) -> None:
+    for var in model.vars_not_encoded:
+        if (
+            isinstance(var.bounds, tuple)
+            and len(var.bounds) == 2
+            and var.bounds[0] != 0
+        ):
+            raise ClassiqValueError(
+                f"Bounds of variable {var.local_name} must start at 0, got {var.bounds}"
+            )
+
+
+def _str_to_list_int(str_ints: str) -> list[int]:
+    return list(map(int, list(str_ints)))
+
+
+def _decode_vector_str(
+    optimization_model: OptimizationModel, vector_str: str
+) -> list[int]:
+    return optimization_model.decode(
+        _str_to_list_int(vector_str[::-1])
+    )  # reverse qubit order
+
+
+def _evaluate_operator(operator: SparsePauliOp, state: Union[list[int], str]) -> float:
+    if isinstance(state, list):
+        state = "".join([str(x) for x in state])
+
+    cost = 0.0
+    for pauli, coeff in zip(operator.paulis, operator.coeffs):
+        expectation = 1
+        for qubit, pauli_char in enumerate(pauli):
+            if pauli_char != "I" and state[qubit] == "1" and pauli_char in ["Z", "Y"]:
+                expectation *= -1
+        cost += expectation * coeff.real
+
+    return cost
+
+
+def _eigenstate_to_solution(
+    optimization_model: OptimizationModel,
+    eigenvector: str,
+    probability: float,
+    num_shots: int,
+) -> QmodPyStruct:
+    pauli = optimization_model.get_operator().pauli_list
+
+    paulis = [item[0] for item in pauli]
+    coeffs = [item[1] for item in pauli]
+
+    operator = SparsePauliOp(paulis, coeffs)
+    cost = _evaluate_operator(operator, eigenvector)
+
+    if is_maximization(optimization_model._model_original):
+        cost *= -1
+
+    return {
+        "probability": probability,
+        "cost": cost,
+        "solution": _decode_vector_str(optimization_model, eigenvector),
+        "count": round(probability * num_shots),
+    }
+
+
+def _get_combi_solution_histogram(
+    optimization_model: OptimizationModel,
+    vqe_result: VQESolverResult,
+) -> list[QmodPyStruct]:
+    if vqe_result.reduced_probabilities is None:
+        raise ValueError(
+            "reduced_probabilities is optional only for backwards compatibility, but it should always be present here"
+        )
+    return [
+        _eigenstate_to_solution(
+            optimization_model, eigenvector, probability, vqe_result.num_shots
+        )
+        for eigenvector, probability in vqe_result.reduced_probabilities.items()
+    ]
+
+
+def get_optimization_solution_from_pyo(
+    pyo_model: pyo.ConcreteModel,
+    vqe_result: VQESolverResult,
+    penalty_energy: float,
+) -> list[QmodPyStruct]:
+    converted_pyo_model = convert_pyomo_to_global_presentation(pyo_model)
+    optimization_model = OptimizationModel(
+        converted_pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
+    )
+    histogram = _get_combi_solution_histogram(optimization_model, vqe_result)
+    histogram.sort(key=lambda x: x["probability"], reverse=True)
+    return histogram

classiq/applications/combinatorial_helpers/encoding_mapping.py

@@ -0,0 +1,107 @@
+import itertools
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+import pyomo.environ as pyo
+from pyomo.core.base import _GeneralVarData
+from pyomo.core.expr.visitor import clone_expression, identify_variables
+
+from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
+from classiq.interface.exceptions import ClassiqCombOptError
+
+from classiq.applications.combinatorial_helpers import pyomo_utils
+
+
+@dataclass
+class VarExpressionMapping:
+    var: _GeneralVarData
+    expr: pyo.Expression
+    encodings_vars: list[_GeneralVarData] = field(default_factory=list)
+
+
+class EncodingMapping:
+    def __init__(self, encoding_type: EncodingType) -> None:
+        self._data: list[VarExpressionMapping] = []
+        self.encoding_type = encoding_type
+
+    @property
+    def original_vars(self) -> list[_GeneralVarData]:
+        return [pair.var for pair in self._data]
+
+    @property
+    def encodings_vars(self) -> list[_GeneralVarData]:
+        return list(
+            itertools.chain.from_iterable(
+                var_mapping.encodings_vars for var_mapping in self._data
+            )
+        )
+
+    @property
+    def substitution_dict(self) -> dict[int, pyo.Expression]:
+        return {id(mapping.var): mapping.expr for mapping in self._data}
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def add(
+        self,
+        original_var: _GeneralVarData,
+        encoding_expr: pyo.Expression,
+        encodings_vars: Union[list[_GeneralVarData], None] = None,
+    ) -> None:
+        if encodings_vars is None:
+            encodings_vars = list(identify_variables(encoding_expr))
+
+        self._check_unique_encoding_vars(encodings_vars)
+        self._data.append(
+            VarExpressionMapping(
+                var=original_var, expr=encoding_expr, encodings_vars=encodings_vars
+            )
+        )
+
+    def _check_unique_encoding_vars(self, variables: list[_GeneralVarData]) -> None:
+        assert all(
+            not pyomo_utils.contains(var, self.encodings_vars) for var in variables
+        )
+
+    def get_var_expr_mapping(
+        self, original_var: _GeneralVarData
+    ) -> VarExpressionMapping:
+        for var_expr_mapping in self._data:
+            if var_expr_mapping.var is original_var:
+                return var_expr_mapping
+        raise ClassiqCombOptError("No variable expression mapping found.")
+
+    def get_encoding_vars(self, original_var: _GeneralVarData) -> list[_GeneralVarData]:
+        return self.get_var_expr_mapping(original_var).encodings_vars
+
+    def get_original_var(
+        self, encoding_var: _GeneralVarData
+    ) -> Optional[_GeneralVarData]:
+        for original_var in self.original_vars:
+            if pyomo_utils.contains(encoding_var, self.get_encoding_vars(original_var)):
+                return original_var
+        return None
+
+    def decode(self, solution: list[int]) -> list[int]:
+        idx = 0
+        decoded_solution = []
+        for var_mapping in self._data:
+            num_encoding_vars = len(var_mapping.encodings_vars)
+            encoding_vars_solution = solution[idx : idx + num_encoding_vars]
+            idx += num_encoding_vars
+
+            substitution_map = {
+                id(var): num
+                for var, num in zip(var_mapping.encodings_vars, encoding_vars_solution)
+            }
+            substituted_expr = clone_expression(
+                var_mapping.expr, substitute=substitution_map
+            )
+
+            if callable(substituted_expr):
+                substituted_expr = substituted_expr()
+
+            decoded_solution.append(substituted_expr)
+
+        return decoded_solution

classiq/applications/combinatorial_helpers/encoding_utils.py

@@ -0,0 +1,124 @@
+import math
+from itertools import filterfalse
+from typing import Any, Union, cast
+
+import numpy as np
+import pyomo.environ as pyo
+from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.component import ComponentData, _ComponentBase
+from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.expr.numeric_expr import (
+    MonomialTermExpression,
+    ProductExpression,
+    clone_expression,
+)
+from sympy import Expr
+
+from classiq.interface.exceptions import ClassiqCombOptNoSolutionError
+
+from classiq.applications.combinatorial_helpers import pyomo_utils
+
+_INTEGER_TYPES = [pyo.NonNegativeIntegers, pyo.Integers, pyo.PositiveIntegers]
+
+
+def is_model_encodable(model: pyo.ConcreteModel) -> bool:
+    variables = pyomo_utils.extract(model, pyo.Var)
+    return not all(is_var_binary(var) for var in variables)
+
+
+def is_var_binary(var: _GeneralVarData) -> bool:
+    return var.domain == pyo.Binary or (
+        var.domain in _INTEGER_TYPES and var.lb == 0 and var.ub == 1
+    )
+
+
+def is_var_span_power_of_2(var: _GeneralVarData) -> bool:
+    var_span = get_var_span(var)
+    return math.log2(var_span + 1).is_integer()
+
+
+ENCODED_SUFFIX = "_encoded"
+ONE_HOT_SUFFIX = "_one_hot"
+CONSTRAINT_SUFFIX = "_constraint"
+
+
+def is_obj_encoded(var: _ComponentBase) -> bool:
+    return ENCODED_SUFFIX in var.name
+
+
+def get_var_span(var: _GeneralVarData) -> int:
+    return var.ub - var.lb
+
+
+def encoded_obj_name(name: str) -> str:
+    return name + ENCODED_SUFFIX
+
+
+def get_encoded_var_index(var: _GeneralVarData) -> int:
+    indexed_var = var.parent_component()
+    index = [
+        index_temp for index_temp, var_temp in indexed_var.items() if var_temp is var
+    ][0]
+    return index[1]
+
+
+def recursively_remove_monomial_expr(obj: Any) -> None:
+    # Due to pyomo bug. see: https://github.com/Pyomo/pyomo/issues/2174
+    for arg in getattr(obj, "args", []):
+        if isinstance(arg, MonomialTermExpression):
+            arg.__class__ = ProductExpression
+        recursively_remove_monomial_expr(arg)
+
+
+def encode_expr(
+    expr: pyo.Expression, substitution_dict: dict[int, pyo.Expression]
+) -> pyo.Expression:
+    encoded_expr = clone_expression(expr=expr, substitute=substitution_dict)
+    recursively_remove_monomial_expr(encoded_expr)
+    return encoded_expr
+
+
+def encode_constraints(
+    model: pyo.ConcreteModel, substitution_dict: dict[int, pyo.Expression]
+) -> None:
+    all_constraints = pyomo_utils.extract(model, _GeneralConstraintData)
+    constraints = filterfalse(is_obj_encoded, all_constraints)
+
+    for constraint in constraints:
+        constraint_expression = encode_expr(constraint.expr, substitution_dict)
+        if not isinstance(constraint_expression, bool) and not isinstance(
+            constraint_expression, np.bool_
+        ):
+            constraint.set_value(expr=constraint_expression)
+            continue
+
+        deal_with_trivial_boolean_constraint(constraint, constraint_expression, model)
+
+
+def deal_with_trivial_boolean_constraint(
+    constraint: _ComponentBase,
+    constraint_expression: Union[bool, Expr],
+    model: pyo.ConcreteModel,
+) -> None:
+    # using '==' on purpose since comparing against sympy's True
+    if constraint_expression == True:  # noqa: E712
+        pyomo_utils.delete_component(model, cast(ComponentData, constraint))
+    if constraint_expression == False:  # noqa: E712
+        raise ClassiqCombOptNoSolutionError
+
+
+def encode_objective(
+    model: pyo.ConcreteModel, substitution_dict: dict[int, pyo.Expression]
+) -> None:
+    objective = next(model.component_objects(pyo.Objective))
+
+    encoded_objective = pyo.Objective(
+        expr=encode_expr(objective.expr, substitution_dict),
+        sense=objective.sense,
+    )
+    model.del_component(objective.name)
+    setattr(
+        model,
+        objective.name,
+        encoded_objective,
+    )

classiq/applications/combinatorial_helpers/memory.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pyomo.core.base import _GeneralVarData
+
+from classiq.interface.generator.function_params import IOName
+
+from classiq.applications.combinatorial_helpers import encoding_utils
+from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
+
+AUXILIARY_NAME = "auxiliary"
+
+
+class InternalQuantumReg:
+    def __init__(self, size: int, name: str) -> None:
+        self.name = name
+        self.size = size
+
+
+class MemoryMapping:
+    def __init__(
+        self,
+        variables: list[_GeneralVarData],
+        vars_encoding_mapping: EncodingMapping | None = None,
+    ) -> None:
+        self.substitution_dict: dict[int, InternalQuantumReg] = dict()
+        self.qubit_allocation: dict[IOName, tuple[int, int]] = dict()
+        self.vars_encoding_mapping: EncodingMapping | None = vars_encoding_mapping
+        self.vars: list[_GeneralVarData] = variables
+        self._allocate_memory()
+
+    def __len__(self) -> int:
+        return len(self.substitution_dict)
+
+    def _allocate_memory(self) -> None:
+        for var_data in self.vars:
+            if (
+                not self.vars_encoding_mapping
+                or encoding_utils.get_var_span(var_data) == 1
+            ):
+                num_qubits_var = 1
+            else:
+                num_qubits_var = len(
+                    self.vars_encoding_mapping.get_encoding_vars(var_data)
+                )
+
+            self.substitution_dict[id(var_data)] = InternalQuantumReg(
+                num_qubits_var, "q"
+            )
+            var_name = get_var_name(var_data)
+            self.qubit_allocation[var_name] = (
+                self._variable_qubits_allocated,
+                num_qubits_var,
+            )
+
+    @property
+    def qregs(self) -> list[InternalQuantumReg]:
+        return list(self.substitution_dict.values())
+
+    @property
+    def _variable_qubits_allocated(self) -> int:
+        return sum(
+            num_qubits
+            for name, (_, num_qubits) in self.qubit_allocation.items()
+            if name != AUXILIARY_NAME
+        )
+
+
+def get_var_name(var: _GeneralVarData) -> str:
+    return (
+        var.name.replace("[", "")
+        .replace("]", "")
+        .replace(",", "")
+        .replace("'", "")
+        .replace('"', "")
+    )