Phase gates

Functions for applying many-qubit rotations around 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)
void	multiplyPhaseGadget (Qureg qureg, int *targets, int numTargets, qreal angle)

Detailed Description

Functions for applying many-qubit rotations around 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!

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

Definition at line 1524 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.

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

                                                                         {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    // treat as a (numTargets-1)-controlled 1-target Pauli Z
    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.

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

                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    // treat as a (numTargets-1)-controlled 1-target diagonal matrix
    DiagMatr1 matr = getDiagMatr1({1, std::exp(1_i * angle)});
 
    // 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!

See also

• applyPhaseGadget()
• applyMultiStateControlledCompMatr1()

Definition at line 1532 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 ctrlVec = util_getVector(controls, numControls);
    auto targVec = util_getVector(targets,  numTargets);
    auto stateVec = util_getVector(states,  numControls); // empty if states==nullptr
    localiser_statevec_anyCtrlPhaseGadget(qureg, ctrlVec, stateVec, targVec, phase);
 
    if (!qureg.isDensityMatrix)
        return;
 
    phase *= -1;
    ctrlVec = util_getBraQubits(ctrlVec, qureg);
    targVec = util_getBraQubits(targVec, qureg);
    localiser_statevec_anyCtrlPhaseGadget(qureg, ctrlVec, stateVec, targVec, 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 1631 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!

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). \]

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 1508 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 1588 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 1639 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 1596 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().

multiplyPhaseGadget()

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

Note

Documentation for this function or struct is under construction!

See also

• multiplyCompMatr1()
• applyPhaseGadget

Definition at line 1500 of file operations.cpp.

                                                                                 {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    qreal phase = util_getPhaseFromGateAngle(angle);
    localiser_statevec_anyCtrlPhaseGadget(qureg, {}, {}, util_getVector(targets,numTargets), phase);
}

Referenced by multiplyPhaseGadget().