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

classiq/analyzer/analyzer.py

@@ -10,16 +10,13 @@ import plotly.graph_objects as go
 
 from classiq.interface.analyzer import analysis_params
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
-from classiq.interface.generator import generated_circuit as generator_result
+from classiq.interface.generator import quantum_program as generator_result
 
-from classiq._internals import client
+from classiq._internals import async_utils, client
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import Asyncify
 from classiq.analyzer.analyzer_utilities import (
     AnalyzerUtilities,
     DeviceName,
-    HardwareGraphs,
-    ProviderAvailableDevices,
     ProviderNameEnum,
 )
 from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
@@ -34,10 +31,10 @@ if find_ipywidgets is not None:
     from classiq._analyzer_extras.interactive_hardware import InteractiveHardware
 
 
-class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
+class Analyzer(AnalyzerUtilities):
     """Analyzer is the wrapper object for all analysis capabilities."""
 
-    def __init__(self, circuit: generator_result.GeneratedCircuit) -> None:
+    def __init__(self, circuit: generator_result.QuantumProgram) -> None:
         """Init self.
 
         Args:
@@ -47,26 +44,31 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             raise ClassiqAnalyzerError(
                 "Analysis requires a circuit with valid QASM code"
             )
-        self._params: analysis_params.AnalysisParams = analysis_params.AnalysisParams(
+        params: analysis_params.AnalysisParams = analysis_params.AnalysisParams(
             qasm=circuit.qasm
         )
-        self.circuit: generator_result.GeneratedCircuit = circuit
+        super().__init__(
+            params=params,
+            circuit=circuit,
+            available_devices=dict(),
+            hardware_graphs=dict(),
+        )
+
         self.hardware_comparison_table: Optional[go.Figure] = None
-        self.available_devices: ProviderAvailableDevices = dict()
-        self.hardware_graphs: HardwareGraphs = dict()
 
         self.transpilation_params = analysis_params.AnalysisHardwareTranspilationParams(
             hardware_data=self.circuit.hardware_data,
-            model_preferences=self.circuit.model.preferences,
+            random_seed=self.circuit.model.execution_preferences.random_seed,
+            transpilation_option=self.circuit.model.execution_preferences.transpile_to_hardware,
         )
 
-    async def analyzer_app_async(self) -> None:
+    def analyzer_app(self) -> None:
         """Opens the analyzer app with synthesis interactive results.
 
         Returns:
             None.
         """
-        result = await ApiWrapper.call_analyzer_app(self.circuit)
+        result = async_utils.run(ApiWrapper.call_analyzer_app(self.circuit))
         webbrowser.open_new_tab(
             urljoin(
                 client_ide_base_url(),
@@ -76,10 +78,12 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             )
         )
 
-    async def get_available_devices_async(
+    def get_available_devices(
         self, providers: Optional[List[ProviderNameEnum]] = None
     ) -> Dict[ProviderNameEnum, List[DeviceName]]:
-        """Returns dict of the available devices by the providers. only devices
+        """Deprecated. Use get_all_hardware_devices instead.
+
+        Returns dict of the available devices by the providers. only devices
         with sufficient number of qubits are returns
 
         Args: providers (): List of providers (string or `AnalyzerProviderVendor`).
@@ -90,13 +94,13 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
         """
         if providers is None:
             providers = list(AnalyzerProviderVendor)
-        await self.request_available_devices_async(providers=providers)
+        async_utils.run(self._request_available_devices_async(providers=providers))
         return {
             provider: self._filter_devices_by_qubits_count(provider)
             for provider in providers
         }
 
