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

classiq/applications/combinatorial_helpers/transformations/ising_converter.py

@@ -0,0 +1,122 @@
+from typing import List
+
+import pyomo
+import sympy as sp
+from pyomo.core.base import _GeneralVarData
+
+from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.helpers import custom_pydantic_types
+
+from classiq.applications.combinatorial_helpers import memory
+from classiq.applications.combinatorial_helpers.memory import InternalQuantumReg
+from classiq.applications.combinatorial_helpers.sympy_utils import (
+    sympyify_expression,
+    sympyify_vars,
+)
+from classiq.exceptions import ClassiqCombOptNotSupportedProblemError
+
+PYOMO_PARSING_ERROR_MESAGE = "Parsing of this pyomo model is not supported."
+
+
+def convert_pyomo_to_hamiltonian(
+    pyomo_expr: pyomo.core.Expression,
+    ordered_pyomo_vars: List[_GeneralVarData],
+    qregs: List[InternalQuantumReg],
+) -> PauliOperator:
+    symbols_map = sympyify_vars(ordered_pyomo_vars)
+    sympy_expr = sympyify_expression(pyomo_expr, symbols_map)
+    if not sympy_expr.is_polynomial():
+        raise ClassiqCombOptNotSupportedProblemError(PYOMO_PARSING_ERROR_MESAGE)
+
+    ordered_sympy_vars = [
+        symbols_map.pyomo2sympy[pyomo_var] for pyomo_var in ordered_pyomo_vars
+    ]
+    ising_expr = _to_ising_symbolic_objective_function(sympy_expr)
+    ising_expr = _refine_ising_expr(ising_expr)
+
+    operator = _convert_ising_sympy_to_operator(ising_expr, ordered_sympy_vars)
+    operator = _add_auxiliary_qubits_to_operator(operator, qregs)
+
+    return PauliOperator(pauli_list=operator)
+
+
+def _convert_ising_sympy_to_operator(
+    ising_expr: sp.Expr, ordered_sympy_vars: List[sp.Symbol]
+) -> custom_pydantic_types.PydanticPauliList:
+    pauli_op_list: custom_pydantic_types.PydanticPauliList = []
+    for expr_term in ising_expr.args:
+        expr_vars = _get_vars(expr_term)
+        z_vec = _find_sub_list_items(ordered_sympy_vars, expr_vars)
+        pauli_string_list = ["I"] * len(z_vec)
+        for index, is_z_op in enumerate(z_vec):
+            if is_z_op:
+                pauli_string_list[len(z_vec) - index - 1] = (
+                    "Z"  # reminder: Pauli reverses the order!
+                )
+        pauli_string = "".join(pauli_string_list)
+        coeff = _get_coeff_from_expr(expr_term)
+        pauli_op_list.append((pauli_string, complex(coeff)))
+    return pauli_op_list
+
+
+def _refine_ising_expr(ising_expr: sp.Expr) -> sp.Expr:
+    # The variables here are assumed to be either 1 or -1 (ising variables).
+    # Therefore x^a can replaced with 1 if a is even, and with x is a is odd.
+    # Change the expression recursively.
+    def update_expr(expr: sp.Expr) -> sp.Expr:
+        if isinstance(expr, sp.Pow):
+            if expr.args[1] % 2:  # odd power: x**a -> x
+                expr = expr.args[0]
+            else:  # even power: x**a -> 1
+                expr = sp.Float(1)
+        if hasattr(expr, "args") and expr.args:
+            new_args = [update_expr(arg) for arg in expr.args]
+            expr_class = type(expr)
+            return expr_class(*new_args)
+        else:
+            return expr
+
+    return update_expr(ising_expr)
+
+
+def _to_ising_symbolic_objective_function(objective: sp.Expr) -> sp.Expr:
+    # cost-function to Hamiltonian conversion explanation:
+    # https://qiskit.org/textbook/ch-applications/qaoa.html#1.1-Diagonal-Hamiltonians
+    subs_vars_dict = {var: (1 - var) / 2 for var in objective.free_symbols}
+    objective_ising = objective.subs(subs_vars_dict)
+    return sp.expand(objective_ising)
+
+
+def _get_vars(expr_term: sp.AtomicExpr) -> List[sp.Symbol]:
+    if isinstance(expr_term, sp.Symbol):
+        return [expr_term]
+    else:
+        return expr_term.args
+
+
+def _find_sub_list_items(
+    long_list: List[sp.Symbol], sub_list: List[sp.Symbol]
+) -> List[bool]:
+    return [x in sub_list for x in long_list]
+
+
+def _get_coeff_from_expr(expr: sp.Expr) -> float:
+    if isinstance(expr, sp.Number):
+        return float(expr)
+    if isinstance(expr, sp.Symbol):
+        return 1
+    if all(isinstance(arg, sp.Symbol) for arg in expr.args):
+        return 1
+    return float(expr.args[0])
+
+
+def _add_auxiliary_qubits_to_operator(
+    operator: custom_pydantic_types.PydanticPauliList, qregs: List[InternalQuantumReg]
+) -> custom_pydantic_types.PydanticPauliList:
+    # TODO: handle the case when the auxiliary are in the middle of the circuit
+    for qreg in qregs:
+        if qreg.name == memory.AUXILIARY_NAME:
+            operator = [
+                ("I" * qreg.size + monomial[0], monomial[1]) for monomial in operator
+            ]
+    return operator

