Functions
Decoherence

Decoherence channels which act on density matrices to induce mixing. More...

Functions

void mixDamping (Qureg qureg, const int targetQubit, qreal prob)
 Mixes a density matrix qureg to induce single-qubit amplitude damping (decay to 0 state). More...
 
void mixDensityMatrix (Qureg combineQureg, qreal prob, Qureg otherQureg)
 Modifies combineQureg to become (1-prob)combineProb + prob otherQureg. More...
 
void mixDephasing (Qureg qureg, const int targetQubit, qreal prob)
 Mixes a density matrix qureg to induce single-qubit dephasing noise. More...
 
void mixDepolarising (Qureg qureg, const int targetQubit, qreal prob)
 Mixes a density matrix qureg to induce single-qubit homogeneous depolarising noise. More...
 
void mixKrausMap (Qureg qureg, int target, ComplexMatrix2 *ops, int numOps)
 Apply a general single-qubit Kraus map to a density matrix, as specified by at most four Kraus operators, $K_i$ (ops). More...
 
void mixMultiQubitKrausMap (Qureg qureg, int *targets, int numTargets, ComplexMatrixN *ops, int numOps)
 Apply a general N-qubit Kraus map to a density matrix, as specified by at most (2N)^2 Kraus operators. More...
 
void mixPauli (Qureg qureg, int targetQubit, qreal probX, qreal probY, qreal probZ)
 Mixes a density matrix qureg to induce general single-qubit Pauli noise. More...
 
void mixTwoQubitDephasing (Qureg qureg, int qubit1, int qubit2, qreal prob)
 Mixes a density matrix qureg to induce two-qubit dephasing noise. More...
 
void mixTwoQubitDepolarising (Qureg qureg, int qubit1, int qubit2, qreal prob)
 Mixes a density matrix qureg to induce two-qubit homogeneous depolarising noise. More...
 
void mixTwoQubitKrausMap (Qureg qureg, int target1, int target2, ComplexMatrix4 *ops, int numOps)
 Apply a general two-qubit Kraus map to a density matrix, as specified by at most sixteen Kraus operators. More...
 

Detailed Description

Decoherence channels which act on density matrices to induce mixing.

Function Documentation

◆ mixDamping()

void mixDamping ( Qureg  qureg,
const int  targetQubit,
qreal  prob 
)

Mixes a density matrix qureg to induce single-qubit amplitude damping (decay to 0 state).

With probability prob, applies damping (transition from 1 to 0 state).

This transforms qureg = $\rho$ into the mixed state

\[ K_0 \rho K_0^\dagger + K_1 \rho K_1^\dagger \]

where q = targetQubit and $K_0$ and $K_1$ are Kraus operators

\[ K_0 = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-\text{prob}} \end{pmatrix}, \;\; K_1 = \begin{pmatrix} 0 & \sqrt{\text{prob}} \\ 0 & 0 \end{pmatrix}. \]

prob cannot exceed 1, at which total damping/decay occurs. Note that unlike mixDephasing() and mixDepolarising(), this function can increase the purity of a mixed state (by, as prob becomes 1, gaining certainty that the qubit is in the 0 state).

Parameters
[in,out]qurega density matrix
[in]targetQubitqubit upon which to induce amplitude damping
[in]probthe probability of the damping
Exceptions
exitWithErrorif qureg is not a density matrix, or if targetQubit is outside [0, qureg.numQubitsRepresented), or if prob is not in [0, 1]
Author
Nicolas Vogt of HQS (local CPU)
Ania Brown (GPU, patched local CPU)
Tyson Jones (distributed, doc)

Definition at line 935 of file QuEST.c.

935  {
936  validateDensityMatrQureg(qureg, __func__);
937  validateTarget(qureg, targetQubit, __func__);
938  validateOneQubitDampingProb(prob, __func__);
939 
940  densmatr_mixDamping(qureg, targetQubit, prob);
941 }

References densmatr_mixDamping(), validateDensityMatrQureg(), validateOneQubitDampingProb(), and validateTarget().

Referenced by TEST_CASE().

