示例#1
0
def test_bell_perm():
    assert [len(generate_bell(i)) for i in xrange(1, 7)] == [1, 2, 5, 15, 52, 203]
    assert list(generate_bell(4)) == [(0, 1, 2, 3), (0, 1, 3, 2), (0, 2, 1, 3),
                                     (0, 3, 1, 2), (0, 3, 2, 1), (1, 0, 2, 3),
                                     (1, 0, 3, 2), (2, 0, 1, 3), (2, 1, 0, 3),
                                     (2, 3, 0, 1), (3, 0, 1, 2), (3, 0, 2, 1),
                                     (3, 1, 0, 2), (3, 1, 2, 0), (3, 2, 1, 0)]
示例#2
0
def test_bell_perm():
    assert [len(generate_bell(i)) for i in xrange(1, 7)] == [1, 2, 5, 15, 52, 203]
    assert list(generate_bell(4)) == [(0, 1, 2, 3), (0, 1, 3, 2), (0, 2, 1, 3),
                                     (0, 3, 1, 2), (0, 3, 2, 1), (1, 0, 2, 3),
                                     (1, 0, 3, 2), (2, 0, 1, 3), (2, 1, 0, 3),
                                     (2, 3, 0, 1), (3, 0, 1, 2), (3, 0, 2, 1),
                                     (3, 1, 0, 2), (3, 1, 2, 0), (3, 2, 1, 0)]
示例#3
0
def test_bell_perm():
    assert [len(set(generate_bell(i))) for i in range(1, 7)] == [factorial(i) for i in range(1, 7)]
    assert list(generate_bell(3)) == [(0, 1, 2), (0, 2, 1), (2, 0, 1), (2, 1, 0), (1, 2, 0), (1, 0, 2)]
    # generate_bell and trotterjohnson are advertised to return the same
    # permutations; this is not technically necessary so this test could
    # be removed
    for n in range(1, 5):
        p = Permutation(range(n))
        b = generate_bell(n)
        for bi in b:
            assert bi == tuple(p.array_form)
            p = p.next_trotterjohnson()
    raises(ValueError, lambda: list(generate_bell(0)))  # XXX is this consistent with other permutation algorithms?
示例#4
0
def test_bell_perm():
    assert [len(set(generate_bell(i))) for i in range(1, 7)] == [
        factorial(i) for i in range(1, 7)]
    assert list(generate_bell(3)) == [
        (0, 1, 2), (0, 2, 1), (2, 0, 1), (2, 1, 0), (1, 2, 0), (1, 0, 2)]
    # generate_bell and trotterjohnson are advertised to return the same
    # permutations; this is not technically necessary so this test could
    # be removed
    for n in range(1, 5):
        p = Permutation(range(n))
        b = generate_bell(n)
        for bi in b:
            assert bi == tuple(p.array_form)
            p = p.next_trotterjohnson()
    raises(ValueError, lambda: list(generate_bell(0)))  # XXX is this consistent with other permutation algorithms?
示例#5
0
def test_bell_perm():
    assert [len(list(generate_bell(i)))
            for i in xrange(1, 7)] == [factorial(i) for i in xrange(1, 7)]
    assert list(generate_bell(3)) == [(0, 1, 2), (1, 0, 2), (1, 2, 0),
                                      (2, 1, 0), (2, 0, 1), (0, 2, 1)]
示例#6
0
def test_bell_perm():
    assert [len(list(generate_bell(i))) for i in xrange(1, 7)] == [
        factorial(i) for i in xrange(1, 7)]
    assert list(generate_bell(3)) == [
        (0, 1, 2), (1, 0, 2), (1, 2, 0), (2, 1, 0), (2, 0, 1), (0, 2, 1)]
示例#7
0
def q_instability_psi(n_qubits, n_ones):
    # from Phys. Rev. A 79, 022302 , eq. 4
    S = lambda k, l: np.sqrt(2 /
                             (n_qubits + 1)) * np.sin(np.pi * (k + 1) *
                                                      (l + 1) / (n_qubits + 1))

    ## generate unnormalized dicke state with (n_qubits, k).
    n_zeros = n_qubits - n_ones
    # initialize vector with n_zeros of zeros and n_ones of ones
    zeros_int = [0 for _ in range(n_zeros)]
    ones_int = [1 for _ in range(n_ones)]
    statevector_init_int = zeros_int + ones_int

    # generate all permutations
    statevect_permutations_int = multiset_permutations(statevector_init_int)

    # generate a list of combinations of flipped spin locations for a given number of spins
    ls = [list(np.nonzero(row)[0]) for row in list(statevect_permutations_int)]
    ls = np.array(ls)

    # generate a permutation group for number of spins
    #ks = list(multiset_permutations(list(range(n_ones))))
    ks = list(generate_bell(n_ones))
    ks = np.array(ks)

    # construct pairs of ks and ls
    clist = []
    for llist in ls:
        # llist goes in the subscript of C (so C_(llist))
        c = 0
        for j, klist in enumerate(ks):
            # j = permutation number
            # klist = ks[j] = member of the permuation group of k
            #       = P_j(ks)
            cterm = (-1)**(j + 1)
            for i in range(len(klist)):
                k, l = klist[i], llist[i]

                cterm *= S(k, l)
            c += cterm

        clist += [c]

    zeros = ["0" for _ in range(n_zeros)]
    ones = ["1" for _ in range(n_ones)]
    statevector_init = zeros + ones

    # generate all permutations
    statevect_permutations = multiset_permutations(statevector_init)

    # join the string of 0s and 1s, convert it to an integer from base 2,
    # these will be the locations of nonzero probabilities
    positiveproblocations = [
        int("".join(vect_permutation), 2)
        for vect_permutation in statevect_permutations
    ]

    # generate XX state
    q_instability_state = [0.] * 2**n_qubits
    for i, loc in enumerate(positiveproblocations):
        q_instability_state[loc] = clist[i]

    # normalize
    q_instability_state = np.array(q_instability_state)
    q_instability_state /= norm(q_instability_state)
    return q_instability_state