classiq 0.61.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

classiq/__init__.py

@@ -46,6 +46,8 @@ from classiq.executor import (
     execute_async,
     set_quantum_program_execution_preferences,
 )
+from classiq.open_library import *  # noqa: F403
+from classiq.open_library import __all__ as _open_library_all
 from classiq.qmod import *  # noqa: F403
 from classiq.qmod import __all__ as _qmod_all
 from classiq.synthesis import (
@@ -114,6 +116,7 @@ __all__ = (
     + _sub_modules
     + _application_constructors_all
     + _qmod_all
+    + _open_library_all
 )
 
 

classiq/_internals/api_wrapper.py

@@ -33,10 +33,6 @@ from classiq._internals.client import client
 from classiq._internals.jobs import JobPoller
 
 ResultType = TypeVar("ResultType", bound=pydantic.BaseModel)
-CLASSIQ_ACCEPT_HEADER = "X-Classiq-Accept-Version"
-
-_ACCEPT_HEADER = "X-Classiq-Accept-Version"
-_CONTENT_TYPE_HEADER = "X-Classiq-Content-Type-Version"
 
 
 class HTTPMethod(StrEnum):
@@ -143,16 +139,10 @@ class ApiWrapper:
         execution_input: dict,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
-        headers = {
-            _ACCEPT_HEADER: "v1",
-            _CONTENT_TYPE_HEADER: execution_input["version"],
-        }
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
-            headers=headers,
-            url=routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
+            url=routes.EXECUTION_JOBS_FULL_PATH,
             body=execution_input,
-            use_versioned_url=False,
             http_client=http_client,
         )
         return execution_request.ExecutionJobDetails.model_validate(data)
@@ -163,12 +153,9 @@ class ApiWrapper:
         job_id: JobID,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
-        headers = {_ACCEPT_HEADER: "v1"}
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            headers=headers,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
-            use_versioned_url=False,
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
             http_client=http_client,
         )
         return execution_request.ExecutionJobDetails.model_validate(data)
@@ -177,14 +164,11 @@ class ApiWrapper:
     async def call_get_execution_job_result(
         cls,
         job_id: JobID,
-        version: str,
         http_client: Optional[httpx.AsyncClient] = None,
     ) -> classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/result",
-            use_versioned_url=False,
-            headers={CLASSIQ_ACCEPT_HEADER: version},
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}/result",
             http_client=http_client,
         )
         return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.model_validate(
@@ -200,11 +184,10 @@ class ApiWrapper:
     ) -> ExecutionJobDetailsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
             params={
                 "name": name,
             },
-            use_versioned_url=False,
             http_client=http_client,
         )
         return ExecutionJobDetailsV1.model_validate(data)
@@ -217,8 +200,7 @@ class ApiWrapper:
     ) -> None:
         await cls._call_task(
             http_method=HTTPMethod.PUT,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/cancel",
-            use_versioned_url=False,
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}/cancel",
             allow_none=True,
             http_client=http_client,
         )
@@ -232,12 +214,11 @@ class ApiWrapper:
     ) -> ExecutionJobsQueryResultsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}",
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}",
             params={
                 "offset": offset,
                 "limit": limit,
             },
-            use_versioned_url=False,
             http_client=http_client,
         )
         return ExecutionJobsQueryResultsV1.model_validate(data)