◆ mixDensityMatrix()

void mixDensityMatrix ( Qureg  combineQureg,
qreal  prob,
Qureg  otherQureg 
)

Modifies combineQureg to become (1-prob)combineProb + prob otherQureg.

Both registers must be equal-dimension density matrices, and prob must be in [0, 1].

Parameters
[in,out]combineQurega density matrix to be modified
[in]probthe probability of otherQureg in the modified combineQureg
[in]otherQurega density matrix to be mixed into combineQureg
Exceptions
exitWithErrorif either combineQureg or otherQureg are not density matrices, or if the dimensions of combineQureg and otherQureg do not match, or if prob is not in [0, 1]
Author
Tyson Jones

Definition at line 770 of file QuEST.c.

770  {
771  validateDensityMatrQureg(combineQureg, __func__);
772  validateDensityMatrQureg(otherQureg, __func__);
773  validateMatchingQuregDims(combineQureg, otherQureg, __func__);
774  validateProb(otherProb, __func__);
775 
776  densmatr_mixDensityMatrix(combineQureg, otherProb, otherQureg);
777 }

References densmatr_mixDensityMatrix(), validateDensityMatrQureg(), validateMatchingQuregDims(), and validateProb().

Referenced by TEST_CASE().

◆ mixDephasing()

void mixDephasing ( Qureg  qureg,
const int  targetQubit,
qreal  prob 
)

Mixes a density matrix qureg to induce single-qubit dephasing noise.

With probability prob, applies Pauli Z to targetQubit.

This transforms qureg = $\rho$ into the mixed state

\[ (1 - \text{prob}) \, \rho + \text{prob} \; Z_q \, \rho \, Z_q \]

where q = targetQubit. prob cannot exceed 1/2, which maximally mixes targetQubit.

Parameters
[in,out]qurega density matrix
[in]targetQubitqubit upon which to induce dephasing noise
[in]probthe probability of the phase error occuring
Exceptions
exitWithErrorif qureg is not a density matrix, or if targetQubit is outside [0, qureg.numQubitsRepresented), or if prob is not in [0, 1/2]
Author
Tyson Jones (GPU, doc)
Ania Brown (CPU, distributed)

Definition at line 902 of file QuEST.c.

902  {
903  validateDensityMatrQureg(qureg, __func__);
904  validateTarget(qureg, targetQubit, __func__);
905  validateOneQubitDephaseProb(prob, __func__);
906 
907  densmatr_mixDephasing(qureg, targetQubit, 2*prob);
908  qasm_recordComment(qureg,
909  "Here, a phase (Z) error occured on qubit %d with probability %g", targetQubit, prob);
910 }

References densmatr_mixDephasing(), qasm_recordComment(), validateDensityMatrQureg(), validateOneQubitDephaseProb(), and validateTarget().

Referenced by TEST_CASE().

◆ mixDepolarising()

void mixDepolarising ( Qureg  qureg,
const int  targetQubit,
qreal  prob 
)

Mixes a density matrix qureg to induce single-qubit homogeneous depolarising noise.

This is equivalent to, with probability prob, uniformly randomly applying either Pauli X, Y, or Z to targetQubit.

This transforms qureg = $\rho$ into the mixed state

\[ (1 - \text{prob}) \, \rho + \frac{\text{prob}}{3} \; \left( X_q \, \rho \, X_q + Y_q \, \rho \, Y_q + Z_q \, \rho \, Z_q \right) \]

where q = targetQubit. prob cannot exceed 3/4, at which maximal mixing occurs. The produced state is equivalently expressed as

\[ \left( 1 - \frac{4}{3} \text{prob} \right) \rho + \left( \frac{4}{3} \text{prob} \right) \frac{\vec{\bf{1}}}{2} \]

where $ \frac{\vec{\bf{1}}}{2} $ is the maximally mixed state of the target qubit.

