Unitaries

Unitary gates. More...

Functions

void compactUnitary (Qureg qureg, int targetQubit, Complex alpha, Complex beta)
 Apply a single-qubit unitary parameterised by two given complex scalars. More...
 
void controlledCompactUnitary (Qureg qureg, int controlQubit, int targetQubit, Complex alpha, Complex beta)
 Apply a controlled unitary (single control, single target) parameterised by two given complex scalars. More...
 
void controlledMultiQubitUnitary (Qureg qureg, int ctrl, int *targs, int numTargs, ComplexMatrixN u)
 Apply a general controlled multi-qubit unitary (including a global phase factor). More...
 
void controlledNot (Qureg qureg, int controlQubit, int targetQubit)
 Apply the controlled not (single control, single target) gate, also known as the c-X, c-sigma-X, c-Pauli-X and c-bit-flip gate. More...
 
void controlledPauliY (Qureg qureg, int controlQubit, int targetQubit)
 Apply the controlled pauliY (single control, single target) gate, also known as the c-Y and c-sigma-Y gate. More...
 
void controlledPhaseFlip (Qureg qureg, int idQubit1, int idQubit2)
 Apply the (two-qubit) controlled phase flip gate, also known as the controlled pauliZ gate. More...
 
void controlledPhaseShift (Qureg qureg, int idQubit1, int idQubit2, qreal angle)
 Introduce a phase factor $ \exp(i \theta) $ on state $ |11\rangle $ of qubits idQubit1 and idQubit2. More...
 
void controlledRotateAroundAxis (Qureg qureg, int controlQubit, int targetQubit, qreal angle, Vector axis)
 Applies a controlled rotation by a given angle around a given vector on the Bloch-sphere. More...
 
void controlledRotateX (Qureg qureg, int controlQubit, int targetQubit, qreal angle)
 Applies a controlled rotation by a given angle around the X-axis of the Bloch-sphere. More...
 
void controlledRotateY (Qureg qureg, int controlQubit, int targetQubit, qreal angle)
 Applies a controlled rotation by a given angle around the Y-axis of the Bloch-sphere. More...
 
void controlledRotateZ (Qureg qureg, int controlQubit, int targetQubit, qreal angle)
 Applies a controlled rotation by a given angle around the Z-axis of the Bloch-sphere. More...
 
void controlledTwoQubitUnitary (Qureg qureg, int controlQubit, int targetQubit1, int targetQubit2, ComplexMatrix4 u)
 Apply a general controlled two-qubit unitary (including a global phase factor). More...
 
void controlledUnitary (Qureg qureg, int controlQubit, int targetQubit, ComplexMatrix2 u)
 Apply a general controlled unitary (single control, single target), which can include a global phase factor. More...
 
void hadamard (Qureg qureg, int targetQubit)
 Apply the single-qubit Hadamard gate. More...
 
void multiControlledMultiQubitUnitary (Qureg qureg, int *ctrls, int numCtrls, int *targs, int numTargs, ComplexMatrixN u)
 Apply a general multi-controlled multi-qubit unitary (including a global phase factor). More...
 
void multiControlledPhaseFlip (Qureg qureg, int *controlQubits, int numControlQubits)
 Apply the multiple-qubit controlled phase flip gate, also known as the multiple-qubit controlled pauliZ gate. More...
 
void multiControlledPhaseShift (Qureg qureg, int *controlQubits, int numControlQubits, qreal angle)
 Introduce a phase factor $ \exp(i \theta) $ on state $ |1 \dots 1 \rangle $ of the passed qubits. More...
 
void multiControlledTwoQubitUnitary (Qureg qureg, int *controlQubits, int numControlQubits, int targetQubit1, int targetQubit2, ComplexMatrix4 u)
 Apply a general multi-controlled two-qubit unitary (including a global phase factor). More...
 
void multiControlledUnitary (Qureg qureg, int *controlQubits, int numControlQubits, int targetQubit, ComplexMatrix2 u)
 Apply a general multiple-control single-target unitary, which can include a global phase factor. More...
 
void multiQubitUnitary (Qureg qureg, int *targs, int numTargs, ComplexMatrixN u)
 Apply a general multi-qubit unitary (including a global phase factor) with any number of target qubits. More...
 
void multiRotatePauli (Qureg qureg, int *targetQubits, enum pauliOpType *targetPaulis, int numTargets, qreal angle)
 Apply a multi-qubit multi-Pauli rotation on a selected number of qubits. More...
 
void multiRotateZ (Qureg qureg, int *qubits, int numQubits, qreal angle)
 Apply a multi-qubit Z rotation on a selected number of qubits. More...
 
void multiStateControlledUnitary (Qureg qureg, int *controlQubits, int *controlState, int numControlQubits, int targetQubit, ComplexMatrix2 u)
 Apply a general multiple-control, conditioned on a specific bit sequence, single-target unitary, which can include a global phase factor. More...
 
void pauliX (Qureg qureg, int targetQubit)
 Apply the single-qubit Pauli-X (also known as the X, sigma-X, NOT or bit-flip) gate. More...
 
void pauliY (Qureg qureg, int targetQubit)
 Apply the single-qubit Pauli-Y (also known as the Y or sigma-Y) gate. More...
 
void pauliZ (Qureg qureg, int targetQubit)
 Apply the single-qubit Pauli-Z (also known as the Z, sigma-Z or phase-flip) gate. More...
 
void phaseShift (Qureg qureg, int targetQubit, qreal angle)
 Shift the phase between $ |0\rangle $ and $ |1\rangle $ of a single qubit by a given angle. More...
 
void rotateAroundAxis (Qureg qureg, int rotQubit, qreal angle, Vector axis)
 Rotate a single qubit by a given angle around a given Vector on the Bloch-sphere. More...
 
void rotateX (Qureg qureg, int rotQubit, qreal angle)
 Rotate a single qubit by a given angle around the X-axis of the Bloch-sphere. More...
 
void rotateY (Qureg qureg, int rotQubit, qreal angle)
 Rotate a single qubit by a given angle around the Y-axis of the Bloch-sphere. More...
 
void rotateZ (Qureg qureg, int rotQubit, qreal angle)
 Rotate a single qubit by a given angle around the Z-axis of the Bloch-sphere (also known as a phase shift gate). More...
 
void sGate (Qureg qureg, int targetQubit)
 Apply the single-qubit S gate. More...
 
void sqrtSwapGate (Qureg qureg, int qb1, int qb2)
 Performs a sqrt SWAP gate between qubit1 and qubit2. More...
 
void swapGate (Qureg qureg, int qubit1, int qubit2)
 Performs a SWAP gate between qubit1 and qubit2. More...
 
void tGate (Qureg qureg, int targetQubit)
 Apply the single-qubit T gate. More...
 
void twoQubitUnitary (Qureg qureg, int targetQubit1, int targetQubit2, ComplexMatrix4 u)
 Apply a general two-qubit unitary (including a global phase factor). More...
 
void unitary (Qureg qureg, int targetQubit, ComplexMatrix2 u)
 Apply a general single-qubit unitary (including a global phase factor). More...
 

Detailed Description

Unitary gates.

Function Documentation

◆ compactUnitary()

void compactUnitary ( Qureg  qureg,
int  targetQubit,
Complex  alpha,
Complex  beta 
)

Apply a single-qubit unitary parameterised by two given complex scalars.

Given valid complex numbers $\alpha$ and $\beta$, applies the unitary

\[ U = \begin{pmatrix} \alpha & -\beta^* \\ \beta & \alpha^* \end{pmatrix} \]

which is general up to a global phase factor.
Valid $\alpha$, $\beta$ satisfy $|\alpha|^2 + |\beta|^2 = 1$.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {U}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to operate on
[in]alphacomplex unitary parameter (row 1, column 1)
[in]betacomplex unitary parameter (row 2, column 1)
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented), or if alpha, beta don't satisfy |alpha|^2 + |beta|^2 = 1.
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 405 of file QuEST.c.

405  {
406  validateTarget(qureg, targetQubit, __func__);
407  validateUnitaryComplexPair(alpha, beta, __func__);
408 
409  statevec_compactUnitary(qureg, targetQubit, alpha, beta);
410  if (qureg.isDensityMatrix) {
411  int shift = qureg.numQubitsRepresented;
412  statevec_compactUnitary(qureg, targetQubit+shift, getConjugateScalar(alpha), getConjugateScalar(beta));
413  }
414 
415  qasm_recordCompactUnitary(qureg, alpha, beta, targetQubit);
416 }

References getConjugateScalar(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordCompactUnitary(), statevec_compactUnitary(), validateTarget(), and validateUnitaryComplexPair().

Referenced by TEST_CASE().

◆ controlledCompactUnitary()

void controlledCompactUnitary ( Qureg  qureg,
int  controlQubit,
int  targetQubit,
Complex  alpha,
Complex  beta 
)

Apply a controlled unitary (single control, single target) parameterised by two given complex scalars.

Given valid complex numbers $\alpha$ and $\beta$, applies the two-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\ & & \alpha & -\beta^* \\ & & \beta & \alpha^* \end{pmatrix} \]

to the control and target qubits. Valid $\alpha$, $\beta$ satisfy $|\alpha|^2 + |\beta|^2 = 1$. The target unitary is general up to a global phase factor.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$U_{\alpha, \beta}$}; \end{tikzpicture} } \]


Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitapply the target unitary if this qubit has value 1
[in]targetQubitqubit on which to apply the target unitary
[in]alphacomplex unitary parameter (row 1, column 1)
[in]betacomplex unitary parameter (row 2, column 1)
Exceptions
invalidQuESTInputErrorif either controlQubit or targetQubit are outside [0, qureg.numQubitsRepresented) or are equal, or if alpha, beta don't satisfy |alpha|^2 + |beta|^2 = 1.
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 418 of file QuEST.c.

418  {
419  validateControlTarget(qureg, controlQubit, targetQubit, __func__);
420  validateUnitaryComplexPair(alpha, beta, __func__);
421 
422  statevec_controlledCompactUnitary(qureg, controlQubit, targetQubit, alpha, beta);
423  if (qureg.isDensityMatrix) {
424  int shift = qureg.numQubitsRepresented;
426  controlQubit+shift, targetQubit+shift,
427  getConjugateScalar(alpha), getConjugateScalar(beta));
428  }
429 
430  qasm_recordControlledCompactUnitary(qureg, alpha, beta, controlQubit, targetQubit);
431 }

References getConjugateScalar(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledCompactUnitary(), statevec_controlledCompactUnitary(), validateControlTarget(), and validateUnitaryComplexPair().

Referenced by TEST_CASE().

◆ controlledMultiQubitUnitary()

void controlledMultiQubitUnitary ( Qureg  qureg,
int  ctrl,
int *  targs,
int  numTargs,
ComplexMatrixN  u 
)

Apply a general controlled multi-qubit unitary (including a global phase factor).

One control and any number of target qubits can be specified. This effects the many-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\\ & & 1 \\ & & & 1 \\ & & & & u_{00} & u_{01} & \dots \\ & & & & u_{10} & u_{11} & \dots \\ & & & & \vdots & \vdots & \ddots \end{pmatrix} \]

on the control and target qubits.

The target qubits in targs are treated as ordered least significant to most significant in u.

