def succprob_poly_withMC(graph, transm=0.9, MC_samples=1000, t_sampl_func=None, in_qubit=0, printing=False):
    """
    Returns an analytical estimate (lower bound) of the success probability for recovering a qubit encoded in the
    graph, in the form of a polinomial of the form

            a_1 t^(e_11) (1-t)^(e_12) + a_2 t^(e_21) (1-t)^(e_22) + ... + a_n t^(e_n1) (1-t)^(e_n2)

    returning it in the form of the dictionary {(e_11, e_12): a_1, (e_21, e_22): a_2, ... , (e_n1, e_n2): a_n}
    """
    gstate = GraphState(graph)
    poss_stabs_list = get_possible_stabs_meas(gstate, in_qubit)

    if t_sampl_func == None:
        trans_sampl_func = lambda t: transm
    else:
        trans_sampl_func = lambda t: t_sampl_func(t)

    success_measurements = []
    for test_ix in range(MC_samples):
        # print(trans_sampl_func(transm))
        decoding_succ, decoding_meas = MC_decoding(poss_stabs_list, trans_sampl_func(transm),
                                                   in_qubit, printing=False, provide_measures=True)
        if decoding_succ:
            success_measurements.append(decoding_meas)

    ## filter out duplicates
    # print('success_measurements', success_measurements)
    success_meas_filter = list(set(success_measurements))
    polynom_all_exponents = [(len(this_meas[0]), len(this_meas[1])) for this_meas in success_meas_filter]

    if printing:
        print("success_meas_filter :", success_meas_filter)
        print("polynom_all_exponents :", polynom_all_exponents)

    return dict(Counter(polynom_all_exponents))
Exemplo n.º 2
0
def graphstate_from_nodes_and_edges(graph_nodes, graph_edges):
    graph = nx.Graph()
    graph.add_nodes_from(graph_nodes)
    graph.add_edges_from(graph_edges)
    return GraphState(graph)
Exemplo n.º 3
0
##############################
###          MAIN          ###
##############################

