# CorrelatedReadoutMitigator

`qiskit.result.CorrelatedReadoutMitigator(assignment_matrix, qubits=None)`

GitHub(opens in a new tab)

Bases: `BaseReadoutMitigator`

N-qubit readout error mitigator.

Mitigates `expectation_value()`

and `quasi_probabilities()`

. The mitigation_matrix should be calibrated using qiskit experiments. This mitigation method should be used in case the readout errors of the qubits are assumed to be correlated. The mitigation_matrix of *N* qubits is of size $2^N x 2^N$ so the mitigation complexity is $O(4^N)$.

Initialize a CorrelatedReadoutMitigator

**Parameters**

**assignment_matrix**(*ndarray*(opens in a new tab)) – readout error assignment matrix.**qubits**(*Iterable*(opens in a new tab)*[**int*(opens in a new tab)*] | None*) – Optional, the measured physical qubits for mitigation.

**Raises**

**QiskitError** – matrix size does not agree with number of qubits

## Attributes

### qubits

The device qubits for this mitigator

### settings

Return settings.

## Methods

### assignment_matrix

`assignment_matrix(qubits=None)`

Return the readout assignment matrix for specified qubits.

The assignment matrix is the stochastic matrix $A$ which assigns a noisy readout probability distribution to an ideal input readout distribution: $P(i|j) = \langle i | A | j \rangle$.

**Parameters**

**qubits** (*List*(opens in a new tab)*[**int*(opens in a new tab)*] | None*) – Optional, qubits being measured.

**Returns**

the assignment matrix A.

**Return type**

np.ndarray

### expectation_value

`expectation_value(data, diagonal=None, qubits=None, clbits=None, shots=None)`

Compute the mitigated expectation value of a diagonal observable.

This computes the mitigated estimator of $\langle O \rangle = \text{Tr}[\rho. O]$ of a diagonal observable $O = \sum_{x\in\{0, 1\}^n} O(x)|x\rangle\!\langle x|$.

**Parameters**

**data**(*Counts*) – Counts object**diagonal**(*Callable*(opens in a new tab)*|**dict*(opens in a new tab)*|**str*(opens in a new tab)*|**ndarray*(opens in a new tab)*| None*) – Optional, the vector of diagonal values for summing the expectation value. If`None`

the default value is $[1, -1]^\otimes n$.**qubits**(*Iterable*(opens in a new tab)*[**int*(opens in a new tab)*] | None*) – Optional, the measured physical qubits the count bitstrings correspond to. If None qubits are assumed to be $[0, ..., n-1]$.**clbits**(*List*(opens in a new tab)*[**int*(opens in a new tab)*] | None*) – Optional, if not None marginalize counts to the specified bits.**shots**(*int*(opens in a new tab)*| None*) – the number of shots.

**Returns**

the expectation value and an upper bound of the standard deviation.

**Return type**

(float(opens in a new tab), float(opens in a new tab))

**Additional Information:**

The diagonal observable $O$ is input using the `diagonal`

kwarg as a list or Numpy array $[O(0), ..., O(2^n -1)]$. If no diagonal is specified the diagonal of the Pauli operator :math`O = mbox{diag}(Z^{otimes n}) = [1, -1]^{otimes n}` is used. The `clbits`

kwarg is used to marginalize the input counts dictionary over the specified bit-values, and the `qubits`

kwarg is used to specify which physical qubits these bit-values correspond to as `circuit.measure(qubits, clbits)`

.

### mitigation_matrix

`mitigation_matrix(qubits=None)`

Return the readout mitigation matrix for the specified qubits.

The mitigation matrix $A^{-1}$ is defined as the inverse of the `assignment_matrix()`

$A$.

**Parameters**

**qubits** (*List*(opens in a new tab)*[**int*(opens in a new tab)*] | None*) – Optional, qubits being measured.

**Returns**

the measurement error mitigation matrix $A^{-1}$.

**Return type**

np.ndarray

### quasi_probabilities

`quasi_probabilities(data, qubits=None, clbits=None, shots=None)`

Compute mitigated quasi probabilities value.

**Parameters**

**data**(*Counts*) – counts object**qubits**(*List*(opens in a new tab)*[**int*(opens in a new tab)*] | None*) – qubits the count bitstrings correspond to.**clbits**(*List*(opens in a new tab)*[**int*(opens in a new tab)*] | None*) – Optional, marginalize counts to just these bits.**shots**(*int*(opens in a new tab)*| None*) – Optional, the total number of shots, if None shots will be calculated as the sum of all counts.

**Returns**

**A dictionary containing pairs of [output, mean] where “output”**

is the key in the dictionaries, which is the length-N bitstring of a measured standard basis state, and “mean” is the mean of non-zero quasi-probability estimates.

**Return type**

### stddev_upper_bound

`stddev_upper_bound(shots)`

Return an upper bound on standard deviation of expval estimator.

**Parameters**

**shots** (*int*(opens in a new tab)) – Number of shots used for expectation value measurement.

**Returns**

the standard deviation upper bound.

**Return type**