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

classiq/{applications_model_constructors → applications}/combinatorial_helpers/arithmetic/isolation.py

@@ -1,7 +1,7 @@
 from sympy import Eq, Expr, GreaterThan, LessThan, Rational, Symbol, solve
 from sympy.core.relational import Relational
 
-from classiq.exceptions import ClassiqCombOptNoSolutionError
+from classiq.interface.exceptions import ClassiqCombOptNoSolutionError
 
 
 def isolate(expression: Expr, var: Symbol) -> Expr:

classiq/{applications_model_constructors → applications}/combinatorial_helpers/combinatorial_problem_utils.py

@@ -1,35 +1,42 @@
 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
 
 from classiq.interface.combinatorial_optimization.sense import is_maximization
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 
-from classiq.applications_model_constructors.combinatorial_helpers.optimization_model import (
+from classiq.applications.combinatorial_helpers.optimization_model import (
     OptimizationModel,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_sparsing import (
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_sparsing import (
     SparsePauliOp,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_utils import (
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
     pauli_operator_to_hamiltonian,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.pyomo_utils import (
+from classiq.applications.combinatorial_helpers.pyomo_utils import (
+    add_var_domain_constraints,
     convert_pyomo_to_global_presentation,
+    evaluate_objective,
+    pyomo_to_qmod_qstruct,
 )
+from classiq.qmod.builtins.structs import PauliTerm
+from classiq.qmod.qmod_variable import QStruct
 
 
 def compute_qaoa_initial_point(
-    hamiltonian: List[QmodPyStruct],
+    hamiltonian: list[PauliTerm],
     repetitions: int,
-) -> List[float]:
-    coeffs_ising = [pauli_term["coefficient"] for pauli_term in hamiltonian[1:]]
+) -> 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)
+    coeffs_abs = np.abs(coeffs_ising)  # type: ignore[arg-type]
     coeffs_largest = np.sort(coeffs_abs)[len(coeffs_ising) // 2 :]
     operator_norm = np.mean(coeffs_largest)
     time_step = 1 / (2 * operator_norm)  # adapted such that for MAXCUT time_step = 1
@@ -41,26 +48,55 @@ def compute_qaoa_initial_point(
 
 def pyo_model_to_hamiltonian(
     pyo_model: pyo.ConcreteModel, penalty_energy: float
-) -> List[QmodPyStruct]:
+) -> 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]:
+    with add_var_domain_constraints(pyo_model):
+        optimization_model = OptimizationModel(
+            pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
+        )
+        _validate_var_domains(optimization_model)
+        qmod_struct = pyomo_to_qmod_qstruct(
+            "QAOAVars", optimization_model.vars_not_encoded
+        )
+        cost_func = partial(
+            evaluate_objective, *optimization_model.objective_not_encoded_sympy
+        )
+        return qmod_struct, cost_func
+
+
+def _validate_var_domains(model: OptimizationModel) -> None:
+    for var in model.vars_not_encoded:
+        if (
+            isinstance(var.bounds, tuple)
+            and len(var.bounds) == 2
+            and var.bounds[0] != 0
+        ):
+            raise ClassiqValueError(
+                f"Bounds of variable {var.local_name} must start at 0, got {var.bounds}"
+            )
+
+
+def _str_to_list_int(str_ints: str) -> list[int]:
     return list(map(int, list(str_ints)))
 
 
 def _decode_vector_str(
     optimization_model: OptimizationModel, vector_str: str
-) -> List[int]:
+) -> 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])
 
@@ -103,7 +139,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"
@@ -120,7 +156,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_model_constructors → applications}/combinatorial_helpers/encoding_mapping.py

@@ -1,35 +1,35 @@
 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
 from pyomo.core.expr.visitor import clone_expression, identify_variables
 
 from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
+from classiq.interface.exceptions import ClassiqCombOptError
 
-from classiq.applications_model_constructors.combinatorial_helpers import pyomo_utils
-from classiq.exceptions import ClassiqCombOptError
+from classiq.applications.combinatorial_helpers import pyomo_utils
 
 
 @dataclass
 class VarExpressionMapping:
     var: _GeneralVarData
     expr: pyo.Expression
-    encodings_vars: List[_GeneralVarData] = field(default_factory=list)
+    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_model_constructors → 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
@@ -14,8 +14,9 @@ from pyomo.core.expr.numeric_expr import (
 )
 from sympy import Expr
 
