PauliStr gadgets

Functions for applying many-qubit rotations around arbitrary PauliStr. More...

Functions
void	applyControlledPauliGadget (Qureg qureg, int control, PauliStr str, qreal angle)
void	applyMultiControlledPauliGadget (Qureg qureg, int *controls, int numControls, PauliStr str, qreal angle)
void	applyMultiStateControlledPauliGadget (Qureg qureg, int *controls, int *states, int numControls, PauliStr str, qreal angle)
void	applyNonUnitaryPauliGadget (Qureg qureg, PauliStr str, qcomp angle)
void	applyPauliGadget (Qureg qureg, PauliStr str, qreal angle)

Detailed Description

Functions for applying many-qubit rotations around arbitrary PauliStr.

Function Documentation

applyControlledPauliGadget()

void applyControlledPauliGadget	(	Qureg	qureg,
		int	control,
		PauliStr	str,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Applies a singly-controlled many-qubit rotation upon qureg, generated by tensor product of Pauli operators str.

‍- See applyPauliGadget() for information about the base operation, angle, and str.

• See applyControlledCompMatr1() for information about control.

Author

Tyson Jones

Definition at line 1265 of file operations.cpp.

                                                                                     {
    validate_quregFields(qureg, __func__);
    validate_controlAndPauliStrTargets(qureg, control, str, __func__);
    
    applyMultiStateControlledPauliGadget(qureg, &control, nullptr, 1, str, angle);
}

applyMultiControlledPauliGadget()

void applyMultiControlledPauliGadget	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		PauliStr	str,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Applies a multiply-controlled many-qubit rotation upon qureg, generated by tensor product of Pauli operators str.

‍- See applyPauliGadget() for information about the base operation, angle, and str.

• See applyMultiControlledCompMatr1() for information about controls.

Author

Tyson Jones

Definition at line 1272 of file operations.cpp.

                                                                                                             {
    validate_quregFields(qureg, __func__);
    validate_controlsAndPauliStrTargets(qureg, controls, numControls, str, __func__);
    
    applyMultiStateControlledPauliGadget(qureg, controls, nullptr, numControls, str, angle);
}

Referenced by applyMultiControlledPauliGadget().

applyMultiStateControlledPauliGadget()

void applyMultiStateControlledPauliGadget	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		PauliStr	str,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Applies an arbitrarily-controlled many-qubit rotation upon qureg, generated by tensor product of Pauli operators str, and conditioned upon controls being in the corresponding states.

‍- See applyPauliGadget() for information about the base operation, angle, and str.

• See applyMultiStateControlledCompMatr1() for information about controls and states.

Author

Tyson Jones

Definition at line 1279 of file operations.cpp.

                                                                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlsAndPauliStrTargets(qureg, controls, numControls, str, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // a non-controlled str=I effects a global phase change (of -angle/2) which does not 
    // at all change a density matrix; the subsequent dagger operation would undo it,
    // which we avoid to preserve numerical accuracy
    if (paulis_isIdentity(str) && numControls == 0 && qureg.isDensityMatrix)
        return;
 
    // when numControls >= 1, all amps satisfying the control condition undergo a phase 
    // change of -angle/2, as if all non-control-qubits were targeted by exp(-angle/2)I,
    // which is sufficiently efficient using the existing gadget backend function
 
    qreal phase = util_getPhaseFromGateAngle(angle);
    auto ctrlList = lists_getList64(controls, numControls);
    auto stateList = util_getList64OrAllOnes(states, numControls);
    localiser_statevec_anyCtrlPauliGadget(qureg, ctrlList, stateList, str, phase);
 
    if (!qureg.isDensityMatrix)
        return;
 
    // conj(e^(i a P)) = e^(-i s a P)
    phase *= - paulis_getSignOfPauliStrConj(str);
    ctrlList = util_getBraQubits(ctrlList, qureg);
    str = paulis_getShiftedPauliStr(str, qureg.numQubits);
    localiser_statevec_anyCtrlPauliGadget(qureg, ctrlList, stateList, str, phase);
}

Referenced by applyControlledPauliGadget(), applyMultiControlledPauliGadget(), applyMultiStateControlledPauliGadget(), and applyPauliGadget().

applyNonUnitaryPauliGadget()

void applyNonUnitaryPauliGadget	(	Qureg	qureg,
		PauliStr	str,
		qcomp	angle )

Note

Documentation for this function or struct is under construction!

This function generalises applyPauliGadget() to accept a complex angle.

Definition at line 1248 of file operations.cpp.

                                                                        {
    validate_quregFields(qureg, __func__);
    validate_pauliStrTargets(qureg, str, __func__);
 
    qcomp phase = util_getPhaseFromGateAngle(angle);
    auto none = lists_getEmptyList64();
    localiser_statevec_anyCtrlPauliGadget(qureg, none, none, str, phase);
 
    if (!qureg.isDensityMatrix)
        return;
 
    // conj(e^i(a)P) = e^(-i s conj(a) P)
    phase = - std::conj(phase) * paulis_getSignOfPauliStrConj(str);
    str = paulis_getShiftedPauliStr(str, qureg.numQubits);
    localiser_statevec_anyCtrlPauliGadget(qureg, none, none, str, phase);
}

Referenced by TEST_CASE().

applyPauliGadget()

void applyPauliGadget	(	Qureg	qureg,
		PauliStr	str,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Applies a many-qubit rotation upon qureg, generated by tensor product of Pauli operators str.

Formulae

Let \( \hat{\sigma} = \) str and \( \theta = \) angle.

This function effects unitary

\[ R_{\hat{\sigma}}(\theta) = \exp \left( - \iu \, \frac{\theta}{2} \, \hat{\sigma} \right), \]

which affects only the qubits for which \( \hat{\sigma} \) is not the identity Pauli. As such, this effects a multi-qubit rotation around an arbitrary Pauli string.

Equivalences

• Because \( R_{\hat{\sigma}}(\theta) \) satisfies

  \[ R_{\hat{\sigma}}(\theta) \equiv \cos\left( \frac{\theta}{2} \right) \, \id - \iu \sin\left( \frac{\theta}{2} \right) \, \hat{\sigma}, \]

  this function is equivalent to (but much faster than) effecting \( \hat{\sigma} \) upon a clone which is subsequently combined.

  // prepare |temp> = str |qureg>
  Qureg temp = createCloneQureg(qureg);
  applyPauliStr(temp, str);
   
  // set |qureg> = cos(theta/2) |qureg> - i sin(theta/2) str |qureg>
  qcomp coeffs[] = {cos(theta/2), -1i * sin(theta/2)};
  Qureg quregs[] = {qureg, temp};
  setQuregToWeightedSum(qureg, coeffs, quregs, 2);

• When str contains only \( \hat{Z} \) or \( \id \) Paulis, this function will automatically invoke applyPhaseGadget() which leverages an optimised implementation.
• When str contains only \( \id \) Paulis, this function merely effects a change of global phase upon statevectors of \( -\theta/2 \), leaving density matrices unchanged.

  qcomp factor = cexp(- theta / 2 * 1.i);
  setQuregToWeightedSum(qureg, &factor, &qureg, 1);

• Passing angle=0 is equivalent to effecting the identity, leaving the state unchanged.

Example

Qureg qureg = createQureg(10);
qreal theta = 3.14;
 
// verbosely
int numPaulis = 4;
char* paulis = "XYIZ";
int targets[] = {0,1,5,7};
PauliStr str = getPauliStr(paulis, targets, numPaulis);
applyPauliGadget(qureg, str, angle);
 
// concisely
applyPauliGadget(qureg, getInlinePauliStr("XYZ",{0,1,7}), theta);

See also

• applyNonUnitaryPauliGadget()

Definition at line 1241 of file operations.cpp.

                                                              {
    validate_quregFields(qureg, __func__);
    validate_pauliStrTargets(qureg, str, __func__);
    
    applyMultiStateControlledPauliGadget(qureg, nullptr, nullptr, 0, str, angle);
}