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

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -0,0 +1,218 @@
+import ast
+from abc import abstractmethod
+from itertools import chain
+from typing import TYPE_CHECKING, Dict, List, Tuple, TypeVar
+
+import sympy
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.sympy_conversion.sympy_to_python import (
+    translate_sympy_quantum_expression,
+)
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+ExpressionOperationT = TypeVar("ExpressionOperationT", bound=QuantumExpressionOperation)
+
+
+class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
+    @abstractmethod
+    def emit(self, op: ExpressionOperationT, /) -> None:
+        pass
+
+    def _emit_with_split(
+        self,
+        op: ExpressionOperationT,
+        expression: Expression,
+        symbols_to_split: List[QuantumSymbol],
+    ) -> None:
+        symbols_parts, bind_ops = self._get_bind_ops(symbols_to_split)
+
+        for symbol_parts in symbols_parts:
+            for symbol in symbol_parts:
+                if symbol.handle.identifier not in self._current_scope:
+                    self._interpreter.emit_statement(
+                        VariableDeclarationStatement(
+                            name=symbol.handle.identifier,
+                            quantum_type=symbol.quantum_type,
+                        )
+                    )
+
+        new_expression = self._update_op_expression(
+            {symbol.handle: symbol for symbol in chain.from_iterable(symbols_parts)},
+            expression,
+        )
+        new_op = op.copy(update=dict(expression=new_expression))
+
+        self._interpreter.emit_statement(
+            WithinApply(
+                compute=bind_ops,
+                action=[new_op],
+                source_ref=op.source_ref,
+            )
+        )
+
+    def _update_op_expression(
+        self,
+        symbol_parts: Dict[HandleBinding, QuantumSymbol],
+        expression: Expression,
+    ) -> Expression:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+
+        new_expr_str = expression.expr
+        for handle in vrc.var_handles:
+            collapsed_handle = handle.collapse()
+            if collapsed_handle in symbol_parts:
+                new_expr_str = new_expr_str.replace(
+                    str(handle), symbol_parts[collapsed_handle].handle.identifier
+                )
+        self._check_all_handles_were_replaced(new_expr_str)
+
+        new_expr = Expression(expr=new_expr_str)
+        new_expr._evaluated_expr = EvaluatedExpression(
+            value=self._interpreter.evaluate(new_expr).value
+        )
+        return new_expr
+
+    @staticmethod
+    def _check_all_handles_were_replaced(new_expr_str: str) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(new_expr_str))
+        for handle in vrc.var_handles:
+            if isinstance(
+                handle,
+                (SubscriptHandleBinding, SlicedHandleBinding, FieldHandleBinding),
+            ):
+                raise ClassiqInternalExpansionError(f"Did not replace handle {handle}")
+
+    @staticmethod
+    def _get_bind_ops(
+        symbols_to_split: List[QuantumSymbol],
+    ) -> Tuple[List[List[QuantumSymbol]], List[BindOperation]]:
+        bind_ops = []
+        symbols_parts = []
+        for symbol in symbols_to_split:
+            symbol_parts = ExpressionOperationEmitter._get_symbol_parts(symbol)
+            symbols_parts.append(symbol_parts)
+            bind_ops.append(
+                BindOperation(
+                    in_handles=[symbol.handle],
+                    out_handles=[
+                        HandleBinding(name=symbol_part.handle.identifier)
+                        for symbol_part in symbol_parts
+                    ],
+                )
+            )
+        return symbols_parts, bind_ops
+
+    @staticmethod
+    def _get_symbol_parts(symbol: QuantumSymbol) -> List[QuantumSymbol]:
+        quantum_type = symbol.quantum_type
+
+        if isinstance(quantum_type, (QuantumBit, QuantumNumeric)):
+            return [symbol]
+
+        if isinstance(quantum_type, QuantumBitvector):
+            if not quantum_type.has_length:
+                raise ClassiqExpansionError(
+                    f"Could not determine the length of quantum array "
+                    f"{symbol.handle}."
+                )
+            return list(
+                chain.from_iterable(
+                    ExpressionOperationEmitter._get_symbol_parts(symbol[idx])
+                    for idx in range(quantum_type.length_value)
+                )
+            )
+
+        if TYPE_CHECKING:
+            assert isinstance(quantum_type, TypeName)
+
+        return list(
+            chain.from_iterable(
+                ExpressionOperationEmitter._get_symbol_parts(field_symbol)
+                for field_symbol in symbol.fields.values()
+            )
+        )
+
+    def _get_symbols_to_split(self, expression: Expression) -> List[QuantumSymbol]:
+        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(handle, (SubscriptHandleBinding, FieldHandleBinding))
+        )
+        return [
+            symbol
+            for symbol_name in symbol_names_to_split
+            if isinstance(
+                symbol := self._current_scope[symbol_name].value,
+                QuantumSymbol,
+            )
+        ]
+
+    def _evaluate_op_expression(self, op: ExpressionOperationT) -> Expression:
+        return self._evaluate_expression(op.expression)
+
+    def _evaluate_expression(self, expression: Expression) -> Expression:
+        evaluated_expression = self._interpreter.evaluate(expression)
+        if isinstance(evaluated_expression.value, sympy.Basic):
+            new_expression = Expression(
+                expr=translate_sympy_quantum_expression(evaluated_expression.value)
+            )
+        else:
+            new_expression = Expression(expr=str(evaluated_expression.value))
+        new_expression._evaluated_expr = EvaluatedExpression(
+            value=evaluated_expression.value
+        )
+        return new_expression
+
+    def _evaluate_types_in_expression(
+        self, op: ExpressionOperationT, expression: Expression
+    ) -> ExpressionOperationT:
+        op_with_evaluated_types = op.copy(update={"expression": expression})
+        vrc = VarRefCollector()
+        vrc.visit(ast.parse(op_with_evaluated_types.expression.expr))
+        handles = list(vrc.var_handles)
+        op_with_evaluated_types.set_var_handles(handles)
+        op_with_evaluated_types.initialize_var_types(
+            {
+                handle.name: self._interpreter.evaluate(handle)
+                .as_type(QuantumSymbol)
+                .quantum_type
+                for handle in handles
+            },
+            self._machine_precision,
+        )
+        return op_with_evaluated_types

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -0,0 +1,250 @@
+from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.inplace_binary_operation import (
+    BinaryOperation,
+    InplaceBinaryOperation,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_types_in_quantum_symbols,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    validate_inplace_binary_op_vars,
+)
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.qmod.builtins.functions import integer_xor, modular_add
+
+
+def _binary_function_declaration(
+    op: BinaryOperation,
+) -> NamedParamsQuantumFunctionDeclaration:
+    return {
+        BinaryOperation.Addition: modular_add.func_decl,
+        BinaryOperation.Xor: integer_xor.func_decl,
+    }[op]
+
+
+class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
+    def emit(self, op: InplaceBinaryOperation, /) -> None:
+        value_var = self._interpreter.evaluate(op.value).as_type(QuantumSymbol)
+        target_var = self._interpreter.evaluate(op.target).as_type(QuantumSymbol)
+        value_var, target_var = evaluate_types_in_quantum_symbols(
+            [value_var, target_var], self._current_scope
+        )
+        validate_inplace_binary_op_vars(value_var, target_var, op.operation.value)
+        if TYPE_CHECKING:
+            assert isinstance(value_var.quantum_type, QuantumNumeric)
+            assert isinstance(target_var.quantum_type, QuantumNumeric)
+
+        sign_diff = int(value_var.quantum_type.sign_value) - int(
+            target_var.quantum_type.sign_value
+        )
+        frac_digits_diff = (
+            value_var.quantum_type.fraction_digits_value
+            - target_var.quantum_type.fraction_digits_value
+        )
+        if (
+            sign_diff + frac_digits_diff == value_var.quantum_type.size_in_bits
+            or -sign_diff - frac_digits_diff == target_var.quantum_type.size_in_bits
+        ):
+            with self._propagated_var_stack.capture_variables(op):
+                return
+
+        value_var = QuantumSymbol(
+            handle=HandleBinding(name="value"), quantum_type=value_var.quantum_type
+        )
+        target_var = QuantumSymbol(
+            handle=HandleBinding(name="target"),
+            quantum_type=target_var.quantum_type,
+        )
+        inplace_binary_op_function = FunctionClosure.create(
+            name=op.operation.value,
+            positional_arg_declarations=[
+                PortDeclaration(
+                    name=value_var.handle.name,
+                    quantum_type=value_var.quantum_type,
+                    direction=PortDeclarationDirection.Inout,
+                ),
+                PortDeclaration(
+                    name=target_var.handle.name,
+                    quantum_type=target_var.quantum_type,
+                    direction=PortDeclarationDirection.Inout,
+                ),
+            ],
+            body=_build_inplace_binary_operation(
+                value_var=value_var,
+                target_var=target_var,
+                frac_digits_diff=frac_digits_diff,
+                internal_function_declaration=_binary_function_declaration(
+                    op.operation
+                ),
+            ),
+            scope=Scope(parent=self._current_scope),
+        )
+        with self._propagated_var_stack.capture_variables(op):
+            self._emit_quantum_function_call(
+                inplace_binary_op_function, [op.value, op.target]
+            )
+
+
+def _build_inplace_binary_operation(
+    value_var: QuantumSymbol,
+    target_var: QuantumSymbol,
+    frac_digits_diff: int,
+    internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
+) -> List[QuantumStatement]:
+    if TYPE_CHECKING:
+        assert isinstance(value_var.quantum_type, QuantumNumeric)
+        assert isinstance(target_var.quantum_type, QuantumNumeric)
+
+    value_overlap_var, value_sign_var, value_bind_targets = _get_inplace_bind_targets(
+        "value", value_var, frac_digits_diff
+    )
+    target_overlap_var, target_sign_var, target_bind_targets = (
+        _get_inplace_bind_targets("target", target_var, -frac_digits_diff)
+    )
+
+    value_pre_ops, value_post_ops = _get_inplace_pre_post_ops(
+        value_var, value_bind_targets
+    )
+    target_pre_ops, target_post_ops = _get_inplace_pre_post_ops(
+        target_var, target_bind_targets
+    )
+
+    binary_ops = []
+    if value_overlap_var is not None and target_overlap_var is not None:
+        binary_ops.append(
+            _internal_inplace_binary_operation_function_call(
+                internal_function_declaration,
+                value_overlap_var.handle,
+                target_overlap_var.handle,
+            )
+        )
+    if value_sign_var is not None and target_sign_var is not None:
+        binary_ops.append(
+            _internal_inplace_binary_operation_function_call(
+                internal_function_declaration,
+                value_sign_var.handle,
+                target_sign_var.handle,
+            )
+        )
+    if len(binary_ops) == 0:
+        raise ClassiqInternalExpansionError("Bug in unrolling inplace operation")
+
+    return [
+        *value_pre_ops,
+        *target_pre_ops,
+        *binary_ops,
+        *target_post_ops,
+        *value_post_ops,
+    ]
+
+
+def _internal_inplace_binary_operation_function_call(
+    internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
+    value_var: HandleBinding,
+    target_var: HandleBinding,
+) -> QuantumFunctionCall:
+    internal_function_call = QuantumFunctionCall(
+        function=internal_function_declaration.name,
+        positional_args=[value_var, target_var],
+    )
+    internal_function_call.set_func_decl(internal_function_declaration)
+    return internal_function_call
+
+
+def _get_inplace_bind_targets(
+    kind: str, var: QuantumSymbol, frac_digits_diff: int
+) -> Tuple[Optional[QuantumSymbol], Optional[QuantumSymbol], List[QuantumSymbol]]:
+    quantum_type = var.quantum_type
+    if TYPE_CHECKING:
+        assert isinstance(quantum_type, QuantumNumeric)
+
+    if not quantum_type.sign_value and frac_digits_diff <= 0:
+        return var, None, []
+
+    significand_overlap = (
+        quantum_type.size_in_bits
+        - quantum_type.fraction_digits_value
+        - int(quantum_type.sign_value)
+    )
+    fraction_overlap = quantum_type.fraction_digits_value - max(0, frac_digits_diff)
+    if significand_overlap + fraction_overlap == 0 and quantum_type.size_in_bits == 1:
+        assert quantum_type.sign_value
+        return None, var, []
+
+    bind_targets = []
+
+    if frac_digits_diff > 0:
+        bind_targets.append(
+            QuantumSymbol(
+                handle=HandleBinding(name=f"trimmed_{kind}_fraction_digits"),
+                quantum_type=QuantumBitvector(
+                    length=Expression(expr=str(frac_digits_diff)),
+                ),
+            )
+        )
+
+    overlap_var = None
+    if significand_overlap + fraction_overlap > 0:
+        overlap_var = QuantumSymbol(
+            handle=HandleBinding(name=f"{kind}_overlap"),
+            quantum_type=QuantumNumeric(
+                size=Expression(expr=str(significand_overlap + fraction_overlap)),
+                is_signed=Expression(expr="False"),
+                fraction_digits=Expression(expr=str(fraction_overlap)),
+            ),
+        )
+        bind_targets.append(overlap_var)
+
+    sign_var = None
+    if quantum_type.sign_value:
+        sign_var = QuantumSymbol(
+            handle=HandleBinding(name=f"trimmed_{kind}_sign"),
+            quantum_type=QuantumBit(),
+        )
+        bind_targets.append(sign_var)
+
+    return overlap_var, sign_var, bind_targets
+
+
+def _get_inplace_pre_post_ops(
+    var: QuantumSymbol, bind_targets: List[QuantumSymbol]
+) -> Tuple[Sequence[QuantumStatement], Sequence[QuantumStatement]]:
+    if len(bind_targets) == 0:
+        return [], []
+
+    value_bind_op = BindOperation(
+        in_handles=[var.handle],
+        out_handles=[var.handle for var in bind_targets],
+    )
+    return [
+        VariableDeclarationStatement(
+            name=var.handle.name,
+            quantum_type=var.quantum_type,
+        )
+        for var in bind_targets
+    ] + [value_bind_op], [value_bind_op.reversed()]

