Remove deprecated experiments (quantumlib#5674)

    - Removes deprecated functions, classes, and modules from experiments.
    - CrossEntropyResult and CrossEntropyResult are still there since they
    need json backwards compatibility.  Will follow up with later PR for it.

Author: dstrain115

cirq-core/cirq/__init__.py

@@ -110,15 +110,10 @@
     estimate_parallel_single_qubit_readout_errors,
     estimate_single_qubit_readout_errors,
     hog_score_xeb_fidelity_from_probabilities,
-    least_squares_xeb_fidelity_from_expectations,
-    least_squares_xeb_fidelity_from_probabilities,
     linear_xeb_fidelity,
     linear_xeb_fidelity_from_probabilities,
     log_xeb_fidelity,
     log_xeb_fidelity_from_probabilities,
-    generate_boixo_2018_supremacy_circuits_v2,
-    generate_boixo_2018_supremacy_circuits_v2_bristlecone,
-    generate_boixo_2018_supremacy_circuits_v2_grid,
     measure_confusion_matrix,
     xeb_fidelity,
 )

cirq-core/cirq/experiments/__init__.py

@@ -13,12 +13,6 @@
 # limitations under the License.
 """Experiments and tools for characterizing quantum operations."""
 
-from cirq.experiments.google_v2_supremacy_circuit import (
-    generate_boixo_2018_supremacy_circuits_v2,
-    generate_boixo_2018_supremacy_circuits_v2_bristlecone,
-    generate_boixo_2018_supremacy_circuits_v2_grid,
-)
-
 from cirq.experiments.qubit_characterizations import (
     RandomizedBenchMarkResult,
     single_qubit_randomized_benchmarking,
@@ -28,29 +22,17 @@
     two_qubit_state_tomography,
 )
 
-from cirq.experiments.cross_entropy_benchmarking import (
-    build_entangling_layers,
-    cross_entropy_benchmarking,
-    CrossEntropyResult,
-    CrossEntropyResultDict,
-)
+from cirq.experiments.cross_entropy_benchmarking import CrossEntropyResult, CrossEntropyResultDict
 
 from cirq.experiments.fidelity_estimation import (
     hog_score_xeb_fidelity_from_probabilities,
-    least_squares_xeb_fidelity_from_expectations,
-    least_squares_xeb_fidelity_from_probabilities,
-    linear_xeb_fidelity,
     linear_xeb_fidelity_from_probabilities,
+    linear_xeb_fidelity,
     log_xeb_fidelity,
     log_xeb_fidelity_from_probabilities,
     xeb_fidelity,
 )
 
-from cirq.experiments.grid_parallel_two_qubit_xeb import (
-    collect_grid_parallel_two_qubit_xeb_data,
-    compute_grid_parallel_two_qubit_xeb_results,
-)
-
 from cirq.experiments.purity_estimation import purity_from_probabilities
 
 from cirq.experiments.random_quantum_circuit_generation import (

cirq-core/cirq/experiments/cross_entropy_benchmarking.py

@@ -12,24 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import (
-    Any,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Set,
-    TYPE_CHECKING,
-    Tuple,
-    Union,
-)
+from typing import Any, Dict, List, Mapping, NamedTuple, Optional, Sequence, TYPE_CHECKING, Tuple
 import dataclasses
 import numpy as np
 from matplotlib import pyplot as plt
-from cirq import _compat, _import, circuits, devices, ops, protocols, sim, value, work
+from cirq import _compat, _import, protocols
 
 if TYPE_CHECKING:
     import cirq
@@ -280,344 +267,3 @@ def __iter__(self):
 
     def __len__(self):
         return len(self.results)
-
-
-@_compat.deprecated(
-    deadline='v0.16', fix=('Use cirq.experiments.xeb_fitting.benchmark_2q_xeb_fidelities instead')
-)
-def cross_entropy_benchmarking(
-    sampler: work.Sampler,
-    qubits: Sequence[ops.Qid],
-    *,
-    benchmark_ops: Sequence[circuits.Moment] = None,
-    num_circuits: int = 20,
-    repetitions: int = 1000,
-    cycles: Union[int, Iterable[int]] = range(2, 103, 10),
-    scrambling_gates_per_cycle: List[List[ops.Gate]] = None,
-    simulator: sim.Simulator = None,
-) -> CrossEntropyResult:
-    r"""Cross-entropy benchmarking (XEB) of multiple qubits.
-
-    A total of M random circuits are generated, each of which comprises N
-    layers where N = max('cycles') or 'cycles' if a single value is specified
-    for the 'cycles' parameter. Every layer contains randomly generated
-    single-qubit gates applied to each qubit, followed by a set of
-    user-defined benchmarking operations (e.g. a set of two-qubit gates).
-
-    Each circuit (circuit_m) from the M random circuits is further used to
-    generate a set of circuits {circuit_mn}, where circuit_mn is built from the
-    first n cycles of circuit_m. n spans all the values in 'cycles'.
-
-    For each fixed value n, the experiment performs the following:
-
-    1) Experimentally collect a number of bit-strings for each circuit_mn via
-    projective measurements in the z-basis.
-
-    2) Theoretically compute the expected bit-string probabilities
-    $P^{th, mn}_|...00>$,  $P^{th, mn}_|...01>$, $P^{th, mn}_|...10>$,
-    $P^{th, mn}_|...11>$ ... at the end of circuit_mn for all m and for all
-    possible bit-strings in the Hilbert space.
-
-    3) Compute an experimental XEB function for each circuit_mn:
-
-    $f_{mn}^{meas} = \langle D * P^{th, mn}_q - 1 \rangle$
-
-    where D is the number of states in the Hilbert space, $P^{th, mn}_q$ is the
-    theoretical probability of a bit-string q at the end of circuit_mn, and
-    $\langle \rangle$ corresponds to the ensemble average over all measured
-    bit-strings.
-
-    Then, take the average of $f_{mn}^{meas}$ over all circuit_mn with fixed
-    n to obtain:
-
-    $f_{n}^{meas} = (\sum_m f_{mn}^{meas}) / M$
-
-    4) Compute a theoretical XEB function for each circuit_mn:
-
-    $f_{mn}^{th} = D \sum_q (P^{th, mn}_q) ** 2 - 1$
-
-    where the summation goes over all possible bit-strings q in the Hilbert
-    space.
-
-    Similarly, we then average $f_m^{th}$ over all circuit_mn with fixed n to
-    obtain:
-
-    $f_{n}^{th} = (\sum_m f_{mn}^{th}) / M$
-
-    5) Calculate the XEB fidelity $\alpha_n$ at fixed n:
-
-    $\alpha_n = f_{n} ^ {meas} / f_{n} ^ {th}$
-
-    Args:
-        sampler: The quantum engine or simulator to run the circuits.
-        qubits: The qubits included in the XEB experiment.
-        benchmark_ops: A sequence of circuits.Moment containing gate operations
-            between specific qubits which are to be benchmarked for fidelity.
-            If more than one circuits.Moment is specified, the random circuits
-            will rotate between the circuits.Moment's. As an example,
-            if benchmark_ops = [Moment([ops.CZ(q0, q1), ops.CZ(q2, q3)]),
-            Moment([ops.CZ(q1, q2)]) where q0, q1, q2 and q3 are instances of
-            Qid (such as GridQubits), each random circuit will apply CZ gate
-            between q0 and q1 plus CZ between q2 and q3 for the first cycle,
-            CZ gate between q1 and q2 for the second cycle, CZ between q0 and
-            q1 and CZ between q2 and q3 for the third cycle and so on. If
-            None, the circuits will consist only of single-qubit gates.
-        num_circuits: The total number of random circuits to be used.
-        repetitions: The number of measurements for each circuit to estimate
-            the bit-string probabilities.
-        cycles: The different numbers of circuit layers in the XEB study.
-            Could be a single or a collection of values.
-        scrambling_gates_per_cycle: If None (by default), the single-qubit
-            gates are chosen from X/2 ($\pi/2$ rotation around the X axis),
-            Y/2 ($\pi/2$ rotation around the Y axis) and (X + Y)/2 ($\pi/2$
-            rotation around an axis $\pi/4$ away from the X on the equator of
-            the Bloch sphere). Otherwise the single-qubit gates for each layer
-            are chosen from a list of possible choices (each choice is a list
-            of one or more single-qubit gates).
-        simulator: A simulator that calculates the bit-string probabilities
-            of the ideal circuit. By default, this is set to sim.Simulator().
-
-    Returns:
-        A CrossEntropyResult object that stores and plots the result.
-    """
-    simulator = sim.Simulator() if simulator is None else simulator
-    num_qubits = len(qubits)
-
-    if isinstance(cycles, int):
-        cycle_range = [cycles]
-    else:
-        cycle_range = list(cycles)
-
-    # These store the measured and simulated bit-string probabilities from
-    # all trials in two dictionaries. The keys of the dictionaries are the
-    # numbers of cycles. The values are 2D arrays with each row being the
-    # probabilities obtained from a single trial.
-    probs_meas = {n: np.zeros((num_circuits, 2**num_qubits)) for n in cycle_range}
-    probs_th = {n: np.zeros((num_circuits, 2**num_qubits)) for n in cycle_range}
-
-    for k in range(num_circuits):
-
-        # Generates one random XEB circuit with max(num_cycle_range) cycles.
-        # Then the first n cycles of the circuit are taken to generate
-        # shorter circuits with n cycles (n taken from cycles). All of these
-        # circuits are stored in circuits_k.
-        circuits_k = _build_xeb_circuits(
-            qubits, cycle_range, scrambling_gates_per_cycle, benchmark_ops
-        )
-
-        # Run each circuit with the sampler to obtain a collection of
-        # bit-strings, from which the bit-string probabilities are estimated.
-        probs_meas_k = _measure_prob_distribution(sampler, repetitions, qubits, circuits_k)
-
-        # Simulate each circuit with the Cirq simulator to obtain the
-        # state vector at the end of each circuit, from which the
-        # theoretically expected bit-string probabilities are obtained.
-        probs_th_k: List[np.ndarray] = []
-        for circ_k in circuits_k:
-            res = simulator.simulate(circ_k, qubit_order=qubits)
-            state_probs = value.state_vector_to_probabilities(np.asarray(res.final_state_vector))
-            probs_th_k.append(state_probs)
-
-        for i, num_cycle in enumerate(cycle_range):
-            probs_th[num_cycle][k, :] = probs_th_k[i]
-            probs_meas[num_cycle][k, :] = probs_meas_k[i]
-
-    fidelity_vals = _xeb_fidelities(probs_th, probs_meas)
-    xeb_data = [CrossEntropyPair(c, k) for (c, k) in zip(cycle_range, fidelity_vals)]
-    return CrossEntropyResult(data=xeb_data, repetitions=repetitions)  # type: ignore
-
-
-@_compat.deprecated(
-    deadline='v0.16', fix=('Use cirq.experiments.random_quantum_circuit_generation instead')
-)
-def build_entangling_layers(
-    qubits: Sequence[devices.GridQubit], two_qubit_gate: ops.Gate
-) -> List[circuits.Moment]:
-    """Builds a sequence of gates that entangle all pairs of qubits on a grid.
-
-    The qubits are restricted to be physically on a square grid with distinct
-    row and column indices (not every node of the grid needs to have a
-    qubit). To entangle all pairs of qubits, a user-specified two-qubit gate
-    is applied between each and every pair of qubit that are next to each
-    other. In general, a total of four sets of parallel operations are needed to
-    perform all possible two-qubit gates. We proceed as follows:
-
-    The first layer applies two-qubit gates to qubits (i, j) and (i, j + 1)
-    where i is any integer and j is an even integer. The second layer
-    applies two-qubit gates to qubits (i, j) and (i + 1, j) where i is an even
-    integer and j is any integer. The third layer applies two-qubit gates
-    to qubits (i, j) and (i, j + 1) where i is any integer and j is an odd
-    integer. The fourth layer applies two-qubit gates to qubits (i, j) and
-    (i + 1, j) where i is an odd integer and j is any integer.
-
-    After the layers are built as above, any empty layer is ejected.:
-
-                 Cycle 1:                            Cycle 2:
-        q00 ── q01    q02 ── q03            q00    q01    q02    q03
-                                             |      |      |      |
-        q10 ── q11    q12 ── q13            q10    q11    q12    q13
-
-        q20 ── q21    q22 ── q23            q20    q21    q22    q23
-                                             |      |      |      |
-        q30 ── q31    q32 ── q33            q30    q31    q32    q33
-
-                  Cycle 3:                           Cycle 4:
-        q00    q01 ── q02    q03            q00    q01    q02    q03
-
-        q10    q11 ── q12    q13            q10    q11    q12    q13
-                                             |      |      |      |
-        q20    q21 ── q22    q23            q20    q21    q22    q23
-
-        q30    q31 ── q32    q33            q30    q31    q32    q33
-
-    Args:
-        qubits: The grid qubits included in the entangling operations.
-        two_qubit_gate: The two-qubit gate to be applied between all
-            neighboring pairs of qubits.
-
-    Returns:
-        A list of circuits.Moment, with a maximum length of 4. Each circuits.Moment
-        includes two-qubit gates which can be performed at the same time.
-
-    Raises:
-        ValueError: two-qubit gate is not used.
-    """
-    if protocols.num_qubits(two_qubit_gate) != 2:
-        raise ValueError('Input must be a two-qubit gate')
-    interaction_sequence = _default_interaction_sequence(qubits)
-    return [
-        circuits.Moment([two_qubit_gate(q_a, q_b) for (q_a, q_b) in pairs])
-        for pairs in interaction_sequence
-    ]
-
-
-def _build_xeb_circuits(
-    qubits: Sequence[ops.Qid],
-    cycles: Sequence[int],
-    single_qubit_gates: List[List[ops.Gate]] = None,
-    benchmark_ops: Sequence[circuits.Moment] = None,
-) -> List[circuits.Circuit]:
-    if benchmark_ops is not None:
-        num_d = len(benchmark_ops)
-    else:
-        num_d = 0
-    max_cycles = max(cycles)
-
-    if single_qubit_gates is None:
-        single_rots = _random_half_rotations(qubits, max_cycles)
-    else:
-        single_rots = _random_any_gates(qubits, single_qubit_gates, max_cycles)
-    all_circuits: List[circuits.Circuit] = []
-    for num_cycles in cycles:
-        circuit_exp = circuits.Circuit()
-        for i in range(num_cycles):
-            circuit_exp.append(single_rots[i])
-            if benchmark_ops is not None:
-                for op_set in benchmark_ops[i % num_d]:
-                    circuit_exp.append(op_set)
-        all_circuits.append(circuit_exp)
-    return all_circuits
-
-
-def _measure_prob_distribution(
-    sampler: work.Sampler,
-    repetitions: int,
-    qubits: Sequence[ops.Qid],
-    circuit_list: List[circuits.Circuit],
-) -> List[np.ndarray]:
-    all_probs: List[np.ndarray] = []
-    num_states = 2 ** len(qubits)
-    for circuit in circuit_list:
-        trial_circuit = circuit.copy()
-        trial_circuit.append(ops.measure(*qubits, key='z'))
-        res = sampler.run(trial_circuit, repetitions=repetitions)
-        res_hist = dict(res.histogram(key='z'))
-        probs = np.zeros(num_states, dtype=float)
-        for k, v in res_hist.items():
-            probs[k] = float(v) / float(repetitions)
-        all_probs.append(probs)
-    return all_probs
-
-
-def _xeb_fidelities(
-    probs_th: Dict[int, np.ndarray], probs_meas: Dict[int, np.ndarray]
-) -> List[float]:
-    """Compute XEB fidelity estimates for all circuit depths.
-
-    Args:
-        probs_th: Theoretical output probabilities by cycle number.
-        probs_meas: Experimental output probabilities by cycle number.
-    Returns:
-        List of fidelity estimates for each circuit depth.
-    """
-    num_cycles = sorted(list(probs_th.keys()))
-    return [_compute_fidelity(probs_th[n], probs_meas[n]) for n in num_cycles]
-
-
-def _compute_fidelity(probs_th: np.ndarray, probs_meas: np.ndarray) -> float:
-    """Compute XEB fidelity estimate.
-
-    Args:
-        probs_th: Theoretical output probabilities.
-        probs_meas: Experimental output probabilities.
-    Returns:
-        XEB fidelity estimate.
-    """
-    _, num_states = probs_th.shape
-    pp_cross = probs_th * probs_meas
-    pp_th = probs_th**2
-    f_meas = np.mean(num_states * np.sum(pp_cross, axis=1) - 1.0)
-    f_th = np.mean(num_states * np.sum(pp_th, axis=1) - 1.0)
-    return float(f_meas / f_th)
-
-
-def _random_half_rotations(qubits: Sequence[ops.Qid], num_layers: int) -> List[List[ops.OP_TREE]]:
-    rot_ops = [ops.X**0.5, ops.Y**0.5, ops.PhasedXPowGate(phase_exponent=0.25, exponent=0.5)]
-    num_qubits = len(qubits)
-    rand_nums = np.random.choice(3, (num_qubits, num_layers))
-    single_q_layers: List[List[ops.OP_TREE]] = []
-    for i in range(num_layers):
-        single_q_layers.append([rot_ops[rand_nums[j, i]](qubits[j]) for j in range(num_qubits)])
-    return single_q_layers
-
-
-def _random_any_gates(
-    qubits: Sequence[ops.Qid], op_list: List[List[ops.Gate]], num_layers: int
-) -> List[List[ops.OP_TREE]]:
-    num_ops = len(op_list)
-    num_qubits = len(qubits)
-    rand_nums = np.random.choice(num_ops, (num_qubits, num_layers))
-    single_q_layers: List[List[ops.OP_TREE]] = []
-    for i in range(num_layers):
-        rots_i: List[ops.OP_TREE] = []
-        for j in range(num_qubits):
-            rots_i.extend([rot(qubits[j]) for rot in op_list[rand_nums[j, i]]])
-        single_q_layers.append(rots_i)
-    return single_q_layers
-
-
-def _default_interaction_sequence(
-    qubits: Sequence[devices.GridQubit],
-) -> List[Set[Tuple[devices.GridQubit, devices.GridQubit]]]:
-    qubit_dict = {(qubit.row, qubit.col): qubit for qubit in qubits}
-    qubit_locs = set(qubit_dict)
-    num_rows = max([q.row for q in qubits]) + 1
-    num_cols = max([q.col for q in qubits]) + 1
-
-    l_s: List[Set[Tuple[devices.GridQubit, devices.GridQubit]]] = [set() for _ in range(4)]
-    for i in range(num_rows):
-        for j in range(num_cols - 1):
-            if (i, j) in qubit_locs and (i, j + 1) in qubit_locs:
-                l_s[j % 2 * 2].add((qubit_dict[(i, j)], qubit_dict[(i, j + 1)]))
-
-    for i in range(num_rows - 1):
-        for j in range(num_cols):
-            if (i, j) in qubit_locs and (i + 1, j) in qubit_locs:
-                l_s[i % 2 * 2 + 1].add((qubit_dict[(i, j)], qubit_dict[(i + 1, j)]))
-
-    l_final: List[Set[Tuple[devices.GridQubit, devices.GridQubit]]] = []
-    for gate_set in l_s:
-        if len(gate_set) != 0:
-            l_final.append(gate_set)
-
-    return l_final

cirq-core/cirq/experiments/cross_entropy_benchmarking_test.py

@@ -12,105 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import matplotlib.pyplot as plt
 import numpy as np
 import pytest
 import cirq
 
-from cirq.experiments import (
-    CrossEntropyResult,
-    CrossEntropyResultDict,
-    cross_entropy_benchmarking,
-    build_entangling_layers,
-)
+from cirq.experiments import CrossEntropyResult, CrossEntropyResultDict
 from cirq.experiments.cross_entropy_benchmarking import CrossEntropyPair, SpecklePurityPair
 
 _DEPRECATION_MESSAGE = 'Use cirq.experiments.xeb_fitting.XEBCharacterizationResult instead'
 _DEPRECATION_RANDOM_CIRCUIT = 'Use cirq.experiments.random_quantum_circuit_generation instead'
 
 
-@pytest.mark.usefixtures('closefigures')
-def test_cross_entropy_benchmarking():
-    # Check that the fidelities returned from a four-qubit XEB simulation are
-    # close to 1 (deviations from 1 is expected due to finite number of
-    # measurements).
-    simulator = cirq.Simulator()
-    qubits = cirq.GridQubit.square(2)
-
-    # Sanity check single-qubit-gate causes error
-    with pytest.raises(ValueError):
-        with cirq.testing.assert_deprecated(_DEPRECATION_RANDOM_CIRCUIT, deadline='v0.16'):
-            build_entangling_layers(qubits, cirq.Z**0.91)
-
-    # Build a sequence of CZ gates.
-    with cirq.testing.assert_deprecated(_DEPRECATION_RANDOM_CIRCUIT, deadline='v0.16'):
-        interleaved_ops = build_entangling_layers(qubits, cirq.CZ**0.91)
-
-    # Specify a set of single-qubit rotations. Pick prime numbers for the
-    # exponent to avoid evolving the system into a basis state.
-    single_qubit_rots = [
-        [cirq.X**0.37],
-        [cirq.Y**0.73, cirq.X**0.53],
-        [cirq.Z**0.61, cirq.X**0.43],
-        [cirq.Y**0.19],
-    ]
-
-    # Simulate XEB using the default single-qubit gate set without two-qubit
-    # gates, XEB using the specified single-qubit gate set without two-qubit
-    # gates, and XEB using the specified single-qubit gate set with two-qubit
-    # gate. Check that the fidelities are close to 1.0 in all cases. Also,
-    # check that a single XEB fidelity is returned if a single cycle number
-    # is specified.
-
-    # Each of theese has one ideprecation for cross_entropy_benchmarking
-    # and one deprecation for CrossEntropyResult
-    with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16', count=2):
-        results_0 = cross_entropy_benchmarking(
-            simulator, qubits, num_circuits=3, repetitions=1000, cycles=range(4, 20, 5)
-        )
-    with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16', count=2):
-        results_1 = cross_entropy_benchmarking(
-            simulator,
-            qubits,
-            num_circuits=3,
-            repetitions=1000,
-            cycles=[4, 8, 12],
-            scrambling_gates_per_cycle=single_qubit_rots,
-        )
-    with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16', count=2):
-        results_2 = cross_entropy_benchmarking(
-            simulator,
-            qubits,
-            benchmark_ops=interleaved_ops,
-            num_circuits=3,
-            repetitions=1000,
-            cycles=[4, 8, 12],
-            scrambling_gates_per_cycle=single_qubit_rots,
-        )
-    with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16', count=2):
-        results_3 = cross_entropy_benchmarking(
-            simulator,
-            qubits,
-            benchmark_ops=interleaved_ops,
-            num_circuits=3,
-            repetitions=1000,
-            cycles=15,
-            scrambling_gates_per_cycle=single_qubit_rots,
-        )
-    fidelities_0 = [datum.xeb_fidelity for datum in results_0.data]
-    fidelities_1 = [datum.xeb_fidelity for datum in results_1.data]
-    fidelities_2 = [datum.xeb_fidelity for datum in results_2.data]
-    fidelities_3 = [datum.xeb_fidelity for datum in results_3.data]
-    assert np.isclose(np.mean(fidelities_0), 1.0, atol=0.1)
-    assert np.isclose(np.mean(fidelities_1), 1.0, atol=0.1)
-    assert np.isclose(np.mean(fidelities_2), 1.0, atol=0.1)
-    assert len(fidelities_3) == 1
-
-    # Sanity test that plot runs.
-    ax = plt.subplot()
-    results_1.plot(ax)
-
-
 def test_cross_entropy_result_depolarizing_models():
     with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16'):
         prng = np.random.RandomState(59566)
@@ -156,6 +68,7 @@ def test_cross_entropy_result_dict_repr():
         )
     with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16'):
         result_dict = CrossEntropyResultDict(results={pair: result})
