def test_weight(self): """Error weighting code test.""" error = ("Error: Calculated error probability not correct for " + "test result '0 0 11 00' in d=3, T=1 repetition code.") code = RepetitionCode(3, 1) dec = GraphDecoder(code) test_results = {"0": {"0 0 00 00": 1024, "0 0 11 00": 512}} p = dec.get_error_probs(test_results) self.assertTrue(round(p[(1, 0, 0), (1, 0, 1)], 2) == 0.33, error)
def test_string2nodes(self): """Test string2nodes with different logical values.""" code = RepetitionCode(3, 2) dec = GraphDecoder(code) s0 = '0 0 01 00 01' s1 = '1 1 01 00 01' self.assertTrue( dec._string2nodes(s0, logical='0') == dec._string2nodes(s1, logical='1'), 'Error: Incorrect nodes from results string')
def test_string2nodes(self): """Test string2nodes with different logical values.""" code = RepetitionCode(3, 2) dec = GraphDecoder(code) s0 = "0 0 01 00 01" s1 = "1 1 01 00 01" self.assertTrue( dec._string2nodes(s0, logical="0") == dec._string2nodes(s1, logical="1"), "Error: Incorrect nodes from results string", )
def single_error_test(self, code): """ Insert all possible single qubit errors into the given code, and check that each creates a pair of syndrome nodes. """ decoder = GraphDecoder(code) for logical in ["0", "1"]: qc = code.circuit[logical] blank_qc = QuantumCircuit() for qreg in qc.qregs: blank_qc.add_register(qreg) for creg in qc.cregs: blank_qc.add_register(creg) error_circuit = {} circuit_name = {} depth = len(qc) for j in range(depth): qubits = qc.data[j][1] for qubit in qubits: for error in ["x", "y", "z"]: temp_qc = blank_qc.copy() temp_qc.name = str((j, qubit, error)) temp_qc.data = qc.data[0:j] getattr(temp_qc, error)(qubit) temp_qc.data += qc.data[j:depth + 1] circuit_name[(j, qubit, error)] = temp_qc.name error_circuit[temp_qc.name] = temp_qc simulator = Aer.get_backend("aer_simulator") job = execute(list(error_circuit.values()), simulator) for j in range(depth): qubits = qc.data[j][1] for qubit in qubits: for error in ["x", "y", "z"]: raw_results = {} raw_results[logical] = job.result().get_counts( str((j, qubit, error))) results = code.process_results(raw_results)[logical] for string in results: nodes = decoder._string2nodes(string, logical=logical) self.assertIn( len(nodes), [0, 2], "Error of type " + error + " on qubit " + str(qubit) + " at depth " + str(j) + " creates " + str(len(nodes)) + " nodes in syndrome graph, instead of 2.", )
def test_graph(self): """Test if analytically derived SyndromeGraph is correct.""" error = ( "Error: The analytical SyndromeGraph does not coincide " + "with the brute force SyndromeGraph in d=7, T=2 RepetitionCode.") code = RepetitionCode(7, 2) graph_new = GraphDecoder(code, brute=False).S graph_old = GraphDecoder(code, brute=True).S test_passed = True for node in graph_new.nodes(): test_passed &= node in graph_old.nodes() for node in graph_old.nodes(): test_passed &= node in graph_new.nodes() test_passed &= rx.is_isomorphic(graph_new, graph_old, lambda x, y: x == y) self.assertTrue(test_passed, error)
def test_rep(self): """ Repetition code test. """ matching_probs = {} lookup_probs = {} post_probs = {} max_dist = 5 noise_model = get_noise(0.02, 0.02) for d in range(3, max_dist + 1, 2): code = RepetitionCode(d, 2) results = get_syndrome(code, noise_model=noise_model, shots=8192) dec = GraphDecoder(code) logical_prob_match = dec.get_logical_prob(results) logical_prob_lookup = lookuptable_decoding(results, results) logical_prob_post = postselection_decoding(results) for log in ['0', '1']: matching_probs[(d, log)] = logical_prob_match[log] lookup_probs[(d, log)] = logical_prob_lookup[log] post_probs[(d, log)] = logical_prob_post[log] for d in range(3, max_dist - 1, 2): for log in ['0', '1']: m_down = matching_probs[(d, log)] \ > matching_probs[(d + 2, log)] l_down = lookup_probs[(d, log)] \ > lookup_probs[(d + 2, log)] p_down = post_probs[(d, log)] \ > post_probs[(d + 2, log)] m_error = "Error: Matching decoder does not improve "\ + "logical error rate between repetition codes"\ + " of distance " + str(d) + " and " + str(d + 2) + ".\n"\ + "For d="+str(d)+": " + str(matching_probs[(d, log)])\ + ".\n"\ + "For d="+str(d+2)+": " + str(matching_probs[(d+2, log)])\ + "." l_error = "Error: Lookup decoder does not improve "\ + "logical error rate between repetition codes"\ + " of distance " + str(d) + " and " + str(d + 2) + ".\n"\ + "For d="+str(d)+": " + str(lookup_probs[(d, log)])\ + ".\n"\ + "For d="+str(d+2)+": " + str(lookup_probs[(d+2, log)])\ + "." p_error = "Error: Postselection decoder does not improve "\ + "logical error rate between repetition codes"\ + " of distance " + str(d) + " and " + str(d + 2) + ".\n"\ + "For d="+str(d)+": " + str(post_probs[(d, log)])\ + ".\n"\ + "For d="+str(d+2)+": " + str(post_probs[(d+2, log)])\ + "." self.assertTrue(m_down or matching_probs[(d, log)] == 0.0, m_error) self.assertTrue(l_down or lookup_probs[(d, log)] == 0.0, l_error) self.assertTrue(p_down or post_probs[(d, log)] == 0.0, p_error)