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

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -0,0 +1,179 @@
+import ast
+from typing import TYPE_CHECKING, cast
+
+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 isinstance(node.func, ast.Name) and node.func.id == "Piecewise":
+            return self._visit_piecewise(node)
+
+        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_piecewise(self, node: ast.Call) -> ast.AST:
+        # sympy Piecewise expression may include bitwise operations:
+        # Piecewise((0, Eq(x, 0)), (0.5, Eq(x, 1) | Eq(x, 2)), (1, True))
+        #                                         ^
+        # We should avoid converting these to 'BitwiseOr' and such.
+        return ast.Call(
+            func=node.func,
+            args=[
+                ast.Tuple(
+                    elts=(
+                        self.generic_visit(cast(ast.Tuple, arg).elts[0]),
+                        cast(ast.Tuple, arg).elts[1],
+                    )
+                )
+                for arg in node.args
+            ],
+            keywords=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=[],
+        )
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.Call:
+        return ast.Call(
+            func=ast.Name("get_field"),
+            args=[node.value, ast.Constant(value=node.attr)],
+            keywords=[],
+        )

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -0,0 +1,123 @@
+import functools
+from typing import Any, 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])}))"
+
+
+class SympyToBoolExpressionTranslator(SympyToQuantumExpressionTranslator):
+    _operators = {
+        **SympyToQuantumExpressionTranslator._operators,
+        **{"not": "not ", "xor": "xor"},
+    }
+
+
+def translate_sympy_quantum_expression(expr: Basic, preserve_bool_ops: bool) -> str:
+    if preserve_bool_ops:
+        return SympyToBoolExpressionTranslator().doprint(expr)
+    else:
+        return SympyToQuantumExpressionTranslator().doprint(expr)

classiq/model_expansions/transformers/ast_renamer.py

@@ -0,0 +1,26 @@
+import ast
+
+_POSSIBLE_HANDLE_AST_TYPES = (ast.Subscript, ast.Attribute, ast.Name)
+
+
+class _ASTRenamer(ast.NodeTransformer):
+    def __init__(self, sub: dict[str, str]) -> None:
+        self._sub = sub
+
+    def visit(self, node: ast.AST) -> ast.AST:
+        if isinstance(node, _POSSIBLE_HANDLE_AST_TYPES):
+            node_expr = ast.unparse(node)
+            if node_expr in self._sub:
+                return ast.Name(id=self._sub[node_expr])
+        return super().visit(node)
+
+    def visit_Call(self, node: ast.Call) -> ast.Call:
+        return ast.Call(
+            func=node.func,
+            args=[self.visit(arg) for arg in node.args],
+            keywords=[],
+        )
+
+
+def rename_variables(expr: str, sub: dict[str, str]) -> str:
+    return ast.unparse(_ASTRenamer(sub).visit(ast.parse(expr)))

classiq/model_expansions/transformers/var_splitter.py