@@ -395,7 +376,6 @@ class ApiWrapper:
     ) -> operator.PauliOperator:
         poller = JobPoller(
             base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH,
-            use_versioned_url=False,
         )
         result = await poller.run_pydantic(
             problem, timeout_sec=None, http_client=http_client

classiq/_internals/client.py

@@ -9,14 +9,7 @@ import sys
 import time
 from collections.abc import Awaitable
 from types import TracebackType
-from typing import (
-    Any,
-    Callable,
-    NoReturn,
-    Optional,
-    TypeVar,
-    Union,
-)
+from typing import Any, Callable, NoReturn, Optional, TypeVar, Union
 
 import httpx
 from typing_extensions import ParamSpec
@@ -170,7 +163,6 @@ class Client:
     _UNKNOWN_VERSION = HostChecker._UNKNOWN_VERSION
     _SESSION_HEADER = "Classiq-Session"
     _WARNINGS_HEADER = "X-Classiq-Warnings"
-    _LATEST_VERSION_API_PREFIX = "/api/v1"
     _HTTP_TIMEOUT_SECONDS = 3600  # Needs to be synced with load-balancer timeout
 
     def __init__(self, conf: config.Configuration) -> None:

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -53,7 +53,7 @@ from classiq.applications.chemistry.chemistry_execution_parameters import (
 )
 from classiq.interface.exceptions import ClassiqError
 from classiq.qmod.utilities import qmod_val_to_expr_str
-from classiq.qmod.builtins.functions.hea import full_hea
+from classiq.open_library.functions.hea import full_hea
 
 _LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {
     "+": "PLUS",

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -7,6 +7,7 @@ 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
 
@@ -20,6 +21,7 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
     pauli_operator_to_hamiltonian,
 )
 from classiq.applications.combinatorial_helpers.pyomo_utils import (
+    add_var_domain_constraints,
     convert_pyomo_to_global_presentation,
     evaluate_objective,
     pyomo_to_qmod_qstruct,
@@ -56,14 +58,30 @@ def pyo_model_to_hamiltonian(
 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
+    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]:

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -23,7 +23,11 @@ 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.pyomo_utils import (
+    get_field_name,
+    index_as_tuple,
+    is_index_var,
+)
 from classiq.applications.combinatorial_helpers.transformations import (
     encoding,
     ising_converter,
@@ -176,7 +180,14 @@ class OptimizationModel:
             for key, value in penalty_map.pyomo2sympy.items():
                 objective_map.pyomo2sympy[key] = value
         sympy_mapping = {
-            sympy_var: get_field_name(pyomo_var)
+            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/pyomo_utils.py

@@ -1,6 +1,11 @@
 import math
 import re
+from collections import defaultdict
+from collections.abc import Iterator
+from contextlib import contextmanager
 from enum import Enum
+from functools import reduce
+from operator import mul
 from typing import Any, Optional, TypeVar, Union
 
 import pydantic
@@ -13,6 +18,7 @@ from pyomo.core.base.component import ComponentData
 from pyomo.core.base.constraint import _GeneralConstraintData
 from pyomo.core.base.indexed_component import IndexedComponent
 from pyomo.core.base.objective import ScalarObjective
+from pyomo.core.expr.base import ExpressionBase
 from pyomo.core.expr.sympy_tools import (
     Pyomo2SympyVisitor,
     PyomoSympyBimap,
@@ -24,7 +30,7 @@ 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
 
-from classiq.qmod.qmod_variable import QBit, QNum, QStruct, QVar
+from classiq.qmod.qmod_variable import QArray, QBit, QNum, QStruct, QVar
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 ListVars = list[_GeneralVarData]
@@ -262,14 +268,74 @@ 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()
-    }
+    qmod_struct.__annotations__ = _get_qstruct_fields(vars)
     return qmod_struct
 
 
+def _get_qstruct_fields(vars: list[_GeneralVarData]) -> dict[str, type[QVar]]:
+    array_type_sizes = _get_array_sizes(vars)
+    fields: dict[str, type[QVar]] = {}
+    for var in vars:
+        _add_qmod_field(var, array_type_sizes, fields)
+    return fields
+
+
+def _get_array_sizes(vars: list[_GeneralVarData]) -> dict[str, tuple[int, ...]]:
+    array_types: dict[str, set[tuple]] = defaultdict(set)
+    for var in vars:
+        if is_index_var(var):
+            array_types[get_field_name(var.parent_component())].add(
+                index_as_tuple(var.index())
+            )
+    return {
+        name: dimensions
+        for name, indices in array_types.items()
+        if (dimensions := _get_indices_dimensions(indices)) is not None
+    }
+
+
+def _get_indices_dimensions(indices: set[tuple[int, ...]]) -> Optional[tuple[int, ...]]:
+    indices_list = list(indices)
+    if len(indices) == 0:
+        return None
+    first_idx = indices_list[0]
+    if len(first_idx) == 0:
+        return None
+    if any(len(idx) != len(first_idx) for idx in indices_list[1:]):
+        return None
+    dimension_bounds = [(idx, idx) for idx in first_idx]
+    for multi_idx in indices_list[1:]:
+        for dim_idx, idx in enumerate(multi_idx):
+            dimension_bounds[dim_idx] = (
+                min(dimension_bounds[dim_idx][0], idx),
+                max(dimension_bounds[dim_idx][1], idx),
+            )
+    if any(lb != 0 for lb, ub in dimension_bounds):
+        return None
+    dimensions = tuple(ub + 1 for _, ub in dimension_bounds)
+    if reduce(mul, dimensions) != len(indices_list):
+        return None
+    return dimensions
+
+
+def _add_qmod_field(
+    var: _GeneralVarData,
+    array_type_sizes: dict[str, tuple[int, ...]],
+    fields: dict[str, type[QVar]],
+) -> None:
+    parent_name = get_field_name(var.parent_component())
+    if parent_name not in array_type_sizes:
+        var_name = get_field_name(var)
+        fields[var_name] = _get_qmod_field_type(var_name, var)
+        return
+    dimensions = array_type_sizes[parent_name]
+    if index_as_tuple(var.index()) == tuple(0 for _ in range(len(dimensions))):
+        qmod_type: type[QVar] = _get_qmod_field_type(parent_name, var)
+        for dim in reversed(dimensions):
+            qmod_type = QArray[qmod_type, dim]  # type:ignore[valid-type]
+        fields[parent_name] = qmod_type
+
+
 def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]:
     if var_data.domain not in SUPPORTED_TYPES:
         raise ClassiqValueError(
@@ -287,18 +353,22 @@ def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]
         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]
+    return qnum[math.ceil(math.log2(ub - lb + 1)), False, 0]
 
 
 def evaluate_objective(
-    var_mapping: dict, sympy_expr: sympy.Expr, struct_obj: Any
+    var_mapping: dict[Any, Union[str, tuple[str, tuple[int, ...]]]],
+    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()
+        sympy_var: (
+            getattr(struct_obj, field_accessor)
+            if isinstance(field_accessor, str)
+            else _get_item(getattr(struct_obj, field_accessor[0]), field_accessor[1])
+        )
+        for sympy_var, field_accessor in var_mapping.items()
     }
 
     # classical objective evaluation
@@ -313,5 +383,65 @@ def evaluate_objective(
     return SymbolicExpr(expr=expr_str, is_quantum=True)
 
 
+def _get_item(obj: Any, multi_index: tuple[int, ...]) -> Any:
+    for idx in multi_index:
+        obj = obj[idx]
+    return obj
+
+
 def get_field_name(var: _GeneralVarData) -> str:
-    return var.local_name.replace("[", "_").replace("]", "")
+    return var.local_name.replace("[", "_").replace("]", "").replace(",", "_")
+
+
+def is_index_var(var: _GeneralVarData) -> bool:
+    index = var.index()
+    return isinstance(index, int) or (
+        isinstance(index, tuple) and all(isinstance(idx, int) for idx in index)
+    )
+
+
+def index_as_tuple(index: Union[int, tuple[int, ...]]) -> tuple[int, ...]:
+    if isinstance(index, int):
+        return (index,)
+    return index
+
+
+@contextmanager
+def add_var_domain_constraints(model: ConcreteModel) -> Iterator[None]:
+    vars = extract(model, _GeneralVarData)
+    constraints = [
+        constraint
+        for var in vars
+        if (constraint := _get_var_domain_constraint(var)) is not None
+    ]
+    if len(constraints) == 0:
+        yield
+        return
+    model.var_domain_constraints = pyo.ConstraintList()
+    for constraint in constraints:
+        model.var_domain_constraints.add(constraint)
+    yield
+    model.del_component("var_domain_constraints")
+
+
+def _get_var_domain_constraint(var: _GeneralVarData) -> Optional[ExpressionBase]:
+    bounds = var.bounds
+    if (
+        type(bounds) is not tuple
+        or len(bounds) != 2
+        or not all(isinstance(bounds[idx], int) for idx in (0, 1))
+    ):
+        raise ClassiqValueError(
+            f"Missing bounds for variable {var.local_name}. Expected both lower and "
+            f"upper bounds, got {bounds}"
+        )
+    lb, ub = bounds
+    if ub < lb:
+        raise ClassiqValueError(
+            f"Illegal bounds for variable {var.local_name}. The upper bound ({ub}) is "
+            f"lesser than the lower bound ({lb})"
+        )
+    ub_norm = ub - lb + 1
+    if ub_norm & (ub_norm - 1) == 0:
+        return None
+    return var <= ub

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -33,7 +33,7 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
     _pauli_terms_to_qmod,
 )
 from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
-from classiq.qmod.builtins.functions import qaoa_penalty
+from classiq.open_library.functions.qaoa_penalty import qaoa_penalty
 
 
 def construct_combi_opt_py_model(

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -6,20 +6,24 @@ import numpy as np
 import pandas as pd
 import pyomo.core as pyo
 import scipy
+from tqdm import tqdm
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.result import ExecutionDetails
 from classiq.interface.model.model import SerializedModel
 
+from classiq import Constraints, Preferences
 from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
     pyo_model_to_qmod_problem,
 )
 from classiq.execution import ExecutionSession
+from classiq.open_library.functions.utility_functions import (
+    apply_to_all,
+    hadamard_transform,
+)
 from classiq.qmod.builtins.functions import (
     RX,
     allocate,
-    apply_to_all,
-    hadamard_transform,
 )
 from classiq.qmod.builtins.operations import phase, repeat
 from classiq.qmod.cparam import CReal
@@ -37,7 +41,7 @@ class CombinatorialProblem:
         num_layers: int,
         penalty_factor: int = 1,
     ):
-        self.problem_vars_, self.cost_func_ = pyo_model_to_qmod_problem(
+        self.problem_vars_, self.cost_func = pyo_model_to_qmod_problem(
             pyo_model, penalty_factor
         )
         self.num_layers_ = num_layers
@@ -45,8 +49,26 @@ class CombinatorialProblem:
         self.qprog_ = None
         self.es_ = None
         self.optimized_params_ = None
+        self.params_trace_: list[np.ndarray] = []
+        self.cost_trace_: list = []
 
-    def get_model(self) -> SerializedModel:
+    @property
+    def cost_trace(self) -> list:
+        return self.cost_trace_
+
+    @property
+    def params_trace(self) -> list[np.ndarray]:
+        return self.params_trace_
+
+    @property
+    def optimized_params(self) -> list:
+        return self.optimized_params_  # type:ignore[return-value]
+
+    def get_model(
+        self,
+        constraints: Optional[Constraints] = None,
+        preferences: Optional[Preferences] = None,
+    ) -> SerializedModel:
         @qfunc
         def main(
             params: CArray[CReal, self.num_layers_ * 2],  # type:ignore[valid-type]
@@ -58,13 +80,15 @@ class CombinatorialProblem:
                 self.num_layers_,
                 lambda i: [  # type:ignore[arg-type]
                     phase(
-                        -self.cost_func_(v), params[i]
+                        -self.cost_func(v), params[i]
                     ),  # type:ignore[func-returns-value]
                     apply_to_all(lambda q: RX(params[self.num_layers_ + i], q), v),
                 ],
             )
 
-        self.model_ = create_model(main)  # type:ignore[assignment]
+        self.model_ = create_model(
+            main, constraints=constraints, preferences=preferences
+        )  # type:ignore[assignment]
         return self.model_  # type:ignore[return-value]
 
     def get_qprog(self) -> SerializedQuantumProgram:
@@ -77,7 +101,6 @@ class CombinatorialProblem:
         self,
         execution_preferences: Optional[ExecutionPreferences] = None,
         maxiter: int = 20,
-        cost_trace: Optional[list[float]] = None,
         quantile: float = 1.0,
     ) -> list[float]:
         if self.qprog_ is None:
@@ -85,40 +108,52 @@ class CombinatorialProblem:
         self.es_ = ExecutionSession(
             self.qprog_, execution_preferences  # type:ignore[assignment,arg-type]
         )
+        self.params_trace_ = []
+        self.cost_trace_ = []
 
         def estimate_cost_wrapper(params: np.ndarray) -> float:
             cost = self.es_.estimate_cost(  # type:ignore[attr-defined]
-                lambda state: self.cost_func_(state["v"]),
+                lambda state: self.cost_func(state["v"]),
                 {"params": params.tolist()},
                 quantile=quantile,
             )
-            if cost_trace is not None:
-                cost_trace.append(cost)
+            self.cost_trace_.append(cost)
+            self.params_trace_.append(params)
             return cost
 
         initial_params = (
             np.concatenate(
                 (
-                    np.linspace(0, 1, self.num_layers_),
-                    np.linspace(1, 0, self.num_layers_),
+                    np.linspace(1 / self.num_layers_, 1, self.num_layers_),
+                    np.linspace(1, 1 / self.num_layers_, self.num_layers_),
                 )
             )
             * math.pi
         )
-        self.optimized_params_ = scipy.optimize.minimize(
-            estimate_cost_wrapper,
-            x0=initial_params,
-            method="COBYLA",
-            options={"maxiter": maxiter},
-        ).x.tolist()
+
+        with tqdm(total=maxiter, desc="Optimization Progress", leave=True) as pbar:
+
+            def _minimze_callback(xk: np.ndarray) -> None:
+                pbar.update(1)  # increment progress bar
+                self.optimized_params_ = xk.tolist()  # save recent optimized value
+
+            self.optimized_params_ = scipy.optimize.minimize(
+                estimate_cost_wrapper,
+                callback=_minimze_callback,
+                x0=initial_params,
+                method="COBYLA",
+                options={"maxiter": maxiter},
+            ).x.tolist()
+
         return self.optimized_params_  # type:ignore[return-value]
 
-    def get_results(self) -> pd.DataFrame:
-        if self.optimized_params_ is None:
-            self.optimize()
+    def sample_uniform(self) -> pd.DataFrame:
+        return self.sample([0] * self.num_layers_ * 2)
+
+    def sample(self, params: list) -> pd.DataFrame:
         assert self.es_ is not None
         res = self.es_.sample(  # type:ignore[unreachable]
-            {"params": self.optimized_params_}
+            {"params": params}
         )
         parsed_result = [
             {
@@ -128,7 +163,7 @@ class CombinatorialProblem:
                     if not re.match(".*_slack_var_.*", key)
                 },
                 "probability": sampled.shots / res.num_shots,
-                "cost": self.cost_func_(sampled.state["v"]),
+                "cost": self.cost_func(sampled.state["v"]),
             }
             for sampled in res.parsed_counts
         ]

classiq/applications/grover/grover_model_constructor.py

@@ -19,7 +19,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 
 from classiq import RegisterUserInput
-from classiq.qmod.builtins.functions.grover import grover_search, phase_oracle
+from classiq.open_library.functions.grover import grover_search, phase_oracle
 
 _OUTPUT_VARIABLE_NAME = "result"
 

classiq/applications/libraries/qmci_library.py

@@ -1,4 +1,5 @@
-from classiq.qmod.builtins.functions import Z, amplitude_estimation
+from classiq.open_library.functions.amplitude_estimation import amplitude_estimation
+from classiq.qmod.builtins.functions import Z
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable