XEB fidelity estimator for large circuits

cirq/__init__.py

@@ -85,6 +85,7 @@
 )
 
 from cirq.experiments import (
+    estimate_circuit_fidelity,
     generate_supremacy_circuit_google_v2,
     generate_supremacy_circuit_google_v2_bristlecone,
     generate_supremacy_circuit_google_v2_grid,

cirq/experiments/__init__.py

@@ -16,3 +16,6 @@
     build_entangling_layers,
     cross_entropy_benchmarking,
 )
+
+from cirq.experiments.fidelity_estimation import (
+    estimate_circuit_fidelity,)

cirq/experiments/fidelity_estimation.py

@@ -0,0 +1,51 @@
+"""Estimate fidelity of large random quantum circuit from observed bitstrings.
+
+Fidelity estimator defined here is used in cross-entropy benchmarking and
+works under the assumption that the evaluated circuit is sufficiently
+random, see https://arxiv.org/abs/1608.00263.
+"""
+
+from typing import cast, List, Sequence, Tuple
+
+import numpy as np
+
+from cirq.circuits import Circuit
+from cirq.ops import Qid
+from cirq.sim import Simulator, WaveFunctionTrialResult
+
+
+def estimate_circuit_fidelity(circuit: Circuit, qubit_order: Sequence[Qid],
+                              bitstrings: Sequence[int]) -> float:
+    """Computes fidelity estimate from one circuit using linear XEB estimator.
+
+    Args:
+        circuit: Random quantum circuit which has been executed on quantum
+            processor under test
+        qubit_order: Qubit order used to construct bitstrings from measurements
+        bitstrings: Results of terminal all-qubit measurements performed after
+            each circuit execution
+    Returns:
+        Estimate of circuit fidelity.
+    Raises:
+        ValueError: Circuit is inconsistent with qubit order or one of the
+            bitstrings is inconsistent with the number of qubits.
+    """
+    dim = 2**len(qubit_order)
+
+    if set(qubit_order) != circuit.all_qubits():
+        raise ValueError(
+            f'Inconsistent qubits: circuit has {circuit.all_qubits()}, '
+            f'qubit order is {qubit_order}')
+    for bitstring in bitstrings:
+        if bitstring < 0 or dim <= bitstring:
+            raise ValueError(
+                f'Bitstring {bitstring} could not have been observed '
+                f'on {len(qubit_order)} qubits.')
+
+    simulator = Simulator()
+    result = cast(WaveFunctionTrialResult,
+                  simulator.simulate(circuit, qubit_order=qubit_order))
+    output_probabilities = np.abs(result.final_state)**2
+    assert 1 - 1e-4 < np.sum(output_probabilities) < 1 + 1e-4
+    fidelity_estimate = dim * np.mean(output_probabilities[bitstrings]) - 1
+    return fidelity_estimate

cirq/experiments/fidelity_estimation_test.py

@@ -0,0 +1,59 @@
+from typing import Sequence
+
+import numpy as np
+import pytest
+
+import cirq
+
+
+def make_bitstrings(samples: np.ndarray) -> Sequence[int]:
+    assert samples.shape[1] == 2
+    return [2 * b1 + b0 for b1, b0 in samples]
+
+
+def sample_noisy_bitstrings(circuit: cirq.Circuit, depolarization: float,
+                            n_samples: int) -> Sequence[int]:
+    assert 0 <= depolarization <= 1
+    n_incoherent = int(depolarization * n_samples)
+    n_coherent = n_samples - n_incoherent
+    incoherent_samples = np.random.randint(2, size=(n_incoherent, 2))
+    if n_coherent > 0:
+        sim = cirq.Simulator()
+        r = sim.run(circuit, repetitions=n_coherent)
+        coherent_samples = r.measurements['0,1']
+        all_samples = np.concatenate((coherent_samples, incoherent_samples))
+        return make_bitstrings(all_samples)
+    return make_bitstrings(incoherent_samples)
+
+
+@pytest.mark.parametrize('depolarization', (0, 0.25, 0.5, 0.75, 1.0))
+def test_estimate_circuit_fidelity(depolarization):
+    prng_state = np.random.get_state()
+    np.random.seed(0)
+
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit.from_ops(cirq.H(q0), cirq.CNOT(q0, q1),
+                                    cirq.measure(q0, q1))
+    bitstrings = sample_noisy_bitstrings(circuit, depolarization, 10000)
+    f = cirq.estimate_circuit_fidelity(circuit, (q0, q1), bitstrings)
+    assert np.isclose(f, 1 - depolarization, atol=0.026)
+
+    np.random.set_state(prng_state)
+
+
+def test_estimate_circuit_fidelity_invalid_qubits():
+    q0, q1, q2 = cirq.LineQubit.range(3)
+    circuit = cirq.Circuit.from_ops(cirq.H(q0), cirq.CNOT(q0, q1),
+                                    cirq.measure(q0, q1))
+    bitstrings = sample_noisy_bitstrings(circuit, 0.9, 10)
+    with pytest.raises(ValueError):
+        cirq.estimate_circuit_fidelity(circuit, (q0, q1, q2), bitstrings)
+
+
+def test_estimate_circuit_fidelity_invalid_bitstrings():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit.from_ops(cirq.H(q0), cirq.CNOT(q0, q1),
+                                    cirq.measure(q0, q1))
+    bitstrings = [0, 1, 2, 3, 4]
+    with pytest.raises(ValueError):
+        cirq.estimate_circuit_fidelity(circuit, (q0, q1), bitstrings)