Pauli 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	applyPauliGadget (Qureg qureg, PauliStr str, qreal angle)
void	multiplyPauliGadget (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!

Definition at line 1435 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!

Definition at line 1442 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!

See also

• applyPauliGadget()
• applyMultiStateControlledCompMatr1()

Definition at line 1449 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 ctrlVec = util_getVector(controls, numControls);
    auto stateVec = util_getVector(states, numControls); // empty if states==nullptr
    localiser_statevec_anyCtrlPauliGadget(qureg, ctrlVec, stateVec, str, phase);
 
    if (!qureg.isDensityMatrix)
        return;
 
    // conj(e^iXZ) = e^(-iXZ), but conj(Y)=-Y, so odd-Y undoes phase negation
    phase *= paulis_hasOddNumY(str) ? 1 : -1;
    ctrlVec = util_getBraQubits(ctrlVec, qureg);
    str = paulis_getShiftedPauliStr(str, qureg.numQubits);
    localiser_statevec_anyCtrlPauliGadget(qureg, ctrlVec, stateVec, str, phase);
}

Referenced by applyControlledPauliGadget(), applyMultiControlledPauliGadget(), applyMultiStateControlledPauliGadget(), applyMultiStateControlledRotateX(), applyMultiStateControlledRotateY(), applyMultiStateControlledRotateZ(), and applyPauliGadget().

applyPauliGadget()

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

Note

Documentation for this function or struct is under construction!

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 superposed.

  // prepare |temp> = str |qureg>
  Qureg temp = createCloneQureg(qureg);
  applyPauliStr(temp, str);
   
  // set |qureg> = cos(theta/2) |qureg> - i sin(theta/2) str |qureg>
  setQuregToSuperposition(cos(theta/2), qureg, - 1.0i * sin(theta/2), temp, 0, temp);

• 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);
  setQuregToSuperposition(factor, qureg, 0,qureg,0,qureg);

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);

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

Definition at line 1428 of file operations.cpp.

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

multiplyPauliGadget()

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

Note

Documentation for this function or struct is under construction!

See also

• multiplyCompMatr1()
• applyPauliGadget()

Definition at line 1420 of file operations.cpp.

                                                                 {
    validate_quregFields(qureg, __func__);
    validate_pauliStrTargets(qureg, str, __func__);
 
    qreal phase = util_getPhaseFromGateAngle(angle);
    localiser_statevec_anyCtrlPauliGadget(qureg, {}, {}, str, phase);
}