classiq/applications/combinatorial_helpers/transformations/penalty.py

@@ -0,0 +1,32 @@
+import itertools
+from typing import List
+
+from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.expr.relational_expr import EqualityExpression
+from pyomo.environ import Expression
+
+
+def get_penalty_expression(
+    flat_constraints: List[_GeneralConstraintData],
+) -> Expression:
+    return sum(
+        _convert_constraint_to_penalty_term(constraint)
+        for constraint in flat_constraints
+    )
+
+
+def _convert_constraint_to_penalty_term(
+    constraint: _GeneralConstraintData,
+) -> Expression:
+    if isinstance(constraint.expr, EqualityExpression):
+        return (constraint.expr.args[0] - constraint.expr.args[1]) ** 2
+
+    # we can assume that isinstance(constraint.expr, InequalityExpression) and constraint.expr.args[1] == 1
+    # due to _is_constraint_penalty_supported method
+    else:
+        index = 0
+        if isinstance(constraint.expr.args[0], int):
+            index = 1
+        constraint_variables = constraint.expr.args[index].args
+        var_pairs = list(itertools.combinations(constraint_variables, 2))
+        return sum(var1 * var2 for var1, var2 in var_pairs)

classiq/applications/combinatorial_helpers/transformations/penalty_support.py

@@ -0,0 +1,37 @@
+from pyomo.core import ConcreteModel
+from pyomo.core.base.constraint import _GeneralConstraintData
+from pyomo.core.expr.relational_expr import EqualityExpression
+from pyomo.repn.standard_repn import _GeneralVarData
+
+from classiq.applications.combinatorial_helpers import (
+    allowed_constraints,
+    encoding_utils,
+)
+from classiq.applications.combinatorial_helpers.pyomo_utils import extract
+from classiq.applications.combinatorial_helpers.sympy_utils import sympyify_expression
+
+
+def is_model_penalty_supported(model: ConcreteModel) -> bool:
+    variables = extract(model, _GeneralVarData)
+    is_vars_supported = all(is_var_penalty_supported(var) for var in variables)
+
+    constraints = extract(model, _GeneralConstraintData)
+    is_constraints_supported = all(
+        is_constraint_penalty_supported(constraint) for constraint in constraints
+    )
+    return is_vars_supported and is_constraints_supported
+
+
+def is_var_penalty_supported(var: _GeneralVarData) -> bool:
+    return encoding_utils.is_var_binary(var) or encoding_utils.is_var_span_power_of_2(
+        var
+    )
+
+
+def is_constraint_penalty_supported(constraint: _GeneralConstraintData) -> bool:
+    if isinstance(constraint.expr, EqualityExpression):
+        return True
+
+    sympy_expr = sympyify_expression(constraint.expr)
+
+    return allowed_constraints.is_constraint_sum_less_than_one(sympy_expr)