-from classiq.applications_model_constructors.combinatorial_helpers import pyomo_utils
-from classiq.exceptions import ClassiqCombOptNoSolutionError
+from classiq.interface.exceptions import ClassiqCombOptNoSolutionError
+
+from classiq.applications.combinatorial_helpers import pyomo_utils
 
 _INTEGER_TYPES = [pyo.NonNegativeIntegers, pyo.Integers, pyo.PositiveIntegers]
 
@@ -38,6 +39,7 @@ def is_var_span_power_of_2(var: _GeneralVarData) -> bool:
 
 ENCODED_SUFFIX = "_encoded"
 ONE_HOT_SUFFIX = "_one_hot"
+CONSTRAINT_SUFFIX = "_constraint"
 
 
 def is_obj_encoded(var: _ComponentBase) -> bool:
@@ -69,7 +71,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)
@@ -77,7 +79,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)
@@ -106,7 +108,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_model_constructors → applications}/combinatorial_helpers/memory.py

@@ -1,15 +1,11 @@
 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,
-)
+from classiq.applications.combinatorial_helpers import encoding_utils
+from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
 
 AUXILIARY_NAME = "auxiliary"
 
@@ -23,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:
@@ -57,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_model_constructors → applications}/combinatorial_helpers/optimization_model.py

@@ -1,43 +1,46 @@
 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
 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.interface.exceptions import ClassiqCombOptError
 
-from classiq.applications_model_constructors.combinatorial_helpers import (
+from classiq.applications.combinatorial_helpers import (
     encoding_utils,
     memory,
     pyomo_utils,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.encoding_mapping import (
-    EncodingMapping,
+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,
+    index_as_tuple,
+    is_index_var,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.memory import (
-    InternalQuantumReg,
-)
-from classiq.applications_model_constructors.combinatorial_helpers.transformations import (
+from classiq.applications.combinatorial_helpers.transformations import (
     encoding,
     ising_converter,
     penalty,
     slack_variables,
 )
-from classiq.applications_model_constructors.combinatorial_helpers.transformations.fixed_variables import (
+from classiq.applications.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 (
+from classiq.applications.combinatorial_helpers.transformations.penalty_support import (
     is_model_penalty_supported,
 )
-from classiq.exceptions import ClassiqCombOptError
 
 
 class OptimizationModel:
@@ -49,22 +52,23 @@ class OptimizationModel:
         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)
+        model_copy = copy.deepcopy(model)
+        self._model_original = model
+        self._assigned_model = remove_fixed_variables(model_copy)
         self.qsolver = qsolver
         self._encoding_type = encoding_type
 
-        self.is_encoded = encoding_utils.is_model_encodable(model)
+        self.is_encoded = encoding_utils.is_model_encodable(model_copy)
         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
+                model_copy, 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
+            self._model = model_copy
             # TODO How to handle encoding_type == None
             self._vars_encoding_mapping = EncodingMapping(self._encoding_type)  # type: ignore[arg-type]
 
@@ -74,24 +78,28 @@ class OptimizationModel:
             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.is_maximization = sense.is_maximization(model_copy)
         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
@@ -103,12 +111,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
@@ -119,19 +127,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
@@ -139,11 +142,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)
 
@@ -164,3 +167,27 @@ 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)
+                if not is_index_var(pyomo_var)
+                else (
+                    get_field_name(pyomo_var.parent_component()),
+                    index_as_tuple(pyomo_var.index()),
+                )
+            )
+            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

@@ -0,0 +1,46 @@
+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
+
+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] = []
+    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 = PauliTerm(
+            [Pauli[p] for p in pauli_term[0]],  # type: ignore[arg-type]
+            pauli_term[1].real,  # type: ignore[arg-type]
+        )
+        pauli_terms.append(term)
+
+    return pauli_terms
+
+
+def pauli_enum_to_str(pauli: Pauli) -> str:
+    return {
+        Pauli.I: "Pauli.I",
+        Pauli.X: "Pauli.X",
+        Pauli.Y: "Pauli.Y",
+        Pauli.Z: "Pauli.Z",
+    }[pauli]
+
+
+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]
+        qmod_strings.append(
+            f"struct_literal(PauliTerm, pauli=[{pauli_str}], coefficient={term.coefficient})"
+        )
+
+    return ", ".join(qmod_strings)
+
+
+def _pauli_dict_to_pauli_terms(hamiltonian: list[QmodPyStruct]) -> list[PauliTerm]:
+    return [PauliTerm(**struct) for struct in hamiltonian]