Parameters
[in,out]qurega density matrix
[in]targetQubitqubit upon which to induce depolarising noise
[in]probthe probability of the depolarising error occuring
Exceptions
exitWithErrorif qureg is not a density matrix, or if targetQubit is outside [0, qureg.numQubitsRepresented), or if prob is not in [0, 3/4]
Author
Tyson Jones (GPU, doc)
Ania Brown (CPU, distributed)

Definition at line 924 of file QuEST.c.

924  {
925  validateDensityMatrQureg(qureg, __func__);
926  validateTarget(qureg, targetQubit, __func__);
927  validateOneQubitDepolProb(prob, __func__);
928 
929  densmatr_mixDepolarising(qureg, targetQubit, (4*prob)/3.0);
930  qasm_recordComment(qureg,
931  "Here, a homogeneous depolarising error (X, Y, or Z) occured on "
932  "qubit %d with total probability %g", targetQubit, prob);
933 }

References densmatr_mixDepolarising(), qasm_recordComment(), validateDensityMatrQureg(), validateOneQubitDepolProb(), and validateTarget().

Referenced by TEST_CASE().

◆ mixKrausMap()

void mixKrausMap ( Qureg  qureg,
int  target,
ComplexMatrix2 *  ops,
int  numOps 
)

Apply a general single-qubit Kraus map to a density matrix, as specified by at most four Kraus operators, $K_i$ (ops).

A Kraus map is also referred to as a "operator-sum representation" of a quantum channel, and enables the simulation of general single-qubit noise process, by effecting

\[ \rho \to \sum\limits_i^{\text{numOps}} K_i \rho K_i^\dagger \]

The Kraus map must be completely positive and trace preserving, which constrains each $ K_i $ in ops by

\[ \sum \limits_i^{\text{numOps}} K_i^\dagger K_i = I \]

where $ I $ is the identity matrix.

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

Parameters
[in,out]quregthe density matrix to which to apply the map
[in]targetthe target qubit of the map
[in]opsan array of at most 4 Kraus operators
[in]numOpsthe number of operators in ops which must be >0 and <= 4.
Exceptions
exitWithErrorif qureg is not a density matrix, or if target is outside of [0, qureg.numQubitsRepresented), or if numOps is outside [1, 4], or if ops do not create a completely positive, trace preserving map, or if a node cannot fit 4 amplitudes in distributed mode.
Author
Balint Koczor
Tyson Jones (refactored, doc)

Definition at line 966 of file QuEST.c.

966  {
967  validateDensityMatrQureg(qureg, __func__);
968  validateTarget(qureg, target, __func__);
969  validateOneQubitKrausMap(qureg, ops, numOps, __func__);
970 
971  densmatr_mixKrausMap(qureg, target, ops, numOps);
972  qasm_recordComment(qureg,
973  "Here, an undisclosed Kraus map was effected on qubit %d", target);
974 }

References densmatr_mixKrausMap(), qasm_recordComment(), validateDensityMatrQureg(), validateOneQubitKrausMap(), and validateTarget().

Referenced by TEST_CASE().

◆ mixMultiQubitKrausMap()

void mixMultiQubitKrausMap ( Qureg  qureg,
int *  targets,
int  numTargets,
ComplexMatrixN *  ops,
int  numOps 
)

Apply a general N-qubit Kraus map to a density matrix, as specified by at most (2N)^2 Kraus operators.

This allows one to simulate a general noise process.

The Kraus map must be completely positive and trace preserving, which constrains each $ K_i $ in ops by

\[ \sum \limits_i^{\text{numOps}} K_i^\dagger K_i = I \]

where $ I $ is the identity matrix.

The first qubit in targets is treated as the least significant qubit in each op in ops.

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

Note too that this routine internally creates a 'superoperator'; a complex matrix of dimensions 2^(2*numTargets) by 2^(2*numTargets). Therefore, invoking this function incurs, for numTargs={1,2,3,4,5, ...}, an additional memory overhead of (at double-precision) {0.25 KiB, 4 KiB, 64 KiB, 1 MiB, 16 MiB, ...} (respectively). At quad precision (usually 10 B per number, but possibly 16 B due to alignment), this costs at most double the amount of memory. For numTargets < 4, this superoperator will be created in the runtime stack. For numTargs >= 4, the superoperator will be allocated in the heap and therefore this routine may suffer an anomalous slowdown.

