PauliStrSum

Functions for applying, exponentiating or Trotterising a weigthed sum of Pauli tensors. More...

Functions
void	applyTrotterizedPauliStrSumGadget (Qureg qureg, PauliStrSum sum, qreal angle, int order, int reps)
void	multiplyPauliStrSum (Qureg qureg, PauliStrSum sum, Qureg workspace)

Detailed Description

Functions for applying, exponentiating or Trotterising a weigthed sum of Pauli tensors.

Function Documentation

applyTrotterizedPauliStrSumGadget()

void applyTrotterizedPauliStrSumGadget	(	Qureg	qureg,
		PauliStrSum	sum,
		qreal	angle,
		int	order,
		int	reps )

Note

Documentation for this function or struct is under construction!

Warning

This function has not yet been unit tested and may contain bugs. Please use with caution!

Formulae

Let \( \hat{H} = \) sum and \( \theta = \) angle. This function approximates the action of

\[ \exp \left(\iu \, \theta \, \hat{H} \right) \]

via a Trotter-Suzuki decomposition of the specified order and number of repetitions (reps).

To be precise, let \( r = \) reps and assume sum is composed of \( T \)-many terms of the form

\[ \hat{H} = \sum\limits_j^T c_j \, \hat{\sigma}_j \]

where \( c_j \) is the (necessarily real) coefficient of the \( j \)-th PauliStr \( \hat{\sigma}_j \).

• When order=1, this function performs first-order Trotterisation, whereby

  \[ \exp(\iu \, \theta \, \hat{H} ) \approx \prod\limits^{r} \prod\limits_{j=1}^{T} \exp \left( \iu \, \frac{\theta \, c_j}{r} \, \hat\sigma_j \right). \]

• When order=2, this function performs the lowest order "symmetrized" Suzuki decomposition, whereby

  \[ \exp(\iu \, \theta \, \hat{H} ) \approx \prod\limits^{r} \left[ \prod\limits_{j=1}^{T} \exp \left( \iu \frac{\theta \, c_j}{2 \, r} \hat\sigma_j \right) \prod\limits_{j=T}^{1} \exp \left( \iu \frac{\theta \, c_j}{2 \, r} \hat\sigma_j \right) \right]. \]

• Greater, even values of order (denoted by symbol \( n \)) invoke higher-order symmetrized decompositions \( S[\theta,n,r] \). Letting \( p = \left( 4 - 4^{1/(n-1)} \right)^{-1} \), these satisfy

  \begin{align*} S[\theta, n, 1] &= \left( \prod\limits^2 S[p \, \theta, n-2, 1] \right) S[ (1-4p)\,\theta, n-2, 1] \left( \prod\limits^2 S[p \, \theta, n-2, 1] \right), \\ S[\theta, n, r] &= \prod\limits^{r} S\left[\frac{\theta}{r}, n, 1\right]. \end{align*}

‍These formulations are taken from 'Finding Exponential Product Formulas of Higher Orders', Naomichi Hatano and Masuo Suzuki (2005) (arXiv).

Definition at line 1169 of file operations.cpp.

                                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_pauliStrSumFields(sum, __func__);
    validate_pauliStrSumTargets(sum, qureg, __func__);
    validate_pauliStrSumIsHermitian(sum, __func__);
    validate_trotterParams(qureg, order, reps, __func__);
 
    // exp(i angle sum) = identity when angle=0
    if (angle == 0)
        return;
 
    // record validation state then disable to avoid repeated
    // re-validations in each invoked applyPauliGadget() below
    bool wasValidationEnabled = validateconfig_isEnabled();
    validateconfig_disable();
 
    // perform sequence of applyPauliGadget()
    for (int r=0; r<reps; r++)
        applyHigherOrderTrotter(qureg, sum, angle/reps, order);
 
    // potentially restore validation
    if (wasValidationEnabled)
        validateconfig_enable();
 
    /// @todo
    /// the accuracy of Trotterisation is greatly improved by randomisation
    /// or (even sub-optimal) grouping into commuting terms. Should we 
    /// implement these above or into another function?
}

multiplyPauliStrSum()

void multiplyPauliStrSum	(	Qureg	qureg,
		PauliStrSum	sum,
		Qureg	workspace )

Note

Documentation for this function or struct is under construction!

Attention

This function's input validation has not yet been unit tested, so erroneous usage may produce unexpected output. Please use with caution!

See also

multiplyCompMatr1()

Definition at line 1112 of file operations.cpp.

                                                                        {
    validate_quregFields(qureg, __func__);
    validate_quregFields(workspace, __func__);
    validate_quregCanBeWorkspace(qureg, workspace, __func__);
    validate_pauliStrSumFields(sum, __func__);
    validate_pauliStrSumTargets(sum, qureg, __func__);
 
    // clone qureg to workspace, set qureg to blank
    localiser_statevec_setQuregToSuperposition(0, workspace, 1, qureg, 0, qureg);
    localiser_statevec_initUniformState(qureg, 0);
 
    // apply each term in-turn, mixing into output qureg, then undo using idempotency
    for (qindex i=0; i<sum.numTerms; i++) {
        localiser_statevec_anyCtrlPauliTensor(workspace, {}, {}, sum.strings[i]);
        localiser_statevec_setQuregToSuperposition(1, qureg, sum.coeffs[i], workspace, 0, workspace);
        localiser_statevec_anyCtrlPauliTensor(workspace, {}, {}, sum.strings[i]);
    }
 
    // workspace -> qureg, and qureg -> sum * qureg
}

Referenced by TEST_CASE().