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

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,144 @@
+import ast
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Optional, 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, unevaluated: bool = False
+    ) -> None:
+        self._var_handles: dict[HandleBinding, bool] = {}
+        self._ignore_duplicated_handles = ignore_duplicated_handles
+        self._unevaluated = unevaluated
+        self._is_nested = False
+
+    @property
+    def var_handles(self) -> list[HandleBinding]:
+        return list(self._var_handles)
+
+    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.Slice):
+            if not self._unevaluated and (
+                not isinstance(node.slice.lower, ast.Num)
+                or not isinstance(node.slice.upper, ast.Num)
+            ):
+                raise ClassiqInternalExpansionError("Unevaluated slice bounds.")
+            if node.slice.lower is None or node.slice.upper is None:
+                raise ClassiqExpansionError(
+                    f"{str(base_handle)!r} slice must specify both lower and upper bounds"
+                )
+            handle = SlicedHandleBinding(
+                base_handle=base_handle,
+                start=Expression(expr=ast.unparse(node.slice.lower)),
+                end=Expression(expr=ast.unparse(node.slice.upper)),
+            )
+        elif not self._unevaluated and not isinstance(node.slice, ast.Num):
+            raise ClassiqInternalExpansionError("Unevaluated slice.")
+        else:
+            handle = SubscriptHandleBinding(
+                base_handle=base_handle,
+                index=Expression(expr=ast.unparse(node.slice)),
+            )
+
+        if not self._is_nested:
+            self._var_handles[handle] = True
+        return handle
+
+    def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
+        return self._get_field_handle(node.value, node.attr)
+
+    def visit_Call(self, node: ast.Call) -> Optional[FieldHandleBinding]:
+        if (
+            not isinstance(node.func, ast.Name)
+            or node.func.id != "get_field"
+            or len(node.args) != 2
+            or not isinstance(node.args[1], ast.Constant)
+            or not isinstance(node.args[1].value, str)
+        ):
+            return self.generic_visit(node)
+        return self._get_field_handle(node.args[0], node.args[1].value)
+
+    def _get_field_handle(
+        self, subject: ast.expr, field: str
+    ) -> Optional[FieldHandleBinding]:
+        with self.set_nested():
+            base_handle = self.visit(subject)
+        if base_handle is None:
+            return None
+        handle = FieldHandleBinding(
+            base_handle=base_handle,
+            field=field,
+        )
+        if not self._is_nested:
+            self._var_handles[handle] = True
+        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[handle] = True
+        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/open_library/__init__.py

@@ -0,0 +1,4 @@
+from .functions import *  # noqa: F403
+from .functions import __all__ as _functions_all
+
+__all__ = _functions_all

classiq/open_library/functions/__init__.py

@@ -0,0 +1,130 @@
+from .amplitude_estimation import *
+from .discrete_sine_cosine_transform import *
+from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
+from .grover import *
+from .hea import *
+from .linear_pauli_rotation import *
+from .linear_pauli_rotation import _single_pauli
+from .modular_exponentiation import *
+from .modular_exponentiation import _check_msb, _ctrl_x
+from .qaoa_penalty import *
+from .qft_functions import *
+from .qpe import *
+from .qsvt 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 *
+
+OPEN_LIBRARY_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_double_phase,
+    projector_controlled_phase,
+    qsvt_inversion,
+    qsvt_lcu,
+    qsvt_lcu_step,
+    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,
+]
+
+__all__ = [
+    "_single_pauli",
+    "allocate_num",
+    "amplitude_estimation",
+    "apply_to_all",
+    "c_modular_multiply",
+    "cc_modular_add",
+    "encode_in_angle",
+    "encode_on_bloch",
+    "full_hea",
+    "grover_diffuser",
+    "grover_operator",
+    "grover_search",
+    "hadamard_transform",
+    "inplace_c_modular_multiply",
+    "inplace_prepare_int",
+    "linear_pauli_rotations",
+    "modular_exp",
+    "modular_increment",
+    "multiswap",
+    "phase_oracle",
+    "prepare_bell_state",
+    "prepare_exponential_state",
+    "prepare_ghz_state",
+    "prepare_int",
+    "prepare_uniform_interval_state",
+    "prepare_uniform_trimmed_state",
+    "projector_controlled_double_phase",
+    "projector_controlled_phase",
+    "qaoa_cost_layer",
+    "qaoa_init",
+    "qaoa_layer",
+    "qaoa_mixer_layer",
+    "qaoa_penalty",
+    "qct_qst_type1",
+    "qct_qst_type2",
+    "qct_type2",
+    "qft",
+    "qft_no_swap",
+    "qft_space_add_const",
+    "qpe",
+    "qpe_flexible",
+    "qst_type2",
+    "qsvt",
+    "qsvt_inversion",
+    "qsvt_lcu",
+    "qsvt_lcu_step",
+    "qsvt_step",
+    "reflect_about_zero",
+    "suzuki_trotter",
+    "swap_test",
+    "switch",
+]

classiq/open_library/functions/amplitude_estimation.py