The passed ComplexMatrix must be unitary and be a compatible size with the specified number of target qubits, otherwise an error is thrown.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 1) {targets}; \node[draw=none] at (-3.5, 4) {control}; \draw (-2, 4) -- (2, 4); \draw[fill=black] (0, 4) circle (.2); \draw(0, 4) -- (0, 3); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-2,2) -- (-1, 2); \draw (1, 2) -- (2, 2); \draw (-1,-1)--(-1,3)--(1,3)--(1,-1); \node[draw=none] at (0, 1) {U}; \node[draw=none] at (0, -1) {$\vdots$}; \end{tikzpicture} } \]

Note that in multithreaded mode, each thread will clone 2^numTargs amplitudes, and store these in the runtime stack. Using t threads, the total memory overhead of this function is t*2^numTargs. For many targets (e.g. 16 qubits), this may cause a stack-overflow / seg-fault (e.g. on a 1 MiB stack).

Note too that in distributed mode, this routine requires that each node contains at least 2^numTargs amplitudes. This means an q-qubit register (state vector or density matrix) can be distributed by at most 2^q / 2^numTargs nodes.

Parameters
[in,out]quregobject representing the set of all qubits
[in]ctrlthe control qubit
[in]targsa list of the target qubits, ordered least to most significant
[in]numTargsthe number of target qubits
[in]uunitary matrix to apply
Exceptions
invalidQuESTInputErrorif ctrl or any index in targs is outside of [0, qureg.numQubitsRepresented), or if targs are not unique, or if targs contains ctrl, or if matrix u is not unitary, or if a node cannot fit the required number of target amplitudes in distributed mode.
Author
Tyson Jones

Definition at line 314 of file QuEST.c.

314  {
315  validateMultiControlsMultiTargets(qureg, (int[]) {ctrl}, 1, targs, numTargs, __func__);
316  validateMultiQubitUnitaryMatrix(qureg, u, numTargs, __func__);
317 
318  statevec_controlledMultiQubitUnitary(qureg, ctrl, targs, numTargs, u);
319  if (qureg.isDensityMatrix) {
320  int shift = qureg.numQubitsRepresented;
321  shiftIndices(targs, numTargs, shift);
323  statevec_controlledMultiQubitUnitary(qureg, ctrl+shift, targs, numTargs, u);
324  shiftIndices(targs, numTargs, -shift);
326  }
327 
328  qasm_recordComment(qureg, "Here, an undisclosed controlled multi-qubit unitary was applied.");
329 }

References Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordComment(), setConjugateMatrixN(), shiftIndices(), statevec_controlledMultiQubitUnitary(), validateMultiControlsMultiTargets(), and validateMultiQubitUnitaryMatrix().

Referenced by TEST_CASE().

◆ controlledNot()

void controlledNot ( Qureg  qureg,
int  controlQubit,
int  targetQubit 
)

Apply the controlled not (single control, single target) gate, also known as the c-X, c-sigma-X, c-Pauli-X and c-bit-flip gate.

This applies pauliX to the target qubit if the control qubit has value 1. This effects the two-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\\ & & & 1 \\ & & 1 \end{pmatrix} \]

on the control and target qubits.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, -.5); \draw (-2,0) -- (2, 0); \draw (0, 0) circle (.5); \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitnots the target if this qubit is 1
[in]targetQubitqubit to not
Exceptions
invalidQuESTInputErrorif either controlQubit or targetQubit are outside [0, qureg.numQubitsRepresented), or are equal.
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 525 of file QuEST.c.

525  {
526  validateControlTarget(qureg, controlQubit, targetQubit, __func__);
527 
528  statevec_controlledNot(qureg, controlQubit, targetQubit);
529  if (qureg.isDensityMatrix) {
530  int shift = qureg.numQubitsRepresented;
531  statevec_controlledNot(qureg, controlQubit+shift, targetQubit+shift);
532  }
533 
534  qasm_recordControlledGate(qureg, GATE_SIGMA_X, controlQubit, targetQubit);
535 }

References GATE_SIGMA_X, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledGate(), statevec_controlledNot(), and validateControlTarget().

Referenced by TEST_CASE().

◆ controlledPauliY()

void controlledPauliY ( Qureg  qureg,
int  controlQubit,
int  targetQubit 
)

Apply the controlled pauliY (single control, single target) gate, also known as the c-Y and c-sigma-Y gate.

This applies pauliY to the target qubit if the control qubit has value 1. This effects the two-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\\ & & & -i \\ & & i \end{pmatrix} \]

on the control and target qubits.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {Y}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitapplies pauliY to the target if this qubit is 1
[in]targetQubitqubit to not
Exceptions
invalidQuESTInputErrorif either controlQubit or targetQubit are outside [0, qureg.numQubitsRepresented), or are equal.
Author
Tyson Jones
Ania Brown (debug)

Definition at line 537 of file QuEST.c.

537  {
538  validateControlTarget(qureg, controlQubit, targetQubit, __func__);
539 
540  statevec_controlledPauliY(qureg, controlQubit, targetQubit);
541  if (qureg.isDensityMatrix) {
542  int shift = qureg.numQubitsRepresented;
543  statevec_controlledPauliYConj(qureg, controlQubit+shift, targetQubit+shift);
544  }
545 
546  qasm_recordControlledGate(qureg, GATE_SIGMA_Y, controlQubit, targetQubit);
547 }

References GATE_SIGMA_Y, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledGate(), statevec_controlledPauliY(), statevec_controlledPauliYConj(), and validateControlTarget().

Referenced by TEST_CASE().

◆ controlledPhaseFlip()

void controlledPhaseFlip ( Qureg  qureg,
int  idQubit1,
int  idQubit2 
)

Apply the (two-qubit) controlled phase flip gate, also known as the controlled pauliZ gate.

For each state, if both input qubits have value one, multiply the amplitude of that state by -1. This applies the two-qubit unitary:

\[ \begin{pmatrix} 1 \\ & 1 \\\ & & 1 \\ & & & -1 \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {idQubit1}; \node[draw=none] at (-3.5, 0) {idQubit2}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 0); \draw (-2,0) -- (2, 0); \draw[fill=black] (0, 0) circle (.2); \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]idQubit1,idQubit2qubits to operate upon
Exceptions
invalidQuESTInputErrorif idQubit1 or idQubit2 are outside [0, qureg.numQubitsRepresented), or are equal
Author
Tyson Jones

Definition at line 549 of file QuEST.c.

549  {
550  validateControlTarget(qureg, idQubit1, idQubit2, __func__);
551 
552  statevec_controlledPhaseFlip(qureg, idQubit1, idQubit2);
553  if (qureg.isDensityMatrix) {
554  int shift = qureg.numQubitsRepresented;
555  statevec_controlledPhaseFlip(qureg, idQubit1+shift, idQubit2+shift);
556  }
557 
558  qasm_recordControlledGate(qureg, GATE_SIGMA_Z, idQubit1, idQubit2);
559 }

References GATE_SIGMA_Z, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledGate(), statevec_controlledPhaseFlip(), and validateControlTarget().

Referenced by TEST_CASE().

◆ controlledPhaseShift()

void controlledPhaseShift ( Qureg  qureg,
int  idQubit1,
int  idQubit2,
qreal  angle 
)

Introduce a phase factor $ \exp(i \theta) $ on state $ |11\rangle $ of qubits idQubit1 and idQubit2.

For angle $\theta$, this effects the unitary

\[ \begin{pmatrix} 1 & & & \\ & 1 & & \\ & & 1 & \\ & & & \exp(i \theta) \end{pmatrix} \]

on idQubit1 and idQubit2.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {qubit1}; \node[draw=none] at (-3.5, 0) {qubit2}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_\theta$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]idQubit1first qubit in the state to phase shift
[in]idQubit2second qubit in the state to phase shift
[in]angleamount by which to shift the phase in radians
Exceptions
invalidQuESTInputErrorif idQubit1 or idQubit2 are outside [0, qureg.numQubitsRepresented), or are equal
Author
Tyson Jones

Definition at line 499 of file QuEST.c.

499  {
500  validateControlTarget(qureg, idQubit1, idQubit2, __func__);
501 
502  statevec_controlledPhaseShift(qureg, idQubit1, idQubit2, angle);
503  if (qureg.isDensityMatrix) {
504  int shift = qureg.numQubitsRepresented;
505  statevec_controlledPhaseShift(qureg, idQubit1+shift, idQubit2+shift, -angle);
506  }
507 
508  qasm_recordControlledParamGate(qureg, GATE_PHASE_SHIFT, idQubit1, idQubit2, angle);
509 }

References GATE_PHASE_SHIFT, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledParamGate(), statevec_controlledPhaseShift(), and validateControlTarget().

Referenced by TEST_CASE().

◆ controlledRotateAroundAxis()

void controlledRotateAroundAxis ( Qureg  qureg,
int  controlQubit,
int  targetQubit,
qreal  angle,
Vector  axis 
)

Applies a controlled rotation by a given angle around a given vector on the Bloch-sphere.


The vector must not be zero (else an error is thrown), but needn't be unit magnitude.

For angle $\theta$ and axis vector $\vec{n}$, applies $R_{\hat{n}} = \exp \left(- i \frac{\theta}{2} \hat{n} \cdot \vec{\sigma} \right) $ to states where the target qubit is 1 ( $\vec{\sigma}$ is the vector of Pauli matrices).

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_{\hat{n}}(\theta)$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitqubit with value 1 in the rotated states
[in]targetQubitqubit to rotate
[in]angleangle by which to rotate in radians
[in]axisvector around which to rotate (can be non-unit; will be normalised)
Exceptions
invalidQuESTInputErrorif either controlQubit or targetQubit are outside [0, qureg.numQubitsRepresented) or are equal or if axis is the zero vector
Author
Tyson Jones

Definition at line 588 of file QuEST.c.

588  {
589  validateControlTarget(qureg, controlQubit, targetQubit, __func__);
590  validateVector(axis, __func__);
591 
592  statevec_controlledRotateAroundAxis(qureg, controlQubit, targetQubit, angle, axis);
593  if (qureg.isDensityMatrix) {
594  int shift = qureg.numQubitsRepresented;
595  statevec_controlledRotateAroundAxisConj(qureg, controlQubit+shift, targetQubit+shift, angle, axis);
596  }
597 
598  qasm_recordControlledAxisRotation(qureg, angle, axis, controlQubit, targetQubit);
599 }

References Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledAxisRotation(), statevec_controlledRotateAroundAxis(), statevec_controlledRotateAroundAxisConj(), validateControlTarget(), and validateVector().

Referenced by TEST_CASE().

◆ controlledRotateX()

void controlledRotateX ( Qureg  qureg,
int  controlQubit,
int  targetQubit,
qreal  angle 
)

Applies a controlled rotation by a given angle around the X-axis of the Bloch-sphere.

The target qubit is rotated in states where the control qubit has value 1.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_x(\theta)$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitqubit which has value 1 in the rotated states
[in]targetQubitqubit to rotate
[in]angleangle by which to rotate the target qubit in radians
Exceptions
invalidQuESTInputErrorif either controlQubit or targetQubit are outside [0, qureg.numQubitsRepresented) or are equal.
Author
Tyson Jones

