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

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.46.0'
+SEMVER_VERSION = '0.46.1'
 VERSION = str(Version(SEMVER_VERSION))

classiq/qmod/builtins/functions/amplitude_estimation.py

@@ -12,7 +12,8 @@ def amplitude_estimation(
 ) -> None:
     """
     [Qmod Classiq-library function]
-    Amplitude estimation function is used to estimate the probability of a state being marked by the operand `oracle` as a "good state."
+
+    Estimate the probability of a state being marked by the operand `oracle` as a "good state."
 
     The algorithm prepares the state in the `packed_vars` register and estimates the probability of this state being marked by the oracle as a "good state."
     This is done using the Quantum Phase Estimation (QPE) algorithm, where the unitary for QPE is the Grover operator, which is composed of the `oracle` and `space_transform` operators.

classiq/qmod/builtins/functions/arithmetic.py

@@ -14,7 +14,7 @@ def unitary(
     """
     [Qmod core-library function]
 
-    Apply a unitary matrix on a quantum state.
+    Applies a unitary matrix on a quantum state.
 
     Args:
         elements:  A 2d array of complex numbers representing the unitary matrix. This matrix must be unitary.
@@ -51,7 +51,7 @@ def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
 @qfunc(external=True)
 def modular_increment(a: CInt, x: QNum) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Adds $a$ to $x$ modulo the range of $x$, assumed that $x$ is a non-negative integer and $a$ is an integer.
     Mathematically it is described as:

classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py

@@ -14,22 +14,22 @@ def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
 
 @qfunc(external=True)
 def qct_qst_type1(x: QArray[QBit]) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies the quantum discrete cosine (DCT) and sine (DST)
     transform of type 1 to the qubit array `x`.
-    Corresponds to the matrix (with $n\equiv$`x.len`):
+    Corresponds to the matrix (with $n\\equiv$`x.len`):
 
     $$
