Rotations

Functions for applying one-qubit rotations around Pauli and arbitrary axis. More...

Functions
void	applyControlledRotateAroundAxis (Qureg qureg, int ctrl, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyControlledRotateX (Qureg qureg, int control, int target, qreal angle)
void	applyControlledRotateY (Qureg qureg, int control, int target, qreal angle)
void	applyControlledRotateZ (Qureg qureg, int control, int target, qreal angle)
void	applyMultiControlledRotateAroundAxis (Qureg qureg, int *ctrls, int numCtrls, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyMultiControlledRotateX (Qureg qureg, int *controls, int numControls, int target, qreal angle)
void	applyMultiControlledRotateY (Qureg qureg, int *controls, int numControls, int target, qreal angle)
void	applyMultiControlledRotateZ (Qureg qureg, int *controls, int numControls, int target, qreal angle)
void	applyMultiStateControlledRotateAroundAxis (Qureg qureg, int *ctrls, int *states, int numCtrls, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyMultiStateControlledRotateX (Qureg qureg, int *controls, int *states, int numControls, int target, qreal angle)
void	applyMultiStateControlledRotateY (Qureg qureg, int *controls, int *states, int numControls, int target, qreal angle)
void	applyMultiStateControlledRotateZ (Qureg qureg, int *controls, int *states, int numControls, int target, qreal angle)
void	applyRotateAroundAxis (Qureg qureg, int target, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyRotateX (Qureg qureg, int target, qreal angle)
void	applyRotateY (Qureg qureg, int target, qreal angle)
void	applyRotateZ (Qureg qureg, int target, qreal angle)

Detailed Description

Functions for applying one-qubit rotations around Pauli and arbitrary axis.

Function Documentation

applyControlledRotateAroundAxis()

void applyControlledRotateAroundAxis	(	Qureg	qureg,
		int	ctrl,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

Note

Documentation for this function or struct is under construction!

Definition at line 1349 of file operations.cpp.

                                                                                                                          {
    validate_quregFields(qureg, __func__);
    validate_controlAndTarget(qureg, ctrl, targ, __func__);
    validate_rotationAxisNotZeroVector(axisX, axisY, axisZ, __func__);
 
    applyMultiStateControlledRotateAroundAxis(qureg, &ctrl, nullptr, 1, targ, angle, axisX, axisY, axisZ);
}

applyControlledRotateX()

void applyControlledRotateX	(	Qureg	qureg,
		int	control,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1223 of file operations.cpp.

                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlAndTarget(qureg, control, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateX(qureg, &control, nullptr, 1, target, angle);
}

applyControlledRotateY()

void applyControlledRotateY	(	Qureg	qureg,
		int	control,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1231 of file operations.cpp.

                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlAndTarget(qureg, control, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateY(qureg, &control, nullptr, 1, target, angle);
}

applyControlledRotateZ()

void applyControlledRotateZ	(	Qureg	qureg,
		int	control,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1239 of file operations.cpp.

                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlAndTarget(qureg, control, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateZ(qureg, &control, nullptr, 1, target, angle);
}

applyMultiControlledRotateAroundAxis()

void applyMultiControlledRotateAroundAxis	(	Qureg	qureg,
		int *	ctrls,
		int	numCtrls,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

Note

Documentation for this function or struct is under construction!

Definition at line 1357 of file operations.cpp.

                                                                                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, ctrls, numCtrls, targ, __func__);
    validate_rotationAxisNotZeroVector(axisX, axisY, axisZ, __func__);
 
    applyMultiStateControlledRotateAroundAxis(qureg, ctrls, nullptr, numCtrls, targ, angle, axisX, axisY, axisZ);
}

Referenced by applyMultiControlledRotateAroundAxis().

applyMultiControlledRotateX()

void applyMultiControlledRotateX	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1247 of file operations.cpp.

                                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateX(qureg, controls, nullptr, numControls, target, angle);
}

Referenced by applyMultiControlledRotateX().

applyMultiControlledRotateY()

void applyMultiControlledRotateY	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1255 of file operations.cpp.

                                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateY(qureg, controls, nullptr, numControls, target, angle);
}

Referenced by applyMultiControlledRotateY().

applyMultiControlledRotateZ()

void applyMultiControlledRotateZ	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1263 of file operations.cpp.

                                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateZ(qureg, controls, nullptr, numControls, target, angle);
}

Referenced by applyMultiControlledRotateZ().

applyMultiStateControlledRotateAroundAxis()

void applyMultiStateControlledRotateAroundAxis	(	Qureg	qureg,
		int *	ctrls,
		int *	states,
		int	numCtrls,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

Note

Documentation for this function or struct is under construction!

See also

• applyRotateAroundAxis()
• applyMultiStateControlledCompMatr1()

Definition at line 1365 of file operations.cpp.

                                                                                                                                                                 {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, ctrls, numCtrls, targ, __func__);
    validate_controlStates(states, numCtrls, __func__); // permits states==nullptr
    validate_rotationAxisNotZeroVector(axisX, axisY, axisZ, __func__);
 
    // defer division of vector norm to improve numerical accuracy
    qreal norm = std::sqrt(std::pow(axisX,2) + std::pow(axisY,2) + std::pow(axisZ,2)); // != 0
 
    // treat as generic 1-qubit matrix
    qreal c = std::cos(angle/2);
    qreal s = std::sin(angle/2);
    qcomp u11 = c - (s * axisZ * 1_i) / norm;
    qcomp u12 =   - (s * (axisY + axisX * 1_i)) / norm;
    qcomp u21 =     (s * (axisY - axisX * 1_i)) / norm;
    qcomp u22 = c + (s * axisZ * 1_i) / norm;
    auto matr = getCompMatr1({{u11,u12},{u21,u22}});
 
    // harmlessly re-validates, and checks unitarity of matr
    applyMultiStateControlledCompMatr1(qureg, ctrls, states, numCtrls, targ, matr);
}

Referenced by applyControlledRotateAroundAxis(), applyMultiControlledRotateAroundAxis(), applyMultiStateControlledRotateAroundAxis(), and applyRotateAroundAxis().

applyMultiStateControlledRotateX()

void applyMultiStateControlledRotateX	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

See also

• applyRotateX()
• applyMultiStateControlledCompMatr1()

Definition at line 1271 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // harmlessly re-validates
    applyMultiStateControlledPauliGadget(qureg, controls, states, numControls, getPauliStr("X", {target}), angle);
}

Referenced by applyControlledRotateX(), applyMultiControlledRotateX(), applyMultiStateControlledRotateX(), and applyRotateX().

applyMultiStateControlledRotateY()

void applyMultiStateControlledRotateY	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

See also

• applyRotateY()
• applyMultiStateControlledCompMatr1()

Definition at line 1280 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // harmlessly re-validates
    applyMultiStateControlledPauliGadget(qureg, controls, states, numControls, getPauliStr("Y", {target}), angle);
}

Referenced by applyControlledRotateY(), applyMultiControlledRotateY(), applyMultiStateControlledRotateY(), and applyRotateY().

applyMultiStateControlledRotateZ()

void applyMultiStateControlledRotateZ	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

See also

• applyRotateZ()
• applyMultiStateControlledCompMatr1()

Definition at line 1289 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // harmlessly re-validates
    applyMultiStateControlledPauliGadget(qureg, controls, states, numControls, getPauliStr("Z", {target}), angle);
}

Referenced by applyControlledRotateZ(), applyMultiControlledRotateZ(), applyMultiStateControlledRotateZ(), and applyRotateZ().

applyRotateAroundAxis()

void applyRotateAroundAxis	(	Qureg	qureg,
		int	target,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

Note

Documentation for this function or struct is under construction!

Formulae

Let \( \theta = \) angle and \( \vec{n} = ( \) axisX, axisY, axisZ \( ) \), with corresponding unit vector \( \bar{n} \). Further, let \( \vec{\sigma} = (\hat{\sigma}_x, \hat{\sigma}_y, \hat{\sigma}_z) \) denote a vector of the Pauli matrices.

This function effects unitary

\[ \hat{R}_{\bar{n}}(\theta) = \exp \left( - \iu \frac{\theta}{2} \bar{n} \cdot \vec{\sigma} \right) \]

upon the target qubit. Explicitly,

\[ \hat{R}_{\bar{n}}(\theta) \equiv \begin{pmatrix} \cos\left( \frac{\theta}{2} \right) - \iu \, \bar{n}_z \sin\left( \frac{\theta}{2} \right) & - \, (\bar{n}_y + \bar{n}_x \, \iu ) \sin\left( \frac{\theta}{2} \right) \\ (\bar{n}_y - \bar{n}_x \, \iu ) \sin\left( \frac{\theta}{2} \right) & \cos\left( \frac{\theta}{2} \right) + \iu \, \bar{n}_z \sin\left( \frac{\theta}{2} \right) \end{pmatrix} \]

where

\[ \bar{n}_i = \frac{\vec{n}_i}{\| \vec{n} \|_2} = \frac{\vec{n}_i}{ \sqrt{ {\vec{n}_x}^2 + {\vec{n}_y}^2 + {\vec{n}_z}^2 } }. \]

Equivalences

• Assuming \( \| \vec{n} \|_2 \ne 0 \), this function is agnostic to the normalisation of the axis vector.

  applyRotateAroundAxis(qureg, target, angle, x,  y,  z);
  applyRotateAroundAxis(qureg, target, angle, 5*x,5*y,5*z); // equivalent

• This function is entirely equivalent to preparing \( \hat{R}_{\bar{n}}(\theta) \) as a CompMatr1 and effecting it upon the state via applyCompMatr1().
• This function is both more accurate and efficient than equivalently instantiating a three-term PauliStrSum \( \hat{H} = \bar{n} \cdot \vec{\sigma}\) and effecting \( \exp \left(\iu \alpha \hat{H} \right) \) via applyTrotterizedPauliStrSumGadget() with \( \alpha = - \theta/2 \) and very many repetitions.
• Passing angle=0 is equivalent to effecting the identity, leaving the state unchanged.

Definition at line 1341 of file operations.cpp.

                                                                                                      {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, targ, __func__);
    validate_rotationAxisNotZeroVector(axisX, axisY, axisZ, __func__);
 
    applyMultiStateControlledRotateAroundAxis(qureg, nullptr, nullptr, 0, targ, angle, axisX, axisY, axisZ);
}

applyRotateX()

void applyRotateX	(	Qureg	qureg,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Formulae

Let \( \theta = \) angle. This function effects unitary

\[ \hat{R}_{x}(\theta) = \exp \left( - \iu \frac{\theta}{2} \hat{\sigma}_x \right) \]

upon the target qubit, where \( \hat{\sigma}_x \) is the Pauli X matrix.

Equivalences

• This function is entirely equivalent to calling applyPauliGadget() with a single-site PauliStr.

  applyPauliGadget(qureg, getInlinePauliStr("X", {target}), angle);

• This function is faster than, but otherwise equivalent to, invoking applyRotateAroundAxis() with an axis vector equal to the X-axis.

  applyRotateAroundAxis(qureg, target, qreal angle, 1,0,0);

• This function is faster than, but otherwise equivalent to, effecting \( \hat{R}_{x}(\theta) \) as a CompMatr1.

  qcomp c = cos(angle/2);
  qcomp s = sin(angle/2) * (-1.i);
  CompMatr1 matr = getInlineCompMatr1({{c, s}, {s, c}});
  applyCompMatr1(qureg, target, matr);

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

Definition at line 1199 of file operations.cpp.

                                                        {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateX(qureg, nullptr, nullptr, 0, target, angle);
}

applyRotateY()

void applyRotateY	(	Qureg	qureg,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Formulae

Let \( \theta = \) angle. This function effects unitary

\[ \hat{R}_{y}(\theta) = \exp \left( - \iu \frac{\theta}{2} \hat{\sigma}_y \right) \]

upon the target qubit, where \( \hat{\sigma}_y \) is the Pauli Y matrix.

Equivalences

• This function is entirely equivalent to calling applyPauliGadget() with a single-site PauliStr.

  applyPauliGadget(qureg, getInlinePauliStr("Y", {target}), angle);

• This function is faster than, but otherwise equivalent to, invoking applyRotateAroundAxis() with an axis vector equal to the Y-axis.

  applyRotateAroundAxis(qureg, target, qreal angle, 0,1,0);

• This function is faster than, but otherwise equivalent to, effecting \( \hat{R}_{y}(\theta) \) as a CompMatr1.

  qcomp c = cos(angle/2);
  qcomp s = sin(angle/2);
  CompMatr1 matr = getInlineCompMatr1({{c, -s}, {s, c}});
  applyCompMatr1(qureg, target, matr);

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

Definition at line 1207 of file operations.cpp.

                                                        {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateY(qureg, nullptr, nullptr, 0, target, angle);
}

applyRotateZ()

void applyRotateZ	(	Qureg	qureg,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Formulae

Let \( \theta = \) angle. This function effects unitary

\[ \hat{R}_{z}(\theta) = \exp \left( - \iu \frac{\theta}{2} \hat{\sigma}_z \right) \]

upon the target qubit, where \( \hat{\sigma}_z \) is the Pauli Z matrix.

Equivalences

• This function is entirely equivalent to calling applyPauliGadget() with a single-site PauliStr.

  applyPauliGadget(qureg, getInlinePauliStr("Z", {target}), angle);

• This function is faster than, but otherwise equivalent to, invoking applyRotateAroundAxis() with an axis vector equal to the Z-axis.

  applyRotateAroundAxis(qureg, target, qreal angle, 0,0,1);

• This function is faster than, but otherwise equivalent to, effecting \( \hat{R}_{z}(\theta) \) as a DiagMatr1.

  qcomp a = cexp(- angle / 2 * 1.i);
  qcomp b = cexp(  angle / 2 * 1.i);
  DiagMatr1 matr = getInlineDiagMatr1({a, b});
  applyDiagMatr1(qureg, target, matr);

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

Definition at line 1215 of file operations.cpp.

                                                        {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateZ(qureg, nullptr, nullptr, 0, target, angle);
}