classiq 0.45.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

classiq/qmod/builtins/functions/qaoa_penalty.py

@@ -0,0 +1,116 @@
+from typing import Literal
+
+from classiq.qmod.builtins.structs import PauliTerm
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CInt, CReal
+from classiq.qmod.qmod_variable import QArray, QBit
+
+
+@qfunc(external=True)
+def qaoa_mixer_layer(b: CReal, target: QArray[QBit]) -> None:
+    """
+    Qmod Classiq-library function
+
+    Generates the mixer layer for the QAOA algorithm.
+    The mixer layer is a sequence of `X` gates applied to each qubit in the target quantum
+    array variable.
+
+    Please refer to the [QAOA mixer tutorial](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/combinatorial-optimization/problem-solving/) for an example
+
+
+    Args:
+        b: The rotation parameter for the mixer layer.
+        target: The target quantum array.
+    """
+    pass
+
+
+@qfunc(external=True)
+def qaoa_cost_layer(
+    g: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
+) -> None:
+    """
+    Qmod Classiq-library function
+
+    Apply the cost layer to the QAOA model.
+
+    This function integrates the problem-specific cost function into the QAOA model's objective function.
+    The cost layer represents the primary objective that the QAOA algorithm seeks to optimize, such as
+    minimizing energy or maximizing profit, depending on the application.
+
+    For more details on defining cost functions in QAOA models using Pyomo, see: [Problem Formulation](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/combinatorial-optimization/)
+    Args:
+        g: The rotation parameter for the cost layer (prefactor).
+        hamiltonian: The Hamiltonian terms for the QAOA model.
+        target: The target quantum array variable.
+    """
+    pass
+
+
+@qfunc(external=True)
+def qaoa_layer(
+    g: CReal, b: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
+) -> None:
+    """
+    Qmod Classiq-library function
+
+    Apply the QAOA layer, which concatenates the cost layer and the mixer layer.
+
+    The `qaoa_layer` function integrates both the cost and mixer layers, essential components of the
+    Quantum Approximate Optimization Algorithm (QAOA). The cost layer encodes the problem's objective,
+    while the mixer layer introduces quantum superposition and drives the search across the solution space.
+
+    For more details mon the QAOA problem formulation, please see the following [tutorial](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/combinatorial-optimization/)
+    Args:
+           g: The rotation parameter for the cost layer.
+           b: The rotation parameter for the mixer layer.
+           hamiltonian: The Hamiltonian terms for the QAOA model.
+           target: The target quantum array variable.
+
+    """
+    pass
+
+
+@qfunc(external=True)
+def qaoa_init(target: QArray[QBit]) -> None:
+    """
+    Qmod Classiq-library function
+
+    Initialize the QAOA circuit by applying the Hadamard gate to all qubits.
+
+    In the Quantum Approximate Optimization Algorithm (QAOA), the initial state is a uniform superposition
+    created by applying the Hadamard gate to each qubit. This function prepares the qubits for the subsequent
+    application of the cost and mixer layers by preparing them in an equal superposition state.
+
+    Args:
+           target: The target quantum array variable.
+    """
+    pass
+
+
+@qfunc(external=True)
+def qaoa_penalty(
+    num_qubits: CInt,
+    params_list: CArray[CReal],
+    hamiltonian: CArray[PauliTerm],
+    target: QArray[QBit, Literal["num_qubits"]],
+) -> None:
+    """
+    Qmod Classiq-library function
+
+    Apply the penalty layer to the QAOA model.
+
+    This function adds a penalty term to the objective function of the QAOA model to
+    enforce certain constraints (e.g., binary or integer variables) during the
+    optimization process.
+
+    Please refer to the [Optimization Problem tutorial](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/combinatorial-optimization/problem-formulation/) for details.
+
+
+    Args:
+        num_qubits: The number of qubits in the quantum circuit.
+        params_list The list of QAOA parameters.
+        hamiltonian: The Hamiltonian terms for the QAOA model.
+        target: The target quantum array variable.
+    """
+    pass

