Decoherence

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

Functions

void mixDamping (Qureg qureg, 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, int targetQubit, qreal prob)
 Mixes a density matrix qureg to induce single-qubit dephasing noise. More...
 
void mixDepolarising (Qureg qureg, 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,
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
invalidQuESTInputErrorif 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 1034 of file QuEST.c.

1034  {
1035  validateDensityMatrQureg(qureg, __func__);
1036  validateTarget(qureg, targetQubit, __func__);
1037  validateOneQubitDampingProb(prob, __func__);
1038 
1039  densmatr_mixDamping(qureg, targetQubit, prob);
1040 }

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
invalidQuESTInputErrorif 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 772 of file QuEST.c.

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

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

Referenced by TEST_CASE().

◆ mixDephasing()

void mixDephasing ( Qureg  qureg,
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
invalidQuESTInputErrorif 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 1001 of file QuEST.c.

1001  {
1002  validateDensityMatrQureg(qureg, __func__);
1003  validateTarget(qureg, targetQubit, __func__);
1004  validateOneQubitDephaseProb(prob, __func__);
1005 
1006  densmatr_mixDephasing(qureg, targetQubit, 2*prob);
1007  qasm_recordComment(qureg,
1008  "Here, a phase (Z) error occured on qubit %d with probability %g", targetQubit, prob);
1009 }

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

Referenced by TEST_CASE().

◆ mixDepolarising()

void mixDepolarising ( Qureg  qureg,
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
invalidQuESTInputErrorif 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 1023 of file QuEST.c.

1023  {
1024  validateDensityMatrQureg(qureg, __func__);
1025  validateTarget(qureg, targetQubit, __func__);
1026  validateOneQubitDepolProb(prob, __func__);
1027 
1028  densmatr_mixDepolarising(qureg, targetQubit, (4*prob)/3.0);
1029  qasm_recordComment(qureg,
1030  "Here, a homogeneous depolarising error (X, Y, or Z) occured on "
1031  "qubit %d with total probability %g", targetQubit, prob);
1032 }

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
invalidQuESTInputErrorif 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 1065 of file QuEST.c.

1065  {
1066  validateDensityMatrQureg(qureg, __func__);
1067  validateTarget(qureg, target, __func__);
1068  validateOneQubitKrausMap(qureg, ops, numOps, __func__);
1069 
1070  densmatr_mixKrausMap(qureg, target, ops, numOps);
1071  qasm_recordComment(qureg,
1072  "Here, an undisclosed Kraus map was effected on qubit %d", target);
1073 }

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
invalidQuESTInputErrorif 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 1085 of file QuEST.c.

1085  {
1086  validateDensityMatrQureg(qureg, __func__);
1087  validateMultiTargets(qureg, targets, numTargets, __func__);
1088  validateMultiQubitKrausMap(qureg, numTargets, ops, numOps, __func__);
1089 
1090  densmatr_mixMultiQubitKrausMap(qureg, targets, numTargets, ops, numOps);
1091  qasm_recordComment(qureg,
1092  "Here, an undisclosed %d-qubit Kraus map was applied to undisclosed qubits", numTargets);
1093 }

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
invalidQuESTInputErrorif 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 1054 of file QuEST.c.

1054  {
1055  validateDensityMatrQureg(qureg, __func__);
1056  validateTarget(qureg, qubit, __func__);
1057  validateOneQubitPauliProbs(probX, probY, probZ, __func__);
1058 
1059  densmatr_mixPauli(qureg, qubit, probX, probY, probZ);
1060  qasm_recordComment(qureg,
1061  "Here, X, Y and Z errors occured on qubit %d with probabilities "
1062  "%g, %g and %g respectively", qubit, probX, probY, probZ);
1063 }

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
invalidQuESTInputErrorif 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 1011 of file QuEST.c.

1011  {
1012  validateDensityMatrQureg(qureg, __func__);
1013  validateUniqueTargets(qureg, qubit1, qubit2, __func__);
1014  validateTwoQubitDephaseProb(prob, __func__);
1015 
1016  ensureIndsIncrease(&qubit1, &qubit2);
1017  densmatr_mixTwoQubitDephasing(qureg, qubit1, qubit2, (4*prob)/3.0);
1018  qasm_recordComment(qureg,
1019  "Here, a phase (Z) error occured on either or both of qubits "
1020  "%d and %d with total probability %g", qubit1, qubit2, prob);
1021 }

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
invalidQuESTInputErrorif 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 1042 of file QuEST.c.

1042  {
1043  validateDensityMatrQureg(qureg, __func__);
1044  validateUniqueTargets(qureg, qubit1, qubit2, __func__);
1045  validateTwoQubitDepolProb(prob, __func__);
1046 
1047  ensureIndsIncrease(&qubit1, &qubit2);
1048  densmatr_mixTwoQubitDepolarising(qureg, qubit1, qubit2, (16*prob)/15.0);
1049  qasm_recordComment(qureg,
1050  "Here, a homogeneous depolarising error occured on qubits %d and %d "
1051  "with total probability %g", qubit1, qubit2, prob);
1052 }

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
invalidQuESTInputErrorif 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 1075 of file QuEST.c.

1075  {
1076  validateDensityMatrQureg(qureg, __func__);
1077  validateMultiTargets(qureg, (int[]) {target1,target2}, 2, __func__);
1078  validateTwoQubitKrausMap(qureg, ops, numOps, __func__);
1079 
1080  densmatr_mixTwoQubitKrausMap(qureg, target1, target2, ops, numOps);
1081  qasm_recordComment(qureg,
1082  "Here, an undisclosed two-qubit Kraus map was effected on qubits %d and %d", target1, target2);
1083 }

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

Referenced by TEST_CASE().

void densmatr_mixDepolarising(Qureg qureg, int targetQubit, qreal depolLevel)
void validateDensityMatrQureg(Qureg qureg, const char *caller)
void validateTarget(Qureg qureg, int targetQubit, const char *caller)
void densmatr_mixKrausMap(Qureg qureg, int target, ComplexMatrix2 *ops, int numOps)
Definition: QuEST_common.c:600
void validateProb(qreal prob, const char *caller)
void densmatr_mixMultiQubitKrausMap(Qureg qureg, int *targets, int numTargets, ComplexMatrixN *ops, int numOps)
Definition: QuEST_common.c:643
void validateTwoQubitDepolProb(qreal prob, const char *caller)
void densmatr_mixDensityMatrix(Qureg combineQureg, qreal otherProb, Qureg otherQureg)
Definition: QuEST_cpu.c:890
void densmatr_mixDephasing(Qureg qureg, int targetQubit, qreal dephase)
Definition: QuEST_cpu.c:79
void validateOneQubitDephaseProb(qreal prob, const char *caller)
void validateMultiTargets(Qureg qureg, int *targetQubits, int numTargetQubits, const char *caller)
void densmatr_mixTwoQubitDephasing(Qureg qureg, int qubit1, int qubit2, qreal dephase)
Definition: QuEST_cpu.c:84
void validateMatchingQuregDims(Qureg qureg1, Qureg qureg2, const char *caller)
void densmatr_mixTwoQubitKrausMap(Qureg qureg, int target1, int target2, ComplexMatrix4 *ops, int numOps)
Definition: QuEST_common.c:635
void densmatr_mixDamping(Qureg qureg, int targetQubit, qreal damping)
void validateOneQubitKrausMap(Qureg qureg, ComplexMatrix2 *ops, int numOps, const char *caller)
void qasm_recordComment(Qureg qureg, char *comment,...)
Definition: QuEST_qasm.c:120
void densmatr_mixTwoQubitDepolarising(Qureg qureg, int qubit1, int qubit2, qreal depolLevel)
void validateOneQubitDepolProb(qreal prob, const char *caller)
void validateTwoQubitKrausMap(Qureg qureg, ComplexMatrix4 *ops, int numOps, const char *caller)
void densmatr_mixPauli(Qureg qureg, int qubit, qreal probX, qreal probY, qreal probZ)
Definition: QuEST_common.c:676
void validateMultiQubitKrausMap(Qureg qureg, int numTargs, ComplexMatrixN *ops, int numOps, const char *caller)
void ensureIndsIncrease(int *ind1, int *ind2)
Definition: QuEST_common.c:64
void validateOneQubitDampingProb(qreal prob, const char *caller)
void validateUniqueTargets(Qureg qureg, int qubit1, int qubit2, const char *caller)
void validateTwoQubitDephaseProb(qreal prob, const char *caller)
void validateOneQubitPauliProbs(qreal probX, qreal probY, qreal probZ, const char *caller)