Add uncorrelated readout error mitigation for arbitrarily long Pauli strings

[eliottrosenberg]

This adds the method readout_mitigation_pauli_uncorrelated to cirq.experiments.readout_confusion_matrix.TensoredConfusionMatrices, which allows one to scalably perform readout error mitigation on arbitrarily long Pauli strings without having to construct any exponentially large matrices. For now, this is restricted to the case when the confusion matrix is a tensor product of single-qubit confusion matrices but could be generalized if desired. The test illustrates its usage. It is a reimplementation of work that I did in grad school (a special case of https://github.com/eliottrosenberg/correlated_SPAM).

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 97.81%. Comparing base (ac63c60) to head (8fb724e).

Additional details and impacted files

@@           Coverage Diff           @@
##             main    #6654   +/-   ##
=======================================
  Coverage   97.81%   97.81%           
=======================================
  Files        1066     1066           
  Lines       91779    91832   +53     
=======================================
+ Hits        89773    89826   +53     
  Misses       2006     2006           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[NoureldinYosri]

thanks Eliott. can you add a reference link to the methods (e.g. to arXiv)?

[NoureldinYosri]

modifications to files don't change their year

[NoureldinYosri]

was the old documentation wrong or is this a result of the changes?

[eliottrosenberg]

The old documentation was wrong.

[NoureldinYosri]

isn't this p1 = measurements @ (1 - one_errors) + (1 - measurements) @ zero_errors? if it's then the matrix product way is clearer to software engineers who are not necessarly familiar with Einstein summation

[eliottrosenberg]

No, it's different because in matrix multiplication the index j would be summed over, and here it is not.

[NoureldinYosri]

is there a way to do this without einsum? what is the function being calculated ? or is this some a reweighing of the matrix?

[eliottrosenberg]

It's computing the probability that the bit should be 1 after adding noise, for each of the measured bitstrings. The einsum is just saying
p1[i,j] = measurements[i,j] * (1- one_errors)[j] + (1-measurements)[i,j] * zero_errors[j],
which you could also implement with a loop, but that would be less efficient.

[eliottrosenberg]

I prefer to keep the einsum if you don't mind.

[NoureldinYosri]

can't this be achieved by the broadcast behaviour of array multiplication? p1 = measurements * (1 - one_errors) + (1 - measurements) * zero_errors that is * instead of @. I tested this below and array multiplication is faster than einsum

you can make the choice here but if it's based on performance then array multiplication is faster. eitherway please add a comment explaining what the line does

In [1]: import numpy as np

In [2]: A = np.random.random((5000, 1 << 18))

In [3]: B = np.random.random(1 << 18)

In [4]: want = np.einsum('ij,j->ij', A, B)

In [5]: got = A * B

In [6]: np.allclose(want, got)
Out[6]: True

In [7]: %timeit A * B
2.61 s ± 61.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [8]: %timeit np.einsum('ij,j->ij', A, B)
3.38 s ± 71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

[eliottrosenberg]

Ok, you're right. I will change it, thanks.

[NoureldinYosri]

prefer to use a None default value. the default value of an argumet is resolved only once ... that means that all places that call the method without specifiying an rng will use the same object. with None we create a new object for each of these calls which prevents any possible correlation between different calls

Suggested change

	rng: np.random.Generator = np.random.default_rng(),
	rng: Optional[np.random.Generator] = None,
	...
	if rng is None: rng = np.random.default_rng()

[NoureldinYosri]

there is a significant amount of logic in this method.. tests should be simply and dry (but not too dry). can you simplify the tests?

[eliottrosenberg]

Well, I want to demonstrate not only that the code runs but also that it works on large Pauli operators.

[NoureldinYosri]

if you replace the random part of the function rng = np.random.default_rng() with a deterministic one (e.g. rng = np.random.default_rng(0)) then the function becomes determinstic -> not needed. in the test below instead of calling the method just iterate over the values z_mit, dz_mit, z_raw, dz_raw from a table.

so just make the test deterministic

[NoureldinYosri]

almost there

[NoureldinYosri]

can you reformat this paragraph?