classiq 0.94.1__py3-none-any.whl → 0.95.0__py3-none-any.whl

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/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 load_amplitudes
 from .discrete_sine_cosine_transform import *
 from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
 from .grover import *
@@ -11,7 +12,7 @@ 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 .lookup_table import get_lookup_table, span_lookup_table
 from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb
 from .qaoa_penalty import *
@@ -98,6 +99,7 @@ __all__ = [
     "encode_on_bloch",
     "exact_amplitude_amplification",
     "full_hea",
+    "get_lookup_table",
     "gqsp",
     "grover_diffuser",
     "grover_operator",
@@ -111,6 +113,7 @@ __all__ = [
     "lcu",
     "lcu_pauli",
     "linear_pauli_rotations",
+    "load_amplitudes",
     "modular_add_qft_space",
     "modular_exp",
     "modular_increment",

classiq/open_library/functions/amplitude_loading.py

@@ -0,0 +1,66 @@
+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 load_amplitudes(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 `get_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
+    """
+    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)

classiq/open_library/functions/lookup_table.py

@@ -17,13 +17,30 @@ def _get_qnum_values(num: QNum) -> list[float]:
         or not isinstance(is_signed, bool)
         or not isinstance(fraction_digits, int)
     ):
-        raise ClassiqValueError(
-            "Must call 'span_lookup_table' inside a generative qfunc"
-        )
+        raise ClassiqValueError(f"QNum argument {str(num)!r} has symbolic attributes")
 
     return qnum_values(size, is_signed, fraction_digits)
 
 
+def get_lookup_table(func: RealFunction, *targets: QNum) -> list[float]:
+    """
+    Reduces a classical function into a lookup table over all the possible values
+    of the quantum numbers.
+
+    Args:
+        func: A Python function
+        *targets: One or more initialized quantum numbers
+
+    Returns:
+        The function's lookup table
+
+    Notes:
+        The QNum arguments must have generative attributes
+    """
+    target_vals = [_get_qnum_values(target) for target in targets]
+    return [func(*vals[::-1]) for vals in product(*target_vals[::-1])]
+
+
 def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
     """
     Applies a classical function to quantum numbers.
@@ -39,13 +56,9 @@ def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
         The quantum result of applying func to targets
 
     Notes:
-        Must be called inside a generative function (`@qfunc`)
+        The QNum arguments must have generative attributes
     """
-    if len(targets) == 0:
-        raise ClassiqValueError("No targets specified")
-
-    target_vals = [_get_qnum_values(target) for target in targets]
-    lookup_table = [func(*vals[::-1]) for vals in product(*target_vals[::-1])]
+    lookup_table = get_lookup_table(func, *targets)
 
     index_size = sum(target.size for target in targets)
     index: QNum = QNum(get_temp_var_name(), size=index_size)

classiq/open_library/functions/modular_exponentiation.py

@@ -242,14 +242,11 @@ def inplace_modular_multiply(n: CInt, a: CInt, x: QArray[QBit]) -> None:
     Comment: It is assumed that `a` has an inverse modulo `n`
     """
     b: QArray[QBit] = QArray(length=x.len + 1)
-    within_apply(
-        lambda: allocate(b),
-        lambda: (
-            modular_multiply(n, a, b, x),
-            multiswap(x, b),
-            invert(lambda: modular_multiply(n, mod_inverse(a, n), b, x)),
-        ),
-    )
+    allocate(b)
+    modular_multiply(n, a, b, x)
+    multiswap(x, b)
+    invert(lambda: modular_multiply(n, mod_inverse(a, n), b, x))
+    free(b)
 
 
 @qfunc

classiq/open_library/functions/qsvt.py

@@ -195,7 +195,7 @@ def projector_controlled_double_phase(
     """
     within_apply(
         lambda: proj_cnot(qvar, aux),
-        lambda: control(lcu, lambda: RZ(phase_even, aux), lambda: RZ(phase_odd, aux)),
+        lambda: control(lcu, lambda: RZ(phase_odd, aux), lambda: RZ(phase_even, aux)),
     )
 
 
@@ -262,7 +262,7 @@ def qsvt_lcu(
 
     The function is intended to be called within a context of LCU, where it is called as the SELECT operator, and wrapped
     with initialization of the `lcu` qubit to get the desired combination coefficients.
-    The even polynomial corresponds to the case where the $lcu=|0\\rangle$, while the odd to #lcu=|1\\rangle$.
+    The even polynomial corresponds to the case where the $lcu=|0\\rangle$, while the odd to $lcu=|1\\rangle$.
 
     Note: the two polynomials should have the same degree up to a difference of 1.
 
@@ -296,7 +296,7 @@ def qsvt_lcu(
     if_(
         condition=phase_seq_odd.len > phase_seq_even.len,
         then=lambda: control(
-            lcu == 0,
+            lcu,
             lambda: [
                 u(qvar),
                 projector_controlled_phase(
@@ -318,7 +318,7 @@ def qsvt_lcu(
                 lcu,
             ),
             control(
-                lcu,
+                lcu == 0,
                 lambda: [
                     invert(lambda: u(qvar)),
                     projector_controlled_phase(

classiq/qmod/builtins/classical_execution_primitives.py

@@ -13,7 +13,6 @@ from classiq.interface.executor.result import (
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 
-from classiq.applications.qsvm.qsvm import Data, Labels
 from classiq.qmod.builtins.enums import Optimizer
 
 _CALL_IN_QFUNC_ERROR = (
@@ -78,16 +77,6 @@ def qae_with_qpe_result_post_processing(  # type: ignore[return]
     _raise_error("qae_with_qpe_result_post_processing")
 
 
-def qsvm_full_run(  # type: ignore[return]
-    train_data: Data,
-    train_labels: Labels,
-    test_data: Data,
-    test_labels: Labels,
-    predict_data: Data,
-) -> QmodPyStruct:
-    _raise_error("qsvm_full_run")
-
-
 def iqae(  # type: ignore[return]
     epsilon: float,
     alpha: float,
@@ -102,7 +91,6 @@ __all__ = [
     "estimate",
     "iqae",
     "qae_with_qpe_result_post_processing",
-    "qsvm_full_run",
     "sample",
     "save",
     "vqe",

classiq/qmod/builtins/enums.py

@@ -2,6 +2,7 @@ from enum import IntEnum
 from typing import TYPE_CHECKING
 
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.helpers.datastructures import LenList
 
 if TYPE_CHECKING:
     from classiq.qmod.builtins.structs import SparsePauliOp
@@ -62,26 +63,24 @@ class Pauli(IntEnum):
         )
 
         return SparsePauliOp(
-            terms=[
-                SparsePauliTerm(
-                    paulis=[  # type:ignore[arg-type]
-                        IndexedPauli(pauli=self, index=index)  # type:ignore[arg-type]
-                    ],
-                    coefficient=1.0,  # type:ignore[arg-type]
-                )
-            ],
+            terms=LenList(
+                [
+                    SparsePauliTerm(
+                        paulis=LenList(
+                            [  # type:ignore[arg-type]
+                                IndexedPauli(
+                                    pauli=self, index=index  # type:ignore[arg-type]
+                                )
+                            ]
+                        ),
+                        coefficient=1.0,  # type:ignore[arg-type]
+                    )
+                ]
+            ),
             num_qubits=index + 1,
         )
 
 
-class QSVMFeatureMapEntanglement(IntEnum):
-    FULL = 0
-    LINEAR = 1
-    CIRCULAR = 2
-    SCA = 3
-    PAIRWISE = 4
-
-
 BUILTIN_ENUM_DECLARATIONS = {
     enum_def.__name__: EnumDeclaration(
         name=enum_def.__name__,
@@ -98,5 +97,4 @@ BUILTIN_ENUM_DECLARATIONS = {
 __all__ = [
     "Optimizer",
     "Pauli",
-    "QSVMFeatureMapEntanglement",
 ]

classiq/qmod/builtins/functions/__init__.py

@@ -2,16 +2,14 @@ from .allocation import *
 from .arithmetic import *
 from .benchmarking import *
 from .exponentiation import *
+from .mcx import MCX
 from .mid_circuit_measurement import *
 from .operators import *
-from .qsvm import *
 from .standard_gates import *
 
 CORE_LIB_DECLS = [
     func.func_decl
     for func in (
-        pauli_feature_map,
-        bloch_sphere_feature_map,
         H,
         X,
         Y,
@@ -67,6 +65,7 @@ CORE_LIB_DECLS = [
         qdrift,
         exponentiation_with_depth_constraint,
         RESET,
+        MCX,
     )
 ]
 
@@ -85,6 +84,7 @@ __all__ = [  # noqa: RUF022
     "H",
     "I",
     "IDENTITY",
+    "MCX",
     "PHASE",
     "R",
     "RX",
@@ -105,7 +105,6 @@ __all__ = [  # noqa: RUF022
     "add",
     "add_inplace_right",
     "apply",
-    "bloch_sphere_feature_map",
     "exponentiation_with_depth_constraint",
     "free",
     "inplace_prepare_amplitudes",
@@ -117,7 +116,6 @@ __all__ = [  # noqa: RUF022
     "modular_add_constant",
     "multi_suzuki_trotter",
     "parametric_suzuki_trotter",
-    "pauli_feature_map",
     "permute",
     "prepare_amplitudes",
     "prepare_amplitudes_approx",

classiq/qmod/builtins/functions/mcx.py

@@ -0,0 +1,7 @@
+from classiq.qmod.qfunc import qperm
+from classiq.qmod.qmod_variable import Const, QArray, QBit
+
+
+@qperm(external=True)
+def MCX(ctrl: Const[QArray[QBit]], target: QBit) -> None:
+    pass