Parameters
[in,out]quregthe density matrix to which to apply the map
[in]targetsa list of target qubit indices, the first of which is treated as least significant in each op in ops
[in]numTargetsthe length of targets
[in]opsan array of at most (2N)^2 Kraus operators
[in]numOpsthe number of operators in ops which must be >0 and <= (2N)^2.
Exceptions
exitWithErrorif qureg is not a density matrix, or if any target in targets is outside of [0, qureg.numQubitsRepresented), or if any qubit in targets is repeated, or if numOps is outside [1, (2 numTargets)^2], or if any ComplexMatrixN in \ops does not have op.numQubits == numTargets, or if ops do not create a completely positive, trace preserving map, or if a node cannot fit (2N)^2 amplitudes in distributed mode.
Author
Tyson Jones
Balint Koczor

Definition at line 986 of file QuEST.c.

986  {
987  validateDensityMatrQureg(qureg, __func__);
988  validateMultiTargets(qureg, targets, numTargets, __func__);
989  validateMultiQubitKrausMap(qureg, numTargets, ops, numOps, __func__);
990 
991  densmatr_mixMultiQubitKrausMap(qureg, targets, numTargets, ops, numOps);
992  qasm_recordComment(qureg,
993  "Here, an undisclosed %d-qubit Kraus map was applied to undisclosed qubits", numTargets);
994 }

References densmatr_mixMultiQubitKrausMap(), qasm_recordComment(), validateDensityMatrQureg(), validateMultiQubitKrausMap(), and validateMultiTargets().

Referenced by TEST_CASE().

◆ mixPauli()

void mixPauli ( Qureg  qureg,
int  targetQubit,
qreal  probX,
qreal  probY,
qreal  probZ 
)

Mixes a density matrix qureg to induce general single-qubit Pauli noise.

With probabilities probX, probY and probZ, applies Pauli X, Y, and Z respectively to targetQubit.

This transforms qureg = $\rho$ into the mixed state

\[ (1 - \text{probX} - \text{probY} - \text{probZ}) \, \rho + \;\;\; (\text{probX})\; X_q \, \rho \, X_q + \;\;\; (\text{probY})\; Y_q \, \rho \, Y_q + \;\;\; (\text{probZ})\; Z_q \, \rho \, Z_q \]

where q = targetQubit. Each of probX, probY and probZ cannot exceed the chance of no error: 1 - probX - probY - probZ

This function operates by first converting the given Pauli probabilities into a single-qubit Kraus map (four 2x2 operators).

Parameters
[in,out]qurega density matrix
[in]targetQubitqubit to decohere
[in]probXthe probability of inducing an X error
[in]probXthe probability of inducing an Y error
[in]probXthe probability of inducing an Z error
Exceptions
exitWithErrorif qureg is not a density matrix, or if targetQubit is outside [0, qureg.numQubitsRepresented), or if any of probX, probY or probZ are not in [0, 1], or if any of p in {probX, probY or probZ} don't satisfy p <= (1 - probX - probY - probZ)
Author
Balint Koczor
Tyson Jones (refactored, doc)

Definition at line 955 of file QuEST.c.

955  {
956  validateDensityMatrQureg(qureg, __func__);
957  validateTarget(qureg, qubit, __func__);
958  validateOneQubitPauliProbs(probX, probY, probZ, __func__);
959 
960  densmatr_mixPauli(qureg, qubit, probX, probY, probZ);
961  qasm_recordComment(qureg,
962  "Here, X, Y and Z errors occured on qubit %d with probabilities "
963  "%g, %g and %g respectively", qubit, probX, probY, probZ);
964 }

References densmatr_mixPauli(), qasm_recordComment(), validateDensityMatrQureg(), validateOneQubitPauliProbs(), and validateTarget().

Referenced by TEST_CASE().

◆ mixTwoQubitDephasing()

void mixTwoQubitDephasing ( Qureg  qureg,
int  qubit1,
int  qubit2,
qreal  prob 
)

