Phase gates

Functions for applying many-qubit rotations around the Pauli Z axis, and phase flips and shifts. More...

Functions
void	applyControlledPhaseGadget (Qureg qureg, int control, int *targets, int numTargets, qreal angle)
void	applyMultiControlledPhaseGadget (Qureg qureg, int *controls, int numControls, int *targets, int numTargets, qreal angle)
void	applyMultiQubitPhaseFlip (Qureg qureg, int *targets, int numTargets)
void	applyMultiQubitPhaseShift (Qureg qureg, int *targets, int numTargets, qreal angle)
void	applyMultiStateControlledPhaseGadget (Qureg qureg, int *controls, int *states, int numControls, int *targets, int numTargets, qreal angle)
void	applyPhaseFlip (Qureg qureg, int target)
void	applyPhaseGadget (Qureg qureg, int *targets, int numTargets, qreal angle)
void	applyPhaseShift (Qureg qureg, int target, qreal angle)
void	applyTwoQubitPhaseFlip (Qureg qureg, int target1, int target2)
void	applyTwoQubitPhaseShift (Qureg qureg, int target1, int target2, qreal angle)

Detailed Description

Functions for applying many-qubit rotations around the Pauli Z axis, and phase flips and shifts.

Function Documentation

applyControlledPhaseGadget()

