classiq 0.63.0__py3-none-any.whl → 0.64.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/phase.py

@@ -1,187 +0,0 @@
-from typing import TYPE_CHECKING
-
-import sympy
-from sympy import sympify
-
-from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
-from classiq.interface.model.phase_operation import PhaseOperation
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_type import (
-    QuantumBitvector,
-    QuantumNumeric,
-    QuantumScalar,
-)
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-from classiq.interface.model.within_apply_operation import WithinApply
-
-from classiq.applications.combinatorial_helpers.transformations.ising_converter import (
-    _find_sub_list_items,
-    _get_vars,
-    _refine_ising_expr,
-    _to_ising_symbolic_objective_function,
-)
-from classiq.model_expansions.quantum_operations.expression_operation import (
-    ExpressionOperationEmitter,
-)
-from classiq.qmod.builtins.functions.exponentiation import suzuki_trotter
-from classiq.qmod.semantics.error_manager import ErrorManager
-
-
-class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
-    def _negate_expression(self, expression: Expression, /) -> Expression:
-        return self._evaluate_expression(
-            expression.model_copy(update=dict(expr=f"-({expression.expr})"))
-        )
-
-    def emit(self, phase_op: PhaseOperation, /) -> None:
-        arrays_with_subscript = self.split_symbols(
-            phase_op.expression, self._counted_name_allocator.allocate
-        )
-        if len(arrays_with_subscript) > 0:
-            self._emit_with_split(phase_op, phase_op.expression, arrays_with_subscript)
-            return
-
-        phase_op = phase_op.model_copy(
-            update=dict(expression=self._negate_expression(phase_op.expression))
-        )
-        phase_op = self._evaluate_types_in_expression(phase_op)
-        if len(phase_op.var_handles) == 0:
-            ErrorManager().add_error(
-                "Cannot perform phase operation on an expression with no quantum variables."
-            )
-            return
-
-        aux_name = self._counted_name_allocator.allocate("phase_aux")
-        if len(phase_op.var_handles) > 1:
-            split_join = True
-            evolution_variable = HandleBinding(name=aux_name)
-        else:
-            split_join = False
-            evolution_variable = phase_op.var_handles[0]
-        expression_evolution_function = QuantumFunctionCall(
-            function=suzuki_trotter.func_decl.name,
-            positional_args=[
-                _convert_cost_expression_to_hamiltonian(
-                    phase_op.expression.expr,
-                    {
-                        var.name: self._current_scope[var.name].value.quantum_type
-                        for var in phase_op.var_handles
-                    },
-                ),
-                phase_op.theta,
-                Expression(expr="1"),
-                Expression(expr="1"),
-                evolution_variable,
-            ],
-            source_ref=phase_op.source_ref,
-        )
-        expression_evolution_function.set_func_decl(suzuki_trotter.func_decl)
-
-        if split_join:
-            self._interpreter.emit_statement(
-                VariableDeclarationStatement(
-                    name=aux_name, quantum_type=QuantumBitvector()
-                )
-            )
-            self._interpreter.emit_statement(
-                WithinApply(
-                    compute=[
-                        BindOperation(
-                            in_handles=phase_op.var_handles,
-                            out_handles=[HandleBinding(name=aux_name)],
-                        )
-                    ],
-                    action=[expression_evolution_function],
-                    source_ref=phase_op.source_ref,
-                )
-            )
-        else:
-            self._interpreter.emit_statement(
-                expression_evolution_function,
-            )
-
-
-def _get_single_bit_vars_expression(
-    expr: sympy.Expr, vars_info: dict[str, QuantumScalar]
-) -> tuple[sympy.Expr, list[sympy.Symbol]]:
-    bit_vars = []
-    for var_name, var_info in vars_info.items():
-        size = var_info.size_in_bits
-        var = sympy.Symbol(var_name)
-        if size == 1:
-            bits = [var]
-            is_signed = False
-            fraction_places = 0
-        else:
-            if TYPE_CHECKING:
-                assert isinstance(var_info, QuantumNumeric)
-            bits = [
-                sympy.Symbol(f"{var_name}{HANDLE_ID_SEPARATOR}{i}__split__")
-                for i in range(size)
-            ]
-            is_signed = var_info.sign_value
-            fraction_places = var_info.fraction_digits_value
-        bit_vars.extend(bits)
-        split_var = 0
-        for i, bit in enumerate(bits):
-            if is_signed and i == size - 1:  # sign bit (MSB)
-                split_var -= bit * 2 ** (size - 1 - fraction_places)
-            else:
-                split_var += bit * 2 ** (i - fraction_places)
-        expr = expr.subs(var, split_var)
-    return expr, bit_vars
-
-
-def _convert_ising_sympy_to_pauli_terms(
-    ising_expr: sympy.Expr, ordered_sympy_vars: list[sympy.Symbol]
-) -> str:
-    pauli_terms: list[str] = []
-    coefficients = ising_expr.as_coefficients_dict(*ordered_sympy_vars)
-    for expr_term in ising_expr.args:
-        expr_vars = _get_vars(expr_term)
-        z_vec = _find_sub_list_items(ordered_sympy_vars, expr_vars)
-        pauli_elements = ["I"] * len(z_vec)
-        for index, is_z_op in enumerate(z_vec):
-            if is_z_op:
-                pauli_elements[len(z_vec) - index - 1] = (
-                    "Z"  # reminder: Pauli reverses the order!
-                )
-        term_var = sympy.Mul(
-            *(var for i, var in enumerate(ordered_sympy_vars) if z_vec[i])
-        )
-        coeff = float(coefficients[term_var])
-        paulis = [f"Pauli.{pauli}" for pauli in pauli_elements]
-        pauli_terms.append(
-            # fmt: off
-                    "struct_literal("
-                    "PauliTerm,"
-                    f"pauli=[{', '.join(paulis)}],"
-                    f"coefficient={Expression(expr=str(coeff))},"
-                    ")"
-            # fmt: on,
-        )
-    return f"[{', '.join(pauli_terms)}]"
-
-
-def _convert_cost_expression_to_hamiltonian(
-    expr: str,
-    vars: dict[str, QuantumScalar],
-) -> Expression:
-    sympy_expr = sympify(expr)
-    single_bit_vars_expression, single_bit_vars = _get_single_bit_vars_expression(
-        sympy_expr, vars
-    )
-    if not single_bit_vars_expression.is_polynomial():
-        raise ClassiqExpansionError(f"phased expression {expr!r} is not polynomial")
-
-    ising_expr = _to_ising_symbolic_objective_function(single_bit_vars_expression)
-    ising_expr = _refine_ising_expr(ising_expr)
-
-    return Expression(
-        expr=_convert_ising_sympy_to_pauli_terms(ising_expr, single_bit_vars)
-    )