Mixes a density matrix qureg to induce two-qubit dephasing noise.

With probability prob, applies Pauli Z to either or both qubits.

This transforms qureg = $\rho$ into the mixed state

\[ (1 - \text{prob}) \, \rho + \frac{\text{prob}}{3} \; \left( Z_a \, \rho \, Z_a + Z_b \, \rho \, Z_b + Z_a Z_b \, \rho \, Z_a Z_b \right) \]

where a = qubit1, b = qubit2. prob cannot exceed 3/4, at which maximal mixing occurs.

Parameters
[in,out]qurega density matrix
[in]qubit1qubit upon which to induce dephasing noise
[in]qubit2qubit upon which to induce dephasing noise
[in]probthe probability of the phase error occuring
Exceptions
exitWithErrorif qureg is not a density matrix, or if either qubit1 or qubit2 is outside [0, qureg.numQubitsRepresented), or if qubit1 = qubit2, or if prob is not in [0, 3/4]
Author
Tyson Jones (GPU, doc)
Ania Brown (CPU, distributed)

Definition at line 912 of file QuEST.c.

912  {
913  validateDensityMatrQureg(qureg, __func__);
914  validateUniqueTargets(qureg, qubit1, qubit2, __func__);
915  validateTwoQubitDephaseProb(prob, __func__);
916 
917  ensureIndsIncrease(&qubit1, &qubit2);
918  densmatr_mixTwoQubitDephasing(qureg, qubit1, qubit2, (4*prob)/3.0);
919  qasm_recordComment(qureg,
920  "Here, a phase (Z) error occured on either or both of qubits "
921  "%d and %d with total probability %g", qubit1, qubit2, prob);
922 }

References densmatr_mixTwoQubitDephasing(), ensureIndsIncrease(), qasm_recordComment(), validateDensityMatrQureg(), validateTwoQubitDephaseProb(), and validateUniqueTargets().

Referenced by TEST_CASE().

◆ mixTwoQubitDepolarising()

void mixTwoQubitDepolarising ( Qureg  qureg,
int  qubit1,
int  qubit2,
qreal  prob 
)

Mixes a density matrix qureg to induce two-qubit homogeneous depolarising noise.

With probability prob, applies to qubit1 and qubit2 any operator of the set $\{ IX, IY, IZ, XI, YI, ZI, XX, XY, XZ, YX, YY, YZ, ZX, ZY, ZZ \}$. Note this is the set of all two-qubit Pauli gates excluding $II$.

This transforms qureg = $\rho$ into the mixed state

\[ (1 - \text{prob}) \, \rho \; + \; \frac{\text{prob}}{15} \; \left( \sum \limits_{\sigma_a \in \{X_a,Y_a,Z_a,I_a\}} \sum \limits_{\sigma_b \in \{X_b,Y_b,Z_b,I_b\}} \sigma_a \sigma_b \; \rho \; \sigma_a \sigma_b \right) - \frac{\text{prob}}{15} I_a I_b \; \rho \; I_a I_b \]

or verbosely

\[ (1 - \text{prob}) \, \rho + \frac{\text{prob}}{15} \; \left( \begin{aligned} &X_a \, \rho \, X_a + X_b \, \rho \, X_b + Y_a \, \rho \, Y_a + Y_b \, \rho \, Y_b + Z_a \, \rho \, Z_a + Z_b \, \rho \, Z_b \\ + &X_a X_b \, \rho \, X_a X_b + X_a Y_b \, \rho \, X_a Y_b + X_a Z_b \, \rho \, X_a Z_b + Y_a X_b \, \rho \, Y_a X_b \\ + &Y_a Y_b \, \rho \, Y_a Y_b + Y_a Z_b \, \rho \, Y_a Z_b + Z_a X_b \, \rho \, Z_a X_b + Z_a Y_b \, \rho \, Z_a Y_b + Z_a Z_b \, \rho \, Z_a Z_b \end{aligned} \right) \]

where a = qubit1, b = qubit2.

prob cannot exceed 15/16, at which maximal mixing occurs.