+        assert len(result_dict) == 1
     with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16', count=6):
         cirq.testing.assert_equivalent_repr(result_dict)
 

cirq-core/cirq/experiments/fidelity_estimation.py

@@ -12,11 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Estimation of fidelity associated with experimental circuit executions."""
-from typing import Callable, List, Mapping, Optional, Sequence, Tuple, cast
+from typing import Callable, Mapping, Optional, Sequence
 
 import numpy as np
 
-from cirq import _compat
 from cirq.circuits import Circuit
 from cirq.ops import QubitOrder, QubitOrderOrList
 from cirq.sim import final_state_vector
@@ -223,162 +222,3 @@ def log_xeb_fidelity(
     return xeb_fidelity(
         circuit, bitstrings, qubit_order, amplitudes, estimator=log_xeb_fidelity_from_probabilities
     )
-
-
-@_compat.deprecated(
-    deadline='v0.16',
-    fix=(
-        'Use cirq.experiments.xeb_fitting '
-        '(benchmark_2q_xeb_fidelities and fit_exponential_decays) instead.'
-    ),
-)
-def least_squares_xeb_fidelity_from_expectations(
-    measured_expectations: Sequence[float],
-    exact_expectations: Sequence[float],
-    uniform_expectations: Sequence[float],
-) -> Tuple[float, List[float]]:
-    """Least squares fidelity estimator.
-
-    An XEB experiment collects data from the execution of random circuits
-    subject to noise. The effect of applying a random circuit with unitary U is
-    modeled as U followed by a depolarizing channel. The result is that the
-    initial state |𝜓⟩ is mapped to a density matrix ρ_U as follows:
-
-        |𝜓⟩ → ρ_U = f |𝜓_U⟩⟨𝜓_U| + (1 - f) I / D
-
-    where |𝜓_U⟩ = U|𝜓⟩, D is the dimension of the Hilbert space, I / D is the
-    maximally mixed state, and f is the fidelity with which the circuit is
-    applied. Let O_U be an observable that is diagonal in the computational
-    basis. Then the expectation of O_U on ρ_U is given by
-
-        Tr(ρ_U O_U) = f ⟨𝜓_U|O_U|𝜓_U⟩ + (1 - f) Tr(O_U / D).
-
-    This equation shows how f can be estimated, since Tr(ρ_U O_U) can be
-    estimated from experimental data, and ⟨𝜓_U|O_U|𝜓_U⟩ and Tr(O_U / D) can be
-    computed numerically.
-
-    Let e_U = ⟨𝜓_U|O_U|𝜓_U⟩, u_U = Tr(O_U / D), and m_U denote the experimental
-    estimate of Tr(ρ_U O_U). Then we estimate f by performing least squares
-    minimization of the quantity
-
-        f (e_U - u_U) - (m_U - u_U)
-
-    over different random circuits (giving different U). The solution to the
-    least squares problem is given by
-
-        f = (∑_U (m_U - u_U) * (e_U - u_U)) / (∑_U (e_U - u_U)^2).
-
-    Args:
-        measured_expectations: A sequence of the m_U, the experimental estimates
-            of the observable, one for each circuit U.
-        exact_expectations: A sequence of the e_U, the exact value of the
-            observable. The order should match the order of the
-            `measured_expectations` argument.
-        uniform_expectations: A sequence of the u_U, the expectation of the
-            observable on a uniformly random bitstring. The order should match
-            the order in the other arguments.
-
-    Returns:
-        A tuple of two values. The first value is the estimated fidelity.
-        The second value is a list of the residuals
-
-            f (e_U - u_U) - (m_U - u_U)
-
-        of the least squares minimization.
-
-    Raises:
-        ValueError: The lengths of the input sequences are not all the same.
-    """
-    if not (len(measured_expectations) == len(exact_expectations) == len(uniform_expectations)):
-        raise ValueError(
-            'The lengths of measured_expectations, '
-            'exact_expectations, and uniform_expectations must '
-            'all be the same. Got lengths '
-            f'{len(measured_expectations)}, '
-            f'{len(exact_expectations)}, and '
-            f'{len(uniform_expectations)}.'
-        )
-    numerator = 0.0
-    denominator = 0.0
-    for m, e, u in zip(measured_expectations, exact_expectations, uniform_expectations):
-        numerator += (m - u) * (e - u)
-        denominator += (e - u) ** 2
-    fidelity = numerator / denominator
-    residuals = [
-        fidelity * (e - u) - (m - u)
-        for m, e, u in zip(measured_expectations, exact_expectations, uniform_expectations)
-    ]
-    return fidelity, residuals
-
-
-@_compat.deprecated(
-    deadline='v0.16',
-    fix=(
-        'Use cirq.experiments.xeb_fitting '
-        '(benchmark_2q_xeb_fidelities and fit_exponential_decays) instead.'
-    ),
-)
-def least_squares_xeb_fidelity_from_probabilities(
-    hilbert_space_dimension: int,
-    observed_probabilities: Sequence[Sequence[float]],
-    all_probabilities: Sequence[Sequence[float]],
-    observable_from_probability: Optional[Callable[[float], float]] = None,
-    normalize_probabilities: bool = True,
-) -> Tuple[float, List[float]]:
-    """Least squares fidelity estimator with observable based on probabilities.
-
-    Using the notation from the docstring of
-    `least_squares_xeb_fidelity_from_expectations`, this function computes the
-    least squares fidelity estimate when the observable O_U has eigenvalue
-    corresponding to the computational basis state |z⟩ given by g(p(z)), where
-    p(z) = |⟨z|𝜓_U⟩|^2 and g is a function that can be specified. By default,
-    g is the identity function, but other choices, such as the logarithm, are
-    useful. By default, the probability p(z) is actually multiplied by the
-    Hilbert space dimension D, so that the observable is actually g(D * p(z)).
-    This behavior can be disabled by setting `normalize_probabilities` to
-    False.
-
-    Args:
-        hilbert_space_dimension: Dimension of the Hilbert space on which
-           the channel whose fidelity is being estimated is defined.
-        observed_probabilities: Ideal probabilities of bitstrings observed in
-            experiments. A list of lists, where each inner list contains the
-            probabilities for a single circuit.
-        all_probabilities: Ideal probabilities of all possible bitstrings.
-            A list of lists, where each inner list contains the probabilities
-            for a single circuit, and should have length equal to the Hilbert
-            space dimension. The order of the lists should correspond to that
-            of `observed_probabilities`.
-        observable_from_probability: Function that computes the observable from
-            a given probability.
-        normalize_probabilities: Whether to multiply the probabilities by the
-            Hilbert space dimension before computing the observable.
-
-    Returns:
-        A tuple of two values. The first value is the estimated fidelity.
-        The second value is a list of the residuals
-
-            f (e_U - u_U) - (m_U - u_U)
-
-        of the least squares minimization.
-    """
-    if not isinstance(observable_from_probability, np.ufunc):
-        if observable_from_probability is None:
-            observable_from_probability = lambda p: p
-        else:
-            observable_from_probability = np.frompyfunc(observable_from_probability, 1, 1)
-    observable_from_probability = cast(Callable, observable_from_probability)
-    measured_expectations = []
-    exact_expectations = []
-    uniform_expectations = []
-    prefactor = hilbert_space_dimension if normalize_probabilities else 1.0
-    for observed_probs, all_probs in zip(observed_probabilities, all_probabilities):
-        observable = observable_from_probability(prefactor * np.array(all_probs))
-        measured_expectations.append(
-            np.mean(observable_from_probability(prefactor * np.array(observed_probs)))
-        )
-        exact_expectations.append(np.sum(all_probs * observable))
-        uniform_expectations.append(np.sum(observable) / hilbert_space_dimension)
-    return least_squares_xeb_fidelity_from_expectations(
-        measured_expectations, exact_expectations, uniform_expectations
-    )

cirq-core/cirq/experiments/fidelity_estimation_test.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import itertools
-import math
 from typing import Sequence
 
 import numpy as np
@@ -143,108 +142,3 @@ def test_xeb_fidelity_tuple_input():
     f1 = cirq.xeb_fidelity(circuit, bitstrings, (q0, q1))
     f2 = cirq.xeb_fidelity(circuit, tuple(bitstrings), (q0, q1))
     assert f1 == f2
-
-
-def test_least_squares_xeb_fidelity_from_expectations():
-    prng_state = np.random.get_state()
-    np.random.seed(0)
-
-    depolarization = 0.5
-
-    n_qubits = 5
-    dim = 2**n_qubits
-    n_circuits = 10
-    qubits = cirq.LineQubit.range(n_qubits)
-
-    measured_expectations_lin = []
-    exact_expectations_lin = []
-    measured_expectations_log = []
-    exact_expectations_log = []
-    uniform_expectations_log = []
-    for _ in range(n_circuits):
-        circuit = make_random_quantum_circuit(qubits, depth=12)
-        bitstrings = sample_noisy_bitstrings(
-            circuit, qubits, depolarization=depolarization, repetitions=5000
-        )
-        amplitudes = cirq.final_state_vector(circuit)
-        probabilities = cirq.state_vector_to_probabilities(amplitudes)
-
-        measured_expectations_lin.append(dim * np.mean(probabilities[bitstrings]))
-        exact_expectations_lin.append(dim * np.sum(probabilities**2))
-
-        measured_expectations_log.append(np.mean(np.log(dim * probabilities[bitstrings])))
-        exact_expectations_log.append(np.sum(probabilities * np.log(dim * probabilities)))
-        uniform_expectations_log.append(np.mean(np.log(dim * probabilities)))
-
-    with cirq.testing.assert_deprecated(
-        'Use cirq.experiments.xeb_fitting', deadline='v0.16', count=2
-    ):
-        f_lin, r_lin = cirq.experiments.least_squares_xeb_fidelity_from_expectations(
-            measured_expectations_lin, exact_expectations_lin, [1.0] * n_circuits
-        )
-        f_log, r_log = cirq.experiments.least_squares_xeb_fidelity_from_expectations(
-            measured_expectations_log, exact_expectations_log, uniform_expectations_log
-        )
-
-    assert np.isclose(f_lin, 1 - depolarization, atol=0.01)
-    assert np.isclose(f_log, 1 - depolarization, atol=0.01)
-    np.testing.assert_allclose(np.sum(np.array(r_lin) ** 2), 0.0, atol=1e-2)
-    np.testing.assert_allclose(np.sum(np.array(r_log) ** 2), 0.0, atol=1e-2)
-
-    np.random.set_state(prng_state)
-
-
-def test_least_squares_xeb_fidelity_from_expectations_bad_length():
-    with pytest.raises(ValueError, match='1, 1, and 2'):
-        with cirq.testing.assert_deprecated('Use cirq.experiments.xeb_fitting', deadline='v0.16'):
-            _ = cirq.experiments.least_squares_xeb_fidelity_from_expectations(
-                [1.0], [1.0], [1.0, 2.0]
-            )
-
-
-def test_least_squares_xeb_fidelity_from_probabilities():
-    prng_state = np.random.get_state()
-    np.random.seed(0)
-
-    depolarization = 0.5
-
-    n_qubits = 5
-    dim = 2**n_qubits
-    n_circuits = 10
-    qubits = cirq.LineQubit.range(n_qubits)
-
-    all_probabilities = []
-    observed_probabilities = []
-    for _ in range(n_circuits):
-        circuit = make_random_quantum_circuit(qubits, depth=12)
-        bitstrings = sample_noisy_bitstrings(
-            circuit, qubits, depolarization=depolarization, repetitions=5000
-        )
-        amplitudes = cirq.final_state_vector(circuit)
-        probabilities = cirq.state_vector_to_probabilities(amplitudes)
-
-        all_probabilities.append(probabilities)
-        observed_probabilities.append(probabilities[bitstrings])
-
-    # 2 deprecation warnings for each of the following
-    with cirq.testing.assert_deprecated(
-        'Use cirq.experiments.xeb_fitting', deadline='v0.16', count=6
-    ):
-        f_lin, r_lin = cirq.least_squares_xeb_fidelity_from_probabilities(
-            dim, observed_probabilities, all_probabilities, None, True
-        )
-        f_log_np, r_log_np = cirq.least_squares_xeb_fidelity_from_probabilities(
-            dim, observed_probabilities, all_probabilities, np.log, True
-        )
-        f_log_math, r_log_math = cirq.least_squares_xeb_fidelity_from_probabilities(
-            dim, observed_probabilities, all_probabilities, math.log, False
-        )
-
-    assert np.isclose(f_lin, 1 - depolarization, atol=0.01)
-    assert np.isclose(f_log_np, 1 - depolarization, atol=0.01)
-    assert np.isclose(f_log_math, 1 - depolarization, atol=0.01)
-    np.testing.assert_allclose(np.sum(np.array(r_lin) ** 2), 0.0, atol=1e-2)
-    np.testing.assert_allclose(np.sum(np.array(r_log_np) ** 2), 0.0, atol=1e-2)
-    np.testing.assert_allclose(np.sum(np.array(r_log_math) ** 2), 0.0, atol=1e-2)
-
-    np.random.set_state(prng_state)

cirq-core/cirq/experiments/google_v2_supremacy_circuit.py

@@ -1,115 +1,18 @@
-# pylint: disable=wrong-or-nonexistent-copyright-notice
-import os
-import numpy as np
-import cirq
-from cirq.experiments import (
-    collect_grid_parallel_two_qubit_xeb_data,
-    compute_grid_parallel_two_qubit_xeb_results,
-)
+# Copyright 2022 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata, LAYER_A, LAYER_B
-
-ALIGNED_HORIZONTAL = cirq.experiments.GridInteractionLayer(
-    col_offset=0, vertical=False, stagger=False
-)
-ALIGNED_VERTICAL = cirq.experiments.GridInteractionLayer(col_offset=0, vertical=True, stagger=False)
-
-
-_DEPRECATION_MESSAGE = 'Use cirq.experiments.xeb_fitting.XEBCharacterizationResult instead'
-_DEPRECATION_RECIRQ = 'Use recirq.benchmarks.xeb.collect_grid_parallel_two_qubit_xeb_data instead.'
-
-
-def test_estimate_parallel_two_qubit_xeb_fidelity_on_grid_no_noise(tmpdir):
-    # No noise, fidelities should be close to 1
-    base_dir = os.path.abspath(tmpdir)
-    qubits = cirq.GridQubit.square(2)
-    two_qubit_gate = cirq.ISWAP**0.5
-    cycles = [5, 10, 15]
-    with cirq.testing.assert_deprecated(_DEPRECATION_RECIRQ, deadline='v0.16'):
-        data_collection_id = collect_grid_parallel_two_qubit_xeb_data(
-            sampler=cirq.Simulator(seed=34310, split_untangled_states=False),
-            qubits=qubits,
-            two_qubit_gate=two_qubit_gate,
-            num_circuits=2,
-            repetitions=1_000,
-            cycles=cycles,
-            layers=(ALIGNED_HORIZONTAL, ALIGNED_VERTICAL),
-            seed=43435,
-            num_workers=1,
-            base_dir=base_dir,
-        )
-    with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16', count=6):
-        results = compute_grid_parallel_two_qubit_xeb_results(data_collection_id, base_dir=base_dir)
-
-    assert len(results) == 4
-    for result in results.values():
-        depolarizing_model = result.depolarizing_model()
-        np.testing.assert_allclose(depolarizing_model.cycle_depolarization, 1.0, atol=1e-2)
-        purity_depolarizing_model = result.purity_depolarizing_model()
-        np.testing.assert_allclose(
-            depolarizing_model.cycle_depolarization,
-            purity_depolarizing_model.cycle_depolarization,
-            atol=3e-2,
-        )
-
-
-def test_estimate_parallel_two_qubit_xeb_fidelity_on_grid_depolarizing(tmpdir):
-    # With depolarizing probability e
-    base_dir = os.path.abspath(tmpdir)
-    qubits = cirq.GridQubit.square(2)
-    two_qubit_gate = cirq.ISWAP**0.5
-    cycles = [5, 10, 15]
-    e = 0.01
-    with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16', count=7):
-        data_collection_id = collect_grid_parallel_two_qubit_xeb_data(
-            sampler=cirq.DensityMatrixSimulator(
-                noise=cirq.depolarize(e), seed=65008, split_untangled_states=False
-            ),
-            qubits=qubits,
-            two_qubit_gate=two_qubit_gate,
-            num_circuits=2,
-            repetitions=1_000,
-            cycles=cycles,
-            layers=(ALIGNED_HORIZONTAL, ALIGNED_VERTICAL),
-            seed=np.random.RandomState(14948),
-            num_workers=1,
-            base_dir=base_dir,
-        )
-        results = compute_grid_parallel_two_qubit_xeb_results(
-            data_collection_id, num_processors=4, base_dir=base_dir
-        )
-
-    assert len(results) == 4
-    for result in results.values():
-        depolarizing_model = result.depolarizing_model()
-        purity_depolarizing_model = result.purity_depolarizing_model()
-        cycle_pauli_error = (1 - depolarizing_model.cycle_depolarization) * 15 / 16
-        purity_error = (1 - purity_depolarizing_model.cycle_depolarization) * 15 / 16
-        np.testing.assert_allclose(1 - cycle_pauli_error, (1 - e) ** 4, atol=1e-2)
-        np.testing.assert_allclose(1 - purity_error, (1 - e) ** 4, atol=5e-2)
-
-
-def test_estimate_parallel_two_qubit_xeb_fidelity_on_grid_concurrent(tmpdir):
-    # Use multiple threads during data collection
-    base_dir = os.path.abspath(tmpdir)
-    qubits = cirq.GridQubit.square(2)
-    two_qubit_gate = cirq.ISWAP**0.5
-    cycles = [5, 10, 15]
-    with cirq.testing.assert_deprecated(_DEPRECATION_MESSAGE, deadline='v0.16', count=7):
-        data_collection_id = collect_grid_parallel_two_qubit_xeb_data(
-            sampler=cirq.Simulator(seed=34310),
-            qubits=qubits,
-            two_qubit_gate=two_qubit_gate,
-            num_circuits=2,
-            repetitions=1_000,
-            cycles=cycles,
-            layers=(ALIGNED_HORIZONTAL, ALIGNED_VERTICAL),
-            seed=43435,
-            num_workers=4,
-            base_dir=base_dir,
-        )
-        results = compute_grid_parallel_two_qubit_xeb_results(data_collection_id, base_dir=base_dir)
-
-        assert len(results) == 4
+import cirq
 
 
 def test_grid_parallel_xeb_metadata_repr():