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

classiq/qmod/semantics/validation/types_validation.py

@@ -0,0 +1,128 @@
+from collections.abc import Sequence
+from typing import Union
+
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.quantum_type import QuantumBitvector
+
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+def check_duplicate_types(
+    types: Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]]
+) -> None:
+    known_types = {type_.name for type_ in BUILTIN_ENUM_DECLARATIONS.values()}
+    known_types |= {type_.name for type_ in BUILTIN_STRUCT_DECLARATIONS.values()}
+    for type_ in types:
+        if type_.name in known_types:
+            with ErrorManager().node_context(type_):
+                ErrorManager().add_error(f"Type {type_.name!r} already exists")
+        else:
+            known_types.add(type_.name)
+
+
+def check_qstruct_flexibility(qstruct: QStructDeclaration) -> None:
+    _check_qstruct_no_array_without_size_and_element_size(qstruct)
+    _check_qstruct_at_most_one_type_without_size(qstruct)
+
+
+def _check_qstruct_no_array_without_size_and_element_size(
+    qstruct: QStructDeclaration,
+) -> None:
+    offending_array_fields = [
+        field_name
+        for field_name, field_type in qstruct.fields.items()
+        if isinstance(field_type, QuantumBitvector)
+        and not field_type.has_length
+        and not field_type.element_type.has_size_in_bits
+    ]
+    if len(offending_array_fields) > 0:
+        with ErrorManager().node_context(qstruct):
+            ErrorManager().add_error(
+                f"Quantum struct {qstruct.name} contains arrays whose neither length "
+                f"nor element size are constants. Offending fields: "
+                f"{', '.join(offending_array_fields)}"
+            )
+
+
+def _check_qstruct_at_most_one_type_without_size(qstruct: QStructDeclaration) -> None:
+    fields_without_size = [
+        field_name
+        for field_name, field_type in qstruct.fields.items()
+        if not field_type.has_size_in_bits
+    ]
+    if len(fields_without_size) > 1:
+        with ErrorManager().node_context(qstruct):
+            ErrorManager().add_error(
+                f"Quantum struct {qstruct.name} has more than one field whose size is "
+                f"not constant. Offending fields: {', '.join(fields_without_size)}"
+            )
+
+
+def check_qstruct_fields_are_defined(qstruct: QStructDeclaration) -> bool:
+    all_defined = True
+    for field_type in qstruct.fields.values():
+        if (
+            isinstance(field_type, TypeName)
+            and field_type.name not in QMODULE.qstruct_decls
+        ):
+            with ErrorManager().node_context(field_type):
+                ErrorManager().add_error(
+                    f"Quantum struct {field_type.name!r} is not defined."
+                )
+            all_defined = False
+    return all_defined
+
+
+def check_qstruct_has_fields(qstruct: QStructDeclaration) -> None:
+    if len(qstruct.fields) == 0:
+        with ErrorManager().node_context(qstruct):
+            ErrorManager().add_error(
+                f"Quantum struct {qstruct.name!r} must have at least one field."
+            )
+
+
+def check_cstruct_has_fields(cstruct: StructDeclaration) -> None:
+    if len(cstruct.variables) == 0:
+        with ErrorManager().node_context(cstruct):
+            ErrorManager().add_error(
+                f"Classical struct {cstruct.name!r} must have at least one field."
+            )
+
+
+def check_qstruct_is_not_recursive(qstruct: QStructDeclaration) -> bool:
+    non_recursive = True
+    for main_field_name, main_field in qstruct.fields.items():
+        if (
+            not isinstance(main_field, TypeName)
+            or main_field.name not in QMODULE.qstruct_decls
+        ):
+            continue
+        main_field_qstruct = QMODULE.qstruct_decls[main_field.name]
+        seen_qstructs = {qstruct.name}
+        stack = [main_field_qstruct]
+        while stack:
+            qstruct = stack.pop()
+            if qstruct.name in seen_qstructs:
+                with ErrorManager().node_context(qstruct):
+                    ErrorManager().add_error(
+                        f"Declaration of field {main_field_name!r} in quantum struct "
+                        f"{qstruct.name!r} creates a recursive definition."
+                    )
+                non_recursive = False
+                break
+            seen_qstructs.add(qstruct.name)
+            stack.extend(
+                [
+                    QMODULE.qstruct_decls[field.name]
+                    for field in qstruct.fields.values()
+                    if isinstance(field, TypeName)
+                    and field.name in QMODULE.qstruct_decls
+                ]
+            )
+    return non_recursive

