Esempio n. 1
0
def test_quantum_fourier():
    assert QFT(0,3).decompose() == SwapGate(0,2)*HadamardGate(0)*CGate((0,), PhaseGate(1))\
    *HadamardGate(1)*CGate((0,), TGate(2))*CGate((1,), PhaseGate(2))*HadamardGate(2)

    assert IQFT(0,3).decompose() == HadamardGate(2)*CGate((1,), RkGate(2,-2))*CGate((0,),RkGate(2,-3))\
    *HadamardGate(1)*CGate((0,), RkGate(1,-2))*HadamardGate(0)*SwapGate(0,2)

    assert represent(QFT(0,3), nqubits=3)\
     == Matrix([[exp(2*pi*I/8)**(i*j%8)/sqrt(8) for i in range(8)] for j in range(8)])

    assert QFT(0, 4).decompose()  #non-trivial decomposition
    assert qapply(QFT(0,3).decompose()*Qubit(0,0,0)).expand() ==\
    qapply(HadamardGate(0)*HadamardGate(1)*HadamardGate(2)*Qubit(0,0,0)).expand()
Esempio n. 2
0
def test_sympy__physics__quantum__qft__IQFT():
    from sympy.physics.quantum.qft import IQFT
    assert _test_args(IQFT(0, 1))
def find_r(x, N):
    """

    Encontra o período de x em aritimética módulo N.
    Essa é a parte realmente quântica da solução.

    Põe a primeira parte do registrador em um estado de superposição |j> |0>,
    com j = 0 to 2 ** n - 1, usando a porta Hadamard.
    Depois aplica a porta Vx e IQFT para determinar a ordem de x.

    """

    # Calcula o número de qubits necessários
    n = int(math.ceil(log(N, 2)))
    t = int(math.ceil(2 * log(N, 2)))

    print("n: ", n)
    print("t: ", t)

    # Cria o registrador
    register = Qubit(IntQubit(0, t + n))
    print("register: ", register)

    # Põe a segunda metade do registrado em superposição |1>|0> + |2>|0> + ... |j>|0> + ... + |2 ** n - 1>|0>
    print("Aplicando Hadamard...")
    circuit = 1
    for i in reversed(list(range(n, n + t))):
        circuit = HadamardGate(i) * circuit
    circuit = qapply(circuit * register)
    print("Circuit Hadamard:\n", circuit.simplify())

    # Calcula os valores para a primeira metade do registrador |1>|x ** 1 % N> + |2>|x ** 2 % N> + ... + |k>|x ** k % N >+ ... + |2 ** n - 1 = j>|x ** j % N>
    print("Aplicando Vx...")
    circuit = qapply(Vx(n, t, x, N) * circuit)
    print("Circuit Vx:\n", circuit.simplify())

    # Faz a medição da primeira metade do registrador obtendo um dos [x ** j % N's]
    print("Medindo 0->n ...")
    circuit = measure_partial_oneshot(circuit, range(n))
    print("Circuit 0->n:\n", circuit.simplify())

    # Aplica a Transformada de Fourier Quântica Inversa na segunda metade do registrador
    print("Aplicando a transformada inversa...")
    circuit = qapply(IQFT(n, n + t).decompose() * circuit)
    print("Circuit IQFT:\n", circuit.simplify())

    # Faz a medição da segunda metade do registrador um dos valores da transformada

    while (
            True
    ):  # O correto seria repetir a rotina inteira, mas é suficiente repetir a medição.
        # Num computador quântico real o estado colapsaria e não seria possível medi-lo novamente.
        print("Medindo n->n+t ...")

        #measurement = measure_partial_oneshot(circuit, range(n, n + t))
        measurement = measure_all_oneshot(circuit)

        print(measurement.simplify())

        if isinstance(measurement, Qubit):
            register = measurement
        elif isinstance(measurement, Mul):
            register = measurement.args[-1]
        else:
            register = measurement.args[-1].args[-1]

        print("Medicao: ", register)

        # Converte o qubit de binário para decimal
        k = 1
        answer = 0
        for i in range(t):
            answer += k * register[n + i]
            k = k << 1

        print("Medicao: ", answer)

        if answer != 0:
            break

    print("2^t: ", 2**t)
    # Lista os termos da fração continuada
    fraction = continued_fraction(answer, 2**t)

    # A soma dos termos da fração continuada é a razão entre dois
    # números primos entre si (p e q onde MDC(p, q) == 1) que
    # multiplicados resultam N (somar apenas os termos menores ou iguais a N)
    r = 0
    for x in fraction:
        if (x > N):
            break
        else:
            print("fraction: ", x)
            r = r + x

    return r