classiq 0.94.2__py3-none-any.whl → 0.96.0__py3-none-any.whl

classiq/interface/backend/quantum_backend_providers.py

@@ -20,7 +20,6 @@ class ProviderVendor(StrEnum):
     OQC = "OQC"
     INTEL = "Intel"
     AQT = "AQT"
-    IQCC = "IQCC"
     CINECA = "CINECA"
 
 
@@ -35,7 +34,6 @@ class ProviderTypeVendor:
     OQC = Literal[ProviderVendor.OQC]
     INTEL = Literal[ProviderVendor.INTEL]
     AQT = Literal[ProviderVendor.AQT]
-    IQCC = Literal[ProviderVendor.IQCC]
     CINECA = Literal[ProviderVendor.CINECA]
 
 

classiq/interface/exceptions.py

@@ -95,10 +95,6 @@ class ClassiqQFuncError(ClassiqValueError):
     pass
 
 
-class ClassiqQSVMError(ClassiqValueError):
-    pass
-
-
 class ClassiqQNNError(ClassiqValueError):
     pass
 

classiq/interface/generator/application_apis/__init__.py

@@ -4,6 +4,5 @@ from classiq.interface.generator.builtin_api_builder import (
 
 from .arithmetic_declarations import *  # noqa: F403
 from .combinatorial_optimization_declarations import *  # noqa: F403
-from .qsvm_declarations import *  # noqa: F403
 
 populate_builtin_declarations(vars().values())

classiq/interface/generator/arith/register_user_input.py

@@ -19,7 +19,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     is_signed: bool = pydantic.Field(default=False)
     fraction_places: pydantic.NonNegativeInt = pydantic.Field(default=0)
     bypass_bounds_validation: bool = pydantic.Field(default=False)
-    bounds: PydanticFloatTuple = pydantic.Field(  # type: ignore[assignment]
+    bounds: PydanticFloatTuple = pydantic.Field(
         default=None,
         validate_default=True,
     )

classiq/interface/generator/function_param_list.py

@@ -42,7 +42,6 @@ from classiq.interface.generator.hardware_efficient_ansatz import (
 from classiq.interface.generator.identity import Identity
 from classiq.interface.generator.mcu import Mcu
 from classiq.interface.generator.mcx import Mcx
-from classiq.interface.generator.qsvm import QSVMFeatureMap
 from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
 from classiq.interface.generator.reset import Reset
 from classiq.interface.generator.standard_gates.standard_gates_param_list import (
@@ -108,7 +107,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             RandomizedBenchmarking,
             UGate,
             AmplitudeLoading,
-            QSVMFeatureMap,
             HadamardTransform,
             Copy,
             Reset,

classiq/interface/generator/generated_circuit_data.py

@@ -1,6 +1,6 @@
 import logging
 import re
-from typing import Literal, Optional, TypeAlias
+from typing import Literal, TypeAlias
 from uuid import UUID
 
 import pydantic
@@ -188,8 +188,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     back_refs: StatementBlock = Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")
-    # Temporary field to store the override debug info for parallel old/new visualization
-    override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
     @property
     def is_allocate_or_free(self) -> bool:
@@ -317,9 +315,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         )
 
     def inverse(self) -> "FunctionDebugInfoInterface":
-        if self.override_debug_info is not None:
-            self.override_debug_info = self.override_debug_info.inverse()
-            return self
         inverse_generated_function = (
             self.generated_function.model_copy(
                 update=dict(registers=self._inverse_registers)

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -42,7 +42,7 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         "If none specified - use connectivity map from the model hardware settings. "
         "If none specified as well, all qubit pairs will be connected.",
     )
-    num_qubits: pydantic.PositiveInt = pydantic.Field(  # type: ignore[assignment]
+    num_qubits: pydantic.PositiveInt = pydantic.Field(
         default=None,
         description="Number of qubits in the ansatz.",
         validate_default=True,

classiq/interface/generator/quantum_function_call.py

@@ -144,7 +144,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
     power: PydanticPowerType = pydantic.Field(
         default=1, description="Number of successive calls to the operation"
     )
-    name: PydanticNonEmptyString = pydantic.Field(  # type: ignore[assignment]
+    name: PydanticNonEmptyString = pydantic.Field(
         default=None,
         validate_default=True,
         description="The name of the function instance. "

classiq/interface/generator/quantum_program.py

@@ -65,7 +65,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     transpiled_circuit: TranspiledCircuitData | None = pydantic.Field(default=None)
     creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
     synthesis_duration: SynthesisStepDurations | None = pydantic.Field(default=None)
-    debug_info: list[FunctionDebugInfoInterface] | None = pydantic.Field(default=None)
     compressed_debug_info: bytes | None = pydantic.Field(default=None)
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: PrimitivesInput | None = pydantic.Field(default=None)
@@ -169,9 +168,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         )
 
     def get_debug_info(self) -> list[FunctionDebugInfoInterface] | None:
-        # Support legacy uncompressed debug info
-        if self.debug_info is not None:
-            return self.debug_info
         if self.compressed_debug_info is None:
             return None
         decompressed_debug_info_dict_list = decompress(self.compressed_debug_info)

classiq/interface/generator/transpiler_basis_gates.py

@@ -64,6 +64,9 @@ DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
 ALL_GATES: BasisGates = (
     SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES | NON_UNITARY_GATES
 )
+ALL_NON_3_QBIT_GATES: BasisGates = (
+    SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | NON_UNITARY_GATES
+)
 
 ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
     ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -20,16 +20,7 @@ class Pauli(IntEnum):
     Z = 3
 
 
-class QSVMFeatureMapEntanglement(IntEnum):
-    FULL = 0
-    LINEAR = 1
-    CIRCULAR = 2
-    SCA = 3
-    PAIRWISE = 4
-
-
 __all__ = [
     "Optimizer",
     "Pauli",
-    "QSVMFeatureMapEntanglement",
 ]

classiq/interface/hardware.py

@@ -32,7 +32,6 @@ class Provider(StrEnum):
     OQC = "OQC"
     INTEL = "Intel"
     AQT = "AQT"
-    IQCC = "IQCC"
     CINECA = "CINECA"
 
     @property

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "13"
+INTERFACE_VERSION = "14"

classiq/interface/model/block.py

@@ -14,3 +14,7 @@ class Block(QuantumOperation):
     statements: "StatementBlock"
 
     label: str | None = pydantic.Field(default=None)
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"statements": self.statements}

classiq/interface/model/classical_if.py

@@ -31,6 +31,10 @@ class ClassicalIf(QuantumOperation):
     def expressions(self) -> list[Expression]:
         return [self.condition]
 
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"then": self.then, "else_": self.else_}
+
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
         return functools.reduce(

classiq/interface/model/control.py

@@ -47,3 +47,10 @@ class Control(QuantumExpressionOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body", "else_block"])
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        blocks = {"body": self.body}
+        if self.else_block is not None:
+            blocks["else_block"] = self.else_block
+        return blocks

classiq/interface/model/invert.py

@@ -14,3 +14,7 @@ class Invert(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}

classiq/interface/model/model_visitor.py

@@ -1,5 +1,12 @@
+from collections.abc import Collection
+
+from pydantic import BaseModel
+
 from classiq.interface.debug_info.debug_info import DebugInfoCollection
-from classiq.interface.generator.visitor import Transformer, Visitor
+from classiq.interface.generator.visitor import RetType, Transformer, Visitor
+from classiq.interface.model.model import Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 
 class ModelVisitor(Visitor):
@@ -7,8 +14,40 @@ class ModelVisitor(Visitor):
         return
 
 
+class ModelStatementsVisitor(ModelVisitor):
+    def visit_BaseModel(self, node: BaseModel) -> RetType | None:
+        if isinstance(node, Model):
+            return self.visit(node.functions)
+        if isinstance(node, NativeFunctionDefinition):
+            return self.visit(node.body)
+        if isinstance(node, QuantumStatement):
+            for block in node.blocks.values():
+                self.visit(block)
+            return None
+        return super().visit_BaseModel(node)
+
+
 class ModelTransformer(Transformer):
     def visit_DebugInfoCollection(
         self, debug_info: DebugInfoCollection
     ) -> DebugInfoCollection:
         return debug_info
+
+
+class ModelStatementsTransformer(ModelTransformer):
+    def visit_BaseModel(
+        self, node: BaseModel, fields_to_skip: Collection[str] | None = None
+    ) -> RetType:
+        if isinstance(node, Model):
+            new_functions = self.visit(node.functions)
+            return node.model_copy(update=dict(functions=new_functions))
+        if isinstance(node, NativeFunctionDefinition):
+            new_body = self.visit(node.body)
+            return node.model_copy(update=dict(body=new_body))
+        if isinstance(node, QuantumStatement):
+            new_blocks = {
+                block_name: self.visit(block)
+                for block_name, block in node.blocks.items()
+            }
+            return node.model_copy(update=new_blocks)
+        return super().visit_BaseModel(node, fields_to_skip)

classiq/interface/model/power.py

@@ -20,3 +20,7 @@ class Power(QuantumOperation):
     @property
     def expressions(self) -> list[Expression]:
         return [self.power]
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}

classiq/interface/model/quantum_statement.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from uuid import UUID, uuid4
 
 import pydantic
@@ -17,6 +17,9 @@ from classiq.interface.model.handle_binding import (
     HandleBinding,
 )
 
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
 
 class QuantumStatement(ASTNode):
     kind: str
@@ -45,6 +48,10 @@ class QuantumStatement(ASTNode):
     def expressions(self) -> list[Expression]:
         return []
 
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {}
+
 
 @dataclass
 class HandleMetadata:

classiq/interface/model/repeat.py

@@ -21,3 +21,7 @@ class Repeat(QuantumOperation):
     @property
     def expressions(self) -> list[Expression]:
         return [self.count]
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}

classiq/interface/model/skip_control.py

@@ -9,3 +9,7 @@ if TYPE_CHECKING:
 class SkipControl(QuantumOperation):
     kind: Literal["SkipControl"]
     body: "StatementBlock"
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}

classiq/interface/model/within_apply_operation.py

@@ -16,6 +16,10 @@ class WithinApply(QuantumOperation):
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["compute", "action"])
 
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"compute": self.compute, "action": self.action}
+
 
 class Compute(QuantumOperation):
     kind: Literal["Compute"]

classiq/interface/server/routes.py

@@ -4,7 +4,6 @@ EXECUTION_SESSIONS_PREFIX = EXECUTION_PREFIX + "/sessions"
 CONVERSION_PREFIX = "/conversion"
 PROVIDERS_PREFIX = "/providers"
 
-IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
 USER_BUDGETS_PREFIX = "/user_budgets"
 
 
@@ -70,17 +69,6 @@ QASM_TO_QMOD_FULL_PATH = CONVERSION_PREFIX + QASM_TO_QMOD_SUFFIX
 
 STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"
 
-IQCC_INIT_AUTH_SUFFIX = "/init_auth"
-IQCC_INIT_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_INIT_AUTH_SUFFIX
-IQCC_PROBE_AUTH_SUFFIX = "/probe_auth"
-IQCC_PROBE_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_PROBE_AUTH_SUFFIX
-IQCC_LIST_AUTH_SCOPES_SUFFIX = "/auth_scopes"
-IQCC_LIST_AUTH_SCOPES_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_SCOPES_SUFFIX
-IQCC_LIST_AUTH_METHODS_SUFFIX = "/auth_methods"
-IQCC_LIST_AUTH_METHODS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_METHODS_SUFFIX
-IQCC_LIST_AUTH_TARGETS_SUFFIX = "/auth_targets"
-IQCC_LIST_AUTH_TARGETS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_TARGETS_SUFFIX
-
 USER_BUDGETS_SUFFIX = "/all"
 USER_BUDGETS_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGETS_SUFFIX
 USER_BUDGET_SET_LIMIT_SUFFIX = "/set_limit"

classiq/model_expansions/generative_functions.py

@@ -172,20 +172,18 @@ class _InterpreterExpandable(QFunc):
         scope_func_decls: dict[str, QuantumFunctionDeclaration] = {}
         for name, evaluated in self._interpreter._builder.current_scope.items():
             value = evaluated.value
+            if (
+                isinstance(value, list)
+                and len(value) > 0
+                and isinstance(value[0], FunctionClosure)
+            ):
+                value = value[0]
             if isinstance(value, FunctionClosure):
                 scope_func_decls[name] = QuantumFunctionDeclaration(
                     name=name,
                     positional_arg_declarations=value.positional_arg_declarations,
                 )
                 continue
-            op_param = self._interpreter._builder.current_function.parameters_dict.get(
-                name
-            )
-            if isinstance(op_param, QuantumOperandDeclaration):
-                scope_func_decls[name] = QuantumFunctionDeclaration(
-                    name=name,
-                    positional_arg_declarations=op_param.positional_arg_declarations,
-                )
         return (
             nameables_to_dict(self._interpreter._get_function_declarations())
             | scope_func_decls

classiq/model_expansions/interpreters/base_interpreter.py

@@ -324,7 +324,7 @@ class BaseInterpreter:
     def emit_statement(self, statement: QuantumStatement) -> None:
         source_ref = statement.source_ref
         error_context = (
-            self._error_manager.node_context(statement)
+            self._error_manager.source_ref_context(statement.source_ref)
             if source_ref is not None
             else nullcontext()
         )

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -41,7 +41,8 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
             if module is None or not module.__name__.startswith("classiq."):
                 file_name = os.path.split(frame.filename)[-1]
                 if (
-                    frame.positions is not None
+                    hasattr(frame, "positions")
+                    and frame.positions is not None
                     and frame.positions.lineno is not None
                     and frame.positions.col_offset is not None
                     and frame.positions.end_lineno is not None

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -19,7 +19,7 @@ from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
 )
 from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
-from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.model_visitor import ModelStatementsVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -84,7 +84,7 @@ def _get_param_expressions(param: AnonPositionalArg) -> list[Expression]:
     return param.quantum_type.expressions
 
 
-class SymbolicParamInference(ModelVisitor):
+class SymbolicParamInference(ModelStatementsVisitor):
     def __init__(
         self,
         functions: list[NativeFunctionDefinition],
@@ -166,7 +166,7 @@ class SymbolicParamInference(ModelVisitor):
             else:
                 for expr in _get_expressions(arg):
                     self._process_nested_compile_time_expression(expr.expr)
-        self.generic_visit(call)
+        self.visit(call.positional_args)
 
     def _get_params(self, call: QuantumFunctionCall) -> Sequence[AnonPositionalArg]:
         name = call.func_name

classiq/model_expansions/visitors/uncomputation_signature_inference.py

@@ -18,9 +18,10 @@ from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.block import Block
+from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.invert import Invert
-from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.model_visitor import ModelStatementsVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
@@ -48,7 +49,7 @@ class _BoundVars(NamedTuple):
         )
 
 
-class UncomputationSignatureInference(ModelVisitor):
+class UncomputationSignatureInference(ModelStatementsVisitor):
     """
     Infers the uncomputation signature of a function (permutation/non-permutation for
     the function, and const/non-const for each parameter).
@@ -139,7 +140,13 @@ class UncomputationSignatureInference(ModelVisitor):
         self._bound_vars_list.append(bound_vars)
 
     def visit_ArithmeticOperation(self, arith: ArithmeticOperation) -> None:
-        self._mark_as_non_const(arith.result_var.name, True)
+        if arith.classical_assignment:
+            if arith.var_handles:
+                self._mark_as_non_permutation()
+                for handle in arith.var_handles:
+                    self._mark_as_non_const(handle.name, False)
+        else:
+            self._mark_as_non_const(arith.result_var.name, True)
 
     def visit_AmplitudeLoadingOperation(
         self, amp_load: AmplitudeLoadingOperation
@@ -172,6 +179,10 @@ class UncomputationSignatureInference(ModelVisitor):
     def visit_SkipControl(self, block: SkipControl) -> None:
         self.visit(block.body)
 
+    def visit_ClassicalIf(self, classical_if: ClassicalIf) -> None:
+        self.visit(classical_if.then)
+        self.visit(classical_if.else_)
+
     def _mark_as_non_permutation(self) -> None:
         self._is_permutation = False
         self._non_permutation_reasons.append(self._source_ref)

classiq/open_library/functions/__init__.py

@@ -3,6 +3,7 @@ from .amplitude_amplification import (
     exact_amplitude_amplification,
 )
 from .amplitude_estimation import *
+from .amplitude_loading import assign_amplitude_table
 from .discrete_sine_cosine_transform import *
 from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
 from .grover import *
@@ -11,7 +12,6 @@ from .hea import *
 from .lcu import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
-from .lookup_table import span_lookup_table
 from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb
 from .qaoa_penalty import *
@@ -92,6 +92,7 @@ __all__ = [
     "amplitude_amplification",
     "amplitude_estimation",
     "apply_to_all",
+    "assign_amplitude_table",
     "c_modular_multiply",
     "cc_modular_add",
     "encode_in_angle",
@@ -126,6 +127,7 @@ __all__ = [
     "prepare_ghz_state",
     "prepare_int",
     "prepare_linear_amplitudes",
+    "prepare_select",
     "prepare_sparse_amplitudes",
     "prepare_uniform_interval_state",
     "prepare_uniform_trimmed_state",
@@ -151,7 +153,6 @@ __all__ = [
     "qsvt_lcu_step",
     "qsvt_step",
     "reflect_about_zero",
-    "span_lookup_table",
     "suzuki_trotter",
     "swap_test",
     "switch",

classiq/open_library/functions/amplitude_loading.py

@@ -0,0 +1,85 @@
+from typing import cast
+
+import numpy as np
+from sympy import fwht
+
+from classiq.interface.exceptions import ClassiqValueError
+
+from classiq.qmod.builtins.functions import CX, RY
+from classiq.qmod.builtins.operations import (
+    bind,
+    skip_control,
+)
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+
+
+def _get_graycode(size: int, i: int) -> int:
+    if i == 2**size:
+        return _get_graycode(size, 0)
+    return i ^ (i >> 1)
+
+
+def _get_graycode_angles_wh(size: int, angles: list[float]) -> list[float]:
+    transformed_angles = fwht(np.array(angles) / 2**size)
+    return [transformed_angles[_get_graycode(size, j)] for j in range(2**size)]
+
+
+def _get_graycode_ctrls(size: int) -> list[int]:
+    return [
+        (_get_graycode(size, i) ^ _get_graycode(size, i + 1)).bit_length() - 1
+        for i in range(2**size)
+    ]
+
+
+@qfunc
+def assign_amplitude_table(
+    amplitudes: list[float], index: QNum, indicator: QBit
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Load a specified list of real amplitudes into a quantum variable using an extra indicator qubit:
+    \\( |i\\rangle|0\\rangle \\rightarrow a(i),\\ |i\\rangle|1\\rangle + \\sqrt{1 - a(i)^2},\\ |x\\rangle|0\\rangle \\).
+    Here, \\(a(i)\\) is the i-th amplitude, determined by the QNum when the index is in state \\(i\\).
+    A list extracted from a given classical function \\(f(x)\\), with indexing according to a given QNum, can be obtained via the utility SDK function `lookup_table`.
+    This function expects the indicator qubit to be initialized to \\(|0\\rangle\\).
+
+    Args:
+        amplitudes: Real values for the amplitudes
+        index: The quantum variable used for amplitude indexing
+        indicator: The quantum indicator qubit
+
+    Example:
+        ```python
+        from classiq import *
+
+
+        @qfunc
+        def main(x: Output[QNum[5, UNSIGNED, 5]], ind: Output[QBit]) -> None:
+            allocate(x)
+            hadamard_transform(x)
+            allocate(ind)
+
+            assign_amplitude_table(lookup_table(lambda x: x**2, x), x, ind)
+        ```
+    """
+    if len(amplitudes) != 2**index.size:
+        raise ClassiqValueError(
+            f"The number of amplitudes must be 2**index.size={2 ** index.size}, got "
+            f"{len(amplitudes)}"
+        )
+
+    angles_to_load = cast(list[float], 2 * np.arcsin(amplitudes))
+    size = cast(int, index.size)
+    transformed_angles = _get_graycode_angles_wh(size, angles_to_load)
+    controllers = _get_graycode_ctrls(size)
+
+    qba: QArray = QArray()
+    bind(index, qba)
+    for k in range(2**size):
+        RY(transformed_angles[k], indicator)
+        skip_control(
+            lambda k=k: CX(qba[controllers[k]], indicator)  # type:ignore[misc]
+        )
+    bind(qba, index)