Functions
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).

See also
Parameters
[in,out]qurega density matrix
[in]targetQubitqubit upon which to induce amplitude damping
[in]probthe probability of the damping
Exceptions
invalidQuESTInputError()
  • if qureg is not a density matrix
  • if targetQubit is outside [0, qureg.numQubitsRepresented)
  • 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 1283 of file QuEST.c.

1283  {
1284  validateDensityMatrQureg(qureg, __func__);
1285  validateTarget(qureg, targetQubit, __func__);
1286  validateOneQubitDampingProb(prob, __func__);
1287 
1288  densmatr_mixDamping(qureg, targetQubit, prob);
1289 }

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

See also
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
invalidQuESTInputError()
  • if either combineQureg or otherQureg are not density matrices
  • if the dimensions of combineQureg and otherQureg do not match
  • if prob is not in [0, 1]
Author
Tyson Jones

Definition at line 1012 of file QuEST.c.

1012  {
1013  validateDensityMatrQureg(combineQureg, __func__);
1014  validateDensityMatrQureg(otherQureg, __func__);
1015  validateMatchingQuregDims(combineQureg, otherQureg, __func__);
1016  validateProb(otherProb, __func__);
1017 
1018  densmatr_mixDensityMatrix(combineQureg, otherProb, otherQureg);
1019 }

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.

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

Definition at line 1250 of file QuEST.c.

1250  {
1251  validateDensityMatrQureg(qureg, __func__);
1252  validateTarget(qureg, targetQubit, __func__);
1253  validateOneQubitDephaseProb(prob, __func__);
1254 
1255  densmatr_mixDephasing(qureg, targetQubit, 2*prob);
1256  qasm_recordComment(qureg,
1257  "Here, a phase (Z) error occured on qubit %d with probability %g", targetQubit, prob);
1258 }

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.

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

Definition at line 1272 of file QuEST.c.

1272  {
1273  validateDensityMatrQureg(qureg, __func__);
1274  validateTarget(qureg, targetQubit, __func__);
1275  validateOneQubitDepolProb(prob, __func__);
1276 
1277  densmatr_mixDepolarising(qureg, targetQubit, (4*prob)/3.0);
1278  qasm_recordComment(qureg,
1279  "Here, a homogeneous depolarising error (X, Y, or Z) occured on "
1280  "qubit %d with total probability %g", targetQubit, prob);
1281 }

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.

See also
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
invalidQuESTInputError()
  • if qureg is not a density matrix
  • if target is outside of [0, qureg.numQubitsRepresented)
  • if numOps is outside [1, 4]
  • if ops do not create a completely positive, trace preserving map
  • if a node cannot fit 4 amplitudes in distributed mode
Author
Balint Koczor
Tyson Jones (refactored, doc)

Definition at line 1314 of file QuEST.c.

1314  {
1315  validateDensityMatrQureg(qureg, __func__);
1316  validateTarget(qureg, target, __func__);
1317  validateOneQubitKrausMap(qureg, ops, numOps, __func__);
1318 
1319  densmatr_mixKrausMap(qureg, target, ops, numOps);
1320  qasm_recordComment(qureg,
1321  "Here, an undisclosed Kraus map was effected on qubit %d", target);
1322 }

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.

See also
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
invalidQuESTInputError()
  • if qureg is not a density matrix
  • if any target in targets is outside of [0, qureg.numQubitsRepresented)
  • if any qubit in targets is repeated
  • if numOps is outside [1, (2 numTargets)^2]
  • if any ComplexMatrixN in ops does not have op.numQubits == numTargets
  • if ops do not create a completely positive, trace preserving map
  • if a node cannot fit (2N)^2 amplitudes in distributed mode
Author
Tyson Jones
Balint Koczor

Definition at line 1334 of file QuEST.c.

1334  {
1335  validateDensityMatrQureg(qureg, __func__);
1336  validateMultiTargets(qureg, targets, numTargets, __func__);
1337  validateMultiQubitKrausMap(qureg, numTargets, ops, numOps, __func__);
1338 
1339  densmatr_mixMultiQubitKrausMap(qureg, targets, numTargets, ops, numOps);
1340  qasm_recordComment(qureg,
1341  "Here, an undisclosed %d-qubit Kraus map was applied to undisclosed qubits", numTargets);
1342 }

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