classiq/applications/combinatorial_helpers/transformations/sign_seperation.py

@@ -0,0 +1,75 @@
+from itertools import filterfalse
+from typing import List, Tuple
+
+from sympy import (
+    Add,
+    Expr,
+    GreaterThan,
+    LessThan,
+    Mul,
+    Number,
+    Symbol,
+    expand,
+    simplify,
+)
+
+from classiq.exceptions import ClassiqCombOptError
+
+
+def sign_separation(expr: Expr) -> LessThan:
+    expr = simplify(expr)
+    expr = expand(expr)
+
+    if not isinstance(expr, (LessThan, GreaterThan)):
+        raise ClassiqCombOptError("sign separation didn't worked out")
+
+    if isinstance(expr, GreaterThan):
+        expr = LessThan(expr.args[1], expr.args[0])
+
+    expr_body = expr.args[0]
+    expr_bound = expr.args[1]
+
+    positive_body_args, negative_body_args = _get_positive_and_negative_args(expr_body)
+
+    positive_bound_args, negative_bound_args = _get_positive_and_negative_args(
+        expr_bound
+    )
+
+    modified_expr = LessThan(
+        Add(*positive_body_args) - Add(*negative_bound_args),
+        Add(*positive_bound_args) - Add(*negative_body_args),
+    )
+
+    return modified_expr
+
+
+def _get_positive_and_negative_args(expr: Expr) -> Tuple[List[Expr], List[Expr]]:
+    positive_args = []
+    negative_args = []
+
+    if isinstance(expr, Add):
+        positive_args += list(filter(_is_positive_expr, expr.args))
+        negative_args += list(filterfalse(_is_positive_expr, expr.args))
+
+    elif _is_positive_expr(expr):
+        positive_args.append(expr)
+    else:
+        negative_args.append(expr)
+
+    if not positive_args and not negative_args:
+        raise ClassiqCombOptError("sign separation didn't worked out")
+
+    return positive_args, negative_args
+
+
+def _is_positive_expr(expr: Expr) -> bool:
+    return (
+        (isinstance(expr, Number) and expr > 0)
+        or isinstance(expr, Symbol)
+        or (
+            isinstance(expr, Mul)
+            and isinstance(expr.args[0], Number)
+            and expr.args[0] > 0
+            and isinstance(expr.args[1], Symbol)
+        )
+    )

classiq/applications/combinatorial_helpers/transformations/slack_variables.py

