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

classiq/applications_model_constructors/combinatorial_helpers/encoding_mapping.py

@@ -0,0 +1,107 @@
+import itertools
+from dataclasses import dataclass, field
+from typing import Dict, List, 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.applications_model_constructors.combinatorial_helpers import pyomo_utils
+from classiq.exceptions import ClassiqCombOptError
+
+
+@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_model_constructors/combinatorial_helpers/encoding_utils.py

@@ -0,0 +1,122 @@
+import math
+from itertools import filterfalse
+from typing import Any, Dict, 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.applications_model_constructors.combinatorial_helpers import pyomo_utils
+from classiq.exceptions import ClassiqCombOptNoSolutionError
+
+_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"
+
+
+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_model_constructors/combinatorial_helpers/memory.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import Dict, List, Tuple
+
+from pyomo.core.base import _GeneralVarData
+
+from classiq.interface.generator.function_params import IOName
+
+from classiq.applications_model_constructors.combinatorial_helpers import encoding_utils
+from classiq.applications_model_constructors.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('"', "")
+    )

classiq/applications_model_constructors/combinatorial_helpers/multiple_comp_basis_sp.py

@@ -0,0 +1,34 @@
+from classiq.interface.generator.function_params import DEFAULT_OUTPUT_NAME
+from classiq.interface.generator.functions import SynthesisNativeFunctionDefinition
+from classiq.interface.generator.state_preparation import (
+    ComputationalBasisStatePreparation,
+)
+
+from classiq import FunctionGenerator, QReg
+
+BinaryStr = str
+Name = str
+
+
+def multiple_comp_basis_sp(
+    function_name: str, states: dict[Name, BinaryStr], call_name_frmt: str = "{}"
+) -> SynthesisNativeFunctionDefinition:
+    generator = FunctionGenerator(function_name=function_name)
+    qregs_dict = {
+        var_name: QReg[len(state)]  # type:ignore[misc]
+        for var_name, state in states.items()
+    }
+    qregs = generator.create_inputs(qregs_dict)
+
+    for var_name, state in states.items():
+        params = ComputationalBasisStatePreparation(computational_state=state)
+        qregs[var_name] = generator.ComputationalBasisStatePreparation(
+            params,
+            in_wires=qregs[var_name],
+            strict_zero_ios=False,
+            call_name=call_name_frmt.format(var_name),
+        )[DEFAULT_OUTPUT_NAME]
+
+    generator.set_outputs(qregs)
+
+    return generator.to_function_definition()

classiq/applications_model_constructors/combinatorial_helpers/optimization_model.py

