LRE failure for chunking

[purva-thakre]

Description

Noticed in #2601

https://github.com/unitaryfund/mitiq/actions/runs/12433520415/job/34715234002?pr=2601#step:6:4591

Originally, the test was written to confirm chunking a circuit performs worse in certain scenarios. However, this performance varies non-deterministically. Due to this reason, now the test is verifying there is a difference between two expectation values.

---

License

• I license this contribution under the terms of the GNU GPL, version 3 and grant Unitary Fund the right to provide additional permissions as described in section 7 of the GNU GPL, version 3.

Before opening the PR, please ensure you have completed the following where appropriate.

• I added unit tests for new code.
• I used type hints in function signatures.
• I used Google-style docstrings for functions.
• I updated the documentation where relevant.
• Added myself / the copyright holder to the AUTHORS file

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 98.74%. Comparing base (2dc8c4f) to head (3021921).
Report is 11 commits behind head on main.

Additional details and impacted files

@@           Coverage Diff           @@
##             main    #2608   +/-   ##
=======================================
  Coverage   98.73%   98.74%           
=======================================
  Files          92       93    +1     
  Lines        4193     4219   +26     
=======================================
+ Hits         4140     4166   +26     
  Misses         53       53           

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

[purva-thakre]

Converting this back to draft because @natestemen suggested to write a better test.

[purva-thakre]

@natestemen I cannot think of a better test here. Which is why I decided to check the function does provided a non-zero expectation value.

test_layerwise_folding already has a test comparing the number of noise-scaled layers for a chunked and a non-chunked circuit.

[natestemen]

I would argue that this test is unnecessary.

We already have tests that ensure that chunking works as expected (here, and here). The only thing this test could be doing (aside from asserting accuracy) is testing the number of circuits run is as expected, but this would be redundant from the above linked tests.

Should we remove it. WDYT?

[purva-thakre]

This test is verifying the executor works with chunking without any issues. I prefer to keep it.

[natestemen]

test is verifying the executor works with chunking

Okay, but we need to define this more specifically. If we know that the LRE config (with chunking) generates $n$ circuits, then what does "works" mean? That the executor runs $n$ times? That the extrapolation gets called with $n$ datapoints? That the extrapolation function, when input $n$ expectation values, produces an expectation value?

[purva-thakre]

that the lre executor takes num_chunks without any issues. I don't think this is tested elsewhere.

[natestemen]

Ah okay that's right! In that case, I think it should be sufficient to mock the executor, and ensure that it is run the correct number of times.

[purva-thakre]

I think it should be sufficient to mock the executor, and ensure that it is run the correct number of times.

Done!