Definition at line 221 of file QuEST.c.

221  {
222  validateControlTarget(qureg, controlQubit, targetQubit, __func__);
223 
224  statevec_controlledRotateX(qureg, controlQubit, targetQubit, angle);
225  if (qureg.isDensityMatrix) {
226  int shift = qureg.numQubitsRepresented;
227  statevec_controlledRotateX(qureg, controlQubit+shift, targetQubit+shift, -angle);
228  }
229 
230  qasm_recordControlledParamGate(qureg, GATE_ROTATE_X, controlQubit, targetQubit, angle);
231 }

References GATE_ROTATE_X, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledParamGate(), statevec_controlledRotateX(), and validateControlTarget().

Referenced by TEST_CASE().

◆ controlledRotateY()

void controlledRotateY ( Qureg  qureg,
int  controlQubit,
int  targetQubit,
qreal  angle 
)

Applies a controlled rotation by a given angle around the Y-axis of the Bloch-sphere.

The target qubit is rotated in states where the control qubit has value 1.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_y(\theta)$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitqubit which has value 1 in the rotated states
[in]targetQubitqubit to rotate
[in]angleangle by which to rotate the target qubit in radians
Exceptions
invalidQuESTInputErrorif either controlQubit or targetQubit are outside [0, qureg.numQubitsRepresented) or are equal.
Author
Tyson Jones

Definition at line 233 of file QuEST.c.

233  {
234  validateControlTarget(qureg, controlQubit, targetQubit, __func__);
235 
236  statevec_controlledRotateY(qureg, controlQubit, targetQubit, angle);
237  if (qureg.isDensityMatrix) {
238  int shift = qureg.numQubitsRepresented;
239  statevec_controlledRotateY(qureg, controlQubit+shift, targetQubit+shift, angle); // rotateY is real
240  }
241 
242  qasm_recordControlledParamGate(qureg, GATE_ROTATE_Y, controlQubit, targetQubit, angle);
243 }

References GATE_ROTATE_Y, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledParamGate(), statevec_controlledRotateY(), and validateControlTarget().

Referenced by TEST_CASE().

◆ controlledRotateZ()

void controlledRotateZ ( Qureg  qureg,
int  controlQubit,
int  targetQubit,
qreal  angle 
)

Applies a controlled rotation by a given angle around the Z-axis of the Bloch-sphere.

The target qubit is rotated in states where the control qubit has value 1.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_z(\theta)$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitqubit which has value 1 in the rotated states
[in]targetQubitqubit to rotate
[in]angleangle by which to rotate the target qubit in radians
Exceptions
invalidQuESTInputErrorif either controlQubit or targetQubit are outside [0, qureg.numQubitsRepresented) or are equal.
Author
Tyson Jones

Definition at line 245 of file QuEST.c.

245  {
246  validateControlTarget(qureg, controlQubit, targetQubit, __func__);
247 
248  statevec_controlledRotateZ(qureg, controlQubit, targetQubit, angle);
249  if (qureg.isDensityMatrix) {
250  int shift = qureg.numQubitsRepresented;
251  statevec_controlledRotateZ(qureg, controlQubit+shift, targetQubit+shift, -angle);
252  }
253 
254  qasm_recordControlledParamGate(qureg, GATE_ROTATE_Z, controlQubit, targetQubit, angle);
255 }

References GATE_ROTATE_Z, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledParamGate(), statevec_controlledRotateZ(), and validateControlTarget().

Referenced by TEST_CASE().

◆ controlledTwoQubitUnitary()

void controlledTwoQubitUnitary ( Qureg  qureg,
int  controlQubit,
int  targetQubit1,
int  targetQubit2,
ComplexMatrix4  u 
)

Apply a general controlled two-qubit unitary (including a global phase factor).

The given unitary is applied to the target amplitudes where the control qubit has value 1. This effects the many-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\ & & 1 \\ & & & 1 \\ & & & & u_{00} & u_{01} & u_{02} & u_{03} \\ & & & & u_{10} & u_{11} & u_{12} & u_{13} \\ & & & & u_{20} & u_{21} & u_{22} & u_{23} \\ & & & & u_{30} & u_{31} & u_{32} & u_{33} \end{pmatrix} \]

on the control and target qubits.

targetQubit1 is treated as the least significant qubit in u, such that a row in u is dotted with the vector $ |\text{targetQubit2} \;\; \text{targetQubit1}\rangle : \{ |00\rangle, |01\rangle, |10\rangle, |11\rangle \} $

The passed 4x4 ComplexMatrix must be unitary, otherwise an error is thrown.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target1}; \node[draw=none] at (-3.5, 2) {target2}; \node[draw=none] at (-3.5, 4) {control}; \draw (-2, 4) -- (2, 4); \draw[fill=black] (0, 4) circle (.2); \draw(0, 4) -- (0, 3); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-2,2) -- (-1, 2); \draw (1, 2) -- (2, 2); \draw (-1,-1)--(-1,3)--(1,3)--(1,-1)--cycle; \node[draw=none] at (0, 1) {U}; \end{tikzpicture} } \]

Note that in distributed mode, this routine requires that each node contains at least 4 amplitudes. This means an q-qubit register (state vector or density matrix) can be distributed by at most 2^q/4 nodes.


Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitthe control qubit which must be in state 1 to effect the given unitary
[in]targetQubit1first qubit to operate on, treated as least significant in u
[in]targetQubit2second qubit to operate on, treated as most significant in u
[in]uunitary matrix to apply
Exceptions
invalidQuESTInputErrorif controlQubit, targetQubit1 or targetQubit2 are outside [0, qureg.numQubitsRepresented), or if any of controlQubit, targetQubit1 and targetQubit2 are equal, or matrix u is not unitary, or if each node cannot fit 4 amplitudes in distributed mode.
Author
Tyson Jones

Definition at line 270 of file QuEST.c.

270  {
271  validateMultiControlsMultiTargets(qureg, (int[]) {controlQubit}, 1, (int[]) {targetQubit1, targetQubit2}, 2, __func__);
272  validateTwoQubitUnitaryMatrix(qureg, u, __func__);
273 
274  statevec_controlledTwoQubitUnitary(qureg, controlQubit, targetQubit1, targetQubit2, u);
275  if (qureg.isDensityMatrix) {
276  int shift = qureg.numQubitsRepresented;
277  statevec_controlledTwoQubitUnitary(qureg, controlQubit+shift, targetQubit1+shift, targetQubit2+shift, getConjugateMatrix4(u));
278  }
279 
280  qasm_recordComment(qureg, "Here, an undisclosed controlled 2-qubit unitary was applied.");
281 }

References getConjugateMatrix4(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordComment(), statevec_controlledTwoQubitUnitary(), validateMultiControlsMultiTargets(), and validateTwoQubitUnitaryMatrix().

Referenced by TEST_CASE().

◆ controlledUnitary()

void controlledUnitary ( Qureg  qureg,
int  controlQubit,
int  targetQubit,
ComplexMatrix2  u 
)

Apply a general controlled unitary (single control, single target), which can include a global phase factor.

The given unitary is applied to the target qubit if the control qubit has value 1, effecting the two-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\ & & u_{00} & u_{01}\\ & & u_{10} & u_{11} \end{pmatrix} \]

on the control and target qubits.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {U}; \end{tikzpicture} } \]


Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitapply unitary if this qubit is 1
[in]targetQubitqubit to operate on
[in]usingle-qubit unitary matrix to apply
Exceptions
invalidQuESTInputErrorif either controlQubit or targetQubit are outside [0, qureg.numQubitsRepresented) or are equal, or if u is not unitary.
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 361 of file QuEST.c.

361  {
362  validateControlTarget(qureg, controlQubit, targetQubit, __func__);
363  validateOneQubitUnitaryMatrix(u, __func__);
364 
365  statevec_controlledUnitary(qureg, controlQubit, targetQubit, u);
366  if (qureg.isDensityMatrix) {
367  int shift = qureg.numQubitsRepresented;
368  statevec_controlledUnitary(qureg, controlQubit+shift, targetQubit+shift, getConjugateMatrix2(u));
369  }
370 
371  qasm_recordControlledUnitary(qureg, u, controlQubit, targetQubit);
372 }

References getConjugateMatrix2(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledUnitary(), statevec_controlledUnitary(), validateControlTarget(), and validateOneQubitUnitaryMatrix().

Referenced by TEST_CASE().

◆ hadamard()

void hadamard ( Qureg  qureg,
int  targetQubit 
)

Apply the single-qubit Hadamard gate.

This takes $|0\rangle$ to $|+\rangle$ and $|1\rangle$ to $|-\rangle$, and is equivalent to a rotation of $\pi$ around the x-axis then $\pi/2$ about the y-axis on the Bloch-sphere. I.e.

\[ \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {H}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to operate on
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented).
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 177 of file QuEST.c.

177  {
178  validateTarget(qureg, targetQubit, __func__);
179 
180  statevec_hadamard(qureg, targetQubit);
181  if (qureg.isDensityMatrix) {
182  statevec_hadamard(qureg, targetQubit+qureg.numQubitsRepresented);
183  }
184 
185  qasm_recordGate(qureg, GATE_HADAMARD, targetQubit);
186 }

References GATE_HADAMARD, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordGate(), statevec_hadamard(), and validateTarget().

Referenced by TEST_CASE().

◆ multiControlledMultiQubitUnitary()

void multiControlledMultiQubitUnitary ( Qureg  qureg,
int *  ctrls,
int  numCtrls,
int *  targs,
int  numTargs,
ComplexMatrixN  u 
)

Apply a general multi-controlled multi-qubit unitary (including a global phase factor).

Any number of control and target qubits can be specified. This effects the many-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\\ & & \ddots \\ & & & u_{00} & u_{01} & \dots \\ & & & u_{10} & u_{11} & \dots \\ & & & \vdots & \vdots & \ddots \end{pmatrix} \]

on the control and target qubits.

The target qubits in targs are treated as ordered least significant to most significant in u.

The passed ComplexMatrix must be unitary and be a compatible size with the specified number of target qubits, otherwise an error is thrown.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 1) {targets}; \node[draw=none] at (-3.5, 5) {controls}; \node[draw=none] at (0, 8) {$\vdots$}; \draw (0, 7) -- (0, 6); \draw (-2, 6) -- (2, 6); \draw[fill=black] (0, 6) circle (.2); \draw (0, 6) -- (0, 4); \draw (-2, 4) -- (2, 4); \draw[fill=black] (0, 4) circle (.2); \draw(0, 4) -- (0, 3); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-2,2) -- (-1, 2); \draw (1, 2) -- (2, 2); \draw (-1,-1)--(-1,3)--(1,3)--(1,-1); \node[draw=none] at (0, 1) {U}; \node[draw=none] at (0, -1) {$\vdots$}; \end{tikzpicture} } \]

Note that in multithreaded mode, each thread will clone 2^numTargs amplitudes, and store these in the runtime stack. Using t threads, the total memory overhead of this function is t*2^numTargs. For many targets (e.g. 16 qubits), this may cause a stack-overflow / seg-fault (e.g. on a 1 MiB stack).

Note that in distributed mode, this routine requires that each node contains at least 2^numTargs amplitudes. This means an q-qubit register (state vector or density matrix) can be distributed by at most 2^q / 2^numTargs nodes.

