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

classiq/qmod/qmod_parameter.py

@@ -1,6 +1,12 @@
 import sys
-from typing import _GenericAlias  # type: ignore[attr-defined]
-from typing import Any, Generic, TypeVar, Union
+from typing import (  # type: ignore[attr-defined]
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    TypeVar,
+    Union,
+    _GenericAlias,
+)
 
 from typing_extensions import ParamSpec
 
@@ -19,8 +25,15 @@ from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 _T = TypeVar("_T")
 
 
-class QParam(Symbolic, Generic[_T]):
-    pass
+if TYPE_CHECKING:
+
+    class QParam(SymbolicExpr, Generic[_T]):
+        pass
+
+else:
+
+    class QParam(Symbolic, Generic[_T]):
+        pass
 
 
 class QParamScalar(QParam, SymbolicExpr):
@@ -46,10 +59,11 @@ class QParamList(QParam):
         )
 
     def __len__(self) -> int:
-        raise ValueError(
-            "len(<expr>) is not supported for QMod lists - use <expr>.len() instead"
+        raise ClassiqValueError(
+            "len(<expr>) is not supported for QMod lists - use <expr>.len instead"
         )
 
+    @property
     def len(self) -> QParamScalar:
         return QParamScalar(f"len({self})")
 
@@ -63,22 +77,31 @@ class QParamStruct(QParam):
         self._struct_type = struct_type
 
     def __getattr__(self, field_name: str) -> QParam:
+        return QParamStruct.get_field(
+            self._qmodule, str(self), self._struct_type.name, field_name
+        )
+
+    @staticmethod
+    def get_field(
+        qmodule: ModelStateContainer,
+        variable_name: str,
+        struct_name: str,
+        field_name: str,
+    ) -> QParam:
         struct_decl = StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.get(
-            self._struct_type.name
+            struct_name, qmodule.type_decls.get(struct_name)
         )
-        if struct_decl is None:
-            struct_decl = self._qmodule.type_decls.get(self._struct_type.name)
         assert struct_decl is not None
         field_type = struct_decl.variables.get(field_name)
         if field_type is None:
             raise ClassiqValueError(
-                f"Struct {self._struct_type.name!r} doesn't have field {field_name!r}"
+                f"Struct {struct_name!r} doesn't have field {field_name!r}"
             )
 
         return create_param(
-            f"get_field({self},{field_name!r})",
+            f"get_field({variable_name},{field_name!r})",
             field_type,
-            qmodule=self._qmodule,
+            qmodule=qmodule,
         )
 
 
@@ -100,7 +123,7 @@ class Array(ArrayBase[_P]):
 def create_param(
     expr_str: str, ctype: ClassicalType, qmodule: ModelStateContainer
 ) -> QParam:
-    if isinstance(ctype, ClassicalList) or isinstance(ctype, ClassicalArray):
+    if isinstance(ctype, (ClassicalList, ClassicalArray)):
         return QParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
         return QParamStruct(expr_str, ctype, qmodule=qmodule)

classiq/qmod/qmod_struct.py

@@ -1,5 +1,5 @@
 import dataclasses
-from typing import Any, List, Type
+from typing import Any, Type
 
 from typing_extensions import dataclass_transform
 
@@ -16,7 +16,7 @@ def _qmod_val_to_expr_str(val: Any) -> str:
         )
         return f"struct_literal({type(val).__name__}, {kwargs_str})"
 
-    if isinstance(val, List):
+    if isinstance(val, list):
         elements_str = ", ".join([_qmod_val_to_expr_str(elem) for elem in val])
         return f"[{elements_str}]"
 
@@ -24,7 +24,7 @@ def _qmod_val_to_expr_str(val: Any) -> str:
 
 
 @dataclass_transform()
-def QStruct(user_class: Type) -> Type:  # noqa: N802 - for consistency with 'QFunc'
+def struct(user_class: Type) -> Type:
     def _new_repr(self: Any) -> str:
         return _qmod_val_to_expr_str(self)
 

classiq/qmod/qmod_variable.py

@@ -1,6 +1,7 @@
 import abc
+import sys
 from contextlib import contextmanager
