def main(samples: int = 1000, max_infidelity: float = 0.01):
    """Demonstration of the usage of the TwoQubitGateTabulation gate compiler.

    Args:
        samples: Number of random 2-qubit unitary samples to compile.
        max_infidelity: Maximum allowed infidelity between randomly generated
            gate and the gate compilation used to generate it. The example
            runtime scales as max_infidelity^{-2}.
    """
    # Define a base gate for compilation
    theta = np.pi / 4
    phi = np.pi / 24
    base = cirq.unitary(cirq.FSimGate(theta, phi))

    # The TwoQubitGateTabulation object is essentially a tabulation of many randomly
    # generated gate products (of the form A k A or A k A k A), along with their
    # associate KAK vectors. The parameter max_infidelity determines the
    # approximate "density" of the tabulated gates. Specifically, it bounds the
    # typical distance between an arbitrary two-qubit gate and the nearest
    # tabulated gate.
    start = time()
    tabulation = cirq.two_qubit_gate_product_tabulation(base, max_infidelity)

    print(tabulation.summary)
    print(f'Gate tabulation time : {time() - start} seconds.')

    # Generate many random two-qubit gates, then attempt to compile them using
    # the tabulation.
    unitaries = [random_special_unitary(4) for _ in range(samples)]

    infidelities = []
    failed_infidelities = []
    start = time()
    for target in unitaries:
        # result.actual_gate is the compiled gate product intended to match the
        # target. result.success denotes is the actual gate is expected to be
        # within the desired fidelity to the target. It can be False if the
        # base gate cannot "fill" the Weyl chamber using at most 3 products.
        # result.local_unitaries stores the local unitaries required to
        # compile the target unitary from the base unitary.
        result = tabulation.compile_two_qubit_gate(target)
        infidelity = 1 - unitary_entanglement_fidelity(target, result.actual_gate)
        if result.success:
            infidelities.append(infidelity)
        else:
            failed_infidelities.append(infidelity)  # pragma: no cover
    t_comp = time() - start

    print(f'Gate compilation time : {t_comp:.3f} seconds ({t_comp / samples:.4f} s per gate)')

    infidelities_arr = np.array(infidelities)
    failed_infidelities_arr = np.array(failed_infidelities)

    if np.size(failed_infidelities_arr):  # pragma: no cover
        print(f'Number of "failed" compilations: {np.size(failed_infidelities_arr)}.')
        print(f'Maximum infidelity of "failed" compilation: {np.max(failed_infidelities_arr)}')

    plt.figure()
    plt.hist(infidelities_arr, bins=25, range=(0.0, max_infidelity * 1.1))  # pragma: no cover
    ylim = plt.ylim()
    plt.plot([max_infidelity] * 2, ylim, '--', label='Maximum tabulation infidelity')
    plt.xlabel('Compiled gate infidelity vs target')
    plt.ylabel('Counts')
    plt.legend()
    plt.title(f'Base FSim(theta={theta:.4f}, phi={phi:.4f})')

    plt.show()
Demonstration of the usage of the TwoQubitGateTabulation gate compiler.

    Args:
        samples: Number of random 2-qubit unitary samples to compile.
        max_infidelity: Maximum allowed infidelity between randomly generated
            gate and the gate compilation used to generate it. The example
            runtime scales as max_infidelity^{-2}.
    
examples/two_qubit_gate_compilation.py