Parameters
[in,out]quregobject representing the set of all qubits
[in]ctrlsa list of the control qubits
[in]numCtrlsthe number of control qubits
[in]targsa list of the target qubits, ordered least to most significant
[in]numTargsthe number of target qubits
[in]uunitary matrix to apply
Exceptions
invalidQuESTInputErrorif any index in ctrls and targs is outside of [0, qureg.numQubitsRepresented), or if ctrls and targs are not unique, or if matrix u is not unitary, or if a node cannot fit the required number of target amplitudes in distributed mode.
Author
Tyson Jones

Definition at line 331 of file QuEST.c.

331  {
332  validateMultiControlsMultiTargets(qureg, ctrls, numCtrls, targs, numTargs, __func__);
333  validateMultiQubitUnitaryMatrix(qureg, u, numTargs, __func__);
334 
335  long long int ctrlMask = getQubitBitMask(ctrls, numCtrls);
336  statevec_multiControlledMultiQubitUnitary(qureg, ctrlMask, targs, numTargs, u);
337  if (qureg.isDensityMatrix) {
338  int shift = qureg.numQubitsRepresented;
339  shiftIndices(targs, numTargs, shift);
341  statevec_multiControlledMultiQubitUnitary(qureg, ctrlMask<<shift, targs, numTargs, u);
342  shiftIndices(targs, numTargs, -shift);
344  }
345 
346  qasm_recordComment(qureg, "Here, an undisclosed multi-controlled multi-qubit unitary was applied.");
347 }

References getQubitBitMask(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordComment(), setConjugateMatrixN(), shiftIndices(), statevec_multiControlledMultiQubitUnitary(), validateMultiControlsMultiTargets(), and validateMultiQubitUnitaryMatrix().

Referenced by TEST_CASE().

◆ multiControlledPhaseFlip()

void multiControlledPhaseFlip ( Qureg  qureg,
int *  controlQubits,
int  numControlQubits 
)

Apply the multiple-qubit controlled phase flip gate, also known as the multiple-qubit controlled pauliZ gate.

For each state, if all control qubits have value one, multiply the amplitude of that state by -1. This applies the many-qubit unitary:

\[ \begin{pmatrix} 1 \\ & 1 \\\ & & \ddots \\ & & & 1 \\ & & & & -1 \end{pmatrix} \]

on the control qubits.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {controls}; \node[draw=none] at (0, 6) {$\vdots$}; \draw (0, 5) -- (0, 4); \draw (-2, 4) -- (2, 4); \draw[fill=black] (0, 4) circle (.2); \draw (0, 4) -- (0, 2); \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 0); \draw (-2,0) -- (2, 0); \draw[fill=black] (0, 0) circle (.2); \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitsarray of input qubits
[in]numControlQubitsnumber of input qubits
Exceptions
invalidQuESTInputErrorif numControlQubits is outside [1, qureg.numQubitsRepresented), or if any qubit in controlQubits is outside [0, qureg.numQubitsRepresented), or if any qubit in qubits is repeated.
Author
Tyson Jones

Definition at line 561 of file QuEST.c.

561  {
562  validateMultiQubits(qureg, controlQubits, numControlQubits, __func__);
563 
564  statevec_multiControlledPhaseFlip(qureg, controlQubits, numControlQubits);
565  if (qureg.isDensityMatrix) {
566  int shift = qureg.numQubitsRepresented;
567  shiftIndices(controlQubits, numControlQubits, shift);
568  statevec_multiControlledPhaseFlip(qureg, controlQubits, numControlQubits);
569  shiftIndices(controlQubits, numControlQubits, -shift);
570  }
571 
572  qasm_recordMultiControlledGate(qureg, GATE_SIGMA_Z, controlQubits, numControlQubits-1, controlQubits[numControlQubits-1]);
573 }

References GATE_SIGMA_Z, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordMultiControlledGate(), shiftIndices(), statevec_multiControlledPhaseFlip(), and validateMultiQubits().

Referenced by TEST_CASE().

◆ multiControlledPhaseShift()

void multiControlledPhaseShift ( Qureg  qureg,
int *  controlQubits,
int  numControlQubits,
qreal  angle 
)

Introduce a phase factor $ \exp(i \theta) $ on state $ |1 \dots 1 \rangle $ of the passed qubits.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {controls}; \node[draw=none] at (1, .7) {$\theta$}; \node[draw=none] at (0, 6) {$\vdots$}; \draw (0, 5) -- (0, 4); \draw (-2, 4) -- (2, 4); \draw[fill=black] (0, 4) circle (.2); \draw (0, 4) -- (0, 2); \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 0); \draw (-2,0) -- (2, 0); \draw[fill=black] (0, 0) circle (.2); \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitsarray of qubits to phase shift
[in]numControlQubitsthe length of array controlQubits
[in]angleamount by which to shift the phase in radians
Exceptions
invalidQuESTInputErrorif numControlQubits is outside [1, qureg.numQubitsRepresented]), or if any qubit index in controlQubits is outside [0, qureg.numQubitsRepresented]), or if any qubit in controlQubits is repeated.
Author
Tyson Jones

Definition at line 511 of file QuEST.c.

511  {
512  validateMultiQubits(qureg, controlQubits, numControlQubits, __func__);
513 
514  statevec_multiControlledPhaseShift(qureg, controlQubits, numControlQubits, angle);
515  if (qureg.isDensityMatrix) {
516  int shift = qureg.numQubitsRepresented;
517  shiftIndices(controlQubits, numControlQubits, shift);
518  statevec_multiControlledPhaseShift(qureg, controlQubits, numControlQubits, -angle);
519  shiftIndices(controlQubits, numControlQubits, -shift);
520  }
521 
522  qasm_recordMultiControlledParamGate(qureg, GATE_PHASE_SHIFT, controlQubits, numControlQubits-1, controlQubits[numControlQubits-1], angle);
523 }

References GATE_PHASE_SHIFT, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordMultiControlledParamGate(), shiftIndices(), statevec_multiControlledPhaseShift(), and validateMultiQubits().

Referenced by TEST_CASE().

◆ multiControlledTwoQubitUnitary()

void multiControlledTwoQubitUnitary ( Qureg  qureg,
int *  controlQubits,
int  numControlQubits,
int  targetQubit1,
int  targetQubit2,
ComplexMatrix4  u 
)

Apply a general multi-controlled two-qubit unitary (including a global phase factor).

Any number of control qubits can be specified, and if all have value 1, the given unitary is applied to the target qubit. This effects the many-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\\ & & \ddots \\ & & & u_{00} & u_{01} & u_{02} & u_{03} \\ & & & u_{10} & u_{11} & u_{12} & u_{13} \\ & & & u_{20} & u_{21} & u_{22} & u_{23} \\ & & & u_{30} & u_{31} & u_{32} & u_{33} \end{pmatrix} \]

on the control and target qubits.

targetQubit1 is treated as the least significant qubit in u, such that a row in u is dotted with the vector $ |\text{targetQubit2} \;\; \text{targetQubit1}\rangle : \{ |00\rangle, |01\rangle, |10\rangle, |11\rangle \} $

The passed 4x4 ComplexMatrix must be unitary, otherwise an error is thrown.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target1}; \node[draw=none] at (-3.5, 2) {target2}; \node[draw=none] at (-3.5, 5) {controls}; \node[draw=none] at (0, 8) {$\vdots$}; \draw (0, 7) -- (0, 6); \draw (-2, 6) -- (2, 6); \draw[fill=black] (0, 6) circle (.2); \draw (0, 6) -- (0, 4); \draw (-2, 4) -- (2, 4); \draw[fill=black] (0, 4) circle (.2); \draw(0, 4) -- (0, 3); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-2,2) -- (-1, 2); \draw (1, 2) -- (2, 2); \draw (-1,-1)--(-1,3)--(1,3)--(1,-1)--cycle; \node[draw=none] at (0, 1) {U}; \end{tikzpicture} } \]

Note that in distributed mode, this routine requires that each node contains at least 4 amplitudes. This means an q-qubit register (state vector or density matrix) can be distributed by at most 2^q/4 nodes.

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitsthe control qubits which all must be in state 1 to effect the given unitary
[in]numControlQubitsthe number of control qubits
[in]targetQubit1first target qubit, treated as least significant in u
[in]targetQubit2second target qubit, treated as most significant in u
[in]uunitary matrix to apply
Exceptions
invalidQuESTInputErrorif targetQubit1 or targetQubit2 are outside [0, qureg.numQubitsRepresented), or if targetQubit1 equals targetQubit2, or if any qubit in controlQubits is outside [0, qureg.numQubitsRepresented), or if controlQubits are not unique, or if either targetQubit1 and targetQubit2 are in controlQubits, or if matrix u is not unitary, or if each node cannot fit 4 amplitudes in distributed mode.
Author
Tyson Jones

Definition at line 283 of file QuEST.c.

283  {
284  validateMultiControlsMultiTargets(qureg, controlQubits, numControlQubits, (int[]) {targetQubit1, targetQubit2}, 2, __func__);
285  validateTwoQubitUnitaryMatrix(qureg, u, __func__);
286 
287  long long int ctrlQubitsMask = getQubitBitMask(controlQubits, numControlQubits);
288  statevec_multiControlledTwoQubitUnitary(qureg, ctrlQubitsMask, targetQubit1, targetQubit2, u);
289  if (qureg.isDensityMatrix) {
290  int shift = qureg.numQubitsRepresented;
291  statevec_multiControlledTwoQubitUnitary(qureg, ctrlQubitsMask<<shift, targetQubit1+shift, targetQubit2+shift, getConjugateMatrix4(u));
292  }
293 
294  qasm_recordComment(qureg, "Here, an undisclosed multi-controlled 2-qubit unitary was applied.");
295 }

References getConjugateMatrix4(), getQubitBitMask(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordComment(), statevec_multiControlledTwoQubitUnitary(), validateMultiControlsMultiTargets(), and validateTwoQubitUnitaryMatrix().

Referenced by TEST_CASE().

◆ multiControlledUnitary()

void multiControlledUnitary ( Qureg  qureg,
int *  controlQubits,
int  numControlQubits,
int  targetQubit,
ComplexMatrix2  u 
)

Apply a general multiple-control single-target unitary, which can include a global phase factor.

Any number of control qubits can be specified, and if all have value 1, the given unitary is applied to the target qubit. This effects the many-qubit unitary

\[ \begin{pmatrix} 1 \\ & 1 \\\ & & \ddots \\ & & & u_{00} & u_{01}\\ & & & u_{10} & u_{11} \end{pmatrix} \]

on the control and target qubits. The given 2x2 ComplexMatrix must be unitary, otherwise an error is thrown.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 3) {controls}; \node[draw=none] at (-3.5, 0) {target}; \node[draw=none] at (0, 6) {$\vdots$}; \draw (0, 5) -- (0, 4); \draw (-2, 4) -- (2, 4); \draw[fill=black] (0, 4) circle (.2); \draw (0, 4) -- (0, 2); \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {U}; \end{tikzpicture} } \]


Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitsapplies unitary if all qubits in this array equal 1
[in]numControlQubitsnumber of control qubits
[in]targetQubitqubit to operate on
[in]usingle-qubit unitary matrix to apply
Exceptions
invalidQuESTInputErrorif numControlQubits is outside [1, qureg.numQubitsRepresented]), or if any qubit index (targetQubit or one in controlQubits) is outside [0, qureg.numQubitsRepresented]), or if any qubit in controlQubits is repeated, or if controlQubits contains targetQubit, or if u is not unitary.
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 374 of file QuEST.c.

