classiq 0.45.1__py3-none-any.whl → 0.46.1__py3-none-any.whl

classiq/model_expansions/sympy_conversion/arithmetics.py

@@ -0,0 +1,49 @@
+from typing import Any, Optional
+
+from sympy import Function, Integer
+from sympy.logic.boolalg import BooleanFunction
+
+
+class BitwiseAnd(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a & b
+
+        return None
+
+
+class BitwiseXor(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a ^ b
+
+        return None
+
+
+class LogicalXor(BooleanFunction):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[bool]:
+        if isinstance(a, bool) and isinstance(b, bool):
+            return a ^ b
+
+        return None
+
+
+class BitwiseOr(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a | b
+
+        return None
+
+
+class BitwiseNot(Function):
+    @classmethod
+    def eval(cls, a: Any) -> Optional[int]:
+        if isinstance(a, Integer):
+            return ~a
+
+        return None

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -0,0 +1,150 @@
+import ast
+from typing import TYPE_CHECKING, Dict, Type
+
+from classiq.interface.exceptions import ClassiqExpansionError
+
+MISSING_SLICE_VALUE_PLACEHOLDER = "MISSING_SLICE_VALUE"
+
+
+def translate_to_sympy(expr: str) -> str:
+    node = ast.parse(expr)
+    node = ExpressionSympyTranslator().visit(node)
+    # node is a Module, we want an Expression
+    if TYPE_CHECKING:
+        assert isinstance(node.body[0], ast.Expr)
+    expression = ast.Expression(node.body[0].value)
+
+    return ast.unparse(ast.fix_missing_locations(expression))
+
+
+class ExpressionSympyTranslator(ast.NodeTransformer):
+    BINARY_OPERATORS: Dict[Type[ast.AST], str] = {
+        ast.BitOr: "BitwiseOr",
+        ast.BitAnd: "BitwiseAnd",
+        ast.BitXor: "BitwiseXor",
+        ast.Div: "do_div",
+    }
+
+    UNARY_OPERATORS: Dict[Type[ast.AST], str] = {
+        ast.Invert: "BitwiseNot",
+        ast.Not: "Not",
+    }
+
+    BOOLEAN_OPERATORS: Dict[Type[ast.AST], str] = {
+        ast.Or: "Or",
+        ast.And: "And",
+    }
+
+    COMPARE_OPERATORS: Dict[Type[ast.AST], str] = {
+        ast.Eq: "Eq",
+        ast.NotEq: "Ne",
+    }
+
+    SPECIAL_FUNCTIONS: Dict[str, str] = {
+        "max": "Max",
+        "min": "Min",
+    }
+
+    def visit_BinOp(self, node: ast.BinOp) -> ast.AST:
+        sympy_class = self.BINARY_OPERATORS.get(node.op.__class__)
+        if sympy_class is not None:
+            left = self.visit(node.left)
+            right = self.visit(node.right)
+
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[left, right],
+                starargs=None,
+                keywords=[],
+                kwargs=None,
+            )
+
+            return new_node
+        return self.generic_visit(node)
+
+    def visit_Compare(self, node: ast.Compare) -> ast.AST:
+        if len(node.ops) > 1:
+            raise ClassiqExpansionError(
+                f"Qmod expressions do not support chained comparison, as done in {ast.unparse(node)}"
+            )
+        sympy_class = self.COMPARE_OPERATORS.get(node.ops[0].__class__)
+        if sympy_class is not None:
+            left = self.visit(node.left)
+            right = self.visit(node.comparators[0])
+
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[left, right],
+                starargs=None,
+                keywords=[],
+                kwargs=None,
+            )
+
+            return new_node
+        return self.generic_visit(node)
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
+        sympy_class = self.BOOLEAN_OPERATORS.get(node.op.__class__)
+        if sympy_class is not None:
+            values = [self.visit(value) for value in node.values]
+
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=values,
+                starargs=None,
+                keywords=[],
+                kwargs=None,
+            )
+
+            return new_node
+        return self.generic_visit(node)
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.AST:
+        sympy_class = self.UNARY_OPERATORS.get(node.op.__class__)
+        if sympy_class is not None:
+            operand = self.visit(node.operand)
+
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[operand],
+                starargs=None,
+                keywords=[],
+                kwargs=None,
+            )
+
+            return new_node
+        return self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        if (
+            not isinstance(node.func, ast.Name)
+            or node.func.id not in self.SPECIAL_FUNCTIONS
+        ):
+            return self.generic_visit(node)
+
+        return ast.Call(
+            func=ast.Name(self.SPECIAL_FUNCTIONS[node.func.id]),
+            args=[self.visit(arg) for arg in (node.args)],
+            keywords=[self.visit(arg) for arg in node.keywords],
+        )
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        if isinstance(node.slice, ast.Slice):
+            if node.slice.lower is not None:
+                lower = self.visit(node.slice.lower)
+            else:
+                lower = ast.Name(MISSING_SLICE_VALUE_PLACEHOLDER)
+            if node.slice.upper is not None:
+                upper = self.visit(node.slice.upper)
+            else:
+                upper = ast.Name(MISSING_SLICE_VALUE_PLACEHOLDER)
+            return ast.Call(
+                func=ast.Name("do_slice"),
+                args=[self.visit(node.value), lower, upper],
+                keywords=[],
+            )
+        return ast.Call(
+            func=ast.Name("do_subscript"),
+            args=[self.visit(node.value), self.visit(node.slice)],
+            keywords=[],
+        )

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -0,0 +1,113 @@
+import functools
+from typing import Any, Dict, Optional, get_args
+
+from sympy import (
+    Array,
+    Basic,
+    Expr,
+    Float,
+    Integer,
+    Matrix,
+    Piecewise,
+    Rational,
+    Symbol,
+)
+from sympy.logic.boolalg import BooleanAtom
+from sympy.printing.pycode import PythonCodePrinter
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
+
+from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
+
+
+def sympy_to_python(
+    value: Any, locals: Optional[Dict[str, ExpressionValue]] = None
+) -> ExpressionValue:
+    if isinstance(value, Integer):
+        value = int(value)
+    elif isinstance(value, Float):
+        value = float(value)
+    elif isinstance(value, BooleanAtom):
+        value = bool(value)
+    elif isinstance(value, Array):
+        value = sympy_to_python(value.tolist(), locals)
+    elif isinstance(value, Rational):
+        value = float(value.evalf())
+    elif isinstance(value, list):
+        value = [sympy_to_python(element, locals) for element in value]
+    elif isinstance(value, Matrix):
+        value = [sympy_to_python(element, locals) for element in value.tolist()]
+    elif isinstance(value, Symbol) and locals is not None and value.name in locals:
+        return locals[value.name]
+    if value is None:
+        value = False
+
+    if not isinstance(value, get_args(ExpressionValue)):
+        raise ClassiqInternalExpansionError(
+            f"Invalid evaluated expression {value} of type {type(value)}"
+        )
+
+    return value
+
+
+def _conditional_true(*args: Any, **kwargs: Any) -> bool:
+    return True
+
+
+class SympyToQuantumExpressionTranslator(PythonCodePrinter):
+    _operators = {**PythonCodePrinter._operators, **{"not": "~", "xor": "^"}}
+    _kf = {
+        **PythonCodePrinter._kf,
+        **{"max": "max", "min": "min", "Max": "max", "Min": "min"},
+    }
+    BINARY_BITWISE_OPERATORS_MAPPING = {
+        "BitwiseAnd": "&",
+        "BitwiseOr": "|",
+        "BitwiseXor": "^",
+        "LogicalXor": "^",
+    }
+    UNARY_BITWISE_OPERATORS_MAPPING = {"BitwiseNot": "~"}
+
+    @staticmethod
+    def _print_bitwise_binary_operator(
+        left_arg: Expr, right_arg: Expr, operator: str
+    ) -> str:
+        return f"(({left_arg}) {operator} ({right_arg}))"
+
+    @staticmethod
+    def _print_bitwise_unary_operator(arg: Expr, operator: str) -> str:
+        return f"({operator} ({arg}))"
+
+    def __init__(self) -> None:
+        super().__init__(settings={"fully_qualified_modules": False})
+        for binary_operator in self.BINARY_BITWISE_OPERATORS_MAPPING:
+            self.known_functions[binary_operator] = [
+                (
+                    _conditional_true,
+                    functools.partial(
+                        self._print_bitwise_binary_operator,
+                        operator=self.BINARY_BITWISE_OPERATORS_MAPPING[binary_operator],
+                    ),
+                )
+            ]
+        for unary_operator in self.UNARY_BITWISE_OPERATORS_MAPPING:
+            self.known_functions[unary_operator] = [
+                (
+                    _conditional_true,
+                    functools.partial(
+                        self._print_bitwise_unary_operator,
+                        operator=self.UNARY_BITWISE_OPERATORS_MAPPING[unary_operator],
+                    ),
+                )
+            ]
+
+    def _print_Piecewise(self, expr: Piecewise) -> str:  # noqa: N802
+        return str(expr)
+
+    def _print_LogicalXor(self, expr: LogicalXor) -> str:  # noqa: N802
+        return f"(({self._print(expr.args[0])}) ^ ({self._print(expr.args[1])}))"
+
+
+def translate_sympy_quantum_expression(expr: Basic) -> str:
+    return SympyToQuantumExpressionTranslator().doprint(expr)

