Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

2274 Benchmark User Guide #2566

Open
wants to merge 33 commits into
base: main
Choose a base branch
from
Open
Show file tree
Hide file tree
Changes from 25 commits
Commits
Show all changes
33 commits
Select commit Hold shift + click to select a range
eedd305
adding benchmark user guide
Shivansh20128 Nov 11, 2024
215ecf6
adding benchmark circuit names
Shivansh20128 Nov 12, 2024
e7c3a3b
adding content for ghz
Shivansh20128 Nov 12, 2024
99b6848
updated changes
Shivansh20128 Nov 12, 2024
3648c29
updating example
Shivansh20128 Nov 12, 2024
63da003
adding examples to doc
Shivansh20128 Nov 13, 2024
f6876c2
adding documentation for benchmark circuits
Shivansh20128 Nov 13, 2024
d8b9232
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
f6a1ed8
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
07e298b
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
f1b36bb
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
ccb5586
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
e94ae2e
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
0a90ac5
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
e5e6746
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
0a17fb6
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 13, 2024
f9bca24
suggestions added
Shivansh20128 Nov 13, 2024
030a819
Merge branch 'unitaryfund:main' into 2274-benchmark-user-guide
Shivansh20128 Nov 13, 2024
8e07d13
changing circuit size in examples
Shivansh20128 Nov 14, 2024
d3dcfab
Merge branch '2274-benchmark-user-guide' of https://github.com/Shivan…
Shivansh20128 Nov 14, 2024
e03961a
adding ideal state of circuits
Shivansh20128 Nov 15, 2024
302eea0
adding mirror circuits example
Shivansh20128 Nov 15, 2024
e06c969
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 19, 2024
f82f54d
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 19, 2024
48c94a1
modifying acc to suggestions
Shivansh20128 Nov 19, 2024
5217250
Update docs/source/guide/benchmarks.md
Shivansh20128 Nov 22, 2024
9492572
changing to benchmarking-circuits
Shivansh20128 Nov 22, 2024
c0df4e0
Merge branch '2274-benchmark-user-guide' of https://github.com/Shivan…
Shivansh20128 Nov 22, 2024
ce2f673
reordering benchmark circuits
Shivansh20128 Nov 22, 2024
afb5b46
addition in w_state circuits suggested by Purva
Shivansh20128 Nov 23, 2024
36eb87d
Update docs/source/guide/benchmarking-circuits.md
Shivansh20128 Nov 26, 2024
3e48c5e
adding example and references
Shivansh20128 Nov 26, 2024
0ca08d1
adding print circuit statement
Shivansh20128 Nov 27, 2024
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
133 changes: 133 additions & 0 deletions docs/source/guide/benchmarks.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,133 @@
---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.11.4
kernelspec:
display_name: Python 3
language: python
name: python3
---

# Benchmarks
Shivansh20128 marked this conversation as resolved.
Show resolved Hide resolved

Mitiq benchmarks error mitigation techniques by evaluating improvements in metrics such as state fidelity (the closeness of the mitigated quantum state to the ideal state), output probability distributions, and logical error rates. The benchmarking process involves running diverse circuit types—such as GHZ, Mirror, Quantum Volume, and Randomized Benchmarking circuits—and comparing mitigated results against ideal theoretical outcomes. Additionally, Mitiq evaluates the overhead associated with each error mitigation technique, such as the increase in circuit depth or the number of samples required, as seen in methods like Zero Noise Extrapolation (ZNE) and Probabilistic Error Cancellation (PEC).

The following workflow demonstrates how to use benchmark circuits in Mitiq. In this example, we generate a GHZ circuit using Mitiq’s benchmarking tools and apply Zero Noise Extrapolation (ZNE) to mitigate errors introduced by depolarizing noise. The workflow is run on a simulator, where we compare results from an ideal circuit, a noisy circuit, and a mitigated circuit to evaluate the impact of error mitigation. The same approach can be extended to other benchmarking circuits provided by Mitiq.

```{code-cell} ipython3
purva-thakre marked this conversation as resolved.
Show resolved Hide resolved
import cirq
from mitiq import benchmarks, zne

def execute(circuit, noise_level=0.005):
"""Returns Tr[ρ |0⟩⟨0|] where ρ is the state prepared by the circuit
with depolarizing noise."""
noisy_circuit = circuit.with_noise(cirq.depolarize(p=noise_level))
return (
cirq.DensityMatrixSimulator()
.simulate(noisy_circuit)
.final_density_matrix[0, 0]
.real
)

circuit = benchmarks.generate_ghz_circuit(n_qubits=7) # Call the required benchmark circuit function here
print(circuit.final_state_vector()) # Shows the ideal circuit state
print(circuit)

true_value = execute(circuit, noise_level=0.0) # Ideal quantum computer
noisy_value = execute(circuit) # Noisy quantum computer
zne_value = zne.execute_with_zne(circuit, execute) # Noisy quantum computer + Mitiq

print(f"Error w/o Mitiq: {abs((true_value - noisy_value) / true_value):.3f}")
print(f"Error w Mitiq: {abs((true_value - zne_value) / true_value):.3f}")
```


## GHZ Circuits