374  {
375  validateMultiControlsTarget(qureg, controlQubits, numControlQubits, targetQubit, __func__);
376  validateOneQubitUnitaryMatrix(u, __func__);
377 
378  long long int ctrlQubitsMask = getQubitBitMask(controlQubits, numControlQubits);
379  long long int ctrlFlipMask = 0;
380  statevec_multiControlledUnitary(qureg, ctrlQubitsMask, ctrlFlipMask, targetQubit, u);
381  if (qureg.isDensityMatrix) {
382  int shift = qureg.numQubitsRepresented;
383  statevec_multiControlledUnitary(qureg, ctrlQubitsMask<<shift, ctrlFlipMask<<shift, targetQubit+shift, getConjugateMatrix2(u));
384  }
385 
386  qasm_recordMultiControlledUnitary(qureg, u, controlQubits, numControlQubits, targetQubit);
387 }

References getConjugateMatrix2(), getQubitBitMask(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordMultiControlledUnitary(), statevec_multiControlledUnitary(), validateMultiControlsTarget(), and validateOneQubitUnitaryMatrix().

Referenced by TEST_CASE().

◆ multiQubitUnitary()

void multiQubitUnitary ( Qureg  qureg,
int *  targs,
int  numTargs,
ComplexMatrixN  u 
)

Apply a general multi-qubit unitary (including a global phase factor) with any number of target qubits.

The first target qubit in targs is treated as least significant in u. For example,

multiQubitUnitary(qureg, (int []) {a, b, c}, 3, u);

will invoke multiplication

\[ \begin{pmatrix} u_{00} & u_{01} & u_{02} & u_{03} & u_{04} & u_{05} & u_{06} & u_{07} \\ u_{10} & u_{11} & u_{12} & u_{13} & u_{14} & u_{15} & u_{16} & u_{17} \\ u_{20} & u_{21} & u_{22} & u_{23} & u_{24} & u_{25} & u_{26} & u_{27} \\ u_{30} & u_{31} & u_{32} & u_{33} & u_{34} & u_{35} & u_{36} & u_{37} \\ u_{40} & u_{41} & u_{42} & u_{43} & u_{44} & u_{45} & u_{46} & u_{47} \\ u_{50} & u_{51} & u_{52} & u_{53} & u_{54} & u_{55} & u_{56} & u_{57} \\ u_{60} & u_{61} & u_{62} & u_{63} & u_{64} & u_{65} & u_{66} & u_{67} \\ u_{70} & u_{71} & u_{72} & u_{73} & u_{74} & u_{75} & u_{76} & u_{77} \\ \end{pmatrix} \begin{pmatrix} |cba\rangle = |000\rangle \\ |cba\rangle = |001\rangle \\ |cba\rangle = |010\rangle \\ |cba\rangle = |011\rangle \\ |cba\rangle = |100\rangle \\ |cba\rangle = |101\rangle \\ |cba\rangle = |110\rangle \\ |cba\rangle = |111\rangle \end{pmatrix} \]

The passed ComplexMatrix must be unitary and be a compatible size with the specified number of target qubits, otherwise an error is thrown.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 1) {targets}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-2,2) -- (-1, 2); \draw (1, 2) -- (2, 2); \draw (-1,-1)--(-1,3)--(1,3)--(1,-1); \node[draw=none] at (0, 1) {U}; \node[draw=none] at (0, -1) {$\vdots$}; \end{tikzpicture} } \]

Note that in multithreaded mode, each thread will clone 2^numTargs amplitudes, and store these in the runtime stack. Using t threads, the total memory overhead of this function is t*2^numTargs. For many targets (e.g. 16 qubits), this may cause a stack-overflow / seg-fault (e.g. on a 1 MiB stack).

Note too that in distributed mode, this routine requires that each node contains at least 2^numTargs amplitudes in the register. This means an q-qubit register (state vector or density matrix) can be distributed by at most 2^q / 2^numTargs nodes.

Parameters
[in,out]quregobject representing the set of all qubits
[in]targsa list of the target qubits, ordered least significant to most in u
[in]numTargsthe number of target qubits
[in]uunitary matrix to apply
Exceptions
invalidQuESTInputErrorif any index in targs is outside of [0, qureg.numQubitsRepresented), or if targs are not unique, or if matrix u is not unitary, or if u is not of a compatible size with numTargs, or if a node cannot fit the required number of target amplitudes in distributed mode.
Author
Tyson Jones

Definition at line 297 of file QuEST.c.

297  {
298  validateMultiTargets(qureg, targs, numTargs, __func__);
299  validateMultiQubitUnitaryMatrix(qureg, u, numTargs, __func__);
300 
301  statevec_multiQubitUnitary(qureg, targs, numTargs, u);
302  if (qureg.isDensityMatrix) {
303  int shift = qureg.numQubitsRepresented;
304  shiftIndices(targs, numTargs, shift);
306  statevec_multiQubitUnitary(qureg, targs, numTargs, u);
307  shiftIndices(targs, numTargs, -shift);
309  }
310 
311  qasm_recordComment(qureg, "Here, an undisclosed multi-qubit unitary was applied.");
312 }

References Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordComment(), setConjugateMatrixN(), shiftIndices(), statevec_multiQubitUnitary(), validateMultiQubitUnitaryMatrix(), and validateMultiTargets().

Referenced by TEST_CASE().

◆ multiRotatePauli()

void multiRotatePauli ( Qureg  qureg,
int *  targetQubits,
enum pauliOpType targetPaulis,
int  numTargets,
qreal  angle 
)

Apply a multi-qubit multi-Pauli rotation on a selected number of qubits.

This is the unitary

\[ \exp \left( - i \theta/2 \bigotimes_{j} \hat{\sigma}_j\right) \]

where $\hat{\sigma}_j \in \{X, Y, Z\}$ is a Pauli operator (indicated by codes 1, 2, 3 respectively in targetPaulis, or by enums PAULI_X, PAULI_Y and PAULI_Z) operating upon the qubit targetQubits[j], and $\theta$ is the passed angle. The operators specified in targetPaulis act on the corresponding qubit in targetQubits. For example:

multiRotatePauli(qureg, (int[]) {4,5,8,9}, (int[]) {0,1,2,3}, 4, .1)

effects

\[ \exp \left( - i .1/2 X_5 Y_8 Z_9 \right) \]

on qureg, where unspecified qubits (along with those specified with Pauli code 0) are assumed to receive the identity operator (excluded from exponentiation). Note that specifying the identity Pauli (code=0 or PAULI_I) on a qubit is superfluous but allowed for convenience. This is means a global phase factor of $ exp(-i \theta/2) $ is NOT induced by supplying 0 pauli-codes. Hence, if all targetPaulis are identity, then this function does nothing to qureg.

This function effects this unitary by first rotating the qubits which are nominated to receive X or Y Paulis into alternate basis, performing multiRotateZ on all target qubits receiving X, Y or Z Paulis, then restoring the original basis. In the worst case, this means that 1+2*numTargets primitive unitaries are performed on the statevector, and double this on density matrices.

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitsa list of the indices of the target qubits
[in]targetPaulisa list of the Pauli codes (0=PAULI_I, 1=PAULI_X, 2=PAULI_Y, 3=PAULI_Z) to apply to the corresponding qubits in targetQubits
[in]numTargetsnumber of target qubits, i.e. the length of targetQubits and targetPaulis
[in]anglethe angle by which the multi-qubit state is rotated
Exceptions
invalidQuESTInputErrorif numQubits is outside [1, qureg.numQubitsRepresented]), or if any qubit in qubits is outside [0, qureg.numQubitsRepresented)) or if any qubit in qubits is repeated.
Author
Tyson Jones

Definition at line 642 of file QuEST.c.

642  {
643  validateMultiTargets(qureg, targetQubits, numTargets, __func__);
644  validatePauliCodes(targetPaulis, numTargets, __func__);
645 
646  int conj=0;
647  statevec_multiRotatePauli(qureg, targetQubits, targetPaulis, numTargets, angle, conj);
648  if (qureg.isDensityMatrix) {
649  conj = 1;
650  int shift = qureg.numQubitsRepresented;
651  shiftIndices(targetQubits, numTargets, shift);
652  statevec_multiRotatePauli(qureg, targetQubits, targetPaulis, numTargets, angle, conj);
653  shiftIndices(targetQubits, numTargets, -shift);
654  }
655 
656  // @TODO: create actual QASM
657  qasm_recordComment(qureg,
658  "Here a %d-qubit multiRotatePauli of angle %g was performed (QASM not yet implemented)",
659  numTargets, angle);
660 }

References Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordComment(), shiftIndices(), statevec_multiRotatePauli(), validateMultiTargets(), and validatePauliCodes().

Referenced by TEST_CASE().

◆ multiRotateZ()

void multiRotateZ ( Qureg  qureg,
int *  qubits,
int  numQubits,
qreal  angle 
)

Apply a multi-qubit Z rotation on a selected number of qubits.

This is the unitary

\[ \exp \left( - i \theta/2 \bigotimes_{j} Z_j\right) \]

where the Pauli Z gates operate upon the passed list $j \in$ qubits, and cause rotations of $\theta =$ angle. All qubits not appearing in qubits are assumed to receive the identity operator. This has the effect of premultiplying every amplitude with $\exp(\pm i \theta/2)$ where the sign is determined by the parity of the target qubits for that amplitude.

Parameters
[in,out]quregobject representing the set of all qubits
[in]qubitsa list of the indices of the target qubits
[in]numQubitsnumber of target qubits
[in]anglethe angle by which the multi-qubit state is rotated around the Z axis
Exceptions
invalidQuESTInputErrorif numQubits is outside [1, qureg.numQubitsRepresented]), or if any qubit in qubits is outside [0, qureg.numQubitsRepresented]) or if any qubit in qubits is repeated.
Author
Tyson Jones

Definition at line 626 of file QuEST.c.

626  {
627  validateMultiTargets(qureg, qubits, numQubits, __func__);
628 
629  long long int mask = getQubitBitMask(qubits, numQubits);
630  statevec_multiRotateZ(qureg, mask, angle);
631  if (qureg.isDensityMatrix) {
632  int shift = qureg.numQubitsRepresented;
633  statevec_multiRotateZ(qureg, mask << shift, -angle);
634  }
635 
636  // @TODO: create actual QASM
637  qasm_recordComment(qureg,
638  "Here a %d-qubit multiRotateZ of angle %g was performed (QASM not yet implemented)",
639  numQubits, angle);
640 }