if __name__ == '__main__':
    import matplotlib.pyplot as plt

    ## index of the input qubit (output qubit is free)
    in_qubit = 0

    ## define graph state

    # three graph
    branching = [2, 1]
    graph = gen_tree_graph(branching)
    gstate = GraphState(graph)

    ### fully connected graph
    # graph = gen_fullyconnected_graph(7)
    # gstate = GraphState(graph)

    ## get list of possible measurements to encode & decode the state
    poss_stabs_list = get_possible_stabs_meas(gstate, in_qubit)

    ##############################################################################
    ################################### SINGLE TEST ##############################
    ##############################################################################

    ## define channel transmission
    transmission = 0.7
    decoding_succ = MC_decoding(poss_stabs_list,
    else:
        return np.real(real_roots[0])


if __name__ == '__main__':
    import matplotlib.pyplot as plt

    in_qubit = 0

    ### random graph
    # graph = gen_random_connected_graph(6)
    # gstate = GraphState(graph)

    ### ring graph
    graph = gen_ring_graph(5)
    gstate = GraphState(graph)

    ### 5-qubit Shor-code graph
    # graph = nx.Graph()
    # nodes = list(range(6))
    # graph.add_nodes_from(nodes)
    # graph.add_edges_from(product([0], nodes[1:]))
    # graph.add_edges_from([(nodes[i], nodes[i + 1]) for i in range(1, 5)] + [(5, 1)])
    # gstate = GraphState(graph)

    ### Cascaded 3-rings
    # graph = nx.Graph()
    # nodes = list(range(7))
    # graph.add_nodes_from(nodes)
    # graph.add_edges_from([(0, 2), (0, 1), (1, 2), (1, 6), (1, 5), (5, 6), (2, 3), (2, 4), (3, 4)])
    # gstate = GraphState(graph)
Exemplo n.º 5
0
    import qecc as q

    # stab_gens = ["XZII", "ZXZI", "IZXZ", "IIZX"]
    # stab_gens = ["ZZII", "XXZI", "IZXZ", "IIZX"]  ##H on first
    # stab_gens = ["ZXII", "XZZI", "IXXZ", "IIZX"]  ##H on first and second
    # stab_gens = ["ZZXXX", "XXXXX", "XZZXX", "XXZZX", "XXXZZ"] # GHZ
    stab_gens = ["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ", "ZZZZZ"]  ## 5-qubit code
    # stab_gens = ["ZZIIIIIII", "ZIZIIIIII", "IIIZZIIII", "IIIZIZIII", "IIIIIIZZI", "IIIIIIZIZ",
    #              "XXXXXXIII", "XXXIIIXXX", "ZIIIZIZII"]  ## Shor code

    gen_list = q.PauliList(stab_gens)
    stab_state = StabState(gen_list)

    graph_equiv, adj_mat, clifford_transf, basis_change_mat = stab_to_graph(
        stab_state)
    graph_state = GraphState(graph_equiv)

    print('Adjacency matrix of equivalent graph state:')
    print(adj_mat)
    print('Local Clifford transformation:')
    print(clifford_transf)

    # SOME TARGET GRAPHS

    ######## 4 qubit line
    # graph_targ = nx.Graph()
    # graph_targ.add_nodes_from([0, 1, 2, 3])
    # graph_targ.add_edges_from([(0, 1), (1, 2), (2, 3)])

    ######## graph for 5-qubit star
    # graph_targ = nx.Graph()
    global_phase = np.pi / 7

    ### add Z rotation on first qubit
    theta = np.pi / 5
    added_U = np.kron(np.array([[1, 0], [0, np.exp(1.j * theta)]]),
                      np.identity(2**(qubits_num - 1)))

    ### print stuff?
    print_tests = False

    for edges_conf_ix, graph_edges in enumerate(all_graphs_by_edges):
        # print('Testing graph', edges_conf_ix, 'of', num_graphs)
        graph = nx.Graph()
        graph.add_nodes_from(graph_nodes)
        graph.add_edges_from(graph_edges)
        this_gstate = GraphState(graph)

        target_adjmat = this_gstate.adj_mat()

        vect_state0 = this_gstate.graph_vecstate()
        vect_state = added_U @ vect_state0
        vect_state = np.exp(1.j * global_phase) * vect_state
        test_if_graph, Amat, _ = vector_is_graphstate(vect_state,
                                                      print_error=False)

        if print_tests:
            print()
            print('target_adjmat:')
            print(target_adjmat)
            print('vect_state0')
            print(vect_state0)
Exemplo n.º 7
0
def graphstate_from_nodes_and_edges(graph_nodes, graph_edges):
    return GraphState(graph_from_nodes_and_edges(graph_nodes, graph_edges))
Exemplo n.º 8
0
                    full_new_lc_class = lc_equivalence_class(
                        graph, fixed_node=input_qubit)
                    obt_graphs = obt_graphs + full_new_lc_class
                    used_rots = used_rots + [
                        rots_list for i in range(len(full_new_lc_class))
                    ]
                    # print('Total class representatives number:', len(lc_class_representatives))
                    # print('Total graph number:', len(obt_graphs))
            else:
                if not arreq_in_list(adj_mat, obt_graphs):
                    # print("Got a NEW graph! Rotation sequence:", rots_list, " Local Z phases:", local_phases, " Applied hadamards: ", applied_hadamard)
                    print(rots_list, local_phases, applied_hadamard)
                    obt_graphs.append(adj_mat)
                    used_rots.append(rots_list)
                    plt.subplot()
                    gstate = GraphState(nx.from_numpy_matrix(adj_mat))
                    gstate.image(with_labels=True)
                    plt.show()
    if not include_lc:
        obt_graphs = [nx.from_numpy_matrix(this_A) for this_A in obt_graphs]

    # plot all obtained graphs
    num_graphs = len(obt_graphs)
    n = int(np.sqrt(num_graphs))

    n_plot_rows = n
    n_plot_cols = num_graphs / n
    if not isinstance(n_plot_cols, int):
        n_plot_cols = int(n_plot_cols) + 1

    # for code_ix in range(num_graphs):