classiq 0.51.0__py3-none-any.whl → 0.52.0__py3-none-any.whl

classiq/interface/server/routes.py

@@ -2,6 +2,9 @@ ANALYZER_PREFIX = "/analyzer"
 CHEMISTRY_PREFIX = "/chemistry"
 EXECUTION_PREFIX = "/execution"
 CONVERSION_PREFIX = "/conversion"
+PROVIDERS_PREFIX = "/providers"
+
+IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
 
 EXECUTION_NON_VERSIONED_PREFIX = "/execution/v1"
 SYNTHESIS_NON_VERSIONED_PREFIX = "/synthesis/v1"
@@ -71,3 +74,8 @@ CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
 )
 
 STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"
+
+IQCC_INIT_AUTH_SUFFIX = "/init_auth"
+IQCC_INIT_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_INIT_AUTH_SUFFIX
+IQCC_PROBE_AUTH_SUFFIX = "/probe_auth"
+IQCC_PROBE_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_PROBE_AUTH_SUFFIX

classiq/model_expansions/evaluators/parameter_types.py

@@ -118,7 +118,7 @@ def _update_operand_signature_environment(
 def _cast(
     quantum_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
 ) -> QuantumSymbol:
-    updated_quantum_type = quantum_type.copy()
+    updated_quantum_type = quantum_type.model_copy()
     _inject_quantum_arg_info_to_type(updated_quantum_type, quantum_symbol, param_name)
     return QuantumSymbol(
         handle=quantum_symbol.handle, quantum_type=updated_quantum_type
@@ -132,13 +132,13 @@ def _evaluate_type_from_arg(
         return parameter
 
     updated_quantum_type: QuantumType = evaluate_type_in_quantum_symbol(
-        parameter.quantum_type.copy(), inner_scope, parameter.name
+        parameter.quantum_type.model_copy(), inner_scope, parameter.name
     )
     if parameter.direction != PortDeclarationDirection.Output:
         updated_quantum_type = _inject_quantum_arg_info_to_type(
             updated_quantum_type, argument.as_type(QuantumSymbol), parameter.name
         )
-    return parameter.copy(update={"quantum_type": updated_quantum_type})
+    return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
 
 def evaluate_type_in_quantum_symbol(

classiq/model_expansions/expression_renamer.py

@@ -30,7 +30,7 @@ class ExpressionRenamer(Transformer):
         update_dict = dict(
             positional_args=[self.visit(arg) for arg in node.positional_args],
         )
-        return node.copy(update=update_dict)
+        return node.model_copy(update=update_dict)
 
     def visit_Expression(self, expression: Expression) -> Expression:
         parsed_expr = ast.parse(expression.expr)

classiq/model_expansions/quantum_operations/control.py

@@ -23,7 +23,6 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -43,7 +42,6 @@ from classiq.model_expansions.quantum_operations.expression_operation import (
     ExpressionOperationEmitter,
 )
 from classiq.model_expansions.scope import Scope
-from classiq.qmod.builtins.functions import inplace_prepare_int
 
 ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 
@@ -51,7 +49,7 @@ ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
         condition = self._evaluate_op_expression(control)
-        control = control.copy(update=dict(expression=condition))
+        control = control.model_copy(update=dict(expression=condition))
 
         arrays_with_subscript = self._get_symbols_to_split(condition)
         if len(arrays_with_subscript) > 0:
@@ -76,7 +74,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
     def _emit_propagated(self, control: Control) -> None:
         if control.is_generative():
             context = self._register_generative_context(control, CONTROL_OPERATOR_NAME)
-            control = control.copy(update={"body": context.statements("body")})
+            control = control.model_copy(update={"body": context.statements("body")})
 
         if self._should_wrap_control(control):
             self._emit_wrapped(control)
@@ -106,7 +104,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         )
         self._update_control_state(control)
         self._builder.emit_statement(
-            control.copy(update=dict(body=context.statements("body")))
+            control.model_copy(update=dict(body=context.statements("body")))
         )
 
     def _emit_wrapped(self, control: Control) -> None:
@@ -119,7 +117,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         )
         self._update_control_state(control)
         self._builder.emit_statement(
-            control.copy(update=dict(body=[wrapping_function]))
+            control.model_copy(update=dict(body=[wrapping_function]))
         )
 
     @staticmethod
@@ -157,7 +155,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         self, control: Control, handle_name: str
     ) -> Control:
         handle_expr = self._interpreter.evaluate(Expression(expr=handle_name)).emit()
-        return control.copy(update=dict(expression=handle_expr))
+        return control.model_copy(update=dict(expression=handle_expr))
 
     def _emit_with_x_gates(
         self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
@@ -166,12 +164,13 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
 
         x_gate_value = self._get_x_gate_value(ctrl_state)
         if x_gate_value != 0:
-            prepare_int_call = QuantumFunctionCall(
-                function=inplace_prepare_int.func_decl.name,
-                positional_args=[Expression(expr=str(x_gate_value)), ctrl.handle],
+            compute_op.append(
+                ArithmeticOperation(
+                    result_var=ctrl.handle,
+                    expression=Expression(expr=str(x_gate_value)),
+                    operation_kind=ArithmeticOperationKind.InplaceXor,
+                )
             )
-            prepare_int_call.set_func_decl(inplace_prepare_int.func_decl)
-            compute_op.append(prepare_int_call)
 
         if isinstance(ctrl, QmodQNumProxy):
             # Canonical control does not accept QNum, so we have to cast it

classiq/model_expansions/quantum_operations/emitter.py

@@ -11,7 +11,13 @@ from typing import (
     cast,
 )
 
+import sympy
+
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.ide.visual_model import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -47,6 +53,9 @@ from classiq.model_expansions.function_builder import (
 )
 from classiq.model_expansions.generative_functions import emit_operands_as_declarative
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.sympy_conversion.sympy_to_python import (
+    translate_sympy_quantum_expression,
+)
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.functions import allocate, free
 from classiq.qmod.quantum_function import GenerativeQFunc
@@ -274,3 +283,16 @@ class Emitter(Generic[QuantumStatementT]):
         context = self._interpreter._expand_operation(gen_closure)
         self._generative_contexts[context_name] = context
         return context
+
+    def _evaluate_expression(self, expression: Expression) -> Expression:
+        evaluated_expression = self._interpreter.evaluate(expression)
+        if isinstance(evaluated_expression.value, sympy.Basic):
+            new_expression = Expression(
+                expr=translate_sympy_quantum_expression(evaluated_expression.value)
+            )
+        else:
+            new_expression = Expression(expr=str(evaluated_expression.value))
+        new_expression._evaluated_expr = EvaluatedExpression(
+            value=evaluated_expression.value
+        )
+        return new_expression

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -3,8 +3,6 @@ from abc import abstractmethod
 from itertools import chain
 from typing import TYPE_CHECKING, Dict, List, Tuple, TypeVar
 
-import sympy
-
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -36,9 +34,6 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
-from classiq.model_expansions.sympy_conversion.sympy_to_python import (
-    translate_sympy_quantum_expression,
-)
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 ExpressionOperationT = TypeVar("ExpressionOperationT", bound=QuantumExpressionOperation)
@@ -74,7 +69,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             },
             expression,
         )
-        new_op = op.copy(update=dict(expression=new_expression))
+        new_op = op.model_copy(update=dict(expression=new_expression))
 
         self._interpreter.emit_statement(
             WithinApply(
@@ -194,23 +189,10 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
     def _evaluate_op_expression(self, op: ExpressionOperationT) -> Expression:
         return self._evaluate_expression(op.expression)
 
-    def _evaluate_expression(self, expression: Expression) -> Expression:
-        evaluated_expression = self._interpreter.evaluate(expression)
-        if isinstance(evaluated_expression.value, sympy.Basic):
-            new_expression = Expression(
-                expr=translate_sympy_quantum_expression(evaluated_expression.value)
-            )
-        else:
-            new_expression = Expression(expr=str(evaluated_expression.value))
-        new_expression._evaluated_expr = EvaluatedExpression(
-            value=evaluated_expression.value
-        )
-        return new_expression
-
     def _evaluate_types_in_expression(
         self, op: ExpressionOperationT, expression: Expression
     ) -> ExpressionOperationT:
-        op_with_evaluated_types = op.copy(update={"expression": expression})
+        op_with_evaluated_types = op.model_copy(update={"expression": expression})
         vrc = VarRefCollector()
         vrc.visit(ast.parse(op_with_evaluated_types.expression.expr))
         handles = vrc.var_handles

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Tuple
+from typing import TYPE_CHECKING, List, Tuple, Union
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
@@ -35,20 +35,37 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol, Scope
-from classiq.qmod.builtins.functions import CX, allocate, integer_xor, modular_add
+from classiq.qmod.builtins.functions import (
+    CX,
+    allocate,
+    integer_xor,
+    modular_add,
+    modular_add_constant,
+    real_xor_constant,
+)
 
 
 def _binary_function_declaration(
-    op: BinaryOperation,
+    op: BinaryOperation, constant: bool
 ) -> NamedParamsQuantumFunctionDeclaration:
     return {
-        BinaryOperation.Addition: modular_add.func_decl,
-        BinaryOperation.Xor: integer_xor.func_decl,
-    }[op]
+        False: {
+            BinaryOperation.Addition: modular_add.func_decl,
+            BinaryOperation.Xor: integer_xor.func_decl,
+        },
+        True: {
+            BinaryOperation.Addition: modular_add_constant.func_decl,
+            BinaryOperation.Xor: real_xor_constant.func_decl,
+        },
+    }[constant][op]
 
 
 class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
     def emit(self, op: InplaceBinaryOperation, /) -> None:
+        if isinstance(op.value, Expression):
+            self._emit_constant_operation(op)
+            return
+
         value_var = self._interpreter.evaluate(op.value).as_type(QuantumSymbol)
         target_var = self._interpreter.evaluate(op.target).as_type(QuantumSymbol)
         value_var, target_var = evaluate_types_in_quantum_symbols(
@@ -95,7 +112,7 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
                 value_var=value_var,
                 target_var=target_var,
                 internal_function_declaration=_binary_function_declaration(
-                    op.operation
+                    op.operation, constant=False
                 ),
             ),
             scope=Scope(parent=self._current_scope),
@@ -105,6 +122,18 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
                 inplace_binary_op_function, [op.value, op.target]
             )
 
+    def _emit_constant_operation(self, op: InplaceBinaryOperation) -> None:
+        if TYPE_CHECKING:
+            assert isinstance(op.value, Expression)
+        value = self._evaluate_expression(op.value)
+        self._interpreter.emit(
+            _internal_inplace_binary_operation_function_call(
+                _binary_function_declaration(op.operation, constant=True),
+                value,
+                op.target,
+            )
+        )
+
 
 def _build_inplace_binary_operation(
     value_var: QuantumSymbol,
@@ -164,12 +193,12 @@ def _build_inplace_binary_operation(
 
 def _internal_inplace_binary_operation_function_call(
     internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
-    value_var: HandleBinding,
+    value: Union[HandleBinding, Expression],
     target_var: HandleBinding,
 ) -> QuantumFunctionCall:
     internal_function_call = QuantumFunctionCall(
         function=internal_function_declaration.name,
-        positional_args=[value_var, target_var],
+        positional_args=[value, target_var],
     )
     internal_function_call.set_func_decl(internal_function_declaration)
     return internal_function_call
@@ -230,10 +259,7 @@ def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
     if not quantum_type.sign_value or size_diff >= 0:
         return var, [], [], [], []
 
-    significand_var, sign_var, sign_split_bind = _split_sign(kind, var)
     padding_var, padding_allocation = _allocate_padding(kind, size_diff)
-    padding_init_ops = _init_padding(sign_var, padding_var, size_diff)
-
     padded_var = QuantumSymbol(
         handle=HandleBinding(name=f"padded_{kind}"),
         quantum_type=QuantumNumeric(
@@ -242,17 +268,42 @@ def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
             fraction_digits=Expression(expr="0"),
         ),
     )
+    var_decls = [
+        VariableDeclarationStatement(
+            name=var.handle.name,
+            quantum_type=var.quantum_type,
+        )
+        for var in (padding_var, padded_var)
+    ]
+
+    if quantum_type.size_in_bits == 1:  # qnum<1, SIGNED, ?>
+        padding_init_ops = _init_padding(var, padding_var, size_diff)
+        padding_rebind = BindOperation(
+            in_handles=[var.handle, padding_var.handle],
+            out_handles=[padded_var.handle],
+        )
+        return (
+            padded_var,
+            var_decls,
+            [padding_allocation],
+            padding_init_ops,
+            [padding_rebind],
+        )
+
+    significand_var, sign_var, sign_split_bind = _split_sign(kind, var)
+    padding_init_ops = _init_padding(sign_var, padding_var, size_diff)
+
     padding_rebind = BindOperation(
         in_handles=[significand_var.handle, sign_var.handle, padding_var.handle],
         out_handles=[padded_var.handle],
     )
 
-    var_decls = [
+    var_decls += [
         VariableDeclarationStatement(
             name=var.handle.name,
             quantum_type=var.quantum_type,
         )
-        for var in (significand_var, sign_var, padding_var, padded_var)
+        for var in (significand_var, sign_var)
     ]
 
     return (

classiq/model_expansions/quantum_operations/invert.py

@@ -16,7 +16,7 @@ class InvertEmitter(Emitter[Invert]):
     def _emit_propagated(self, invert: Invert, /) -> None:
         if invert.is_generative():
             context = self._register_generative_context(invert, INVERT_OPERATOR_NAME)
-            invert = invert.copy(update={"body": context.statements("body")})
+            invert = invert.model_copy(update={"body": context.statements("body")})
 
         if self._should_wrap(invert.body):
             self._emit_wrapped(invert)

classiq/model_expansions/quantum_operations/phase.py

@@ -35,19 +35,18 @@ from classiq.qmod.semantics.error_manager import ErrorManager
 class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
     def _negate_expression(self, expression: Expression, /) -> Expression:
         return self._evaluate_expression(
-            # TODO: change to model_copy for pydantic V2
-            expression.copy(update=dict(expr=f"-({expression.expr})"))
+            expression.model_copy(update=dict(expr=f"-({expression.expr})"))
         )
 
     def emit(self, phase_op: PhaseOperation, /) -> None:
         phase_expression = self._evaluate_op_expression(phase_op)
-        phase_op = phase_op.copy(update=dict(expression=phase_expression))
+        phase_op = phase_op.model_copy(update=dict(expression=phase_expression))
         arrays_with_subscript = self._get_symbols_to_split(phase_op.expression)
         if len(arrays_with_subscript) > 0:
             self._emit_with_split(phase_op, phase_op.expression, arrays_with_subscript)
             return
-        # TODO: change to model_copy for pydantic V2
-        phase_op = phase_op.copy(
+
+        phase_op = phase_op.model_copy(
             update=dict(expression=self._negate_expression(phase_op.expression))
         )
         phase_op = self._evaluate_types_in_expression(phase_op, phase_op.expression)

classiq/model_expansions/quantum_operations/power.py

@@ -27,7 +27,7 @@ class PowerEmitter(Emitter[Power]):
     def _emit_propagated(self, power: Power) -> None:
         if power.is_generative():
             context = self._register_generative_context(power, POWER_OPERATOR_NAME)
-            power = power.copy(update={"body": context.statements("body")})
+            power = power.model_copy(update={"body": context.statements("body")})
 
         self._power = power
         self._power_value = self._get_power_value()

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -1,7 +1,11 @@
 import ast
+import re
 from typing import Tuple
 
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
 from classiq.interface.generator.compiler_keywords import INPLACE_ARITH_AUX_VAR_PREFIX
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import HandleBinding
@@ -38,13 +42,22 @@ from classiq.qmod import builtins
 from classiq.qmod.builtins.functions import X, allocate
 
 
-def _is_zero(expr: str) -> bool:
+def _is_constant(expr: str) -> bool:
     try:
-        return float(expr) == 0.0
+        float(expr)
+        return True
     except ValueError:
         return False
 
 
+def _is_zero(expr: str) -> bool:
+    return _is_constant(expr) and float(expr) == 0
+
+
+def _is_variable(expr: str) -> bool:
+    return re.fullmatch("[a-zA-Z_][a-zA-Z0-9_]*", expr) is not None
+
+
 class QuantumAssignmentOperationEmitter(
     ExpressionOperationEmitter[QuantumAssignmentOperation]
 ):
@@ -86,6 +99,7 @@ class QuantumAssignmentOperationEmitter(
             or op.result_type.size_in_bits > 1
             or not _is_res_boolean(op)
             or target.quantum_type.size_in_bits > 1
+            or _is_constant(expression.expr)
         ):
             _validate_naive_inplace_handles(op)
             self._build_naive_inplace(op, expression)
@@ -131,7 +145,7 @@ class QuantumAssignmentOperationEmitter(
             expr=ast.unparse(optimizer.visit(ast.parse(expression.expr)))
         )
         optimized_expression = self._evaluate_expression(optimized_expression)
-        optimized_op = op.copy(update=dict(expression=optimized_expression))
+        optimized_op = op.model_copy(update=dict(expression=optimized_expression))
         return optimized_op, optimized_expression, optimizer.is_convertible
 
     def _adapt_boolean_inplace(
@@ -141,12 +155,43 @@ class QuantumAssignmentOperationEmitter(
         adapted_expression = self._evaluate_expression(
             Expression(expr=ast.unparse(adapter.visit(ast.parse(expression.expr))))
         )
-        adapted_op = op.copy(update=dict(expression=adapted_expression))
+        adapted_op = op.model_copy(update=dict(expression=adapted_expression))
         return adapted_op, adapted_expression, adapter.to_invert
 
     def _build_naive_inplace(
         self, qe: ArithmeticOperation, new_expression: Expression
     ) -> None:
+        if qe.operation_kind == ArithmeticOperationKind.InplaceXor:
+            op = BinaryOperation.Xor
+        elif qe.operation_kind == ArithmeticOperationKind.InplaceAdd:
+            op = BinaryOperation.Addition
+        else:
+            raise ClassiqInternalExpansionError(
+                f"Unrecognized operation kind {qe.operation_kind!r}"
+            )
+
+        if _is_constant(new_expression.expr):
+            self._interpreter.emit_statement(
+                InplaceBinaryOperation(
+                    operation=op,
+                    target=qe.result_var,
+                    value=new_expression,
+                )
+            )
+            return
+
+        if _is_variable(new_expression.expr):
+            value_var = self._interpreter.evaluate(new_expression.expr).value
+            if isinstance(value_var, QuantumSymbol):
+                self._interpreter.emit_statement(
+                    InplaceBinaryOperation(
+                        operation=op,
+                        target=qe.result_var,
+                        value=value_var.handle,
+                    )
+                )
+                return
+
         aux_var = self._counted_name_allocator.allocate(INPLACE_ARITH_AUX_VAR_PREFIX)
         self._interpreter.emit_statement(
             VariableDeclarationStatement(name=aux_var, quantum_type=QuantumNumeric())
@@ -156,10 +201,6 @@ class QuantumAssignmentOperationEmitter(
             expression=new_expression,
             operation_kind=ArithmeticOperationKind.Assignment,
         )
-        if qe.operation_kind == ArithmeticOperationKind.InplaceXor:
-            op = BinaryOperation.Xor
-        else:
-            op = BinaryOperation.Addition
         inplace_store = InplaceBinaryOperation(
             operation=op,
             target=qe.result_var,

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -12,8 +12,8 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
     def emit(self, variable_declaration: VariableDeclarationStatement, /) -> None:
-        var_decl = variable_declaration.copy()
-        var_decl.quantum_type = variable_declaration.quantum_type.copy()
+        var_decl = variable_declaration.model_copy()
+        var_decl.quantum_type = variable_declaration.quantum_type.model_copy()
         self._current_scope[variable_declaration.name] = Evaluated(
             value=QuantumSymbol(
                 handle=HandleBinding(name=var_decl.name),

classiq/model_expansions/quantum_operations/within_apply.py

@@ -19,7 +19,7 @@ class WithinApplyEmitter(Emitter[WithinApply]):
             within_apply_context = self._register_generative_context(
                 within_apply, WITHIN_APPLY_NAME, ["within", "apply"]
             )
-            within_apply = within_apply.copy(
+            within_apply = within_apply.model_copy(
                 update={
                     "compute": within_apply_context.statements("within"),
                     "action": within_apply_context.statements("apply"),

classiq/qmod/builtins/__init__.py

@@ -17,9 +17,7 @@ from .operations import __all__ as _builtin_operations
 from .structs import *  # noqa: F403
 from .structs import __all__ as _builtin_structs
 
-FinanceFunctionInput.update_forward_refs(
-    FinanceFunctionType=FinanceFunctionType  # noqa: F405
-)
+FinanceFunctionInput.model_rebuild()
 BUILTIN_CONSTANTS = [
     constant._get_constant_node()
     for constant in [

classiq/qmod/builtins/functions/__init__.py

@@ -69,6 +69,8 @@ CORE_LIB_DECLS = [
         add,
         modular_add,
         integer_xor,
+        modular_add_constant,
+        real_xor_constant,
         U,
         CCX,
         allocate,
@@ -192,6 +194,8 @@ __all__ = [
     "add",
     "modular_add",
     "integer_xor",
+    "modular_add_constant",
+    "real_xor_constant",
     "U",
     "CCX",
     "allocate",

classiq/qmod/builtins/functions/arithmetic.py

@@ -43,11 +43,21 @@ def modular_add(left: QArray[QBit], right: QArray[QBit]) -> None:
     pass
 
 
+@qfunc(external=True)
+def modular_add_constant(left: CReal, right: QNum) -> None:
+    pass
+
+
 @qfunc(external=True)
 def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
     pass
 
 
+@qfunc(external=True)
+def real_xor_constant(left: CReal, right: QNum) -> None:
+    pass
+
+
 @qfunc(external=True)
 def modular_increment(a: CInt, x: QNum) -> None:
     """

classiq/qmod/create_model_function.py

@@ -106,7 +106,7 @@ def _expand_generative_model(
         preferences,
         classical_execution_function,
     )
-    generative_functions = _get_generative_functions(gen_main)
+    generative_functions = _get_generative_functions(gen_main, preferences)
     model.functions = generative_functions
     model.types = list(QMODULE.type_decls.values())
     model.enums = list(QMODULE.enum_decls.values())
@@ -114,20 +114,25 @@ def _expand_generative_model(
     return model
 
 
-def _get_generative_functions(gen_main: QFunc) -> List[NativeFunctionDefinition]:
+def _get_generative_functions(
+    gen_main: QFunc, preferences: Optional[Preferences]
+) -> List[NativeFunctionDefinition]:
     # The Interpreter accepts a model and a list of generative functions.
     # Since the main function is generative, it can only be expanded using the
     # Interpreter.
     # To solve this deadlock, we create a wrapper model
     # `qfunc main(...) { _gen_main(...); }` and rename `main` to `_gen_main` before
     # passing them to the Interpreter.
-    gen_model = _get_wrapper_main(gen_main)
+    gen_model = _get_wrapper_main(gen_main, preferences)
     gen_functions = _get_all_model_functions_as_generative_functions()
     functions_dict = _interpret_generative_model(gen_model, gen_functions)
     return list(functions_dict.values())
 
 
-def _get_wrapper_main(gen_main: QFunc) -> Model:
+def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Model:
+    extra_args = {}
+    if preferences is not None:
+        extra_args["preferences"] = preferences
     return Model(
         functions=[
             NativeFunctionDefinition(
@@ -145,6 +150,7 @@ def _get_wrapper_main(gen_main: QFunc) -> Model:
                 ],
             ),
         ],
+        **extra_args,
     )
 
 
@@ -159,7 +165,7 @@ def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
             if gen_func.func_decl.name != MAIN_FUNCTION_NAME
             else GenerativeQFunc(
                 gen_func._py_callable,
-                gen_func.func_decl.copy(update={"name": GEN_MAIN_NAME}),
+                gen_func.func_decl.model_copy(update={"name": GEN_MAIN_NAME}),
             )
         )
         for gen_func in gen_functions
@@ -182,9 +188,9 @@ def _interpret_generative_model(
     expanded_gen_main_name = cast(
         QuantumFunctionCall, functions_dict[MAIN_FUNCTION_NAME].body[0]
     ).func_name
-    functions_dict[MAIN_FUNCTION_NAME] = functions_dict[expanded_gen_main_name].copy(
-        update={"name": MAIN_FUNCTION_NAME}
-    )
+    functions_dict[MAIN_FUNCTION_NAME] = functions_dict[
+        expanded_gen_main_name
+    ].model_copy(update={"name": MAIN_FUNCTION_NAME})
     functions_dict.pop(expanded_gen_main_name)
 
     return functions_dict