classiq 0.93.0__py3-none-any.whl → 0.100.0__py3-none-any.whl

classiq/open_library/functions/state_preparation.py

@@ -17,19 +17,22 @@ from classiq.qmod.builtins.functions import (
     RY,
     H,
     X,
+    free,
     inplace_prepare_amplitudes,
 )
 from classiq.qmod.builtins.operations import (
     allocate,
+    bind,
     control,
     if_,
     inplace_add,
     inplace_xor,
+    invert,
     repeat,
     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 +251,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 +276,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 +327,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)"]],
@@ -390,7 +393,7 @@ def _dicke_split_cycle_shift(k: int, qvar: QArray[QBit]) -> None:
     internal function, assumes the input is in the form |11..100..0> with up to k ones.
     transforms the state to: sqrt(1/n)*|11..100..0> + sqrt((n-1)/n)*|01..110..0>.
     """
-    for i in range(k):
+    for i in range(min(k, qvar.len - 1)):
         within_apply(
             lambda i=i: CX(qvar[i + 1], qvar[0]),  # type: ignore[misc]
             lambda i=i: (  # type: ignore[misc]
@@ -412,7 +415,7 @@ def prepare_dicke_state_unary_input(max_k: int, qvar: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
 
-    Prepares a Dicke state with a variable number of excitations based on an unary-encoded input.
+    Prepares a Dicke state with a variable number of excitations based on a unary-encoded input.
 
     The Dicke state is defined to be:
 
@@ -427,9 +430,12 @@ def prepare_dicke_state_unary_input(max_k: int, qvar: QArray[QBit]) -> None:
         max_k: The maximum number of allowed excitations (upper bound for k).
         qvar: Unary-encoded quantum input register of length >= max_k. Must be pre-initialized.
     """
-    if qvar.len > max(1, max_k):
+    if qvar.len >= max(1, max_k):
         _dicke_split_cycle_shift(max_k, qvar)
-        prepare_dicke_state_unary_input(min(max_k, qvar.len - 2), qvar[1 : qvar.len])
+        if qvar.len > 2:
+            prepare_dicke_state_unary_input(
+                min(max_k, qvar.len - 2), qvar[1 : qvar.len]
+            )
 
 
 @qfunc
@@ -456,7 +462,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 +521,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 +544,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
 
@@ -564,6 +570,115 @@ def swap_states(a: int, b: int, target: QArray) -> None:
     )
 
 
