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

classiq/applications_model_constructors/combinatorial_helpers/transformations/ising_converter.py

@@ -0,0 +1,124 @@
+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_model_constructors.combinatorial_helpers import memory
+from classiq.applications_model_constructors.combinatorial_helpers.memory import (
+    InternalQuantumReg,
+)
+from classiq.applications_model_constructors.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_model_constructors/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_model_constructors/combinatorial_helpers/transformations/penalty_support.py

@@ -0,0 +1,41 @@
+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_model_constructors.combinatorial_helpers import (
+    allowed_constraints,
+    encoding_utils,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.pyomo_utils import (
+    extract,
+)
+from classiq.applications_model_constructors.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_model_constructors/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_model_constructors/combinatorial_helpers/transformations/slack_variables.py

@@ -0,0 +1,90 @@
+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_model_constructors.combinatorial_helpers import pyomo_utils
+from classiq.applications_model_constructors.combinatorial_helpers.arithmetic.arithmetic_expression import (
+    multivariate_extremum,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.transformations import (
+    penalty_support,
+)
+from classiq.applications_model_constructors.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_model_constructors/combinatorial_optimization_model_constructor.py

@@ -1,20 +1,19 @@
-import json
-from typing import List, Optional
+from typing import Optional
 
-import sympy
 from pyomo import environ as pyo
-from pyomo.core import ConcreteModel, Constraint, Objective, Var, maximize
-from pyomo.core.base.objective import ScalarObjective
-from pyomo.core.expr.sympy_tools import Pyomo2SympyVisitor, PyomoSympyBimap
+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, Real
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    Real,
+    Struct,
+)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.types.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
 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
@@ -25,62 +24,15 @@ from classiq.applications.combinatorial_optimization.combinatorial_optimization_
     OptimizerConfig,
     QAOAConfig,
 )
-
-_OUTPUT_VARIABLE_NAME = "solution"
-
-
-def pyomo2qmod(struct_name: str, pyo_model: ConcreteModel) -> str:
-    symbols_map = PyomoSympyBimap()
-
-    variables: List[sympy.Symbol] = []
-
-    bounds_set = False
-    lower_bound = None
-    upper_bound = None
-
-    for var_dict in pyo_model.component_objects(Var):
-        for key in var_dict:
-            var = Pyomo2SympyVisitor(symbols_map).walk_expression(var_dict[key])
-            var.name = var.name.replace(",", "_")
-            variables.append(var)
-            if bounds_set:
-                if lower_bound != var_dict[key].lb:
-                    raise ValueError("All problem variables must agree on lower bound")
-                if upper_bound != var_dict[key].ub:
-                    raise ValueError("All problem variables must agree on upper bound")
-            else:
-                lower_bound = var_dict[key].lb
-                upper_bound = var_dict[key].ub
-                bounds_set = True
-
-    constraint_exprs: List[sympy.Expr] = []
-
-    for constraint_dict in pyo_model.component_objects(Constraint):
-        for key in constraint_dict:
-            constraint_exprs.append(
-                Pyomo2SympyVisitor(symbols_map).walk_expression(
-                    constraint_dict[key].expr
-                )
-            )
-
-    pyo_objective: ScalarObjective = next(pyo_model.component_objects(Objective))
-    objective_type_str = "Max" if pyo_objective.sense == maximize else "Min"
-    objective_expr: sympy.Expr = Pyomo2SympyVisitor(symbols_map).walk_expression(
-        pyo_objective
-    )
-
-    combi_struct_decl = {
-        "name": struct_name,
-        "variables": {str(variable): {"kind": "int"} for variable in variables},
-        "variable_lower_bound": lower_bound,
-        "variable_upper_bound": upper_bound,
-        "constraints": [
-            {"expr": str(constraint_expr)} for constraint_expr in constraint_exprs
-        ],
-        "objective_type": objective_type_str,
-        "objective_function": {"expr": str(objective_expr)},
-    }
-    return json.dumps(combi_struct_decl, indent=2)
+from classiq.applications_model_constructors.combinatorial_helpers.combinatorial_problem_utils import (
+    compute_qaoa_initial_point,
+    convert_pyomo_to_global_presentation,
+    pyo_model_to_hamiltonian,
+)
+from classiq.applications_model_constructors.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    _pauli_operator_to_qmod,
+    get_pauli_operator,
+)
 
 
 def construct_combi_opt_py_model(
@@ -98,16 +50,24 @@ def construct_combi_opt_py_model(
     if optimizer_config.max_iteration is not None:
         max_iteration = optimizer_config.max_iteration
 
+    hamiltonian = 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"compute_qaoa_initial_point(optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy}),{qaoa_config.num_layers})"
+        else f"{qaoa_initial_point}"
     )
 
     return Model(
-        types=[
-            CombinatorialOptimizationStructDeclaration.parse_raw(
-                pyomo2qmod("MyCombiProblem", pyo_model)
+        constants=[
+            Constant(
+                name="hamiltonian",
+                const_type=ClassicalList(element_type=Struct(name="PauliTerm")),
+                value=Expression(expr=f"[{pauli_qmod}]"),
             )
         ],
         functions=[
@@ -121,9 +81,7 @@ def construct_combi_opt_py_model(
                 port_declarations={
                     "target": PortDeclaration(
                         name="target",
-                        size=Expression(
-                            expr=f"len(get_field(optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy})[0], 'pauli'))"
-                        ),
+                        size=Expression(expr=f"{len_hamiltonian}"),
                         direction=PortDeclarationDirection.Output,
                     ),
                 },
@@ -138,12 +96,9 @@ def construct_combi_opt_py_model(
                     QuantumFunctionCall(
                         function="qaoa_penalty",
                         params={
-                            "hamiltonian": Expression(
-                                expr=f"optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy})"
-                            ),
-                            "params_list": Expression(expr="params_list"),
                             "num_qubits": Expression(expr="len(target)"),
-                            "is_st": Expression(expr="True"),
+                            "params_list": Expression(expr="params_list"),
+                            "hamiltonian": Expression(expr="hamiltonian"),
                         },
                         inouts={"target": HandleBinding(name="target")},
                     ),
@@ -152,19 +107,18 @@ def construct_combi_opt_py_model(
         ],
         classical_execution_code=f"""
 vqe_result = vqe(
-    hamiltonian=optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy}),
-    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}
+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}
 )
-{_OUTPUT_VARIABLE_NAME} = get_optimization_solution(get_type(MyCombiProblem), vqe_result, {qaoa_config.penalty_energy})
-hamiltonian = optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy})
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}, "vqe_result": vqe_result, "hamiltonian": hamiltonian}})
+
+save({{"vqe_result": vqe_result, "hamiltonian": hamiltonian}})
 """,
     )
 
@@ -174,5 +128,8 @@ def construct_combinatorial_optimization_model(
     qaoa_config: Optional[QAOAConfig] = None,
     optimizer_config: Optional[OptimizerConfig] = None,
 ) -> SerializedModel:
-    model = construct_combi_opt_py_model(pyo_model, qaoa_config, optimizer_config)
+    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_model_constructors/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,10 +12,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.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -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(
@@ -91,10 +78,10 @@ def construct_finance_model(
                     QuantumFunctionCall(
                         function="qmci",
                         params={
+                            "num_phase_qubits": Expression(expr=f"{phase_port_size}"),
                             "num_unitary_qubits": Expression(
                                 expr=f"{num_unitary_qubits}"
                             ),
-                            "num_phase_qubits": Expression(expr=f"{phase_port_size}"),
                         },
                         operands={
                             "sp_op": QuantumLambdaFunction(