classiq/qmod/builtins/functions/qft.py

@@ -0,0 +1,23 @@
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit
+
+
+@qfunc(external=True)
+def qft(target: QArray[QBit]) -> None:
+    """
+    Qmod Classiq-library function.
+
+    Performs the Quantum Fourier Transform (QFT) on `target` in-place.
+    Implements the following transformation:
+
+    $$
+    y_{k} = \\frac{1}{\\sqrt{N}} \\sum_{j=0}^{N-1} x_j e^{2\\pi i \\frac{jk}{N}}
+    $$
+
+    Args:
+        target: The quantum object to be transformed
+
+    Further reading in Classiq Library:
+    Link: [qft library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qft/qft.ipynb)
+    """
+    pass

classiq/qmod/builtins/functions/qpe.py

@@ -0,0 +1,39 @@
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CInt
+from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.quantum_callable import QCallable
+
+
+@qfunc(external=True)
+def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
+    """
+    Qmod Classiq-library function.
+
+    Implements the Quantum Phase Estimation (QPE) algorithm,  which estimates the phase (eigenvalue) associated with an eigenstate of a given unitary operator $U$.
+    This is a flexible version that allows the user to provide a callable that generates the unitary operator $U^k$ for a given integer $k$, offering greater flexibility in handling different quantum circuits using some powering rule.
+
+    Args:
+        unitary_with_power: A callable that returns the unitary operator $U^k$ given an integer $k$. This callable is used to control the application of powers of the unitary operator.
+        phase: The quantum variable that represents the estimated phase (eigenvalue), assuming initialized to zero.
+
+    Further reading in Classiq Library:
+    Link: [qpe library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb)
+    """
+    pass
+
+
+@qfunc(external=True)
+def qpe(unitary: QCallable, phase: QNum) -> None:
+    """
+    Qmod Classiq-library function.
+
+    Implements the standard Quantum Phase Estimation (QPE) algorithm, which estimates the phase (eigenvalue) associated with an eigenstate of a given unitary operator $U$.
+
+    Args:
+        unitary: A callable representing the unitary operator $U$, whose eigenvalue is to be estimated.
+        phase: The quantum variable that represents the estimated phase (eigenvalue), assuming initialized to zero.
+
+    Further reading in Classiq Library:
+    Link: [qpe library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb)
+    """
+    pass

classiq/qmod/builtins/functions/qsvm.py