void applyControlledPhaseGadget	(	Qureg	qureg,
		int	control,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

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

‍- See applyPhaseGadget() for information about the base operation, angle, and targets.

• See applyControlledCompMatr1() for information about control.

Author

Tyson Jones

Definition at line 1338 of file operations.cpp.

                                                                                                     {
    validate_quregFields(qureg, __func__);
    validate_controlAndTargets(qureg, control, targets, numTargets, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledPhaseGadget(qureg, &control, nullptr, 1, targets, numTargets, angle);
}

Referenced by applyControlledPhaseGadget().

applyMultiControlledPhaseGadget()

void applyMultiControlledPhaseGadget	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

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

‍- See applyPhaseGadget() for information about the base operation, angle, and targets.

• See applyMultiControlledCompMatr1() for information about controls.

Author

Tyson Jones

Definition at line 1346 of file operations.cpp.

                                                                                                                             {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTargets(qureg, controls, numControls, targets, numTargets, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledPhaseGadget(qureg, controls, nullptr, numControls, targets, numTargets, angle);
}

Referenced by applyMultiControlledPhaseGadget().

applyMultiQubitPhaseFlip()

void applyMultiQubitPhaseFlip	(	Qureg	qureg,
		int *	targets,
		int	numTargets )

Note

Documentation for this function or struct is under construction!

Formulae

This function flips the sign of all computational basis states for which the targeted qubits are all in state \( \ket{1} \). This is equivalent to the diagonal unitary

\[ \hat{U}(\theta) = \begin{pmatrix} 1 \\ & \ddots \\ & & 1 \\ & & & -1 \end{pmatrix}, \]

effected upon the target qubits.

Remarks

This function is sometimes more efficient when targets are specified in increasing order, though the effect of this function is incidentally unaffected by the ordering of targets.

Equivalences

• The ordering of targets has no affect on the effected operation.
• This function is entirely equivalent to a multi-controlled Pauli-Z unitary (or a hypothetical many-controlled variant of applyPhaseFlip()) with all but one arbitrary target qubit becoming control qubits.

  applyMultiControlledPauliZ(qureg, targets, numTargets-1, targets[0]);

• This function is faster and more accurate than, but otherwise equivalent to, a multi-qubit phase shift with angle \( = \pi \).

  applyMultiQubitPhaseShift(qureg, targets, numTargets, 3.141592653); // approx equiv

Definition at line 1466 of file operations.cpp.

                                                                         {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    // treat as a (numTargets-1)-controlled 1-target Pauli Z
    static const DiagMatr1 matr = getDiagMatr1({1, -1});
 
    // harmlessly re-validates
    applyMultiStateControlledDiagMatr1(qureg, &targets[1], nullptr, numTargets-1, targets[0], matr);
}

Referenced by applyMultiQubitPhaseFlip(), applyPhaseFlip(), and applyTwoQubitPhaseFlip().

applyMultiQubitPhaseShift()

void applyMultiQubitPhaseShift	(	Qureg	qureg,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Formulae

Let \( \theta = \) angle. This function multiplies factor \( e^{\iu \theta} \) upon all computational basis states for which all targeted qubits are in state \( \ket{1} \). This is equivalent to the diagonal unitary

\[ \hat{U}(\theta) = \begin{pmatrix} 1 \\ & \ddots \\ & & 1 \\ & & & e^{\iu \theta} \end{pmatrix}, \]

effected upon the target qubits.

Remarks

This function is sometimes more efficient when targets are specified in increasing order, though the effect of this function is incidentally unaffected by the ordering of targets.

Diagram

Equivalences

• The ordering of targets has no affect on the effected operation.
• This function is equivalent to a multi-controlled variant of applyPhaseShift(), treating all but one arbitrary target qubit as control qubits.
• This function generalises applyMultiQubitPhaseFlip() to arbitrary changes in phase.
• Passing angle=0 is equivalent to effecting the identity, leaving the state unchanged.

Definition at line 1422 of file operations.cpp.

                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    // treat as a (numTargets-1)-controlled 1-target diagonal matrix
    static DiagMatr1 matr = getDiagMatr1({1, /*un-init*/ 0});
    matr.elems[1] = std::exp(1_i * angle); // micro-optimisation
 
    // harmlessly re-validates
    applyMultiStateControlledDiagMatr1(qureg, &targets[1], nullptr, numTargets-1, targets[0], matr);
}

Referenced by applyMultiQubitPhaseShift(), applyPhaseShift(), and applyTwoQubitPhaseShift().

applyMultiStateControlledPhaseGadget()

void applyMultiStateControlledPhaseGadget	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

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

‍- See applyPhaseGadget() for information about the base operation, angle, and targets.

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

Author

Tyson Jones

Definition at line 1354 of file operations.cpp.

                                                                                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTargets(qureg, controls, numControls, targets, numTargets, __func__);
    validate_controlStates(states, numControls, __func__);
 
    qreal phase = util_getPhaseFromGateAngle(angle);
    auto ctrlList = lists_getList64(controls, numControls);
    auto stateList = util_getList64OrAllOnes(states, numControls);
    auto targList = lists_getList64(targets,  numTargets);
    localiser_statevec_anyCtrlPhaseGadget(qureg, ctrlList, stateList, targList, phase);
 
    if (!qureg.isDensityMatrix)
        return;
 
    phase *= -1;
    ctrlList = util_getBraQubits(ctrlList, qureg);
    targList = util_getBraQubits(targList, qureg);
    localiser_statevec_anyCtrlPhaseGadget(qureg, ctrlList, stateList, targList, phase);
}

Referenced by applyControlledPhaseGadget(), applyMultiControlledPhaseGadget(), applyMultiStateControlledPhaseGadget(), and applyPhaseGadget().

applyPhaseFlip()

void applyPhaseFlip	(	Qureg	qureg,
		int	target )

Note

Documentation for this function or struct is under construction!

This function is a mere alias of applyPauliZ(), meaningfully differing only for many targets.

Definition at line 1449 of file operations.cpp.

                                             {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiQubitPhaseFlip(qureg, &target, 1);
}

applyPhaseGadget()

void applyPhaseGadget	(	Qureg	qureg,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

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

Formulae

Let \( \vec{t} = \) targets and \( \theta = \) angle.

This function effects diagonal unitary

\[ R_{\hat{Z}}(\theta) = \exp \left( - \iu \, \frac{\theta}{2} \, \bigotimes_{t \,\in\, \vec{t}} \hat{Z}_t \right). \]

Remarks

This function is sometimes more efficient when targets are specified in increasing order, though the effect of this function is incidentally unaffected by the ordering of targets.

Equivalences

• This function is equivalent to calling applyPauliGadget() with a PauliStr containing only \( \hat{Z} \) and \( \id \). This latter function will actually automatically invoke applyPhaseGadget() which has an optimised implementation.
• This function is equivalent to, albeit much faster than, preparing a DiagMatr with \( \pm 1 \) elements (depending upon the parity of the targeted set bits) and effecting it with applyDiagMatr().
• Passing angle=0 is equivalent to effecting the identity, leaving the state unchanged.

Definition at line 1330 of file operations.cpp.

                                                                              {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledPhaseGadget(qureg, nullptr, nullptr, 0, targets, numTargets, angle);
}

Referenced by applyPhaseGadget().

applyPhaseShift()

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

Note

Documentation for this function or struct is under construction!

Formulae

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

\[ \hat{U}(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{\iu \theta} \end{pmatrix} \]

upon the target qubit.

Equivalences

• This function is equivalent to, albeit much faster than, a Z-axis rotation with an adjustment to the global phase (which is redundant upon density matrices).

  \[ \hat{U}(\theta) \equiv \hat{R}_z(\theta) \cdot e^{\iu \frac{\theta}{2}} \hat{\id} \]

  applyRotateZ(qureg, target, angle);
  applyPauliGadget(qureg, getPauliStr("I"), angle); // global phase

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

Definition at line 1405 of file operations.cpp.

                                                           {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiQubitPhaseShift(qureg, &target, 1, angle);
}

applyTwoQubitPhaseFlip()

void applyTwoQubitPhaseFlip	(	Qureg	qureg,
		int	target1,
		int	target2 )

Note

Documentation for this function or struct is under construction!

Applies a two-qubit phase flip upon qubits target1 and target2 of qureg.

Formulae

This function flips the sign of all computational basis states for which the targeted qubits are in state \( \ket{1}\ket{1} \). This is equivalent to the diagonal unitary

\[ \hat{U}(\theta) = \begin{pmatrix} 1 \\ & 1 \\ & & 1 \\ & & & -1 \end{pmatrix}, \]

effected upon the target qubits.

Diagram

Equivalences

• The target qubits are interchangeable, ergo

  applyTwoQubitPhaseFlip(qureg, target1, target2);
  applyTwoQubitPhaseFlip(qureg, target2, target1); // equivalent

• This function is entirely equivalent to a controlled Pauli-Z unitary (or a hypothetical controlled variant of applyPhaseFlip()) with either target qubit substituted for the control qubit.

  applyControlledPauliZ(qureg, target1, target2);

• This function is faster and more accurate than, but otherwise equivalent to, a two-qubit phase shift with angle \( = \pi \).

  applyTwoQubitPhaseShift(qureg, target1, target2, 3.141592653); // approx equiv

Definition at line 1457 of file operations.cpp.

                                                                   {
    validate_quregFields(qureg, __func__);
    validate_twoTargets(qureg, target1, target2, __func__);
 
    // harmlessly re-validates
    int targets[] = {target1, target2};
    applyMultiQubitPhaseFlip(qureg, targets, 2);
}

applyTwoQubitPhaseShift()

void applyTwoQubitPhaseShift	(	Qureg	qureg,
		int	target1,
		int	target2,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Applies a two-qubit phase shift upon qubits target1 and target2 of qureg.

Formulae

Let \( \theta = \) angle. This function multiplies factor \( e^{\iu \theta} \) upon all computational basis states for which the targeted qubits are in state \( \ket{1}\ket{1} \). This is equivalent to the diagonal unitary

\[ \hat{U}(\theta) = \begin{pmatrix} 1 \\ & 1 \\ & & 1 \\ & & & e^{\iu \theta} \end{pmatrix}, \]

effected upon the target qubits.

Diagram

Equivalences

• The target qubits are interchangeable, ergo

  applyTwoQubitPhaseShift(qureg, target1, target2, angle);
  applyTwoQubitPhaseShift(qureg, target2, target1, angle); // equivalent

• This function is equivalent to a controlled variant of applyPhaseShift(), treating either target qubit as the control qubit.
• This function generalises applyTwoQubitPhaseFlip() to arbitrary changes in phase.
• Passing angle=0 is equivalent to effecting the identity, leaving the state unchanged.

Definition at line 1413 of file operations.cpp.

                                                                                 {
    validate_quregFields(qureg, __func__);
    validate_twoTargets(qureg, target1, target2, __func__);
 
    // harmlessly re-validates
    int targets[] = {target1, target2};
    applyMultiQubitPhaseShift(qureg, targets, 2, angle);
}

Referenced by applyQuantumFourierTransform().