classiq 0.86.1__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/evaluators/qmod_node_evaluators/unary_op_evaluation.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -7,10 +7,23 @@ from classiq.interface.exceptions import (
 )
 from classiq.interface.generator.functions.classical_type import Integer, Real
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumNumeric,
+    QuantumScalar,
+)
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_node_evaluators.bool_op_evaluation import is_bool_type
-from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_numeric_type
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    is_classical_type,
+    is_numeric_type,
+)
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_bitwise_invert,
+    compute_result_attrs_negate,
+)
 
 
 def unary_op_allowed(op: ast.AST, operand_type: QmodType) -> bool:
@@ -19,7 +32,42 @@ def unary_op_allowed(op: ast.AST, operand_type: QmodType) -> bool:
     return is_numeric_type(operand_type)
 
 
-def eval_unary_op(expr_val: QmodAnnotatedExpression, node: ast.UnaryOp) -> None:
+def _infer_unary_op_type(
+    op: ast.AST, operand_type: QmodType, machine_precision: int
+) -> QmodType:
+    if is_classical_type(operand_type):
+        if isinstance(operand_type, TypeName):
+            # The operand is enum, return as integer
+            return Integer()
+        return operand_type
+
+    if TYPE_CHECKING:
+        assert isinstance(operand_type, QuantumScalar)
+
+    if isinstance(op, (ast.Not, ast.UAdd)):
+        return operand_type
+
+    if not operand_type.is_evaluated:
+        return QuantumNumeric()
+
+    operand_attrs = NumericAttributes.from_quantum_scalar(
+        operand_type, machine_precision
+    )
+    if isinstance(op, ast.Invert):
+        result_attrs = compute_result_attrs_bitwise_invert(
+            operand_attrs, machine_precision
+        )
+    elif isinstance(op, ast.USub):
+        result_attrs = compute_result_attrs_negate(operand_attrs, machine_precision)
+    else:
+        raise ClassiqInternalExpansionError
+
+    return result_attrs.to_quantum_numeric()
+
+
+def eval_unary_op(
+    expr_val: QmodAnnotatedExpression, node: ast.UnaryOp, machine_precision: int
+) -> None:
     operand = node.operand
     op = node.op
 
@@ -34,12 +82,8 @@ def eval_unary_op(expr_val: QmodAnnotatedExpression, node: ast.UnaryOp) -> None:
         raise ClassiqExpansionError(
             f"Operation {type(op).__name__!r} on a real value is not supported"
         )
-    op_type: QmodType
-    if isinstance(operand_type, TypeName):
-        op_type = Integer()
-    else:
-        op_type = operand_type
-    expr_val.set_type(node, op_type)
+
+    expr_val.set_type(node, _infer_unary_op_type(op, operand_type, machine_precision))
 
     if not expr_val.has_value(operand):
         return

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -1,7 +1,8 @@
-from typing import Any, Optional, Union, cast
+from typing import Optional, Union, cast
 
 import sympy
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalTuple,
@@ -24,10 +25,6 @@ NumberValueType = Union[IntegerValueType, RealValueType]
 SYMPY_SYMBOLS = {sym: getattr(sympy, sym) for sym in sympy.__all__}
 
 
-def get_qmod_type_name(type_: Any) -> str:
-    return getattr(type_, "type_name", type(type_).__name__)
-
-
 def is_classical_type(qmod_type: QmodType) -> bool:
     if isinstance(qmod_type, TypeName):
         return qmod_type.has_classical_struct_decl or qmod_type.is_enum
@@ -42,6 +39,31 @@ def qnum_is_qbit(qmod_type: QuantumNumeric) -> bool:
     )
 
 