@@ -0,0 +1,24 @@
+from typing import Literal
+
+from classiq.qmod.builtins.structs import (
+    QSVMFeatureMapPauli,
+)
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CInt
+from classiq.qmod.qmod_variable import QArray, QBit
+
+
+@qfunc(external=True)
+def pauli_feature_map(
+    feature_map: QSVMFeatureMapPauli,
+    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def bloch_sphere_feature_map(
+    feature_dimension: CInt,
+    qbv: QArray[QBit, Literal["ceiling(feature_dimension / 2)"]],
+) -> None:
+    pass

classiq/qmod/builtins/functions/qsvt.py

@@ -0,0 +1,136 @@
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CReal
+from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.quantum_callable import QCallable
+
+
+@qfunc(external=True)
+def qsvt_step(
+    phase1: CReal,
+    phase2: CReal,
+    proj_cnot_1: QCallable[QArray[QBit], QBit],
+    proj_cnot_2: QCallable[QArray[QBit], QBit],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QBit,
+) -> None:
+    r"""
+    Qmod Classiq-library function.
+
+    Applies a single QSVT step, composed of 2 projector-controlled-phase rotations, and applications of the block encoding unitary `u` and its inverse:
+
+    $$
+    \Pi_{\phi_2}U^{\dagger}\tilde{\Pi}_{\phi_{1}}U
+    $$
+
+    Args:
+        phase1: 1st rotation phase.
+        phase2: 2nd rotation phase.
+        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        u: A block encoded unitary matrix.
+        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+
+    Further reading in Classiq Library:
+        [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
+    """
+    pass
+
+
+@qfunc(external=True)
+def qsvt(
+    phase_seq: CArray[CReal],
+    proj_cnot_1: QCallable[QArray[QBit], QBit],
+    proj_cnot_2: QCallable[QArray[QBit], QBit],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QBit,
+) -> None:
+    r"""
+    Qmod Classiq-library function.
+
+    Implements the Quantum Singular Value Transformation (QSVT) - an algorithmic framework, used to apply polynomial transformations of degree `d` on the singular values of a block encoded matrix, given as the unitary `u`.    Given a unitary $U$, a list of phase angles  $\phi_1, \phi_2, ..., \phi_{d+1}$ and 2 projector-controlled-not operands $C_{\Pi}NOT,C_{\tilde{\Pi}}NOT$, the QSVT sequence is as follows:
+    Given a unitary $U$, a list of phase angles  $\phi_1, \phi_2, ..., \phi_{d+1}$ and 2 projector-controlled-not operands $C_{\Pi}NOT,C_{\tilde{\Pi}}NOT$, the QSVT sequence is as follows:
+
+    $$
+    \tilde{\Pi}_{\phi_{d+1}}U \prod_{k=1}^{(d-1)/2} (\Pi_{\phi_{d-2k}} U^{\dagger}\tilde{\Pi}_{\phi_{d - (2k+1)}}U)\Pi_{\phi_{1}}
+    $$
+
+    for odd $d$, and:
+
+    $$
+    \prod_{k=1}^{d/2} (\Pi_{\phi_{d-(2k-1)}} U^{\dagger}\tilde{\Pi}_{\phi_{d-2k}}U)\Pi_{\phi_{1}}
+    $$
+
+    for even $d$.
+
+    Each of the $\Pi$s is a projector-controlled-phase unitary, according to the given projectors.
+
+    Args:
+        phase_seq: A sequence of phase angles of length d+1.
+        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        u: A block encoded unitary matrix.
+        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+
+    Further reading in Classiq Library:
+        [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
+    """
+    pass
+
+
+@qfunc(external=True)
+def projector_controlled_phase(
+    phase: CReal,
+    proj_cnot: QCallable[QArray[QBit], QBit],
+    qvar: QArray[QBit],
+    aux: QBit,
+) -> None:
+    r"""
+    Qmod Classiq-library function.
+
+    Assigns a phase to the entire subspace determined by the given projector. Corresponds to the operation:
+
+    $$
+    \Pi_{\phi} = (C_{\Pi}NOT) e^{-i\frac{\phi}{2}Z}(C_{\Pi}NOT)
+    $$
+
+    Args:
+        phase_seq: A rotation phase.
+        proj_cnot: Projector-controlled-not unitary that sets an auxilliary qubit to |1> when the state is in the projection.
+        qvar: The quantum variable to which the rotation applies, which resides in the entire block encoding space.
+        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotation. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+
+    Further reading in Classiq Library:
+        [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
+    """
+    pass
+
+
+@qfunc(external=True)
+def qsvt_inversion(
+    phase_seq: CArray[CReal],
+    block_encoding_cnot: QCallable[QArray[QBit], QBit],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QBit,
+) -> None:
+    r"""
+    Qmod Classiq-library function.
+
+    Implements matrix inversion on a given block-encoding of a square matrix, using the QSVT framework. Applies a polynomial approximation
+    of the inverse of the singular values of the matrix encoded in `u`. The phases for the polynomial should be pre-calculated and passed into the function.
+
+    Args:
+        phase_seq: A sequence of phase angles of length d+1, corresponding to an odd polynomial approximation of the scaled inverse function.
+        block_encoding_cnot: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        u: A block encoded unitary matrix.
+        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+
+    For usage example, see:
+        [QSVT matrix inversion example](https://docs.classiq.io/latest/explore/algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion)
+    """
+    pass