def test_benchmark_2q_xeb_fidelities_parallel():
circuits = rqcg.generate_library_of_2q_circuits(
n_library_circuits=5,
two_qubit_gate=cirq.ISWAP**0.5,
max_cycle_depth=4)
cycle_depths = [2, 3, 4]
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(2, 2))
combs = rqcg.get_random_combinations_for_device(
n_library_circuits=len(circuits),
n_combinations=2,
device_graph=graph,
random_state=10)
sampled_df = sample_2q_xeb_circuits(
sampler=cirq.Simulator(),
circuits=circuits,
cycle_depths=cycle_depths,
combinations_by_layer=combs,
)
fid_df = benchmark_2q_xeb_fidelities(sampled_df, circuits, cycle_depths)
n_pairs = sum(len(c.pairs) for c in combs)
assert len(fid_df) == len(cycle_depths) * n_pairs
fit_df = fit_exponential_decays(fid_df)
for _, row in fit_df.iterrows():
assert list(row['cycle_depths']) == list(cycle_depths)
assert len(row['fidelities']) == len(cycle_depths)
def test_sample_2q_parallel_xeb_circuits_error_bad_qubits():
circuits = rqcg.generate_library_of_2q_circuits(
n_library_circuits=5,
two_qubit_gate=cirq.ISWAP**0.5,
max_cycle_depth=10,
q0=cirq.GridQubit(0, 0),
q1=cirq.GridQubit(1, 1),
)
cycle_depths = [10]
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 2))
combs = rqcg.get_random_combinations_for_device(
n_library_circuits=len(circuits),
n_combinations=5,
device_graph=graph,
random_state=10,
)
with pytest.raises(
ValueError,
match=r'.*each operating on LineQubit\(0\) and LineQubit\(1\)'):
_ = sample_2q_xeb_circuits(
sampler=cirq.Simulator(),
circuits=circuits,
cycle_depths=cycle_depths,
combinations_by_layer=combs,
)
def test_sample_2q_parallel_xeb_circuits():
circuits = rqcg.generate_library_of_2q_circuits(
n_library_circuits=5,
two_qubit_gate=cirq.ISWAP**0.5,
max_cycle_depth=10)
cycle_depths = [10]
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 2))
combs = rqcg.get_random_combinations_for_device(
n_library_circuits=len(circuits),
n_combinations=5,
device_graph=graph,
random_state=10,
)
df = sample_2q_xeb_circuits(
sampler=cirq.Simulator(),
circuits=circuits,
cycle_depths=cycle_depths,
combinations_by_layer=combs,
)
n_pairs = sum(len(c.pairs) for c in combs)
assert len(df) == len(cycle_depths) * len(circuits) * n_pairs
for (circuit_i, cycle_depth), row in df.iterrows():
assert 0 <= circuit_i < len(circuits)
assert cycle_depth in cycle_depths
assert len(row['sampled_probs']) == 4
assert np.isclose(np.sum(row['sampled_probs']), 1)
assert 0 <= row['layer_i'] < 4
assert 0 <= row[
'pair_i'] < 2 # in 3x2 graph, there's a max of 2 pairs per layer
assert len(df['pair'].unique()) == 7 # seven pairs in 3x2 graph
def test_get_random_combinations_for_small_device():
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 1))
n_combinations = 4
combinations = get_random_combinations_for_device(
n_library_circuits=3,
n_combinations=n_combinations,
device_graph=graph,
random_state=99,
)
assert len(combinations) == 2 # 3x1 device only fits two layers
def test_random_combinations_layer_circuit_vs_device():
# Random combinations from layer circuit is the same as getting it directly from graph
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 3))
layer_circuit = get_grid_interaction_layer_circuit(graph)
combs1 = get_random_combinations_for_layer_circuit(
n_library_circuits=10, n_combinations=10, layer_circuit=layer_circuit, random_state=1
)
combs2 = get_random_combinations_for_device(
n_library_circuits=10, n_combinations=10, device_graph=graph, random_state=1
)
for comb1, comb2 in zip(combs1, combs2):
assert comb1.pairs == comb2.pairs
assert np.all(comb1.combinations == comb2.combinations)
def test_sample_2q_parallel_xeb_circuits(tmpdir):
circuits = rqcg.generate_library_of_2q_circuits(
n_library_circuits=5,
two_qubit_gate=cirq.ISWAP**0.5,
max_cycle_depth=10)
cycle_depths = [5, 10]
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 2))
combs = rqcg.get_random_combinations_for_device(
n_library_circuits=len(circuits),
n_combinations=5,
device_graph=graph,
random_state=10,
)
df = sample_2q_xeb_circuits(
sampler=cirq.Simulator(),
circuits=circuits,
cycle_depths=cycle_depths,
combinations_by_layer=combs,
dataset_directory=f'{tmpdir}/my_dataset',
)
n_pairs = sum(len(c.pairs) for c in combs)
assert len(df) == len(cycle_depths) * len(circuits) * n_pairs
for (circuit_i, cycle_depth), row in df.iterrows():
assert 0 <= circuit_i < len(circuits)
assert cycle_depth in cycle_depths
assert len(row['sampled_probs']) == 4
assert np.isclose(np.sum(row['sampled_probs']), 1)
assert 0 <= row['layer_i'] < 4
assert 0 <= row[
'pair_i'] < 2 # in 3x2 graph, there's a max of 2 pairs per layer
assert len(df['pair'].unique()) == 7 # seven pairs in 3x2 graph
# Test loading from dataset
chunks = [
record for fn in glob.glob(f'{tmpdir}/my_dataset/*')
for record in cirq.read_json(fn)
]
df2 = pd.DataFrame(chunks).set_index(['circuit_i', 'cycle_depth'])
df2['pair'] = [tuple(row['pair']) for _, row in df2.iterrows()]
actual_index_names = ['layer_i', 'pair_i', 'combination_i', 'cycle_depth']
_assert_frame_approx_equal(
df.reset_index().set_index(actual_index_names),
df2.reset_index().set_index(actual_index_names),
atol=1e-5,
)
def test_get_random_combinations_for_device():
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 3))
n_combinations = 4
combinations = get_random_combinations_for_device(
n_library_circuits=3,
n_combinations=n_combinations,
device_graph=graph,
random_state=99,
)
assert len(combinations) == 4 # degree-four graph
for i, comb in enumerate(combinations):
assert comb.combinations.shape[0] == n_combinations
assert comb.combinations.shape[1] == len(comb.pairs)
assert np.all(comb.combinations >= 0)
assert np.all(comb.combinations < 3) # number of library circuits
for q0, q1 in comb.pairs:
assert q0 in cirq.GridQubit.rect(3, 3)
assert q1 in cirq.GridQubit.rect(3, 3)
assert cirq.experiments.HALF_GRID_STAGGERED_PATTERN[i] == comb.layer
def test_sample_2q_parallel_xeb_circuits_bad_circuit_library():
circuits = rqcg.generate_library_of_2q_circuits(
n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, max_cycle_depth=10
)
cycle_depths = [10]
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 2))
combs = rqcg.get_random_combinations_for_device(
n_library_circuits=len(circuits) + 100, # !!! should cause invlaid input
n_combinations=5,
device_graph=graph,
random_state=10,
)
with pytest.raises(ValueError, match='.*invalid indices.*'):
_ = sample_2q_xeb_circuits(
sampler=cirq.Simulator(),
circuits=circuits,
cycle_depths=cycle_depths,
combinations_by_layer=combs,
)
def test_parallel_full_workflow(use_pool):
circuits = rqcg.generate_library_of_2q_circuits(
n_library_circuits=5,
two_qubit_gate=cirq.ISWAP**0.5,
max_cycle_depth=4,
random_state=8675309,
)
cycle_depths = [2, 3, 4]
graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(2, 2))
combs = rqcg.get_random_combinations_for_device(
n_library_circuits=len(circuits),
n_combinations=2,
device_graph=graph,
random_state=10)
sampled_df = sample_2q_xeb_circuits(
sampler=cirq.Simulator(),
circuits=circuits,
cycle_depths=cycle_depths,
combinations_by_layer=combs,
)
if use_pool:
pool = multiprocessing.Pool()
else:
pool = None
fids_df_0 = benchmark_2q_xeb_fidelities(sampled_df=sampled_df,
circuits=circuits,
cycle_depths=cycle_depths,
pool=pool)
options = SqrtISwapXEBOptions(characterize_zeta=False,
characterize_gamma=False,
characterize_chi=False)
p_circuits = [
parameterize_circuit(circuit, options) for circuit in circuits
]
result = characterize_phased_fsim_parameters_with_xeb_by_pair(
sampled_df=sampled_df,
parameterized_circuits=p_circuits,
cycle_depths=cycle_depths,
options=options,
# super loose tolerances
fatol=5e-2,
xatol=5e-2,
pool=pool,
)
if pool is not None:
pool.terminate()
assert len(result.optimization_results) == graph.number_of_edges()
for opt_res in result.optimization_results.values():
assert np.abs(opt_res.fun) < 0.1 # noiseless simulator
assert len(
result.fidelities_df) == len(cycle_depths) * graph.number_of_edges()
assert np.all(result.fidelities_df['fidelity'] > 0.90)
before_after_df = before_and_after_characterization(
fids_df_0, characterization_result=result)
for _, row in before_after_df.iterrows():
assert len(row['fidelities_0']) == len(cycle_depths)
assert len(row['fidelities_c']) == len(cycle_depths)
assert 0 <= row['a_0'] <= 1
assert 0 <= row['a_c'] <= 1
assert 0 <= row['layer_fid_0'] <= 1
assert 0 <= row['layer_fid_c'] <= 1