-    \left(
+    \\left(
     \begin{array}{ccc|c}
     {} &{} &{} \\
       {}&{\rm DCT}^{(1)}(2^{n-1}+1) & {}& 0\\
       {} &{} &{} \\
-      \hline
+      \\hline
       {} & 0 & {} & i{\rm DST}^{(1)}(2^{n-1}-1)
-    \end{array}
+    \\end{array}
     \right)
     $$
 
@@ -44,20 +44,20 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
 
 @qfunc(external=True)
 def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies the quantum discrete cosine (DCT) and sine (DST)
     transform of type 2 to the qubit array `x` concatenated with `q`, with `q` being the MSB.
-    Corresponds to the matrix (with $n\equiv$`x.len`+1):
+    Corresponds to the matrix (with $n\\equiv$`x.len`+1):
 
     $$
-    \left(
+    \\left(
     \begin{array}{c|c}
       {\rm DCT}^{(2)}(2^{n-1}) & 0\\
-      \hline
+      \\hline
       0 & -{\rm DST}^{(2)}(2^{n-1})
-    \end{array}
+    \\end{array}
     \right)
     $$
 
@@ -73,8 +73,8 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
 
 @qfunc(external=True)
 def qct_type2(x: QArray[QBit]) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies the quantum discrete cosine (DCT)
     transform of type 2, ${\rm DCT}^{(2)}$, to the qubit array `x`.
@@ -90,8 +90,8 @@ def qct_type2(x: QArray[QBit]) -> None:
 
 @qfunc(external=True)
 def qst_type2(x: QArray[QBit]) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies the quantum discrete sine (DST)
     transform of type 2, ${\rm DST}^{(2)}$, to the qubit array `x`.

classiq/qmod/builtins/functions/exponentiation.py

@@ -16,9 +16,9 @@ def single_pauli_exponent(
     qbv: QArray[QBit, Literal["get_field(pauli_string, 'len')"]],
 ) -> None:
     """
-    [Qmod Classiq-library function]
-    This function exponentiates a single Pauli operator.
-    The operator may be multiplied by a coefficient.
+    [Qmod core-library function]
+
+    Exponentiates the specified single Pauli operator multiplied by some coefficient.
 
     Args:
         pauli_string: The Pauli operator to be exponentiated.
@@ -39,9 +39,9 @@ def suzuki_trotter(
     ],
 ) -> None:
     """
-    [Qmod Classiq-library function]
-    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
-    This function applies the Suzuki-Trotter decomposition to a Pauli operator.
+    [Qmod core-library function]
+
+    Applies the Suzuki-Trotter decomposition to a Pauli operator. 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.
 
@@ -67,9 +67,9 @@ def qdrift(
     ],
 ) -> None:
     """
-    [Qmod Classiq-library function]
-    The QDrift method is a stochastic method based on the Trotter decomposition for approximating the exponential of a sum of operators by a product of exponentials of each operator.
-    This function exponentiates a Pauli operator using the QDrift method.
+    [Qmod core-library function]
+
+    Exponentiates a Pauli operator using the QDrift method. The QDrift method is a stochastic method based on the Trotter decomposition for approximating the exponential of a sum of operators by a product of exponentials of each operator.
     The QDrift method randomizes the order of the operators in the product of exponentials to stochastically reduce the error of the approximation.
     The error of the QDrift method decreases as the number of QDrift steps increases.
 
@@ -94,8 +94,9 @@ def exponentiation_with_depth_constraint(
     ],
 ) -> None:
     """
-    [Qmod Classiq-library function]
-    This function exponentiates a Pauli operator via the Suzuki-Trotter decomposition with a depth constraint.
+    [Qmod core-library function]
+
+    Exponentiates a Pauli operator via the Suzuki-Trotter decomposition with a depth constraint.
     The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
     This function automatically determines the order and number of repetitions of the Suzuki-Trotter decomposition to minimize the error given a depth constraint.
 

classiq/qmod/builtins/functions/grover.py

@@ -10,22 +10,21 @@ from classiq.qmod.quantum_callable import QCallable
 def phase_oracle(
     predicate: QCallable[QArray[QBit], QBit], target: QArray[QBit]
 ) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Creates a phase oracle operator based on a predicate function.
-    The function can be used on its own, or by other functions, such as Grover's algorithm.
 
     Applies a predicate function and marks "good" and "bad" states with a phase flip.
-    If the predicate is marked as $\chi$, and the oracle is marked as $S_\chi$, then:
+    If the predicate is marked as $\\chi$, and the oracle is marked as $S_\\chi$, then:
 
 
     $$
-    S_\chi\lvert x \rangle =
+    S_\\chi\\lvert x \rangle =
     \begin{cases}
-    -\lvert x \rangle & \text{if } \chi(x) = 1 \\
-     \phantom{-} \lvert x \rangle & \text{if } \chi(x) = 0
-    \end{cases}
+    -\\lvert x \rangle & \text{if } \\chi(x) = 1 \\
+     \\phantom{-} \\lvert x \rangle & \text{if } \\chi(x) = 0
+    \\end{cases}
     $$
 
     Args:
@@ -42,16 +41,16 @@ def phase_oracle(
 
 @qfunc(external=True)
 def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
-    r"""
-    Qmod core-library function
+    """
+    [Qmod Classiq-library function]
 
     Reflects the state about the |0> state (i.e. applies a (-1) phase to all states
     besides the |0> state). Implements the operator $S_0$:
 
     $$
     \begin{equation}
-    S_0|{x}\rangle = (-1)^{(x\ne0)}|{x}\rangle= (2|{0}\rangle\langle{0}|-I)|{x}\rangle
-    \end{equation}
+    S_0|{x}\rangle = (-1)^{(x\ne0)}|{x}\rangle= (2|{0}\rangle\\langle{0}|-I)|{x}\rangle
+    \\end{equation}
     $$
 
     Args:
@@ -64,16 +63,16 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
 def grover_diffuser(
     space_transform: QCallable[QArray[QBit]], packed_vars: QArray[QBit]
 ) -> None:
-    r"""
-    Qmod core-library function
+    """
+    [Qmod Classiq-library function]
 
-    The Grover diffuser operator reflects the given state about the A|0> state, where A
+    Reflects the given state about the A|0> state, where A
     is the `space_transform` parameter. It is defined as:
 
     $$
     \begin{equation}
-    D = A S_0 A^{\dagger}
-    \end{equation}
+    D = A S_0 A^{\\dagger}
+    \\end{equation}
     $$
 
     where $S_0$ is the reflection about the |0> state (see `reflect_about_zero`).
@@ -91,22 +90,22 @@ def grover_operator(
     space_transform: QCallable[QArray[QBit]],
     packed_vars: QArray[QBit],
 ) -> None:
-    r"""
-    Qmod open-library function
+    """
+    [Qmod Classiq-library function]
 
     Applies the grover operator, defined by:
 
     $$
-    Q=S_{\psi_0}S_{\psi_1}
+    Q=S_{\\psi_0}S_{\\psi_1}
     $$
 
-    where $S_{\psi_1}$ is a reflection about marked states, and $S_{\psi_0}$ is a reflection
-    about a given state defined by $|\psi_0\rangle = A|0\rangle$.
+    where $S_{\\psi_1}$ is a reflection about marked states, and $S_{\\psi_0}$ is a reflection
+    about a given state defined by $|\\psi_0\rangle = A|0\rangle$.
 
 
     Args:
         oracle: A unitary operator which adds a phase of (-1) to marked states.
-        space_transform: The operator which creates $|\psi_0\rangle$, the initial state, used by the diffuser to reflect about it.
+        space_transform: The operator which creates $|\\psi_0\rangle$, the initial state, used by the diffuser to reflect about it.
         packed_vars: The state to which to apply the grover operator.
 
 
@@ -123,8 +122,8 @@ def grover_operator(
 def grover_search(
     reps: CInt, oracle: QCallable[QArray[QBit]], packed_vars: QArray[QBit]
 ) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies Grover search algorithm.
 
@@ -144,15 +143,15 @@ def grover_search(
 
 @qfunc(external=True)
 def hadamard_transform(target: QArray[QBit]) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies Hadamard transform to the target qubits.
 
     Corresponds to the braket notation:
 
     $$
-     H^{\otimes n} |x\rangle = \frac{1}{\sqrt{2^n}} \sum_{y=0}^{2^n - 1} (-1)^{x \cdot y} |y\rangle
+     H^{\\otimes n} |x\rangle = \frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^n - 1} (-1)^{x \\cdot y} |y\rangle
     $$
 
     Args:
@@ -167,7 +166,7 @@ def apply_to_all(
     gate_operand: QCallable[Annotated[QBit, "target"]], target: QArray[QBit]
 ) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Applies the single-qubit operand `gate_operand` to each qubit in the qubit
     array `target`.

classiq/qmod/builtins/functions/hea.py

@@ -22,7 +22,7 @@ def full_hea(
     x: QArray[QBit, Literal["num_qubits"]],
 ) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Implements an ansatz on a qubit array `x` with the given 1-qubit and 2-qubit operations.
 

classiq/qmod/builtins/functions/linear_pauli_rotation.py

@@ -26,8 +26,8 @@ def linear_pauli_rotations(
     x: QArray[QBit],
     q: QArray[QBit],
 ) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Performs a rotation on a series of $m$ target qubits,
     where the rotation angle is a linear function of an $n$-qubit
@@ -36,14 +36,14 @@ def linear_pauli_rotations(
     Corresponds to the braket notation:
 
     $$
-    \left|x\right\rangle _{n}\left|q\right\rangle
-    _{m}\rightarrow\left|x\right\rangle
-    _{n}\prod_{k=1}^{m}\left(\cos\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)-
-    i\sin\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)P_{k}\right)\left|q_{k}\right\rangle
+    \\left|x\right\rangle _{n}\\left|q\right\rangle
+    _{m}\rightarrow\\left|x\right\rangle
+    _{n}\\prod_{k=1}^{m}\\left(\\cos\\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)-
+    i\\sin\\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)P_{k}\right)\\left|q_{k}\right\rangle
     $$
 