References getQubitBitMask(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordComment(), statevec_multiRotateZ(), and validateMultiTargets().

Referenced by TEST_CASE().

◆ multiStateControlledUnitary()

void multiStateControlledUnitary ( Qureg  qureg,
int *  controlQubits,
int *  controlState,
int  numControlQubits,
int  targetQubit,
ComplexMatrix2  u 
)

Apply a general multiple-control, conditioned on a specific bit sequence, single-target unitary, which can include a global phase factor.

Any number of control qubits can be specified, along with which of their states (0 or 1) to condition upon; when the specified controls are in the specified state, the given unitary is applied to the target qubit. This is equivalent to NOTing the control bits which are conditioned on 0, calling multiControlledUnitary then NOTing the same control bits.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 3) {controls}; \node[draw=none] at (-3.5, 0) {target}; \node[draw=none] at (0, 6) {$\vdots$}; \draw (0, 5) -- (0, 4); \draw (-2, 4) -- (2, 4); \draw[fill=black] (0, 4) circle (.2); \draw (0, 4) -- (0, 2); \draw (-2, 2) -- (2, 2); \draw[fill=white] (0, 2) circle (.2); \draw (0, 2-.2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {U}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]controlQubitsthe indices of the control qubits
[in]controlStatethe bit values (0 or 1) of each control qubit, upon which to condition
[in]numControlQubitsnumber of control qubits
[in]targetQubitqubit to operate the unitary upon
[in]usingle-qubit unitary matrix to apply
Exceptions
invalidQuESTInputErrorif numControlQubits is outside [1, qureg.numQubitsRepresented]), or if any qubit index (targetQubit or one in controlQubits) is outside [0, qureg.numQubitsRepresented]), or if any qubit in controlQubits is repeated., or if controlQubits contains targetQubit, or if any element of controlState is not a bit (0 or 1), or if u is not unitary.
Author
Tyson Jones

Definition at line 389 of file QuEST.c.

389  {
390  validateMultiControlsTarget(qureg, controlQubits, numControlQubits, targetQubit, __func__);
391  validateOneQubitUnitaryMatrix(u, __func__);
392  validateControlState(controlState, numControlQubits, __func__);
393 
394  long long int ctrlQubitsMask = getQubitBitMask(controlQubits, numControlQubits);
395  long long int ctrlFlipMask = getControlFlipMask(controlQubits, controlState, numControlQubits);
396  statevec_multiControlledUnitary(qureg, ctrlQubitsMask, ctrlFlipMask, targetQubit, u);
397  if (qureg.isDensityMatrix) {
398  int shift = qureg.numQubitsRepresented;
399  statevec_multiControlledUnitary(qureg, ctrlQubitsMask<<shift, ctrlFlipMask<<shift, targetQubit+shift, getConjugateMatrix2(u));
400  }
401 
402  qasm_recordMultiStateControlledUnitary(qureg, u, controlQubits, controlState, numControlQubits, targetQubit);
403 }

References getConjugateMatrix2(), getControlFlipMask(), getQubitBitMask(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordMultiStateControlledUnitary(), statevec_multiControlledUnitary(), validateControlState(), validateMultiControlsTarget(), and validateOneQubitUnitaryMatrix().

Referenced by TEST_CASE().

◆ pauliX()

void pauliX ( Qureg  qureg,
int  targetQubit 
)

Apply the single-qubit Pauli-X (also known as the X, sigma-X, NOT or bit-flip) gate.

This is a rotation of $\pi$ around the x-axis on the Bloch sphere. I.e.

\[ \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (2, 0); \draw (0, 0) circle (.5); \draw (0, .5) -- (0, -.5); \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to operate on
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented).
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 433 of file QuEST.c.

433  {
434  validateTarget(qureg, targetQubit, __func__);
435 
436  statevec_pauliX(qureg, targetQubit);
437  if (qureg.isDensityMatrix) {
438  statevec_pauliX(qureg, targetQubit+qureg.numQubitsRepresented);
439  }
440 
441  qasm_recordGate(qureg, GATE_SIGMA_X, targetQubit);
442 }

References GATE_SIGMA_X, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordGate(), statevec_pauliX(), and validateTarget().

Referenced by TEST_CASE().

◆ pauliY()

void pauliY ( Qureg  qureg,
int  targetQubit 
)

Apply the single-qubit Pauli-Y (also known as the Y or sigma-Y) gate.

This is a rotation of $\pi$ around the Y-axis on the Bloch sphere. I.e.

\[ \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$\sigma_y$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to operate on
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented).
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 444 of file QuEST.c.

444  {
445  validateTarget(qureg, targetQubit, __func__);
446 
447  statevec_pauliY(qureg, targetQubit);
448  if (qureg.isDensityMatrix) {
449  statevec_pauliYConj(qureg, targetQubit + qureg.numQubitsRepresented);
450  }
451 
452  qasm_recordGate(qureg, GATE_SIGMA_Y, targetQubit);
453 }

References GATE_SIGMA_Y, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordGate(), statevec_pauliY(), statevec_pauliYConj(), and validateTarget().

Referenced by TEST_CASE().

◆ pauliZ()

void pauliZ ( Qureg  qureg,
int  targetQubit 
)

Apply the single-qubit Pauli-Z (also known as the Z, sigma-Z or phase-flip) gate.

This is a rotation of $\pi$ around the Z-axis (a phase shift) on the Bloch sphere. I.e.

\[ \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$\sigma_z$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to operate on
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented).
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 455 of file QuEST.c.

455  {
456  validateTarget(qureg, targetQubit, __func__);
457 
458  statevec_pauliZ(qureg, targetQubit);
459  if (qureg.isDensityMatrix) {
460  statevec_pauliZ(qureg, targetQubit+qureg.numQubitsRepresented);
461  }
462 
463  qasm_recordGate(qureg, GATE_SIGMA_Z, targetQubit);
464 }

References GATE_SIGMA_Z, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordGate(), statevec_pauliZ(), and validateTarget().

Referenced by TEST_CASE().

◆ phaseShift()

void phaseShift ( Qureg  qureg,
int  targetQubit,
qreal  angle 
)

Shift the phase between $ |0\rangle $ and $ |1\rangle $ of a single qubit by a given angle.

This is equivalent to a rotation Z-axis of the Bloch-sphere up to a global phase factor. For angle $\theta$, applies

\[ \begin{pmatrix} 1 & 0 \\ 0 & \exp(i \theta) \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {rot}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_\theta$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to undergo a phase shift
[in]angleamount by which to shift the phase in radians
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented).
Author
Tyson Jones

Definition at line 488 of file QuEST.c.

488  {
489  validateTarget(qureg, targetQubit, __func__);
490 
491  statevec_phaseShift(qureg, targetQubit, angle);
492  if (qureg.isDensityMatrix) {
493  statevec_phaseShift(qureg, targetQubit+qureg.numQubitsRepresented, -angle);
494  }
495 
496  qasm_recordParamGate(qureg, GATE_PHASE_SHIFT, targetQubit, angle);
497 }

References GATE_PHASE_SHIFT, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordParamGate(), statevec_phaseShift(), and validateTarget().

Referenced by TEST_CASE().

◆ rotateAroundAxis()

void rotateAroundAxis ( Qureg  qureg,
int  rotQubit,
qreal  angle,
Vector  axis 
)

Rotate a single qubit by a given angle around a given Vector on the Bloch-sphere.


The vector must not be zero (else an error is thrown), but needn't be unit magnitude, since it will be normalised by QuEST.

For angle $\theta$ and axis vector $\vec{n}$, applies $R_{\hat{n}} = \exp \left(- i \frac{\theta}{2} \hat{n} \cdot \vec{\sigma} \right) $ where $\vec{\sigma}$ is the vector of Pauli matrices.

Parameters
[in,out]quregobject representing the set of all qubits
[in]rotQubitqubit to rotate
[in]angleangle by which to rotate in radians
[in]axisvector around which to rotate (can be non-unit; will be normalised)
Exceptions
invalidQuESTInputErrorif rotQubit is outside [0, qureg.numQubitsRepresented), or if axis is the zero vector
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 575 of file QuEST.c.

575  {
576  validateTarget(qureg, rotQubit, __func__);
577  validateVector(axis, __func__);
578 
579  statevec_rotateAroundAxis(qureg, rotQubit, angle, axis);
580  if (qureg.isDensityMatrix) {
581  int shift = qureg.numQubitsRepresented;
582  statevec_rotateAroundAxisConj(qureg, rotQubit+shift, angle, axis);
583  }
584 
585  qasm_recordAxisRotation(qureg, angle, axis, rotQubit);
586 }

References Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordAxisRotation(), statevec_rotateAroundAxis(), statevec_rotateAroundAxisConj(), validateTarget(), and validateVector().

Referenced by TEST_CASE().

◆ rotateX()

void rotateX ( Qureg  qureg,
int  rotQubit,
qreal  angle 
)

Rotate a single qubit by a given angle around the X-axis of the Bloch-sphere.

For angle $\theta$, applies

\[ \begin{pmatrix} \cos\theta/2 & -i \sin \theta/2\\ -i \sin \theta/2 & \cos \theta/2 \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {rot}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_x(\theta)$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]rotQubitqubit to rotate
[in]angleangle by which to rotate in radians
Exceptions
invalidQuESTInputErrorif rotQubit is outside [0, qureg.numQubitsRepresented).
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 188 of file QuEST.c.

188  {
189  validateTarget(qureg, targetQubit, __func__);
190 
191  statevec_rotateX(qureg, targetQubit, angle);
192  if (qureg.isDensityMatrix) {
193  statevec_rotateX(qureg, targetQubit+qureg.numQubitsRepresented, -angle);
194  }
195 
196  qasm_recordParamGate(qureg, GATE_ROTATE_X, targetQubit, angle);
197 }

References GATE_ROTATE_X, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordParamGate(), statevec_rotateX(), and validateTarget().

Referenced by TEST_CASE().

◆ rotateY()

void rotateY ( Qureg  qureg,
int  rotQubit,
qreal  angle 
)

Rotate a single qubit by a given angle around the Y-axis of the Bloch-sphere.

For angle $\theta$, applies

\[ \begin{pmatrix} \cos\theta/2 & - \sin \theta/2\\ \sin \theta/2 & \cos \theta/2 \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {rot}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_y(\theta)$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]rotQubitqubit to rotate
[in]angleangle by which to rotate in radians
Exceptions
invalidQuESTInputErrorif rotQubit is outside [0, qureg.numQubitsRepresented).
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc, debug)

Definition at line 199 of file QuEST.c.

199  {
200  validateTarget(qureg, targetQubit, __func__);
201 
202  statevec_rotateY(qureg, targetQubit, angle);
203  if (qureg.isDensityMatrix) {
204  statevec_rotateY(qureg, targetQubit+qureg.numQubitsRepresented, angle);
205  }
206 
207  qasm_recordParamGate(qureg, GATE_ROTATE_Y, targetQubit, angle);
208 }

References GATE_ROTATE_Y, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordParamGate(), statevec_rotateY(), and validateTarget().

Referenced by TEST_CASE().

◆ rotateZ()

void rotateZ ( Qureg  qureg,
int  rotQubit,
qreal  angle 
)

Rotate a single qubit by a given angle around the Z-axis of the Bloch-sphere (also known as a phase shift gate).


For angle $\theta$, applies

\[ \begin{pmatrix} \exp(-i \theta/2) & 0 \\ 0 & \exp(i \theta/2) \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {rot}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_z(\theta)$}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]rotQubitqubit to rotate
[in]angleangle by which to rotate in radians
Exceptions
invalidQuESTInputErrorif rotQubit is outside [0, qureg.numQubitsRepresented).
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 210 of file QuEST.c.