The {func}`.generate_ghz_circuit` create the GHZ states that are highly sensitive to noise. A [GHZ (Greenberger–Horne–Zeilinger)](https://en.wikipedia.org/wiki/Greenberger-Horne-Zeilinger_state) state is a maximally entangled quantum state involving multiple qubits. Thus, they make it easy to test error rates in entanglement creation and preservation, which is central for many quantum algorithms.

```{code-cell} ipython3
from mitiq.benchmarks import generate_ghz_circuit

circuit = generate_ghz_circuit(n_qubits=7)
```

## Mirror Circuits

The {func}`.generate_mirror_circuit` involves running a quantum circuit forward and then “mirroring” it (applying the reverse operations). Ideally, this results in returning the system to the initial state, so they’re great for testing if the noise mitigation is effective in preserving information through complex sequences.


## Mirror Quantum Volume Circuits

The {func}`.generate_mirror_qv_circuit` is designed to test [Quantum Volume](https://en.wikipedia.org/wiki/Quantum_volume), a metric combining circuit depth, number of qubits, and fidelity. These circuits check whether error mitigation techniques help achieve higher effective quantum volumes on noisy devices.

```{code-cell} ipython3
from mitiq.benchmarks import generate_mirror_qv_circuit

circuit = generate_mirror_qv_circuit(num_qubits=7, depth=2)
```

## Quantum Phase Estimation Circuits

The {func}`.generate_qpe_circuit` is used to the measure eigenvalues of unitary operators. Since accurate phase estimation requires precise control over operations, these circuits test the mitigation techniques’ ability to handle small noise effects over multiple gate sequences.

```{code-cell} ipython3
from mitiq.benchmarks import generate_qpe_circuit

circuit = generate_qpe_circuit(evalue_reg=7)
```

## Quantum Volume Circuits
Shivansh20128 marked this conversation as resolved.
Show resolved Hide resolved

The {func}`.generate_quantum_volume_circuit` tests the maximum achievable "volume" or computational capacity of a quantum processor. Running these circuits with error mitigation tests if mitiq’s techniques improve the effective quantum volume.

```{code-cell} ipython3
from mitiq.benchmarks import generate_quantum_volume_circuit

circuit,_ = generate_quantum_volume_circuit(num_qubits=4, depth=7)
```

## Randomized Benchmarking Circuits

The {func}`.generate_rb_circuits` are sequences of random gates (generally Clifford gates), to estimate an average error rate. They’re standard in benchmarking for evaluating how well mitiq’s error mitigation reduces this error rate across different levels of noise.
Copy link
Collaborator

@purva-thakre purva-thakre Nov 14, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Can you add some details about what the state of each circuit is supposed to be? For example, the ideal output of a randomized benchmarking circuit is an identity.

GHZ and W circuits define a state. So, you could use some latex equations to show what the states are supposed to be etc.

We don't want to describe what the addition of noise will do to a circuit. the focus is on the details of the benchmarking circuit. All docstrings link a reference used to define a particular benchmarking circuit. You could use details from these refs if you don't know a lot about these circuits.

Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

You can also use .final_state_vector() to show the ideal circuit state, which is what we expect it to be.

from mitiq.benchmarks import generate_ghz_circuit
circuit = generate_ghz_circuit(n_qubits=3)
circuit.final_state_vector()

this will spit out the 1-D vector form of a 3 qubit GHZ state.

image

Copy link
Author

@Shivansh20128 Shivansh20128 Nov 15, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

You can also use .final_state_vector() to show the ideal circuit state, which is what we expect it to be.

Yes, I can add this function to the example workflow at the top of the file instead of adding it explicitly inside every circuit, so every circuit's ideal circuit state can be seen.

Copy link
Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We don't want to describe what the addition of noise will do to a circuit. the focus is on the details of the benchmarking circuit. All docstrings link a reference used to define a particular benchmarking circuit. You could use details from these refs if you don't know a lot about these circuits.

Since the section is about benchmarking, I believe we should show improvements with mitiq when compared to a noisy circuit without mitiq. But if you think otherwise, I can remove that part from the examples.

Also, since I have now added .final_state_vector(), shall I still go ahead and add the latex equations to show what the states are supposed to be?

Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The focus is on benchmarking circuits. Not benchmarking the performance of a QEM technique using mitiq.


```{code-cell} ipython3
from mitiq.benchmarks import generate_rb_circuits

circuits = generate_rb_circuits(n_qubits=1, num_cliffords=5)
circuit=circuits[0]
```

## Rotated Randomized Benchmarking Circuits

The {func}`.generate_rotated_rb_circuits` are sequences of random gates similar to {func}`.generate_rb_circuits`, but with rotations added, that allows assessment of errors beyond just the standard Clifford gates. They’re useful to check how well Mitiq handles noise in scenarios with more diverse gates.

```{code-cell} ipython3
from mitiq.benchmarks import generate_rotated_rb_circuits

circuits = generate_rotated_rb_circuits(n_qubits=1, num_cliffords=5)
circuit=circuits[0]
```

## Randomized Clifford+T Circuits

The {func}`.generate_random_clifford_t_circuit` add the T gate to the standard Clifford set, adding more complex operations to the random benchmarking. This type evaluates Mitiq’s performance with gate sets that go beyond the Clifford gates, crucial for fault-tolerant computing.

```{code-cell} ipython3
from mitiq.benchmarks import generate_random_clifford_t_circuit

circuit = generate_random_clifford_t_circuit(num_qubits=7, num_oneq_cliffords=2, num_twoq_cliffords=2, num_t_gates=2)
```

## W State Circuits

The {func}`.generate_w_circuit` are entangled circuits that distribute the entanglement across qubits differently than GHZ states. Testing with W state circuits can help explore how well a device maintains distributed entanglement in noisy environments.

```{code-cell} ipython3
from mitiq.benchmarks import generate_w_circuit

circuit = generate_w_circuit(n_qubits=7)
```
1 change: 1 addition & 0 deletions docs/source/guide/core-concepts.md
Original file line number Diff line number Diff line change
Expand Up @@ -8,4 +8,5 @@ frontends-backends.md
executors.md
observables.md
calibrators.md
benchmarks.md
```
Loading