@@ -0,0 +1,88 @@
+import math
+from functools import cached_property
+from itertools import filterfalse
+from typing import List
+
+import pyomo.core as pyo
+from pyomo.core.base.component import _ComponentBase
+from pyomo.core.expr.sympy_tools import sympy2pyomo_expression, sympyify_expression
+
+from classiq.applications.combinatorial_helpers import pyomo_utils
+from classiq.applications.combinatorial_helpers.arithmetic.arithmetic_expression import (
+    multivariate_extremum,
+)
+from classiq.applications.combinatorial_helpers.transformations import penalty_support
+from classiq.applications.combinatorial_helpers.transformations.sign_seperation import (
+    sign_separation,
+)
+
+
+def slack_vars_convert(model: pyo.ConcreteModel) -> pyo.ConcreteModel:
+    constraints = pyomo_utils.extract(model, pyo.Constraint)
+    converted_constraints = list(
+        filterfalse(penalty_support.is_constraint_penalty_supported, constraints)
+    )
+
+    for constraint in converted_constraints:
+        convertor = ConstraintConvertor(constraint)
+        setattr(model, convertor.slack_var_name, convertor.slack_var)
+        setattr(model, convertor.slack_constraint_name, convertor.slack_constraint)
+
+        pyomo_utils.delete_component(model, constraint)
+
+    return model
+
+
+_SLACK_VAR_SUFFIX = "_slack_var"
+_SLACK_SUFFIX = "_slack"
+
+
+def is_obj_slacked(var: _ComponentBase) -> bool:
+    return _SLACK_SUFFIX in var.name
+
+
+class ConstraintConvertor:
+    def __init__(self, constraint: pyo.Constraint) -> None:
+        self._symbols_map, self._expr = sympyify_expression(constraint.expr)
+        self._expr = sign_separation(self._expr)
+        self._expr_lower, self._expr_upper = self._expr.args
+
+        self._name = pyomo_utils.get_name(constraint)
+
+        self.slack_var_name = self._name + _SLACK_VAR_SUFFIX
+        self.slack_var_idxs = range(self._bound_int.bit_length())
+        self.slack_var = pyo.Var(self.slack_var_idxs, domain=pyo.Binary)
+        self.slack_var.construct()
+
+        self.slack_constraint_name = self._name + _SLACK_SUFFIX
+
+    @cached_property
+    def _bound_int(self) -> int:
+        max_upper = math.ceil(
+            multivariate_extremum(self._expr_upper, self._symbols_map, is_min=False)
+        )
+        min_lower = math.floor(
+            multivariate_extremum(self._expr_lower, self._symbols_map, is_min=True)
+        )
+        return max_upper - min_lower
+
+    @cached_property
+    def _slack_coeffs(self) -> List[int]:
+        coeffs = [2**idx for idx in self.slack_var_idxs[:-1]]
+        coeffs += [self._bound_int - sum(coeffs)]
+        return coeffs
+
+    @cached_property
+    def _slack_expr(self) -> pyo.Expression:
+        return sum(
+            coeff * self.slack_var[num] for num, coeff in enumerate(self._slack_coeffs)
+        )
+
+    @cached_property
+    def slack_constraint(self) -> pyo.Constraint:
+        expr_lower_pyomo = sympy2pyomo_expression(self._expr_lower, self._symbols_map)
+        expr_upper_pyomo = sympy2pyomo_expression(self._expr_upper, self._symbols_map)
+
+        return pyo.Constraint(
+            expr=expr_lower_pyomo + self._slack_expr == expr_upper_pyomo
+        )

classiq/applications/combinatorial_optimization/__init__.py

@@ -1,15 +1,26 @@
 from typing import List
 
 from classiq.interface.combinatorial_optimization import examples
+from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
 
+from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
+    get_optimization_solution_from_pyo,
+)
+
 from .combinatorial_optimization_config import OptimizerConfig, QAOAConfig