classiq/model_expansions/quantum_operations/invert.py

@@ -0,0 +1,38 @@
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    INVERT_OPERATOR_NAME,
+)
+from classiq.interface.model.invert import Invert
+
+from classiq.model_expansions.closure import Closure
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Scope
+
+
+class InvertEmitter(Emitter[Invert]):
+    def emit(self, invert: Invert, /) -> None:
+        if self._should_wrap(invert.body):
+            self._emit_wrapped(invert)
+            return
+
+        self._emit_as_operation(invert)
+
+    def _emit_as_operation(self, invert: Invert) -> None:
+        invert_operation = Closure(
+            name=INVERT_OPERATOR_NAME,
+            blocks={"body": invert.body},
+            scope=Scope(parent=self._current_scope),
+        )
+        with self._propagated_var_stack.capture_variables(invert):
+            context = self._expand_operation(invert_operation)
+        self._builder.emit_statement(
+            Invert(body=context.statements("body"), source_ref=invert.source_ref)
+        )
+
+    def _emit_wrapped(self, invert: Invert) -> None:
+        with self._propagated_var_stack.capture_variables(invert):
+            wrapping_function = self._create_expanded_wrapping_function(
+                INVERT_OPERATOR_NAME, invert.body
+            )
+        self._builder.emit_statement(
+            Invert(body=[wrapping_function], source_ref=invert.source_ref)
+        )