classiq/qmod/symbolic.py

@@ -1,228 +1,277 @@
 import sys
-from typing import Tuple
-
-from classiq.qmod.qmod_parameter import QParamScalar
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from classiq.interface.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 (
+    CArray,
+    CParam,
+    CParamScalar,
+    CReal,
+    create_param,
+)
+from classiq.qmod.qmod_variable import QNum
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 
-pi = SymbolicExpr("pi")
-E = SymbolicExpr("E")
-I = SymbolicExpr("I")  # noqa: E741
-GoldenRatio = SymbolicExpr("GoldenRatio")
-EulerGamma = SymbolicExpr("EulerGamma")
-Catalan = SymbolicExpr("Catalan")
+pi = SymbolicExpr("pi", False)
+E = SymbolicExpr("E", False)
+I = SymbolicExpr("I", False)  # noqa: E741
+GoldenRatio = SymbolicExpr("GoldenRatio", False)
+EulerGamma = SymbolicExpr("EulerGamma", False)
+Catalan = SymbolicExpr("Catalan", False)
+
+T = TypeVar("T", bound=CParam)
+
+
+@overload
+def symbolic_function(*args: Any, return_type: None = None) -> CParamScalar: ...
 
 
-def symbolic_function(*args: SymbolicTypes) -> QParamScalar:
+@overload
+def symbolic_function(*args: Any, return_type: type[T]) -> T: ...
+
+
+def symbolic_function(*args: Any, return_type: Optional[type[T]] = None) -> CParam:
+    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 CParamScalar(expr)
 
+    if TYPE_CHECKING:
+        assert return_type is not None
 
-def sin(x: SymbolicTypes) -> QParamScalar:
+    qmod_type = python_type_to_qmod(return_type, 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) -> CParamScalar:
     return symbolic_function(x)
 
 
