classiq 0.86.0__py3-none-any.whl → 0.87.0__py3-none-any.whl

classiq/__init__.py

@@ -37,6 +37,7 @@ from classiq.applications.combinatorial_optimization import (
 from classiq.applications.hamiltonian.pauli_decomposition import (
     hamiltonian_to_matrix,
     matrix_to_hamiltonian,
+    matrix_to_pauli_operator,
 )
 from classiq.execution import *  # noqa: F403
 from classiq.execution import __all__ as _execution_all
@@ -109,6 +110,7 @@ __all__ = (
         "show",
         "hamiltonian_to_matrix",
         "matrix_to_hamiltonian",
+        "matrix_to_pauli_operator",
         "quantum_program_from_qasm",
         "quantum_program_from_qasm_async",
     ]

classiq/applications/chemistry/hartree_fock.py

@@ -55,7 +55,11 @@ def _get_hf_qubit_op(
     problem: FermionHamiltonianProblem, mapper: FermionToQubitMapper
 ) -> QubitOperator:
     hf_fermion_op = get_hf_fermion_op(problem)
-    return mapper.map(hf_fermion_op)
+    # In case of tapering: We need to taper the state, not the operator. This can be done by passing is_invariant=True
+    # (even though the operator is not necessarily invariant).
+    # Then, taper_off_qubits eliminates the qubits to taper off (up to a sign)
+    # for each term in the Hamiltonian.
+    return mapper.map(hf_fermion_op, is_invariant=True)
 
 
 def _apply_term_on_zero_state(

classiq/applications/chemistry/op_utils.py

@@ -27,7 +27,7 @@ def qubit_op_to_pauli_terms(
 ) -> SparsePauliOp:
     n_qubits = _get_n_qubits(qubit_op, n_qubits)
     return SparsePauliOp(
-        terms=[  # type:ignore[arg-type]
+        terms=[
             SparsePauliTerm(
                 paulis=[  # type:ignore[arg-type]
                     IndexedPauli(
@@ -40,7 +40,7 @@ def qubit_op_to_pauli_terms(
             )
             for term, coeff in qubit_op.terms.items()
         ],
-        num_qubits=n_qubits,  # type:ignore[arg-type]
+        num_qubits=n_qubits,
     )
 
 

classiq/applications/combinatorial_helpers/encoding_mapping.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass, field
 from typing import Optional, Union
 
 import pyomo.environ as pyo
-from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.var import VarData
 from pyomo.core.expr.visitor import clone_expression, identify_variables
 
 from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
@@ -14,9 +14,9 @@ from classiq.applications.combinatorial_helpers import pyomo_utils
 
 @dataclass
 class VarExpressionMapping:
-    var: _GeneralVarData
+    var: VarData
     expr: pyo.Expression
-    encodings_vars: list[_GeneralVarData] = field(default_factory=list)
+    encodings_vars: list[VarData] = field(default_factory=list)
 
 
 class EncodingMapping:
@@ -25,11 +25,11 @@ class EncodingMapping:
         self.encoding_type = encoding_type
 
     @property
-    def original_vars(self) -> list[_GeneralVarData]:
+    def original_vars(self) -> list[VarData]:
         return [pair.var for pair in self._data]
 
     @property
-    def encodings_vars(self) -> list[_GeneralVarData]:
+    def encodings_vars(self) -> list[VarData]:
         return list(
             itertools.chain.from_iterable(
                 var_mapping.encodings_vars for var_mapping in self._data
@@ -45,9 +45,9 @@ class EncodingMapping:
 
     def add(
         self,
-        original_var: _GeneralVarData,
+        original_var: VarData,
         encoding_expr: pyo.Expression,
-        encodings_vars: Union[list[_GeneralVarData], None] = None,
+        encodings_vars: Union[list[VarData], None] = None,
     ) -> None:
         if encodings_vars is None:
             encodings_vars = list(identify_variables(encoding_expr))
@@ -59,25 +59,21 @@ class EncodingMapping:
             )
         )
 
-    def _check_unique_encoding_vars(self, variables: list[_GeneralVarData]) -> None:
+    def _check_unique_encoding_vars(self, variables: list[VarData]) -> 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:
+    def get_var_expr_mapping(self, original_var: VarData) -> 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]:
+    def get_encoding_vars(self, original_var: VarData) -> list[VarData]:
         return self.get_var_expr_mapping(original_var).encodings_vars
 
-    def get_original_var(
-        self, encoding_var: _GeneralVarData
-    ) -> Optional[_GeneralVarData]:
+    def get_original_var(self, encoding_var: VarData) -> Optional[VarData]:
         for original_var in self.original_vars:
             if pyomo_utils.contains(encoding_var, self.get_encoding_vars(original_var)):
                 return original_var

classiq/applications/combinatorial_helpers/encoding_utils.py

@@ -4,14 +4,14 @@ 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.base.var import VarData
 from pyomo.core.expr.numeric_expr import (
     MonomialTermExpression,
     ProductExpression,
-    clone_expression,
 )
+from pyomo.core.expr.visitor import clone_expression
 from sympy import Expr
 
 from classiq.interface.exceptions import ClassiqCombOptNoSolutionError
@@ -26,13 +26,13 @@ def is_model_encodable(model: pyo.ConcreteModel) -> bool:
     return not all(is_var_binary(var) for var in variables)
 
 
-def is_var_binary(var: _GeneralVarData) -> bool:
+def is_var_binary(var: VarData) -> 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:
+def is_var_span_power_of_2(var: VarData) -> bool:
     var_span = get_var_span(var)
     return math.log2(var_span + 1).is_integer()
 
@@ -46,7 +46,7 @@ def is_obj_encoded(var: _ComponentBase) -> bool:
     return ENCODED_SUFFIX in var.name
 
 
-def get_var_span(var: _GeneralVarData) -> int:
+def get_var_span(var: VarData) -> int:
     return var.ub - var.lb
 
 
@@ -54,7 +54,7 @@ def encoded_obj_name(name: str) -> str:
     return name + ENCODED_SUFFIX
 
 
-def get_encoded_var_index(var: _GeneralVarData) -> int:
+def get_encoded_var_index(var: VarData) -> int:
     indexed_var = var.parent_component()
     index = [
         index_temp for index_temp, var_temp in indexed_var.items() if var_temp is var

classiq/applications/combinatorial_helpers/memory.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.var import VarData
 
 from classiq.interface.generator.function_params import IOName
 
@@ -19,13 +19,13 @@ class InternalQuantumReg:
 class MemoryMapping:
     def __init__(
         self,
-        variables: list[_GeneralVarData],
+        variables: list[VarData],
         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.vars: list[VarData] = variables
         self._allocate_memory()
 
     def __len__(self) -> int:
@@ -65,7 +65,7 @@ class MemoryMapping:
         )
 
 
-def get_var_name(var: _GeneralVarData) -> str:
+def get_var_name(var: VarData) -> str:
     return (
         var.name.replace("[", "")
         .replace("]", "")

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -6,8 +6,8 @@ from typing import Optional, Union
 import pyomo.environ as pyo
 import sympy
 from pyomo.core import ConcreteModel
-from pyomo.core.base import _GeneralVarData
 from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.base.var import VarData
 from pyomo.core.expr.sympy_tools import sympyify_expression
 from pyomo.environ import Expression
 
@@ -92,15 +92,15 @@ class OptimizationModel:
         self._initialize_objective_not_encoded(model_copy)
 
     @property
-    def vars(self) -> list[_GeneralVarData]:
-        return pyomo_utils.extract(self._model, _GeneralVarData)
+    def vars(self) -> list[VarData]:
+        return pyomo_utils.extract(self._model, VarData)
 
     @property
-    def vars_not_encoded(self) -> list[_GeneralVarData]:
+    def vars_not_encoded(self) -> list[VarData]:
         return list(filterfalse(encoding_utils.is_obj_encoded, self.vars))
 
     @property
-    def _ising_vars(self) -> list[_GeneralVarData]:
+    def _ising_vars(self) -> list[VarData]:
         if self.is_encoded:
             return [
                 var

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -28,26 +28,22 @@ def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> list[PauliTe
 
 
 def pauli_operator_to_sparse_hamiltonian(
-    pauli_list: PydanticPauliList,
+    pauli_list: list[PauliTerm],
 ) -> SparsePauliOp:
     pauli_terms: list[SparsePauliTerm] = []
     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."
-            )
         term = SparsePauliTerm(
             paulis=[  # type:ignore[arg-type]
-                IndexedPauli(pauli=Pauli[p], index=i)  # type:ignore[arg-type]
-                for i, p in enumerate(pauli_term[0][::-1])
+                IndexedPauli(pauli=p, index=i)  # type:ignore[arg-type]
+                for i, p in enumerate(pauli_term.pauli[::-1])
             ],
-            coefficient=pauli_term[1].real,  # type: ignore[arg-type]
+            coefficient=pauli_term.coefficient,
         )
         pauli_terms.append(term)
 
     return SparsePauliOp(
-        terms=pauli_terms,  # type:ignore[arg-type]
-        num_qubits=len(pauli_list[0][0]),  # type:ignore[arg-type]
+        terms=pauli_terms,
+        num_qubits=len(pauli_list[0].pauli),  # type: ignore[arg-type]
     )
 
 

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -15,11 +15,11 @@ 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.base.var import VarData
 from pyomo.core.expr.base import ExpressionBase
 from pyomo.core.expr.sympy_tools import (
     Pyomo2SympyVisitor,
@@ -35,7 +35,7 @@ from classiq.interface.generator.types.struct_declaration import StructDeclarati
 from classiq.qmod.qmod_variable import QArray, QBit, QNum, QStruct, QVar
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
-ListVars = list[_GeneralVarData]
+ListVars = list[VarData]
 SUPPORTED_TYPES = [
     pyo.Binary,
     pyo.Integers,
@@ -65,12 +65,12 @@ class CombinatorialOptimizationStructDeclaration(StructDeclaration):
     )
 
 
-def contains(var_data: _GeneralVarData, vars_data: ListVars) -> bool:
+def contains(var_data: VarData, 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:
+def remove(var_data: VarData, 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()
@@ -81,7 +81,7 @@ def remove(var_data: _GeneralVarData, vars_data: ListVars) -> ListVars:
     return vars_data
 
 
-def index(var_data: _GeneralVarData, vars_data: ListVars) -> int:
+def index(var_data: VarData, vars_data: ListVars) -> int:
     # HACK: standard "index method" doesn't work.
     assert contains(var_data, vars_data), "var not in list"
     idxs = [
@@ -94,7 +94,7 @@ T = TypeVar("T")
 
 
 def extract(model: ConcreteModel, type_: type[T]) -> list[T]:
-    if type_ == _GeneralVarData:
+    if type_ == VarData:
         type_ = Var
 
     elif type_ == _GeneralConstraintData:
@@ -267,15 +267,13 @@ def pyomo2qmod(
     )
 
 
-def pyomo_to_qmod_qstruct(
-    struct_name: str, vars: list[_GeneralVarData]
-) -> type[QStruct]:
+def pyomo_to_qmod_qstruct(struct_name: str, vars: list[VarData]) -> 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]]:
+def _get_qstruct_fields(vars: list[VarData]) -> dict[str, type[QVar]]:
     array_type_sizes = _get_array_sizes(vars)
     fields: dict[str, type[QVar]] = {}
     for var in vars:
@@ -283,7 +281,7 @@ def _get_qstruct_fields(vars: list[_GeneralVarData]) -> dict[str, type[QVar]]:
     return fields
 
 
-def _get_array_sizes(vars: list[_GeneralVarData]) -> dict[str, tuple[int, ...]]:
+def _get_array_sizes(vars: list[VarData]) -> dict[str, tuple[int, ...]]:
     array_types: dict[str, set[tuple]] = defaultdict(set)
     for var in vars:
         if is_index_var(var):
@@ -293,11 +291,13 @@ def _get_array_sizes(vars: list[_GeneralVarData]) -> dict[str, tuple[int, ...]]:
     return {
         name: dimensions
         for name, indices in array_types.items()
-        if (dimensions := _get_indices_dimensions(indices)) is not None
+        if (dimensions := _get_indices_dimensions(indices, strict=False)) is not None
     }
 
 
-def _get_indices_dimensions(indices: set[tuple[int, ...]]) -> Optional[tuple[int, ...]]:
+def _get_indices_dimensions(
+    indices: set[tuple[int, ...]], *, strict: bool
+) -> Optional[tuple[int, ...]]:
     indices_list = list(indices)
     if len(indices) == 0:
         return None
@@ -313,16 +313,16 @@ def _get_indices_dimensions(indices: set[tuple[int, ...]]) -> Optional[tuple[int
                 min(dimension_bounds[dim_idx][0], idx),
                 max(dimension_bounds[dim_idx][1], idx),
             )
-    if any(lb != 0 for lb, ub in dimension_bounds):
+    if strict and 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):
+    if strict and reduce(mul, dimensions) != len(indices_list):
         return None
     return dimensions
 
 
 def _add_qmod_field(
-    var: _GeneralVarData,
+    var: VarData,
     array_type_sizes: dict[str, tuple[int, ...]],
     fields: dict[str, type[QVar]],
 ) -> None:
@@ -331,15 +331,16 @@ def _add_qmod_field(
         var_name = get_field_name(var)
         fields[var_name] = _get_qmod_field_type(var_name, var)
         return
+    if parent_name in fields:
+        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
+    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]:
+def _get_qmod_field_type(var_name: str, var_data: VarData) -> 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"
@@ -396,11 +397,11 @@ def _get_item(obj: Any, multi_index: tuple[int, ...]) -> Any:
     return obj
 
 
-def get_field_name(var: _GeneralVarData) -> str:
+def get_field_name(var: VarData) -> str:
     return var.local_name.replace("[", "_").replace("]", "").replace(",", "_")
 
 
-def is_index_var(var: _GeneralVarData) -> bool:
+def is_index_var(var: VarData) -> bool:
     index = var.index()
     return isinstance(index, int) or (
         isinstance(index, tuple) and all(isinstance(idx, int) for idx in index)
@@ -415,7 +416,7 @@ def index_as_tuple(index: Union[int, tuple[int, ...]]) -> tuple[int, ...]:
 
 @contextmanager
 def add_var_domain_constraints(model: ConcreteModel) -> Iterator[None]:
-    vars = extract(model, _GeneralVarData)
+    vars = extract(model, VarData)
     constraints = [
         constraint
         for var in vars
@@ -431,7 +432,7 @@ def add_var_domain_constraints(model: ConcreteModel) -> Iterator[None]:
     model.del_component("var_domain_constraints")
 
 
-def _get_var_domain_constraint(var: _GeneralVarData) -> Optional[ExpressionBase]:
+def _get_var_domain_constraint(var: VarData) -> Optional[ExpressionBase]:
     bounds = var.bounds
     if (
         type(bounds) is not tuple

classiq/applications/combinatorial_helpers/sympy_utils.py

@@ -1,12 +1,12 @@
 from typing import Optional
 
 import pyomo.core as pyo
-from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.var import VarData
 from pyomo.core.expr.sympy_tools import Pyomo2SympyVisitor, PyomoSympyBimap
 from sympy import Expr
 
 
-def sympyify_vars(variables: list[_GeneralVarData]) -> PyomoSympyBimap:
+def sympyify_vars(variables: list[VarData]) -> PyomoSympyBimap:
     symbols_map = PyomoSympyBimap()
     for var in variables:
         Pyomo2SympyVisitor(symbols_map).walk_expression(var)

classiq/applications/combinatorial_helpers/transformations/encoding.py

@@ -3,7 +3,7 @@ from itertools import chain, product
 from typing import Callable, Union
 
 import pyomo.environ as pyo
-from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.var import VarData
 from pyomo.core.expr.numeric_expr import ExpressionBase
 from pyomo.core.expr.relational_expr import EqualityExpression
 
@@ -25,9 +25,7 @@ def _make_invalid_encoding_type_error(
     )
 
 
-def encoding_length(
-    var: _GeneralVarData, encoding_type: Union[EncodingType, None]
-) -> int:
+def encoding_length(var: VarData, encoding_type: Union[EncodingType, None]) -> int:
     if encoding_type is None:
         return 1
 
@@ -99,7 +97,7 @@ class ModelEncoder:
         return vars_encoding_mapping
 
     def _get_encoding_expr(
-        self, var_data: _GeneralVarData, encoding_vars: list[_GeneralVarData]
+        self, var_data: VarData, encoding_vars: list[VarData]
     ) -> pyo.Expression:
         if self.encoding_type == EncodingType.BINARY:
             var_span = encoding_utils.get_var_span(var_data)
@@ -119,7 +117,7 @@ class ModelEncoder:
         return encoding_expr
 
     def _get_binary_coeffs(
-        self, encoding_vars: list[_GeneralVarData], var_span: int
+        self, encoding_vars: list[VarData], var_span: int
     ) -> list[int]:
         num_vars = len(encoding_vars)
         if self.qsolver == QSolver.QAOAMixer:

classiq/applications/combinatorial_helpers/transformations/fixed_variables.py

@@ -3,9 +3,9 @@ from typing import Union
 
 from pyomo.core import ConcreteModel, Var
 from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.base.var import VarData
 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.interface.exceptions import (
     ClassiqCombOptNoSolutionError,
@@ -81,10 +81,10 @@ def _get_fixing_constraints(model: ConcreteModel) -> list[_GeneralConstraintData
 
 def _get_var_and_value_from_fixing_constraint(
     constraint: _GeneralConstraintData,
-) -> tuple[_GeneralVarData, float]:
+) -> tuple[VarData, float]:
     var = next(identify_variables(constraint.body))
 
-    if isinstance(constraint.body, _GeneralVarData):
+    if isinstance(constraint.body, VarData):
         return var, constraint.upper.value
 
     symbols_map = sympyify_vars([var])
@@ -125,7 +125,7 @@ def add_fixed_variables_to_solution(
     return solution_with_fixed
 
 
-def _get_value_if_exists(var: _GeneralVarData) -> Union[int, _GeneralVarData]:
+def _get_value_if_exists(var: VarData) -> Union[int, VarData]:
     return var.value if var.value is not None else var
 
 

classiq/applications/combinatorial_helpers/transformations/ising_converter.py

@@ -1,6 +1,6 @@
 import pyomo
 import sympy as sp
-from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.var import VarData
 
 from classiq.interface.chemistry.operator import PauliOperator
 from classiq.interface.exceptions import ClassiqCombOptNotSupportedProblemError
@@ -18,7 +18,7 @@ PYOMO_PARSING_ERROR_MESAGE = "Parsing of this pyomo model is not supported."
 
 def convert_pyomo_to_hamiltonian(
     pyomo_expr: pyomo.core.Expression,
-    ordered_pyomo_vars: list[_GeneralVarData],
+    ordered_pyomo_vars: list[VarData],
     qregs: list[InternalQuantumReg],
 ) -> PauliOperator:
     symbols_map = sympyify_vars(ordered_pyomo_vars)

classiq/applications/combinatorial_helpers/transformations/penalty_support.py

@@ -1,7 +1,7 @@
 from pyomo.core import ConcreteModel
 from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.base.var import VarData
 from pyomo.core.expr.relational_expr import EqualityExpression
-from pyomo.repn.standard_repn import _GeneralVarData
 
 from classiq.applications.combinatorial_helpers import (
     allowed_constraints,
@@ -12,7 +12,7 @@ from classiq.applications.combinatorial_helpers.sympy_utils import sympyify_expr
 
 
 def is_model_penalty_supported(model: ConcreteModel) -> bool:
-    variables = extract(model, _GeneralVarData)
+    variables = extract(model, VarData)
     is_vars_supported = all(is_var_penalty_supported(var) for var in variables)
 
     constraints = extract(model, _GeneralConstraintData)
@@ -22,7 +22,7 @@ def is_model_penalty_supported(model: ConcreteModel) -> bool:
     return is_vars_supported and is_constraints_supported
 
 
-def is_var_penalty_supported(var: _GeneralVarData) -> bool:
+def is_var_penalty_supported(var: VarData) -> bool:
     return encoding_utils.is_var_binary(var) or encoding_utils.is_var_span_power_of_2(
         var
     )

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -143,6 +143,10 @@ class CombinatorialProblem:
         ]
         return pd.DataFrame.from_records(parsed_result)
 
+    def teardown(self) -> None:
+        if self._es is not None:
+            self._es.close()
+
 
 def execute_qaoa(
     problem_vars: type[QVar],

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -3,10 +3,14 @@ from typing import Union
 import numpy as np
 from sympy import fwht
 
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    pauli_operator_to_sparse_hamiltonian,
+)
 from classiq.qmod import (  # type:ignore[attr-defined]
     Pauli,
     PauliTerm,
 )
+from classiq.qmod.builtins.structs import SparsePauliOp
 
 ATOL = 1e-12
 PAULI_MATRICES_DICT = {
@@ -93,6 +97,18 @@ def matrix_to_hamiltonian(
     return hamiltonian
 
 
+def matrix_to_pauli_operator(
+    mat: np.ndarray, tol: float = ATOL, is_hermitian: bool = True
+) -> SparsePauliOp:
+    """
+    The decomposition per set is done by the Walsh-Hadamard transform,
+    since the transformation between {e_0,e_3} ({e_1,e_2}) to {I,Z} ({X,iY}) is the Hadamard matrix.
+    """
+    return pauli_operator_to_sparse_hamiltonian(
+        matrix_to_hamiltonian(mat, tol=tol, is_hermitian=is_hermitian)
+    )
+
+
 # convert a single puali string of length N to 2**N X 2**N matrix
 def pauli_string_to_mat(seq: list[Pauli]) -> np.ndarray:
     real_matrix = PAULI_MATRICES_DICT[seq[0]]
@@ -101,8 +117,24 @@ def pauli_string_to_mat(seq: list[Pauli]) -> np.ndarray:
     return real_matrix
 
 
+def _sparse_pauli_to_list(operator: SparsePauliOp) -> list[PauliTerm]:
+    terms_list = []
+    for term in operator.terms:
+        pauli_list = [Pauli.I for i in range(operator.num_qubits)]
+        for p in term.paulis:  # type:ignore[attr-defined]
+            pauli_list[p.index] = p.pauli
+        terms_list.append(
+            PauliTerm(coefficient=term.coefficient, pauli=list(reversed(pauli_list)))
+        )
+    return terms_list
+
+
 # return matrix from hamiltonian
-def hamiltonian_to_matrix(hamiltonian: list[PauliTerm]) -> np.ndarray:
+def hamiltonian_to_matrix(
+    hamiltonian: Union[list[PauliTerm], SparsePauliOp],
+) -> np.ndarray:
+    if isinstance(hamiltonian, SparsePauliOp):
+        hamiltonian = _sparse_pauli_to_list(hamiltonian)
     matrix = np.zeros(
         [2 ** len(hamiltonian[0].pauli), 2 ** len(hamiltonian[0].pauli)],
         dtype=np.complex_,