classiq/model_expansions/quantum_operations/power.py

@@ -0,0 +1,74 @@
+from typing import Union
+
+import sympy
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    POWER_OPERATOR_NAME,
+)
+from classiq.interface.model.power import Power
+
+from classiq.model_expansions.closure import Closure
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Scope
+
+
+class PowerEmitter(Emitter[Power]):
+    _power_value: Union[int, sympy.Basic]
+    _power_expr: Expression
+
+    def emit(self, power: Power, /) -> None:
+        self._power = power
+        self._power_value = self._get_power_value()
+        self._power_expr = Expression(
+            expr=str(self._power_value), source_ref=power.power.source_ref
+        )
+        self._power_expr._evaluated_expr = EvaluatedExpression(value=self._power_value)
+
+        if len(power.body) > 1 and isinstance(self._power_value, sympy.Basic):
+            self._emit_wrapped()
+            return
+
+        self._emit_as_operation(power)
+
+    def _emit_as_operation(self, power: Power) -> None:
+        power_operation = Closure(
+            name=POWER_OPERATOR_NAME,
+            blocks=dict(body=self._power.body),
+            scope=Scope(parent=self._current_scope),
+        )
+        with self._propagated_var_stack.capture_variables(self._power):
+            context = self._expand_operation(power_operation)
+        self._builder.emit_statement(
+            Power(
+                body=context.statements("body"),
+                power=self._power_expr,
+                source_ref=power.source_ref,
+            )
+        )
+
+    def _emit_wrapped(self) -> None:
+        with self._propagated_var_stack.capture_variables(self._power):
+            wrapping_function = self._create_expanded_wrapping_function(
+                POWER_OPERATOR_NAME, self._power.body
+            )
+        self._builder.emit_statement(
+            Power(
+                body=[wrapping_function],
+                power=self._power_expr,
+                source_ref=self._power.source_ref,
+            )
+        )
+
+    def _get_power_value(self) -> Union[int, sympy.Basic]:
+        power_value = self._interpreter.evaluate(self._power.power).value
+        if not (isinstance(power_value, int) or power_value.is_symbol):
+            raise ClassiqExpansionError(
+                f"`power`'s argument should be an integer or identifier. Complex "
+                f"expressions are not supported. Got {str(power_value)!r}"
+            )
+        return power_value