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

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -0,0 +1,308 @@
+import ast
+from typing import Any, Optional, cast
+
+import sympy
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumNumeric,
+    QuantumType,
+)
+
+from classiq.evaluators.qmod_annotated_expression import (
+    QmodAnnotatedExpression,
+    QmodExprNodeId,
+)
+from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
+    BitwiseAnd,
+    BitwiseNot,
+    BitwiseOr,
+    BitwiseXor,
+    LShift,
+    RShift,
+)
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType
+
+_SYMPY_WRAPPERS = {
+    wrapper.__name__: wrapper
+    for wrapper in [
+        BitwiseAnd,
+        BitwiseNot,
+        BitwiseOr,
+        BitwiseXor,
+        LShift,
+        RShift,
+    ]
+}
+
+
+class _VarMaskTransformer(ast.NodeTransformer):
+    def __init__(self, expr_val: QmodAnnotatedExpression) -> None:
+        self._expr_val = expr_val
+        self._mask_id = 0
+        self.masks: dict[str, QmodExprNodeId] = {}
+        self._assigned_masks: dict[HandleBinding, str] = {}
+
+    def _create_mask(self) -> str:
+        mask = f"x{self._mask_id}"
+        self._mask_id += 1
+        return mask
+
+    def visit(self, node: ast.AST) -> ast.AST:
+        if self._expr_val.has_value(node):
+            return ast.parse(str(self._expr_val.get_value(node)))
+        if self._expr_val.has_var(node):
+            var = self._expr_val.get_var(node)
+            if var in self._assigned_masks:
+                mask = self._assigned_masks[var]
+            else:
+                mask = self._create_mask()
+                self._assigned_masks[var] = mask
+                self.masks[mask] = id(node)
+            return ast.Name(id=mask)
+        if self._expr_val.has_quantum_subscript(node):
+            mask = self._create_mask()
+            self.masks[mask] = id(node)
+            return ast.Name(id=mask)
+        return self.generic_visit(node)
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        mask = self._create_mask()
+        self.masks[mask] = id(node)
+        return ast.Name(id=mask)
+
+
+class _InverseVarMaskTransformer(ast.NodeTransformer):
+    def __init__(
+        self, expr_val: QmodAnnotatedExpression, masks: dict[str, QmodExprNodeId]
+    ) -> None:
+        self._expr_val = expr_val
+        self._masks = masks
+
+    def visit_Name(self, node: ast.Name) -> Any:
+        name = node.id
+        if name in self._masks:
+            mask_id = self._masks[name]
+            if not self._expr_val.has_node(mask_id):
+                raise ClassiqInternalExpansionError
+            return ast.Name(id=ast.unparse(self._expr_val.get_node(mask_id)))
+        return node
+
+
+class _SympyCompatibilityTransformer(ast.NodeTransformer):
+    def visit_BoolOp(self, node: ast.BoolOp) -> ast.Call:
+        if len(node.values) != 2:
+            raise ClassiqInternalExpansionError
+        node = cast(ast.BoolOp, self.generic_visit(node))
+        if isinstance(node.op, ast.Or):
+            sympy_func = "Or"
+        else:
+            sympy_func = "And"
+        return ast.Call(func=ast.Name(id=sympy_func), args=node.values, keywords=[])
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
+        node = cast(ast.UnaryOp, self.generic_visit(node))
+        if isinstance(node.op, ast.Not):
+            sympy_func = "Not"
+        elif isinstance(node.op, ast.Invert):
+            sympy_func = BitwiseNot.__name__
+        else:
+            return node
+        return ast.Call(func=ast.Name(id=sympy_func), args=[node.operand], keywords=[])
+
+    def visit_Compare(self, node: ast.Compare) -> ast.Call:
+        if len(node.ops) != 1:
+            raise ClassiqInternalExpansionError
+        node = cast(ast.Compare, self.generic_visit(node))
+        op = node.ops[0]
+        if isinstance(op, ast.Eq):
+            sympy_func = "Eq"
+        elif isinstance(op, ast.NotEq):
+            sympy_func = "Ne"
+        elif isinstance(op, ast.Lt):
+            sympy_func = "Lt"
+        elif isinstance(op, ast.LtE):
+            sympy_func = "Le"
+        elif isinstance(op, ast.Gt):
+            sympy_func = "Gt"
+        elif isinstance(op, ast.GtE):
+            sympy_func = "Ge"
+        else:
+            raise ClassiqInternalExpansionError
+        return ast.Call(
+            func=ast.Name(id=sympy_func),
+            args=[node.left, node.comparators[0]],
+            keywords=[],
+        )
+
+    def visit_BinOp(self, node: ast.BinOp) -> Any:
+        node = cast(ast.BinOp, self.generic_visit(node))
+        if isinstance(node.op, ast.LShift):
+            sympy_func = LShift.__name__
+        elif isinstance(node.op, ast.RShift):
+            sympy_func = RShift.__name__
+        elif isinstance(node.op, ast.BitOr):
+            sympy_func = BitwiseOr.__name__
+        elif isinstance(node.op, ast.BitXor):
+            sympy_func = BitwiseXor.__name__
+        elif isinstance(node.op, ast.BitAnd):
+            sympy_func = BitwiseAnd.__name__
+        else:
+            return node
+        return ast.Call(
+            func=ast.Name(id=sympy_func), args=[node.left, node.right], keywords=[]
+        )
+
+
+class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
+    def visit_Call(self, node: ast.Call) -> Any:
+        node = cast(ast.Call, self.generic_visit(node))
+        if not isinstance(node.func, ast.Name):
+            raise ClassiqInternalExpansionError
+        func = node.func.id
+
+        if (
+            func
+            in {
+                "Eq",
+                "Ne",
+                "Lt",
+                "Le",
+                "Gt",
+                "Ge",
+                LShift.__name__,
+                RShift.__name__,
+                BitwiseOr.__name__,
+                BitwiseXor.__name__,
+                BitwiseAnd.__name__,
+            }
+            and (len(node.args) != 2 or len(node.keywords) > 0)
+        ) or (
+            func in {BitwiseNot.__name__}
+            and (len(node.args) != 2 or len(node.keywords) > 0)
+        ):
+            raise ClassiqInternalExpansionError
+
+        if func == BitwiseNot.__name__:
+            return ast.UnaryOp(op=ast.Invert, operand=node.args[0])
+
+        if func == "Eq":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.Eq()], comparators=[node.args[1]]
+            )
+        if func == "Ne":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.NotEq()], comparators=[node.args[1]]
+            )
+        if func == "Lt":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.Lt()], comparators=[node.args[1]]
+            )
+        if func == "Le":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.LtE()], comparators=[node.args[1]]
+            )
+        if func == "Gt":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.Gt()], comparators=[node.args[1]]
+            )
+        if func == "GtE":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.GtE()], comparators=[node.args[1]]
+            )
+
+        if func == LShift.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.LShift(), right=node.args[1])
+        if func == RShift.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.RShift(), right=node.args[1])
+        if func == BitwiseOr.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.BitOr(), right=node.args[1])
+        if func == BitwiseXor.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.BitXor(), right=node.args[1])
+        if func == BitwiseAnd.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.BitAnd(), right=node.args[1])
+
+        return node
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
+        node = cast(ast.UnaryOp, self.generic_visit(node))
+
+        if isinstance(node.op, ast.Invert):
+            return ast.UnaryOp(op=ast.Not(), operand=node.operand)
+
+        return node
+
+    def visit_BinOp(self, node: ast.BinOp) -> Any:
+        node = cast(ast.BinOp, self.generic_visit(node))
+
+        if isinstance(node.op, ast.BitOr):
+            return ast.BoolOp(op=ast.Or(), values=[node.left, node.right])
+        if isinstance(node.op, ast.BitAnd):
+            return ast.BoolOp(op=ast.And(), values=[node.left, node.right])
+
+        return node
+
+
+def _get_numeric_type(
+    expr_val: QmodAnnotatedExpression,
+    expr_type: QmodType,
+    simplified_expr: str,
+    masks: dict[str, QmodExprNodeId],
+    machine_precision: int,
+) -> Optional[QuantumNumeric]:
+    if isinstance(expr_type, QuantumBit):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        )
+    if not isinstance(expr_type, QuantumNumeric):
+        return None
+    if expr_type.is_evaluated:
+        return expr_type
+    var_types = {
+        var_name: expr_val.get_type(node_id) for var_name, node_id in masks.items()
+    }
+    if not all(
+        isinstance(var_type, QuantumBit)
+        or (isinstance(var_type, QuantumNumeric) and var_type.is_instantiated)
+        for var_type in var_types.values()
+    ):
+        return None
+    return compute_arithmetic_result_type(
+        simplified_expr, cast(dict[str, QuantumType], var_types), machine_precision
+    )
+
+
+def simplify_qmod_expression(
+    expr_val: QmodAnnotatedExpression, machine_precision: int
+) -> tuple[str, Optional[QuantumNumeric]]:
+    if expr_val.has_value(expr_val.root):
+        raise ClassiqInternalExpansionError(
+            "This expression is a constant value. No need for simplification"
+        )
+    var_mask_transformer = _VarMaskTransformer(expr_val)
+    masks = var_mask_transformer.masks
+    mask_expr = var_mask_transformer.visit(expr_val.root)
+    sympy_expr = _SympyCompatibilityTransformer().visit(mask_expr)
+    simplified_expr = str(
+        sympy.sympify(ast.unparse(sympy_expr), locals=_SYMPY_WRAPPERS)
+    )
+    restored_expr = _InverseSympyCompatibilityTransformer().visit(
+        ast.parse(simplified_expr, mode="eval")
+    )
+    expr_type = _get_numeric_type(
+        expr_val,
+        expr_val.get_type(expr_val.root),
+        ast.unparse(restored_expr),
+        masks,
+        machine_precision,
+    )
+    restored_expr = _InverseVarMaskTransformer(
+        expr_val, var_mask_transformer.masks
+    ).visit(restored_expr)
+    return ast.unparse(restored_expr), expr_type

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -0,0 +1,112 @@
+import ast
+from collections.abc import Mapping
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    Integer,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.handle_binding import FieldHandleBinding
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+)
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType, get_qmod_type_name
+
+
+def _eval_type_attribute(
+    expr_val: QmodAnnotatedExpression, node: ast.Attribute
+) -> None:
+    subject = node.value
+    attr = node.attr
+
+    subject_type = expr_val.get_type(subject)
+    if isinstance(subject_type, QuantumType) and attr == "size":
+        expr_val.set_type(node, Integer())
+        if subject_type.has_size_in_bits:
+            expr_val.set_value(node, subject_type.size_in_bits)
+        else:
+            expr_val.set_quantum_type_attr(node, subject, attr)
+        return
+    if isinstance(subject_type, (ClassicalArray, QuantumBitvector)) and attr == "len":
+        expr_val.set_type(node, Integer())
+        if subject_type.has_length:
+            expr_val.set_value(node, subject_type.length_value)
+        elif isinstance(subject_type, QuantumType):
+            expr_val.set_quantum_type_attr(node, subject, attr)
+        return
+    if isinstance(subject_type, ClassicalTuple) and attr == "len":
+        expr_val.set_type(node, Integer())
+        expr_val.set_value(node, len(subject_type.element_types))
+        return
+    if isinstance(subject_type, QuantumNumeric):
+        if attr == "is_signed":
+            expr_val.set_type(node, Bool())
+            if subject_type.has_sign:
+                expr_val.set_value(node, subject_type.sign_value)
+            elif subject_type.has_size_in_bits:
+                expr_val.set_value(node, False)
+            else:
+                expr_val.set_quantum_type_attr(node, subject, attr)
+            return
+        if attr == "fraction_digits":
+            expr_val.set_type(node, Integer())
+            if subject_type.has_fraction_digits:
+                expr_val.set_value(node, subject_type.fraction_digits_value)
+            elif subject_type.has_size_in_bits:
+                expr_val.set_value(node, 0)
+            else:
+                expr_val.set_quantum_type_attr(node, subject, attr)
+            return
+    raise ClassiqExpansionError(
+        f"{get_qmod_type_name(subject_type)} has no attribute {attr!r}"
+    )
+
+
+def eval_attribute(expr_val: QmodAnnotatedExpression, node: ast.Attribute) -> None:
+    subject = node.value
+    attr = node.attr
+
+    subject_type = expr_val.get_type(subject)
+    if not isinstance(subject_type, TypeName) or (
+        subject_type.has_fields and attr == "size"
+    ):
+        _eval_type_attribute(expr_val, node)
+        return
+    subject_fields: Mapping[str, QmodType]
+    if subject_type.has_classical_struct_decl:
+        subject_fields = subject_type.classical_struct_decl.variables
+    elif subject_type.has_fields:
+        subject_fields = subject_type.fields
+    else:
+        raise ClassiqInternalExpansionError
+    if attr not in subject_fields:
+        raise ClassiqExpansionError(
+            f"{get_qmod_type_name(subject_type)} has no field {attr!r}"
+        )
+    expr_val.set_type(node, subject_fields[attr])
+
+    if expr_val.has_value(subject):
+        subject_value = expr_val.get_value(subject)
+        if (
+            not isinstance(subject_value, QmodStructInstance)
+            or attr not in subject_value.fields
+        ):
+            raise ClassiqInternalExpansionError
+        expr_val.set_value(node, subject_value.fields[attr])
+    elif expr_val.has_var(subject):
+        subject_var = expr_val.get_var(subject)
+        expr_val.set_var(node, FieldHandleBinding(base_handle=subject_var, field=attr))
+        expr_val.remove_var(subject)

