def test_get_random_combinations_for_bad_layer_circuit():
q0, q1, q2, q3 = cirq.LineQubit.range(4)
circuit = cirq.Circuit(
cirq.H.on_each(q0, q1, q2, q3), cirq.CNOT(q0, q1), cirq.CNOT(q2, q3), cirq.CNOT(q1, q2)
)
with pytest.raises(ValueError, match=r'non-2-qubit operation'):
_ = get_random_combinations_for_layer_circuit(
n_library_circuits=3, n_combinations=4, layer_circuit=circuit, random_state=99
)
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_get_random_combinations_for_layer_circuit():
q0, q1, q2, q3 = cirq.LineQubit.range(4)
circuit = cirq.Circuit(cirq.CNOT(q0, q1), cirq.CNOT(q2, q3), cirq.CNOT(q1, q2))
combinations = get_random_combinations_for_layer_circuit(
n_library_circuits=3, n_combinations=4, layer_circuit=circuit, random_state=99
)
assert len(combinations) == 2 # operations pack into two layers
for i, comb in enumerate(combinations):
assert comb.combinations.shape[0] == 4 # 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.LineQubit.range(4)
assert q1 in cirq.LineQubit.range(4)
assert comb.layer == circuit.moments[i]
def run_local_xeb_calibration(
calibration: LocalXEBPhasedFSimCalibrationRequest,
sampler: cirq.Sampler) -> PhasedFSimCalibrationResult:
"""Run a calibration request using `cirq.experiments` XEB utilities and a sampler rather
than `Engine.run_calibrations`.
Args:
calibration: A LocalXEBPhasedFSimCalibration request describing the XEB characterization
to carry out.
sampler: A sampler to execute circuits.
"""
options: LocalXEBPhasedFSimCalibrationOptions = calibration.options
circuit = cirq.Circuit(
[calibration.gate.on(*pair) for pair in calibration.pairs])
# 2. Set up XEB experiment
cycle_depths = options.cycle_depths
circuits = rqcg.generate_library_of_2q_circuits(
n_library_circuits=options.n_library_circuits,
two_qubit_gate=calibration.gate,
max_cycle_depth=max(cycle_depths),
)
combs_by_layer = rqcg.get_random_combinations_for_layer_circuit(
n_library_circuits=len(circuits),
n_combinations=options.n_combinations,
layer_circuit=circuit,
)
# 3. Sample data
sampled_df = xebsamp.sample_2q_xeb_circuits(
sampler=sampler,
circuits=circuits,
cycle_depths=cycle_depths,
combinations_by_layer=combs_by_layer,
)
# 4. Initial fidelities
# initial_fids = xebf.benchmark_2q_xeb_fidelities(
# sampled_df=sampled_df,
# circuits=circuits,
# cycle_depths=cycle_depths,
# )
# 5. Characterize by fitting angles.
if options.fsim_options.defaults_set():
fsim_options = options.fsim_options
else:
fsim_options = options.fsim_options.with_defaults_from_gate(
calibration.gate)
pcircuits = [
xebf.parameterize_circuit(circuit, fsim_options)
for circuit in circuits
]
fatol = options.fatol if options.fatol is not None else 5e-3
xatol = options.xatol if options.xatol is not None else 5e-3
with _maybe_multiprocessing_pool(n_processes=options.n_processes) as pool:
char_results = xebf.characterize_phased_fsim_parameters_with_xeb_by_pair(
sampled_df=sampled_df,
parameterized_circuits=pcircuits,
cycle_depths=cycle_depths,
options=fsim_options,
pool=pool,
fatol=fatol,
xatol=xatol,
)
return PhasedFSimCalibrationResult(
parameters={
pair: PhasedFSimCharacterization(**param_dict)
for pair, param_dict in char_results.final_params.items()
},
gate=calibration.gate,
options=options,
)