classiq/model_expansions/utils/counted_name_allocator.py

@@ -0,0 +1,11 @@
+from collections import Counter
+
+
+class CountedNameAllocator:
+    def __init__(self) -> None:
+        self._count: Counter[str] = Counter()
+
+    def allocate(self, prefix: str) -> str:
+        allocated = f"{prefix}_{self._count[prefix]}"
+        self._count[prefix] += 1
+        return allocated

classiq/model_expansions/visitors/boolean_expression_transformers.py

@@ -0,0 +1,214 @@
+import ast
+import copy
+from typing import TYPE_CHECKING, Union
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+
+from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
+
+
+class BooleanExpressionOptimizer(ast.NodeTransformer):
+    """
+    This class assumes that all variables in the expression are single qubit.
+    It does the following:
+    It checks whether the expression can be transformed into a boolean expression with boolean
+    variables (i.e, single-qubit variables), and if so, does the transformation by converting bitwise
+    ops to their boolean analogs.
+    The condition is that the expression consists of bitwise operations and relational operations only,
+    and not operations like addition.
+    The transformation results in better circuits.
+    """
+
+    def __init__(self) -> None:
+        self._is_convertible: bool = False
+
+    @property
+    def is_convertible(self) -> bool:
+        return self._is_convertible
+
+    def visit_Expr(self, node: ast.Expr) -> ast.Expr:
+        self._is_convertible = False
+        original_expr = copy.deepcopy(node)
+        self.generic_visit(node)
+        return node if self._is_convertible else original_expr
+
+    def visit_operator(self, node: ast.operator) -> ast.operator:
+        self._is_convertible = False
+        return node
+
+    def visit_BinOp(self, node: ast.BinOp) -> Union[ast.BinOp, ast.BoolOp]:
+        self.generic_visit(node)
+        self._is_convertible = self._is_bool(node)
+        if not self._is_convertible:
+            return node
+
+        return self.visit(self._convert_bin_op_to_bool_op(node))
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.AST:
+        self.generic_visit(node)
+        self._is_convertible = self._is_bool(node)
+        if not self._is_convertible:
+            return node
+
+        return ast.UnaryOp(op=ast.Not(), operand=node.operand)
+
+    def visit_Compare(self, node: ast.Compare) -> ast.AST:
+        if len(node.ops) != 1 or len(node.comparators) != 1:
+            raise ClassiqInternalExpansionError
+
+        self.generic_visit(node)
+        self._is_convertible = self._is_bool(node)
+        if not self._is_convertible:
+            return node
+
+        if not (
+            isinstance(node.left, ast.Constant)
+            or isinstance(node.comparators[0], ast.Constant)
+        ):
+            return node
+
+        return self._simplify_trivial_equality(node)
+
+    def visit_Call(self, node: ast.Call) -> ast.Call:
+        self._is_convertible = (
+            isinstance(node.func, ast.Name) and node.func.id == LogicalXor.__name__
+        )
+        return node
+
+    def _is_bool(self, node: ast.AST) -> bool:
+        if isinstance(node, (ast.BoolOp, ast.Name)):  # Name due to boolean vars
+            return True
+        if isinstance(node, ast.BinOp):
+            return (
+                self._is_bool(node.left)
+                and self._is_bool(node.right)
+                and isinstance(node.op, (ast.BitOr, ast.BitAnd, ast.BitXor))
+            )
+        if isinstance(node, ast.Constant):
+            return isinstance(node.value, int) and node.value in (0, 1)
+        if isinstance(node, ast.UnaryOp):
+            return isinstance(node.op, (ast.Invert, ast.Not)) and self._is_bool(
+                node.operand
+            )
+        if isinstance(node, ast.Compare):
+            return (
+                self._is_bool(node.left)
+                and self._is_bool(node.comparators[0])
+                and isinstance(node.ops[0], (ast.Eq, ast.NotEq))
+            )
+        if isinstance(node, ast.Call):
+            return (
+                isinstance(node.func, ast.Name) and node.func.id == LogicalXor.__name__
+            )
+        return False
+
+    def _convert_bin_op_to_bool_op(self, node: ast.BinOp) -> ast.AST:
+        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])
+        if isinstance(node.op, ast.BitXor):
+            return self._simplify_xor(node)
+        raise ClassiqInternalExpansionError
+
+    @staticmethod
+    def _simplify_xor(node: ast.BinOp) -> ast.AST:
+        if not (
+            isinstance(node.left, ast.Constant) or isinstance(node.right, ast.Constant)
+        ):
+            return ast.Call(
+                func=ast.Name(LogicalXor.__name__),
+                args=[node.left, node.right],
+                keywords=[],
+            )
+
+        if isinstance(node.left, ast.Constant):
+            constant = node.left.value
+            other = node.right
+        else:
+            if TYPE_CHECKING:
+                assert isinstance(node.right, ast.Constant)
+            try:
+                constant = node.right.value
+            except AttributeError as e:
+                raise e
+            other = node.left
+
+        return other if constant == 0 else ast.UnaryOp(op=ast.Not(), operand=other)
+
+    @staticmethod
+    def _simplify_trivial_equality(node: ast.Compare) -> ast.AST:
+        if isinstance(node.left, ast.Constant):
+            val = node.left.value
+            other = node.comparators[0]
+        else:
+            if TYPE_CHECKING:
+                assert isinstance(node.comparators[0], ast.Constant)
+            val = node.comparators[0].value
+            other = node.left
+
+        to_invert = (val == 0 and isinstance(node.ops[0], ast.Eq)) or (
+            val == 1 and isinstance(node.ops[0], ast.NotEq)
+        )
+
+        return ast.UnaryOp(op=ast.Not(), operand=other) if to_invert else other
+
+
+class BooleanExpressionFuncLibAdapter(ast.NodeTransformer):
+    """
+    The class assumes that the expression result is single-qubit.
+
+    Due to limitations on the inplace arithmetic in our function library, this visitor checks whether
+    the expression has one of the following forms:
+    a. A single, simple boolean assignment (res ^= x).
+    b. A bitwise-not operation on a boolean expression (res ^= ~(x > 5)).
+    The former will be transformed into res ^= (x == 1). The latter to (res ^= x > 5) and then the Interpreter
+    will append an X gate to the result variable.
+    To understand the necessity of this transformation, see the _OPERATIONS_ALLOWING_TARGET variable
+    which limits the possible inplace operations. Not is forbidden, and a simple assignment res ^= x
+    is converted into an addition res ^= x + 0, which is also forbidden.
+
+    """
+
+    def __init__(self, is_boolean_optimized: bool) -> None:
+        self._to_invert: bool = False
+        self._is_boolean_optimized = is_boolean_optimized
+
+    @property
+    def to_invert(self) -> bool:
+        return self._to_invert
+
+    def visit_Expr(self, node: ast.Expr) -> ast.Expr:
+        self.generic_visit(node)
+        if isinstance(node.value, ast.Name):
+            node.value = ast.Compare(
+                left=node.value,
+                ops=[ast.Eq()],
+                comparators=[ast.Constant(value=1)],
+            )
+        if isinstance(node.value, ast.UnaryOp) and isinstance(
+            node.value.op, (ast.Not, ast.Invert)
+        ):
+            self._to_invert = not self._to_invert
+            node.value = node.value.operand
+            return self.visit(node)
+
+        return node
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.UnaryOp:
+        """Due to Sympy crap, we need to translate the Invert nodes to Not"""
+        if not (self._is_boolean_optimized and isinstance(node.op, ast.Invert)):
+            return node
+        self.generic_visit(node)
+        return ast.UnaryOp(op=ast.Not(), operand=node.operand)
+
+    def visit_BinOp(self, node: ast.BinOp) -> Union[ast.BinOp, ast.Call]:
+        """Due to Sympy crap, we need to translate the Xor nodes to our LogicalXor"""
+        if not (self._is_boolean_optimized and isinstance(node.op, ast.BitXor)):
+            return node
+        self.generic_visit(node)
+        return ast.Call(
+            func=ast.Name(LogicalXor.__name__),
+            args=[node.left, node.right],
+            keywords=[],
+        )

