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 1182 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 1038 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 1046 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 1054 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 1190 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 1062 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 1070 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 1078 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 1198 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 1086 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // note that for the single-target scenario, we do not call the backend of
    // applyMultiStateControlledPauliGadget() since it contains sub-optimal logic
    // which sees the factor of every amplitude dynamically evaluated (based on
    // index parity, etc); the dense-matrix element lookup is faster
 
    // harmlessly re-validates, including hardcoded matrix unitarity
    CompMatr1 matrix = util_getExpPauliX(angle);
    validateAndApplyAnyCtrlAnyTargUnitaryMatrix(qureg, controls, states, numControls, &target, 1, matrix, __func__);
}

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 1101 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // note that for the single-target scenario, we do not call the backend of
    // applyMultiStateControlledPauliGadget() since it contains sub-optimal logic
    // which sees the factor of every amplitude dynamically evaluated (based on
    // index parity, etc); the dense-matrix element lookup is faster
 
    // harmlessly re-validates, including hardcoded matrix unitarity
    CompMatr1 matrix = util_getExpPauliY(angle);
    validateAndApplyAnyCtrlAnyTargUnitaryMatrix(qureg, controls, states, numControls, &target, 1, matrix, __func__);
}

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 1116 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // note that for the single-target scenario, we do not call the backend of
    // applyMultiStateControlledPauliGadget() since it contains sub-optimal logic
    // which sees the factor of every amplitude dynamically evaluated (based on
    // index parity, etc); the dense-matrix element lookup is faster
 
    // harmlessly re-validates, including hardcoded matrix unitarity
    DiagMatr1 matrix = util_getExpPauliZ(angle);
    validateAndApplyAnyCtrlAnyTargUnitaryMatrix(qureg, controls, states, numControls, &target, 1, matrix, __func__);
}

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 1174 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 1014 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 1022 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 1030 of file operations.cpp.

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