210  {
211  validateTarget(qureg, targetQubit, __func__);
212 
213  statevec_rotateZ(qureg, targetQubit, angle);
214  if (qureg.isDensityMatrix) {
215  statevec_rotateZ(qureg, targetQubit+qureg.numQubitsRepresented, -angle);
216  }
217 
218  qasm_recordParamGate(qureg, GATE_ROTATE_Z, targetQubit, angle);
219 }

References GATE_ROTATE_Z, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordParamGate(), statevec_rotateZ(), and validateTarget().

Referenced by TEST_CASE().

◆ sGate()

void sGate ( Qureg  qureg,
int  targetQubit 
)

Apply the single-qubit S gate.

This is a rotation of $\pi/2$ around the Z-axis on the Bloch sphere, or the unitary:

\[ \begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {S}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to operate upon
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented)
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 466 of file QuEST.c.

466  {
467  validateTarget(qureg, targetQubit, __func__);
468 
469  statevec_sGate(qureg, targetQubit);
470  if (qureg.isDensityMatrix) {
471  statevec_sGateConj(qureg, targetQubit+qureg.numQubitsRepresented);
472  }
473 
474  qasm_recordGate(qureg, GATE_S, targetQubit);
475 }

References GATE_S, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordGate(), statevec_sGate(), statevec_sGateConj(), and validateTarget().

Referenced by TEST_CASE().

◆ sqrtSwapGate()

void sqrtSwapGate ( Qureg  qureg,
int  qb1,
int  qb2 
)

Performs a sqrt SWAP gate between qubit1 and qubit2.

This effects

\[ \begin{pmatrix} 1 \\ & \frac{1}{2}(1+i) & \frac{1}{2}(1-i) \\\ & \frac{1}{2}(1-i) & \frac{1}{2}(1+i) \\ & & & 1 \end{pmatrix} \]

on the designated qubits, though is performed internally by three CNOT gates.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {qubit1}; \node[draw=none] at (-3.5, 0) {qubit2}; \draw (-2, 2) -- (2, 2); \draw (0, 2) -- (0, 0); \draw (-2,0) -- (2, 0); \draw (-.35,-.35) -- (.35,.35); \draw (-.35,.35) -- (.35,-.35); \draw (-.35,-.35 + 2) -- (.35,.35 + 2); \draw (-.35,.35 + 2) -- (.35,-.35 + 2); \draw[fill=white] (0, 1) circle (.5); \node[draw=none] at (0, 1) {1/2}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]qubit1qubit to sqrt swap
[in]qubit2other qubit to sqrt swap
Exceptions
invalidQuESTInputErrorif either qubit1 or qubit2 are outside [0, qureg.numQubitsRepresented), or are equal.
Author
Tyson Jones

Definition at line 613 of file QuEST.c.

613  {
614  validateUniqueTargets(qureg, qb1, qb2, __func__);
615  validateMultiQubitMatrixFitsInNode(qureg, 2, __func__); // uses 2qb unitary in QuEST_common
616 
617  statevec_sqrtSwapGate(qureg, qb1, qb2);
618  if (qureg.isDensityMatrix) {
619  int shift = qureg.numQubitsRepresented;
620  statevec_sqrtSwapGateConj(qureg, qb1+shift, qb2+shift);
621  }
622 
623  qasm_recordControlledGate(qureg, GATE_SQRT_SWAP, qb1, qb2);
624 }

References GATE_SQRT_SWAP, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledGate(), statevec_sqrtSwapGate(), statevec_sqrtSwapGateConj(), validateMultiQubitMatrixFitsInNode(), and validateUniqueTargets().

Referenced by TEST_CASE().

◆ swapGate()

void swapGate ( Qureg  qureg,
int  qubit1,
int  qubit2 
)

Performs a SWAP gate between qubit1 and qubit2.

This effects

\[ \begin{pmatrix} 1 \\ & & 1 \\\ & 1 \\ & & & 1 \end{pmatrix} \]

on the designated qubits, though is performed internally by three CNOT gates.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {qubit1}; \node[draw=none] at (-3.5, 0) {qubit2}; \draw (-2, 2) -- (2, 2); \draw (0, 2) -- (0, 0); \draw (-2,0) -- (2, 0); \draw (-.35,-.35) -- (.35,.35); \draw (-.35,.35) -- (.35,-.35); \draw (-.35,-.35 + 2) -- (.35,.35 + 2); \draw (-.35,.35 + 2) -- (.35,-.35 + 2); \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]qubit1qubit to swap
[in]qubit2other qubit to swap
Exceptions
invalidQuESTInputErrorif either qubit1 or qubit2 are outside [0, qureg.numQubitsRepresented), or are equal.
Author
Tyson Jones

Definition at line 601 of file QuEST.c.

601  {
602  validateUniqueTargets(qureg, qb1, qb2, __func__);
603 
604  statevec_swapQubitAmps(qureg, qb1, qb2);
605  if (qureg.isDensityMatrix) {
606  int shift = qureg.numQubitsRepresented;
607  statevec_swapQubitAmps(qureg, qb1+shift, qb2+shift);
608  }
609 
610  qasm_recordControlledGate(qureg, GATE_SWAP, qb1, qb2);
611 }

References GATE_SWAP, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordControlledGate(), statevec_swapQubitAmps(), and validateUniqueTargets().

Referenced by TEST_CASE().

◆ tGate()

void tGate ( Qureg  qureg,
int  targetQubit 
)

Apply the single-qubit T gate.

This is a rotation of $\pi/4$ around the Z-axis on the Bloch sphere, or the unitary:

\[ \begin{pmatrix} 1 & 0 \\ 0 & \exp\left(i \frac{\pi}{4}\right) \end{pmatrix} \]

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {T}; \end{tikzpicture} } \]

Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to operate upon
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented)
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 477 of file QuEST.c.

477  {
478  validateTarget(qureg, targetQubit, __func__);
479 
480  statevec_tGate(qureg, targetQubit);
481  if (qureg.isDensityMatrix) {
482  statevec_tGateConj(qureg, targetQubit+qureg.numQubitsRepresented);
483  }
484 
485  qasm_recordGate(qureg, GATE_T, targetQubit);
486 }

References GATE_T, Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordGate(), statevec_tGate(), statevec_tGateConj(), and validateTarget().

Referenced by TEST_CASE().

◆ twoQubitUnitary()

void twoQubitUnitary ( Qureg  qureg,
int  targetQubit1,
int  targetQubit2,
ComplexMatrix4  u 
)

Apply a general two-qubit unitary (including a global phase factor).

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target2}; \node[draw=none] at (-3.5, 2) {target1}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-2,2) -- (-1, 2); \draw (1, 2) -- (2, 2); \draw (-1,-1)--(-1,3)--(1,3)--(1,-1)--cycle; \node[draw=none] at (0, 1) {U}; \end{tikzpicture} } \]

targetQubit1 is treated as the least significant qubit in u, such that a row in u is dotted with the vector $ |\text{targetQubit2} \;\; \text{targetQubit1}\rangle : \{ |00\rangle, |01\rangle, |10\rangle, |11\rangle \} $

For example,

twoQubitUnitary(qureg, a, b, u);

will invoke multiplication

\[ \begin{pmatrix} u_{00} & u_{01} & u_{02} & u_{03} \\ u_{10} & u_{11} & u_{12} & u_{13} \\ u_{20} & u_{21} & u_{22} & u_{23} \\ u_{30} & u_{31} & u_{32} & u_{33} \end{pmatrix} \begin{pmatrix} |ba\rangle = |00\rangle \\ |ba\rangle = |01\rangle \\ |ba\rangle = |10\rangle \\ |ba\rangle = |11\rangle \end{pmatrix} \]

The passed 4x4 ComplexMatrix must be unitary, otherwise an error is thrown.

Note that in distributed mode, this routine requires that each node contains at least 4 amplitudes. This means an q-qubit register (state vector or density matrix) can be distributed by at most 2^q/4 nodes.


Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubit1first qubit to operate on, treated as least significant in u
[in]targetQubit2second qubit to operate on, treated as most significant in u
[in]uunitary matrix to apply
Exceptions
invalidQuESTInputErrorif targetQubit1 or targetQubit2 are outside [0, qureg.numQubitsRepresented), or if targetQubit1 equals targetQubit2, or matrix u is not unitary, or if each node cannot fit 4 amplitudes in distributed mode.
Author
Tyson Jones

Definition at line 257 of file QuEST.c.

257  {
258  validateMultiTargets(qureg, (int []) {targetQubit1, targetQubit2}, 2, __func__);
259  validateTwoQubitUnitaryMatrix(qureg, u, __func__);
260 
261  statevec_twoQubitUnitary(qureg, targetQubit1, targetQubit2, u);
262  if (qureg.isDensityMatrix) {
263  int shift = qureg.numQubitsRepresented;
264  statevec_twoQubitUnitary(qureg, targetQubit1+shift, targetQubit2+shift, getConjugateMatrix4(u));
265  }
266 
267  qasm_recordComment(qureg, "Here, an undisclosed 2-qubit unitary was applied.");
268 }

References getConjugateMatrix4(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordComment(), statevec_twoQubitUnitary(), validateMultiTargets(), and validateTwoQubitUnitaryMatrix().

Referenced by TEST_CASE().

◆ unitary()

void unitary ( Qureg  qureg,
int  targetQubit,
ComplexMatrix2  u 
)

Apply a general single-qubit unitary (including a global phase factor).

The passed 2x2 ComplexMatrix must be unitary, otherwise an error is thrown.

\[ \setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {U}; \end{tikzpicture} } \]

If qureg is a state-vector, then the resulting state is $ u \, |\text{qureg}\rangle $. If qureg is a density-matrix $ \rho $, then the resulting state is $ u \, \rho \, u^\dagger $.


Parameters
[in,out]quregobject representing the set of all qubits
[in]targetQubitqubit to operate on
[in]uunitary matrix to apply
Exceptions
invalidQuESTInputErrorif targetQubit is outside [0, qureg.numQubitsRepresented), or matrix u is not unitary.
Author
Ania Brown (state-vector)
Tyson Jones (density matrix, doc)

Definition at line 349 of file QuEST.c.

349  {
350  validateTarget(qureg, targetQubit, __func__);
351  validateOneQubitUnitaryMatrix(u, __func__);
352 
353  statevec_unitary(qureg, targetQubit, u);
354  if (qureg.isDensityMatrix) {
355  statevec_unitary(qureg, targetQubit+qureg.numQubitsRepresented, getConjugateMatrix2(u));
356  }
357 
358  qasm_recordUnitary(qureg, u, targetQubit);
359 }

References getConjugateMatrix2(), Qureg::isDensityMatrix, Qureg::numQubitsRepresented, qasm_recordUnitary(), statevec_unitary(), validateOneQubitUnitaryMatrix(), and validateTarget().

Referenced by TEST_CASE().