classiq/evaluators/qmod_node_evaluators/binary_op_evaluation.py

@@ -0,0 +1,132 @@
+import ast
+from typing import TYPE_CHECKING
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.model.quantum_type import QuantumNumeric
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    IntegerValueType,
+    NumberValueType,
+    QmodType,
+    is_classical_integer,
+    is_classical_type,
+    is_numeric_type,
+)
+
+
+def _binary_op_allowed(left: QmodType, right: QmodType) -> bool:
+    return is_numeric_type(left) and is_numeric_type(right)
+
+
+def _validate_binary_op(op: ast.AST, left_type: QmodType, right_type: QmodType) -> None:
+    if not _binary_op_allowed(left_type, right_type):
+        raise ClassiqExpansionError(
+            f"Both sides of the binary operator {type(op).__name__!r} must be "
+            f"scalar values"
+        )
+    if isinstance(op, (ast.LShift, ast.RShift)) and (
+        isinstance(left_type, Real) or isinstance(right_type, Real)
+    ):
+        raise ClassiqExpansionError(
+            f"Bitshift operation {type(op).__name__!r} on real values is not "
+            f"supported"
+        )
+    if isinstance(op, (ast.BitOr, ast.BitXor, ast.BitAnd)) and (
+        isinstance(left_type, Real) or isinstance(right_type, Real)
+    ):
+        raise ClassiqExpansionError(
+            f"Bitwise operation {type(op).__name__!r} on real values is not supported"
+        )
+
+    if isinstance(op, ast.MatMult):
+        raise ClassiqExpansionError(
+            f"Binary operation {type(op).__name__!r} is not supported"
+        )
+
+    if not is_classical_type(right_type) and (
+        isinstance(
+            op, (ast.Div, ast.FloorDiv, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
+        )
+    ):
+        raise ClassiqExpansionError(
+            f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
+        )
+
+
+def _eval_binary_op_constant(
+    op: ast.AST, left_value: NumberValueType, right_value: NumberValueType
+) -> NumberValueType:
+    if isinstance(op, ast.Add):
+        return left_value + right_value
+    if isinstance(op, ast.Sub):
+        return left_value - right_value
+    if isinstance(op, ast.Mult):
+        return left_value * right_value
+    if isinstance(op, ast.Div):
+        if right_value == 0:
+            raise ClassiqExpansionError("Division by zero")
+        return left_value / right_value
+    if isinstance(op, ast.FloorDiv):
+        if right_value == 0:
+            raise ClassiqExpansionError("Integer division by zero")
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Integer division with a complex number")
+        return left_value // right_value
+    if isinstance(op, ast.Mod):
+        if right_value == 0:
+            raise ClassiqExpansionError("Integer modulu by zero")
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Integer modulu with a complex number")
+        return left_value % right_value
+    if isinstance(op, ast.Pow):
+        return left_value**right_value
+
+    if TYPE_CHECKING:
+        assert isinstance(left_value, IntegerValueType)
+        assert isinstance(right_value, IntegerValueType)
+
+    if isinstance(op, ast.LShift):
+        return left_value << right_value
+    if isinstance(op, ast.RShift):
+        return left_value >> right_value
+    if isinstance(op, ast.BitAnd):
+        return left_value & right_value
+    if isinstance(op, ast.BitOr):
+        return left_value | right_value
+    if isinstance(op, ast.BitXor):
+        return left_value ^ right_value
+
+    raise ClassiqInternalExpansionError
+
+
+def eval_binary_op(expr_val: QmodAnnotatedExpression, node: ast.BinOp) -> None:
+    left = node.left
+    right = node.right
+    op = node.op
+
+    left_type = expr_val.get_type(left)
+    right_type = expr_val.get_type(right)
+    _validate_binary_op(op, left_type, right_type)
+
+    node_type: QmodType
+    if not is_classical_type(left_type) or not is_classical_type(left_type):
+        node_type = QuantumNumeric()
+    elif (
+        not isinstance(op, ast.Div)
+        and is_classical_integer(left_type)
+        and is_classical_integer(right_type)
+    ):
+        node_type = Integer()
+    else:
+        node_type = Real()
+    expr_val.set_type(node, node_type)
+
+    if expr_val.has_value(left) and expr_val.has_value(right):
+        left_value = expr_val.get_value(left)
+        right_value = expr_val.get_value(right)
+        expr_val.set_value(node, _eval_binary_op_constant(op, left_value, right_value))

classiq/evaluators/qmod_node_evaluators/bool_op_evaluation.py

@@ -0,0 +1,70 @@
+import ast
+from functools import reduce
+from operator import and_, or_
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Bool
+from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    is_classical_type,
+    qnum_is_qbit,
+)
+
+
+def bool_op_allowed(left: QmodType, right: QmodType) -> bool:
+    return is_bool_type(left) and is_bool_type(right)
+
+
+def is_bool_type(qmod_type: QmodType) -> bool:
+    if isinstance(qmod_type, QuantumNumeric):
+        return qnum_is_qbit(qmod_type)
+    elif not isinstance(qmod_type, (QuantumBit, Bool)):
+        return False
+    return True
+
+
+def eval_bool_op(expr_val: QmodAnnotatedExpression, node: ast.BoolOp) -> None:
+    if len(node.values) < 2:
+        raise ClassiqInternalExpansionError
+
+    left = node.values[0]
+    rights = node.values[0:]
+    op = node.op
+
+    left_type = expr_val.get_type(left)
+    right_types = [expr_val.get_type(right) for right in rights]
+    if not all(bool_op_allowed(left_type, right_type) for right_type in right_types):
+        raise ClassiqExpansionError(
+            f"Both sides of the Boolean operator {type(op).__name__!r} must be "
+            f"Boolean values"
+        )
+    qmod_type: QmodType
+    if not is_classical_type(left_type) or not all(
+        is_classical_type(right_type) for right_type in right_types
+    ):
+        qmod_type = QuantumBit()
+    else:
+        qmod_type = Bool()
+    expr_val.set_type(node, qmod_type)
+
+    if not expr_val.has_value(left) or not all(
+        expr_val.has_value(right) for right in rights
+    ):
+        return
+
+    left_value = expr_val.get_value(left)
+    right_values = [expr_val.get_value(right) for right in rights]
+    if isinstance(op, ast.And):
+        operator = and_
+    elif isinstance(op, ast.Or):
+        operator = or_
+    else:
+        raise ClassiqInternalExpansionError
+    constant_value = reduce(operator, [left_value, *right_values])
+    expr_val.set_value(node, constant_value)