classiq 0.68.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -48,7 +48,7 @@ from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QScalar, QVa
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
-from classiq.qmod.utilities import get_source_ref
+from classiq.qmod.utilities import Statements, get_source_ref, suppress_return_value
 
 _MISSING_VALUE: Final[int] = -1
 
@@ -63,6 +63,7 @@ def allocate(out: Output[QVar]) -> None:
     pass
 
 
+@suppress_return_value
 def allocate(*args: Any, **kwargs: Any) -> None:
     """
     Initialize a quantum variable to a new quantum object in the zero state:
@@ -106,6 +107,7 @@ def allocate(*args: Any, **kwargs: Any) -> None:
     )
 
 
+@suppress_return_value
 def bind(
     source: Union[Input[QVar], list[Input[QVar]]],
     destination: Union[Output[QVar], list[Output[QVar]]],
@@ -125,10 +127,11 @@ def bind(
     )
 
 
+@suppress_return_value
 def if_(
     condition: Union[SymbolicExpr, bool],
-    then: Union[QCallable, Callable[[], None]],
-    else_: Union[QCallable, Callable[[], None], int] = _MISSING_VALUE,
+    then: Union[QCallable, Callable[[], Statements]],
+    else_: Union[QCallable, Callable[[], Statements], int] = _MISSING_VALUE,
 ) -> None:
     _validate_operand(then)
     if else_ != _MISSING_VALUE:
@@ -149,10 +152,11 @@ def if_(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 
+@suppress_return_value
 def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
-    stmt_block: Union[QCallable, Callable[[], None]],
-    else_block: Union[QCallable, Callable[[], None], None] = None,
+    stmt_block: Union[QCallable, Callable[[], Statements]],
+    else_block: Union[QCallable, Callable[[], Statements], None] = None,
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -170,6 +174,7 @@ def control(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
+@suppress_return_value
 def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Initialize a scalar quantum variable using an arithmetic expression.
@@ -194,6 +199,7 @@ def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Perform an amplitude-encoding assignment operation on a quantum variable and a
@@ -216,6 +222,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Add an arithmetic expression to a quantum variable.
@@ -238,6 +245,7 @@ def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Bitwise-XOR a quantum variable with an arithmetic expression.
@@ -260,9 +268,10 @@ def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def within_apply(
-    within: Callable[[], None],
-    apply: Callable[[], None],
+    within: Callable[[], Statements],
+    apply: Callable[[], Statements],
 ) -> None:
     _validate_operand(within)
     _validate_operand(apply)
@@ -279,7 +288,10 @@ def within_apply(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(within_apply_stmt)
 
 
-def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) -> None:
+@suppress_return_value
+def repeat(
+    count: Union[SymbolicExpr, int], iteration: Callable[[int], Statements]
+) -> None:
     _validate_operand(iteration)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -310,9 +322,10 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(repeat_stmt)
 
 
+@suppress_return_value
 def power(
     exponent: Union[SymbolicExpr, int],
-    stmt_block: Union[QCallable, Callable[[], None]],
+    stmt_block: Union[QCallable, Callable[[], Statements]],
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -327,7 +340,8 @@ def power(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(power_stmt)
 
 
-def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
+@suppress_return_value
+def invert(stmt_block: Union[QCallable, Callable[[], Statements]]) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -339,6 +353,7 @@ def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 
+@suppress_return_value
 def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -402,7 +417,7 @@ def _get_operand_hint(
 
 
 def _operand_to_body(
-    callable_: Union[QCallable, Callable[[], None]], param_name: str
+    callable_: Union[QCallable, Callable[[], Statements]], param_name: str
 ) -> StatementBlock:
     op_name = sys._getframe(1).f_code.co_name
     if (

classiq/qmod/cparam.py

@@ -1,4 +1,5 @@
 import sys
+from abc import ABC, abstractmethod
 from typing import (  # type: ignore[attr-defined]
     TYPE_CHECKING,
     Any,
@@ -9,6 +10,8 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec
 
+from classiq.interface.exceptions import ClassiqValueError
+
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
 if TYPE_CHECKING:
@@ -21,18 +24,34 @@ else:
 
 class CParam(SymbolicSuperclass):
     def __init__(self, expr: str) -> None:
-        super().__init__(expr, False)
+        super().__init__(expr, is_quantum=False)
+
+
+class CParamAbstract(ABC, CParam):
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "CParamAbstract":
+        raise ClassiqValueError(
+            f"{cls.__name__} is a Qmod type hint for a classical parameter and it cannot be instantiated. "
+            f"Use regular Pythonic values as arguments instead. "
+            f"Example:\n\n"
+            f"def foo(val: {cls.__name__}) -> None: ...\n\n"
+            f"foo({_EXAMPLE_VALUES[cls.__name__]})  # Correct\n"
+        )
 
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
 
-class CInt(CParam):
+
+class CInt(CParamAbstract):
     pass
 
 
-class CReal(CParam):
+class CReal(CParamAbstract):
     pass
 
 
-class CBool(CParam):
+class CBool(CParamAbstract):
     pass
 
 
@@ -47,7 +66,7 @@ class ArrayBase(Generic[_P]):
             return _GenericAlias(cls, args)
 
 
-class CArray(CParam, ArrayBase[_P]):
+class CArray(CParamAbstract, ArrayBase[_P]):
     if TYPE_CHECKING:
 
         @property
@@ -62,3 +81,11 @@ Array = CArray
 class CParamScalar(CParam, SymbolicExpr):
     def __hash__(self) -> int:
         return hash(str(self))
+
+
+_EXAMPLE_VALUES: dict[str, Any] = {
+    CInt.__name__: 1,
+    CReal.__name__: 1.0,
+    CBool.__name__: True,
+    CArray.__name__: [1, 2],
+}

classiq/qmod/declaration_inferrer.py

@@ -38,6 +38,7 @@ from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.python_classical_type import PythonClassicalType
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.semantics.validation.type_hints import validate_annotation
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 if sys.version_info[0:2] >= (3, 9):
@@ -123,7 +124,7 @@ def _extract_operand_decl(
 
 
 def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
-    if sys.version_info[0:2] < (3, 9) or get_origin(py_type) is not Annotated:
+    if get_origin(py_type) is not Annotated:
         return None, py_type
     args = get_args(py_type)
     if len(args) == 2:
@@ -163,6 +164,7 @@ def _extract_positional_args(
 ) -> Sequence[AnonPositionalArg]:
     result: list[AnonPositionalArg] = []
     for name, py_type in args:
+        validate_annotation(py_type)
         if name == "return":
             continue
         name = unmangle_keyword(name)

classiq/qmod/python_classical_type.py

@@ -30,16 +30,22 @@ CARRAY_ERROR_MESSAGE = (
 
 class PythonClassicalType:
     def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
-        if py_type is int or py_type is CInt:
+        if py_type is int:
+            return Integer().set_generative()
+        elif py_type is CInt:
             return Integer()
-        elif py_type in (float, complex) or py_type is CReal:
+        elif py_type in (float, complex):
+            return Real().set_generative()
+        elif py_type is CReal:
             return Real()
-        elif py_type is bool or py_type is CBool:
+        elif py_type is bool:
+            return Bool().set_generative()
+        elif py_type is CBool:
             return Bool()
         elif get_origin(py_type) is list:
             element_type = self.convert(get_args(py_type)[0])
             if element_type is not None:
-                return ClassicalList(element_type=element_type)
+                return ClassicalList(element_type=element_type).set_generative()
         elif get_origin(py_type) is CArray:
             array_args = version_portable_get_args(py_type)
             if len(array_args) == 1:

classiq/qmod/qmod_parameter.py

@@ -22,6 +22,11 @@ from classiq.qmod.cparam import (  # noqa: F401
     CParamScalar,
     CReal,
 )
+from classiq.qmod.generative import (
+    generative_mode_context,
+    interpret_expression,
+    is_generative_mode,
+)
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
@@ -66,6 +71,9 @@ class CParamList(CParam):
 
     @property
     def len(self) -> CParamScalar:
+        if is_generative_mode():
+            with generative_mode_context(False):
+                return interpret_expression(str(self.len))
         return CParamScalar(f"get_field({self}, 'len')")
 
 

classiq/qmod/qmod_variable.py

@@ -23,7 +23,7 @@ from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.qmod_qarray_proxy import (
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
     ILLEGAL_SLICE_MSG,
     ILLEGAL_SLICING_STEP_MSG,
 )
@@ -72,12 +72,6 @@ from classiq.qmod.utilities import (
 )
 
 
-def _is_input_output_typehint(type_hint: Any) -> bool:
-    return isinstance(type_hint, _AnnotatedAlias) and isinstance(
-        type_hint.__metadata__[0], PortDeclarationDirection
-    )
-
-
 def get_type_hint_expr(type_hint: Any) -> str:
     if isinstance(type_hint, ForwardRef):  # expression in string literal
         return str(type_hint.__forward_arg__)
@@ -143,9 +137,12 @@ class QVar(Symbolic):
 
     @staticmethod
     def from_type_hint(type_hint: Any) -> Optional[type["QVar"]]:
-        if _is_input_output_typehint(type_hint):
-            return QVar.from_type_hint(type_hint.__args__[0])
-        type_ = get_origin(type_hint) or type_hint
+        non_annotated_type = (
+            type_hint.__origin__
+            if isinstance(type_hint, _AnnotatedAlias)
+            else type_hint
+        )
+        type_ = get_origin(non_annotated_type) or non_annotated_type
         if issubclass(type_, QVar):
             if issubclass(type_, QStruct):
                 with _no_current_expandable():
@@ -170,10 +167,10 @@ class QVar(Symbolic):
 
     @classmethod
     def port_direction(cls, type_hint: Any) -> PortDeclarationDirection:
-        if _is_input_output_typehint(type_hint):
-            assert len(type_hint.__metadata__) >= 1
-            return type_hint.__metadata__[0]
-        assert type_hint == cls or get_origin(type_hint) == cls
+        if isinstance(type_hint, _AnnotatedAlias):
+            for metadata in type_hint.__metadata__:
+                if isinstance(metadata, PortDeclarationDirection):
+                    return metadata
         return PortDeclarationDirection.Inout
 
     def __str__(self) -> str:

classiq/qmod/quantum_callable.py

@@ -21,7 +21,7 @@ from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.source_reference import SourceReference
 
 from classiq.qmod.cparam import CInt
-from classiq.qmod.utilities import get_source_ref
+from classiq.qmod.utilities import get_source_ref, suppress_return_value
 
 if TYPE_CHECKING:
     from classiq.qmod.quantum_expandable import QTerminalCallable
@@ -48,6 +48,7 @@ class QCallable(Generic[P], ABC):
     CURRENT_EXPANDABLE: ClassVar[Optional[QExpandableInterface]] = None
     FRAME_DEPTH = 1
 
+    @suppress_return_value
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         assert QCallable.CURRENT_EXPANDABLE is not None
         source_ref = get_source_ref(sys._getframe(self.FRAME_DEPTH))

classiq/qmod/quantum_function.py

@@ -24,10 +24,11 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 
 from classiq.qmod.classical_function import CFunc
+from classiq.qmod.cparam import CParamAbstract
 from classiq.qmod.declaration_inferrer import infer_func_decl
 from classiq.qmod.generative import set_frontend_interpreter
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import CArray, CParam
+from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
@@ -308,7 +309,7 @@ def _validate_no_gen_params(annotations: dict[str, Any]) -> None:
         for name, annotation in annotations.items()
         if not (
             name == "return"
-            or (isclass(annotation) and issubclass(annotation, CParam))
+            or (isclass(annotation) and issubclass(annotation, CParamAbstract))
             or (isclass(annotation) and is_dataclass(annotation))
             or (isclass(annotation) and isinstance(annotation, EnumMeta))
             or get_origin(annotation) is CArray

classiq/qmod/semantics/annotation/call_annotation.py

@@ -3,18 +3,9 @@ from contextlib import contextmanager
 from typing import Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import Integer
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
 from classiq.interface.model.model import Model
 from classiq.interface.model.model_visitor import ModelVisitor
 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.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -24,36 +15,17 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
 )
-from classiq.interface.model.quantum_type import QuantumBitvector
 
 from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.lambdas import get_renamed_parameters
 
-ALLOCATE_DECL_FOR_COMPATIBILITY = QuantumFunctionDeclaration(
-    name="allocate",
-    positional_arg_declarations=[
-        ClassicalParameterDeclaration(
-            name="num_qubits",
-            classical_type=Integer(),
-        ),
-        PortDeclaration(
-            name="out",
-            quantum_type=QuantumBitvector(length=Expression(expr="num_qubits")),
-            direction=PortDeclarationDirection.Output,
-        ),
-    ],
-)
-
 
 def _annotate_function_call_decl(
     fc: QuantumFunctionCall,
     function_dict: Mapping[str, QuantumFunctionDeclaration],
 ) -> None:
-    if fc.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
-        fc.set_func_decl(ALLOCATE_DECL_FOR_COMPATIBILITY)
-        return
     if fc._func_decl is None:
         func_decl = function_dict.get(fc.func_name)
         if func_decl is None:

classiq/qmod/semantics/annotation/qstruct_annotator.py

@@ -9,8 +9,18 @@ class QStructAnnotator(ModelVisitor):
         self._visited: set[TypeName] = set()
 
     def visit_TypeName(self, type_name: TypeName) -> None:
+        self._annotate_quantum_struct(type_name)
+        self._annotate_classical_struct(type_name)
+
+    def _annotate_quantum_struct(self, type_name: TypeName) -> None:
+        if (
+            type_name.has_classical_struct_decl
+            or type_name.has_fields
+            or type_name in self._visited
+        ):
+            return
         decl = QMODULE.qstruct_decls.get(type_name.name)
-        if decl is None or type_name.has_fields or (type_name in self._visited):
+        if decl is None:
             return
         self._visited.add(type_name)
         new_fields = {
@@ -21,3 +31,13 @@ class QStructAnnotator(ModelVisitor):
         # qstructs
         self.visit(new_fields)
         type_name.set_fields(new_fields)
+
+    def _annotate_classical_struct(self, type_name: TypeName) -> None:
+        if type_name.has_classical_struct_decl or type_name.has_fields:
+            return
+        decl = QMODULE.type_decls.get(type_name.name)
+        if decl is None:
+            return
+        type_name.set_classical_struct_decl(decl)
+        for field_type in decl.variables.values():
+            self.visit(field_type)

classiq/qmod/semantics/error_manager.py

@@ -46,7 +46,7 @@ class ErrorManager:
         error: str,
         *,
         source_ref: Optional[SourceReference] = None,
-        function: Optional[str] = None
+        function: Optional[str] = None,
     ) -> None:
         if not self._ignore_errors:
             self._errors.append(

classiq/qmod/semantics/validation/main_validation.py

@@ -25,7 +25,7 @@ def _validate_main_classical_param_type(
 ) -> None:
     if isinstance(param, ClassicalList):
         raise ClassiqExpansionError(
-            f"Classical array parameter {param_name!r} of function 'main' must must "
+            f"Classical array parameter {param_name!r} of function 'main' must "
             f"specify array length",
         )
     if isinstance(param, ClassicalArray):

classiq/qmod/semantics/validation/type_hints.py

@@ -0,0 +1,29 @@
+from typing import Any
+
+from typing_extensions import _AnnotatedAlias
+
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+
+annotation_map: dict[PortDeclarationDirection, str] = {
+    PortDeclarationDirection.Input: PortDeclarationDirection.Input.name,
+    PortDeclarationDirection.Output: PortDeclarationDirection.Output.name,
+}
+
+
+def validate_annotation(type_hint: Any) -> None:
+    if not isinstance(type_hint, _AnnotatedAlias):
+        return
+    directions: list[PortDeclarationDirection] = [
+        direction
+        for direction in type_hint.__metadata__
+        if isinstance(direction, PortDeclarationDirection)
+    ]
+    if len(directions) <= 1:
+        return
+    raise ClassiqValueError(
+        f"Multiple directions are not allowed in a single type hint: "
+        f"[{', '.join(annotation_map[direction] for direction in reversed(directions))}]\n"
+    )

classiq/qmod/utilities.py

@@ -3,16 +3,33 @@ import inspect
 import itertools
 import keyword
 import sys
+from collections import Counter
 from collections.abc import Iterable
 from enum import Enum as PythonEnum
 from types import FrameType
-from typing import Any, ForwardRef, Literal, Optional, get_args, get_origin, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ForwardRef,
+    Literal,
+    Optional,
+    Union,
+    get_args,
+    get_origin,
+    overload,
+)
+
+from typing_extensions import ParamSpec
 
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.source_reference import SourceReference
 
+if TYPE_CHECKING:
+    from classiq.qmod.qmod_variable import QVar
+
 DEFAULT_DECIMAL_PRECISION = 4
 
 
@@ -132,3 +149,51 @@ def varname(depth: int) -> Optional[str]:
     if not var_name.isidentifier():
         return None
     return var_name
+
+
+Params = ParamSpec("Params")
+
+
+def suppress_return_value(func: Callable[Params, None]) -> Callable[Params, None]:
+    # An empty decorator suppresses mypy's func-returns-value error when assigning the
+    # return value of a None-returning function
+    return func
+
+
+Statements = Union[None, list[Union[None, "QVar"]], tuple[Union[None, "QVar"], ...]]
+
+
+def _eval_qnum(val: int, size: int, is_signed: bool, fraction_digits: int) -> float:
+    if val < 0 or val >= 2**size:
+        raise ValueError
+    if size == 1 and is_signed and fraction_digits == 1:
+        return -0.5 if val == 1 else 0
+    if is_signed and val & (1 << (size - 1)) > 0:
+        val ^= 1 << (size - 1)
+        val -= 1 << (size - 1)
+    return val * 2**-fraction_digits
+
+
+def qnum_values(size: int, is_signed: bool, fraction_digits: int) -> list[float]:
+    return [_eval_qnum(i, size, is_signed, fraction_digits) for i in range(2**size)]
+
+
+def qnum_attributes(max_size: int) -> list[tuple[int, bool, int]]:
+    return [(1, True, 1)] + [
+        (size, is_signed, fraction_digits)
+        for size in range(1, max_size + 1)
+        for is_signed in (False, True)
+        for fraction_digits in range(size - int(is_signed) + 1)
+    ]
+
+
+_VAR_NAME_COUNTER: Counter[str] = Counter()
+
+
+def get_temp_var_name(var_name: str = "temp") -> str:
+    n = _VAR_NAME_COUNTER[var_name]
+    _VAR_NAME_COUNTER[var_name] += 1
+    return f"{var_name}_{n}"
+
+
+RealFunction = Callable[Params, float]

classiq/synthesis.py

@@ -3,16 +3,15 @@ from typing import Any, NewType, Optional, Union
 import pydantic
 
 from classiq.interface.analyzer.result import QasmCode
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
-from classiq.interface.model.model import Model, SerializedModel
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedModel
 
 from classiq import QuantumProgram
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq.qmod.create_model_function import create_model
 from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
 
 SerializedQuantumProgram = NewType("SerializedQuantumProgram", str)
@@ -90,9 +89,13 @@ def synthesize(
         SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
     """
     if isinstance(model, (QFunc, GenerativeQFunc)):
-        serialized_model = create_model(
-            model, constraints=constraints, preferences=preferences
-        )
+        func_name = model._py_callable.__name__
+        if func_name != MAIN_FUNCTION_NAME:
+            raise ClassiqError(
+                f"The entry point function must be named 'main', got {func_name!r}"
+            )
+        model_obj = model.create_model(constraints=constraints, preferences=preferences)
+        serialized_model = model_obj.get_model()
     else:
         serialized_model = model
     result = async_utils.run(synthesize_async(serialized_model))