-from typing import (
+from typing import (  # type: ignore[attr-defined]
     TYPE_CHECKING,
     Any,
     ForwardRef,
@@ -12,8 +13,10 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    _GenericAlias,
     get_args,
     get_origin,
+    overload,
 )
 
 from typing_extensions import Annotated, ParamSpec, Self, _AnnotatedAlias
@@ -22,7 +25,11 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -40,11 +47,14 @@ from classiq.interface.model.quantum_type import (
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.qmod_parameter import ArrayBase, QParam, QParamScalar
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.symbolic_expr import SymbolicExpr
+from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
+from classiq.qmod.utilities import version_portable_get_args
 
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
 SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
+UNSUPPORTED_ELEMENT_TYPE = "Only QBit is supported as element type for QArray"
+QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
 
 
 def _is_input_output_typehint(type_hint: Any) -> bool:
@@ -183,22 +193,72 @@ class QBit(QScalar):
         return QuantumBit()
 
 
-_T = TypeVar("_T")
+_P = ParamSpec("_P")
 
 
-class QNum(Generic[_T], QScalar):
+class QNum(Generic[_P], QScalar):
     QMOD_TYPE = QuantumNumeric
 
+    @overload
+    def __init__(self, name: str):
+        pass
+
+    @overload
+    def __init__(
+        self,
+        name: str,
+        size: Union[int, QParam[int]],
+        is_signed: Union[bool, QParam[bool]],
+        fraction_digits: Union[int, QParam[int]],
+    ):
+        pass
+
+    def __init__(
+        self,
+        name: str,
+        size: Union[int, QParam[int], None] = None,
+        is_signed: Union[bool, QParam[bool], None] = None,
+        fraction_digits: Union[int, QParam[int], None] = None,
+    ):
+        if (
+            size is None
+            and (is_signed is not None or fraction_digits is not None)
+            or size is not None
+            and (is_signed is None or fraction_digits is None)
+        ):
+            raise ClassiqValueError(
+                "Assign none or all of size, is_signed, and fraction_digits"
+            )
+        self._size = None if size is None else Expression(expr=str(size))
+        self._is_signed = None if is_signed is None else Expression(expr=str(is_signed))
+        self._fraction_digits = (
+            None if fraction_digits is None else Expression(expr=str(fraction_digits))
+        )
+        super().__init__(name)
+
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
-        size_expr: Optional[Expression] = None
-        if get_args(type_hint):
-            size_expr = Expression(expr=get_type_hint_expr(get_args(type_hint)[0]))
-
-        return cls.QMOD_TYPE(size=size_expr)
+        type_args = get_args(type_hint)
+        if len(type_args) == 0:
+            return cls.QMOD_TYPE()
+        type_args = type_args[0]
+        if len(type_args) != 3:
+            raise ClassiqValueError(
+                "QNum receives three type arguments: QNum[size: int | QParam[int], "
+                "is_signed: bool | QParam[bool], fraction_digits: int | QParam[int]]"
+            )
+        return cls.QMOD_TYPE(
+            size=Expression(expr=get_type_hint_expr(type_args[0])),
+            is_signed=Expression(expr=get_type_hint_expr(type_args[1])),
+            fraction_digits=Expression(expr=get_type_hint_expr(type_args[2])),
+        )
 
     def get_qmod_type(self) -> QuantumType:
-        return self.QMOD_TYPE()
+        return self.QMOD_TYPE(
+            size=self._size,
+            is_signed=self._is_signed,
+            fraction_digits=self._fraction_digits,
+        )
 
     @property
     def size(self) -> QParamScalar:
@@ -212,62 +272,119 @@ class QNum(Generic[_T], QScalar):
     def is_signed(self) -> QParamScalar:
         return QParamScalar(f"is_signed({self._name})")
 
+    # Support comma-separated generic args in older Python versions
+    if sys.version_info[0:2] < (3, 10):
 
-_P = ParamSpec("_P")
+        def __class_getitem__(cls, args) -> _GenericAlias:
+            return _GenericAlias(cls, args)
 
 
 class QArray(ArrayBase[_P], QVar):
-    def __init__(self, name: str, slice_: Optional[Tuple[int, int]] = None) -> None:
-        super().__init__(name)
+    def __init__(
+        self,
+        name: str,
+        element_type: _GenericAlias = QBit,
+        length: Optional[Union[int, QParam[int]]] = None,
+        # TODO [CAD-18620]: improve type hints
+        slice_: Optional[Tuple[int, int]] = None,
+        index_: Optional[Union[int, QParam[int]]] = None,
+    ) -> None:
+        if element_type is not QBit:
+            raise ClassiqValueError(UNSUPPORTED_ELEMENT_TYPE)
+        self._element_type = element_type
+        self._length = length
         self._slice = slice_
+        self._index = index_
+        super().__init__(name)
 
     def get_handle_binding(self) -> HandleBinding:
-        if self._slice is None:
-            return HandleBinding(name=self._name)
-        return SlicedHandleBinding(
-            name=self._name,
-            start=Expression(expr=str(self._slice[0])),
-            end=Expression(expr=str(self._slice[1])),
-        )
+        if self._index is not None:
+            return SubscriptHandleBinding(
+                name=self._name,
+                index=Expression(expr=str(self._index)),
+            )
+
+        if self._slice is not None:
+            return SlicedHandleBinding(
+                name=self._name,
+                start=Expression(expr=str(self._slice[0])),
+                end=Expression(expr=str(self._slice[1])),
+            )
+
+        return HandleBinding(name=self._name)
 
     def __getitem__(self, key: Union[slice, int, QParam]) -> "QArray":
-        offset = self._slice[0] if self._slice is not None else 0
+        if self._index is not None:
+            raise ClassiqValueError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
+
+        # TODO [CAD-18620]: improve type hints
+        new_index: Optional[Any] = None
+
         if isinstance(key, slice):
             if key.step is not None:
-                raise NotImplementedError(ILLEGAL_SLICING_STEP_MSG)
-            new_slice = (offset + key.start, offset + key.stop)
+                raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+            new_slice = self._get_new_slice(key.start, key.stop)
+
         else:
             if isinstance(key, QParam) and not isinstance(key, QParamScalar):
                 raise ClassiqValueError("Non-classical parameter for slicing")
-            new_slice = (offset + key, offset + key + 1)
-        if self._slice is not None and new_slice[1] > self._slice[1]:
+            new_slice = self._get_new_slice(key, key + 1)
+            new_index = new_slice[0]
+
+        if (
+            self._slice is not None
+            and not isinstance(new_slice[1], Symbolic)
+            and not isinstance(self._slice[1], Symbolic)
+            and new_slice[1] > self._slice[1]
+        ) or (
+            self._length is not None
+            and not isinstance(new_slice[1], Symbolic)
+            and not isinstance(self._length, Symbolic)
+            and new_slice[1] > self._length
+        ):
             raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
         # prevent addition to local handles, since this is used for slicing existing local handles
         with _no_current_expandable():
-            return QArray(self._name, slice_=new_slice)
+            return QArray(
+                self._name, length=self._length, slice_=new_slice, index_=new_index
+            )
+
+    # TODO [CAD-18620]: improve type hints
+    def _get_new_slice(self, start: Any, end: Any) -> Tuple[Any, Any]:
+        if self._slice is not None:
+            return (self._slice[0] + start, self._slice[0] + end)
+        return (start, end)
 
     def __len__(self) -> int:
-        raise ValueError(
-            "len(<var>) is not supported for quantum variables - use <var>.len() instead"
+        raise ClassiqValueError(
+            "len(<var>) is not supported for quantum variables - use <var>.len instead"
         )
 
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
     else:
 
+        @property
         def len(self) -> QParamScalar:
+            if self._length is not None:
+                return QParamScalar(f"{self._length}")
             return QParamScalar(f"len({self._name})")
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
         length_expr: Optional[Expression] = None
-        if len(get_args(type_hint)) == 2:
-            length_expr = Expression(expr=get_type_hint_expr(get_args(type_hint)[1]))
+        if len(version_portable_get_args(type_hint)) == 2:
+            length_expr = Expression(
+                expr=get_type_hint_expr(version_portable_get_args(type_hint)[1])
+            )
         return QuantumBitvector(length=length_expr)
 
     def get_qmod_type(self) -> QuantumType:
+        if self._length is not None:
+            return QuantumBitvector(length=Expression(expr=str(self._length)))
         return QuantumBitvector()
 
 

classiq/qmod/quantum_callable.py

@@ -68,6 +68,7 @@ class QCallable(Generic[P], ABC):
 class QCallableList(QCallable, Generic[P], ABC):
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
         def __getitem__(self, key: Union[slice, int, QParam]) -> "QTerminalCallable":

classiq/qmod/quantum_expandable.py

@@ -1,3 +1,4 @@
+import inspect
 from abc import ABC
 from types import TracebackType
 from typing import (
@@ -25,14 +26,13 @@ from classiq.interface.model.quantum_function_call import (
     ArgValue,
     OperandIdentifier,
     QuantumFunctionCall,
-    QuantumLambdaFunction,
-    QuantumOperand,
 )
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -41,6 +41,7 @@ from classiq.interface.model.variable_declaration_statement import (
 
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
+from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import QParam, QParamScalar, create_param
 from classiq.qmod.qmod_variable import QVar, create_qvar_for_port_decl
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
@@ -96,9 +97,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
         for arg in self.func_decl.get_positional_arg_decls():
             if isinstance(arg, ClassicalParameterDeclaration):
                 rename_dict = self.infer_rename_params()
-                actual_name = (
-                    rename_dict[arg.name] if arg.name in rename_dict else arg.name
-                )
+                actual_name = rename_dict.get(arg.name, arg.name)
                 result.append(
                     create_param(actual_name, arg.classical_type, self._qmodule)
                 )
@@ -126,17 +125,12 @@ class QLambdaFunction(QExpandable):
         return self._decl
 
     def infer_rename_params(self) -> Dict[str, str]:
-        if not self._py_callable.__annotations__:
-            return {}
+        py_params = inspect.getfullargspec(self._py_callable)
+        decl_params = self.func_decl.param_decls.keys()
         return {
-            decl_name: actual_name
-            for decl_name, actual_name in list(
-                zip(
-                    [arg.name for arg in self.func_decl.get_positional_arg_decls()],
-                    self._py_callable.__annotations__.keys(),
-                )
-            )
-            if decl_name != actual_name
+            decl_param: py_param
+            for decl_param, py_param in zip(decl_params, py_params.args)
+            if decl_param != py_param
         }
 
 
@@ -163,16 +157,18 @@ class QTerminalCallable(QCallable):
         return QTerminalCallable(self._decl, key)
 
     def __len__(self) -> int:
-        raise ValueError(
-            "len(<func>) is not supported for quantum callables - use <func>.len() instead (Only if it is an operand list)"
+        raise ClassiqValueError(
+            "len(<func>) is not supported for quantum callables - use <func>.len instead (Only if it is an operand list)"
         )
 
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
     else:
 
+        @property
         def len(self) -> QParamScalar:
             if not self.is_list:
                 raise ClassiqValueError("Cannot get length of a non-list operand")
@@ -196,8 +192,8 @@ class QTerminalCallable(QCallable):
 
 @overload
 def prepare_arg(
-    arg_decl: PositionalArg, val: Union[QCallable, Callable[[Any], None]]
-) -> QuantumOperand: ...
+    arg_decl: PositionalArg, val: Union[QCallable, Callable[..., None]]
+) -> QuantumLambdaFunction: ...
 
 
 @overload
@@ -205,6 +201,9 @@ def prepare_arg(arg_decl: PositionalArg, val: Any) -> ArgValue: ...
 
 
 def prepare_arg(arg_decl: PositionalArg, val: Any) -> ArgValue:
+    if isinstance(val, QConstant):
+        val.add_to_model()
+        return Expression(expr=str(val.name))
     if isinstance(arg_decl, ClassicalParameterDeclaration):
         return Expression(expr=str(val))
     elif isinstance(arg_decl, PortDeclaration):

classiq/qmod/quantum_function.py

@@ -1,3 +1,4 @@
+import ast
 import functools
 from typing import Any, Callable, Dict, List, Optional, Tuple, get_origin
 
@@ -13,6 +14,7 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.exceptions import ClassiqError
 from classiq.qmod.classical_function import CFunc
 from classiq.qmod.declaration_inferrer import infer_func_decl
+from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import QParam
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
@@ -32,6 +34,10 @@ def create_model(
     preferences: Optional[Preferences] = None,
     classical_execution_function: Optional[CFunc] = None,
 ) -> SerializedModel:
+    if entry_point.func_decl.name != "main":
+        raise ClassiqError(
+            f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
+        )
     return entry_point.create_model(
         constraints, execution_preferences, preferences, classical_execution_function
     ).get_model()
@@ -63,21 +69,23 @@ class QFunc(QExpandable):
     ) -> Model:
         self._qmodule.type_decls = dict()
         self._qmodule.native_defs = dict()
+        self._qmodule.constants = dict()
+        QConstant.set_current_model(self._qmodule)
         self._add_native_func_def()
         model_extra_settings: List[Tuple[str, Any]] = [
             ("constraints", constraints),
             ("execution_preferences", execution_preferences),
             ("preferences", preferences),
         ]
-        classical_execution_function = (
-            CFunc.default_cmain()
-            if classical_execution_function is None
-            else classical_execution_function
-        )
+        if classical_execution_function is not None:
+            self._add_constants_from_classical_code(classical_execution_function)
+            model_extra_settings.append(
+                ("classical_execution_code", classical_execution_function.code)
+            )
         return Model(
+            constants=list(self._qmodule.constants.values()),
             functions=list(self._qmodule.native_defs.values()),
             types=list(self._qmodule.type_decls.values()),
-            classical_execution_code=classical_execution_function.code,
             **{key: value for key, value in model_extra_settings if value},
         )
 
@@ -89,18 +97,43 @@ class QFunc(QExpandable):
             **self.func_decl.__dict__, body=self.body
         )
 
+    def _add_constants_from_classical_code(
+        self, classical_execution_function: CFunc
+    ) -> None:
+        # FIXME: https://classiq.atlassian.net/browse/CAD-18050
+        # We use this visitor to add the constants that were used in the classical
+        # execution code to the model. In the future, if we will have a better notion
+        # of "QModule" and a "QConstant" will be a part of it then we may be able to
+        # remove the handling of the QConstants from this visitor, but I think we will
+        # need similar logic to allow using python variables in the classical execution
+        # code
+        class IdentifierVisitor(ast.NodeVisitor):
+            def visit_Name(self, node: ast.Name) -> None:
+                if (
+                    node.id in classical_execution_function._caller_constants
+                    and isinstance(
+                        classical_execution_function._caller_constants[node.id],
+                        QConstant,
+                    )
+                ):
+                    classical_execution_function._caller_constants[
+                        node.id
+                    ].add_to_model()
+
+        IdentifierVisitor().visit(ast.parse(classical_execution_function.code))
+
 
 class ExternalQFunc(QTerminalCallable):
     def __init__(self, py_callable: Callable) -> None:
         decl = _lookup_qfunc(unmangle_keyword(py_callable.__name__))
         if decl is None:
-            raise ValueError(f"Definition of {py_callable.__name__!r} not found")
+            raise ClassiqError(f"Definition of {py_callable.__name__!r} not found")
 
         py_callable.__annotations__.pop("return", None)
         if py_callable.__annotations__.keys() != {
             mangle_keyword(arg.name) for arg in decl.get_positional_arg_decls()
         }:
-            raise ValueError(
+            raise ClassiqError(
                 f"Parameter type hints for {py_callable.__name__!r} do not match imported declaration"
             )
         super().__init__(decl)

classiq/qmod/symbolic.py

@@ -1,7 +1,10 @@
 import sys
-from typing import Tuple
+from typing import List, Optional, Tuple, Type, get_args, get_origin, overload
 
-from classiq.qmod.qmod_parameter import QParamScalar
+from classiq.exceptions import ClassiqValueError
+from classiq.qmod import model_state_container
+from classiq.qmod.declaration_inferrer import python_type_to_qmod
+from classiq.qmod.qmod_parameter import QParam, QParamScalar, create_param
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 
@@ -13,9 +16,44 @@ EulerGamma = SymbolicExpr("EulerGamma")
 Catalan = SymbolicExpr("Catalan")
 
 
-def symbolic_function(*args: SymbolicTypes) -> QParamScalar:
+@overload
+def symbolic_function(
+    *args: SymbolicTypes, return_type: None = None
+) -> QParamScalar: ...
+
+
+@overload
+def symbolic_function(*args: SymbolicTypes, return_type: Type[QParam]) -> QParam: ...
+
+
+def symbolic_function(
+    *args: SymbolicTypes, return_type: Optional[Type[QParam]] = None
+) -> QParam:
+    qmodule = (
+        model_state_container.QMODULE
+    )  # FIXME: https://classiq.atlassian.net/browse/CAD-15126
     str_args = [str(x) for x in args]
-    return QParamScalar(f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})")
+    expr = f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})"
+
+    if return_type is None:
+        return QParamScalar(expr)
+
+    if get_origin(return_type) is not QParam:
+        raise ClassiqValueError(
+            f"Unsupported return type for symbolic function: {return_type}"
+        )
+
+    qmod_type = python_type_to_qmod(get_args(return_type)[0], qmodule=qmodule)
+    if qmod_type is None:
+        raise ClassiqValueError(
+            f"Unsupported return type for symbolic function: {return_type}"
+        )
+
+    return create_param(
+        expr,
+        qmod_type,
+        qmodule,
+    )
 
 
 def sin(x: SymbolicTypes) -> QParamScalar:
@@ -238,6 +276,10 @@ def logical_not(x: SymbolicTypes) -> SymbolicExpr:
     return SymbolicExpr._unary_op(x, "not")
 
 
+def mod_inverse(a: SymbolicTypes, m: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(a, m)
+
+
 __all__ = [
     "pi",
     "E",
@@ -300,8 +342,9 @@ __all__ = [
     "logical_and",
     "logical_or",
     "logical_not",
+    "mod_inverse",
 ]
 
 
-def __dir__():
+def __dir__() -> List[str]:
     return __all__