@@ -0,0 +1,30 @@
+from classiq.open_library.functions.grover import grover_operator
+from classiq.open_library.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
+
+
+@qfunc
+def amplitude_estimation(
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    phase: QNum,
+    packed_vars: QArray[QBit],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Estimate the probability of a state being marked by the operand `oracle` as a "good state."
+
+    The algorithm prepares the state in the `packed_vars` register and estimates the probability of this state being marked by the oracle as a "good state."
+    This is done using the Quantum Phase Estimation (QPE) algorithm, where the unitary for QPE is the Grover operator, which is composed of the `oracle` and `space_transform` operators.
+
+    Args:
+        oracle: The oracle operator that marks the "good" state. This operator should flip the sign of the amplitude of the "good" state.
+        space_transform: The space transform operator (which is known also the state preparation operator), which is first applied to prepare the state before the QPE, and then used inside the Grover operator.
+        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.
+    """
+    space_transform(packed_vars)
+    qpe(lambda: grover_operator(oracle, space_transform, packed_vars), phase)

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -0,0 +1,181 @@
+from classiq.open_library.functions.qft_functions import qft
+from classiq.open_library.functions.utility_functions import (
+    apply_to_all,
+    modular_increment,
+)
+from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
+from classiq.qmod.builtins.operations import (
+    allocate,
+    bind,
+    control,
+    invert,
+    repeat,
+    within_apply,
+)
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.symbolic import pi
+
+
+def _b_operator(q: QBit) -> None:
+    S(q)
+    H(q)
+
+
+@qfunc
+def _qct_d_operator(x: QNum, q: QBit) -> None:
+    _b_operator(q)
+    control(x == 0, lambda: invert(lambda: _b_operator(q)))
+
+
+@qfunc
+def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
+    control(q == 1, lambda: apply_to_all(X, x))
+    control(q == 1, lambda: modular_increment(1, x))
+
+
+def _t_operator(x: QArray) -> None:
+    _qct_d_operator(x[0 : x.len - 1], x[x.len - 1])
+    _qct_pi_operator(x[0 : x.len - 1], x[x.len - 1])
+
+
+def _vn_operator(x: QArray[QBit], q: QBit) -> None:
+    H(q)
+    control(q == 1, lambda: apply_to_all(X, x))
+
+
+def _d1_operator(x: QArray[QBit], q: QBit) -> None:
+    omega_exp = 2 * pi / (4 * 2**x.len)
+
+    # Li
+    control(q == 0, lambda: repeat(x.len, lambda k: PHASE(omega_exp * (2**k), x[k])))
+    # Ki
+    control(
+        q == 1,
+        lambda: repeat(
+            x.len,
+            lambda k: within_apply(
+                lambda: X(x[k]), lambda: PHASE(-omega_exp * (2**k), x[k])
+            ),
+        ),
+    )
+    PHASE(-omega_exp, q)
+
+
+def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
+    control(q == 1, lambda: modular_increment(1, x))
+
+
+def _j_operator(q: QBit) -> None:
+    within_apply(lambda: Z(q), lambda: (S(q), H(q), S(q)))  # type:ignore[arg-type]
+
+
+def _b_t_operator(q: QBit) -> None:
+    H(q)
+    S(q)
+
+
+def _d0dt_operator(x: QArray, q: QBit) -> None:
+    x_num: QNum = QNum("x_num", x.len, False, 0)
+    bind(x, x_num)
+    _b_t_operator(q)
+    control(x_num == 0, lambda: _j_operator(q))
+    bind(x_num, x)
+
+
+def _un_dag_operator(x: QArray[QBit], q: QBit) -> None:
+    _d1_operator(x, q)
+    invert(lambda: _qct_pi_operator(x, q))
+    _d0dt_operator(x, q)
+    invert(lambda: _pi2_operator(x, q))
+
+
+@qfunc
+def qct_qst_type1(x: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the quantum discrete cosine (DCT) and sine (DST)
+    transform of type 1 to the qubit array `x`.
+    Corresponds to the matrix (with $n\\equiv$`x.len`):
+
+    $$
+    \\left(
+    \begin{array}{ccc|c}
+    {} &{} &{} \\
+      {}&{\rm DCT}^{(1)}(2^{n-1}+1) & {}& 0\\
+      {} &{} &{} \\
+      \\hline
+      {} & 0 & {} & i{\rm DST}^{(1)}(2^{n-1}-1)
+    \\end{array}
+    \right)
+    $$
+
+    Args:
+        x: The qubit array to apply the transform to.
+    """
+    within_apply(lambda: _t_operator(x), lambda: qft(x))
+
+
+@qfunc
+def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the quantum discrete cosine (DCT) and sine (DST)
+    transform of type 2 to the qubit array `x` concatenated with `q`, with `q` being the MSB.
+    Corresponds to the matrix (with $n\\equiv$`x.len`+1):
+
+    $$
+    \\left(
+    \begin{array}{c|c}
+      {\rm DCT}^{(2)}(2^{n-1}) & 0\\
+      \\hline
+      0 & -{\rm DST}^{(2)}(2^{n-1})
+    \\end{array}
+    \right)
+    $$
+
+    Args:
+        x: The LSB part of the qubit array to apply the transform to.
+        q: The MSB of the qubit array to apply the transform to.
+    """
+    extended_state: QArray = QArray("extended_state")
+    _vn_operator(x, q)
+    bind([x, q], extended_state)
+    qft(extended_state)
+    bind(extended_state, [x, q])
+    _un_dag_operator(x, q)
+
+
+@qfunc
+def qct_type2(x: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the quantum discrete cosine (DCT)
+    transform of type 2, ${\rm DCT}^{(2)}$, to the qubit array `x`.
+
+    Args:
+        x: The qubit array to apply the transform to.
+    """
+    q = QBit("q")
+    within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
+
+
+@qfunc
+def qst_type2(x: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the quantum discrete sine (DST)
+    transform of type 2, ${\rm DST}^{(2)}$, to the qubit array `x`.
+
+    Args:
+        x: The qubit array to apply the transform to.
+    """
+    q = QBit("q")
+    within_apply(
+        lambda: (allocate(1, q), X(q)),  # type:ignore[arg-type]
+        lambda: qct_qst_type2(x, q),
+    )