See also
Parameters
[in,out]qurega density matrix
[in]targetQubitqubit to decohere
[in]probXthe probability of inducing an X error
[in]probYthe probability of inducing an Y error
[in]probZthe probability of inducing an Z error
Exceptions
invalidQuESTInputError()
  • if qureg is not a density matrix
  • if targetQubit is outside [0, qureg.numQubitsRepresented)
  • if any of probX, probY or probZ are not in [0, 1]
  • 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 1303 of file QuEST.c.

1303  {
1304  validateDensityMatrQureg(qureg, __func__);
1305  validateTarget(qureg, qubit, __func__);
1306  validateOneQubitPauliProbs(probX, probY, probZ, __func__);
1307 
1308  densmatr_mixPauli(qureg, qubit, probX, probY, probZ);
1309  qasm_recordComment(qureg,
1310  "Here, X, Y and Z errors occured on qubit %d with probabilities "
1311  "%g, %g and %g respectively", qubit, probX, probY, probZ);
1312 }

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.

See also
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
invalidQuESTInputError()
  • if qureg is not a density matrix
  • if either qubit1 or qubit2 is outside [0, qureg.numQubitsRepresented)
  • if qubit1 = qubit2
  • if prob is not in [0, 3/4]
Author
Tyson Jones (GPU, doc)
Ania Brown (CPU, distributed)

Definition at line 1260 of file QuEST.c.

1260  {
1261  validateDensityMatrQureg(qureg, __func__);
1262  validateUniqueTargets(qureg, qubit1, qubit2, __func__);
1263  validateTwoQubitDephaseProb(prob, __func__);
1264 
1265  ensureIndsIncrease(&qubit1, &qubit2);
1266  densmatr_mixTwoQubitDephasing(qureg, qubit1, qubit2, (4*prob)/3.0);
1267  qasm_recordComment(qureg,
1268  "Here, a phase (Z) error occured on either or both of qubits "
1269  "%d and %d with total probability %g", qubit1, qubit2, prob);
1270 }

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.

See also
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
invalidQuESTInputError()
  • if qureg is not a density matrix
  • if either qubit1 or qubit2 is outside [0, qureg.numQubitsRepresented)
  • if qubit1 = qubit2
  • if prob is not in [0, 15/16]
Author
Tyson Jones (GPU, doc)
Ania Brown (CPU, distributed)

Definition at line 1291 of file QuEST.c.

1291  {
1292  validateDensityMatrQureg(qureg, __func__);
1293  validateUniqueTargets(qureg, qubit1, qubit2, __func__);
1294  validateTwoQubitDepolProb(prob, __func__);
1295 
1296  ensureIndsIncrease(&qubit1, &qubit2);
1297  densmatr_mixTwoQubitDepolarising(qureg, qubit1, qubit2, (16*prob)/15.0);
1298  qasm_recordComment(qureg,
1299  "Here, a homogeneous depolarising error occured on qubits %d and %d "
1300  "with total probability %g", qubit1, qubit2, prob);
1301 }

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.

See also
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
invalidQuESTInputError()
  • if qureg is not a density matrix
  • if either target1 or target2 is outside of [0, qureg.numQubitsRepresented)
  • if target1 = target2
  • if numOps is outside [1, 16]
  • if ops do not create a completely positive, trace preserving map
  • if a node cannot fit 16 amplitudes in distributed mode
Author
Balint Koczor
Tyson Jones (refactored, doc)

Definition at line 1324 of file QuEST.c.

1324  {
1325  validateDensityMatrQureg(qureg, __func__);
1326  validateMultiTargets(qureg, (int[]) {target1,target2}, 2, __func__);
1327  validateTwoQubitKrausMap(qureg, ops, numOps, __func__);
1328 
1329  densmatr_mixTwoQubitKrausMap(qureg, target1, target2, ops, numOps);
1330  qasm_recordComment(qureg,
1331  "Here, an undisclosed two-qubit Kraus map was effected on qubits %d and %d", target1, target2);
1332 }

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

Referenced by TEST_CASE().

