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)')