+from .combinatorial_optimization_model_constructor import (
+    construct_combinatorial_optimization_model,
+)
 
 __all__ = [
+    "EncodingType",
+    "OptimizerConfig",
+    "QAOAConfig",
     "QSolver",
+    "construct_combinatorial_optimization_model",
     "examples",
-    "QAOAConfig",
-    "OptimizerConfig",
+    "get_optimization_solution_from_pyo",
 ]
 
 

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -0,0 +1,134 @@
+from typing import Optional
+
+from pyomo import environ as pyo
+from pyomo.core import Objective, maximize
+
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    Real,
+    Struct,
+)
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+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
+
+from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
+    _internal_pyo_model_to_hamiltonian,
+    compute_qaoa_initial_point,
+    convert_pyomo_to_global_presentation,
+)
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    _pauli_operator_to_qmod,
+    get_pauli_operator,
+)
+from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
+
+
+def construct_combi_opt_py_model(
+    pyo_model: pyo.ConcreteModel,
+    qaoa_config: Optional[QAOAConfig] = None,
+    optimizer_config: Optional[OptimizerConfig] = None,
+) -> Model:
+    if qaoa_config is None:
+        qaoa_config = QAOAConfig()
+
+    if optimizer_config is None:
+        optimizer_config = OptimizerConfig()
+
+    max_iteration = 0
+    if optimizer_config.max_iteration is not None:
+        max_iteration = optimizer_config.max_iteration
+
+    hamiltonian = _internal_pyo_model_to_hamiltonian(
+        pyo_model, qaoa_config.penalty_energy
+    )
+    qaoa_initial_point = compute_qaoa_initial_point(hamiltonian, qaoa_config.num_layers)
+    len_hamiltonian = len(hamiltonian[0]["pauli"])
+    pauli_oper = get_pauli_operator(hamiltonian)
+    pauli_qmod = _pauli_operator_to_qmod(pauli_oper)
+
+    initial_point_expression = (
+        f"{optimizer_config.initial_point}"
+        if optimizer_config.initial_point is not None
+        else f"{qaoa_initial_point}"
+    )
+
+    return Model(
+        constants=[
+            Constant(
+                name="hamiltonian",
+                const_type=ClassicalList(element_type=Struct(name="PauliTerm")),
+                value=Expression(expr=f"[{pauli_qmod}]"),
+            )
+        ],
+        functions=[
+            NativeFunctionDefinition(
+                name="main",
+                param_decls={
+                    "params_list": ClassicalArray(
+                        element_type=Real(), size=qaoa_config.num_layers * 2
+                    )
+                },
+                port_declarations={
+                    "target": PortDeclaration(
+                        name="target",
+                        size=Expression(expr=f"{len_hamiltonian}"),
+                        direction=PortDeclarationDirection.Output,
+                    ),
+                },
+                body=[
+                    QuantumFunctionCall(
+                        function="allocate",
+                        positional_args=[
+                            Expression(expr="len(target)"),
+                            HandleBinding(name="target"),
+                        ],
+                    ),
+                    QuantumFunctionCall(
+                        function="qaoa_penalty",
+                        params={
+                            "num_qubits": Expression(expr="len(target)"),
+                            "params_list": Expression(expr="params_list"),
+                            "hamiltonian": Expression(expr="hamiltonian"),
+                        },
+                        inouts={"target": HandleBinding(name="target")},
+                    ),
+                ],
+            ),
+        ],
+        classical_execution_code=f"""
+vqe_result = vqe(
+hamiltonian=hamiltonian,
+maximize={next(pyo_model.component_objects(Objective)).sense == maximize},
+initial_point={initial_point_expression},
+optimizer=Optimizer.{optimizer_config.opt_type},
+max_iteration={max_iteration},
+tolerance={optimizer_config.tolerance},
+step_size={optimizer_config.step_size},
+skip_compute_variance={optimizer_config.skip_compute_variance},
+alpha_cvar={optimizer_config.alpha_cvar}
+)
+
+save({{"vqe_result": vqe_result, "hamiltonian": hamiltonian}})
+""",
+    )
+
+
+def construct_combinatorial_optimization_model(
+    pyo_model: pyo.ConcreteModel,
+    qaoa_config: Optional[QAOAConfig] = None,
+    optimizer_config: Optional[OptimizerConfig] = None,
+) -> SerializedModel:
+    converted_pyo_model = convert_pyomo_to_global_presentation(pyo_model)
+    model = construct_combi_opt_py_model(
+        converted_pyo_model, qaoa_config, optimizer_config
+    )
+    return model.get_model()

classiq/applications/finance/__init__.py

@@ -4,14 +4,15 @@ from classiq.interface.finance import (
     function_input,
     gaussian_model_input,
     log_normal_model_input,
-    model_input,
 )
 
+from .finance_model_constructor import construct_finance_model
+
 __all__ = [
+    "construct_finance_model",
     "function_input",
     "gaussian_model_input",
     "log_normal_model_input",
-    "model_input",
 ]
 
 

classiq/{applications_model_constructors → applications/finance}/finance_model_constructor.py

@@ -4,10 +4,6 @@ from typing import Union
 from classiq.interface.finance.function_input import FinanceFunctionInput
 from classiq.interface.finance.gaussian_model_input import GaussianModelInput
 from classiq.interface.finance.log_normal_model_input import LogNormalModelInput