void statevec_phaseShift(Qureg qureg, int targetQubit, qreal angle)
Definition: QuEST_common.c:251
void validateMultiControlsTarget(Qureg qureg, int *controlQubits, int numControlQubits, int targetQubit, const char *caller)
void statevec_sGate(Qureg qureg, int targetQubit)
Definition: QuEST_common.c:265
void statevec_pauliZ(Qureg qureg, int targetQubit)
Definition: QuEST_common.c:258
void statevec_rotateX(Qureg qureg, int rotQubit, qreal angle)
Definition: QuEST_common.c:293
void validateTarget(Qureg qureg, int targetQubit, const char *caller)
void qasm_recordParamGate(Qureg qureg, TargetGate gate, int targetQubit, qreal param)
Definition: QuEST_qasm.c:186
void shiftIndices(int *indices, int numIndices, int shift)
Definition: QuEST_common.c:150
void statevec_controlledTwoQubitUnitary(Qureg qureg, int controlQubit, int targetQubit1, int targetQubit2, ComplexMatrix4 u)
Definition: QuEST_common.c:523
@ GATE_T
Definition: QuEST_qasm.h:24
@ GATE_PHASE_SHIFT
Definition: QuEST_qasm.h:32
void qasm_recordUnitary(Qureg qureg, ComplexMatrix2 u, int targetQubit)
Definition: QuEST_qasm.c:207
void qasm_recordMultiControlledGate(Qureg qureg, TargetGate gate, int *controlQubits, int numControlQubits, int targetQubit)
Definition: QuEST_qasm.c:316
void validateMultiQubitMatrixFitsInNode(Qureg qureg, int numTargets, const char *caller)
void statevec_twoQubitUnitary(Qureg qureg, int targetQubit1, int targetQubit2, ComplexMatrix4 u)
Definition: QuEST_common.c:517
void statevec_tGateConj(Qureg qureg, int targetQubit)
Definition: QuEST_common.c:286
void statevec_unitary(Qureg qureg, int targetQubit, ComplexMatrix2 u)
ComplexMatrix4 getConjugateMatrix4(ComplexMatrix4 src)
Definition: QuEST_common.c:104
@ GATE_ROTATE_X
Definition: QuEST_qasm.h:27
void validateMultiQubitUnitaryMatrix(Qureg qureg, ComplexMatrixN u, int numTargs, const char *caller)
void statevec_multiControlledMultiQubitUnitary(Qureg qureg, long long int ctrlMask, int *targs, int numTargs, ComplexMatrixN u)
This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks ...
void statevec_multiRotateZ(Qureg qureg, long long int mask, qreal angle)
Definition: QuEST_cpu.c:3109
void qasm_recordControlledCompactUnitary(Qureg qureg, Complex alpha, Complex beta, int controlQubit, int targetQubit)
Definition: QuEST_qasm.c:264
@ GATE_ROTATE_Z
Definition: QuEST_qasm.h:29
@ GATE_SIGMA_Z
Definition: QuEST_qasm.h:23
void statevec_controlledPauliY(Qureg qureg, int controlQubit, int targetQubit)
Complex getConjugateScalar(Complex scalar)
Definition: QuEST_common.c:85
void statevec_controlledPhaseShift(Qureg qureg, int idQubit1, int idQubit2, qreal angle)
Definition: QuEST_cpu.c:3019
@ GATE_HADAMARD
Definition: QuEST_qasm.h:26
ComplexMatrix2 getConjugateMatrix2(ComplexMatrix2 src)
Definition: QuEST_common.c:99
void statevec_multiControlledPhaseShift(Qureg qureg, int *controlQubits, int numControlQubits, qreal angle)
Definition: QuEST_cpu.c:3059
void statevec_pauliY(Qureg qureg, int targetQubit)
void statevec_controlledMultiQubitUnitary(Qureg qureg, int ctrl, int *targets, int numTargets, ComplexMatrixN u)
Definition: QuEST_common.c:535
void qasm_recordMultiStateControlledUnitary(Qureg qureg, ComplexMatrix2 u, int *controlQubits, int *controlState, int numControlQubits, int targetQubit)
Definition: QuEST_qasm.c:362
void statevec_sqrtSwapGate(Qureg qureg, int qb1, int qb2)
Definition: QuEST_common.c:384
void statevec_swapQubitAmps(Qureg qureg, int qb1, int qb2)
void statevec_controlledPauliYConj(Qureg qureg, int controlQubit, int targetQubit)
void validateVector(Vector vec, const char *caller)
void validateMultiQubits(Qureg qureg, int *qubits, int numQubits, const char *caller)
void statevec_controlledUnitary(Qureg qureg, int controlQubit, int targetQubit, ComplexMatrix2 u)
void qasm_recordControlledGate(Qureg qureg, TargetGate gate, int controlQubit, int targetQubit)
Definition: QuEST_qasm.c:238
void validateControlTarget(Qureg qureg, int controlQubit, int targetQubit, const char *caller)
void qasm_recordAxisRotation(Qureg qureg, qreal angle, Vector axis, int targetQubit)
Definition: QuEST_qasm.c:223
@ GATE_SQRT_SWAP
Definition: QuEST_qasm.h:34
@ GATE_SIGMA_X
Definition: QuEST_qasm.h:21
void statevec_tGate(Qureg qureg, int targetQubit)
Definition: QuEST_common.c:272
void validateControlState(int *controlState, int numControlQubits, const char *caller)
void validateMultiTargets(Qureg qureg, int *targetQubits, int numTargetQubits, const char *caller)
void qasm_recordControlledParamGate(Qureg qureg, TargetGate gate, int controlQubit, int targetQubit, qreal param)
Definition: QuEST_qasm.c:247
void statevec_rotateAroundAxis(Qureg qureg, int rotQubit, qreal angle, Vector axis)
Definition: QuEST_common.c:311
void setConjugateMatrixN(ComplexMatrixN m)
Definition: QuEST_common.c:109
void statevec_multiControlledTwoQubitUnitary(Qureg qureg, long long int ctrlMask, int targetQubit1, int targetQubit2, ComplexMatrix4 u)
This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks ...
void qasm_recordControlledAxisRotation(Qureg qureg, qreal angle, Vector axis, int controlQubit, int targetQubit)
Definition: QuEST_qasm.c:300
long long int getQubitBitMask(int *qubits, int numQubits)
Definition: QuEST_common.c:44
void statevec_compactUnitary(Qureg qureg, int targetQubit, Complex alpha, Complex beta)
void statevec_multiRotatePauli(Qureg qureg, int *targetQubits, enum pauliOpType *targetPaulis, int numTargets, qreal angle, int applyConj)
applyConj=1 will apply conjugate operation, else applyConj=0
Definition: QuEST_common.c:411
void statevec_multiControlledPhaseFlip(Qureg qureg, int *controlQubits, int numControlQubits)
Definition: QuEST_cpu.c:3331
void qasm_recordComment(Qureg qureg, char *comment,...)
Definition: QuEST_qasm.c:120
void statevec_multiQubitUnitary(Qureg qureg, int *targets, int numTargets, ComplexMatrixN u)
Definition: QuEST_common.c:529
void statevec_controlledRotateAroundAxis(Qureg qureg, int controlQubit, int targetQubit, qreal angle, Vector axis)
Definition: QuEST_common.c:327
void statevec_sGateConj(Qureg qureg, int targetQubit)
Definition: QuEST_common.c:279
void statevec_rotateAroundAxisConj(Qureg qureg, int rotQubit, qreal angle, Vector axis)
Definition: QuEST_common.c:318
long long int getControlFlipMask(int *controlQubits, int *controlState, int numControlQubits)
Definition: QuEST_common.c:54
void qasm_recordMultiControlledUnitary(Qureg qureg, ComplexMatrix2 u, int *controlQubits, int numControlQubits, int targetQubit)
additionally performs Rz on target to restore the global phase lost from u in QASM U(a,...
Definition: QuEST_qasm.c:341
void qasm_recordMultiControlledParamGate(Qureg qureg, TargetGate gate, int *controlQubits, int numControlQubits, int targetQubit, qreal param)
Definition: QuEST_qasm.c:324
void statevec_controlledNot(Qureg qureg, int controlQubit, int targetQubit)
void validateTwoQubitUnitaryMatrix(Qureg qureg, ComplexMatrix4 u, const char *caller)
void statevec_controlledRotateX(Qureg qureg, int controlQubit, int targetQubit, qreal angle)
Definition: QuEST_common.c:343
int isDensityMatrix
Whether this instance is a density-state representation.
Definition: QuEST.h:206
void statevec_hadamard(Qureg qureg, int targetQubit)
void statevec_rotateY(Qureg qureg, int rotQubit, qreal angle)
Definition: QuEST_common.c:299
void statevec_multiControlledUnitary(Qureg qureg, long long int ctrlQubitsMask, long long int ctrlFlipMask, int targetQubit, ComplexMatrix2 u)
void validateOneQubitUnitaryMatrix(ComplexMatrix2 u, const char *caller)
void statevec_sqrtSwapGateConj(Qureg qureg, int qb1, int qb2)
Definition: QuEST_common.c:397
void statevec_controlledRotateZ(Qureg qureg, int controlQubit, int targetQubit, qreal angle)
Definition: QuEST_common.c:355
int numQubitsRepresented
The number of qubits represented in either the state-vector or density matrix.
Definition: QuEST.h:208
void statevec_pauliX(Qureg qureg, int targetQubit)
void validateMultiControlsMultiTargets(Qureg qureg, int *controlQubits, int numControlQubits, int *targetQubits, int numTargetQubits, const char *caller)
@ GATE_S
Definition: QuEST_qasm.h:25
@ GATE_SWAP
Definition: QuEST_qasm.h:33
void statevec_controlledPhaseFlip(Qureg qureg, int idQubit1, int idQubit2)
Definition: QuEST_cpu.c:3300
@ GATE_SIGMA_Y
Definition: QuEST_qasm.h:22
void qasm_recordCompactUnitary(Qureg qureg, Complex alpha, Complex beta, int targetQubit)
Definition: QuEST_qasm.c:195
void qasm_recordControlledUnitary(Qureg qureg, ComplexMatrix2 u, int controlQubit, int targetQubit)
additionally performs Rz on target to restore the global phase lost from u in QASM U(a,...
Definition: QuEST_qasm.c:278
void statevec_controlledRotateY(Qureg qureg, int controlQubit, int targetQubit, qreal angle)
Definition: QuEST_common.c:349
void statevec_controlledRotateAroundAxisConj(Qureg qureg, int controlQubit, int targetQubit, qreal angle, Vector axis)
Definition: QuEST_common.c:334
void qasm_recordGate(Qureg qureg, TargetGate gate, int targetQubit)
Definition: QuEST_qasm.c:178
void validatePauliCodes(enum pauliOpType *pauliCodes, int numPauliCodes, const char *caller)
void validateUnitaryComplexPair(Complex alpha, Complex beta, const char *caller)
@ GATE_ROTATE_Y
Definition: QuEST_qasm.h:28
void statevec_rotateZ(Qureg qureg, int rotQubit, qreal angle)
Definition: QuEST_common.c:305
void statevec_controlledCompactUnitary(Qureg qureg, int controlQubit, int targetQubit, Complex alpha, Complex beta)
void validateUniqueTargets(Qureg qureg, int qubit1, int qubit2, const char *caller)
void statevec_pauliYConj(Qureg qureg, int targetQubit)