+@qperm
+def _controlled_xor(
+    target: QNum, target_value: CInt, ctrl: QNum, ctrl_value: CInt
+) -> None:
+    control(ctrl == ctrl_value, lambda: inplace_xor(target_value, target))
+
+
+@qperm
+def _inplace_xor(i: CInt, target: QNum) -> None:
+    inplace_xor(i, target)
+
+
+def _update_states(
+    states: list[int],
+    q: QArray,
+    assignment_indices: list[int],
+    assignment_value: int,
+    pivot_indices: list[int],
+    pivot_value: int,
+) -> None:
+    _controlled_xor(
+        [q[i] for i in assignment_indices],
+        assignment_value,
+        [q[i] for i in pivot_indices],
+        pivot_value,
+    )
+    for j in range(len(states)):
+        s = states[j]
+        ctrl_bits = sum(((s >> i) & 1) << k for k, i in enumerate(pivot_indices))
+        if ctrl_bits == pivot_value:
+            for k, i in enumerate(assignment_indices):
+                if (assignment_value >> k) & 1:
+                    s ^= 1 << i
+
+        states[j] = s
+
+
+@qperm
+def pack_amplitudes(states: list[int], target: QArray) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Perform the inverse operation for sparse state preparation - for each given state in `states`,
+    move it to the first available computational basis state, according to the order in the array.
+    The function does not guarantee what happens to the other states which are not in the list.
+
+    Args:
+        states: A list of distinct computational basis indices to pack. The order of the list will
+                reflect the order of the packed states.
+        target: The quantum variable to act upon. Assumed to be larged enough to populate all given `states`,
+                and at least of size `2 * len(states)`.
+    """
+    target_size = target.len
+
+    # handle the dense case by using an additional auxilliary qubit
+    if len(states) > 2 ** (target_size - 1):
+        # allocate a pivot
+        p = QBit()
+        p |= 0
+        temp_target: QArray = QArray("extended_target")
+        bind([target, p], temp_target)
+        # replace register to unify the different flows
+        target, temp_target = temp_target, target
+
+    for index, _ in enumerate(states):
+        state = states[
+            index
+        ]  # access this way because `states` is changing in each iteration
+
+        if state == index:
+            continue  # nothing to do
+
+        if index == 0:
+            _inplace_xor(state, target)
+            states = [s ^ state for s in states]
+            continue
+
+        # if no pivot, create one:
+        if state < 2 ** index.bit_length():
+            pivot = index.bit_length()
+            _update_states(states, target, [pivot], 1, list(range(pivot)), state)
+        else:
+            pivot = state.bit_length() - 1
+
+        # use the pivot to update the quantum array
+        _update_states(
+            states,
+            target,
+            list(range(pivot)),
+            (state % (1 << pivot)) ^ index,
+            [pivot],
+            1,
+        )
+
+        # finally clean the pivot
+        if index == 2 ** (index.bit_length() - 1) and pivot < target_size:
+            # this specific case requires only a single ctrl qubit for the cleaning
+            # It won't work though if the auxilliary is used
+            _update_states(states, target, [pivot], 1, [index.bit_length() - 1], 1)
+        else:
+            _update_states(
+                states, target, [pivot], 1, list(range(index.bit_length())), index
+            )
+
+    if len(states) > 2 ** (target_size - 1):
+        bind(target, [temp_target, p])
+        free(p)
+
+
 @qfunc
 def inplace_prepare_sparse_amplitudes(
     states: list[int], amplitudes: list[complex], target: QArray
@@ -596,32 +711,23 @@ def inplace_prepare_sparse_amplitudes(
     dense_size = max(int(np.ceil(np.log2(len(states)))), 1)
     dense_amplitudes = np.zeros(2**dense_size, dtype=complex)
 
-    ## make sure the states with number smaller than the dense state size are located in their place already
-    for i, state in enumerate(states):
-        if state < len(dense_amplitudes):
+    if max(states) < 2**dense_size:
+        for i, state in enumerate(states):
             dense_amplitudes[state] = amplitudes[i]
-
-    ## make a swap list for all other states
-    swap_list = []
-    free_index = 0
-    for i, state in enumerate(states):
-        if state < len(dense_amplitudes):
-            continue  # already populated
-        while dense_amplitudes[free_index]:
-            free_index += 1  # index is not free
-
-        dense_amplitudes[free_index] = amplitudes[i]
-        swap_list.append((free_index, state))
-        free_index += 1
+    else:
+        dense_amplitudes = np.pad(
+            amplitudes, (0, 2**dense_size - len(amplitudes)), "constant"
+        )
 
     inplace_prepare_complex_amplitudes(
         np.abs(dense_amplitudes), np.angle(dense_amplitudes), target[0:dense_size]
     )
 
-    # swap all required states
-    sparse_size = max(int(np.ceil(np.log2(max(list(states) + [1])))), 1)
-    for a, b in swap_list:
-        swap_states(a, b, target[0:sparse_size])
+    if max(states) < 2**dense_size:
+        return
+
+    # Shuffle states to the desired position using the inverse operation of packing them
+    invert(lambda: pack_amplitudes(states, target))
 
 
 @qfunc

classiq/qmod/__init__.py

@@ -4,11 +4,11 @@ from .cfunc import cfunc
 from .classical_variable import measure
 from .create_model_function import create_model
 from .expression_query import get_expression_numeric_attributes
-from .qfunc import qfunc
+from .qfunc import qfunc, qperm
 from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
-from .qmod_variable import Const, Input, Output, Permutable, QArray, QBit, QNum, QStruct
-from .quantum_callable import QCallable, QCallableList
+from .qmod_variable import Const, Input, Output, QArray, QBit, QNum, QStruct
+from .quantum_callable import QCallable, QCallableList, QPerm, QPermList
 from .write_qmod import write_qmod
 
 __all__ = [
@@ -20,18 +20,20 @@ __all__ = [
     "Input",
     "Output",
     "Const",
-    "Permutable",
     "QArray",
     "QBit",
     "QNum",
     "QCallable",
     "QCallableList",
     "QConstant",
+    "QPerm",
+    "QPermList",
     "QStruct",
     "cfunc",
     "create_model",
     "measure",
     "get_expression_numeric_attributes",
     "qfunc",
+    "qperm",
     "write_qmod",
 ] + _builtins_all

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from classiq.interface.applications.iqae.iqae_result import IQAEResult
 from classiq.interface.exceptions import ClassiqError
@@ -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 = (
@@ -32,7 +31,7 @@ def save(values_to_save: dict) -> None:
 
 
 def sample(  # type: ignore[return]
-    execution_params: Optional[ExecutionParams] = None,
+    execution_params: ExecutionParams | None = None,
 ) -> ExecutionDetails:
     _raise_error("sample")
 
@@ -44,7 +43,7 @@ def batch_sample(  # type: ignore[return]
 
 
 def estimate(  # type: ignore[return]
-    hamiltonian: list[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
+    hamiltonian: list[QmodPyStruct], execution_params: ExecutionParams | None = None
 ) -> EstimationResult:
     _raise_error("estimate")
 
@@ -78,38 +77,20 @@ 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,
-    execution_params: Optional[ExecutionParams] = None,
+    execution_params: ExecutionParams | None = None,
 ) -> IQAEResult:
     _raise_error("iqae")
 
 
-def molecule_ground_state_solution_post_process(  # type: ignore[return]
-    problem: QmodPyStruct, vqe_result: VQESolverResult
-) -> QmodPyStruct:
-    _raise_error("molecule_ground_state_solution_post_process")
-
-
 __all__ = [
     "batch_estimate",
     "batch_sample",
     "estimate",
     "iqae",
-    "molecule_ground_state_solution_post_process",
     "qae_with_qpe_result_post_processing",
-    "qsvm_full_run",
     "sample",
     "save",
     "vqe",

classiq/qmod/builtins/classical_functions.py

@@ -1,7 +1,7 @@
 # This file was generated automatically - do not edit manually
 
 
-from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
+from classiq.qmod.qmod_parameter import CInt, CReal
 from classiq.qmod.symbolic import symbolic_function
 
 from .structs import *
@@ -17,47 +17,6 @@ def qft_const_adder_phase(
     )
 
 
-def fock_hamiltonian_problem_to_hamiltonian(
-    problem: FockHamiltonianProblem,
-) -> CArray[PauliTerm]:
-    return symbolic_function(
-        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
-    )
-
-
-def molecule_problem_to_hamiltonian(
-    problem: MoleculeProblem,
-) -> CArray[PauliTerm]:
-    return symbolic_function(
-        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
-    )
-
-
-def grid_entangler_graph(
-    num_qubits: CInt,
-    schmidt_rank: CInt,
-    grid_randomization: CBool,
-) -> CArray[CArray[CInt]]:
-    return symbolic_function(
-        num_qubits,
-        schmidt_rank,
-        grid_randomization,
-        return_type=CArray[CArray[CInt]],  # type:ignore[type-abstract]
-    )
-
-
-def hypercube_entangler_graph(
-    num_qubits: CInt,
-) -> CArray[CArray[CInt]]:
-    return symbolic_function(
-        num_qubits, return_type=CArray[CArray[CInt]]  # type:ignore[type-abstract]
-    )
-
-
 __all__ = [
     "qft_const_adder_phase",
-    "fock_hamiltonian_problem_to_hamiltonian",
-    "molecule_problem_to_hamiltonian",
-    "grid_entangler_graph",
-    "hypercube_entangler_graph",
 ]

classiq/qmod/builtins/enums.py

@@ -2,144 +2,12 @@ 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
 
 
-class Element(IntEnum):
-    H = 0
-    He = 1
-    Li = 2
-    Be = 3
-    B = 4
-    C = 5
-    N = 6
-    O = 7  # noqa: E741
-    F = 8
-    Ne = 9
-    Na = 10
-    Mg = 11
-    Al = 12
-    Si = 13
-    P = 14
-    S = 15
-    Cl = 16
-    Ar = 17
-    K = 18
-    Ca = 19
-    Sc = 20
-    Ti = 21
-    V = 22
-    Cr = 23
-    Mn = 24
-    Fe = 25
-    Co = 26
-    Ni = 27
-    Cu = 28
-    Zn = 29
-    Ga = 30
-    Ge = 31
-    As = 32
-    Se = 33
-    Br = 34
-    Kr = 35
-    Rb = 36
-    Sr = 37
-    Y = 38
-    Zr = 39
-    Nb = 40
-    Mo = 41
-    Tc = 42
-    Ru = 43
-    Rh = 44
-    Pd = 45
-    Ag = 46
-    Cd = 47
-    In = 48
-    Sn = 49
-    Sb = 50
-    Te = 51
-    I = 52  # noqa: E741
-    Xe = 53
-    Cs = 54
-    Ba = 55
-    La = 56
-    Ce = 57
-    Pr = 58
-    Nd = 59
-    Pm = 60
-    Sm = 61
-    Eu = 62
-    Gd = 63
-    Tb = 64
-    Dy = 65
-    Ho = 66
-    Er = 67
-    Tm = 68
-    Yb = 69
-    Lu = 70
-    Hf = 71
-    Ta = 72
-    W = 73
-    Re = 74
-    Os = 75
-    Ir = 76
-    Pt = 77
-    Au = 78
-    Hg = 79
-    Tl = 80
-    Pb = 81
-    Bi = 82
-    Po = 83
-    At = 84
-    Rn = 85
-    Fr = 86
-    Ra = 87
-    Ac = 88
-    Th = 89
-    Pa = 90
-    U = 91
-    Np = 92
-    Pu = 93
-    Am = 94
-    Cm = 95
-    Bk = 96
-    Cf = 97
-    Es = 98
-    Fm = 99
-    Md = 100
-    No = 101
-    Lr = 102
-    Rf = 103
-    Db = 104
-    Sg = 105
-    Bh = 106
-    Hs = 107
-    Mt = 108
-    Ds = 109
-    Rg = 110
-    Cn = 111
-    Nh = 112
-    Fl = 113
-    Mc = 114
-    Lv = 115
-    Ts = 116
-    Og = 117
-
-
-class FermionMapping(IntEnum):
-    JORDAN_WIGNER = 0
-    PARITY = 1
-    BRAVYI_KITAEV = 2
-    FAST_BRAVYI_KITAEV = 3
-
-
-class LadderOperator(IntEnum):
-    PLUS = 0
-    MINUS = 1
-
-
 class Optimizer(IntEnum):
     COBYLA = 1
     SPSA = 2
@@ -195,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__,
@@ -229,10 +95,6 @@ BUILTIN_ENUM_DECLARATIONS = {
 }
 
 __all__ = [
-    "Element",
-    "FermionMapping",
-    "LadderOperator",
     "Optimizer",
     "Pauli",
-    "QSVMFeatureMapEntanglement",
 ]