The produced state is equivalently expressed as

\[ \left( 1 - \frac{16}{15} \text{prob} \right) \rho + \left( \frac{16}{15} \text{prob} \right) \frac{\vec{\bf{1}}}{2} \]

where $ \frac{\vec{\bf{1}}}{2} $ is the maximally mixed state of the two target qubits.

Parameters
[in,out]qurega density matrix
[in]qubit1qubit upon which to induce depolarising noise
[in]qubit2qubit upon which to induce depolarising noise
[in]probthe probability of the depolarising error occuring
Exceptions
exitWithErrorif qureg is not a density matrix, or if either qubit1 or qubit2 is outside [0, qureg.numQubitsRepresented), or if qubit1 = qubit2, or if prob is not in [0, 15/16]
Author
Tyson Jones (GPU, doc)
Ania Brown (CPU, distributed)

Definition at line 943 of file QuEST.c.

943  {
944  validateDensityMatrQureg(qureg, __func__);
945  validateUniqueTargets(qureg, qubit1, qubit2, __func__);
946  validateTwoQubitDepolProb(prob, __func__);
947 
948  ensureIndsIncrease(&qubit1, &qubit2);
949  densmatr_mixTwoQubitDepolarising(qureg, qubit1, qubit2, (16*prob)/15.0);
950  qasm_recordComment(qureg,
951  "Here, a homogeneous depolarising error occured on qubits %d and %d "
952  "with total probability %g", qubit1, qubit2, prob);
953 }

References densmatr_mixTwoQubitDepolarising(), ensureIndsIncrease(), qasm_recordComment(), validateDensityMatrQureg(), validateTwoQubitDepolProb(), and validateUniqueTargets().

Referenced by TEST_CASE().

◆ mixTwoQubitKrausMap()

void mixTwoQubitKrausMap ( Qureg  qureg,
int  target1,
int  target2,
ComplexMatrix4 *  ops,
int  numOps 
)

Apply a general two-qubit Kraus map to a density matrix, as specified by at most sixteen Kraus operators.

A Kraus map is also referred to as a "operator-sum representation" of a quantum channel. This allows one to simulate a general two-qubit noise process.

The Kraus map must be completely positive and trace preserving, which constrains each $ K_i $ in ops by

\[ \sum \limits_i^{\text{numOps}} K_i^\dagger K_i = I \]

where $ I $ is the identity matrix.

targetQubit1 is treated as the least significant qubit in each op in ops.

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

Parameters
[in,out]quregthe density matrix to which to apply the map
[in]target1the least significant target qubit in ops
[in]target2the most significant target qubit in ops
[in]opsan array of at most 16 Kraus operators
[in]numOpsthe number of operators in ops which must be >0 and <= 16.
Exceptions
exitWithErrorif qureg is not a density matrix, or if either target1 or target2 is outside of [0, qureg.numQubitsRepresented), or if target1 = target2, or if numOps is outside [1, 16], or if ops do not create a completely positive, trace preserving map, or if a node cannot fit 16 amplitudes in distributed mode.
Author
Balint Koczor
Tyson Jones (refactored, doc)

Definition at line 976 of file QuEST.c.

976  {
977  validateDensityMatrQureg(qureg, __func__);
978  validateMultiTargets(qureg, (int[]) {target1,target2}, 2, __func__);
979  validateTwoQubitKrausMap(qureg, ops, numOps, __func__);
980 
981  densmatr_mixTwoQubitKrausMap(qureg, target1, target2, ops, numOps);
982  qasm_recordComment(qureg,
983  "Here, an undisclosed two-qubit Kraus map was effected on qubits %d and %d", target1, target2);
984 }

References densmatr_mixTwoQubitKrausMap(), qasm_recordComment(), validateDensityMatrQureg(), validateMultiTargets(), and validateTwoQubitKrausMap().

Referenced by TEST_CASE().

