classiq 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -1,6 +1,5 @@
 import ast
 import re
-from typing import Tuple
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -23,6 +22,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import (
     QuantumNumeric,
+    QuantumType,
 )
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -41,6 +41,10 @@ from classiq.model_expansions.visitors.boolean_expression_transformers import (
 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_constant(expr: str) -> bool:
     try:
@@ -97,7 +101,7 @@ class QuantumAssignmentOperationEmitter(
         if (
             op.operation_kind != ArithmeticOperationKind.InplaceXor
             or op.result_type.size_in_bits > 1
-            or not _is_res_boolean(op)
+            or not self._is_res_boolean(op)
             or target.quantum_type.size_in_bits > 1
             or _is_constant(expression.expr)
         ):
@@ -129,7 +133,7 @@ class QuantumAssignmentOperationEmitter(
 
     def _optimize_boolean_expression(
         self, op: ArithmeticOperation, expression: Expression
-    ) -> Tuple[ArithmeticOperation, Expression, bool]:
+    ) -> tuple[ArithmeticOperation, Expression, bool]:
         if (
             self._interpreter._is_frontend
             or op.operation_kind
@@ -137,7 +141,8 @@ class QuantumAssignmentOperationEmitter(
                 ArithmeticOperationKind.Assignment,
                 ArithmeticOperationKind.InplaceXor,
             )
-            or not _all_vars_boolean(op)
+            or not self._all_vars_boolean(op)
+            or not self._is_res_boolean(op)
         ):
             return op, expression, False
         optimizer = BooleanExpressionOptimizer()
@@ -150,7 +155,7 @@ class QuantumAssignmentOperationEmitter(
 
     def _adapt_boolean_inplace(
         self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
-    ) -> Tuple[ArithmeticOperation, Expression, 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))))
@@ -223,34 +228,26 @@ class QuantumAssignmentOperationEmitter(
         self._interpreter.emit_statement(allocate_call)
         return True
 
+    @staticmethod
+    def _get_updated_op_split_symbols(
+        op: QuantumAssignmentOperation,
+        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
+    ) -> QuantumAssignmentOperation:
+        if op.result_var not in symbol_mapping:
+            return op
+        handle_str, quantum_type = symbol_mapping[op.result_var]
+        if handle_str in op.expression.expr:
+            raise ClassiqExpansionError(
+                HANDLE_ERROR_MESSAGE.format(handle_str=str(op.result_var))
+            )
+        new_result_handle = HandleBinding(name=handle_str)
+        return op.model_copy(
+            update=dict(result_var=new_result_handle, _result_type=quantum_type)
+        )
+
 
 def _validate_naive_inplace_handles(qe: ArithmeticOperation) -> None:
     if qe.result_var in qe.var_handles:
         raise ClassiqExpansionError(
-            f"Quantum variable {qe.result_var.name} cannot appear on both sides of "
-            f"the ^= assignment"
+            HANDLE_ERROR_MESSAGE.format(handle_str=str(qe.result_var))
         )
-
-
-def _all_vars_boolean(op: ArithmeticOperation) -> bool:
-    if not all(
-        var_type.has_size_in_bits and var_type.size_in_bits == 1
-        for var_type in op.var_types.values()
-    ):
-        return False
-    if any(
-        isinstance(var_type, QuantumNumeric)
-        and (var_type.sign_value or var_type.fraction_digits_value > 0)
-        for var_type in op.var_types.values()
-    ):
-        return False
-    return _is_res_boolean(op)
-
-
-def _is_res_boolean(op: ArithmeticOperation) -> bool:
-    if not (op.result_type.has_size_in_bits and op.result_type.size_in_bits == 1):
-        return False
-    return not (
-        isinstance(op.result_type, QuantumNumeric)
-        and (op.result_type.sign_value or op.result_type.fraction_digits_value > 0)
-    )

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,11 +1,20 @@
+from typing import TYPE_CHECKING
+
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.qmod.semantics.error_manager import ErrorManager
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreter import Interpreter
+
 
 class QuantumFunctionCallEmitter(Emitter[QuantumFunctionCall]):
+    def __init__(self, interpreter: "Interpreter") -> None:
+        super().__init__(interpreter)
+        self._model = self._interpreter._model
+
     def emit(self, call: QuantumFunctionCall, /) -> None:
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args

classiq/model_expansions/quantum_operations/repeat.py

@@ -1,5 +1,3 @@
-from typing import Type
-
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -24,7 +22,7 @@ class RepeatEmitter(Emitter[Repeat]):
                 self._emit_propagated(repeat, i)
 
     def _emit_propagated(self, repeat: Repeat, i: int) -> None:
-        closure_constructor: Type[FunctionClosure]
+        closure_constructor: type[FunctionClosure]
         extra_args: dict
         if repeat.is_generative():
             closure_constructor = GenerativeFunctionClosure

classiq/model_expansions/quantum_operations/within_apply.py

@@ -1,5 +1,4 @@
 from classiq.interface.generator.functions.builtins.internal_operators import (
-    COMPUTE_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
@@ -26,10 +25,6 @@ class WithinApplyEmitter(Emitter[WithinApply]):
                 }
             )
 