classiq/model_expansions/visitors/variable_references.py

@@ -0,0 +1,115 @@
+import ast
+from contextlib import contextmanager
+from typing import Dict, Iterator, Optional, Set, Union
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.arith.arithmetic_expression_validator import (
+    DEFAULT_SUPPORTED_FUNC_NAMES,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.sympy_supported_expressions import (
+    SYMPY_SUPPORTED_EXPRESSIONS,
+)
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+
+
+class VarRefCollector(ast.NodeVisitor):
+    def __init__(self, ignore_duplicated_handles: bool = False) -> None:
+        self.var_handles: Set[HandleBinding] = set()
+        self._ignore_duplicated_handles = ignore_duplicated_handles
+        self._is_nested = False
+
+    def visit(self, node: ast.AST) -> Union[
+        SubscriptHandleBinding,
+        SlicedHandleBinding,
+        FieldHandleBinding,
+        HandleBinding,
+        None,
+    ]:
+        res = super().visit(node)
+        if not self._ignore_duplicated_handles and len(self.var_handles) != len(
+            {handle.name for handle in self.var_handles}
+        ):
+            raise ClassiqExpansionError(
+                "Multiple non-identical variable references in an expression are not supported."
+            )
+        return res
+
+    def visit_Subscript(
+        self, node: ast.Subscript
+    ) -> Union[SubscriptHandleBinding, SlicedHandleBinding, None]:
+        with self.set_nested():
+            base_handle = self.visit(node.value)
+        if base_handle is None:
+            return None
+
+        handle: Union[SubscriptHandleBinding, SlicedHandleBinding]
+        if isinstance(node.slice, ast.Num):
+            handle = SubscriptHandleBinding(
+                base_handle=base_handle,
+                index=Expression(expr=str(node.slice.value)),
+            )
+        elif isinstance(node.slice, ast.Slice):
+            if not isinstance(node.slice.lower, ast.Num) or not isinstance(
+                node.slice.upper, ast.Num
+            ):
+                raise ClassiqInternalExpansionError("Unevaluated slice bounds.")
+            handle = SlicedHandleBinding(
+                base_handle=base_handle,
+                start=Expression(expr=str(node.slice.lower.value)),
+                end=Expression(expr=str(node.slice.upper.value)),
+            )
+        else:
+            raise ClassiqInternalExpansionError("Unevaluated slice.")
+
+        if not self._is_nested:
+            self.var_handles.add(handle)
+        return handle
+
+    def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
+        with self.set_nested():
+            base_handle = self.visit(node.value)
+        if base_handle is None:
+            return None
+        handle = FieldHandleBinding(
+            base_handle=base_handle,
+            field=node.attr,
+        )
+        if not self._is_nested:
+            self.var_handles.add(handle)
+        return handle
+
+    def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
+        if node.id in set(SYMPY_SUPPORTED_EXPRESSIONS) | set(
+            DEFAULT_SUPPORTED_FUNC_NAMES
+        ):
+            return None
+        handle = HandleBinding(name=node.id)
+        if not self._is_nested:
+            self.var_handles.add(handle)
+        return handle
+
+    @contextmanager
+    def set_nested(self) -> Iterator[None]:
+        previous_is_nested = self._is_nested
+        self._is_nested = True
+        yield
+        self._is_nested = previous_is_nested
+
+
+class VarRefTransformer(ast.NodeTransformer):
+    def __init__(self, var_mapping: Dict[str, str]) -> None:
+        self.var_mapping = var_mapping
+
+    def visit_Name(self, node: ast.Name) -> ast.Name:
+        if node.id in self.var_mapping:
+            node.id = self.var_mapping[node.id]
+        return node

classiq/qmod/__init__.py

@@ -1,14 +1,13 @@
-from . import symbolic
 from .builtins import *  # noqa: F403
 from .builtins import __all__ as _builtins_all
 from .cfunc import cfunc
+from .create_model_function import create_model
 from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
 from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
 from .qmod_variable import Input, Output, QArray, QBit, QNum, QStruct
 from .quantum_callable import QCallable, QCallableList
-from .quantum_function import create_model
 from .write_qmod import write_qmod
 
 __all__ = [
@@ -30,6 +29,5 @@ __all__ = [
     "create_model",
     "get_expression_numeric_attributes",
     "qfunc",
-    "symbolic",
     "write_qmod",
 ] + _builtins_all