@@ -0,0 +1,166 @@
+import copy
+from itertools import filterfalse
+from typing import List, Optional, Union
+
+import pyomo.environ as pyo
+from pyomo.core import ConcreteModel
+from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.environ import Expression
+
+from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.combinatorial_optimization import sense
+from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
+from classiq.interface.combinatorial_optimization.solver_types import QSolver
+
+from classiq.applications_model_constructors.combinatorial_helpers import (
+    encoding_utils,
+    memory,
+    pyomo_utils,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.encoding_mapping import (
+    EncodingMapping,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.memory import (
+    InternalQuantumReg,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.transformations import (
+    encoding,
+    ising_converter,
+    penalty,
+    slack_variables,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.transformations.fixed_variables import (
+    add_fixed_variables_to_solution,
+    remove_fixed_variables,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.transformations.penalty_support import (
+    is_model_penalty_supported,
+)
+from classiq.exceptions import ClassiqCombOptError
+
+
+class OptimizationModel:
+    def __init__(
+        self,
+        model: ConcreteModel,
+        qsolver: QSolver,
+        penalty_energy: Optional[float],
+        encoding_type: Optional[EncodingType] = None,
+    ) -> None:
+        assert model.nobjectives() == 1, "model must have a single objective"
+        self._model_original = copy.deepcopy(model)
+        self._assigned_model = remove_fixed_variables(model)
+        self.qsolver = qsolver
+        self._encoding_type = encoding_type
+
+        self.is_encoded = encoding_utils.is_model_encodable(model)
+        if self.is_encoded:
+            if self._encoding_type is None:
+                self._encoding_type = EncodingType.BINARY
+            self._model_encoder = encoding.ModelEncoder(
+                model, qsolver, self._encoding_type
+            )
+            self._model = self._model_encoder.encoded_model
+            self._vars_encoding_mapping = self._model_encoder.vars_encoding_mapping
+        else:
+            self._model = model
+            # TODO How to handle encoding_type == None
+            self._vars_encoding_mapping = EncodingMapping(self._encoding_type)  # type: ignore[arg-type]
+
+        self._slack_vars_convert()
+
+        self.memory_mapping = memory.MemoryMapping(
+            self.vars_not_encoded, self._vars_encoding_mapping
+        )
+
+        self.is_maximization = sense.is_maximization(model)
+        self.objective = next(self._model.component_objects(pyo.Objective))
+
+        self.penalty_energy = penalty_energy
+        self._add_penalty_term()
+
+        self.ising: PauliOperator = self._to_ising()
+
+    @property
+    def vars(self) -> List[_GeneralVarData]:
+        return pyomo_utils.extract(self._model, _GeneralVarData)
+
+    @property
+    def vars_not_encoded(self) -> List[_GeneralVarData]:
+        return list(filterfalse(encoding_utils.is_obj_encoded, self.vars))
+
+    @property
+    def _ising_vars(self) -> List[_GeneralVarData]:
+        if self.is_encoded:
+            return [
+                var
+                for var in self.vars
+                if encoding_utils.is_obj_encoded(var)
+                or slack_variables.is_obj_slacked(var)
+            ]
+        else:
+            return self.vars
+
+    @property
+    def constraints(self) -> List[_GeneralConstraintData]:
+        all_constraints = pyomo_utils.extract(self._model, _GeneralConstraintData)
+        return list(filterfalse(encoding_utils.is_obj_encoded, all_constraints))
+
+    @property
+    def qregs(self) -> List[InternalQuantumReg]:
+        return self.memory_mapping.qregs
+
+    @property
+    def num_qubits(self) -> int:
+        return sum(qreg.size for qreg in self.qregs)
+
+    @property
+    def sign(self) -> int:
+        return -1 if self.is_maximization else 1
+
+    def _add_penalty_term(self) -> None:
+        if self.qsolver == QSolver.QAOAPenalty:
+            self.objective.expr += self._get_penalty_term()
+
+    def _get_penalty_term(self) -> Union[int, Expression]:
+        normalized_penalty_term = penalty.get_penalty_expression(self.constraints)
+        penalty_term = self.penalty_energy * normalized_penalty_term * self.sign
+
+        if self.is_encoded:
+            penalty_term = self._model_encoder.encode_expr(penalty_term)
+        return penalty_term
+
+    def _to_ising(self) -> PauliOperator:
+        return (
+            ising_converter.convert_pyomo_to_hamiltonian(
+                self.objective.expr, self._ising_vars, self.qregs
+            )
+            * self.sign
+        )
+
+    def _remove_slack_variables_from_solution(self, solution: List[int]) -> List[int]:
+        variables = pyomo_utils.extract(self._model_original, pyo.Var)
+        return solution[: len(variables)]
+
+    def decode(self, solution: List[int]) -> List[int]:
+        if self.is_encoded:
+            solution = self._vars_encoding_mapping.decode(solution)
+
+        solution = add_fixed_variables_to_solution(self._model_original, solution)
+
+        return self._remove_slack_variables_from_solution(solution)
+
+    def get_operator(self) -> PauliOperator:
+        try:
+            return self.ising
+        except Exception as exc:
+            raise ClassiqCombOptError(
+                f"Could not convert optimization model to operator: {exc}"
+            ) from exc
+
+    def _slack_vars_convert(self) -> ConcreteModel:
+        if self.qsolver == QSolver.QAOAPenalty and not is_model_penalty_supported(
+            self._model
+        ):
+            return slack_variables.slack_vars_convert(self._model)

classiq/applications_model_constructors/combinatorial_helpers/pauli_helpers/pauli_sparsing.py

@@ -0,0 +1,31 @@
+from typing import Any, Union
+
+import numpy as np
+
+
+class SparsePauliOp:
+    def __init__(self, paulis: Any, coeffs: Any) -> None:
+        assert len(paulis) == len(
+            coeffs
+        ), "Paulis and coefficients lists must have the same length."
+        self.paulis = np.array(paulis)
+        self.coeffs = np.array(coeffs, dtype=complex)
+
+    def __str__(self) -> str:
+        terms = [f"{coef}*{pauli}" for coef, pauli in zip(self.coeffs, self.paulis)]
+        return " + ".join(terms)
+
+    def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
+        """Add two SparsePauliOp objects."""
+        if not isinstance(other, SparsePauliOp):
+            raise ValueError("Can only add SparsePauliOp objects.")
+        new_paulis = np.concatenate([self.paulis, other.paulis])
+        new_coeffs = np.concatenate([self.coeffs, other.coeffs])
+        return SparsePauliOp(new_paulis, new_coeffs)
+
+    def __mul__(self, other: Union[int, float, complex]) -> "SparsePauliOp":
+        """Scalar multiplication of a SparsePauliOp."""
+        if not isinstance(other, (int, float, complex)):
+            raise ValueError("Can only multiply by scalar values.")
+        new_coeffs = self.coeffs * other
+        return SparsePauliOp(self.paulis, new_coeffs)

classiq/applications_model_constructors/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -0,0 +1,65 @@
+from typing import List, cast
+
+from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.generator.expressions.enums.pauli import Pauli
+from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
+from classiq.interface.helpers.custom_pydantic_types import PydanticPauliList
+
+from classiq.exceptions import (
+    ClassiqExecutorInvalidHamiltonianError,
+    ClassiqNonNumericCoefficientInPauliError,
+    ClassiqValueError,
+)
+
+
+def _pauli_str_to_enums(pauli_str: str) -> str:
+    return ", ".join(f"Pauli.{pauli_term}" for pauli_term in pauli_str)
+
+
+def pauli_integers_to_str(paulis: List[Pauli]) -> str:
+    return "".join([Pauli(pauli).name for pauli in paulis])
+
+
+def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> List[QmodPyStruct]:
+    pauli_struct_list: List[QmodPyStruct] = []
+    for pauli_term in pauli_list:
+        if not isinstance(pauli_term[1], complex) or pauli_term[1].imag != 0:
+            raise ClassiqNonNumericCoefficientInPauliError(
+                "Coefficient is not a number."
+            )
+
+        pauli_struct_list.append(
+            {
+                "pauli": [Pauli[p] for p in pauli_term[0]],
+                "coefficient": pauli_term[1].real,
+            }
+        )
+    return pauli_struct_list
+
+
+def get_pauli_operator(pauli_operator: List[QmodPyStruct]) -> PauliOperator:
+    pauli_list = [
+        (
+            pauli_integers_to_str(elem["pauli"]),
+            elem["coefficient"],
+        )
+        for elem in pauli_operator
+    ]
+
+    try:
+        pauli = PauliOperator(pauli_list=pauli_list)
+    except ValueError:
+        raise ClassiqExecutorInvalidHamiltonianError() from None
+
+    return pauli
+
+
+def _pauli_operator_to_qmod(hamiltonian: PauliOperator) -> str:
+    if not all(isinstance(summand[1], complex) for summand in hamiltonian.pauli_list):
+        raise ClassiqValueError(
+            "Supporting only Hamiltonian with numeric coefficients."
+        )
+    return ", ".join(
+        f"struct_literal(PauliTerm, pauli=[{_pauli_str_to_enums(pauli)}], coefficient={cast(complex, coeff).real})"
+        for pauli, coeff in hamiltonian.pauli_list
+    )