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

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/benchmarking/mirror_benchmarking.py

@@ -1,15 +1,15 @@
 from copy import deepcopy
 
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
 from classiq.interface.generator.model.preferences.preferences import (
     Preferences,
     QuantumFormat,
     TranspilationOption,
 )
+from classiq.interface.generator.quantum_program import QuantumProgram
 
-from classiq._internals.async_utils import Asyncify
+from classiq._internals import async_utils
 from classiq.model.model import Model
-from classiq.quantum_functions.decorators import quantum_function as qfunc
+from classiq.quantum_functions.decorators import quantum_function
 from classiq.quantum_functions.function_library import QASM_INTRO, FunctionLibrary
 from classiq.quantum_register import QReg, ZeroQReg
 from classiq.synthesis import synthesize_async
@@ -18,7 +18,7 @@ _MB_NAME: str = "mirror_benchmarking"
 _MB_FUNCTION_LIBRARY_NAME: str = f"{_MB_NAME}_function_library"
 
 
-class MirrorBenchmarking(metaclass=Asyncify):
+class MirrorBenchmarking:
     def __init__(self, model: Model) -> None:
         self.functional_model: Model = model
         self.functional_model._model.preferences = self.get_functional_preferences(
@@ -26,7 +26,7 @@ class MirrorBenchmarking(metaclass=Asyncify):
         )
 
     async def mirror_benchmarking_model_async(self) -> Model:
-        functional_circuit: GeneratedCircuit = GeneratedCircuit.parse_raw(
+        functional_circuit: QuantumProgram = QuantumProgram.parse_raw(
             await synthesize_async(self.functional_model.get_model())
         )
 
@@ -38,7 +38,7 @@ class MirrorBenchmarking(metaclass=Asyncify):
             )
         circuit_qasm: str = circuit_qasm_list[-1]
 
-        @qfunc
+        @quantum_function
         def functional_model_function(reg: ZeroQReg[num_qubits]) -> QReg[num_qubits]:  # type: ignore[type-arg, valid-type]
             return QASM_INTRO + circuit_qasm  # type: ignore[return-value]
 
@@ -54,6 +54,9 @@ class MirrorBenchmarking(metaclass=Asyncify):
         mb_model.functional_model_function(in_wires=inner_wires, is_inverse=True)
         return mb_model
 
+    def mirror_benchmarking_model(self) -> Model:
+        return async_utils.run(self.mirror_benchmarking_model_async())
+
     @staticmethod
     def get_functional_preferences(preferences: Preferences) -> Preferences:
         functional_preferences = deepcopy(preferences)

classiq/applications/combinatorial_optimization/__init__.py

@@ -3,6 +3,10 @@ from typing import List
 from classiq.interface.combinatorial_optimization import examples
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
 
+from classiq.applications_model_constructors.combinatorial_helpers.combinatorial_problem_utils import (
+    get_optimization_solution_from_pyo,
+)
+
 from .combinatorial_optimization_config import OptimizerConfig, QAOAConfig
 
 __all__ = [
@@ -10,6 +14,7 @@ __all__ = [
     "examples",
     "QAOAConfig",
     "OptimizerConfig",
+    "get_optimization_solution_from_pyo",
 ]
 
 

classiq/applications/qnn/circuit_utils.py

@@ -5,8 +5,8 @@ from typing import Iterable, List, Tuple, Union
 from torch import Tensor
 
 from classiq.interface.generator.circuit_code.types_and_constants import QasmVersion
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.qnn.types import Arguments, Circuit
 from classiq.exceptions import ClassiqQNNError, ClassiqValueError
@@ -95,7 +95,7 @@ def _get_extracted_parameters(obj: CircuitOrExtractedParameters) -> ParametersTu
     # This `if` is for caching
     if isinstance(obj, tuple):
         weight_params, input_params = obj
-    elif isinstance(obj, GeneratedCircuit):
+    elif isinstance(obj, QuantumProgram):
         weight_params, input_params = extract_parameters(obj)
     else:
         raise ClassiqValueError("Invalid object passed to `map_parameters`")

classiq/applications/qnn/gradients/quantum_gradient.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from torch import Tensor
 
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.qnn.circuit_utils import extract_parameters, validate_circuit
 from classiq.applications.qnn.types import ExecuteFunction, PostProcessFunction
@@ -23,7 +23,7 @@ class QuantumGradient(abc.ABC):
         self._execute = execute
         self._post_process = post_process
 
-        circuit = GeneratedCircuit.parse_raw(quantum_program)
+        circuit = QuantumProgram.parse_raw(quantum_program)
         validate_circuit(circuit)
         self._quantum_program = quantum_program
         self._parameters_names = extract_parameters(circuit)

classiq/applications/qnn/types.py

@@ -5,13 +5,13 @@ from torch import Tensor
 
 from classiq.interface.executor.execution_result import ResultsCollection, SavedResult
 
-from classiq import GeneratedCircuit
+from classiq import QuantumProgram
 from classiq.synthesis import SerializedQuantumProgram
 
 Arguments = Dict[str, float]
 MultipleArguments = Tuple[Arguments, ...]
 
-Circuit = GeneratedCircuit
+Circuit = QuantumProgram
 ExecuteFunction = Callable[
     [SerializedQuantumProgram, MultipleArguments], ResultsCollection
 ]

classiq/applications/qsvm/qsvm.py

@@ -1,15 +1,12 @@
-from typing import Any, List, Union
+from typing import List
 
-import numpy as np
-
-from classiq.interface.applications.qsvm import DataList, QSVMData, QSVMPreferences
-
-Data = Union[DataList, np.ndarray]
-Labels = Union[List[Any], np.ndarray]
+from classiq.interface.applications.qsvm import Data, Labels, QSVMData, QSVMPreferences
 
 __all__ = [
     "QSVMData",
     "QSVMPreferences",
+    "Data",
+    "Labels",
 ]
 
 

classiq/applications/qsvm/qsvm_data_generation.py

@@ -24,11 +24,8 @@ def generate_data(
 
     results = {}
     for index, s in enumerate(sources):
-        temp = []
-        # for each dimension
-        for point in s:
-            # draw from a gaussian distribution
-            temp.append(np.random.normal(point, std, amount))
+        # for each dimension draw from a gaussian distribution
+        temp = [np.random.normal(point, std, amount) for point in s]
         # combine the list of np.arrays
         results[index] = np.array(list(zip(*temp)))
 

classiq/applications_model_constructors/__init__.py

@@ -1,6 +1,9 @@
 from typing import List
 
-from .chemistry_model_constructor import construct_chemistry_model
+from .chemistry_model_constructor import (
+    construct_chemistry_model,
+    molecule_problem_to_qmod,
+)
 from .combinatorial_optimization_model_constructor import (
     construct_combinatorial_optimization_model,
 )
@@ -14,4 +17,9 @@ __all__: List[str] = [
     "construct_chemistry_model",
     "construct_finance_model",
     "construct_grover_model",
+    "molecule_problem_to_qmod",
 ]
+
+
+def __dir__():
+    return __all__

classiq/applications_model_constructors/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_model_constructors/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_model_constructors/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_model_constructors.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_model_constructors/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_model_constructors/combinatorial_helpers/combinatorial_problem_utils.py

@@ -0,0 +1,130 @@
+import itertools
+from typing import List, 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.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 (
+    OptimizationModel,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_sparsing import (
+    SparsePauliOp,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    pauli_operator_to_hamiltonian,
+)
+from classiq.applications_model_constructors.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 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 _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