-    async def plot_hardware_connectivity_async(
+    def plot_hardware_connectivity(
         self,
         provider: Optional[ProviderNameEnum] = None,
         device: Optional[DeviceName] = None,
@@ -118,7 +122,7 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             available_devices=self.available_devices,
             hardware_graphs=self.hardware_graphs,
         )
-        await interactive_hardware.enable_interactivity_async()
+        async_utils.run(interactive_hardware.enable_interactivity_async())
         if provider is not None:
             interactive_hardware.providers_combobox.value = provider
             if device is not None:
@@ -126,7 +130,7 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
 
         return interactive_hardware.show_interactive_graph()
 
-    async def get_hardware_comparison_table_async(
+    def get_hardware_comparison_table(
         self,
         providers: Optional[Sequence[Union[str, AnalyzerProviderVendor]]] = None,
         devices: Optional[List[str]] = None,
@@ -148,10 +152,10 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             devices=devices,
             transpilation_params=self.transpilation_params,
         )
-        result = await ApiWrapper.call_table_graphs_task(params=params)
+        result = async_utils.run(ApiWrapper.call_table_graphs_task(params=params))
         self.hardware_comparison_table = go.Figure(json.loads(result.details))
 
-    async def plot_hardware_comparison_table_async(
+    def plot_hardware_comparison_table(
         self,
         providers: Optional[List[Union[str, AnalyzerProviderVendor]]] = None,
         devices: Optional[List[str]] = None,
@@ -162,12 +166,10 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
         Returns:
             None.
         """
-        await self._hardware_comparison_condition_async(
-            providers=providers, devices=devices
-        )
+        self._hardware_comparison_condition(providers=providers, devices=devices)
         self.hardware_comparison_table.show()  # type: ignore[union-attr]
 
-    async def _hardware_comparison_condition_async(
+    def _hardware_comparison_condition(
         self,
         providers: Optional[Sequence[Union[str, AnalyzerProviderVendor]]] = None,
         devices: Optional[List[str]] = None,
@@ -177,9 +179,7 @@ class Analyzer(AnalyzerUtilities, metaclass=Asyncify):
             or devices is not None
             or self.hardware_comparison_table is None
         ):
-            await self.get_hardware_comparison_table_async(
-                providers=providers, devices=devices
-            )
+            self.get_hardware_comparison_table(providers=providers, devices=devices)
 
     @staticmethod
     def _open_route(path: str) -> None:

classiq/analyzer/analyzer_utilities.py

@@ -2,7 +2,7 @@ from typing import Dict, List, Union
 
 from classiq.interface.analyzer import analysis_params
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq.exceptions import ClassiqAnalyzerError
@@ -22,16 +22,16 @@ class AnalyzerUtilities:
     def __init__(
         self,
         params: analysis_params.AnalysisParams,
-        circuit: GeneratedCircuit,
+        circuit: QuantumProgram,
         available_devices: ProviderAvailableDevices,
         hardware_graphs: HardwareGraphs,
     ) -> None:
         self._params: analysis_params.AnalysisParams = params
-        self.circuit: GeneratedCircuit = circuit
+        self.circuit: QuantumProgram = circuit
         self.available_devices = available_devices
         self.hardware_graphs = hardware_graphs
 
-    async def request_available_devices_async(
+    async def _request_available_devices_async(
         self, providers: List[ProviderNameEnum]
     ) -> None:
         requested_providers = self._requested_providers_filter(providers)
@@ -58,7 +58,7 @@ class AnalyzerUtilities:
     async def _device_validation_async(
         self, provider: ProviderNameEnum, device: DeviceName
     ) -> None:
-        await self.request_available_devices_async(providers=[provider])
+        await self._request_available_devices_async(providers=[provider])
         provider_lower_name = _to_lower_case(provider)
         available_device_dict = self.available_devices
         if available_device_dict[provider_lower_name].get(device) is False:

classiq/analyzer/rb.py

@@ -10,12 +10,11 @@ from classiq.interface.analyzer.analysis_params import AnalysisRBParams
 from classiq.interface.analyzer.result import RbResults
 
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import Asyncify
 from classiq.exceptions import ClassiqAnalyzerError
 from classiq.executor import BackendPreferencesAndResult
 
 
-class RBAnalysis(metaclass=Asyncify):
+class RBAnalysis:
     def __init__(self, experiments_data: List[AnalysisRBParams]) -> None:
         """Init self.
 
@@ -67,9 +66,9 @@ class RBAnalysis(metaclass=Asyncify):
         df = self._total_results.loc[["mean_fidelity", "average_error"]].transpose()
         hardware = list(df.index)
         params = list(df.columns)
-        data = []
-        for param in params:
-            data.append(go.Bar(name=param, x=hardware, y=df[param].values * 100))
+        data = [
+            go.Bar(name=param, x=hardware, y=df[param].values * 100) for param in params
+        ]
         fig = go.Figure(data).update_layout(
             title="RB hardware comparison",
             barmode="group",

classiq/analyzer/show_interactive_hack.py

@@ -1,26 +1,26 @@
 import webbrowser
 from urllib.parse import urljoin
 
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
 
 
-async def handle_remote_app(circuit: GeneratedCircuit) -> None:
+async def handle_remote_app(circuit: QuantumProgram) -> None:
     circuit_dataid = await ApiWrapper.call_analyzer_app(circuit)
     app_url = urljoin(
         client_ide_base_url(),
         circuit_page_uri(circuit_id=circuit_dataid.id, circuit_version=circuit.version),
     )
-    print(f"Opening: {app_url}")
+    print(f"Opening: {app_url}")  # noqa: T201
     webbrowser.open_new_tab(app_url)
 
 
-async def _show_interactive(self: GeneratedCircuit) -> None:
+async def _show_interactive(self: QuantumProgram) -> None:
     await handle_remote_app(circuit=self)
 
 
-GeneratedCircuit.show = syncify_function(_show_interactive)  # type: ignore[attr-defined]
-GeneratedCircuit.show_async = _show_interactive  # type: ignore[attr-defined]
+QuantumProgram.show = syncify_function(_show_interactive)  # type: ignore[attr-defined]
+QuantumProgram.show_async = _show_interactive  # type: ignore[attr-defined]

classiq/applications/__init__.py

@@ -1,15 +1,8 @@
 from typing import List
 
-from classiq.applications import (
-    benchmarking,
-    chemistry,
-    combinatorial_optimization,
-    finance,
-    qsvm,
-)
+from classiq.applications import chemistry, combinatorial_optimization, finance, qsvm
 
 __all__ = [
-    "benchmarking",
     "combinatorial_optimization",
     "chemistry",
     "finance",

classiq/applications/chemistry/__init__.py

@@ -15,6 +15,10 @@ from classiq.interface.chemistry.operator import PauliOperator, PauliOperators
 from . import ground_state_problem
 from .ansatz_parameters import HEAParameters, HVAParameters, UCCParameters
 from .chemistry_execution_parameters import ChemistryExecutionParameters
+from .chemistry_model_constructor import (
+    construct_chemistry_model,
+    molecule_problem_to_qmod,
+)
 
 __all__ = [
     "Molecule",
@@ -29,6 +33,8 @@ __all__ = [
     "HVAParameters",
     "HEAParameters",
     "ChemistryExecutionParameters",
+    "construct_chemistry_model",
+    "molecule_problem_to_qmod",
 ]
 
 

classiq/{applications_model_constructors → applications/chemistry}/chemistry_model_constructor.py

@@ -30,10 +30,8 @@ from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
-    QuantumLambdaFunction,
-)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 
 from classiq.applications.chemistry.ansatz_parameters import (
     AnsatzParameters,
@@ -219,7 +217,7 @@ def _atoms_to_qmod_atoms(atoms: List[Atom]) -> str:
     return ",".join(atom_struct_literals)
 
 
-def _molecule_problem_to_qmod_molecule_problem(
+def molecule_problem_to_qmod(
     molecule_problem: MoleculeProblem,
 ) -> str:
     # fmt: off
@@ -288,7 +286,7 @@ def _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(
 
 def _convert_library_problem_to_qmod_problem(problem: CHEMISTRY_PROBLEMS_TYPE) -> str:
     if isinstance(problem, MoleculeProblem):
-        return _molecule_problem_to_qmod_molecule_problem(problem)
+        return molecule_problem_to_qmod(problem)
     elif isinstance(problem, HamiltonianProblem):
         return _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(problem)
     else:
@@ -305,10 +303,10 @@ def _get_chemistry_function(
     return QuantumFunctionCall(
         function=f"{problem_prefix}_{chemistry_function_name}",
         params={
-            **(ansatz_parameters_expressions or dict()),
             f"{problem_prefix}_problem": Expression(
                 expr=_convert_library_problem_to_qmod_problem(chemistry_problem)
             ),
+            **(ansatz_parameters_expressions or dict()),
         },
         inouts=inouts,
     )
@@ -332,11 +330,11 @@ def _get_hea_function(hea_parameters: HEAParameters) -> QuantumFunctionCall:
             "is_parametrized": Expression(
                 expr=f"{[int(_is_parametric_gate(_HAE_GATE_MAPPING[gate])) for gate in hea_parameters.one_qubit_gates+hea_parameters.two_qubit_gates]}"
             ),
+            "angle_params": Expression(expr="t"),
             "connectivity_map": Expression(
                 expr=f"{[list(connectivity_pair) for connectivity_pair in hea_parameters.connectivity_map]}"
             ),
             "reps": Expression(expr=f"{hea_parameters.reps}"),
-            "angle_params": Expression(expr="t"),
         },
         operands={
             "operands_1qubit": [
@@ -387,17 +385,11 @@ def _get_molecule_problem_execution_post_processing(
     molecule_problem: MoleculeProblem,
 ) -> str:
     return f"""
-{_MOLECULE_PROBLEM_RESULT} = molecule_ground_state_solution_post_process({_molecule_problem_to_qmod_molecule_problem(molecule_problem)},{_EXECUTION_RESULT})
+{_MOLECULE_PROBLEM_RESULT} = molecule_ground_state_solution_post_process({molecule_problem_to_qmod(molecule_problem)},{_EXECUTION_RESULT})
 save({{{_MOLECULE_PROBLEM_RESULT!r}: {_MOLECULE_PROBLEM_RESULT}}})
 """
 
 
-def _get_fock_hamiltonian_problem_execution_post_processing(
-    hamiltonian_problem: HamiltonianProblem,
-) -> str:
-    return f"save({{{_EXECUTION_RESULT!r}: {_EXECUTION_RESULT}}})"
-
-
 def _is_parametric_gate(call: QuantumFunctionCall) -> bool:
     return len(call.params) > 0
 
@@ -408,7 +400,7 @@ def _get_execution_result_post_processing_statements(
     if isinstance(problem, MoleculeProblem):
         return _get_molecule_problem_execution_post_processing(problem)
     elif isinstance(problem, HamiltonianProblem):
-        return _get_fock_hamiltonian_problem_execution_post_processing(problem)
+        return ""
     else:
         raise ClassiqError(f"Invalid problem type: {problem}")
 
@@ -488,6 +480,7 @@ def _get_chemistry_classical_code(
 {_EXECUTION_RESULT} = vqe(
     hamiltonian={_get_problem_to_hamiltonian_name(chemistry_problem)}({qmod_problem}), {_get_chemistry_vqe_additional_params(execution_parameters)}
 )
+save({{{_EXECUTION_RESULT!r}: {_EXECUTION_RESULT}}})
 """ + _get_execution_result_post_processing_statements(
         chemistry_problem
     )

classiq/applications/combinatorial_helpers/allowed_constraints.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from sympy import Add, Expr, LessThan, Symbol
+
+from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
+
+_INEQUALITY_UPPER_LIMIT = 1
+
+
+def is_constraint_sum_less_than_one(
+    expression: Expr, encoding_type: Optional[EncodingType] = None
+) -> bool:
+    # tests the case: x_1 + ... + x_n <= 1
+    return (
+        isinstance(expression, LessThan)
+        and isinstance(expression.args[0], Add)
+        and all(isinstance(arg, Symbol) for arg in expression.args[0].args)
+        and expression.args[1] == _INEQUALITY_UPPER_LIMIT
+        and encoding_type is None
+    )

classiq/applications/combinatorial_helpers/arithmetic/arithmetic_expression.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+import sympy
+from pyomo.core.expr.sympy_tools import PyomoSympyBimap
+from scipy.optimize import differential_evolution
+from sympy import Expr
+
+from classiq.applications.combinatorial_helpers import encoding_utils
+
+
+def sympy_lambdify(*args: Any, **kwargs: Any) -> Any:
+    new_kwargs = kwargs
+    new_kwargs["modules"] = ["sympy"]
+    return sympy.lambdify(*args, **new_kwargs)
+
+
+def multivariate_extremum(
+    expr: Expr, symbols_map: PyomoSympyBimap, is_min: bool
+) -> float:
+    if expr.is_number:
+        return float(expr)
+
+    free_symbols = tuple(expr.free_symbols)
+    bounds = [
+        (0, encoding_utils.get_var_span(symbols_map.sympy2pyomo[sym]))
+        for sym in free_symbols
+    ]
+
+    # differential_evolution finds the global minimum, where we looking for the minimum or the maximum
+    extremum_type_coeff = 1 if is_min else -1
+
+    # Should be used only with sanitized imports due to use could be a potential risk to exec function https://docs.sympy.org/latest/modules/utilities/lambdify.html
+    func = sympy_lambdify([free_symbols], expr=extremum_type_coeff * expr)
+    result = differential_evolution(func, bounds)
+    return result.fun * extremum_type_coeff

classiq/applications/combinatorial_helpers/arithmetic/isolation.py

@@ -0,0 +1,42 @@
+from sympy import Eq, Expr, GreaterThan, LessThan, Rational, Symbol, solve
+from sympy.core.relational import Relational
+
+from classiq.exceptions import ClassiqCombOptNoSolutionError
+
+
+def isolate(expression: Expr, var: Symbol) -> Expr:
+    isolated_exp = solve(expression, var)
+    # This converts Rationals to Floats which is needed since we don't support division in arithmetic
+    if isinstance(isolated_exp, Relational) and _has_rational_atom(isolated_exp):
+        isolated_exp = isolated_exp.evalf()
+
+    if isinstance(expression, Eq):
+        if len(isolated_exp) == 1:
+            isolated_exp = type(expression)(var, isolated_exp[0])
+        elif len(isolated_exp) > 1:
+            # sympy didn't manage to isolate an expression
+            isolated_exp = expression
+        else:
+            raise ClassiqCombOptNoSolutionError
+
+    else:
+        if _is_symbol_in_right_hand_side(isolated_exp):
+            isolated_exp = _reverse_ineq_exp(isolated_exp)
+
+    return isolated_exp
+
+
+def _has_rational_atom(expression: Relational) -> bool:
+    return any(type(atom) is Rational for atom in expression.atoms())
+
+
+def _is_symbol_in_right_hand_side(expression: Expr) -> bool:
+    return isinstance(expression.args[1], Symbol) and not isinstance(
+        expression.args[0], Symbol
+    )
+
+
+def _reverse_ineq_exp(expression: Expr) -> Expr:
+    original_relation = type(expression)
+    reverse_relation = LessThan if original_relation is GreaterThan else GreaterThan
+    return reverse_relation(expression.args[1], expression.args[0])

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -0,0 +1,150 @@
+import itertools
+from typing import List, Union, cast
+
+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.executor.vqe_result import VQESolverResult
+from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
+
+from classiq.applications.combinatorial_helpers.optimization_model import (
+    OptimizationModel,
+)
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_sparsing import (
+    SparsePauliOp,
+)
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    PauliTerm,
+    get_pauli_operator,
+    pauli_operator_to_hamiltonian,
+    pauli_string_to_int,
+)
+from classiq.applications.combinatorial_helpers.pyomo_utils import (
+    convert_pyomo_to_global_presentation,
+)
+
+
+def compute_qaoa_initial_point(
+    hamiltonian: List[QmodPyStruct],
+    repetitions: int,
+) -> 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_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
+
+    beta_params: np.ndarray = np.linspace(1, 0, repetitions) * time_step
+    gamma_params: np.ndarray = np.linspace(0, 1, repetitions) * time_step
+    return list(itertools.chain(*zip(gamma_params, beta_params)))
+
+
+def _internal_pyo_model_to_hamiltonian(
+    pyo_model: pyo.ConcreteModel, penalty_energy: float
+) -> List[QmodPyStruct]:
+    pauli_list = OptimizationModel(
+        pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
+    ).ising.pauli_list
+    return pauli_operator_to_hamiltonian(pauli_list)
+
+
+def pyo_model_to_hamiltonian(
+    pyo_model: pyo.ConcreteModel, penalty_energy: float
+) -> List[PauliTerm]:
+    hamiltonian = _internal_pyo_model_to_hamiltonian(pyo_model, penalty_energy)
+    pauli_operator = get_pauli_operator(hamiltonian).pauli_list
+    pauli_terms = []
+    for item in pauli_operator:
+        term = PauliTerm()
+        term.pauli, term.coefficient = (
+            pauli_string_to_int(item[0]),
+            cast(complex, item[1]).real,
+        )
+        pauli_terms.append(term)
+
+    return pauli_terms
+
+
+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]:
+    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:
+    if isinstance(state, list):
+        state = "".join([str(x) for x in state])
+
+    cost = 0.0
+    for pauli, coeff in zip(operator.paulis, operator.coeffs):
+        expectation = 1
+        for qubit, pauli_char in enumerate(pauli):
+            if pauli_char != "I" and state[qubit] == "1" and pauli_char in ["Z", "Y"]:
+                expectation *= -1
+        cost += expectation * coeff.real
+
+    return cost
+
+
+def _eigenstate_to_solution(
+    optimization_model: OptimizationModel,
+    eigenvector: str,
+    probability: float,
+    num_shots: int,
+) -> QmodPyStruct:
+    pauli = optimization_model.get_operator().pauli_list
+
+    paulis = [item[0] for item in pauli]
+    coeffs = [item[1] for item in pauli]
+
+    operator = SparsePauliOp(paulis, coeffs)
+    cost = _evaluate_operator(operator, eigenvector)
+
+    if is_maximization(optimization_model._model_original):
+        cost *= -1
+
+    return {
+        "probability": probability,
+        "cost": cost,
+        "solution": _decode_vector_str(optimization_model, eigenvector),
+        "count": round(probability * num_shots),
+    }
+
+
+def _get_combi_solution_histogram(
+    optimization_model: OptimizationModel,
+    vqe_result: VQESolverResult,
+) -> 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"
+        )
+    return [
+        _eigenstate_to_solution(
+            optimization_model, eigenvector, probability, vqe_result.num_shots
+        )
+        for eigenvector, probability in vqe_result.reduced_probabilities.items()
+    ]
+
+
+def get_optimization_solution_from_pyo(
+    pyo_model: pyo.ConcreteModel,
+    vqe_result: VQESolverResult,
+    penalty_energy: float,
+) -> 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
+    )
+    histogram = _get_combi_solution_histogram(optimization_model, vqe_result)
+    histogram.sort(key=lambda x: x["probability"], reverse=True)
+    return histogram