-from classiq.interface.generator.expressions.enums.finance_functions import (
-    FINANCE_FUNCTION_STRING,
-    FinanceFunctionType,
-)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -16,18 +12,16 @@ 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.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
-from classiq.applications_model_constructors.libraries.ampltitude_estimation_library import (
+from classiq.applications.libraries.ampltitude_estimation_library import (
     AE_CLASSICAL_LIBRARY,
 )
-from classiq.applications_model_constructors.libraries.qmci_library import QMCI_LIBRARY
+from classiq.applications.libraries.qmci_library import QMCI_LIBRARY
 from classiq.exceptions import ClassiqError
 
 _OUTPUT_VARIABLE_NAME = "result"
@@ -56,13 +50,6 @@ def construct_finance_model(
     else:
         raise ClassiqError(f"Invalid model input: {finance_model_input}")
 
-    if isinstance(finance_function_input.f, FinanceFunctionType):
-        finance_function_f = finance_function_input.f
-    elif isinstance(finance_function_input.f, str):
-        finance_function_f = FINANCE_FUNCTION_STRING[finance_function_input.f]
-    else:
-        finance_function_f = FinanceFunctionType(finance_function_input.f)
-
     polynomial_degree = 0
     if finance_function_input.polynomial_degree is not None:
         polynomial_degree = finance_function_input.polynomial_degree
@@ -71,7 +58,7 @@ def construct_finance_model(
     if finance_function_input.tail_probability is not None:
         tail_probability = finance_function_input.tail_probability
 
-    finance_function_object = f"struct_literal(FinanceFunction, f={finance_function_f}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
+    finance_function_object = f"struct_literal(FinanceFunction, f={finance_function_input.f}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
     num_unitary_qubits = total_num_qubits + 1
 
     model = Model(
@@ -88,16 +75,26 @@ def construct_finance_model(
                 },
                 body=[
                     VariableDeclarationStatement(name="unitary_port"),
+                    QuantumFunctionCall(
+                        function="allocate",
+                        positional_args=[
+                            Expression(expr=f"{num_unitary_qubits}"),
+                            HandleBinding(name="unitary_port"),
+                        ],
+                    ),
+                    QuantumFunctionCall(
+                        function="allocate_num",
+                        positional_args=[
+                            Expression(expr=f"{phase_port_size}"),
+                            Expression(expr="False"),
+                            Expression(expr=f"{phase_port_size}"),
+                            HandleBinding(name="phase_port"),
+                        ],
+                    ),
                     QuantumFunctionCall(
                         function="qmci",
-                        params={
-                            "num_unitary_qubits": Expression(
-                                expr=f"{num_unitary_qubits}"
-                            ),
-                            "num_phase_qubits": Expression(expr=f"{phase_port_size}"),
-                        },
                         operands={
-                            "sp_op": QuantumLambdaFunction(
+                            "space_transform": QuantumLambdaFunction(
                                 body=[
                                     QuantumFunctionCall(
                                         function=finance_function,
@@ -110,16 +107,16 @@ def construct_finance_model(
                                             ),
                                         },
                                         inouts={
-                                            "func_port": HandleBinding(name="reg"),
-                                            "obj_port": HandleBinding(name="ind"),
+                                            "func_port": HandleBinding(name="arg0"),
+                                            "obj_port": HandleBinding(name="arg1"),
                                         },
                                     ),
                                 ],
                             ),
                         },
-                        outputs={
-                            "phase_port": HandleBinding(name="phase_port"),
-                            "unitary_port": HandleBinding(name="unitary_port"),
+                        inouts={
+                            "phase": HandleBinding(name="phase_port"),
+                            "packed_vars": HandleBinding(name="unitary_port"),
                         },
                     ),
                 ],

classiq/applications/grover/__init__.py

@@ -0,0 +1,11 @@
+from typing import List
+
+from .grover_model_constructor import construct_grover_model
+
+__all__ = [
+    "construct_grover_model",
+]
+
+
+def __dir__() -> List[str]:
+    return __all__