classiq 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -1,6 +1,7 @@
 # flake8: noqa
 
-from typing import Dict, List, Mapping, Optional, Type
+from typing import Optional
+from collections.abc import Mapping
 
 from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
@@ -53,17 +54,17 @@ from classiq.applications.chemistry.chemistry_execution_parameters import (
 from classiq.interface.exceptions import ClassiqError
 from classiq.qmod.utilities import qmod_val_to_expr_str
 
-_LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: Dict[str, str] = {
+_LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {
     "+": "PLUS",
     "-": "MINUS",
 }
 
-_CHEMISTRY_PROBLEM_PREFIX_MAPPING: Dict[Type[CHEMISTRY_PROBLEMS_TYPE], str] = {
+_CHEMISTRY_PROBLEM_PREFIX_MAPPING: dict[type[CHEMISTRY_PROBLEMS_TYPE], str] = {
     MoleculeProblem: "molecule",
     HamiltonianProblem: "fock_hamiltonian",
 }
 
-_ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING: Dict[Type[AnsatzParameters], str] = {
+_ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING: dict[type[AnsatzParameters], str] = {
     UCCParameters: "ucc",
     HVAParameters: "hva",
 }
@@ -71,7 +72,7 @@ _ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING: Dict[Type[AnsatzParameters], str] = {
 _EXECUTION_RESULT = "vqe_result"
 _MOLECULE_PROBLEM_RESULT = "molecule_result"
 
-_HAE_GATE_MAPPING: Dict[str, QuantumFunctionCall] = {
+_HAE_GATE_MAPPING: dict[str, QuantumFunctionCall] = {
     "h": QuantumFunctionCall(
         function="H",
         positional_args=[HandleBinding(name="q")],
@@ -191,7 +192,7 @@ _HAE_GATE_MAPPING: Dict[str, QuantumFunctionCall] = {
 }
 
 
-def _atoms_to_qmod_atoms(atoms: List[Atom]) -> List[QmodChemistryAtom]:
+def _atoms_to_qmod_atoms(atoms: list[Atom]) -> list[QmodChemistryAtom]:
     return [
         QmodChemistryAtom(
             element=Element[atom.symbol],  # type:ignore[arg-type]
@@ -285,7 +286,7 @@ def _get_chemistry_function(
     chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
     chemistry_function_name: str,
     inouts: Mapping[IOName, HandleBinding],
-    ansatz_parameters_expressions: Optional[List[Expression]] = None,
+    ansatz_parameters_expressions: Optional[list[Expression]] = None,
 ) -> QuantumFunctionCall:
     problem_prefix = _CHEMISTRY_PROBLEM_PREFIX_MAPPING[type(chemistry_problem)]
     return QuantumFunctionCall(
@@ -400,7 +401,7 @@ def _get_execution_result_post_processing_statements(
         raise ClassiqError(f"Invalid problem type: {problem}")
 
 
-def _count_parametric_gates(gates: List[str]) -> int:
+def _count_parametric_gates(gates: list[str]) -> int:
     return sum(_is_parametric_gate(_HAE_GATE_MAPPING[gate]) for gate in gates)
 
 
@@ -415,7 +416,7 @@ def _get_hea_port_size(hea_parameters: HEAParameters) -> int:
 
 def _get_chemistry_quantum_main_params(
     ansatz_parameters: AnsatzParameters,
-) -> List[ClassicalParameterDeclaration]:
+) -> list[ClassicalParameterDeclaration]:
     if not isinstance(ansatz_parameters, HEAParameters):
         return []
     return [

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -1,5 +1,6 @@
 import itertools
-from typing import List, Union
+from functools import partial
+from typing import Callable, Union
 
 import numpy as np
 import pyomo.environ as pyo
@@ -20,14 +21,17 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
 )
 from classiq.applications.combinatorial_helpers.pyomo_utils import (
     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],
+    hamiltonian: list[PauliTerm],
     repetitions: int,
-) -> List[float]:
+) -> 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]
@@ -42,26 +46,39 @@ def compute_qaoa_initial_point(
 
 def pyo_model_to_hamiltonian(
     pyo_model: pyo.ConcreteModel, penalty_energy: float
-) -> List[PauliTerm]:
+) -> 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 _str_to_list_int(str_ints: str) -> List[int]:
+def pyo_model_to_qmod_problem(
+    pyo_model: pyo.ConcreteModel, penalty_energy: float
+) -> tuple[type[QStruct], Callable]:
+    optimization_model = OptimizationModel(
+        pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
+    )
+    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 _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]:
+) -> 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:
+def _evaluate_operator(operator: SparsePauliOp, state: Union[list[int], str]) -> float:
     if isinstance(state, list):
         state = "".join([str(x) for x in state])
 
@@ -104,7 +121,7 @@ def _eigenstate_to_solution(
 def _get_combi_solution_histogram(
     optimization_model: OptimizationModel,
     vqe_result: VQESolverResult,
-) -> List[QmodPyStruct]:
+) -> 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"
@@ -121,7 +138,7 @@ def get_optimization_solution_from_pyo(
     pyo_model: pyo.ConcreteModel,
     vqe_result: VQESolverResult,
     penalty_energy: float,
-) -> List[QmodPyStruct]:
+) -> 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

classiq/applications/combinatorial_helpers/encoding_mapping.py

@@ -1,6 +1,6 @@
 import itertools
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 import pyomo.environ as pyo
 from pyomo.core.base import _GeneralVarData
@@ -16,20 +16,20 @@ from classiq.applications.combinatorial_helpers import pyomo_utils
 class VarExpressionMapping:
     var: _GeneralVarData
     expr: pyo.Expression
-    encodings_vars: List[_GeneralVarData] = field(default_factory=list)
+    encodings_vars: list[_GeneralVarData] = field(default_factory=list)
 
 
 class EncodingMapping:
     def __init__(self, encoding_type: EncodingType) -> None:
-        self._data: List[VarExpressionMapping] = []
+        self._data: list[VarExpressionMapping] = []
         self.encoding_type = encoding_type
 
     @property
-    def original_vars(self) -> List[_GeneralVarData]:
+    def original_vars(self) -> list[_GeneralVarData]:
         return [pair.var for pair in self._data]
 
     @property
-    def encodings_vars(self) -> List[_GeneralVarData]:
+    def encodings_vars(self) -> list[_GeneralVarData]:
         return list(
             itertools.chain.from_iterable(
                 var_mapping.encodings_vars for var_mapping in self._data
@@ -37,7 +37,7 @@ class EncodingMapping:
         )
 
     @property
-    def substitution_dict(self) -> Dict[int, pyo.Expression]:
+    def substitution_dict(self) -> dict[int, pyo.Expression]:
         return {id(mapping.var): mapping.expr for mapping in self._data}
 
     def __len__(self) -> int:
@@ -47,7 +47,7 @@ class EncodingMapping:
         self,
         original_var: _GeneralVarData,
         encoding_expr: pyo.Expression,
-        encodings_vars: Union[List[_GeneralVarData], None] = None,
+        encodings_vars: Union[list[_GeneralVarData], None] = None,
     ) -> None:
         if encodings_vars is None:
             encodings_vars = list(identify_variables(encoding_expr))
@@ -59,7 +59,7 @@ class EncodingMapping:
             )
         )
 
-    def _check_unique_encoding_vars(self, variables: List[_GeneralVarData]) -> None:
+    def _check_unique_encoding_vars(self, variables: list[_GeneralVarData]) -> None:
         assert all(
             not pyomo_utils.contains(var, self.encodings_vars) for var in variables
         )
@@ -72,7 +72,7 @@ class EncodingMapping:
                 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: _GeneralVarData) -> list[_GeneralVarData]:
         return self.get_var_expr_mapping(original_var).encodings_vars
 
     def get_original_var(
@@ -83,7 +83,7 @@ class EncodingMapping:
                 return original_var
         return None
 
-    def decode(self, solution: List[int]) -> List[int]:
+    def decode(self, solution: list[int]) -> list[int]:
         idx = 0
         decoded_solution = []
         for var_mapping in self._data:

classiq/applications/combinatorial_helpers/encoding_utils.py

@@ -1,6 +1,6 @@
 import math
 from itertools import filterfalse
-from typing import Any, Dict, Union, cast
+from typing import Any, Union, cast
 
 import numpy as np
 import pyomo.environ as pyo
@@ -70,7 +70,7 @@ def recursively_remove_monomial_expr(obj: Any) -> None:
 
 
 def encode_expr(
-    expr: pyo.Expression, substitution_dict: Dict[int, pyo.Expression]
+    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)
@@ -78,7 +78,7 @@ def encode_expr(
 
 
 def encode_constraints(
-    model: pyo.ConcreteModel, substitution_dict: Dict[int, pyo.Expression]
+    model: pyo.ConcreteModel, substitution_dict: dict[int, pyo.Expression]
 ) -> None:
     all_constraints = pyomo_utils.extract(model, _GeneralConstraintData)
     constraints = filterfalse(is_obj_encoded, all_constraints)
@@ -107,7 +107,7 @@ def deal_with_trivial_boolean_constraint(
 
 
 def encode_objective(
-    model: pyo.ConcreteModel, substitution_dict: Dict[int, pyo.Expression]
+    model: pyo.ConcreteModel, substitution_dict: dict[int, pyo.Expression]
 ) -> None:
     objective = next(model.component_objects(pyo.Objective))
 

classiq/applications/combinatorial_helpers/memory.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Dict, List, Tuple
-
 from pyomo.core.base import _GeneralVarData
 
 from classiq.interface.generator.function_params import IOName
@@ -21,13 +19,13 @@ class InternalQuantumReg:
 class MemoryMapping:
     def __init__(
         self,
-        variables: List[_GeneralVarData],
+        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.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[_GeneralVarData] = variables
         self._allocate_memory()
 
     def __len__(self) -> int:
@@ -55,7 +53,7 @@ class MemoryMapping:
             )
 
     @property
-    def qregs(self) -> List[InternalQuantumReg]:
+    def qregs(self) -> list[InternalQuantumReg]:
         return list(self.substitution_dict.values())
 
     @property

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -1,11 +1,13 @@
 import copy
+from functools import cached_property
 from itertools import filterfalse
-from typing import List, Optional, Union
+from typing import 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.core.expr.sympy_tools import sympyify_expression
 from pyomo.environ import Expression
 
 from classiq.interface.chemistry.operator import PauliOperator
@@ -21,6 +23,7 @@ from classiq.applications.combinatorial_helpers import (
 )
 from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
 from classiq.applications.combinatorial_helpers.memory import InternalQuantumReg
+from classiq.applications.combinatorial_helpers.pyomo_utils import get_field_name
 from classiq.applications.combinatorial_helpers.transformations import (
     encoding,
     ising_converter,
@@ -72,23 +75,27 @@ class OptimizationModel:
         )
 
         self.is_maximization = sense.is_maximization(model_copy)
-        self.objective = next(self._model.component_objects(pyo.Objective))
-
         self.penalty_energy = penalty_energy
-        self._add_penalty_term()
 
-        self.ising: PauliOperator = self._to_ising()
+        self.objective = next(self._model.component_objects(pyo.Objective))
+        if self.qsolver == QSolver.QAOAPenalty:
+            self.objective.expr += self._get_penalty_term(self.constraints)
+            if self.is_encoded:
+                self.objective.expr = self._model_encoder.encode_expr(
+                    self.objective.expr
+                )
+        self._initialize_objective_not_encoded(model_copy)
 
     @property
-    def vars(self) -> List[_GeneralVarData]:
+    def vars(self) -> list[_GeneralVarData]:
         return pyomo_utils.extract(self._model, _GeneralVarData)
 
     @property
-    def vars_not_encoded(self) -> List[_GeneralVarData]:
+    def vars_not_encoded(self) -> list[_GeneralVarData]:
         return list(filterfalse(encoding_utils.is_obj_encoded, self.vars))
 
     @property
-    def _ising_vars(self) -> List[_GeneralVarData]:
+    def _ising_vars(self) -> list[_GeneralVarData]:
         if self.is_encoded:
             return [
                 var
@@ -100,12 +107,12 @@ class OptimizationModel:
             return self.vars
 
     @property
-    def constraints(self) -> List[_GeneralConstraintData]:
+    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]:
+    def qregs(self) -> list[InternalQuantumReg]:
         return self.memory_mapping.qregs
 
     @property
@@ -116,19 +123,14 @@ class OptimizationModel:
     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 _get_penalty_term(
+        self, constraints: list[_GeneralConstraintData]
+    ) -> Union[int, Expression]:
+        normalized_penalty_term = penalty.get_penalty_expression(constraints)
+        return self.penalty_energy * normalized_penalty_term * self.sign
 
-    def _to_ising(self) -> PauliOperator:
+    @cached_property
+    def ising(self) -> PauliOperator:
         return (
             ising_converter.convert_pyomo_to_hamiltonian(
                 self.objective.expr, self._ising_vars, self.qregs
@@ -136,11 +138,11 @@ class OptimizationModel:
             * self.sign
         )
 
-    def _remove_slack_variables_from_solution(self, solution: List[int]) -> List[int]:
+    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]:
+    def decode(self, solution: list[int]) -> list[int]:
         if self.is_encoded:
             solution = self._vars_encoding_mapping.decode(solution)
 
@@ -161,3 +163,20 @@ class OptimizationModel:
             self._model
         ):
             return slack_variables.slack_vars_convert(self._model)
+
+    def _initialize_objective_not_encoded(self, model_copy: pyo.ConcreteModel) -> None:
+        objective_not_encoded = next(model_copy.component_objects(pyo.Objective))
+        objective_map, objective_expr = sympyify_expression(objective_not_encoded)
+        objective_expr *= self.sign
+        if self.qsolver == QSolver.QAOAPenalty:
+            penalty = self._get_penalty_term(self.constraints)
+            penalty_map, penalty_expr = sympyify_expression(penalty)
+            objective_expr += penalty_expr * self.sign
+            objective_map.sympy2pyomo |= penalty_map.sympy2pyomo
+            for key, value in penalty_map.pyomo2sympy.items():
+                objective_map.pyomo2sympy[key] = value
+        sympy_mapping = {
+            sympy_var: get_field_name(pyomo_var)
+            for pyomo_var, sympy_var in objective_map.pyomo2sympy.items()
+        }
+        self.objective_not_encoded_sympy = sympy_mapping, objective_expr

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.exceptions import ClassiqNonNumericCoefficientInPauliError
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.helpers.custom_pydantic_types import PydanticPauliList
@@ -8,8 +6,8 @@ from classiq.qmod.builtins.enums import Pauli
 from classiq.qmod.builtins.structs import PauliTerm
 
 
-def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> List[PauliTerm]:
-    pauli_terms: List[PauliTerm] = []
+def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> list[PauliTerm]:
+    pauli_terms: list[PauliTerm] = []
     for pauli_term in pauli_list:
         if not isinstance(pauli_term[1], complex) or pauli_term[1].imag != 0:
             raise ClassiqNonNumericCoefficientInPauliError(
@@ -33,7 +31,7 @@ def pauli_enum_to_str(pauli: Pauli) -> str:
     }[pauli]
 
 
-def _pauli_terms_to_qmod(hamiltonian: List[PauliTerm]) -> str:
+def _pauli_terms_to_qmod(hamiltonian: list[PauliTerm]) -> str:
     qmod_strings = []
     for term in hamiltonian:
         pauli_str = ", ".join([pauli_enum_to_str(p) for p in term.pauli])  # type: ignore[attr-defined]
@@ -44,5 +42,5 @@ def _pauli_terms_to_qmod(hamiltonian: List[PauliTerm]) -> str:
     return ", ".join(qmod_strings)
 
 
-def _pauli_dict_to_pauli_terms(hamiltonian: List[QmodPyStruct]) -> List[PauliTerm]:
+def _pauli_dict_to_pauli_terms(hamiltonian: list[QmodPyStruct]) -> list[PauliTerm]:
     return [PauliTerm(**struct) for struct in hamiltonian]

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -1,6 +1,7 @@
-import json
+import math
+import re
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
+from typing import Any, Optional, TypeVar, Union
 
 import pydantic
 import pyomo.core.expr.numeric_expr as pyo_expr
@@ -20,9 +21,21 @@ from pyomo.core.expr.sympy_tools import (
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import Integer
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
-ListVars = List[_GeneralVarData]
+from classiq.qmod.qmod_variable import QBit, QNum, QStruct, QVar
+from classiq.qmod.symbolic_expr import SymbolicExpr
+
+ListVars = list[_GeneralVarData]
+SUPPORTED_TYPES = [
+    pyo.Binary,
+    pyo.Integers,
+    pyo.NegativeIntegers,
+    pyo.NonNegativeIntegers,
+    pyo.NonPositiveIntegers,
+    pyo.PositiveIntegers,
+]
 
 
 class ObjectiveType(Enum):
@@ -33,7 +46,7 @@ class ObjectiveType(Enum):
 class CombinatorialOptimizationStructDeclaration(StructDeclaration):
     variable_lower_bound: int = pydantic.Field(default=0)
     variable_upper_bound: int = pydantic.Field(default=1)
-    constraints: List[Expression] = pydantic.Field(
+    constraints: list[Expression] = pydantic.Field(
         default_factory=list, description="List of constraint expressions"
     )
     objective_type: ObjectiveType = pydantic.Field(
@@ -72,7 +85,7 @@ def index(var_data: _GeneralVarData, vars_data: ListVars) -> int:
 T = TypeVar("T")
 
 
-def extract(model: ConcreteModel, type_: Type[T]) -> List[T]:
+def extract(model: ConcreteModel, type_: type[T]) -> list[T]:
     if type_ == _GeneralVarData:
         type_ = Var
 
@@ -104,7 +117,7 @@ def delete_component(model: ConcreteModel, component: ComponentData) -> None:
             model.del_component(parent_component)
 
 
-def _delete_element_by_value(dict_: Dict, value: Any) -> None:
+def _delete_element_by_value(dict_: dict, value: Any) -> None:
     iter_dict = {**dict_}
     for k, v in iter_dict.items():
         if v is value and k in dict_:
@@ -121,7 +134,7 @@ def get_name(component: Union[IndexedComponent, ComponentData]) -> str:
 class FixedSympy2PyomoVisitor(Sympy2PyomoVisitor):
     def beforeChild(  # noqa: N802
         self, node: Optional[sympy.Expr], child: sympy.Expr, child_idx: Optional[int]
-    ) -> Tuple[bool, Union[int, float, None]]:
+    ) -> tuple[bool, Union[int, float, None]]:
         if not child._args:
             item = self.object_map.getPyomoSymbol(child, None)
             if item is None:
@@ -142,10 +155,7 @@ def sympy2pyomo_expression(
 def convert_pyomo_to_global_presentation(
     pyo_model: pyo.ConcreteModel,
 ) -> pyo.ConcreteModel:
-    pyo_model_str = pyomo2qmod("nativePyoModel", pyo_model)
-    problem_struct = CombinatorialOptimizationStructDeclaration.model_validate_json(
-        pyo_model_str
-    )
+    problem_struct = pyomo2qmod("nativePyoModel", pyo_model)
 
     pyomo_model = pyo.ConcreteModel()
 
@@ -190,10 +200,12 @@ def convert_pyomo_to_global_presentation(
     return pyomo_model
 
 
-def pyomo2qmod(struct_name: str, pyo_model: ConcreteModel) -> str:
+def pyomo2qmod(
+    struct_name: str, pyo_model: ConcreteModel
+) -> CombinatorialOptimizationStructDeclaration:
     symbols_map = PyomoSympyBimap()
 
-    variables: List[sympy.Symbol] = []
+    variables: list[sympy.Symbol] = []
 
     bounds_set = False
     lower_bound = None
@@ -218,7 +230,7 @@ def pyomo2qmod(struct_name: str, pyo_model: ConcreteModel) -> str:
                 upper_bound = var_dict[key].ub
                 bounds_set = True
 
-    constraint_exprs: List[sympy.Expr] = []
+    constraint_exprs: list[sympy.Expr] = []
 
     constraint_exprs.extend(
         Pyomo2SympyVisitor(symbols_map).walk_expression(constraint_dict[key].expr)
@@ -232,15 +244,74 @@ def pyomo2qmod(struct_name: str, pyo_model: ConcreteModel) -> str:
         pyo_objective
     )
 
-    combi_struct_decl = {
-        "name": struct_name,
-        "variables": {str(variable): {"kind": "int"} for variable in variables},
-        "variable_lower_bound": lower_bound,
-        "variable_upper_bound": upper_bound,
-        "constraints": [
-            {"expr": str(constraint_expr)} for constraint_expr in constraint_exprs
+    return CombinatorialOptimizationStructDeclaration(
+        name=struct_name,
+        variables={str(variable): Integer() for variable in variables},
+        variable_lower_bound=lower_bound,
+        variable_upper_bound=upper_bound,
+        constraints=[
+            Expression(expr=str(constraint_expr))
+            for constraint_expr in constraint_exprs
         ],
-        "objective_type": objective_type_str,
-        "objective_function": {"expr": str(objective_expr)},
+        objective_type=objective_type_str,
+        objective_function=Expression(expr=str(objective_expr)),
+    )
+
+
+def pyomo_to_qmod_qstruct(
+    struct_name: str, vars: list[_GeneralVarData]
+) -> type[QStruct]:
+    qmod_struct = type(struct_name, (QStruct,), {})
+    var_names = {get_field_name(var): var for var in vars}
+    qmod_struct.__annotations__ = {
+        var_name: _get_qmod_field_type(var_name, var_data)
+        for var_name, var_data in var_names.items()
     }
-    return json.dumps(combi_struct_decl, indent=2)
+    return qmod_struct
+
+
+def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]:
+    if var_data.domain not in SUPPORTED_TYPES:
+        raise ClassiqValueError(
+            f"Type {str(var_data.domain)!r} of variable {var_name!r} is not supported"
+        )
+
+    if var_data.domain == pyo.Binary:
+        return QBit
+
+    bounds = var_data.bounds
+    if bounds is None:
+        raise ClassiqValueError(f"Variable {var_name!r} has no bounds")
+    lb, ub = bounds
+    if not isinstance(lb, int) or not isinstance(ub, int):
+        raise ClassiqValueError(
+            f"Non-integer bounds for variable {var_name!r} are not supported"
+        )
+    if lb > 0:
+        ub -= lb
+    qnum: Any = QNum  # mypy shenanigans
+    return qnum[math.ceil(math.log2(ub - lb)), False, 0]
+
+
+def evaluate_objective(
+    var_mapping: dict, sympy_expr: sympy.Expr, struct_obj: Any
+) -> Any:
+    sympy_assignment = {
+        sympy_var: getattr(struct_obj, field_name)
+        for sympy_var, field_name in var_mapping.items()
+    }
+
+    # classical objective evaluation
+    if not isinstance(struct_obj, QStruct):
+        return float(sympy_expr.evalf(subs=sympy_assignment))
+
+    # quantum objective evaluation
+    expr_str = str(sympy_expr).replace("'", "")
+    for var_name, var_value in sympy_assignment.items():
+        var_name = str(var_name).replace("'", "")
+        expr_str = re.sub(rf"\b{var_name}\b", str(var_value), expr_str)
+    return SymbolicExpr(expr=expr_str, is_quantum=True)
+
+
+def get_field_name(var: _GeneralVarData) -> str:
+    return var.local_name.replace("[", "_").replace("]", "")

classiq/applications/combinatorial_helpers/sympy_utils.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Optional
 
 import pyomo.core as pyo
 from pyomo.core.base import _GeneralVarData
@@ -6,7 +6,7 @@ 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[_GeneralVarData]) -> PyomoSympyBimap:
     symbols_map = PyomoSympyBimap()
     for var in variables:
         Pyomo2SympyVisitor(symbols_map).walk_expression(var)