-        if self._should_wrap(within_apply.compute):
-            self._emit_wrapped(within_apply)
-            return
-
         self._emit_as_operation(within_apply)
 
     def _emit_as_operation(self, within_apply: WithinApply) -> None:
@@ -46,14 +41,3 @@ class WithinApplyEmitter(Emitter[WithinApply]):
                 source_ref=within_apply.source_ref,
             )
         )
-
-    def _emit_wrapped(self, within_apply: WithinApply) -> None:
-        wrapped_compute = self._create_expanded_wrapping_function(
-            COMPUTE_OPERATOR_NAME, within_apply.compute
-        )
-        wrapped_within_apply = WithinApply(
-            compute=[wrapped_compute],
-            action=within_apply.action,
-            source_ref=within_apply.source_ref,
-        )
-        self._builder.emit_statement(wrapped_within_apply)

classiq/model_expansions/scope.py

@@ -1,9 +1,10 @@
 import itertools
 from collections import UserDict
+from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import singledispatch
-from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -104,7 +105,7 @@ class QuantumSymbol:
         )
 
     @property
-    def fields(self) -> Dict[str, "QuantumSymbol"]:
+    def fields(self) -> dict[str, "QuantumSymbol"]:
         quantum_type = self.quantum_type
         if not isinstance(quantum_type, TypeName):
             raise ClassiqExpansionError(
@@ -120,18 +121,18 @@ class QuantumSymbol:
 
 
 @singledispatch
-def _evaluated_to_str(value: Any) -> str:
+def evaluated_to_str(value: Any) -> str:
     return str(value)
 
 
-@_evaluated_to_str.register
+@evaluated_to_str.register
 def _evaluated_to_str_list(value: list) -> str:
-    return f"[{', '.join(_evaluated_to_str(x) for x in value)}]"
+    return f"[{', '.join(evaluated_to_str(x) for x in value)}]"
 
 
-@_evaluated_to_str.register
+@evaluated_to_str.register
 def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
-    return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={_evaluated_to_str(v)}' for k, v in value.fields.items())})"
+    return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={evaluated_to_str(v)}' for k, v in value.fields.items())})"
 
 
 @dataclass(frozen=True)
@@ -139,7 +140,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     value: Any
     defining_function: Optional["Closure"] = None
 
-    def as_type(self, t: Type[T]) -> T:
+    def as_type(self, t: type[T]) -> T:
         if t is int:
             return self._as_int()  # type: ignore[return-value]
 
@@ -162,7 +163,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
         if isinstance(self.value, QuantumSymbol):
             return self.value.emit()
 
-        ret = Expression(expr=_evaluated_to_str(self.value))
+        ret = Expression(expr=evaluated_to_str(self.value))
         ret._evaluated_expr = EvaluatedExpression(value=self.value)
         return ret
 
@@ -176,7 +177,7 @@ else:
 class Scope(EvaluatedUserDict):
     def __init__(
         self,
-        data: Optional[Dict[str, Evaluated]] = None,
+        data: Optional[dict[str, Evaluated]] = None,
         /,
         *,
         parent: Optional["Scope"] = None,

classiq/model_expansions/scope_initialization.py

@@ -1,4 +1,4 @@
-from typing import List, Sequence
+from collections.abc import Sequence
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
@@ -43,7 +43,7 @@ def get_main_renamer(
     return ExpressionRenamer(var_mapping={})
 
 
-def _add_constants_to_scope(constants: List[Constant], scope: Scope) -> None:
+def _add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
     for constant in constants:
         scope[constant.name] = Evaluated(
             value=evaluate_classical_expression(constant.value, scope).value
@@ -51,7 +51,7 @@ def _add_constants_to_scope(constants: List[Constant], scope: Scope) -> None:
 
 
 def _add_functions_to_scope(
-    functions: List[NativeFunctionDefinition], scope: Scope
+    functions: list[NativeFunctionDefinition], scope: Scope
 ) -> None:
     for function in functions:
         scope[function.name] = Evaluated(
@@ -65,7 +65,7 @@ def _add_functions_to_scope(
 
 
 def _add_generative_functions_to_scope(
-    functions: List[GenerativeQFunc], scope: Scope
+    functions: list[GenerativeQFunc], scope: Scope
 ) -> None:
     for function in functions:
         scope[function.func_decl.name] = Evaluated(
@@ -138,7 +138,7 @@ def add_entry_point_params_to_scope(
 
 
 def init_top_level_scope(
-    model: Model, generative_functions: List[GenerativeQFunc], scope: Scope
+    model: Model, generative_functions: list[GenerativeQFunc], scope: Scope
 ) -> None:
     _add_functions_to_scope(model.functions, scope)
     _add_generative_functions_to_scope(generative_functions, scope)

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -1,5 +1,5 @@
 import ast
-from typing import TYPE_CHECKING, Dict, Type, cast
+from typing import TYPE_CHECKING, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 
@@ -18,29 +18,29 @@ def translate_to_sympy(expr: str) -> str:
 
 
 class ExpressionSympyTranslator(ast.NodeTransformer):
-    BINARY_OPERATORS: Dict[Type[ast.AST], str] = {
+    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] = {
+    UNARY_OPERATORS: dict[type[ast.AST], str] = {
         ast.Invert: "BitwiseNot",
         ast.Not: "Not",
     }
 
-    BOOLEAN_OPERATORS: Dict[Type[ast.AST], str] = {
+    BOOLEAN_OPERATORS: dict[type[ast.AST], str] = {
         ast.Or: "Or",
         ast.And: "And",
     }
 
-    COMPARE_OPERATORS: Dict[Type[ast.AST], str] = {
+    COMPARE_OPERATORS: dict[type[ast.AST], str] = {
         ast.Eq: "Eq",
         ast.NotEq: "Ne",
     }
 
-    SPECIAL_FUNCTIONS: Dict[str, str] = {
+    SPECIAL_FUNCTIONS: dict[str, str] = {
         "max": "Max",
         "min": "Min",
     }

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -1,5 +1,5 @@
 import functools
-from typing import Any, Dict, Optional, get_args
+from typing import Any, Optional, get_args
 
 from sympy import (
     Array,
@@ -22,7 +22,7 @@ from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 
 
 def sympy_to_python(
-    value: Any, locals: Optional[Dict[str, ExpressionValue]] = None
+    value: Any, locals: Optional[dict[str, ExpressionValue]] = None
 ) -> ExpressionValue:
     if isinstance(value, Integer):
         value = int(value)

classiq/model_expansions/visitors/variable_references.py

@@ -1,6 +1,7 @@
 import ast
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Dict, Iterator, List, Optional, Union
+from typing import Optional, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -23,12 +24,12 @@ from classiq.interface.model.handle_binding import (
 
 class VarRefCollector(ast.NodeVisitor):
     def __init__(self, ignore_duplicated_handles: bool = False) -> None:
-        self._var_handles: Dict[HandleBinding, bool] = {}
+        self._var_handles: dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
         self._is_nested = False
 
     @property
-    def var_handles(self) -> List[HandleBinding]:
+    def var_handles(self) -> list[HandleBinding]:
         return list(self._var_handles)
 
     def visit(self, node: ast.AST) -> Union[
@@ -110,7 +111,7 @@ class VarRefCollector(ast.NodeVisitor):
 
 
 class VarRefTransformer(ast.NodeTransformer):
-    def __init__(self, var_mapping: Dict[str, str]) -> None:
+    def __init__(self, var_mapping: dict[str, str]) -> None:
         self.var_mapping = var_mapping
 
     def visit_Name(self, node: ast.Name) -> ast.Name:

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,4 +1,4 @@
-from typing import Dict, Final, List, Optional, Union
+from typing import Final, Optional, Union
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
@@ -15,7 +15,7 @@ from classiq.interface.generator.functions.qmod_python_interface import QmodPySt
 from classiq.applications.qsvm.qsvm import Data, Labels
 from classiq.qmod.builtins.enums import Optimizer
 
-ExecutionParams = Dict[str, Union[float, int, List[int], List[float]]]
+ExecutionParams = dict[str, Union[float, int, list[int], list[float]]]
 
 _CALL_IN_QFUNC_ERROR = (
     'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'
@@ -39,28 +39,28 @@ def sample(  # type: ignore[return]
 
 
 def batch_sample(  # type: ignore[return]
-    batch_execution_params: List[ExecutionParams],
+    batch_execution_params: list[ExecutionParams],
 ) -> MultipleExecutionDetails:
     _raise_error("batch_sample")
 
 
 def estimate(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
+    hamiltonian: list[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
 ) -> EstimationResult:
     _raise_error("estimate")
 
 
 def batch_estimate(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct],
-    batch_execution_params: List[ExecutionParams],
+    hamiltonian: list[QmodPyStruct],
+    batch_execution_params: list[ExecutionParams],
 ) -> EstimationResults:
     _raise_error("batch_estimate")
 
 
 def vqe(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct],
+    hamiltonian: list[QmodPyStruct],
     maximize: bool,
-    initial_point: List[float],
+    initial_point: list[float],
     optimizer: Optimizer,
     max_iteration: int,
     tolerance: float,
@@ -118,5 +118,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/builtins/functions/__init__.py

@@ -1,3 +1,6 @@
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+
+from ...quantum_function import GenerativeQFunc
 from .amplitude_estimation import *
 from .arithmetic import *
 from .benchmarking import *
@@ -14,7 +17,7 @@ from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb, _ctrl_x
 from .operators import *
 from .qaoa_penalty import *
-from .qft import *
+from .qft_functions import *
 from .qpe import *
 from .qsvm import *
 from .qsvt import *
@@ -22,6 +25,7 @@ from .standard_gates import *
 from .state_preparation import *
 from .state_preparation import _prepare_uniform_trimmed_state_step
 from .swap_test import *
+from .utility_functions import *
 from .variational import *
 
 CORE_LIB_DECLS = [
@@ -86,62 +90,75 @@ CORE_LIB_DECLS = [
     )
 ]
 
+OPEN_LIBRARY_UNPROCESSED_FUNCTIONS = [
+    qpe_flexible,
+    qpe,
+    _single_pauli,
+    linear_pauli_rotations,
+    amplitude_estimation,
+    phase_oracle,
+    reflect_about_zero,
+    grover_diffuser,
+    grover_operator,
+    grover_search,
+    hadamard_transform,
+    apply_to_all,
+    qft_no_swap,
+    qft_space_add_const,
+    cc_modular_add,
+    c_modular_multiply,
+    multiswap,
+    inplace_c_modular_multiply,
+    modular_exp,
+    qsvt_step,
+    qsvt,
+    projector_controlled_phase,
+    qsvt_inversion,
+    allocate_num,
+    qaoa_mixer_layer,
+    qaoa_cost_layer,
+    qaoa_layer,
+    qaoa_init,
+    qaoa_penalty,
+    full_hea,
+    swap_test,
+    prepare_uniform_trimmed_state,
+    prepare_uniform_interval_state,
+    prepare_ghz_state,
+    prepare_exponential_state,
+    prepare_bell_state,
+    inplace_prepare_int,
+    prepare_int,
+    switch,
+    qct_qst_type1,
+    qct_qst_type2,
+    qct_type2,
+    qst_type2,
+    modular_increment,
+    qft,
+    _ctrl_x,
+    _prepare_uniform_trimmed_state_step,
+    _qct_d_operator,
+    _qct_pi_operator,
+    _check_msb,
+    encode_in_angle,
+    encode_on_bloch,
+]
+
+OPEN_LIBRARY_FUNCTIONS: list[NativeFunctionDefinition] = []
+
+
+def load_open_library_implementations() -> None:
+    OPEN_LIBRARY_FUNCTIONS.extend(
+        [func.get_implementation() for func in OPEN_LIBRARY_UNPROCESSED_FUNCTIONS]
+    )
+
+
+OPEN_LIBRARY_GENERATIVE_FUNCTIONS: list[GenerativeQFunc] = []
+
 OPEN_LIB_DECLS = [
     func.func_decl
-    for func in (
-        qpe_flexible,
-        qpe,
-        _single_pauli,
-        linear_pauli_rotations,
-        amplitude_estimation,
-        phase_oracle,
-        reflect_about_zero,
-        grover_diffuser,
-        grover_operator,
-        grover_search,
-        hadamard_transform,
-        apply_to_all,
-        qft_no_swap,
-        qft_space_add_const,
-        cc_modular_add,
-        c_modular_multiply,
-        multiswap,
-        inplace_c_modular_multiply,
-        modular_exp,
-        qsvt_step,
-        qsvt,
-        projector_controlled_phase,
-        qsvt_inversion,
-        allocate_num,
-        qaoa_mixer_layer,
-        qaoa_cost_layer,
-        qaoa_layer,
-        qaoa_init,
-        qaoa_penalty,
-        full_hea,
-        swap_test,
-        prepare_uniform_trimmed_state,
-        prepare_uniform_interval_state,
-        prepare_ghz_state,
-        prepare_exponential_state,
-        prepare_bell_state,
-        inplace_prepare_int,
-        prepare_int,
-        switch,
-        qct_qst_type1,
-        qct_qst_type2,
-        qct_type2,
-        qst_type2,
-        modular_increment,
-        qft,
-        _ctrl_x,
-        _prepare_uniform_trimmed_state_step,
-        _qct_d_operator,
-        _qct_pi_operator,
-        _check_msb,
-        encode_in_angle,
-        encode_on_bloch,
-    )
+    for func in OPEN_LIBRARY_GENERATIVE_FUNCTIONS + OPEN_LIBRARY_UNPROCESSED_FUNCTIONS
 ]
 
 STD_QMOD_OPERATORS = [func.func_decl for func in (apply, permute)]

classiq/qmod/builtins/functions/amplitude_estimation.py

@@ -1,3 +1,5 @@
+from classiq.qmod.builtins.functions.grover import grover_operator
+from classiq.qmod.builtins.functions.qpe import qpe
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
@@ -24,4 +26,5 @@ def amplitude_estimation(
         phase: Assuming this variable starts from the zero state -this variable output holds the $phase=\\theta$ result in the [0,1] domain, which relates to the estimated probability $a$ through $a=\\sin^2(\\pi \\theta)$.
         packed_vars: The variable that holds the state to be estimated. Assumed to be in the zero state at the beginning of the algorithm.
     """
-    pass
+    space_transform(packed_vars)
+    qpe(lambda: grover_operator(oracle, space_transform, packed_vars), phase)

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,9 +1,13 @@
 from typing import Literal
 
+from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import PHASE
+from classiq.qmod.builtins.operations import bind, repeat, within_apply
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
+from classiq.qmod.symbolic import pi
 
 
 @qfunc(external=True)
@@ -75,4 +79,13 @@ def modular_increment(a: CInt, x: QNum) -> None:
         x: A quantum number that is assumed to be non-negative integer.
 
     """
-    pass
+    array_cast: QArray = QArray("array_cast")
+    within_apply(
+        lambda: (  # type:ignore[arg-type]
+            bind(x, array_cast),  # type:ignore[func-returns-value]
+            qft(array_cast),
+        ),
+        lambda: repeat(
+            x.size, lambda i: PHASE(a * 2 * pi * 2**i / (2**x.size), array_cast[i])
+        ),
+    )