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

classiq/interface/chemistry/molecule.py

@@ -1,8 +1,10 @@
-from typing import List, Literal, Union
+from typing import Literal, Union
 
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.chemistry.elements import ELEMENTS
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.custom_pydantic_types import AtomType
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
@@ -17,9 +19,9 @@ class Atom(HashablePydanticBaseModel):
 
 
 class Molecule(HashablePydanticBaseModel):
-    atoms: List[Atom] = pydantic.Field(
+    atoms: list[Atom] = pydantic.Field(
         description="A list of atoms each containing the atoms symbol and  its (x,y,z) location",
-        min_items=1,
+        min_length=1,
     )
     spin: pydantic.NonNegativeInt = pydantic.Field(
         default=1, description="spin of the molecule"
@@ -29,37 +31,41 @@ class Molecule(HashablePydanticBaseModel):
     )
 
     @property
-    def atoms_type(self) -> List[AtomType]:
+    def atoms_type(self) -> list[AtomType]:
         return [(atom.symbol, [atom.x, atom.y, atom.z]) for atom in self.atoms]
 
-    @pydantic.validator("atoms", each_item=True, pre=True)
-    def _validate_atoms(cls, atom: Union[AtomType, Atom]) -> Atom:
+    @classmethod
+    def _validate_atom(cls, atom: Union[AtomType, Atom]) -> Atom:
         if isinstance(atom, (list, tuple)):
             return cls._validate_old_atoms_type(atom)
         return atom
 
+    @pydantic.field_validator("atoms", mode="before")
+    @classmethod
+    def _validate_atoms(cls, atoms: list[Union[AtomType, Atom]]) -> list[Atom]:
+        return [cls._validate_atom(atom) for atom in atoms]
+
     @staticmethod
     def _validate_old_atoms_type(atom: AtomType) -> Atom:
         if len(atom) != 2:
-            raise ValueError(
+            raise ClassiqValueError(
                 "each atom should be a list of two entries: 1) name pf the elemnt (str) 2) list of its (x,y,z) location"
             )
-        if type(atom[0]) is not str:
-            raise ValueError(
+        if not isinstance(atom[0], str):
+            raise ClassiqValueError(
                 f"atom name should be a string. unknown element: {atom[0]}."
             )
         if len(atom[1]) != 3:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"location of the atom is of length three, representing the (x,y,z) coordinates of the atom, error value: {atom[1]}"
             )
         for idx in atom[1]:
-            if type(idx) is not float and type(idx) is not int:
-                raise ValueError(
+            if not isinstance(idx, (float, int)):
+                raise ClassiqValueError(
                     f"coordinates of the atom should be of type float. error value: {idx}"
                 )
         symbol, coordinate = atom
 
         return Atom(symbol=symbol, x=coordinate[0], y=coordinate[1], z=coordinate[2])
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/chemistry/operator.py

@@ -1,18 +1,26 @@
+from collections.abc import Collection
 from functools import reduce
-from typing import Any, Collection, Dict, List, Optional, Tuple, Union, cast
+from typing import (
+    Any,
+    Optional,
+    Union,
+    cast,
+)
 
 import numpy as np
 import pydantic
 import sympy
 from more_itertools import all_equal
+from pydantic import ConfigDict
 
-from classiq.interface.generator.expressions.enums.pauli import Pauli
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import validate_expression_str
 from classiq.interface.generator.parameters import (
     ParameterComplexType,
     ParameterType,
     PydanticParameterComplexType,
 )
+from classiq.interface.generator.types.builtin_enum_declarations import Pauli
 from classiq.interface.helpers.custom_pydantic_types import (
     PydanticPauliList,
     PydanticPauliMonomial,
@@ -23,8 +31,6 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 )
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq.exceptions import ClassiqValueError
-
 
 class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     """
@@ -34,8 +40,8 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     pauli_list: PydanticPauliList = pydantic.Field(
         description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
     )
-    is_hermitian: bool = pydantic.Field(default=False)
     has_complex_coefficients: bool = pydantic.Field(default=True)
+    is_hermitian: bool = pydantic.Field(default=False)
 
     def show(self) -> str:
         if self.is_hermitian:
@@ -47,16 +53,19 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
         )
 
-    @pydantic.validator("pauli_list", each_item=True, pre=True)
+    @pydantic.field_validator("pauli_list", mode="before")
+    @classmethod
     def _validate_pauli_monomials(
-        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
-    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
-        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
-            monomial=monomial
-        )  # Validate the length of the monomial.
-        coeff = cls._validate_monomial_coefficient(monomial[1])
-        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
-        return (parsed_monomial.string, parsed_monomial.coeff)
+        cls, pauli_list: PydanticPauliList
+    ) -> PydanticPauliList:
+        validated_pauli_list = []
+        for monomial in pauli_list:
+            # Validate the length
+            _PauliMonomialLengthValidator(monomial=monomial)  # type: ignore[call-arg]
+            coeff = cls._validate_monomial_coefficient(monomial[1])
+            parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)
+            validated_pauli_list.append((parsed_monomial.string, parsed_monomial.coeff))
+        return validated_pauli_list
 
     @staticmethod
     def _validate_monomial_coefficient(
@@ -68,16 +77,38 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             coeff = str(coeff)
         return coeff
 
-    @pydantic.validator("pauli_list")
+    @pydantic.field_validator("pauli_list", mode="after")
+    @classmethod
     def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
         if not all_equal(len(summand[0]) for summand in pauli_list):
-            raise ValueError("Pauli strings have incompatible lengths.")
+            raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
-    @pydantic.root_validator
-    def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @staticmethod
+    def check_if_hermitian(pauli_list: PydanticPauliList) -> bool:
+        if all(isinstance(summand[1], (float, int, complex)) for summand in pauli_list):
+            if all(np.isclose(summand[1].imag, 0) for summand in pauli_list):  # type: ignore[union-attr]
+                return True
+
+            for pauli_string, coeff in pauli_list:
+                reverse_string = pauli_string[::-1]
+                reverse_found = False
+                for other_string, other_coeff in pauli_list:
+                    if other_string == reverse_string and np.isclose(
+                        coeff, other_coeff.conjugate()  # type: ignore[union-attr]
+                    ):
+                        reverse_found = True
+                        break
+                if not reverse_found:
+                    return False
+            return True
+        return False
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_hermitianity(cls, values: dict[str, Any]) -> dict[str, Any]:
         pauli_list = values.get("pauli_list", [])
-        if all(isinstance(summand[1], complex) for summand in pauli_list):
+        if PauliOperator.check_if_hermitian(pauli_list):
             values["is_hermitian"] = all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
@@ -85,7 +116,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         if values.get("is_hermitian", False):
             values["has_complex_coefficients"] = False
             values["pauli_list"] = [
-                (summand[0], complex(summand[1].real)) for summand in pauli_list
+                (summand[0], complex(summand[1]).real) for summand in pauli_list
             ]
         else:
             values["has_complex_coefficients"] = not all(
@@ -120,7 +151,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         )
 
     @staticmethod
-    def _is_sub_pauli_commutative(qubit_pauli_string: Union[List[str], str]) -> bool:
+    def _is_sub_pauli_commutative(qubit_pauli_string: Union[list[str], str]) -> bool:
         unique_paulis = set(qubit_pauli_string) - {"I"}
         return len(unique_paulis) <= 1
 
@@ -128,8 +159,12 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     def num_qubits(self) -> int:
         return len(self.pauli_list[0][0])
 
+    @property
+    def all_coefficients_numeric(self) -> bool:
+        return all(isinstance(summand[1], complex) for summand in self.pauli_list)
+
     def to_matrix(self) -> np.ndarray:
-        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
+        if not self.all_coefficients_numeric:
             raise ClassiqValueError(
                 "Supporting only Hamiltonian with numeric coefficients."
             )
@@ -149,7 +184,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
             for (pauli_string, coeff) in self.pauli_list
         ]
-        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
+        return self.model_copy(update={"pauli_list": new_pauli_list}, deep=True)
 
     @staticmethod
     def _reorder_pauli_string(
@@ -172,16 +207,18 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         num_extra_qubits: int,
     ) -> None:
         if num_extra_qubits < 0:
-            raise ValueError("Number of extra qubits cannot be negative")
+            raise ClassiqValueError("Number of extra qubits cannot be negative")
 
         if len(order) != num_qubits:
-            raise ValueError("The qubits order doesn't match the Pauli operator")
+            raise ClassiqValueError("The qubits order doesn't match the Pauli operator")
 
         if len(order) != len(set(order)):
-            raise ValueError("The qubits order is not one-to-one")
+            raise ClassiqValueError("The qubits order is not one-to-one")
 
         if not all(pos < num_qubits + num_extra_qubits for pos in order):
-            raise ValueError("The qubits order contains qubits which do no exist")
+            raise ClassiqValueError(
+                "The qubits order contains qubits which do no exist"
+            )
 
     @classmethod
     def reorder(
@@ -197,217 +234,19 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
             for pauli_string, coeff in operator.pauli_list
         ]
-        return cls(pauli_list=new_pauli_list)
+        return cls(pauli_list=new_pauli_list, is_hermitian=operator.is_hermitian)
 
     @classmethod
     def from_unzipped_lists(
         cls,
-        operators: List[List[Pauli]],
-        coefficients: Optional[List[complex]] = None,
+        operators: list[list["Pauli"]],
+        coefficients: Optional[list[complex]] = None,
     ) -> "PauliOperator":
         if coefficients is None:
             coefficients = [1] * len(operators)
 
         if len(operators) != len(coefficients):
-            raise ValueError(
-                f"The number of coefficients ({len(coefficients)}) must be equal to the number of pauli operators ({len(operators)})"
-            )
-
-        return cls(
-            pauli_list=[
-                (pauli_integers_to_str(op), coeff)
-                for op, coeff in zip(operators, coefficients)
-            ]
-        )
-
-    class Config:
-        frozen = True
-
-
-class PauliOperatorV1(HashablePydanticBaseModel):
-    """
-    Specification of a Pauli sum operator.
-    """
-
-    pauli_list: PydanticPauliList = pydantic.Field(
-        description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
-    )
-    is_hermitian: bool = pydantic.Field(default=False)
-    has_complex_coefficients: bool = pydantic.Field(default=True)
-
-    def show(self) -> str:
-        if self.is_hermitian:
-            # If the operator is hermitian then the coefficients must be numeric
-            return "\n".join(
-                f"{summand[1].real:+.3f} * {summand[0]}" for summand in self.pauli_list  # type: ignore[union-attr]
-            )
-        return "\n".join(
-            f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
-        )
-
-    @pydantic.validator("pauli_list", each_item=True, pre=True)
-    def _validate_pauli_monomials(
-        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
-    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
-        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
-            monomial=monomial
-        )  # Validate the length of the monomial.
-        coeff = cls._validate_monomial_coefficient(monomial[1])
-        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
-        return (parsed_monomial.string, parsed_monomial.coeff)
-
-    @staticmethod
-    def _validate_monomial_coefficient(
-        coeff: Union[sympy.Expr, ParameterComplexType]
-    ) -> ParameterComplexType:
-        if isinstance(coeff, str):
-            validate_expression_str(coeff)
-        elif isinstance(coeff, sympy.Expr):
-            coeff = str(coeff)
-        return coeff
-
-    @pydantic.validator("pauli_list")
-    def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
-        if not all_equal(len(summand[0]) for summand in pauli_list):
-            raise ValueError("Pauli strings have incompatible lengths.")
-        return pauli_list
-
-    @pydantic.root_validator
-    def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        pauli_list = values.get("pauli_list", [])
-        if all(isinstance(summand[1], complex) for summand in pauli_list):
-            values["is_hermitian"] = all(
-                np.isclose(complex(summand[1]).real, summand[1])
-                for summand in pauli_list
-            )
-        if values.get("is_hermitian", False):
-            values["has_complex_coefficients"] = False
-            values["pauli_list"] = [
-                (summand[0], complex(summand[1].real)) for summand in pauli_list
-            ]
-        else:
-            values["has_complex_coefficients"] = not all(
-                np.isclose(complex(summand[1]).real, summand[1])
-                for summand in pauli_list
-                if isinstance(summand[1], complex)
-            )
-        return values
-
-    def __mul__(self, coefficient: complex) -> "PauliOperatorV1":
-        multiplied_ising = [
-            (monomial[0], self._multiply_monomial_coefficient(monomial[1], coefficient))
-            for monomial in self.pauli_list
-        ]
-        return self.__class__(pauli_list=multiplied_ising)
-
-    @staticmethod
-    def _multiply_monomial_coefficient(
-        monomial_coefficient: ParameterComplexType, coefficient: complex
-    ) -> ParameterComplexType:
-        if isinstance(monomial_coefficient, ParameterType):
-            return str(sympy.sympify(monomial_coefficient) * coefficient)
-        return monomial_coefficient * coefficient
-
-    @property
-    def is_commutative(self) -> bool:
-        return all(
-            self._is_sub_pauli_commutative(
-                [summand[0][qubit_num] for summand in self.pauli_list]
-            )
-            for qubit_num in range(self.num_qubits)
-        )
-
-    @staticmethod
-    def _is_sub_pauli_commutative(qubit_pauli_string: Union[List[str], str]) -> bool:
-        unique_paulis = set(qubit_pauli_string) - {"I"}
-        return len(unique_paulis) <= 1
-
-    @property
-    def num_qubits(self) -> int:
-        return len(self.pauli_list[0][0])
-
-    def to_matrix(self) -> np.ndarray:
-        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
             raise ClassiqValueError(
-                "Supporting only Hamiltonian with numeric coefficients."
-            )
-        return sum(
-            cast(complex, summand[1]) * to_pauli_matrix(summand[0])
-            for summand in self.pauli_list
-        )  # type: ignore[return-value]
-
-    @staticmethod
-    def _extend_pauli_string(
-        pauli_string: PydanticPauliMonomialStr, num_extra_qubits: int
-    ) -> PydanticPauliMonomialStr:
-        return "I" * num_extra_qubits + pauli_string
-
-    def extend(self, num_extra_qubits: int) -> "PauliOperatorV1":
-        new_pauli_list = [
-            (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
-            for (pauli_string, coeff) in self.pauli_list
-        ]
-        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
-
-    @staticmethod
-    def _reorder_pauli_string(
-        pauli_string: PydanticPauliMonomialStr,
-        order: Collection[int],
-        new_num_qubits: int,
-    ) -> PydanticPauliMonomialStr:
-        reversed_pauli_string = pauli_string[::-1]
-        reversed_new_pauli_string = ["I"] * new_num_qubits
-
-        for logical_pos, actual_pos in enumerate(order):
-            reversed_new_pauli_string[actual_pos] = reversed_pauli_string[logical_pos]
-
-        return "".join(reversed(reversed_new_pauli_string))
-
-    @staticmethod
-    def _validate_reorder(
-        order: Collection[int],
-        num_qubits: int,
-        num_extra_qubits: int,
-    ) -> None:
-        if num_extra_qubits < 0:
-            raise ValueError("Number of extra qubits cannot be negative")
-
-        if len(order) != num_qubits:
-            raise ValueError("The qubits order doesn't match the Pauli operator")
-
-        if len(order) != len(set(order)):
-            raise ValueError("The qubits order is not one-to-one")
-
-        if not all(pos < num_qubits + num_extra_qubits for pos in order):
-            raise ValueError("The qubits order contains qubits which do no exist")
-
-    @classmethod
-    def reorder(
-        cls,
-        operator: "PauliOperatorV1",
-        order: Collection[int],
-        num_extra_qubits: int = 0,
-    ) -> "PauliOperatorV1":
-        cls._validate_reorder(order, operator.num_qubits, num_extra_qubits)
-
-        new_num_qubits = operator.num_qubits + num_extra_qubits
-        new_pauli_list = [
-            (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
-            for pauli_string, coeff in operator.pauli_list
-        ]
-        return cls(pauli_list=new_pauli_list)
-
-    @classmethod
-    def from_unzipped_lists(
-        cls,
-        operators: List[List[Pauli]],
-        coefficients: Optional[List[complex]] = None,
-    ) -> "PauliOperatorV1":
-        if coefficients is None:
-            coefficients = [1] * len(operators)
-
-        if len(operators) != len(coefficients):
-            raise ValueError(
                 f"The number of coefficients ({len(coefficients)}) must be equal to the number of pauli operators ({len(operators)})"
             )
 
@@ -418,8 +257,7 @@ class PauliOperatorV1(HashablePydanticBaseModel):
             ]
         )
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 # This class validates the length of a monomial.
@@ -428,8 +266,7 @@ class _PauliMonomialLengthValidator:
     monomial: PydanticPauliMonomial
 
 
-@pydantic.dataclasses.dataclass
-class _PauliMonomialParser:
+class _PauliMonomialParser(pydantic.BaseModel):
     string: PydanticPauliMonomialStr
     coeff: PydanticParameterComplexType
 
@@ -448,7 +285,7 @@ def to_pauli_matrix(pauli_op: PydanticPauliMonomialStr) -> np.ndarray:
 
 def validate_operator_is_hermitian(pauli_operator: PauliOperator) -> PauliOperator:
     if not pauli_operator.is_hermitian:
-        raise ValueError("Coefficients of the Hamiltonian must be real numbers")
+        raise ClassiqValueError("Coefficients of the Hamiltonian must be real numbers")
     return pauli_operator
 
 
@@ -456,13 +293,15 @@ def validate_operator_has_no_complex_coefficients(
     pauli_operator: PauliOperator,
 ) -> PauliOperator:
     if pauli_operator.has_complex_coefficients:
-        raise ValueError("Coefficients of the Hamiltonian mustn't be complex numbers")
+        raise ClassiqValueError(
+            "Coefficients of the Hamiltonian mustn't be complex numbers"
+        )
     return pauli_operator
 
 
-def pauli_integers_to_str(paulis: List[Pauli]) -> str:
+def pauli_integers_to_str(paulis: list[Pauli]) -> str:
     return "".join([Pauli(pauli).name for pauli in paulis])
 
 
 class PauliOperators(VersionedModel):
-    operators: List[PauliOperator]
+    operators: list[PauliOperator]

classiq/interface/combinatorial_optimization/encoding_types.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class EncodingType(StrEnum):

classiq/interface/combinatorial_optimization/examples/ascending_sequence.py

@@ -1,17 +1,15 @@
-from typing import List
-
 import numpy as np
 import pyomo.core as pyo
 
 
-def ascending_sequence(coeffs: List[int], bound: int) -> pyo.ConcreteModel:
+def ascending_sequence(coeffs: list[int], bound: int) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()
     model.x = pyo.Var(
         range(len(coeffs)), domain=pyo.NonNegativeIntegers, bounds=(0, bound)
     )
 
     @model.Constraint(range(len(coeffs) - 1))
-    def monotone_rule(model, idx):
+    def monotone_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
         return model.x[idx] <= model.x[idx + 1]
 
     model.cost = pyo.Objective(

classiq/interface/combinatorial_optimization/examples/greater_than_ilp.py

@@ -19,7 +19,7 @@ def greater_than_ilp(
     )
 
     @model.Constraint(range(num_constraints))
-    def monotone_rule(model, idx):
+    def monotone_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
         return a[idx, :] @ list(model.x.values()) >= float(b[idx])
 
     # model objective: max(c * x)

classiq/interface/combinatorial_optimization/examples/ilp.py

@@ -1,5 +1,6 @@
 import numpy as np
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def ilp(a: np.ndarray, b: np.ndarray, c: np.ndarray, bound: int) -> pyo.ConcreteModel:
@@ -17,7 +18,7 @@ def ilp(a: np.ndarray, b: np.ndarray, c: np.ndarray, bound: int) -> pyo.Concrete
     )
 
     @model.Constraint(range(num_constraints))
-    def monotone_rule(model, idx):
+    def monotone_rule(model: pyo.ConcreteModel, idx: int) -> pyo_expr.ExpressionBase:
         return a[idx, :] @ list(model.x.values()) <= float(b[idx])
 
     # model objective: max(c * x)

classiq/interface/combinatorial_optimization/examples/integer_portfolio_optimization.py

@@ -1,16 +1,14 @@
-from typing import List
-
 import numpy as np
 import pyomo.core as pyo
 
 
 def integer_portfolio_optimization(
-    covariances: np.ndarray, returns: np.ndarray, upper_bounds: List[int]
+    covariances: np.ndarray, returns: np.ndarray, upper_bounds: list[int]
 ) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()
     num_assets = len(returns)
 
-    def bounds(_, i):
+    def bounds(model: pyo.ConcreteModel, i: int) -> tuple[int, int]:
         return 0, upper_bounds[i]
 
     model.x = pyo.Var(range(num_assets), domain=pyo.NonNegativeIntegers, bounds=bounds)

classiq/interface/combinatorial_optimization/examples/knapsack.py

@@ -1,13 +1,13 @@
-from typing import List, Optional
+from typing import Optional
 
 import numpy as np
 import pyomo.core as pyo
 
 
 def knapsack(
-    values: List[int],
+    values: list[int],
     upper_bound: int,
-    weights: Optional[List[int]] = None,
+    weights: Optional[list[int]] = None,
     max_weight: Optional[int] = None,
 ) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()

classiq/interface/combinatorial_optimization/examples/mds.py

@@ -1,5 +1,6 @@
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def mds(graph: nx.Graph) -> pyo.ConcreteModel:
@@ -7,7 +8,7 @@ def mds(graph: nx.Graph) -> pyo.ConcreteModel:
     model.x = pyo.Var(graph.nodes, domain=pyo.Binary)
 
     @model.Constraint(graph.nodes)
-    def dominating_rule(model, idx):
+    def dominating_rule(model: pyo.ConcreteModel, idx: int) -> pyo_expr.ExpressionBase:
         sum_of_neighbors = sum(model.x[neighbor] for neighbor in graph.neighbors(idx))
         return model.x[idx] + sum_of_neighbors >= 1
 

classiq/interface/combinatorial_optimization/examples/mht.py

@@ -1,12 +1,12 @@
 import math
-from typing import Dict, Tuple
 
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 Node = int
-Edge = Tuple[Node, Node]
-Pubo = Dict[Tuple[Edge, ...], float]
+Edge = tuple[Node, Node]
+Pubo = dict[tuple[Edge, ...], float]
 
 
 def build_mht_pyomo_model(
@@ -22,7 +22,9 @@ def build_mht_pyomo_model(
     if has_constraints:
 
         @model.Constraint(model.Nodes)
-        def out_edges_rule(model, idx):
+        def out_edges_rule(
+            model: pyo.ConcreteModel, idx: int
+        ) -> pyo_expr.ExpressionBase:
             out_nodes = [
                 node_id for node_id in model.Nodes if [idx, node_id] in model.Arcs
             ]
@@ -32,7 +34,9 @@ def build_mht_pyomo_model(
                 return pyo.Constraint.Feasible
 
         @model.Constraint(model.Nodes)
-        def in_edges_rule(model, idx):
+        def in_edges_rule(
+            model: pyo.ConcreteModel, idx: int
+        ) -> pyo_expr.ExpressionBase:
             in_nodes = [
                 node_id for node_id in model.Nodes if [node_id, idx] in model.Arcs
             ]
@@ -41,7 +45,7 @@ def build_mht_pyomo_model(
             else:
                 return pyo.Constraint.Feasible
 
-    def obj_expression(model):
+    def obj_expression(model: pyo.ConcreteModel) -> pyo_expr.ExpressionBase:
         return sum(
             round(pubo_energy, _decimals)
             * math.prod(model.x[edge] for edge in pubo_edges)