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

classiq/qmod/builtins/functions/__init__.py

@@ -1,24 +1,15 @@
 from .allocation import *
 from .arithmetic import *
 from .benchmarking import *
-from .chemistry import *
 from .exponentiation import *
+from .mcx_func 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 (
-        molecule_ucc,
-        molecule_hva,
-        molecule_hartree_fock,
-        fock_hamiltonian_ucc,
-        fock_hamiltonian_hva,
-        fock_hamiltonian_hartree_fock,
-        pauli_feature_map,
-        bloch_sphere_feature_map,
         H,
         X,
         Y,
@@ -60,6 +51,7 @@ CORE_LIB_DECLS = [
         U,
         CCX,
         free,
+        drop,
         randomized_benchmarking,
         inplace_prepare_state,
         inplace_prepare_state_approx,
@@ -68,12 +60,16 @@ CORE_LIB_DECLS = [
         single_pauli_exponent,
         commuting_paulis_exponent,
         suzuki_trotter,
+        unscheduled_suzuki_trotter,
+        exponentiate,
         multi_suzuki_trotter,
         parametric_suzuki_trotter,
         sparse_suzuki_trotter,
         qdrift,
         exponentiation_with_depth_constraint,
         RESET,
+        mcx,
+        SX,
     )
 ]
 
@@ -92,6 +88,7 @@ __all__ = [  # noqa: RUF022
     "H",
     "I",
     "IDENTITY",
+    "mcx",
     "PHASE",
     "R",
     "RX",
@@ -109,15 +106,13 @@ __all__ = [  # noqa: RUF022
     "X",
     "Y",
     "Z",
+    "SX",
     "add",
     "add_inplace_right",
     "apply",
-    "bloch_sphere_feature_map",
     "exponentiation_with_depth_constraint",
-    "fock_hamiltonian_hartree_fock",
-    "fock_hamiltonian_hva",
-    "fock_hamiltonian_ucc",
     "free",
+    "drop",
     "inplace_prepare_amplitudes",
     "inplace_prepare_amplitudes_approx",
     "inplace_prepare_state",
@@ -125,12 +120,8 @@ __all__ = [  # noqa: RUF022
     "integer_xor",
     "modular_add",
     "modular_add_constant",
-    "molecule_hartree_fock",
-    "molecule_hva",
-    "molecule_ucc",
     "multi_suzuki_trotter",
     "parametric_suzuki_trotter",
-    "pauli_feature_map",
     "permute",
     "prepare_amplitudes",
     "prepare_amplitudes_approx",

classiq/qmod/builtins/functions/allocation.py

@@ -1,12 +1,12 @@
 from typing import Literal
 
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_parameter import CArray, CReal
-from classiq.qmod.qmod_variable import Input, Output, Permutable, QArray, QBit
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
 
 
-@qfunc(external=True)
-def free(in_: Permutable[Input[QArray[QBit]]]) -> None:
+@qperm(external=True)
+def free(in_: Input[QArray[QBit]]) -> None:
     """
     [Qmod core-library function]
 
@@ -21,6 +21,27 @@ def free(in_: Permutable[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/arithmetic.py

@@ -1,12 +1,11 @@
 from typing import Literal
 
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_parameter import CArray, CBool, CReal
 from classiq.qmod.qmod_variable import (
     Const,
     Input,
     Output,
-    Permutable,
     QArray,
     QBit,
     QNum,
@@ -30,17 +29,15 @@ def unitary(
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def add(
     left: Const[QNum],
     right: Const[QNum],
-    result: Permutable[
-        Output[
-            QNum[
-                Literal["result_size"],
-                Literal["result_is_signed"],
-                Literal["result_fraction_places"],
-            ]
+    result: Output[
+        QNum[
+            Literal["result_size"],
+            Literal["result_is_signed"],
+            Literal["result_fraction_places"],
         ]
     ],
     result_size: CReal,
@@ -50,17 +47,15 @@ def add(
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def add_inplace_right(
     left: Const[QNum],
-    right: Permutable[Input[QNum]],
-    result: Permutable[
-        Output[
-            QNum[
-                Literal["result_size"],
-                Literal["result_is_signed"],
-                Literal["result_fraction_places"],
-            ]
+    right: Input[QNum],
+    result: Output[
+        QNum[
+            Literal["result_size"],
+            Literal["result_is_signed"],
+            Literal["result_fraction_places"],
         ]
     ],
     result_size: CReal,
@@ -70,21 +65,21 @@ def add_inplace_right(
     pass
 
 
-@qfunc(external=True)
-def modular_add(left: Const[QArray[QBit]], right: Permutable[QArray[QBit]]) -> None:
+@qperm(external=True)
+def modular_add(left: Const[QArray[QBit]], right: QArray[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
-def modular_add_constant(left: CReal, right: Permutable[QNum]) -> None:
+@qperm(external=True)
+def modular_add_constant(left: CReal, right: QNum) -> None:
     pass
 
 
-@qfunc(external=True)
-def integer_xor(left: Const[QArray[QBit]], right: Permutable[QArray[QBit]]) -> None:
+@qperm(external=True)
+def integer_xor(left: Const[QArray[QBit]], right: QArray[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
-def real_xor_constant(left: CReal, right: Permutable[QNum]) -> None:
+@qperm(external=True)
+def real_xor_constant(left: CReal, right: QNum) -> None:
     pass

classiq/qmod/builtins/functions/exponentiation.py

@@ -108,6 +108,55 @@ def multi_suzuki_trotter(
     pass
 
 
+@qfunc(external=True)
+def unscheduled_suzuki_trotter(
+    hamiltonians: CArray[SparsePauliOp],
+    evolution_coefficients: CArray[CReal],
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray,
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Applies the Suzuki-Trotter decomposition jointly to a sum of Hamiltonians
+    (represented as Pauli operators), each with its separate evolution coefficient,
+    approximating $\\exp{-iH_1t_1+H_2t_2+\\dots}$  with a specified order and number of
+    repetitions. Does not reorder the Pauli terms.
+
+    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    The Suzuki-Trotter decomposition of a given order nullifies the error of the Taylor series expansion of the product of exponentials up to that order.
+    The error of a Suzuki-Trotter decomposition decreases as the order and number of repetitions increase.
+
+    Args:
+        hamiltonians: The hamitonians to be exponentiated, in sparse representation.
+        evolution_coefficients: The hamiltonian coefficients (can be link-time).
+        order: The order of the Suzuki-Trotter decomposition.
+        repetitions: The number of repetitions of the Suzuki-Trotter decomposition.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
+@qfunc(external=True)
+def exponentiate(
+    hamiltonian: SparsePauliOp,
+    evolution_coefficient: CReal,
+    qbv: QArray[QBit],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Exponentiates a Pauli operator.
+
+    Args:
+        hamiltonian: The Pauli operator to be exponentiated.
+        evolution_coefficient: A global coefficient multiplying the Pauli operator.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
 @qfunc(external=True)
 def parametric_suzuki_trotter(
     paulis: CArray[CArray[Pauli]],
@@ -169,10 +218,10 @@ def sparse_suzuki_trotter(
 
 @qfunc(external=True)
 def qdrift(
-    pauli_operator: CArray[PauliTerm],
+    pauli_operator: SparsePauliOp,  # FIXME: Rename to hamiltonian (CLS-4347)
     evolution_coefficient: CReal,
     num_qdrift: CInt,
-    qbv: QArray[QBit, Literal["pauli_operator[0].pauli.len"]],
+    qbv: QArray[QBit],  # FIXME: Add length expr (CLS-4347)
 ) -> None:
     """
     [Qmod core-library function]

classiq/qmod/builtins/functions/mcx_func.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

classiq/qmod/builtins/functions/standard_gates.py

@@ -1,8 +1,8 @@
 from typing import Literal
 
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_parameter import CReal
-from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit
+from classiq.qmod.qmod_variable import Const, QArray, QBit
 
 
 @qfunc(external=True)
@@ -24,8 +24,8 @@ def H(target: QBit) -> None:
     pass
 
 
-@qfunc(external=True)
-def X(target: Permutable[QBit]) -> None:
+@qperm(external=True)
+def X(target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -43,8 +43,8 @@ def X(target: Permutable[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
-def Y(target: Permutable[QBit]) -> None:
+@qperm(external=True)
+def Y(target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -62,7 +62,7 @@ def Y(target: Permutable[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def Z(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -81,7 +81,7 @@ def Z(target: Const[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def I(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -100,7 +100,7 @@ def I(target: Const[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def S(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -119,7 +119,7 @@ def S(target: Const[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def T(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -138,7 +138,7 @@ def T(target: Const[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def SDG(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -157,7 +157,7 @@ def SDG(target: Const[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def TDG(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -176,7 +176,7 @@ def TDG(target: Const[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def PHASE(theta: CReal, target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -238,7 +238,7 @@ def RY(theta: CReal, target: QBit) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def RZ(theta: CReal, target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -323,7 +323,7 @@ def RYY(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def RZZ(theta: CReal, target: Const[QArray[QBit, Literal[2]]]) -> None:
     """
     [Qmod core-library function]
@@ -369,8 +369,8 @@ def CH(ctrl: Const[QBit], target: QBit) -> None:
     pass
 
 
-@qfunc(external=True)
-def CX(ctrl: Const[QBit], target: Permutable[QBit]) -> None:
+@qperm(external=True)
+def CX(ctrl: Const[QBit], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -394,8 +394,8 @@ def CX(ctrl: Const[QBit], target: Permutable[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
-def CY(ctrl: Const[QBit], target: Permutable[QBit]) -> None:
+@qperm(external=True)
+def CY(ctrl: Const[QBit], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -419,7 +419,7 @@ def CY(ctrl: Const[QBit], target: Permutable[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def CZ(ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -496,7 +496,7 @@ def CRY(theta: CReal, ctrl: Const[QBit], target: QBit) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def CRZ(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -522,7 +522,7 @@ def CRZ(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def CPHASE(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
@@ -548,8 +548,8 @@ def CPHASE(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
-def SWAP(qbit0: Permutable[QBit], qbit1: Permutable[QBit]) -> None:
+@qperm(external=True)
+def SWAP(qbit0: QBit, qbit1: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -573,7 +573,7 @@ def SWAP(qbit0: Permutable[QBit], qbit1: Permutable[QBit]) -> None:
     pass
 
 
-@qfunc(external=True)
+@qperm(external=True)
 def IDENTITY(target: Const[QArray[QBit]]) -> None:
     """
     [Qmod core-library function]
@@ -622,8 +622,8 @@ def U(theta: CReal, phi: CReal, lam: CReal, gam: CReal, target: QBit) -> None:
     pass
 
 
-@qfunc(external=True)
-def CCX(ctrl: Const[QArray[QBit, Literal[2]]], target: Permutable[QBit]) -> None:
+@qperm(external=True)
+def CCX(ctrl: Const[QArray[QBit, Literal[2]]], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -649,3 +649,22 @@ def CCX(ctrl: Const[QArray[QBit, Literal[2]]], target: Permutable[QBit]) -> None
         target (QBit): The qubit to apply the conditioned Pauli-X gate on.
     """
     pass
+
+
+@qfunc(external=True)
+def SX(target: QBit) -> None:
+    """
+    [Qmod core-library function]
+
+    Performs the sqrt(X) gate on a qubit.
+
+    This operation is represented by the following matrix:
+
+    $$
+    SX = 1/\\sqrt2 \\begin{bmatrix}
+    1+i & i-1 \\\\
+    i-1 & 1+i \\\\
+    \\end{bmatrix}
+    $$
+    """
+    pass