@@ -0,0 +1,299 @@
+import ast
+from dataclasses import dataclass
+from itertools import chain
+from typing import TYPE_CHECKING, Callable, Optional, TypeVar, cast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.visitor import NodeType, Transformer
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    NestedHandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumScalar,
+    QuantumType,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+AST_NODE = TypeVar("AST_NODE", bound=NodeType)
+
+
+@dataclass(frozen=True)
+class SymbolPart:
+    source_handle: HandleBinding
+    target_var_name: str
+    target_var_type: QuantumType
+
+    @property
+    def target_var_handle(self) -> HandleBinding:
+        return HandleBinding(name=self.target_var_name)
+
+
+SymbolParts = dict[HandleBinding, list[SymbolPart]]
+PartNamer = Callable[[str], str]
+
+
+class VarSplitter:
+    def __init__(self, scope: Scope):
+        self._scope = scope
+
+    def split_symbols(self, expression: Expression, namer: PartNamer) -> SymbolParts:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+        symbol_names_to_split = dict.fromkeys(
+            handle.name
+            for handle in vrc.var_handles
+            if isinstance(self._scope[handle.name].value, QuantumSymbol)
+            and isinstance(handle, NestedHandleBinding)
+        )
+
+        symbol_handles = {
+            symbol: list(
+                dict.fromkeys(
+                    handle.collapse()
+                    for handle in vrc.var_handles
+                    if handle.name == symbol.handle.name
+                )
+            )
+            for symbol_name in symbol_names_to_split
+            if isinstance(
+                symbol := self._scope[symbol_name].value,
+                QuantumSymbol,
+            )
+        }
+
+        return {
+            symbol.handle: [
+                SymbolPart(
+                    source_handle=part.handle,
+                    target_var_name=namer(part.handle.identifier),
+                    target_var_type=part.quantum_type,
+                )
+                for part in self._get_symbol_parts(symbol, handles)
+            ]
+            for symbol, handles in symbol_handles.items()
+        }
+
+    def _get_symbol_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        for i in range(len(target_parts)):
+            for j in range(i + 1, len(target_parts)):
+                if target_parts[i].overlaps(target_parts[j]):
+                    raise ClassiqInternalExpansionError(
+                        f"Handles {str(target_parts[i])!r} and "
+                        f"{str(target_parts[j])!r} overlapping in expression"
+                    )
+        return self._get_symbol_parts_unsafe(symbol, target_parts)
+
+    def _get_symbol_parts_unsafe(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        if all(
+            symbol.handle == target_part or symbol.handle not in target_part.prefixes()
+            for target_part in target_parts
+        ) or isinstance(symbol.quantum_type, QuantumScalar):
+            return [symbol]
+
+        if isinstance(symbol.quantum_type, QuantumBitvector):
+            return self._get_array_parts(symbol, target_parts)
+
+        return self._get_struct_parts(symbol, target_parts)
+
+    def _get_array_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+
+        if not symbol.quantum_type.has_length:
+            raise ClassiqExpansionError(
+                f"Could not determine the length of quantum array " f"{symbol.handle}."
+            )
+        target_slices = self._get_target_slices(symbol, target_parts)
+
+        symbol_parts: list[QuantumSymbol] = []
+        idx = 0
+        while idx < symbol.quantum_type.length_value:
+            if idx in target_slices:
+                stop = target_slices[idx]
+                if stop <= idx:
+                    raise ClassiqInternalExpansionError(
+                        f"Illegal sliced handle {str(symbol[idx: stop].handle)!r}"
+                    )
+                symbol_parts.append(symbol[idx:stop])
+                idx = stop
+            else:
+                symbol_parts.extend(
+                    self._get_symbol_parts_unsafe(symbol[idx], target_parts)
+                )
+                idx += 1
+
+        return symbol_parts
+
+    def _get_target_slices(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> dict[int, int]:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+        target_items = {
+            idx
+            for idx in range(symbol.quantum_type.length_value)
+            for target_part in target_parts
+            if target_part
+            in SubscriptHandleBinding(
+                base_handle=symbol.handle, index=Expression(expr=str(idx))
+            )
+        }
+        target_slices = {
+            target_part.start.to_int_value(): target_part.end.to_int_value()
+            for target_part in target_parts
+            if isinstance(target_part, SlicedHandleBinding)
+            and symbol.handle == target_part.base_handle
+        }
+        self._add_unused_indices_as_slices(symbol, target_items, target_slices)
+        return target_slices
+
+    @staticmethod
+    def _add_unused_indices_as_slices(
+        symbol: QuantumSymbol, target_items: set[int], target_slices: dict[int, int]
+    ) -> None:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+        last_unused_idx: Optional[int] = None
+        array_length = symbol.quantum_type.length_value
+        idx = 0
+
+        while idx < array_length:
+            if (
+                idx in target_items or idx in target_slices
+            ) and last_unused_idx is not None:
+                target_slices[last_unused_idx] = idx
+                last_unused_idx = None
+
+            if idx in target_slices:
+                if target_slices[idx] <= idx:
+                    raise ClassiqInternalExpansionError
+                idx = target_slices[idx]
+                continue
+
+            if idx not in target_items and last_unused_idx is None:
+                last_unused_idx = idx
+
+            idx += 1
+
+        if last_unused_idx is not None:
+            target_slices[last_unused_idx] = array_length
+
+    def _get_struct_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        return list(
+            chain.from_iterable(
+                self._get_symbol_parts_unsafe(field_symbol, target_parts)
+                for field_symbol in symbol.fields.values()
+            )
+        )
+
+    @staticmethod
+    def get_bind_ops(symbol_parts: SymbolParts) -> list[BindOperation]:
+        return [
+            BindOperation(
+                in_handles=[handle],
+                out_handles=[part.target_var_handle for part in parts],
+            )
+            for handle, parts in symbol_parts.items()
+        ]
+
+    @staticmethod
+    def get_var_decls(symbol_parts: SymbolParts) -> list[VariableDeclarationStatement]:
+        return [
+            VariableDeclarationStatement(
+                name=part.target_var_name,
+                quantum_type=part.target_var_type,
+            )
+            for part in chain.from_iterable(symbol_parts.values())
+        ]
+
+    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolParts) -> AST_NODE:
+        if len(symbol_mapping) == 0:
+            return subject
+        handle_replacements = {
+            part.source_handle: part.target_var_handle
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+
+        class ReplaceSplitVars(Transformer):
+            @staticmethod
+            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
+                handle = handle.collapse()
+                for handle_to_replace, replacement in handle_replacements.items():
+                    handle = handle.replace_prefix(handle_to_replace, replacement)
+                return handle
+
+            @staticmethod
+            def visit_Expression(expr: Expression) -> Expression:
+                return self._rewrite_expression(symbol_mapping, expr)
+
+            def visit_QuantumExpressionOperation(
+                self, op: QuantumExpressionOperation
+            ) -> QuantumExpressionOperation:
+                op = cast(QuantumExpressionOperation, self.generic_visit(op))
+                previous_var_handles = list(op._var_handles)
+                op._var_handles = self.visit(op._var_handles)
+                op._var_types = {
+                    new_handle.name: op._var_types.get(
+                        new_handle.name, op._var_types[previous_handle.name]
+                    )
+                    for previous_handle, new_handle in zip(
+                        previous_var_handles, op._var_handles
+                    )
+                }
+                return op
+
+        return ReplaceSplitVars().visit(subject)
+
+    def _rewrite_expression(
+        self,
+        symbol_mapping: SymbolParts,
+        expression: Expression,
+    ) -> Expression:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+
+        handle_names = {
+            part.source_handle: part.target_var_handle
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+        new_expr_str = expression.expr
+        for handle in vrc.var_handles:
+            new_handle = handle.collapse()
+            for handle_to_replace, replacement in handle_names.items():
+                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
+            new_expr_str = new_expr_str.replace(str(handle), str(new_handle))
+            if handle.qmod_expr != str(handle):
+                new_expr_str = new_expr_str.replace(
+                    handle.qmod_expr, new_handle.qmod_expr
+                )
+
+        new_expr = Expression(expr=new_expr_str)
+        new_expr._evaluated_expr = expression._evaluated_expr
+        return new_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/utils/handles_collector.py

@@ -0,0 +1,33 @@
+import ast
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.visitor import NodeType, Visitor
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+
+class _HandlesCollector(Visitor):
+    def __init__(self) -> None:
+        self.handles: list[HandleBinding] = []
+
+    def visit_HandleBinding(self, handle: HandleBinding) -> None:
+        self.handles.append(handle)
+
+    def visit_Expression(self, expression: Expression) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+        self.handles.extend(vrc.var_handles)
+
+    def visit_QuantumExpressionOperation(self, op: QuantumExpressionOperation) -> None:
+        self.handles.extend(op.var_handles)
+        self.generic_visit(op)
+
+
+def extract_handles(node: NodeType) -> list[HandleBinding]:
+    collector = _HandlesCollector()
+    collector.visit(node)
+    return collector.handles