def test_planar_y_decoder_decode_equal_coset_probabilities(): code = PlanarCode(2, 3) decoder = PlanarYDecoder() # The following error Pauli gives identical coset probabilities: # I-+-I-+-Y # I I # Y-+-Y-+-I # So we expect approximately equal success and failure error_pauli = PlanarCode(2, 3).new_pauli().site('Y', (2, 0), (2, 2), (0, 4)) # count success and fail success, fail = 0, 0 # run simulations error = error_pauli.to_bsf() syndrome = pt.bsp(error, code.stabilizers.T) for _ in range(2000): recovery = decoder.decode(code, syndrome) assert np.array_equal(pt.bsp( recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'. format(recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'. format(recovery, error)) if np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0): success += 1 else: fail += 1 assert _is_close( success, fail, rtol=0.2, atol=0 ), 'Success and fail not equally likely with equal coset probabilities'
def test_planar_y_decoder_y_logical(code): y_logical = PlanarYDecoder._y_logical(code) assert not np.any(pt.bsp(y_logical, code.stabilizers.T) ), 'Y-logical does not commute with code stabilizers' assert np.any( pt.bsp(y_logical, code.logicals.T)), 'Y-logical does commute with code logicals'
def test_planar_mps_decoder_small_code_negative_coset_probability(chi, mode): # parameters code = PlanarCode(3, 3) decoder = PlanarMPSDecoder(chi=chi, mode=mode) error_model = DepolarizingErrorModel() error_probability = 0.1 # logged run values error = pt.unpack(["e0048000", 26]) syndrome = pt.bsp(error, code.stabilizers.T) # debug print() print(code.ascii_art(syndrome, code.new_pauli(error))) # decode prob_dist = error_model.probability_distribution(error_probability) any_recovery = decoder.sample_recovery(code, syndrome) # coset probabilities coset_ps, recoveries = decoder._coset_probabilities( prob_dist, any_recovery) print('chi={}, mode={}, coset_ps={}'.format(chi, mode, coset_ps)) max_coset_p, max_recovery = max( zip(coset_ps, recoveries), key=lambda coset_p_recovery: coset_p_recovery[0]) success = np.all( pt.bsp(max_recovery.to_bsf() ^ error, code.logicals.T) == 0) print('### success=', success) assert mp.isfinite( max_coset_p ) and max_coset_p > 0, 'Max coset probability not as expected' assert np.all( np.array(coset_ps) >= 0), 'At least one coset probability is negative'
def test_planar_rmps_decoder_correlated_errors(): # check MPS decoder successfully decodes for error # I--+--I--+--I # I I # Y--+--I--+--Y # I I # I--+--I--+--I # and MWPM decoder fails as expected code = PlanarCode(3, 3) error = code.new_pauli().site('Y', (2, 0), (2, 4)).to_bsf() syndrome = pt.bsp(error, code.stabilizers.T) # MPS decoder decoder = PlanarRMPSDecoder() recovery = decoder.decode(code, syndrome) # check recovery ^ error commutes with stabilizers (by construction) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers for MPS decoder.' .format(recovery, error)) # check recovery ^ error commutes with logicals (we expect this to succeed for MPS) assert np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with logicals for MPS decoder.' .format(recovery, error)) # MWPM decoder decoder = PlanarMWPMDecoder() recovery = decoder.decode(code, syndrome) # check recovery ^ error commutes with stabilizers (by construction) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers for MWPM decoder.' .format(recovery, error)) # check recovery ^ error commutes with logicals (we expect this to fail for MWPM) assert not np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'recovery ^ error ({} ^ {}) does commute with logicals for MWPM decoder.' .format(recovery, error))
def test_planar_y_decoder_sample_recovery_sans_residual(error_pauli): def _mock_residual_recovery(cls, code, syndrome): raise AssertionError('Residual recovery called unexpectedly') real_residual_recovery = PlanarYDecoder._residual_recovery try: # mock function PlanarYDecoder._residual_recovery = classmethod( _mock_residual_recovery) error = error_pauli.to_bsf() code = error_pauli.code syndrome = pt.bsp(error, code.stabilizers.T) recovery = PlanarYDecoder._sample_recovery(code, syndrome) print() print(code.ascii_art(syndrome, code.new_pauli(recovery))) assert np.array_equal(pt.bsp( recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'. format(recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'. format(recovery, error)) finally: # restore real function PlanarYDecoder._residual_recovery = real_residual_recovery
def test_planar_cmwpm_decoder_odd_diagonal_correlated_error(): """ ·─┬─·─┬─·─┬─· · · · ·─┼─·─┼─·─┼─· · · · ·─┼─Y─┼─·─┼─· · Y · ·─┼─·─┼─Y─┼─· · · · ·─┼─·─┼─·─┼─· · · · ·─┴─·─┴─·─┴─· """ code = PlanarCode(6, 4) error = code.new_pauli().site('Y', (4, 2), (5, 3), (6, 4)).to_bsf() syndrome = pt.bsp(error, code.stabilizers.T) decoder_mwpm = PlanarCMWPMDecoder(max_iterations=1) decoder_cmwpm = PlanarCMWPMDecoder(factor=3, max_iterations=4, box_shape='t', distance_algorithm=1) # show mwpm fails recovery = decoder_mwpm.decode(code, syndrome) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'MWPM recovery does not commute with stabilizers.') assert not np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'MWPM recovery does commute with logicals.') # show cmwpm succeeds recovery = decoder_cmwpm.decode(code, syndrome) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'CMWPM recovery does not commute with stabilizers.') assert np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'CMWPM recovery does not commute with logicals.')
def test_planar_mps_decoder_positive_max_coset_probability(mode): # parameters code = PlanarCode(9, 9) decoder = PlanarMPSDecoder(chi=48, mode=mode) error_model = BiasedDepolarizingErrorModel(bias=100) error_probability = 0.41 # logged run values error = pt.unpack([ "c96aa012210dc2254031f15d9ce80c871fb864b510c91086e112a018f8aece7406638fdc00", 290 ]) syndrome = pt.unpack(["8f59cd273bd1c027b3b925085af85f2aaf22", 144]) assert np.array_equal(syndrome, pt.bsp(error, code.stabilizers.T)) # debug # print(code.ascii_art(syndrome, code.new_pauli(error))) # decode prob_dist = error_model.probability_distribution(error_probability) any_recovery = decoder.sample_recovery(code, syndrome) # coset probabilities coset_ps, recoveries = decoder._coset_probabilities( prob_dist, any_recovery) print('mode={}, coset_ps={}'.format(mode, coset_ps)) max_coset_p, max_recovery = max( zip(coset_ps, recoveries), key=lambda coset_p_recovery: coset_p_recovery[0]) success = np.all( pt.bsp(max_recovery.to_bsf() ^ error, code.logicals.T) == 0) print('### success=', success) assert mp.isfinite( max_coset_p ) and max_coset_p > 0, 'Max coset probability not as expected'
def test_planar_y_decoder_y_stabilizers(code): y_stabilizers = PlanarYDecoder._y_stabilizers(code) code_gcd = math.gcd(*code.size) assert len(y_stabilizers) == 2**( code_gcd - 1), 'There are not 2^(gcd(p,q)-1) y-stabilizers' assert not np.any(pt.bsp(y_stabilizers, code.stabilizers.T) ), 'Y-stabilizers do not commute with code stabilizers' assert not np.any(pt.bsp( y_stabilizers, code.logicals.T)), 'Y-stabilizers do not commute with code logicals'
def _timed_runs(decoder): start_time = time.time() for _ in range(n_run): error = error_model.generate(code, error_probability) syndrome = pt.bsp(error, code.stabilizers.T) recovery = decoder.decode(code, syndrome) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.' .format(recovery, error)) return time.time() - start_time
def test_color666_mps_decoder_sample_recovery(error_pauli): error = error_pauli.to_bsf() code = error_pauli.code syndrome = pt.bsp(error, code.stabilizers.T) recovery_pauli = Color666MPSDecoder.sample_recovery(code, syndrome) recovery = recovery_pauli.to_bsf() assert np.array_equal(pt.bsp(recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'.format(recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'.format(recovery, error))
def test_naive_decoder_decode(error): code = FiveQubitCode() decoder = NaiveDecoder() syndrome = pt.bsp(error, code.stabilizers.T) recovery = decoder.decode(code, syndrome) assert np.array_equal(pt.bsp(recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'.format( recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'.format( recovery, error))
def test_color666_mps_decoder_decode(error_pauli, chi, caplog): with caplog.at_level(logging.WARN): error = error_pauli.to_bsf() code = error_pauli.code syndrome = pt.bsp(error, code.stabilizers.T) decoder = Color666MPSDecoder(chi=chi) recovery = decoder.decode(code, syndrome) assert np.array_equal(pt.bsp(recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'.format(recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'.format(recovery, error)) assert len(caplog.records) == 0, 'Unexpected log messages: {}'.format(caplog.text)
def test_toric_mwpm_decoder_decode(error_pauli): error = error_pauli.to_bsf() code = error_pauli.code decoder = ToricMWPMDecoder() syndrome = pt.bsp(error, code.stabilizers.T) recovery = decoder.decode(code, syndrome) assert np.array_equal(pt.bsp(recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'.format( recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'.format( recovery, error))
def test_planar_y_decoder_sample_recovery_with_residual(error_pauli): error = error_pauli.to_bsf() code = error_pauli.code syndrome = pt.bsp(error, code.stabilizers.T) recovery = PlanarYDecoder._sample_recovery(code, syndrome) print() print(error_pauli) print(code.ascii_art(syndrome, code.new_pauli(recovery))) assert np.array_equal(pt.bsp(recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'.format( recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'.format( recovery, error))
def test_planar_mps_decoder_svd_does_not_converge(): code = PlanarCode(21, 21) decoder = PlanarMPSDecoder(chi=4) error = pt.unpack(( '001281500200080080000000000080001000000c0000002012000000801040004000000100000000004000002100000800800000000000' '02000100028022001000002044841000080080008110020000400801200000801040112008010004400000000000000002000000402201' '10040000000000000481000200000601000080080000000820200020000000008820000100000010045000004000010000000000000000' '40010000840010200008000400024000880000000004000000004000200890040001082000000000000002000000', 1682)) syndrome = pt.bsp(error, code.stabilizers.T) recovery = decoder.decode(code, syndrome) # no error raised assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'.format( recovery, error))
def test_planar_lattice_ascii_art(pauli): code = pauli.code syndrome = pt.bsp(pauli.to_bsf(), code.stabilizers.T) assert isinstance(code.ascii_art(), str) assert isinstance(code.ascii_art(syndrome=syndrome), str) assert isinstance(code.ascii_art(pauli=pauli), str) assert isinstance(code.ascii_art(syndrome=syndrome, pauli=pauli), str)
def test_color666_mps_decoder_decode_value(): # expected coset_ps expected_coset_ps = ( mp.mpf('1.4290529991554288e-9'), # I mp.mpf('2.1657729564075353e-13'), # X mp.mpf('2.2541268663248664e-13'), # Y mp.mpf('9.3780172173812118e-12'), # Z ) code = Color666Code(7) decoder = Color666MPSDecoder(chi=16) # error error = code.new_pauli() error.site('X', (2, 1)) # error.site('Y', (3, 1), (4, 2), (7, 3), (9, 6)) error.site('Y', (7, 3)) error.site('Z', (6, 0), (3, 3), (7, 6)) # syndrome syndrome = pt.bsp(error.to_bsf(), code.stabilizers.T) # sample sample = decoder.sample_recovery(code, syndrome) print(sample) # probabilities prob_dist = DepolarizingErrorModel().probability_distribution(0.1) # coset probabilities coset_ps, _ = decoder._coset_probabilities(prob_dist, sample) print('# expected Pr(G)=', expected_coset_ps) print('# actual Pr(G)=', coset_ps) assert all(_is_close(expected_coset_ps, coset_ps, rtol=1e-11, atol=0)), ( 'Coset probabilites do not satisfy expected Pr(G) ~= Pr(G)')
def test_planar_cmwpm_decoder_null_decoding(): code = PlanarCode(3, 3) error = code.new_pauli().site('Y', (2, 0), (2, 4)).to_bsf() syndrome = pt.bsp(error, code.stabilizers.T) decoder_null = PlanarCMWPMDecoder(max_iterations=0) recovery = decoder_null.decode(code, syndrome) assert np.all(recovery == 0), 'Null decoder does not return null recovery'
def test_planar_y_decoder_decode(error_pauli): error = error_pauli.to_bsf() code = error_pauli.code decoder = PlanarYDecoder() syndrome = pt.bsp(error, code.stabilizers.T) recovery = decoder.decode(code, syndrome) print() print(code.new_pauli(recovery)) assert np.array_equal(pt.bsp(recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'.format( recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'.format( recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with logicals.'.format( recovery, error))
def test_planar_y_decoder_partial_recovery(code, syndrome_index, expected_syndrome_indices): partial_recovery = PlanarYDecoder._partial_recovery(code, syndrome_index) print() print(code.new_pauli(partial_recovery)) syndrome = pt.bsp(partial_recovery, code.stabilizers.T) syndrome_indices = code.syndrome_to_plaquette_indices(syndrome) assert syndrome_indices == expected_syndrome_indices, 'syndrome_indices not as expected'
def test_planar_cmwpm_decoder_dog_leg_correlated_error(): """ ·─┬─·─┬─·─┬─·─┬─· · · · · ·─┼─Y─┼─·─┼─·─┼─· · Y Y · ·─┼─·─┼─Y─┼─·─┼─· · · · · ·─┴─·─┴─·─┴─·─┴─· """ code = PlanarCode(4, 5) error = code.new_pauli().site('Y', (2, 2), (3, 3), (4, 4), (3, 5)).to_bsf() syndrome = pt.bsp(error, code.stabilizers.T) decoder_mwpm = PlanarCMWPMDecoder(max_iterations=1) decoder_cmwpm_t_2 = PlanarCMWPMDecoder(factor=3, max_iterations=4, box_shape='t', distance_algorithm=2) decoder_cmwpm_t_4 = PlanarCMWPMDecoder(factor=3, max_iterations=4, box_shape='t', distance_algorithm=4) decoder_cmwpm_r_1 = PlanarCMWPMDecoder(factor=3, max_iterations=4, box_shape='r', distance_algorithm=1) # show mwpm fails recovery = decoder_mwpm.decode(code, syndrome) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'MWPM recovery does not commute with stabilizers.') assert not np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'MWPM recovery does commute with logicals.') # show cmwpm_t_2 fails recovery = decoder_cmwpm_t_2.decode(code, syndrome) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'CMWPM (t,2) recovery does not commute with stabilizers.') assert not np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'CMWPM (t,2) recovery does commute with logicals.') # show cmwpm_t_4 succeeds recovery = decoder_cmwpm_t_4.decode(code, syndrome) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'CMWPM (t,4) recovery does not commute with stabilizers.') assert np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'CMWPM (t,4) recovery does not commute with logicals.') # show cmwpm_r_1 succeeds recovery = decoder_cmwpm_r_1.decode(code, syndrome) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'CMWPM (r,1) recovery does not commute with stabilizers.') assert np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'CMWPM (r,1) recovery does not commute with logicals.')
def test_rotated_planar_mps_decoder_sample_recovery(error_pauli): print('ERROR:') print(error_pauli) error = error_pauli.to_bsf() code = error_pauli.code syndrome = pt.bsp(error, code.stabilizers.T) print('SYNDROME:') print(code.ascii_art(syndrome=syndrome)) recovery_pauli = RotatedPlanarMPSDecoder.sample_recovery(code, syndrome) print('SAMPLE_RECOVERY:') print(recovery_pauli) recovery = recovery_pauli.to_bsf() assert np.array_equal(pt.bsp(recovery, code.stabilizers.T), syndrome), ( 'recovery {} does not give the same syndrome as the error {}'.format( recovery, error)) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'recovery ^ error ({} ^ {}) does not commute with stabilizers.'.format( recovery, error))
def test_planar_y_decoder_destabilizer(code, syndrome_index, expected_syndrome_indices): destabilizer = PlanarYDecoder._destabilizer(code, syndrome_index) print() print(code.new_pauli(destabilizer)) syndrome = pt.bsp(destabilizer, code.stabilizers.T) syndrome_indices = code.syndrome_to_plaquette_indices(syndrome) print(syndrome_indices) assert syndrome_indices == expected_syndrome_indices, 'syndrome_indices not as expected'
def test_planar_cmwpm_decoder_overflow(caplog): """ Error: ·─┬─·─┬─·─┬─·─┬─· · · · · ·─┼─Y─┼─·─┼─·─┼─· · Y · · ·─┼─·─┼─·─┼─·─┼─· · · · · ·─┼─·─┼─·─┼─Z─┼─· · · · · ·─┴─·─┴─·─┴─·─┴─· Syndrome: ──┬───┬───┬───┬── │ Z │ │ │ ──X───┼───┼───┼── │ │ Z │ │ ──┼───X───┼───┼── │ │ │ │ ──┼───┼───X───X── │ │ │ │ ──┴───┴───┴───┴── """ factor = 1e+308 # This is just a bit smaller than max float, so it causes overflow with multiple matched indices code = PlanarCode(5, 5) error = code.new_pauli().site('Y', (2, 2), (3, 3)).site('Z', (6, 6)).to_bsf() syndrome = pt.bsp(error, code.stabilizers.T) decoder_cmwpm = PlanarCMWPMDecoder(factor=factor, max_iterations=4, box_shape='t', distance_algorithm=4) # show cmwpm succeeds print() recovery = decoder_cmwpm.decode(code, syndrome) assert np.all(pt.bsp(recovery ^ error, code.stabilizers.T) == 0), ( 'CMWPM recovery does not commute with stabilizers.') assert np.all(pt.bsp(recovery ^ error, code.logicals.T) == 0), ( 'CMWPM recovery does not commute with logicals.') assert 'FPE RAISED FloatingPointError' in caplog.text, 'FloatingPointError not logged' print(caplog.text)
def test_rotated_toric_lattice_ascii_art(pauli): code = pauli.code syndrome = pt.bsp(pauli.to_bsf(), code.stabilizers.T) assert isinstance(code.ascii_art(), str) assert isinstance(code.ascii_art(syndrome=syndrome), str) assert isinstance(code.ascii_art(pauli=pauli), str) ascii_art = code.ascii_art(syndrome=syndrome, pauli=pauli) print() print() print(ascii_art) assert isinstance(ascii_art, str)
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 validate(self): r""" Perform various sanity checks. Sanity checks: * :math:`stabilizers \odot stabilisers^T = 0` * :math:`stabilizers \odot logicals^T = 0` * :math:`logicals \odot logicals^T = \Lambda` See :func:`qecsim.paulitools.bsp` for definition of :math:`\odot` and :math:`\Lambda`. :raises QecsimError: if the stabilizers or logicals fail the sanity checks. """ if not np.all(pt.bsp(self.stabilizers, self.stabilizers.T) == 0): raise QecsimError('Stabilizers do not mutually commute.') if not np.all(pt.bsp(self.stabilizers, self.logicals.T) == 0): raise QecsimError('Stabilizers do not commute with logicals.') # twisted identity with shape (len(logicals), len(logicals)) i1, i2 = np.hsplit(np.identity(len(self.logicals), dtype=int), 2) expected = np.hstack((i2, i1)) if not np.array_equal(pt.bsp(self.logicals, self.logicals.T), expected): raise QecsimError('Logicals do not commute as expected.')
def decode(self, code, syndrome, **kwargs): """ See :meth:`qecsim.model.Decoder.decode` :raises ValueError: if qubits in code exceeds max_qubits. """ n_qubits = code.n_k_d[0] if self._max_qubits and n_qubits > self._max_qubits: raise ValueError( 'NaiveDecoder limited to {} qubits. {} code has {} qubits. ' 'Set max_qubits to override limit.'.format( self._max_qubits, code.label, n_qubits)) for error in pt.ibsf(n_qubits): if np.array_equal(pt.bsp(error, code.stabilizers.T), syndrome): return error
def test_planar_mps_decoder_zero_norm_in_left_canonical_form(): # parameters random_seed = 13 code = PlanarCode(7, 7) error_model = BitFlipErrorModel() decoder = PlanarMPSDecoder(chi=6, mode='c') error_probability = 0.1 # single run error = error_model.generate(code, error_probability, np.random.default_rng(random_seed)) syndrome = pt.bsp(error, code.stabilizers.T) decoder.decode(code, syndrome, error_model=error_model, error_probability=error_probability)
def test_planar_rmps_mps_accuracy(error_pauli): error = error_pauli.to_bsf() code = error_pauli.code syndrome = pt.bsp(error, code.stabilizers.T) recovery_pauli = PlanarRMPSDecoder.sample_recovery(code, syndrome) prob_dist = DepolarizingErrorModel().probability_distribution(0.1) rmps_coset_ps, _ = PlanarRMPSDecoder(chi=8)._coset_probabilities( prob_dist, recovery_pauli) print('#rmps_coset_ps (chi=8)=', rmps_coset_ps) mps_coset_ps, _ = PlanarMPSDecoder(chi=8)._coset_probabilities( prob_dist, recovery_pauli) print('#mps_coset_ps (chi=8)=', mps_coset_ps) assert all(_is_close( rmps_coset_ps, mps_coset_ps, rtol=1e-1, atol=0)), ('rmps_coset_ps (chi=8) not close to mps_coset_ps (chi=8)')