classiq/model_expansions/quantum_operations/power.py

@@ -1,71 +0,0 @@
-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.call_emitter import CallEmitter
-from classiq.model_expansions.scope import Scope
-
-
-class PowerEmitter(CallEmitter[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),
-        )
-        context = self._expand_operation(power_operation)
-        self.emit_statement(
-            Power(
-                body=context.statements("body"),
-                power=self._power_expr,
-                source_ref=power.source_ref,
-            )
-        )
-
-    def _emit_wrapped(self) -> None:
-        wrapping_function = self._create_expanded_wrapping_function(
-            POWER_OPERATOR_NAME, self._power.body
-        )
-        self.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 isinstance(power_value, int) and power_value < 0:
-            raise ClassiqExpansionError(
-                f"power exponent must be non-negative, got {power_value}"
-            )
-        return power_value

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -1,230 +0,0 @@
-import ast
-import re
-
-from classiq.interface.exceptions import (
-    ClassiqExpansionError,
-    ClassiqInternalExpansionError,
-)
-from classiq.interface.generator.arith.arithmetic import is_zero
-from classiq.interface.generator.arith.arithmetic_expression_validator import (
-    is_constant,
-)
-from classiq.interface.generator.compiler_keywords import INPLACE_ARITH_AUX_VAR_PREFIX
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.inplace_binary_operation import (
-    BinaryOperation,
-    InplaceBinaryOperation,
-)
-from classiq.interface.model.quantum_expressions.arithmetic_operation import (
-    ArithmeticOperation,
-    ArithmeticOperationKind,
-)
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumAssignmentOperation,
-)
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_type import QuantumNumeric
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-from classiq.interface.model.within_apply_operation import WithinApply
-
-from classiq.model_expansions.capturing.mangling_utils import demangle_handle
-from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
-from classiq.model_expansions.quantum_operations.expression_operation import (
-    ExpressionOperationEmitter,
-)
-from classiq.model_expansions.scope import QuantumSymbol
-from classiq.model_expansions.transformers.var_splitter import SymbolParts
-from classiq.model_expansions.visitors.boolean_expression_transformers import (
-    BooleanExpressionFuncLibAdapter,
-    BooleanExpressionOptimizer,
-)
-from classiq.qmod import builtins
-from classiq.qmod.builtins.functions import X, allocate
-
-HANDLE_ERROR_MESSAGE = (
-    "Quantum variable '{handle_str}' cannot appear on both sides of the assignment"
-)
-
-
-def _is_variable(expr: str) -> bool:
-    return re.fullmatch("[a-zA-Z_][a-zA-Z0-9_]*", expr) is not None
-
-
-class QuantumAssignmentOperationEmitter(
-    ExpressionOperationEmitter[QuantumAssignmentOperation]
-):
-    def emit(self, op: QuantumAssignmentOperation, /) -> None:
-        if self._skip_assignment(op, op.expression.expr):
-            return
-        arrays_with_subscript = self.split_symbols(
-            op.expression, self._counted_name_allocator.allocate
-        )
-        if len(arrays_with_subscript) > 0:
-            self._emit_with_split(op, op.expression, arrays_with_subscript)
-            return
-
-        self._emit_op(op)
-
-    def _emit_op(self, op: QuantumAssignmentOperation) -> None:
-        op = self._evaluate_types_in_expression(op)
-        if isinstance(op, ArithmeticOperation):
-            self._emit_arithmetic_op(op)
-            return
-        self._emit_general_assignment_operation(op)
-
-    def _emit_arithmetic_op(self, op: ArithmeticOperation) -> None:
-        op, expression, is_bool_opt = self._optimize_boolean_expression(op)
-        if op.is_inplace:
-            self._emit_inplace_arithmetic_op(op, expression, is_bool_opt)
-        else:
-            self._emit_general_assignment_operation(op)
-
-    def _emit_inplace_arithmetic_op(
-        self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
-    ) -> None:
-        target = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
-        if (
-            op.operation_kind != ArithmeticOperationKind.InplaceXor
-            or op.result_type.size_in_bits > 1
-            or not self._is_res_boolean(op)
-            or target.quantum_type.size_in_bits > 1
-            or is_constant(expression.expr)
-        ):
-            _validate_naive_inplace_handles(op)
-            self._build_naive_inplace(op, expression)
-            return
-
-        op, expression, to_invert = self._adapt_boolean_inplace(
-            op, expression, is_bool_opt
-        )
-        self._emit_general_assignment_operation(op)
-        if not to_invert:
-            return
-
-        call = QuantumFunctionCall(
-            function=builtins.functions.X.__name__,  # type:ignore[attr-defined]
-            positional_args=[op.result_var],
-            source_ref=op.source_ref,
-        )
-        call.set_func_decl(X.func_decl)
-        self._interpreter.emit_statement(call)
-
-    def _emit_general_assignment_operation(
-        self, op: QuantumAssignmentOperation
-    ) -> None:
-        result = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
-        copy_type_information(op.result_type, result.quantum_type, str(result.handle))
-        self.emit_statement(op)
-
-    def _optimize_boolean_expression(
-        self, op: ArithmeticOperation
-    ) -> tuple[ArithmeticOperation, Expression, bool]:
-        if (
-            op.operation_kind
-            not in (
-                ArithmeticOperationKind.Assignment,
-                ArithmeticOperationKind.InplaceXor,
-            )
-            or not self._all_vars_boolean(op)
-            or not self._is_res_boolean(op)
-        ):
-            return op, op.expression, False
-        optimizer = BooleanExpressionOptimizer()
-        optimized_expression = Expression(
-            expr=ast.unparse(optimizer.visit(ast.parse(op.expression.expr)))
-        )
-        optimized_expression = self._evaluate_expression(optimized_expression)
-        optimized_op = op.model_copy(update=dict(expression=optimized_expression))
-        return optimized_op, optimized_expression, optimizer.is_convertible
-
-    def _adapt_boolean_inplace(
-        self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
-    ) -> tuple[ArithmeticOperation, Expression, bool]:
-        adapter = BooleanExpressionFuncLibAdapter(is_bool_opt)
-        adapted_expression = self._evaluate_expression(
-            Expression(expr=ast.unparse(adapter.visit(ast.parse(expression.expr))))
-        )
-        adapted_op = op.model_copy(update=dict(expression=adapted_expression))
-        return adapted_op, adapted_expression, adapter.to_invert
-
-    def _build_naive_inplace(
-        self, qe: ArithmeticOperation, new_expression: Expression
-    ) -> None:
-        if qe.operation_kind == ArithmeticOperationKind.InplaceXor:
-            op = BinaryOperation.Xor
-        elif qe.operation_kind == ArithmeticOperationKind.InplaceAdd:
-            op = BinaryOperation.Addition
-        else:
-            raise ClassiqInternalExpansionError(
-                f"Unrecognized operation kind {qe.operation_kind!r}"
-            )
-
-        if is_constant(new_expression.expr):
-            self._interpreter.emit_statement(
-                InplaceBinaryOperation(
-                    operation=op,
-                    target=qe.result_var,
-                    value=new_expression,
-                )
-            )
-            return
-
-        if _is_variable(new_expression.expr):
-            value_var = self._interpreter.evaluate(new_expression.expr).value
-            if isinstance(value_var, QuantumSymbol):
-                self._interpreter.emit_statement(
-                    InplaceBinaryOperation(
-                        operation=op,
-                        target=qe.result_var,
-                        value=value_var.handle,
-                    )
-                )
-                return
-
-        aux_var = self._counted_name_allocator.allocate(INPLACE_ARITH_AUX_VAR_PREFIX)
-        self._interpreter.emit_statement(
-            VariableDeclarationStatement(name=aux_var, quantum_type=QuantumNumeric())
-        )
-        arith_expression = ArithmeticOperation(
-            result_var=HandleBinding(name=aux_var),
-            expression=new_expression,
-            operation_kind=ArithmeticOperationKind.Assignment,
-        )
-        inplace_store = InplaceBinaryOperation(
-            operation=op,
-            target=qe.result_var,
-            value=HandleBinding(name=aux_var),
-        )
-        self._interpreter.emit_statement(
-            WithinApply(compute=[arith_expression], action=[inplace_store])
-        )
-
-    def _skip_assignment(self, op: QuantumAssignmentOperation, expr: str) -> bool:
-        if not isinstance(op, ArithmeticOperation) or not is_zero(expr):
-            return False
-        if op.operation_kind != ArithmeticOperationKind.Assignment:
-            return True
-        allocate_call = QuantumFunctionCall(
-            function=allocate.func_decl.name,
-            positional_args=[Expression(expr="1"), op.result_var],
-        )
-        allocate_call.set_func_decl(allocate.func_decl)
-        self._interpreter.emit_statement(allocate_call)
-        return True
-
-    def _get_updated_op_split_symbols(
-        self, op: QuantumAssignmentOperation, symbol_parts: SymbolParts
-    ) -> QuantumAssignmentOperation:
-        return op.model_copy(
-            update=dict(result_var=self.rewrite(op.result_var, symbol_parts))
-        )
-
-
-def _validate_naive_inplace_handles(qe: ArithmeticOperation) -> None:
-    if qe.result_var in qe.var_handles:
-        raise ClassiqExpansionError(
-            HANDLE_ERROR_MESSAGE.format(handle_str=str(demangle_handle(qe.result_var)))
-        )

classiq/model_expansions/quantum_operations/within_apply.py

@@ -1,25 +0,0 @@
-from classiq.interface.generator.functions.builtins.internal_operators import (
-    WITHIN_APPLY_NAME,
-)
-from classiq.interface.model.within_apply_operation import WithinApply
-
-from classiq.model_expansions.closure import Closure
-from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import Scope
-
-
-class WithinApplyEmitter(Emitter[WithinApply]):
-    def emit(self, within_apply: WithinApply, /) -> None:
-        within_apply_operation = Closure(
-            name=WITHIN_APPLY_NAME,
-            blocks=dict(within=within_apply.compute, apply=within_apply.action),
-            scope=Scope(parent=self._current_scope),
-        )
-        context = self._expand_operation(within_apply_operation)
-        self.emit_statement(
-            WithinApply(
-                compute=context.statements("within"),
-                action=context.statements("apply"),
-                source_ref=within_apply.source_ref,
-            )
-        )