-def cos(x: SymbolicTypes) -> QParamScalar:
+def cos(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def tan(x: SymbolicTypes) -> QParamScalar:
+def tan(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def cot(x: SymbolicTypes) -> QParamScalar:
+def cot(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def sec(x: SymbolicTypes) -> QParamScalar:
+def sec(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def csc(x: SymbolicTypes) -> QParamScalar:
+def csc(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def asin(x: SymbolicTypes) -> QParamScalar:
+def asin(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acos(x: SymbolicTypes) -> QParamScalar:
+def acos(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def atan(x: SymbolicTypes) -> QParamScalar:
+def atan(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acot(x: SymbolicTypes) -> QParamScalar:
+def acot(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def asec(x: SymbolicTypes) -> QParamScalar:
+def asec(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acsc(x: SymbolicTypes) -> QParamScalar:
+def acsc(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def sinh(x: SymbolicTypes) -> QParamScalar:
+def sinh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def cosh(x: SymbolicTypes) -> QParamScalar:
+def cosh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def tanh(x: SymbolicTypes) -> QParamScalar:
+def tanh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def coth(x: SymbolicTypes) -> QParamScalar:
+def coth(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def sech(x: SymbolicTypes) -> QParamScalar:
+def sech(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def csch(x: SymbolicTypes) -> QParamScalar:
+def csch(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def asinh(x: SymbolicTypes) -> QParamScalar:
+def asinh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acosh(x: SymbolicTypes) -> QParamScalar:
+def acosh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def atanh(x: SymbolicTypes) -> QParamScalar:
+def atanh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acoth(x: SymbolicTypes) -> QParamScalar:
+def acoth(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def asech(x: SymbolicTypes) -> QParamScalar:
+def asech(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def exp(x: SymbolicTypes) -> QParamScalar:
+def exp(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def log(x: SymbolicTypes, base: SymbolicTypes = E) -> QParamScalar:
+def log(x: SymbolicTypes, base: SymbolicTypes = E) -> CParamScalar:
     return symbolic_function(x, base)
 
 
-def ln(x: SymbolicTypes) -> QParamScalar:
+def ln(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def sqrt(x: SymbolicTypes) -> QParamScalar:
+def sqrt(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def abs(x: SymbolicTypes) -> QParamScalar:
+def abs(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def floor(x: SymbolicTypes) -> QParamScalar:
+def floor(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def ceiling(x: SymbolicTypes) -> QParamScalar:
+def ceiling(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def erf(x: SymbolicTypes) -> QParamScalar:
+def erf(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def erfc(x: SymbolicTypes) -> QParamScalar:
+def erfc(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def gamma(x: SymbolicTypes) -> QParamScalar:
+def gamma(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def beta(x: SymbolicTypes) -> QParamScalar:
+def beta(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def besselj(x: SymbolicTypes) -> QParamScalar:
+def besselj(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def bessely(x: SymbolicTypes) -> QParamScalar:
+def bessely(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def besseli(x: SymbolicTypes) -> QParamScalar:
+def besseli(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def besselk(x: SymbolicTypes) -> QParamScalar:
+def besselk(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def dirichlet_eta(x: SymbolicTypes) -> QParamScalar:
+def dirichlet_eta(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def polygamma(x: SymbolicTypes) -> QParamScalar:
+def polygamma(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def loggamma(x: SymbolicTypes) -> QParamScalar:
+def loggamma(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def factorial(x: SymbolicTypes) -> QParamScalar:
+def factorial(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def binomial(x: SymbolicTypes) -> QParamScalar:
+def binomial(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def subfactorial(x: SymbolicTypes) -> QParamScalar:
+def subfactorial(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def primorial(x: SymbolicTypes) -> QParamScalar:
+def primorial(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def bell(x: SymbolicTypes) -> QParamScalar:
+def bell(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def bernoulli(x: SymbolicTypes) -> QParamScalar:
+def bernoulli(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def euler(x: SymbolicTypes) -> QParamScalar:
+def euler(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def catalan(x: SymbolicTypes) -> QParamScalar:
+def catalan(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> QParamScalar:  # noqa: N802
+def Piecewise(*args: tuple[SymbolicTypes, SymbolicTypes]) -> CParamScalar:  # noqa: N802
     return symbolic_function(*args)
 
 
-def max(x: SymbolicTypes, y: SymbolicTypes) -> QParamScalar:
+def max(x: SymbolicTypes, y: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x, y)
 
 
-def min(x: SymbolicTypes, y: SymbolicTypes) -> QParamScalar:
+def min(x: SymbolicTypes, y: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x, y)
 
 
@@ -238,70 +287,88 @@ def logical_not(x: SymbolicTypes) -> SymbolicExpr:
     return SymbolicExpr._unary_op(x, "not")
 
 
+def mod_inverse(a: SymbolicTypes, m: SymbolicTypes) -> CParamScalar:
+    return symbolic_function(a, m)
+
+
+def sum(arr: SymbolicTypes) -> CParamScalar:
+    return symbolic_function(arr)
+
+
+def subscript(
+    amplitudes: Union[list[float], list[CReal], list[CParamScalar], CArray[CReal]],
+    index: QNum,
+) -> CParamScalar:
+    return CParamScalar(expr=f"{amplitudes}[{index}]")
+
+
 __all__ = [
-    "pi",
+    "Catalan",
     "E",
-    "I",
-    "GoldenRatio",
     "EulerGamma",
-    "Catalan",
-    "sin",
-    "cos",
-    "tan",
-    "cot",
-    "sec",
-    "csc",
-    "asin",
+    "GoldenRatio",
+    "I",
+    "Piecewise",
+    "abs",
     "acos",
-    "atan",
+    "acosh",
     "acot",
-    "asec",
+    "acoth",
     "acsc",
-    "sinh",
-    "cosh",
-    "tanh",
-    "coth",
-    "sech",
-    "csch",
+    "asec",
+    "asech",
+    "asin",
     "asinh",
-    "acosh",
+    "atan",
     "atanh",
-    "acoth",
-    "asech",
-    "exp",
-    "log",
-    "ln",
-    "sqrt",
-    "abs",
-    "floor",
+    "bell",
+    "bernoulli",
+    "besseli",
+    "besselj",
+    "besselk",
+    "bessely",
+    "beta",
+    "binomial",
+    "catalan",
     "ceiling",
+    "cos",
+    "cosh",
+    "cot",
+    "coth",
+    "csc",
+    "csch",
+    "dirichlet_eta",
     "erf",
     "erfc",
+    "euler",
+    "exp",
+    "factorial",
+    "floor",
     "gamma",
-    "beta",
-    "besselj",
-    "bessely",
-    "besseli",
-    "besselk",
-    "dirichlet_eta",
-    "polygamma",
+    "ln",
+    "log",
     "loggamma",
-    "factorial",
-    "binomial",
-    "subfactorial",
-    "primorial",
-    "bell",
-    "bernoulli",
-    "euler",
-    "catalan",
-    "Piecewise",
-    "max",
-    "min",
     "logical_and",
-    "logical_or",
     "logical_not",
+    "logical_or",
+    "max",
+    "min",
+    "mod_inverse",
+    "pi",
+    "polygamma",
+    "primorial",
+    "sec",
+    "sech",
+    "sin",
+    "sinh",
+    "sqrt",
+    "subfactorial",
+    "subscript",
+    "sum",
+    "tan",
+    "tanh",
 ]
 
 
-def __dir__():
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/symbolic_expr.py

@@ -1,42 +1,66 @@
 from __future__ import annotations
 
+import ast
+from enum import Enum as PythonEnum
 from typing import Any
 
+from classiq.qmod.utilities import qmod_val_to_expr_str
+
 
 class Symbolic:
-    def __init__(self, expr: str) -> None:
+    def __init__(self, expr: str, is_quantum: bool) -> None:
         self._expr = expr
+        self.is_quantum = is_quantum
 
     def __str__(self) -> str:
         return self._expr
 
     def __repr__(self) -> str:
-        return self._expr
+        return self.__str__()
+
+    def __bool__(self) -> bool:
+        try:
+            return bool(ast.literal_eval(self._expr))
+        except ValueError:
+            raise TypeError(
+                f"Symbolic expression {self._expr!r} cannot be converted to bool"
+            ) from None
 
 
 class SymbolicExpr(Symbolic):
-    def __init__(self, expr: str) -> None:
-        super().__init__(expr)
+    def __init__(self, expr: str, is_quantum: bool) -> None:
+        super().__init__(expr, is_quantum)
 
     @staticmethod
     def _binary_op(lhs: Any, rhs: Any, op: str) -> SymbolicExpr:
-        if not isinstance(lhs, (SymbolicExpr, int, float, bool)):
+        if not isinstance(lhs, (SymbolicExpr, int, float, bool, PythonEnum)):
             raise TypeError(f"Invalid lhs argument {lhs!r} for binary operation {op!r}")
 
-        if not isinstance(rhs, (SymbolicExpr, int, float, bool)):
+        if not isinstance(rhs, (SymbolicExpr, int, float, bool, PythonEnum)):
             raise TypeError(f"Invalid lhs argument {rhs!r} for binary operation {op!r}")
 
-        lhs_str = str(lhs) if isinstance(lhs, (int, float, bool)) else f"({lhs})"
-        rhs_str = str(rhs) if isinstance(rhs, (int, float, bool)) else f"({rhs})"
+        lhs_str = qmod_val_to_expr_str(lhs)
+        if not isinstance(lhs, (int, float, bool, PythonEnum)):
+            lhs_str = f"({lhs_str})"
+        rhs_str = qmod_val_to_expr_str(rhs)
+        if not isinstance(rhs, (int, float, bool, PythonEnum)):
+            rhs_str = f"({rhs_str})"
 
-        return SymbolicExpr(f"{lhs_str} {op} {rhs_str}")
+        lhs_is_quantum = isinstance(lhs, SymbolicExpr) and lhs.is_quantum
+        rhs_is_quantum = isinstance(rhs, SymbolicExpr) and rhs.is_quantum
+
+        return SymbolicExpr(
+            f"{lhs_str} {op} {rhs_str}", lhs_is_quantum or rhs_is_quantum
+        )
 
     @staticmethod
     def _unary_op(arg: Any, op: str) -> SymbolicExpr:
         if not isinstance(arg, (SymbolicExpr, int, float, bool)):
             raise TypeError(f"Invalid argument {arg!r} for unary operation {op!r}")
 
-        return SymbolicExpr(f"{op}({arg})")
+        arg_is_quantum = isinstance(arg, SymbolicExpr) and arg.is_quantum
+
+        return SymbolicExpr(f"{op}({arg})", arg_is_quantum)
 
     def __add__(self, other: Any) -> SymbolicExpr:
         return SymbolicExpr._binary_op(self, other, "+")
@@ -143,7 +167,7 @@ class SymbolicExpr(Symbolic):
 
 class SymbolicEquality(SymbolicExpr):
     def __init__(self, lhs: Any, rhs: Any) -> None:
-        expr = SymbolicExpr._binary_op(lhs, rhs, "==")._expr
-        super().__init__(expr)
+        sym_expr = SymbolicExpr._binary_op(lhs, rhs, "==")
+        super().__init__(sym_expr._expr, sym_expr.is_quantum)
         self.lhs = lhs
         self.rhs = rhs