def test_rotated_toric_pauli_path(size, a_index, b_index): code = RotatedToricCode(*size) pauli = code.new_pauli().path(a_index, b_index) syndrome = pt.bsp(pauli.to_bsf(), code.stabilizers.T) syndrome_indices = code.syndrome_to_plaquette_indices(syndrome) if a_index == b_index: assert len(syndrome_indices) == 0, 'Unexpected syndrome for null path' else: dim_y, dim_x = code.size a_index = tuple(np.mod(a_index, (dim_x, dim_y))) b_index = tuple(np.mod(b_index, (dim_x, dim_y))) assert syndrome_indices == {a_index, b_index }, 'Path does not give expected syndrome'
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_once_ftp_seeded(): code = RotatedToricCode(4, 4) time_steps = 4 error_model = BitPhaseFlipErrorModel() decoder = RotatedToricSMWPMDecoder() error_probability = 0.15 data1 = app.run_once_ftp(code, time_steps, error_model, decoder, error_probability, rng=np.random.default_rng(5)) data2 = app.run_once_ftp(code, time_steps, error_model, decoder, error_probability, rng=np.random.default_rng(5)) assert data1['error_weight'] == data2['error_weight'] assert data1['success'] == data2['success'] assert np.array_equal(data1['logical_commutations'], data2['logical_commutations']) assert np.array_equal(data1['custom_values'], data2['custom_values'])
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_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_rotated_toric_code_new_invalid_parameters(rows, columns): with pytest.raises((ValueError, TypeError), match=r"^RotatedToricCode") as exc_info: RotatedToricCode(rows, columns) print(exc_info)
def test_rotated_toric_lattice_translation(size, a_index, b_index, expected): assert RotatedToricCode(*size).translation(a_index, b_index) == expected
def test_rotated_toric_lattice_is_in_bounds(index, expected): lattice = RotatedToricCode(4, 6) assert lattice.is_in_bounds(index) == expected
def test_rotated_toric_code_properties(size): code = RotatedToricCode(*size) assert isinstance(code.label, str) assert isinstance(repr(code), str)
def test_rotated_toric_lattice_is_x_plaquette(index, expected): lattice = RotatedToricCode(2, 4) assert lattice.is_x_plaquette(index) == expected
def test_rotated_toric_pauli_properties(size): code = RotatedToricCode(*size) pauli = code.new_pauli() assert pauli.code == code assert isinstance(repr(pauli), str) assert isinstance(str(pauli), str)
def test_rotated_toric_code_logicals(): assert len(RotatedToricCode(4, 4).logicals) == 4
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)
return 'fixed' @pytest.mark.parametrize('code, error_model, decoder', [ # each code with each valid decoder (Color666Code(5), DepolarizingErrorModel(), Color666MPSDecoder(chi=8)), (FiveQubitCode(), DepolarizingErrorModel(), NaiveDecoder()), (PlanarCode(5, 5), DepolarizingErrorModel(), PlanarCMWPMDecoder()), (PlanarCode(5, 5), DepolarizingErrorModel(), PlanarMPSDecoder(chi=6)), (PlanarCode(5, 5), DepolarizingErrorModel(), PlanarMWPMDecoder()), (PlanarCode(5, 5), DepolarizingErrorModel(), PlanarRMPSDecoder(chi=6)), (PlanarCode(4, 5), BitPhaseFlipErrorModel(), PlanarYDecoder()), (RotatedPlanarCode(7, 7), DepolarizingErrorModel(), RotatedPlanarMPSDecoder(chi=8)), (RotatedPlanarCode(7, 7), DepolarizingErrorModel(), RotatedPlanarRMPSDecoder(chi=8)), (RotatedPlanarCode(7, 7), BiasedDepolarizingErrorModel(100), RotatedPlanarSMWPMDecoder()), (RotatedToricCode(6, 6), BiasedDepolarizingErrorModel(100), RotatedToricSMWPMDecoder()), (SteaneCode(), DepolarizingErrorModel(), NaiveDecoder()), (ToricCode(5, 5), DepolarizingErrorModel(), ToricMWPMDecoder()), # each generic noise model (PlanarCode(5, 5), BiasedDepolarizingErrorModel(10), PlanarMPSDecoder(chi=6)), (PlanarCode(5, 5), BiasedYXErrorModel(10), PlanarMPSDecoder(chi=6)), (PlanarCode(5, 5), BitFlipErrorModel(), PlanarMPSDecoder(chi=6)), (PlanarCode(5, 5), BitPhaseFlipErrorModel(), PlanarMPSDecoder(chi=6)), (PlanarCode(5, 5), CenterSliceErrorModel((0.2, 0.8, 0), 0.5), PlanarMPSDecoder(chi=6)), (PlanarCode(5, 5), DepolarizingErrorModel(), PlanarMPSDecoder(chi=6)), (PlanarCode(5, 5), PhaseFlipErrorModel(), PlanarMPSDecoder(chi=6)), ]) def test_run_once(code, error_model, decoder): error_probability = 0.15 data = app.run_once(code, error_model, decoder, error_probability) # no error raised expected_key_cls = {'error_weight': int, 'success': bool, 'logical_commutations': np.ndarray,
def test_rotated_toric_code_n_k_d(size, expected): code = RotatedToricCode(*size) assert code.n_k_d == expected
((3, 0), True), # boundary x plaquette ((3, 2), True), # out-bounds x plaquette ((0, 0), False), # in-bounds z plaquette ((1, 1), False), # boundary z plaquette ((3, 1), False), # out-bounds z plaquette ]) def test_rotated_toric_lattice_is_x_plaquette(index, expected): lattice = RotatedToricCode(2, 4) assert lattice.is_x_plaquette(index) == expected @pytest.mark.parametrize( 'lattice, expected', [ # RotatedToricCode(row, cols), (max_site_x, max_site_y) (RotatedToricCode(2, 2), (1, 1)), (RotatedToricCode(4, 4), (3, 3)), (RotatedToricCode(2, 4), (3, 1)), (RotatedToricCode(4, 2), (1, 3)), (RotatedToricCode(6, 6), (5, 5)), (RotatedToricCode(4, 6), (5, 3)), (RotatedToricCode(6, 4), (3, 5)), ]) def test_rotated_toric_lattice_bounds(lattice, expected): assert lattice.bounds == expected @pytest.mark.parametrize( 'index, expected', [ ((0, 1), True), # in-bounds left
def test_rotated_toric_code_stabilizers(size, expected): assert len(RotatedToricCode(*size).stabilizers) == expected
def test_rotated_toric_lattice_size(size): lattice = RotatedToricCode(*size) assert lattice.size == size
def test_rotated_toric_code_validate(size): code = RotatedToricCode(*size) code.validate() # no error raised
(2, 4), (4, 2), (6, 6), (4, 6), (6, 4), ]) def test_rotated_toric_pauli_properties(size): code = RotatedToricCode(*size) pauli = code.new_pauli() assert pauli.code == code assert isinstance(repr(pauli), str) assert isinstance(str(pauli), str) @pytest.mark.parametrize('pauli', [ RotatedToricCode(4, 4).new_pauli(), RotatedToricCode(4, 6).new_pauli().plaquette((1, 1)).plaquette((3, 2)), RotatedToricCode(6, 6).new_pauli().logical_x1().plaquette( (-1, 0)).plaquette((4, 1)), RotatedToricCode(6, 4).new_pauli().logical_z1().plaquette( (1, 5)).plaquette((3, -1)), RotatedToricCode(8, 6).new_pauli().logical_x2().plaquette( (0, 2)).plaquette((1, 1)), RotatedToricCode(6, 8).new_pauli().logical_z2().plaquette( (1, -1)).plaquette((2, 4)), ]) def test_rotated_toric_pauli_new_to_bsf(pauli): assert pauli.code.new_pauli(pauli.to_bsf()) == pauli, ( 'Conversion to_bsf+from_bsf does not result in equality.')