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

classiq/open_library/functions/lcu.py

@@ -9,6 +9,7 @@ from classiq.open_library.functions.utility_functions import switch
 from classiq.qmod.builtins.functions import IDENTITY, X, Y, Z, inplace_prepare_state
 from classiq.qmod.builtins.operations import (
     control,
+    if_,
     repeat,
     within_apply,
 )
@@ -16,7 +17,7 @@ from classiq.qmod.builtins.structs import IndexedPauli, SparsePauliOp
 from classiq.qmod.cparam import CArray
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
-from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.quantum_callable import QCallable, QCallableList
 
 
 @qfunc
@@ -36,27 +37,23 @@ def apply_pauli_term(pauli_string: CArray[IndexedPauli], x: QArray[QBit]) -> Non
 
 
 @qfunc
-def lcu(
+def prepare_select(
     coefficients: list[float],
-    unitaries: QCallableList,
+    select: QCallable[QNum],
     block: QNum[Literal["max(ceiling(log(coefficients.len, 2)), 1)"]],
 ) -> None:
     """
     [Qmod Classiq-library function]
 
-    Implements a general linear combination of unitaries (LCU) procedure. The algorithm prepares a superposition
-    over the `unitaries` according to `magnitudes`, and then conditionally applies each unitary controlled by the `block`.
-
-    The operation is of the form:
-
-    $$\\sum_j \\alpha_j U_j$$
-
-    where $U_j$ is a unitary operation applied to `data`.
+    Applies the 'Prepare-Select' scheme used for Linear Combination of Unitaries (LCU).
+    Compared to the `lcu` function, here the Select operator should be provided directly, allowing to take advantage of some structure for
+    the unitaries of the LCU.
+    The select operator is defined by: $\\mathrm{SELECT} = \\sum_{j=0}^{m-1} |j\rangle\\!\\langle j|_{block} \\otimes U_j$.
 
     Args:
         coefficients: L1-normalized array of  $\\{ \\alpha_j \\}$ of the LCU coefficients.
-        unitaries: A list of quantum callable functions to be applied conditionally.
-        block: Quantum variable that holds the superposition index used for conditional application of each unitary.
+        select: A quantum callable to be applied between the state preparation and its inverse. Its input is the `block` variable, labeling the index of the unitaries in the LCU.
+        block: A Quantum variable that holds the index used as input for the 'select' operator.
     """
     coefficients = coefficients + [0] * (
         2**block.size - len(coefficients)  # type:ignore[operator]
@@ -68,16 +65,48 @@ def lcu(
     within_apply(
         lambda: inplace_prepare_state(magnitudes, 0, block),
         lambda: [
-            repeat(
-                count=unitaries.len,
-                iteration=lambda i: control(block == i, lambda: unitaries[i]()),
+            select(block),
+            if_(
+                not np.allclose(np.array(phases) % (2 * np.pi), 0),
+                lambda: apply_phase_table(phases, block),
             ),
-            # TODO: replace to sparse constant phase
-            apply_phase_table(phases, block),
         ],
     )
 
 
+@qfunc
+def lcu(
+    coefficients: list[float],
+    unitaries: QCallableList,
+    block: QNum[Literal["max(ceiling(log(coefficients.len, 2)), 1)"]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Implements a general linear combination of unitaries (LCU) procedure. The algorithm prepares a superposition
+    over the `unitaries` according to the given `coefficients`, and then conditionally applies each unitary controlled by the `block`.
+
+    The operation is of the form:
+
+    $$\\sum_j \\alpha_j U_j$$
+
+    where $U_j$ is a unitary operation applied to `data`.
+
+    Args:
+        coefficients: L1-normalized array of  $\\{ \\alpha_j \\}$ of the LCU coefficients.
+        unitaries: A list of quantum callable functions to be applied conditionally.
+        block: Quantum variable that holds the superposition index used for conditional application of each unitary.
+    """
+    prepare_select(
+        coefficients,
+        lambda _block: repeat(
+            count=unitaries.len,
+            iteration=lambda i: control(_block == i, lambda: unitaries[i]()),
+        ),
+        block,
+    )
+
+
 @qfunc
 def lcu_pauli(
     operator: SparsePauliOp,

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/open_library/functions/state_preparation.py

@@ -29,7 +29,7 @@ from classiq.qmod.builtins.operations import (
     within_apply,
 )
 from classiq.qmod.cparam import CArray, CInt, CReal
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 from classiq.qmod.symbolic import (
     acos,
@@ -248,7 +248,7 @@ def prepare_bell_state(
     CX(qpair[0], qpair[1])
 
 
-@qfunc
+@qperm
 def inplace_prepare_int(value: CInt, target: QNum) -> None:
     """
     [Qmod Classiq-library function]
@@ -273,7 +273,7 @@ def inplace_prepare_int(value: CInt, target: QNum) -> None:
     target ^= value
 
 
-@qfunc
+@qperm
 def prepare_int(
     value: CInt,
     out: Output[QNum[Literal["floor(log(value, 2)) + 1"]]],
@@ -324,7 +324,7 @@ def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
     return 1 / np.sqrt(len(arr)) * np.array(sympy.fwht(np.array(arr)))
 
 
-@qfunc
+@qperm
 def apply_phase_table(
     phases: list[float],
     target: QArray[QBit, Literal["log(phases.len, 2)"]],
@@ -456,7 +456,7 @@ def prepare_dicke_state(k: int, qvar: QArray[QBit]) -> None:
         prepare_dicke_state_unary_input(k, qvar)
 
 
-@qfunc
+@qperm
 def prepare_basis_state(state: list[bool], arr: Output[QArray]) -> None:
     """
     [Qmod Classiq-library function]
@@ -515,7 +515,7 @@ def prepare_linear_amplitudes(x: QArray) -> None:
     hadamard_transform(x)
 
 
-@qfunc
+@qperm
 def swap_states(a: int, b: int, target: QArray) -> None:
     """
     Swap 2 computational basis states a and b, leave all other states untouched.
@@ -538,7 +538,7 @@ def swap_states(a: int, b: int, target: QArray) -> None:
     if anchor < target.len - 1:
         target_without_anchor.append(target[anchor + 1 : target.len])
 
-    @qfunc
+    @qperm
     def _xor_if_equal(n: CInt, ctrl: QNum, target: QBit) -> None:
         target ^= ctrl == n
 

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,
@@ -53,6 +51,7 @@ CORE_LIB_DECLS = [
         U,
         CCX,
         free,
+        drop,
         randomized_benchmarking,
         inplace_prepare_state,
         inplace_prepare_state_approx,
@@ -67,6 +66,7 @@ CORE_LIB_DECLS = [
         qdrift,
         exponentiation_with_depth_constraint,
         RESET,
+        MCX,
     )
 ]
 
@@ -85,6 +85,7 @@ __all__ = [  # noqa: RUF022
     "H",
     "I",
     "IDENTITY",
+    "MCX",
     "PHASE",
     "R",
     "RX",
@@ -105,9 +106,9 @@ __all__ = [  # noqa: RUF022
     "add",
     "add_inplace_right",
     "apply",
-    "bloch_sphere_feature_map",
     "exponentiation_with_depth_constraint",
     "free",
+    "drop",
     "inplace_prepare_amplitudes",
     "inplace_prepare_amplitudes_approx",
     "inplace_prepare_state",
@@ -117,7 +118,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/allocation.py

@@ -21,6 +21,27 @@ def free(in_: Input[QArray[QBit]]) -> None:
     pass
 
 
+@qperm(external=True)
+def drop(in_: Input[QArray[QBit]]) -> None:
+    """
+    [Qmod core-library function]
+
+    Discards the qubits allocated to a quantum variable which may be in any state,
+    preventing their further use.
+
+    Args:
+        in_: The quantum variable that will be dropped. Must be initialized before.
+
+    Note:
+        This operation can be used to bypass the restrictions on a local variable
+        that enable its uncomputation. The implication is that its qubits are left
+        dirty, possibly entangled with functional qubits, and never subsequently reused.
+
+        Functions which use `drop` cannot be inverted or used inside a _within_ block.
+    """
+    pass
+
+
 @qfunc(external=True)
 def prepare_state(
     probabilities: CArray[CReal],

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