+def get_numeric_properties(
+    qmod_type: QuantumScalar,
+) -> tuple[Optional[int], Optional[bool], Optional[int]]:
+    if isinstance(qmod_type, QuantumBit):
+        return 1, False, 0
+    if not isinstance(qmod_type, QuantumNumeric):
+        raise ClassiqInternalExpansionError
+    size = qmod_type.size_in_bits if qmod_type.has_size_in_bits else None
+    is_signed_expr = qmod_type.is_signed
+    if is_signed_expr is None:
+        is_signed = False
+    elif is_signed_expr.is_evaluated() and is_signed_expr.is_constant():
+        is_signed = is_signed_expr.to_bool_value()
+    else:
+        is_signed = None
+    fraction_digits_expr = qmod_type.fraction_digits
+    if fraction_digits_expr is None:
+        fraction_digits = 0
+    elif fraction_digits_expr.is_evaluated() and fraction_digits_expr.is_constant():
+        fraction_digits = fraction_digits_expr.to_int_value()
+    else:
+        fraction_digits = None
+    return size, is_signed, fraction_digits
+
+
 def qnum_is_qint(qmod_type: QuantumType) -> bool:
     return isinstance(qmod_type, QuantumBit) or (
         isinstance(qmod_type, QuantumNumeric)
@@ -63,7 +85,7 @@ def array_len(
 ) -> Optional[int]:
     if isinstance(classical_type, ClassicalTuple):
         return len(classical_type.element_types)
-    if classical_type.has_length:
+    if classical_type.has_constant_length:
         return classical_type.length_value
     return None
 

classiq/evaluators/qmod_type_inference/classical_type_inference.py

@@ -0,0 +1,188 @@
+from enum import IntEnum
+from typing import Any, Optional, Union
+
+import sympy
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    ClassicalType,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import Enum, Struct, TypeName
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.backward_compatibility import zip_strict
+
+
+def _copy_generative_flag(
+    from_type: ClassicalType, to_type: Optional[ClassicalType]
+) -> Optional[ClassicalType]:
+    if to_type is None:
+        return None
+    if from_type.is_generative:
+        return to_type.set_generative()
+    return to_type
+
+
+def infer_classical_type(value: Any) -> ClassicalType:
+    if isinstance(value, IntEnum):
+        return Enum(name=type(value).__name__)
+    if isinstance(value, bool):
+        return Bool()
+    if isinstance(value, int):
+        return Integer()
+    if isinstance(value, (float, complex)):
+        return Real()
+    if isinstance(value, list):
+        return ClassicalTuple(
+            element_types=[infer_classical_type(item) for item in value]
+        )
+    if isinstance(value, QmodStructInstance):
+        struct_name = value.struct_declaration.name
+        classical_type = Struct(name=struct_name)
+        classical_type.set_classical_struct_decl(
+            StructDeclaration(
+                name=struct_name,
+                variables={
+                    field_name: infer_classical_type(field_value)
+                    for field_name, field_value in value.fields.items()
+                },
+            )
+        )
+        return classical_type
+    # FIXME: Remove sympy compatibility (CLS-3214)
+    if (
+        isinstance(value, sympy.Basic)
+        and len(value.free_symbols) == 0
+        and value.is_complex
+    ):
+        return Real()
+    raise ClassiqInternalExpansionError
+
+
+def _inject_classical_array_attributes(
+    from_type: ClassicalType, to_type: Union[ClassicalArray, ClassicalTuple]
+) -> Optional[ClassicalType]:
+    if isinstance(to_type, ClassicalArray):
+        if isinstance(from_type, ClassicalArray):
+            length: Optional[Expression]
+            if from_type.has_constant_length:
+                if (
+                    to_type.has_constant_length
+                    and from_type.length_value != to_type.length_value
+                ):
+                    return None
+                length = from_type.length
+            else:
+                length = to_type.length
+            element_type = inject_classical_type_attributes(
+                from_type.element_type, to_type.element_type
+            )
+            if element_type is None:
+                return None
+            return ClassicalArray(element_type=element_type, length=length)
+        if isinstance(from_type, ClassicalTuple):
+            if (
+                to_type.has_constant_length
+                and len(from_type.element_types) != to_type.length_value
+            ):
+                return None
+            element_types = [
+                inject_classical_type_attributes(element_type, to_type.element_type)
+                for element_type in from_type.element_types
+            ]
+            if None in element_types:
+                return None
+            return ClassicalTuple(element_types=element_types)
+        return None
+    if isinstance(from_type, ClassicalArray):
+        if from_type.has_constant_length and from_type.length_value != len(
+            to_type.element_types
+        ):
+            return None
+        element_types = [
+            inject_classical_type_attributes(from_type.element_type, element_type)
+            for element_type in to_type.element_types
+        ]
+        if None in element_types:
+            return None
+        return ClassicalTuple(element_types=element_types)
+    if isinstance(from_type, ClassicalTuple):
+        if len(from_type.element_types) != len(to_type.element_types):
+            return None
+        element_types = [
+            inject_classical_type_attributes(from_element_type, to_element_type)
+            for from_element_type, to_element_type in zip_strict(
+                from_type.element_types, to_type.element_types, strict=True
+            )
+        ]
+        if None in element_types:
+            return None
+        return ClassicalTuple(element_types=element_types)
+    return None
+
+
+def _inject_classical_type_name_attributes(
+    from_type: ClassicalType, to_type: TypeName
+) -> Optional[ClassicalType]:
+    if to_type.is_enum:
+        if isinstance(from_type, Integer) or (
+            isinstance(from_type, TypeName) and from_type.name == to_type.name
+        ):
+            return Enum(name=to_type.name)
+        return None
+    if to_type.has_classical_struct_decl:
+        if not isinstance(from_type, TypeName) or from_type.name != to_type.name:
+            return None
+        classical_type = Struct(name=to_type.name)
+        field_types = {
+            field_name: inject_classical_type_attributes(
+                from_type.classical_struct_decl.variables[field_name],
+                to_type.classical_struct_decl.variables[field_name],
+            )
+            for field_name in to_type.classical_struct_decl.variables
+        }
+        if None in field_types.values():
+            return None
+        classical_type.set_classical_struct_decl(
+            StructDeclaration(name=to_type.name, variables=field_types)
+        )
+        return classical_type
+    return None
+
+
+def inject_classical_type_attributes(
+    from_type: ClassicalType, to_type: ClassicalType
+) -> Optional[ClassicalType]:
+    if isinstance(to_type, Bool):
+        if isinstance(from_type, Bool):
+            return _copy_generative_flag(to_type, Bool())
+        return None
+    if isinstance(to_type, Integer):
+        if isinstance(from_type, (Integer, Real)) or (
+            isinstance(from_type, TypeName) and from_type.is_enum
+        ):
+            return _copy_generative_flag(to_type, Integer())
+        return None
+    if isinstance(to_type, Real):
+        if isinstance(from_type, (Integer, Real)) or (
+            isinstance(from_type, TypeName) and from_type.is_enum
+        ):
+            return _copy_generative_flag(to_type, Real())
+        return None
+    if isinstance(to_type, (ClassicalArray, ClassicalTuple)):
+        return _copy_generative_flag(
+            to_type, _inject_classical_array_attributes(from_type, to_type)
+        )
+    if isinstance(to_type, TypeName):
+        return _copy_generative_flag(
+            to_type, _inject_classical_type_name_attributes(from_type, to_type)
+        )
+    return None

classiq/evaluators/qmod_type_inference/quantum_type_inference.py

@@ -0,0 +1,330 @@
+from typing import TYPE_CHECKING, Optional
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+)
+
+from classiq.evaluators.quantum_type_utils import set_bounds
+
+
+def _normalized_qnum(quantum_type: QuantumType) -> QuantumType:
+    if not isinstance(quantum_type, QuantumNumeric):
+        return quantum_type
+    normalized_qnum = QuantumNumeric(
+        size=quantum_type.size,
+        is_signed=(
+            quantum_type.is_signed
+            if quantum_type.is_signed is not None
+            else Expression(expr="False")
+        ),
+        fraction_digits=(
+            quantum_type.fraction_digits
+            if quantum_type.fraction_digits is not None
+            else Expression(expr="0")
+        ),
+    )
+    normalized_qnum.set_bounds(quantum_type.get_bounds())
+    return normalized_qnum
+
+
+def _same_shape(quantum_type_1: QuantumType, quantum_type_2: QuantumType) -> bool:
+    if isinstance(quantum_type_1, QuantumBit) and isinstance(
+        quantum_type_2, QuantumBit
+    ):
+        return True
+    if (
+        isinstance(quantum_type_1, QuantumNumeric)
+        and isinstance(quantum_type_2, QuantumNumeric)
+        and (
+            not quantum_type_1.has_size_in_bits
+            or not quantum_type_2.has_size_in_bits
+            or quantum_type_1.size_in_bits == quantum_type_2.size_in_bits
+        )
+    ):
+        return True
+    if (
+        isinstance(quantum_type_1, QuantumBitvector)
+        and isinstance(quantum_type_2, QuantumBitvector)
+        and (
+            not quantum_type_1.has_constant_length
+            or not quantum_type_2.has_constant_length
+            or quantum_type_1.length_value == quantum_type_2.length_value
+        )
+        and _same_shape(quantum_type_1.element_type, quantum_type_2.element_type)
+    ):
+        return True
+    return (
+        isinstance(quantum_type_1, TypeName)
+        and quantum_type_1.has_fields
+        and isinstance(quantum_type_2, TypeName)
+        and quantum_type_2.has_fields
+        and quantum_type_1.name == quantum_type_2.name
+        and all(
+            _same_shape(
+                quantum_type_1.fields[field_name], quantum_type_2.fields[field_name]
+            )
+            for field_name in quantum_type_1.fields
+        )
+    )
+
+
+def _inject_qnum_type_attributes(
+    from_type: QuantumType, to_type: QuantumNumeric
+) -> QuantumNumeric:
+    size: Optional[Expression]
+    if from_type.has_size_in_bits:
+        size = Expression(expr=str(from_type.size_in_bits))
+    else:
+        size = to_type.size
+    if to_type.is_signed is not None:
+        if to_type.is_signed.is_evaluated():
+            is_signed = Expression(expr=str(to_type.sign_value))
+        else:
+            is_signed = Expression(expr="False")
+    else:
+        is_signed = None
+    if to_type.fraction_digits is not None:
+        if to_type.fraction_digits.is_evaluated():
+            fraction_digits = Expression(expr=str(to_type.fraction_digits_value))
+        else:
+            fraction_digits = Expression(expr="0")
+    else:
+        fraction_digits = None
+    if isinstance(from_type, QuantumNumeric) and not to_type.has_size_in_bits:
+        if (
+            is_signed is None
+            and from_type.is_signed is not None
+            and from_type.is_signed.is_evaluated()
+        ):
+            is_signed = from_type.is_signed
+        if (
+            fraction_digits is None
+            and from_type.fraction_digits is not None
+            and from_type.fraction_digits.is_evaluated()
+        ):
+            fraction_digits = from_type.fraction_digits
+    if size is not None and is_signed is None:
+        is_signed = Expression(expr="False")
+    if size is not None and fraction_digits is None:
+        fraction_digits = Expression(expr="0")
+    updated_type = QuantumNumeric(
+        size=size, is_signed=is_signed, fraction_digits=fraction_digits
+    )
+    updated_type.set_bounds(to_type.get_bounds())
+    set_bounds(_normalized_qnum(from_type), updated_type)
+    return updated_type
+
+
+def _inject_qarray_type_attributes(
+    from_type: QuantumType, to_type: QuantumBitvector
+) -> Optional[QuantumBitvector]:
+    if _same_shape(from_type, to_type):
+        if TYPE_CHECKING:
+            assert isinstance(from_type, QuantumBitvector)
+        if to_type.has_length:
+            length = to_type.length
+        elif from_type.has_length:
+            length = from_type.length
+        elif from_type.has_size_in_bits:
+            raise ClassiqExpansionError(
+                f"Could not infer the length attribute of type {to_type.qmod_type_name}"
+            )
+        else:
+            length = None
+        element_type = inject_quantum_type_attributes(
+            from_type.element_type, to_type.element_type
+        )
+    else:
+        if to_type.has_constant_length:
+            if (
+                from_type.has_size_in_bits
+                and from_type.size_in_bits % to_type.length_value != 0
+            ):
+                return None
+            length = to_type.length
+        elif from_type.has_size_in_bits:
+            if not to_type.element_type.has_size_in_bits:
+                raise ClassiqExpansionError(
+                    f"Could not infer the length attribute of type "
+                    f"{to_type.qmod_type_name}"
+                )
+            if from_type.size_in_bits % to_type.element_type.size_in_bits != 0:
+                return None
+            length = Expression(
+                expr=str(from_type.size_in_bits // to_type.element_type.size_in_bits)
+            )
+        else:
+            length = None
+        if length is not None and from_type.has_size_in_bits:
+            element_type = inject_quantum_type_attributes(
+                QuantumBitvector(
+                    length=Expression(
+                        expr=str(from_type.size_in_bits // length.to_int_value())
+                    )
+                ),
+                to_type.element_type,
+            )
+        else:
+            element_type = inject_quantum_type_attributes(
+                QuantumBitvector(), to_type.element_type
+            )
+    return QuantumBitvector(element_type=element_type, length=length)
+
+
+def _inject_qstruct_type_attributes(
+    from_type: QuantumType, to_type: TypeName
+) -> Optional[TypeName]:
+    if isinstance(from_type, TypeName) and from_type.name == to_type.name:
+        fields = {
+            field_name: inject_quantum_type_attributes(
+                from_type.fields[field_name], to_type.fields[field_name]
+            )
+            for field_name in to_type.fields
+        }
+        if None in fields.values():
+            return None
+    elif not from_type.has_size_in_bits:
+        fields = {
+            field_name: inject_quantum_type_attributes(QuantumBitvector(), field_type)
+            for field_name, field_type in to_type.fields.items()
+        }
+    else:
+        initialized_fields = {
+            field_name: field_type.has_size_in_bits
+            for field_name, field_type in to_type.fields.items()
+        }
+        if sum(initialized_fields.values()) == len(initialized_fields) - 1:
+            flexible_field_name = [
+                field_name
+                for field_name, is_initialized in initialized_fields.items()
+                if not is_initialized
+            ][0]
+            flexible_field_size = from_type.size_in_bits - sum(
+                field_type.size_in_bits
+                for field_name, field_type in to_type.fields.items()
+                if initialized_fields[field_name]
+            )
+            flexible_field_type = inject_quantum_type_attributes(
+                QuantumBitvector(length=Expression(expr=str(flexible_field_size))),
+                to_type.fields[flexible_field_name],
+            )
+            if flexible_field_type is None:
+                return None
+            fields = {
+                field_name: (
+                    flexible_field_type
+                    if field_name == flexible_field_name
+                    else inject_quantum_type_attributes(QuantumBitvector(), field_type)
+                )
+                for field_name, field_type in to_type.fields.items()
+            }
+        else:
+            fields = {
+                field_name: inject_quantum_type_attributes(
+                    QuantumBitvector(), field_type
+                )
+                for field_name, field_type in to_type.fields.items()
+            }
+    classical_type = TypeName(name=to_type.name)
+    classical_type.set_fields(fields)  # type:ignore[arg-type]
+    return classical_type
+
+
+def inject_quantum_type_attributes(
+    from_type: QuantumType, to_type: QuantumType
+) -> Optional[QuantumType]:
+    for qmod_type in (from_type, to_type):
+        if isinstance(qmod_type, TypeName) and not qmod_type.has_fields:
+            raise ClassiqInternalExpansionError
+    if to_type.has_size_in_bits and (
+        (from_type.has_size_in_bits and to_type.size_in_bits != from_type.size_in_bits)
+        or (from_type.minimal_size_in_bits > to_type.size_in_bits)
+    ):
+        return None
+    if isinstance(to_type, QuantumBit):
+        return QuantumBit()
+    if isinstance(to_type, QuantumNumeric):
+        return _inject_qnum_type_attributes(from_type, to_type)
+    if isinstance(to_type, QuantumBitvector):
+        return _inject_qarray_type_attributes(from_type, to_type)
+    if isinstance(to_type, TypeName):
+        return _inject_qstruct_type_attributes(from_type, to_type)
+    raise ClassiqInternalExpansionError
+
+
+def inject_quantum_type_attributes_inplace(
+    from_type: QuantumType, to_type: QuantumType
+) -> bool:
+    updated_type = inject_quantum_type_attributes(from_type, to_type)
+    if updated_type is None:
+        return False
+    if isinstance(to_type, QuantumBit) and isinstance(updated_type, QuantumBit):
+        return True
+    if isinstance(to_type, QuantumNumeric) and isinstance(updated_type, QuantumNumeric):
+        to_type.size = updated_type.size
+        to_type.is_signed = updated_type.is_signed
+        to_type.fraction_digits = updated_type.fraction_digits
+        to_type.set_bounds(updated_type.get_bounds())
+        return True
+    if isinstance(to_type, QuantumBitvector) and isinstance(
+        updated_type, QuantumBitvector
+    ):
+        to_type.length = updated_type.length
+        to_type.element_type = updated_type.element_type
+        return True
+    if (
+        isinstance(to_type, TypeName)
+        and to_type.has_fields
+        and isinstance(updated_type, TypeName)
+        and updated_type.has_fields
+    ):
+        to_type.set_fields(updated_type.fields)
+        return True
+    raise ClassiqInternalExpansionError
+
+
+def validate_quantum_type_attributes(quantum_type: QuantumType) -> None:
+    if isinstance(quantum_type, TypeName):
+        if len(quantum_type.fields) == 0:
+            raise ClassiqExpansionError(
+                f"QStruct {quantum_type.name} must have at least one field"
+            )
+        for field_type in quantum_type.fields.values():
+            validate_quantum_type_attributes(field_type)
+        return
+    if isinstance(quantum_type, QuantumBitvector):
+        validate_quantum_type_attributes(quantum_type.element_type)
+        if quantum_type.has_constant_length and quantum_type.length_value < 1:
+            raise ClassiqExpansionError(
+                f"QArray length must be positive, got {quantum_type.length_value}"
+            )
+        return
+    if isinstance(quantum_type, QuantumNumeric):
+        if quantum_type.has_size_in_bits and quantum_type.size_in_bits < 1:
+            raise ClassiqExpansionError(
+                f"QNum size must be positive, got {quantum_type.size_in_bits}"
+            )
+        if quantum_type.has_fraction_digits:
+            if quantum_type.fraction_digits_value < 0:
+                raise ClassiqExpansionError(
+                    f"QNum fraction digits must be positive, got "
+                    f"{quantum_type.fraction_digits_value}"
+                )
+            if (
+                quantum_type.has_size_in_bits
+                and quantum_type.fraction_digits_value > quantum_type.size_in_bits
+            ):
+                raise ClassiqExpansionError(
+                    f"QNum size ({quantum_type.size_in_bits}) must be greater or "
+                    f"equals than the fraction digits "
+                    f"({quantum_type.fraction_digits_value})"
+                )