-    where $\left|x\right\rangle$ is the control register,
-    $\left|q\right\rangle$ is the target register, each $P_{k}$ is one of
+    where $\\left|x\right\rangle$ is the control register,
+    $\\left|q\right\rangle$ is the target register, each $P_{k}$ is one of
     the three Pauli matrices $X$, $Y$, or $Z$, and $a_{k}$, $b_{k}$ are
     the user given slopes and offsets, respectively.
 

classiq/qmod/builtins/functions/modular_exponentiation.py

@@ -6,7 +6,7 @@ from classiq.qmod.qmod_variable import QArray, QBit, QNum
 @qfunc(external=True)
 def qft_no_swap(qbv: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Applies the Quantum Fourier Transform (QFT) without the swap gates.
 
@@ -30,7 +30,7 @@ def _ctrl_x(ref: CInt, ctrl: QNum, aux: QBit) -> None:
 @qfunc(external=True)
 def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Adds a constant to a quantum number (in the Fourier space) using the Quantum Fourier Transform (QFT) Adder algorithm.
     Assuming that the input `phi_b` has `n` qubits, the result will be $\\phi_b+=value \\mod 2^n$.
@@ -49,7 +49,7 @@ def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
 @qfunc(external=True)
 def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Adds a constant `a` to a quantum number `phi_b` modulo the constant `n`, controlled by 2 qubits.
     The quantum number `phi_b` and the constant `a` are assumed to be in the QFT space.
@@ -70,7 +70,7 @@ def c_modular_multiply(
     n: CInt, a: CInt, b: QArray[QBit], x: QArray[QBit], ctrl: QBit
 ) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Performs out-of-place multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
     controlled by a quantum bit `ctrl` and adds the result to a quantum array `b`. Applies $b += xa \\mod n$ if `ctrl=1`, and the identity otherwise.
@@ -88,10 +88,10 @@ def c_modular_multiply(
 @qfunc(external=True)
 def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Swaps the qubit states between two arrays.
-    Swaps according to the indices of the shorter array.
+    Qubits of respective indices are swapped, and additional qubits in the longer array are left unchanged.
 
     Args:
         x: The first array
@@ -104,9 +104,9 @@ def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
 @qfunc(external=True)
 def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
-    Performs Multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
+    Performs multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
     controlled by a quantum bit `ctrl`. Applies $x=xa \\mod n$ if `ctrl=1`, and the identity otherwise.
 
     Args:
@@ -121,7 +121,7 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
 @qfunc(external=True)
 def modular_exp(n: CInt, a: CInt, x: QArray[QBit], power: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Raises a classical integer `a` to the power of a quantum number `x` modulo classical integer `n`
     times a quantum number `power`. Performs $power=(a^x \\mod n)*power$ in-place.

classiq/qmod/builtins/functions/qaoa_penalty.py

@@ -9,9 +9,9 @@ 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
+    [Qmod Classiq-library function]
 
-    Generates the mixer layer for the QAOA algorithm.
+    Applies 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.
 
@@ -30,9 +30,9 @@ def qaoa_cost_layer(
     g: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
 ) -> None:
     """
-    Qmod Classiq-library function
+    [Qmod Classiq-library function]
 
-    Apply the cost layer to the QAOA model.
+    Applies 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
@@ -52,9 +52,9 @@ def qaoa_layer(
     g: CReal, b: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
 ) -> None:
     """
-    Qmod Classiq-library function
+    [Qmod Classiq-library function]
 
-    Apply the QAOA layer, which concatenates the cost layer and the mixer layer.
+    Applies 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,
@@ -74,9 +74,9 @@ def qaoa_layer(
 @qfunc(external=True)
 def qaoa_init(target: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function
+    [Qmod Classiq-library function]
 
-    Initialize the QAOA circuit by applying the Hadamard gate to all qubits.
+    Initializes 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
@@ -96,9 +96,9 @@ def qaoa_penalty(
     target: QArray[QBit, Literal["num_qubits"]],
 ) -> None:
     """
-    Qmod Classiq-library function
+    [Qmod Classiq-library function]
 
-    Apply the penalty layer to the QAOA model.
+    Applies 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

classiq/qmod/builtins/functions/qft.py

@@ -5,7 +5,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 @qfunc(external=True)
 def qft(target: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Performs the Quantum Fourier Transform (QFT) on `target` in-place.
     Implements the following transformation:

classiq/qmod/builtins/functions/qpe.py

@@ -7,7 +7,7 @@ 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.
+    [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.
@@ -25,7 +25,7 @@ def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
 @qfunc(external=True)
 def qpe(unitary: QCallable, phase: QNum) -> None:
     """
-    Qmod Classiq-library function.
+    [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$.
 

classiq/qmod/builtins/functions/qsvt.py

@@ -14,13 +14,13 @@ def qsvt_step(
     qvar: QArray[QBit],
     aux: QBit,
 ) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [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
+    \\Pi_{\\phi_2}U^{\\dagger}\tilde{\\Pi}_{\\phi_{1}}U
     $$
 
     Args:
@@ -47,25 +47,25 @@ def qsvt(
     qvar: QArray[QBit],
     aux: QBit,
 ) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [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:
+    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}}
+    \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}}
+    \\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.
+    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.
@@ -88,13 +88,13 @@ def projector_controlled_phase(
     qvar: QArray[QBit],
     aux: QBit,
 ) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [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)
+    \\Pi_{\\phi} = (C_{\\Pi}NOT) e^{-i\frac{\\phi}{2}Z}(C_{\\Pi}NOT)
     $$
 
     Args:
@@ -117,8 +117,8 @@ def qsvt_inversion(
     qvar: QArray[QBit],
     aux: QBit,
 ) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [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.

classiq/qmod/builtins/functions/standard_gates.py

@@ -409,9 +409,9 @@ def CH(control: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
-    Applies the controlled-Hadamard (CH) gate to the target qubit, conditioned on the control qubit.
+    Applies the Hadamard gate to the target qubit, conditioned on the control qubit.
 
-    The controlled-Hadamard gate applies a Hadamard transformation to the target qubit only if the control qubit is in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CH = \\frac{1}{\\sqrt{2}} \\begin{bmatrix}
@@ -438,7 +438,7 @@ def CX(control: QBit, target: QBit) -> None:
 
     Applies the Pauli-X gate to the target qubit, conditioned on the control qubit.
 
-    The controlled-X gate applies a Pauli-X (NOT) gate to the target qubit only if the control qubit is in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CX = \\begin{bmatrix}
@@ -465,7 +465,7 @@ def CY(control: QBit, target: QBit) -> None:
 
     Applies the Pauli-Y gate to the target qubit, conditioned on the control qubit.
 
-    The controlled-Y gate applies a Pauli-Y gate to the target qubit only if the control qubit is in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CY = \\begin{bmatrix}
@@ -492,7 +492,7 @@ def CZ(control: QBit, target: QBit) -> None:
 
     Applies the Pauli-Z gate to the target qubit, conditioned on the control qubit.
 
-    The controlled-Z gate applies a Pauli-Z gate to the target qubit only if the control qubit is in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CZ = \\begin{bmatrix}
@@ -519,7 +519,7 @@ def CRX(theta: CReal, control: QBit, target: QBit) -> None:
 
     Applies the RX gate to the target qubit, conditioned on the control qubit.
 
-    The controlled-RX gate applies a RX gate to the target qubit only if the control qubit is in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CRX = \\begin{bmatrix}
@@ -547,7 +547,7 @@ def CRY(theta: CReal, control: QBit, target: QBit) -> None:
 
     Applies the RY gate to the target qubit, conditioned on the control qubit.
 
-    The controlled-RY gate applies a RY gate to the target qubit only if the control qubit is in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CRY = \\begin{bmatrix}
@@ -575,7 +575,7 @@ def CRZ(theta: CReal, control: QBit, target: QBit) -> None:
 
     Applies the RZ gate to the target qubit, conditioned on the control qubit.
 
-    The controlled-RZ gate applies a RZ gate to the target qubit only if the control qubit is in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CRZ = \\begin{bmatrix}
@@ -603,7 +603,7 @@ def CPHASE(theta: CReal, control: QBit, target: QBit) -> None:
 
     Applies the PHASE gate to the target qubit, conditioned on the control qubit.
 
-    The controlled-PHASE gate applies a PHASE gate to the target qubit only if the control qubit is in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CPHASE = \\begin{bmatrix}
@@ -631,7 +631,7 @@ def SWAP(qbit0: QBit, qbit1: QBit) -> None:
 
     Swaps the states of two qubits.
 
-    The SWAP gate exchanges the states of two qubits. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     SWAP = \\begin{bmatrix}
@@ -654,7 +654,7 @@ def SWAP(qbit0: QBit, qbit1: QBit) -> None:
 @qfunc(external=True)
 def IDENTITY(target: QArray[QBit]) -> None:
     """
-    Qmod core-library function
+    [Qmod core-library function]
 
     Does nothing.
 
@@ -711,9 +711,9 @@ def CCX(control: QArray[QBit, Literal[2]], target: QBit) -> None:
     """
     [Qmod core-library function]
 
-    Toffoli (CCX) gate - applies the Pauli-X gate to the target qubit, conditioned on the control qubits.
+    Applies the Pauli-X gate to the target qubit, conditioned on the two control qubits (Toffoli).
 
-    The Toffoli gate applies a Pauli-X gate to the target qubit only if both control qubits are in the state $|1>$. This operation is represented by the following matrix:
+    This operation is represented by the following matrix:
 
     $$
     CCX = \\begin{bmatrix}

classiq/qmod/builtins/functions/state_preparation.py

@@ -10,7 +10,7 @@ def allocate(
     num_qubits: CInt, out: Output[QArray[QBit, Literal["num_qubits"]]]
 ) -> None:
     """
-    Qmod core-library function.
+    [Qmod core-library function]
 
     Allocates the specified number of qubits to a given quantum variable and initializes
     them in the zero state:
@@ -41,8 +41,7 @@ def allocate_num(
     ],
 ) -> None:
     """
-
-    Qmod Classiq-library function
+    [Qmod Classiq-library function]
 
     Initializes a quantum number with the given number of qubits, sign, and fractional digits.
 
@@ -60,7 +59,7 @@ def allocate_num(
 @qfunc(external=True)
 def free(in_: Input[QArray[QBit]]) -> None:
     """
-    Qmod core-library function.
+    [Qmod core-library function]
 
     Releases the qubits allocated to a quantum variable, allowing them to be reused.
 
@@ -80,7 +79,7 @@ def prepare_state(
     out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
 ) -> None:
     """
-    Qmod core-library function.
+    [Qmod core-library function]
 
     Initializes a quantum variable in a state corresponding to a given probability distribution:
 
@@ -110,7 +109,7 @@ def prepare_amplitudes(
     out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
 ) -> None:
     """
-    Qmod core-library function.
+    [Qmod core-library function]
 
     Initializes a quantum variable in a state corresponding to the given amplitudes:
 
@@ -140,9 +139,10 @@ def inplace_prepare_state(
     target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
 ) -> None:
     """
-    Qmod core-library function.
+    [Qmod core-library function]
 
-    Similar to `prepare_state`, but without the restriction that the quantum variable must be uninitialized.
+    Transforms a given quantum variable in the state |0> to the state per the specified probability distribution
+    (similar to `prepare_state` but preformed on an initialized variable).
 
     Args:
         probabilities: The probability distribution corresponding to the quantum variable state. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
@@ -162,9 +162,10 @@ def inplace_prepare_amplitudes(
     target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
 ) -> None:
     """
-    Qmod core-library function.
+    [Qmod core-library function]
 
-    Similar to `prepare_amplitudes`, but without the restriction that the quantum variable must be uninitialized.
+    Transforms a given quantum variable in the state |0> to the state per the specified amplitudes
+    (similar to `prepare_amplitudes` but preformed on an initialized variable).
 
     Args:
         amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
@@ -187,7 +188,7 @@ def _prepare_uniform_trimmed_state_step(
 @qfunc(external=True)
 def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Initializes a quantum variable in a uniform superposition of the first `m` computational basis states:
 
@@ -212,7 +213,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
 @qfunc(external=True)
 def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Initializes a quantum variable in a uniform superposition of the specified interval in the computational basis states:
 
@@ -237,7 +238,7 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
 @qfunc(external=True)
 def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
     """
-    Qmod core-library function.
+    [Qmod Classiq-library function]
 
     Initializes a quantum variable in a Greenberger-Horne-Zeilinger (GHZ) state. i.e., a balanced superposition of all ones and all zeros, on an arbitrary number of qubits..
 
@@ -257,7 +258,7 @@ def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
 def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
     """
 
-    Qmod Classiq-library function
+    [Qmod Classiq-library function]
 
     Prepares a quantum state with exponentially decreasing amplitudes. The state is prepared in the computational basis, with the amplitudes of the states decreasing exponentially with the index of the state:
 
@@ -277,7 +278,7 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
 @qfunc(external=True)
 def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) -> None:
     """
-    Qmod core-library function.
+    [Qmod Classiq-library function]
 
     Initializes a quantum array of size 2 in one of the four Bell states.
 
@@ -323,7 +324,7 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 @qfunc(external=True)
 def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Transitions a quantum variable in the zero state $|0\\rangle$ into the computational basis state $|\\text{value}\\rangle$.
     In the general case, the function performs a bitwise-XOR, i.e. transitions the state $|\\psi\\rangle$ into $|\\psi \\oplus \\text{value}\\rangle$.
@@ -341,7 +342,7 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
 @qfunc(external=True)
 def prepare_int(value: CInt, out: Output[QNum]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Initializes a quantum variable to the computational basis state $|\\text{value}\\rangle$.
     The number of allocated qubits is automatically computed from the value, and is the minimal number required for representation in the computational basis.

classiq/qmod/builtins/functions/swap_test.py

@@ -5,10 +5,10 @@ from classiq.qmod.qmod_variable import Output, QArray, QBit
 @qfunc(external=True)
 def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
-    A quantum algorithm primitive that tests the overlap (in terms of fidelity) of two quantum states.
-    The fidelity of `state1` and `state2` is calculated from the probability of measuring the `test` qubit in the state 0 as follows:
+    Tests the overlap (in terms of fidelity) of two quantum states.
+    The fidelity of `state1` and `state2` is calculated from the probability of measuring `test` qubit in the state 0 as follows:
 
     $$
         |\\langle state1 | state2 \\rangle |^2 = 2*Prob(test=0)-1

{classiq-0.46.0.dist-info → classiq-0.46.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.46.0
+Version: 0.46.1
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary

{classiq-0.46.0.dist-info → classiq-0.46.1.dist-info}/RECORD

@@ -93,7 +93,7 @@ classiq/execution/jobs.py,sha256=JX4f5LFf4Orl_-SlcIwX-Jy7gKwnQAT_WwcQtpoTrW8,506
 classiq/execution/qnn.py,sha256=qsOA2mD8Ne_4VwvyGPfuHVDTzyxVnDHwE2gfoaOMsf8,2339
 classiq/executor.py,sha256=jKD5O_tJpL2NMTC_N0NEuPJEmKZIaqsTpQrgZ88sleg,2594
 classiq/interface/__init__.py,sha256=cg7hD_XVu1_jJ1fgwmT0rMIoZHopNVeB8xtlmMx-E_A,83
-classiq/interface/_version.py,sha256=YkIsLmribFX92Prhz8f0kuSR84PEy5QjQ-UUTtbR1Jc,197
+classiq/interface/_version.py,sha256=P8akUoU2JbjwdaYBo9AmLsJv4Xj0QMcuBfoYbHhwWJU,197
 classiq/interface/analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/analyzer/analysis_params.py,sha256=043hfS-I3Ec6tkcniKMQQUiRyEC7zlNhntTBpZQB8hw,3725
 classiq/interface/analyzer/cytoscape_graph.py,sha256=_2GviubgrDMAbF57PTDMhS9W0mTCLYWdyu0HndDPh54,2116
@@ -435,26 +435,26 @@ classiq/qmod/builtins/classical_execution_primitives.py,sha256=VlA4Wam35v2wMppZ5
 classiq/qmod/builtins/classical_functions.py,sha256=sOMYm_vU24mAGgR63qmJ5eMTgpacXCRIhNEXa6pl0Q4,1914
 classiq/qmod/builtins/enums.py,sha256=JzfANJT4Z1Gy8io4JjCnez4t97mxBjT1K-ij2Cli9kQ,3417
 classiq/qmod/builtins/functions/__init__.py,sha256=xpAaTC4wrHh0WmykWsvf_5IdPPxJxWDoHror_rq20kg,5352
-classiq/qmod/builtins/functions/amplitude_estimation.py,sha256=cBsF1IjrZRvWO1S28Mysh9L_DX48_loezjfTj_vcohU,1602
-classiq/qmod/builtins/functions/arithmetic.py,sha256=SSVImJg3sxcCizSlw6hF_UA0h_RcIT7cDrnvGEsyBJI,1719
+classiq/qmod/builtins/functions/amplitude_estimation.py,sha256=nO2HlzVgZw3621YUr1-4AflAWDm5xTBaTSjQ6o9yjKA,1562
+classiq/qmod/builtins/functions/arithmetic.py,sha256=DtjQor_ZuJPBJzFrgMJUN2frmJatvnNgpJSYP8-1tHM,1722
 classiq/qmod/builtins/functions/benchmarking.py,sha256=TYY1VRd5DHl-mKTKeW5wF1txZgFsb3yPXM_rdgoLWCo,250
 classiq/qmod/builtins/functions/chemistry.py,sha256=Wl8ktlY0U_M-mDXozcCht44_flZtwImIiGeAMr7hs4s,2126
-classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py,sha256=LH9PrxSiq5nlKwSIltZh3FOE4OXGnviSxUJopOW6Ms0,2799
-classiq/qmod/builtins/functions/exponentiation.py,sha256=-BpWGMZMyxbQnRT2Z7_J17jz5mbHdJR8tWjj_wvPi_Q,4559
+classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py,sha256=miT9CDKueQtA-T3NBg2sZTG5zoxxgiZ7g6GV2krTj-I,2807
+classiq/qmod/builtins/functions/exponentiation.py,sha256=poR2fTvaBtVQiNvQJ7sLNzm7akp7GGuMW3vsPee3TfE,4477
 classiq/qmod/builtins/functions/finance.py,sha256=zo-UZ_R_8UMw0FCLJQsw_CEMAKV4derY00tnbAPC2yw,861
-classiq/qmod/builtins/functions/grover.py,sha256=NuXS4V_fRFwAEoAyFglIz6z0Ids3yfBaUpy6aiBUqVA,5064
-classiq/qmod/builtins/functions/hea.py,sha256=hq_fjR3OaV-lNsgGku856L9P9OVOTErmAJyIfDTzAw0,2504
-classiq/qmod/builtins/functions/linear_pauli_rotation.py,sha256=HFEkpplkervyNThZo0Sr3dOpSzlxvY4NZsjs2pEKs1A,2046
-classiq/qmod/builtins/functions/modular_exponentiation.py,sha256=duZgRuMigkGyxdl5nPULwyo7O2us0tjFazwmLjtcGvo,4159
+classiq/qmod/builtins/functions/grover.py,sha256=xWPUDsSdtXnmzfZTsf_pBynHb8dfiXVs-6X3-iicj_Y,4980
+classiq/qmod/builtins/functions/hea.py,sha256=oyzBFt2FqKgBA5zBiWa9VaoP_y3g6q1peyIXcYKw6C4,2505
+classiq/qmod/builtins/functions/linear_pauli_rotation.py,sha256=Vs9E7Cn_BpCI4Ed531MABDJXB9Od8ZBZB0gWm6nEIzM,2058
+classiq/qmod/builtins/functions/modular_exponentiation.py,sha256=1cWE2eKc6zyCytzs1GzRYgQzEy_huIjQm8_RjY3Sqjo,4217
 classiq/qmod/builtins/functions/operators.py,sha256=EyjsDy4aOrBncFcf8r9ioEB2vigOpqvYwi4n1aMj7qI,398
-classiq/qmod/builtins/functions/qaoa_penalty.py,sha256=gRQEyWNUthuIRjBKwmrclWfH6nlWo2k520_jrbJfU4A,4245
-classiq/qmod/builtins/functions/qft.py,sha256=E_7kGV4kSlnEQjvuCHVFESU6fWJUi8CmpWVx03TGO9E,686
-classiq/qmod/builtins/functions/qpe.py,sha256=cp34N9i2b-T-7NNAnwWMG7KTnJb44kv95NXoCzlFT_A,1982
+classiq/qmod/builtins/functions/qaoa_penalty.py,sha256=AIPhMLNIMrUKSGcyxf5DkcpQmpClW62PCt_auIN40ac,4260
+classiq/qmod/builtins/functions/qft.py,sha256=N8cyfZ6foBcG4pN2ui8Z3te048qrVCcqjjpu2dIhCxE,687
+classiq/qmod/builtins/functions/qpe.py,sha256=zemPR03SszqGLbWlwHI8ZrdRuTqcgnXdHGRSy3-4PJ8,1984
 classiq/qmod/builtins/functions/qsvm.py,sha256=j5UbMWfl2UNtBewjSWgXq-fvHuAznpINw_b5-_XEKdU,586
-classiq/qmod/builtins/functions/qsvt.py,sha256=m9rHXHcdpVgAnAPSjjtShTSdqMNiaN6680C8iMNswvs,6596
-classiq/qmod/builtins/functions/standard_gates.py,sha256=dVqS8p6KF4Nx6ng62iDpn-bddp8eYF2iymbmUCadghk,23458
-classiq/qmod/builtins/functions/state_preparation.py,sha256=GDkkqbQbMeDWK2Zt-mxxvx9wSuVCOv0rRXECug02n34,15387
-classiq/qmod/builtins/functions/swap_test.py,sha256=WK3aK6H4ph36Dxz5H3wIfzrLzj0A7fq1J0QkTtfA8Q8,995
+classiq/qmod/builtins/functions/qsvt.py,sha256=aSePhlqVql8IHfmhsGY6vMucJi3htoUNKvLJYOQvIGM,6635
+classiq/qmod/builtins/functions/standard_gates.py,sha256=fsljKq_Y8aI_JYN4Gxf23jPB8FCVrDRmt3Aqj5Jb1DM,22349
+classiq/qmod/builtins/functions/state_preparation.py,sha256=BJcd9ZV4CHHzXTFq4NKw3KrbR2xFO5zt_Z_9jbg7E9A,15552
+classiq/qmod/builtins/functions/swap_test.py,sha256=DGWCkJNvunUGR5Q_eYxKOMO21elfD8kQkiNlQpcerOU,957
 classiq/qmod/builtins/operations.py,sha256=-2ktlfP4xlPXjby29KDQp56achnSsrpBEDOxJfkVdno,13878
 classiq/qmod/builtins/structs.py,sha256=pdjNKFAhxLNzVdz4bhONO4PwvfI_W7Z7Skjgqt47mxw,2913
 classiq/qmod/cfunc.py,sha256=quwJdgYRgqI2C13SRrRunLi-Kuf7nCAk2-O2B46QtoY,1093
@@ -495,6 +495,6 @@ classiq/qmod/utilities.py,sha256=z_VnIRmOYTWjJp2UlOcWK0rQRtMqysmP_Gr6WYY_nak,273
 classiq/qmod/write_qmod.py,sha256=SO7hdBdO31lTzyeaJ-Htyma-aJmrbBNtABNEB2llI4Q,1818
 classiq/show.py,sha256=GyxceOzWrnVC9KvsLdHJbxycD9WkcQkkhOSw45P6CPo,1428
 classiq/synthesis.py,sha256=wBk5iFCH2Bw9AvVPzGvTI96zjQXw6QpKRN9VZxc_Xl0,3350
-classiq-0.46.0.dist-info/METADATA,sha256=F2bvtS3922eZe4VGe-z6Lw0vo7bhzEvK_xAMBiEUTiM,3087
-classiq-0.46.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-classiq-0.46.0.dist-info/RECORD,,
+classiq-0.46.1.dist-info/METADATA,sha256=Gl4sPXRCcoQGGw1u9i1NwsaGX2vBWT2H5rFhd0uSFuw,3087
+classiq-0.46.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+classiq-0.46.1.dist-info/RECORD,,