densmatr_mixDepolarising
void densmatr_mixDepolarising(Qureg qureg, int targetQubit, qreal depolLevel)
Definition: QuEST_cpu_distributed.c:712
validateDensityMatrQureg
void validateDensityMatrQureg(Qureg qureg, const char *caller)
Definition: QuEST_validation.c:519
validateTarget
void validateTarget(Qureg qureg, int targetQubit, const char *caller)
Definition: QuEST_validation.c:400
densmatr_mixKrausMap
void densmatr_mixKrausMap(Qureg qureg, int target, ComplexMatrix2 *ops, int numOps)
Definition: QuEST_common.c:644
validateProb
void validateProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:551
densmatr_mixMultiQubitKrausMap
void densmatr_mixMultiQubitKrausMap(Qureg qureg, int *targets, int numTargets, ComplexMatrixN *ops, int numOps)
Definition: QuEST_common.c:701
validateTwoQubitDepolProb
void validateTwoQubitDepolProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:583
densmatr_mixDensityMatrix
void densmatr_mixDensityMatrix(Qureg combineQureg, qreal otherProb, Qureg otherQureg)
Definition: QuEST_cpu.c:901
densmatr_mixDephasing
void densmatr_mixDephasing(Qureg qureg, int targetQubit, qreal dephase)
Definition: QuEST_cpu.c:85
validateOneQubitDephaseProb
void validateOneQubitDephaseProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:563
validateMultiTargets
void validateMultiTargets(Qureg qureg, int *targetQubits, int numTargetQubits, const char *caller)
Definition: QuEST_validation.c:428
densmatr_mixTwoQubitDephasing
void densmatr_mixTwoQubitDephasing(Qureg qureg, int qubit1, int qubit2, qreal dephase)
Definition: QuEST_cpu.c:90
validateMatchingQuregDims
void validateMatchingQuregDims(Qureg qureg1, Qureg qureg2, const char *caller)
Definition: QuEST_validation.c:531
densmatr_mixTwoQubitKrausMap
void densmatr_mixTwoQubitKrausMap(Qureg qureg, int target1, int target2, ComplexMatrix4 *ops, int numOps)
Definition: QuEST_common.c:682
densmatr_mixDamping
void densmatr_mixDamping(Qureg qureg, int targetQubit, qreal damping)
Definition: QuEST_cpu_distributed.c:739
validateOneQubitKrausMap
void validateOneQubitKrausMap(Qureg qureg, ComplexMatrix2 *ops, int numOps, const char *caller)
Definition: QuEST_validation.c:610
qasm_recordComment
void qasm_recordComment(Qureg qureg, char *comment,...)
Definition: QuEST_qasm.c:121
densmatr_mixTwoQubitDepolarising
void densmatr_mixTwoQubitDepolarising(Qureg qureg, int qubit1, int qubit2, qreal depolLevel)
Definition: QuEST_cpu_distributed.c:766
validateOneQubitDepolProb
void validateOneQubitDepolProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:573
validateTwoQubitKrausMap
void validateTwoQubitKrausMap(Qureg qureg, ComplexMatrix4 *ops, int numOps, const char *caller)
Definition: QuEST_validation.c:622
densmatr_mixPauli
void densmatr_mixPauli(Qureg qureg, int qubit, qreal probX, qreal probY, qreal probZ)
Definition: QuEST_common.c:743
validateMultiQubitKrausMap
void validateMultiQubitKrausMap(Qureg qureg, int numTargs, ComplexMatrixN *ops, int numOps, const char *caller)
Definition: QuEST_validation.c:634
ensureIndsIncrease
void ensureIndsIncrease(int *ind1, int *ind2)
Definition: QuEST_common.c:70
validateOneQubitDampingProb
void validateOneQubitDampingProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:578
validateUniqueTargets
void validateUniqueTargets(Qureg qureg, int qubit1, int qubit2, const char *caller)
Definition: QuEST_validation.c:414
validateTwoQubitDephaseProb
void validateTwoQubitDephaseProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:568
validateOneQubitPauliProbs
void validateOneQubitPauliProbs(qreal probX, qreal probY, qreal probZ, const char *caller)
Definition: QuEST_validation.c:588