def test_run_ftp_seeded():
code = RotatedToricCode(4, 4)
time_steps = 4
error_model = BitPhaseFlipErrorModel()
decoder = RotatedToricSMWPMDecoder()
error_probability = 0.15
max_runs = 5
random_seed = 5
data1 = app.run_ftp(code, time_steps, error_model, decoder, error_probability, max_runs=max_runs,
random_seed=random_seed)
data2 = app.run_ftp(code, time_steps, error_model, decoder, error_probability, max_runs=max_runs,
random_seed=random_seed)
# remove wall_time from data
for data in (data1, data2):
del data['wall_time']
assert data1 == data2, 'Identically seeded runs are not the same. '
def test_run_ftp_measurement_error_probability_defaults(time_steps, error_probability, measurement_error_probability,
expected):
code = RotatedToricCode(4, 4)
error_model = BitPhaseFlipErrorModel()
decoder = RotatedToricSMWPMDecoder()
max_runs = 2
data = app.run_ftp(code, time_steps, error_model, decoder, error_probability, measurement_error_probability,
max_runs=max_runs)
assert data['measurement_error_probability'] == expected
def test_run_ftp_physical_error_rate(code, time_steps, error_model, decoder, error_probability):
max_runs = 100 # Need to repeat many times to ensure physical_error_rate is close to error_probability
data = app.run_ftp(code, time_steps, error_model, decoder, error_probability, max_runs=max_runs)
for key in ('error_probability', 'physical_error_rate', 'error_weight_pvar'):
assert key in data, 'data={} does not contain key={}'.format(data, key)
e_prob = data['error_probability']
p_rate = data['physical_error_rate']
p_var = data['error_weight_pvar'] / (data['n_k_d'][0] ** 2) # physical_error_rate_pvar (power of 2 is correct)
p_std = math.sqrt(p_var) # physical_error_rate_std
assert p_rate - p_std < e_prob < p_rate + p_std, (
'physical_error_rate={} is not within 1 std={} of error_probability={}'.format(p_rate, p_std, e_prob))
def run_ftp(code, time_steps, error_model, decoder, error_probabilities, max_failures, max_runs,
measurement_error_probability, output, random_seed):
"""
Simulate fault-tolerant (time-periodic) quantum error correction.
Arguments:
\b
CODE Stabilizer code in format name(<args>)
#CODE_PARAMETERS#
\b
TIME_STEPS Number of time steps as INT >= 1
\b
ERROR_MODEL Error model in format name(<args>)
#ERROR_MODEL_PARAMETERS#
\b
DECODER Decoder in format name(<args>)
#DECODER_PARAMETERS#
\b
ERROR_PROBABILITY... One or more probabilities as FLOAT in [0.0, 1.0]
Examples:
qecsim run-ftp -r5 "rotated_planar(13,13)" 13 "generic.bit_phase_flip" "rotated_planar.smwpm" 0.1 0.2
qecsim run-ftp -r5 -m0.05 "rotated_toric(6,6)" 4 "generic.bit_phase_flip" "rotated_toric.smwpm" 0.1
qecsim run-ftp -r5 -o"data.json" "rotated_planar(7,7)" 7 "generic.depolarizing" "rotated_planar.smwpm" 0.1
"""
# INPUT
code.validate()
logger.info('RUN STARTING: code={}, time_steps={}, error_model={}, decoder={}, error_probabilities={}, '
'max_failures={}, max_runs={}, measurement_error_probability={}, random_seed={}.'
.format(code, time_steps, error_model, decoder, error_probabilities, max_failures, max_runs,
measurement_error_probability, random_seed))
# RUN
data = []
for error_probability in error_probabilities:
runs_data = app.run_ftp(code, time_steps, error_model, decoder, error_probability,
measurement_error_probability=measurement_error_probability,
max_runs=max_runs, max_failures=max_failures, random_seed=random_seed)
data.append(runs_data)
logger.info('RUN COMPLETE: data={}'.format(data))
# OUTPUT
_write_data(output, data)
def test_run_ftp_count(max_runs, max_failures):
code = RotatedToricCode(6, 6)
time_steps = 6
error_model = BitPhaseFlipErrorModel()
decoder = RotatedToricSMWPMDecoder()
error_probability = 0.05
data = app.run_ftp(code, time_steps, error_model, decoder, error_probability,
max_runs=max_runs, max_failures=max_failures) # no error raised
assert {'n_run', 'n_fail'} <= data.keys(), 'data={} missing count keys'
if max_runs is None and max_failures is None:
assert data['n_run'] == 1, 'n_run does not equal 1 when max_runs and max_failures unspecified'
if max_runs is not None:
assert data['n_run'] <= max_runs, ('n_run is not <= requested max_runs (data={}).'.format(data))
if max_failures is not None:
assert data['n_fail'] <= max_failures, ('n_fail is not <= requested max_failures (data={}).'.format(data))
def test_run_ftp(code, time_steps, error_model, decoder):
error_probability = 0.15
max_runs = 2
data = app.run_ftp(code, time_steps, error_model, decoder, error_probability, max_runs=max_runs)
expected_keys = {'code', 'n_k_d', 'error_model', 'decoder', 'error_probability', 'time_steps',
'measurement_error_probability', 'n_run', 'n_success', 'n_fail', 'n_logical_commutations',
'custom_totals', 'error_weight_total', 'error_weight_pvar', 'logical_failure_rate',
'physical_error_rate', 'wall_time'}
assert data.keys() == expected_keys, 'data={} has missing/extra keys'
assert data['n_run'] == max_runs, ('n_run does not equal requested max_runs (data={}).'.format(data))
assert data['n_success'] + data['n_fail'] == max_runs, (
'n_success + n_fail does not equal requested max_runs (data={}).'.format(data))
assert data['n_success'] >= 0, 'n_success is negative (data={}).'.format(data)
assert data['n_fail'] >= 0, 'n_fail is negative (data={}).'.format(data)
assert data['logical_failure_rate'] == data['n_fail'] / data['n_run']
def test_run_ftp_invalid_parameters(time_steps, error_probability, measurement_error_probability):
with pytest.raises(ValueError) as exc_info:
app.run_ftp(RotatedToricCode(6, 6), time_steps, BitPhaseFlipErrorModel(), RotatedToricSMWPMDecoder(),
error_probability, measurement_error_probability, max_runs=2)
print(exc_info)