validateDensityMatrQureg
void validateDensityMatrQureg(Qureg qureg, const char *caller)
Definition: QuEST_validation.c:422
validateTarget
void validateTarget(Qureg qureg, int targetQubit, const char *caller)
Definition: QuEST_validation.c:307
densmatr_mixKrausMap
void densmatr_mixKrausMap(Qureg qureg, int target, ComplexMatrix2 *ops, int numOps)
Definition: QuEST_common.c:599
densmatr_mixDephasing
void densmatr_mixDephasing(Qureg qureg, const int targetQubit, qreal dephase)
Definition: QuEST_cpu.c:79
validateProb
void validateProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:450
densmatr_mixMultiQubitKrausMap
void densmatr_mixMultiQubitKrausMap(Qureg qureg, int *targets, int numTargets, ComplexMatrixN *ops, int numOps)
Definition: QuEST_common.c:642
validateMultiTargets
void validateMultiTargets(Qureg qureg, int *targetQubits, const int numTargetQubits, const char *caller)
Definition: QuEST_validation.c:335
validateTwoQubitDepolProb
void validateTwoQubitDepolProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:482
densmatr_mixDepolarising
void densmatr_mixDepolarising(Qureg qureg, const int targetQubit, qreal depolLevel)
Definition: QuEST_cpu_distributed.c:700
densmatr_mixDensityMatrix
void densmatr_mixDensityMatrix(Qureg combineQureg, qreal otherProb, Qureg otherQureg)
Definition: QuEST_cpu.c:889
validateOneQubitDephaseProb
void validateOneQubitDephaseProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:462
validateMatchingQuregDims
void validateMatchingQuregDims(Qureg qureg1, Qureg qureg2, const char *caller)
Definition: QuEST_validation.c:434
densmatr_mixTwoQubitKrausMap
void densmatr_mixTwoQubitKrausMap(Qureg qureg, int target1, int target2, ComplexMatrix4 *ops, int numOps)
Definition: QuEST_common.c:634
densmatr_mixTwoQubitDephasing
void densmatr_mixTwoQubitDephasing(Qureg qureg, const int qubit1, const int qubit2, qreal dephase)
Definition: QuEST_cpu.c:84
validateOneQubitKrausMap
void validateOneQubitKrausMap(Qureg qureg, ComplexMatrix2 *ops, int numOps, const char *caller)
Definition: QuEST_validation.c:511
qasm_recordComment
void qasm_recordComment(Qureg qureg, char *comment,...)
Definition: QuEST_qasm.c:120
densmatr_mixTwoQubitDepolarising
void densmatr_mixTwoQubitDepolarising(Qureg qureg, int qubit1, int qubit2, qreal depolLevel)
Definition: QuEST_cpu_distributed.c:754
validateOneQubitDepolProb
void validateOneQubitDepolProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:472
validateTwoQubitKrausMap
void validateTwoQubitKrausMap(Qureg qureg, ComplexMatrix4 *ops, int numOps, const char *caller)
Definition: QuEST_validation.c:523
densmatr_mixDamping
void densmatr_mixDamping(Qureg qureg, const int targetQubit, qreal damping)
Definition: QuEST_cpu_distributed.c:727
densmatr_mixPauli
void densmatr_mixPauli(Qureg qureg, int qubit, qreal probX, qreal probY, qreal probZ)
Definition: QuEST_common.c:675
validateMultiQubitKrausMap
void validateMultiQubitKrausMap(Qureg qureg, int numTargs, ComplexMatrixN *ops, int numOps, const char *caller)
Definition: QuEST_validation.c:535
ensureIndsIncrease
void ensureIndsIncrease(int *ind1, int *ind2)
Definition: QuEST_common.c:63
validateOneQubitDampingProb
void validateOneQubitDampingProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:477
validateUniqueTargets
void validateUniqueTargets(Qureg qureg, int qubit1, int qubit2, const char *caller)
Definition: QuEST_validation.c:321
validateTwoQubitDephaseProb
void validateTwoQubitDephaseProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:467
validateOneQubitPauliProbs
void validateOneQubitPauliProbs(qreal probX, qreal probY, qreal probZ, const char *caller)
Definition: QuEST_validation.c:487