Pró-Reitoria de Graduação Curso de Física Trabalho de Conclusão de Curso COMPUTAÇÃO QUÂNTICA: COMPARATIVO DOS ALGORITMOS DE SHOR E DE FERMAT

Pró-Reitoria de Graduação Curso de Física Trabalho de Conclusão de Curso COMPUTAÇÃO QUÂNTICA: COMPARATIVO DOS ALGORITMOS DE SHOR E DE FERMAT Autora: Silviane Silva Orientador: Dr. Paulo Henrique Alves Guimarães Brasília - DF 2011

COMPUTAÇÃO QUÂNTICA: COMPARATIVO DOS ALGORITMOS DE SHOR E DE FERMAT (Quantum Computation: Comparison between Shor's and Fermat s algorithms) Silviane Silva 1, Dr. Paulo Henrique A. Guimarães 2 1 Curso de Física - Universidade Católica de Brasília 2 Departamento de Física Universidade de Brasília Tanto um computador clássico quanto um computador quântico fazem uso de algoritmos para realização de suas operações. Este trabalho se propõe a apresentar de forma simplificada uma breve introdução à computação quântica, compará-la com a computação clássica e mostrar o desempenho do algoritmo de Shor em um software desenvolvido para este trabalho, para o cálculo dos fatores coprimos de um número, em relação ao algoritmo de Fermat utilizado na computação clássica, demonstrando os resultados encontrados. Palavras-chave: Computação quântica, algoritmo de Shor, algoritmo de Fermat, computação clássica. Both classical computer and quantum computer makes use of algorithms to perform its operations. This paper intends to present in simplified form a brief introduction to quantum computing, compare it with classical computing and show the performance of Shor s algorithm on a software developed for this work, for the calculation of the coprime factors of a number in relation to the Fermat algorithm used in classical computing, demonstrating the results. Keywords: quantum computing, algorithms, Shor s algorithm, Fermat, classical computing. 1. Introdução A computação quântica atrai o interesse de muitas empresas que trabalham utilizando processamento de dados (NIELSEN, CHUANG, 2005, com adaptações). Ainda não concretizada, mais já avançada em muitas pesquisas, a computação quântica possui uma estrutura muito parecida com a 1

computação clássica, mas com a forma de recebimentos e processamento de dados muito diferente daquela. Por esse motivo está despertando muitas especulações na área de informática, especialmente nos assuntos de transmissão de informações que utilizam processos criptográficos. Um algoritmo cujo estudo já demonstra avanços nesta área é o desenvolvido por Peter Shor, que vem mostrando uma eficiência superior a todos os algoritmos já utilizados na computação clássica (NIELSEN, CHUANG, 2005, com adaptações). O primeiro assunto deste trabalho será sobre o início e evolução da computação quântica, seguido de um breve comparativo desta com a computação clássica. Mais adiante será demonstrada a importância do algoritmo na área computacional e porque a criptografia tem um papel fundamental na transmissão de informações. Na apresentação dos algoritmos de Fermat e de Shor serão comentadas suas falhas e utilizações. Por fim, será demonstrado o desempenho desses algoritmos em uma máquina clássica, utilizando um código desenvolvido em um programa de plataforma alta, onde poderão ser observadas as diferenças de processamento. 2. Inicio da Computação quântica Imaginar o nosso mundo atualmente sem a tecnologia computacional seria como regredirmos no tempo. Geralmente resumimos a história da computação com o surgimento da primeira máquina de Turing, quando na verdade a história da computação iniciou com a evolução do homem nas diversas áreas da física e da matemática (NIELSEN, CHUANG, 2005, com adaptações). A computação quântica é o resultado mais atual da evolução computacional. Em meados dos anos 80 Richard Feynman elaborou uma proposta de utilizar um fenômeno quântico para executar rotinas computacionais. Ele explica que um computador tradicional levaria um tempo extremamente longo para simular um simples experimento de física quântica. Foi baseada nesta ideia e utilizando as propriedades da mecânica quântica, que a computação quântica começou a evoluir. Atualmente já é possível 2

explicar como funciona um computador quântico. Grandes empresas como IBM Intel já possuem estudos avançados nesta área (NIELSEN, CHUANG, 2005, com adaptações). O computador quântico possui uma estrutura muito parecida com um computador normal, ambos possuem memórias, processador, portas de entradas e saída de dados, e periféricos. O diferencial de um computador quântico é a forma como ele processa as informações e como estas são lidas. As propriedades da mecânica quântica dizem que é possível que uma partícula esteja em dois ou mais estados ao mesmo tempo, e isso lembra muito a famosa metáfora do Gato de Schrödinger que diz: Se fecharmos um gato em um caixa e apostarmos se ele está vivo ou morto, teremos a probabilidade de ele estar cinquenta por cento vivo ou cinquenta por cento morto. Essa probabilidade também é ultilizada para as particulas na mecânica quântica e superposição das partículas (NETO, Acesso em: 05/10/2011, com adaptações). Para entendermos melhor o processamento dessas informações é necessário fazer um comparativo da computação clássica com a quântica. 3. Computação Quântica x Clássica Um computador quântico possui a mesma arquitetura dos computadores clássicos, organizada da seguinte forma: 3

Arquitetura do Computador Processad or Comutador Barramento de Memoria Bloco de Memória Barramento de Entrada/saída Sistema de Entrada/saída Disco Rígido CD - ROM Placa de Vídeo Monitor Figura 1: Organização básica de computadores (CARTER, 2001). Dentro da arquitetura computacional podemos verificar que o processador está na parte superior da arquitetura, isso porque o processador é o elemento responsável pela tradução das informações de entrada para o computador e pela execução dos programas que são sequências de instruções que dizem o que deve ser feito. O computador comunica-se com o bloco de memória através do barramento de memória que transfere e/ou recebe dados para o processador e barramentos de entradas e saídas, que seriam os dispositivos. Da mesma forma os dispositivos enviam dados através do barramento que os transfere para o comutador, o qual enviará dados para o bloco de memória ou para o processador (CARTER, 2001). Na computação clássica a entrada de dados é realizada da seguinte forma: 4

Quando o computador é ligado ele recebe sinais elétricos analógicos (elétrons); dependendo do nível de tensão do sinal os sistemas digitais do computador conseguem traduzi-lo para uma tensão baixa, cujo valor será representado por 0 (bit), ou para uma tensão alta, cujo valor será representado por 1 (bit). Sistemas que mapeiam sinais elétricos são conhecidos por reconhecerem alterações de tensões, e são chamados de sistemas binários, onde a tensão que cada sinal carrega é chamada de BIT (forma abreviada para Binary digit Dígito binário) (CARTER, 2001). A computação quântica consiste basicamente no processamento de dados de partículas subatômicas e seus estados que podem ser representados pelos q-bits, que seriam bits quânticos traduzidos em vetores. Com esses vetores podemos formar combinações lineares de estados, chamadas de superposições conforme a equação 1 abaixo: 0 1 Onde α e β são números complexos e pode armazenar inúmeras informações de uma só vez. Um bit clássico é como uma moeda, pode ter 2 estados: cara ou coroa. Em moedas defeituosas podem existir estados intermediários, como se ela se equilibrasse sobre a borda, mas tais situações podem ser descartadas no caso ideal. Em contraste, na computação quântica um q-bit pode existir em um estado contínuo entre 0 e 1 (1) - até que ele seja observado. Enfatizamos que quando um q-bit é medido, o resultado será sempre 0 ou 1 probabilisticamente (NIELSEN, CHUANG, 2005), um exemplo de estado quântico está representado abaixo: 1 2 0 1 2 1 (2) Calculando a probabilidade de encontrar os estados, verificar que dará 50% para 0 e 50% para 1. 2 1 2, pode-se 5

Um q-bit pode ser encontrado em diferentes estados físicos como: duas polarizações diferentes, polarizações de um fóton; alinhamento de um spin nuclear em um campo magnético uniforme; ou dois estados de um elétron orbitando ao redor do átomo; Figura 2: Dois níveis eletrônicos em um modelo átomo de Bohr representando um q- bit. Podemos reescrever a superposição de estados da seguinte forma (NIELSEN, CHUANG, 2005): ( ) (3) em que, e são números reais. O termo e não é geometricamente observável, logo podemos escrever a Equação 3 da seguinte forma (NIELSEN, CHUANG, 2005): ( ) (4) O argumento e número presentes na Equação 4 definem um ponto sobre a superfície de uma esfera de raio unitário chamada de esfera de Block ilustrada na Figura 2 (NIELSEN, CHUANG, 2005). 6

Figura 3: Representação de um q-bit na esfera de Block. Fonte: Enciclopédia livre - Wikipédia. A esfera de Block é um ótimo modelo para demonstração de um q-bit, mas para mais q-bits este modelo já não pode ser utilizado. 3.1. Circuitos Computacionais Fazer uma análise dos circuitos computacionais é interessante para entender a criação das chaves utilizadas na criptografia. Um computador clássico é constituído de circuitos elétricos contendo fios e portas lógicas. Um computador quântico é constituído a partir de um circuito quântico onde se encontram portas lógicas quânticas que manipulam a informação quântica e fios que transportam a informação (NIELSEN, CHUANG, 2005). Na computação clássica podemos tomar como exemplo um computador com três bits de memória, onde cada bit pode apenas armazenar dois estados lógicos (um ou zero); isso significa que os três bits podem representar oito estados lógicos (000, 001, 010, 011, 100, 101, 110, 111). Um computador quântico pode atualmente armazenar dezesseis valores analógicos em pares para formar oito números complexos conforme mostrado na tabela 1. 7

Tabela 1: Devido a superposição um computador quântico pode assumir 8 estados simultaneamente para um conjunto de 3 q-bits. Estado Amplitude Probabilidade * (a+ib) (a²+b²) 000 0.37 + i 0.04 0.14 001 0.11 + i 0.18 0.04 010 0.09 + i 0.31 0.10 011 0.30 + i 0.30 0.18 100 0.35 + i 0.43 0.31 101 0.40 + i 0.01 0.16 110 0.09 + i 0.12 0.02 111 0.15 + i 0.16 0.05 Fonte: Enciclopédia livre - Wikipédia os três bits. Na primeira coluna da Tabela 1 estão todos os estados possíveis para No computador clássico será suportado apenas um estado de cada vez, mas no computador quântico, devido a superposição, ele pode assumir os oitos estados simultaneamente. A segunda coluna mostra a "amplitude" para cada um dos oito estados. Os oito números complexos são uma imagem dos conteúdos de um computador quântico num determinado momento. No processamento estes oito números irão modificar e interagir uns com os outros. Com isso já se pode concluir que um computador quântico de três q-bits tem muito mais memória do que um computador clássico de três bits. A terceira coluna da tabela calcula a probabilidade de cada estado ser encontrado. Neste exemplo, há uma probabilidade de 14% de que o estado seja "000", 4% de que seja "001", e assim por diante (NIELSEN, CHUANG, 2005, com adaptações). 4. Criptografia A criptografia está ligada diretamente com os algoritmos, que seriam as instruções para executar várias tarefas, conforme explicações no item 5. Para este trabalho a criptografa não será utilizada, pois não a necessidade de se ocultar as informações, mas a explicação deste item é necessário pois os algoritmos de Shor e Fermat fazem uso da criptografia em rotinhas que necessitam ocultar informações de entrada e saída e informações. 8

Com o surgimento da internet e com a evolução da área computacional a criptográfica vem evoluindo com o passar dos anos. Existem várias formas de se ocultar uma informação, pode-se ocultar informações de formas simples ou mais elaboradas, um exemplo seria a RSA. A sigla RSA é originada das iniciais dos nomes de três professores do Instituto de Tecnologia de Massachusetts, seus nomes são Ronald Rivest, Adi Shamir e Leonard Adleman. RSA é um algoritmo de criptografia de dados que cria Chave Privada e Chave Pública. Uma chave é uma informação codificada através de um algoritmo e que será decodificada, também através de um algoritmo. A Chave Privada é uma informação pessoal que permanece em posse da pessoa - não publicável, já a Chave Pública é uma informação associada a uma pessoa que é distribuída a todos. Um exemplo muito conhecido é a transmissão de mensagens entre Alice e Bob que utilização da chave RSA. Alice e Bob precisam trocar mensagens seguras sem interceptação. O algoritmo RSA permite essa troca segura de mensagens pela utilização de chaves públicas e privadas: Alice cria seu par de chaves (uma pública e outra privada) e envia sua chave pública para todos, inclusive Bob; Bob escreve sua mensagem para Alice. Após escrita, Bob faz a cifragem do texto final com a chave pública de Alice, gerando um texto criptografado Alice recebe o texto criptografado de Bob e faz decifragem utilizando a sua chave privada O procedimento é realizado com sucesso porque somente a chave privada de Alice é capaz de decifrar um texto criptografado com a sua chave pública Se aplicarmos a chave pública de Alice sobre o texto critografado não teremos a mensagem original de Bob, mesmo que a mensagem seja interceptada é impossível decifrá-la sem a chave privada de Alice (NIELSEN, CHUANG, 2005 com adaptações). 9

5. Algoritmos e as principais aplicações Quando pensamos na palavra algoritmo fica difícil associá-la como uma tarefa, talvez por ela ser muito utilizada na área computacional. Um algoritmo é um conjunto de tarefas que devem ser executadas. Por exemplo: quando realizamos uma tarefa, seja ela qual for, e a realizamos como programado, estamos executando um algoritmo. Quando fazemos um bolo seguimos uma receita; portanto, executamos um algoritmo; mas então porque não utilizamos a palavra algoritmo em nosso dia a dia? O algoritmo é muito conhecido na área da computação, porque tudo começou no no inicio de século XX com um desafio proposto pelo matemático David Hilbert, questionando a existência de algum algoritmo que resolvesse todos os problemas matemáticos. Se esse algoritmo existisse seria a solução para muitos problemas não só da matemática, mas principalmente da computação. Nesta área já existiam grandes pioneiros que introduziram a teoria de algoritmos, como Afonzo Church e Alan Turing. É devido a eles que os algoritmos são muito conhecidos na área computacional (NIELSEN, CHUANG, 2005). É muito difícil fazer um computador ou qualquer aparelho eletrônico funcional sem a execução de um algoritmo, pois os circuitos eletrônicos funcionam com execução de um conjunto de tarefas (NIELSEN, CHUANG, 2005). A computação convencional e a computação quântica fazem uso de vários algoritmos, alguns mais elaborados, outros menos, mas quanto mais eficiente ele for maior será o seu desempenho e seu poder de solucionar problemas, para este trabalho será apresentado o funcionamento dos algoritmos de Fermat e Shor, conforme itens 5.1 e 5.2. 5.1 Algoritmo de Fermat O algoritmo de Fermat se originou do último Teorema de Fermat, feito pelo matemático e cientista Pierre de Fermat (França, 1601-1665) e não possuía registros de sua demonstração. Este teorema se originou a partir de um estudo sobre o famoso Teorema de Pitágoras, que demonstra que o 10

quadrado da hipotenusa é igual à soma do quadrado dos catetos. Adotando x e y como catetos e z como hipotenusa: x² + y² = z² (5) Partindo deste principio, o Algoritmo de Fermat é muito eficiente para fatorar números inteiros. Dado um número n será pesquisado dois números inteiros que satisfaçam a expressão: n x 2 - y 2 (6) Sendo: n (x - y)( x y ) (7) Onde x e y serão os fatores encontrados pelo algoritmo que pode ser escrito da seguinte forma: Dado um número n qualquer. Calcula-se a parte inteira da raiz de quadrada de n x. Elevando x 2, se R<n então soma-se 1 a x. Calcula-se x 2 -n y, retira-se a parte inteira de y que ficará y nte ro. Se o y <> y nte ro acrescêntasse mais 1 para x até que y =y nte ro. Exemplo: n=56. = 7.483314774, a parte inteira do resultado é 7. Elevando 7 2 =49 < 56 então x. Calcula-se 8 2-56 = 2.828427125, parte inteira é 2. 2.828427125 <> 2 então acrescentasse + 1 para x que assume o valor de x=9 Calcula-se 9 2-56 = 5, parte inteira é 5. Como o resultado da raiz é igual a parte inteira, temos: x=9 e y=5 Substituindo os valores na equação (7). Temos n=(9-5)(9 + 5)=56 Fatores encontrados: 4 e 14 11

5.2 Algoritmo de Shor O Algoritmo de Shor foi elaborado por Peter Shor, professor de matemática aplicada no Instituto de Tecnologia de Massachusetts (MIT), famoso por seu trabalho em computação quântica. Este algoritmo tem como principal característica fatoração de números muito grandes em computadores quânticos; por trabalhar com funções probabilísticas, ele mostra-se muito eficiente comparado a todos os algoritmos da computação clássica para fatoração de números. Um computador quântico pode executar este algoritmo com muita eficiência, por isso que se consegue adquirir resultados extraordinários com este algoritmo. Existem preocupações quanto a execução deste algoritmo processado em máquinas quânticas, devido a sua velocidade de execução ele poderia, em teoria, quebrar muitos dos sistemas criptográficos em uso atualmente. O algoritmo de Shor pode ser implementado em computadores clássicos, mas não terá em nenhum momento um desempenho comparado a um computador quântico. Podemos explicar este algoritmo resumindo em quatro passos: Dado um número N, escolhe-se de forma aleatória y<n tal que y e N sejam números coprimos (primos entre si), ou seja M.D.C.(y,N)=1. Em seguida procura-se o número r que satisfaça a equação y r =1 mod N. Sendo r um número ímpar volta-se ao passo inicial e escolhe-se aleatoriamente outro y. Sendo r um número par então x=y r/2 é candidato a solução não trivial da equação x 2 =1 mod N. (a solução não tr v al ocorre quando x ±a ±1). Sendo x uma solução trivial volta-se ao passo inicial e escolhe-se aleatoriamente outro y. Atendidas as condições acima os candidatos à solução consistem em encontrar: n 1 = M.D.C.(x-1,N) e n 2 = M.D.C.(x+1,N) 12

O algoritmo de Shor sendo um algoritmo probabilístico pode não se obter o resultado para a primeira escolha de y, mas sendo o número de possíveis y grande, haverá certamente uma convergência para a solução em um tempo polinomial (RODRIGUES, 2004). Partindo da citação acima, utilizaremos o número 56 como exemplo: Escolhendo um y aleatoriamente: y=51 Determinando o r: 51 r 1 mod 56 tal que r=6 Verifico se r é par, caso contrario volto para o início do algoritmo. Determinando o x: x 51 6 2 =132.651 Verificando se x é válido: 132.651 1 mod 56, caso contrario volto para o início do algoritmo. Determinando os fatores de 56 Fator 1 = M.D.C ((132.651 1),56) = 14 Fator 2 = M.D.C ((132.651 + 1),56) = 4 6 Comparativo dos algoritmos de Fermat e Shor O desempenho dos algoritmos de Fermat e Shor em um computador clássico foi demonstrado, neste trabalho, através de um código de programação orientado a objeto com o objetivo de apresentar de forma simples e comparativa alguns resultados. Foram observados pontos chaves para analisar as diferenças, como o tempo gasto no processamento e os níveis de utilização de memória e CPU da máquina. Conforme demonstrado no ítem 5, as características e finalidades dos algoritmos de Fermat e de Shor são diferentes, sobretudo o objetivo a que se propõem. Lembramos, por exemplo, que aplicando o algoritmo de Fermat fica fácil descobrir seus fatores desde que a diferença entre eles seja pequena. Já 13

para o algoritmo de SHOR observamos uma melhor performance para a fatoração de grandes números. 6.1 O Simulador Para a construção do simulador dos algoritmos foi utilizada a linguagem de programação Visual Basic.NET da Microsoft. A tecnologia Microsoft.NET é uma iniciativa da Microsoft que visa ter uma plataforma única para desenvolvimento e execução de sistemas e aplicações. Todo e qualquer código gerado para.net, pode ser executado em qualquer dispositivo ou plataforma que possua um framework na plataforma.net. O simulador conta com uma única tela dividida em duas seções, uma para demonstrar o cálculo com algoritmo Fermat e outra para algoritmo Shor. Para a medida do tempo gasto no processamento foram inseridos contadores visuais instantâneos. Importante destacar que a linguagem utilizada é orientada a objetos, o que significa que o software é construído com objetos que têm um comportamento especifico e interagem entre si, ou seja, baseia-se no conceito de que o sistema deve ser construído a partir de componentes reutilizáveis. A execução é realizada por rotinas, uma de cada vez. Portanto, existem dois botões separados, um para disparar a rotina de Fermat e outro para a de Shor. A tela do programa está demonstrada na Figura 4 abaixo: Figura 4: O simulador 14

Os resultados de cada simulação são apresentados em um painel que descreve cada passo processado. O número a ser calculado (ou fatorado) é inserido em uma caixa de texto, e a ao cl car sobre o botão Fatorar o cálculo é n c ado. Ao f nal é mostrado na tela o tempo decorrido e os resultados passo a passo. 6.2 O Ambiente de Processamento Ao utilizarmos softwares que realizam medições de tempo e performance, é fundamental descrevermos as características do ambiente em que as operações e simulações ocorreram. Os resultados obtidos por este simulador variam entre si sob o aspecto de uso de memória e recursos consumidos pela CPU. Porém são absolutamente dependentes do ambiente computacional no qual estão sendo executados. As características do hardware são pontos cruciais a serem considerados, pois interferem diretamente no software e seu desempenho, além do que variam de computador para computador. Neste trabalho utilizamos para testes uma máquina com as seguintes características: Processador: ntel Core 3 CPU M380 Velocidade de Processamento: 2,53GHz Memória instalada (RAM): 4GB (utilizável: 3,80GB) Sistema Operacional: Microsoft Windows 7 64 Bits Os resultados obtidos num ambiente de 64 bits são muito superiores, em desempenho, aos do ambiente de 32 bits, visto que a diferença é a capacidade de processamento que cada um deles suporta. O Windows 64 é capaz de gerenciar quantidades grandes de memória RAM de maneira mais eficiente do que o Windows 32. Os bits de um processador não se referem à sua velocidade, mas sim à quantidade de informação que ele leva em cada viagem, logo, é necessário mais memória RAM para potencializar essa capacidade. 15

6.3 Resultados Para tentar demonstrar os resultados obtidos nas simulações pelo aplicativo foram realizados testes aleatórios de valores, desde os mais simples aos mais complexos. Segue abaixo alguns exemplos, com as devidas observações acerca dos passos realizados pelos algoritmos. O objetivo aqui é demonstrar que o algoritmo de Fermat possui uma única linha de execução, variando seu tempo de resposta em função da quantidade de interações que o algoritmo faz em loop para encontrar o fator y. Os números de Fermat são todos os que têm a forma: n 2 2n 1 (8) Como os números de Fermat crescem muito rapidamente em função de n, torna-se muito laborioso testar a sua primalidade. Alguns exemplos curiosos destas variações serão explanados adiante. Já para o algoritmo de Shor, os resultados são muito variados. A cada processamento de um mesmo número podemos ter cálculos mais rápidos ou não, pois a escolha do número aleatório y pelo algoritmo é o que irá determinar a complexidade dos cálculos subsequentes. Para a determinação de r foi definido 60 como limite máximo de interações, para evitar que a exponenciação de grandes números gerando um travamento no computador, ou estourando memória, devido à capacidade de armazenamento das variáveis de programação. Verificamos que independentemente do y escolhido aleatoriamente o algoritmo Shor nem sempre encontra os mesmos resultados. E é justamente na probabilidade que este algoritmo trabalha, testando diferentes resultados conforme a gama de y possíveis até que o mais provável seja eleito. Esta foi uma das características mais marcantes observada na simulação do algoritmo de Shor. 6.3.1 Exemplo Comparativo 1 Iniciamos a demonstração com um número inteiro pequeno: 15 (não primo). Para fatorar utilizando o algoritmo de Fermat tivemos um resultado 16

quase instantâneo: em apenas 11 centésimos de segundo chegamos aos fatores 5 e 3. Ao fatorar utilizando o algoritmo de Shor temos um resultado semelhante, chegando aos fatores 5 e 3 nos mesmos 11 centésimos de segundo, observada a escolha do número 7 como o y aleatório (menor que 15), e respectivos r=4 e x=7. Abaixo figura 5 ilustra o resultado do simulador utilizando o número 15: Figura 5: Imagem do simulador utilizando o número 15 6.3.2 Exemplo Comparativo 2 Demonstração com um número inteiro pequeno: 56 Importante observar que no algoritmo Shor a escolha de y aleatoriamente afeta toda a sequência de cálculo, uma vez que o y pode ser recusado várias vezes, ou então o r pode não ser aceito dentro do limite proposto, forçando a reinício do processo. Neste caso é possível observar na figura 6 que sua primeira escolha de y foi 42, como este número não é um coprimo o simulador escolheu outro y=51. Isso fez com que o algoritmo levasse um tempo maior para execução, mas com o tempo de sete centésimos de segundos e executou a tarefa em um tempo menor que o algoritmo de Fermat. 17

Abaixo a figura 6 ilustra o resultado do simulador utilizando o número 56: Figura 6: Imagem do simulador utilizando o número 56 6.3.3 Exemplo Comparativo 3 Utilizando o número inteiro 134. Ao fatorar o número 134 utilizando o algoritmo de Fermat temos como resultado os fatores (x+y)=1.518.500.252 e (x-y)=0, onde x=759.250.126, o mesmo valor de Y. O tempo gasto no cálculo foi de 24,663 segundos. O que mais chamou a atenção foi o elevado número de iterações para determinar o y=759.250.714, o que significa que x foi incrementado mais de 759 milhões de vezes até que a x 2-134 fosse encontrada. O valor inicial 12 foi atribuído a x, sendo calculado 3 para o y inicial. Como a raiz quadrada de 12 menos o 134 resulta em 10 e 10 não tem raiz exata, deflagrou-se um processo de incremento de x até que o simulador obtivesse um valor com raiz exata em relação ao n (134). O objetivo era obter uma raiz exata de (x 2 -n). Ao iniciar com x=12, o primeiro cálculo do simulador do algoritmo de Fermat obteve: Para 12 2-134 = 3,162 18

Então o processo seguiu-se com incremento de X em 1 unidade, e assim por diante até que o resultado fosse uma raiz exata. Ao final do processo os valores de x e y foram os mesmos, de 759.250.126. Quando isto acontece temos como resultado do algoritmo de Fermat o valor de 0 (zero), pois: (x + y) (x - y) = (759.250.126+759.250.126) (759.250.126-759.250.126) = 0 Este resultado mostra que o algoritmo de Fermat não é eficiente para algumas fatorações, devido à natureza do processo, que, dependendo do valor a ser fatorado, pode incorrer em um loop que esgota o limite de cálculo de x e y. Outro ponto observado devido ao loop contínuo foi o consumo de recursos da CPU, que chegou a 27%, conforme a figura 7 abaixo: Figura 7: Consumo de CPU no exemplo 6.3.3 com o algoritmo de Fermat Agora vamos verificar a simulação do número 134 pelo algoritmo de Shor. O tempo gasto para realizar a fatoração foi de apenas 10 centésimos de segundo. O consumo de CPU foi insignificante para este tempo de execução. Os fatores obtidos como resultado foram 2 e 134. O processo iniciou-se com a escolha aleatória de y como sendo 123 coprimo de 134 e, portanto, aceito. Porém, ao tentar determinar o r, não houve 19

nenhum que atendesse o requisito de ser par, dentro do limite de 60 tentativas justificado no início do ítem 6.3. Consequentemente o simulador reiniciou o processo com a escolha de outro y aleatório, desta vez o número 133, devidamente aceito. Na sequência o r foi calculado como sendo 2 e o x igual a 133. Imediatamente foram calculados os fatores finais: x= m.d.c (x-1,n) e y= m.d.c (x+1,n). Substituindo os valores temos os fatores finais: x= m.d.c (132, 134) = 2, e y= m.d.c (134, 134) = 134. Os fatores finais encontrados pelo algoritmo de Shor neste exemplo não são valores corretos para o numero 134. O que foi possível verificar que quando o algoritmo de Shor não consegue encontrar os fatores de um número, ele dá como resposta dois números que multiplicados entre si dá o dobro do valor inicial e este tipo de resposta foi verificada com alguns números pares e não primos. Abaixo a figura 8 ilustra o resultado do simulador utilizando o número 134: Figura 8: Imagem do simulador utilizando o número 134, pela primeira vez. Apenas para demonstrar a enorme gama de possibilidades de cálculo do algoritmo de Shor, devido às escolhas aleatórias de y, observamos na figura 9 20

um cálculo ainda mais rápido, onde todas as etapas foram feitas uma única vez com sucesso, resultando em apenas 8 centésimos de segundo. Figura 9: imagem do simulador utilizando o número 134, pela segunda vez. 6.3.4 Exemplo Comparativo 4 Utilizando o número inteiro 523.176.328 Ao tentar fatorar o número 523.176.328 utilizando o algoritmo de Fermat temos como resultado os fatores (x + y)=130.794.082 e (x - y)= 4, onde x=65.397.043, e y=65.397.039. O tempo gasto no cálculo foi de 2,128 segundos. O incremento se repete por 65.374.169 vezes, resultando em valor para x de 65.397.043 O resultado final é dado pela equação (7). Substituindo os fatores encontrados temos: (65.397.043 + 65.397.039)(65.397.043-65.397.039) = 523.176.328. De fato chega-se ao número inicial a ser fatorado. A simulação do número 523.176.328 pelo algoritmo de Shor não foi possível de ser executada pelo aplicativo, devido aos seguintes motivos: 21

a) a regra inicial do algoritmo de Shor é escolher aleatoriamente um número y menor que n. No caso o sistema escolheu o número 506.315. b) Até o valor de r=54 todos os r calculados não foram aceitos, devido a não haver resultado igual a 1 na equação anterior. E ao tentar elevar o y à exponencial de 54, dá como resultado um número extremamente grande, que supera toda a capacidade de armazenamento em memória da variável no código, ou seja, ocorre um evento chamado estouro de memór a ( overflow ), o que encerra o apl cat vo. Portanto, devido ao y escolhido aleatoriamente ser muito grande para valores de n e, sobretudo, o cálculo de r realizar diversas sequências exponenciais crescentes, o valor tende a ser extremamente elevado e passa a não ser suportado pela estrutura clássica de um computador. Em consequência, o algoritmo de Shor para fatoração de grandes números torna-se de difícil execução em um computador clássico. Caso soubéssemos antecipadamente um número primo pequeno do n a fatorar poderíamos tentar forçar o código a tomar ele como y e daí seguir o processamento. Porém, isso não garante que com este y presumido os valores de r e x sejam obtidos com sucesso. A figura 10 mostra a imagem do simulador com os resultados. Figura 10: Imagem do simulador utilizando o número 523.176.328 22

Na figura 11 podemos observar o momento em que ocorre o erro de estouro de memória, paralisando o processamento: Figura 11: imagem da parada do simulador utilizando o número 523.176.328 pelo algoritmo de Shor. Observamos que o cálculo de r está tentando achar o resto da divisão de (506.315 55 523.176.328). A primeira parte da expressão resulta no erro apontado. 6.3.5 Exemplo Comparativo 5 Para este caso foram realizados várias simulação com valores diferentes, para se fazer um comparativo quanto ao tempo de execução dos algoritmos. Figura 12: Imagem da parada do simulador utilizando o número 1.200 23

Figura 13: Imagem da parada do simulador utilizando o número 67.893 Figura 14 : Imagem da parada do simulador utilizando o número 100.000 Analisando as figuras 12, 13 e 14 é possível verificar o que tempo de execução é diferente para todos os casos. E que o algoritmo de Fermat obteve um desempenho muito superior que o algoritmo se Shor, isso porque o algoritmo de Shor obteve escolhas não satisfatórias para os números 24

apresentados, mas se executarmos o programa várias vezes para o mesmo número, teremos outros resultados de fatores e também de tempo de execução devido a forma probabilística de escolha do y. As figuras 15, 16, 17 e 18 mostram as imagens do simulador com os resultados. Figura 15: Imagem da parada do simulador utilizando o número 1.200 Figura 16: Imagem da parada do simulador utilizando o número 1.200 25

Figura 17: Imagem da parada do simulador utilizando o número 1.200 Figura 18 - Imagem da parada do simulador utilizando o número 1.200 O algoritmo de Fermat obteve os mesmos resultados para todos os tempos execuções, 6 centésimos de segundos. Já o algoritmo de Shor se mostrou mais lento em três escolhas e mais eficiente em uma, isso fica evidente devido à escolha aleatória do y utilizado para a fatoração. 26

7. Conclusão O objetivo deste trabalho foi atingido com êxito. Nas simulações realizadas foi possível verificar uma falha existente no algoritmo de Fermat, que ocorre quando o valor de x encontrado é igual ao valor de y; Ao acontecer isto o algoritmo apresenta uma falha de fatoração. Outro aspecto observado para este algoritmo foi o excelente desempenho dele para fatoração de números pequenos, e também foi possível verificar que quanto maior o número a ser fatorado, maior é o seu tempo de execução. O algoritmo de Shor apresentou uma eficiência muito superior para encontrar os fatores de um número, a forma probabilista de se encontrar fatores ficou muito evidente nas várias execuções do simulador com o mesmo valor. Pelas simulações, verificamos que este algoritmo foi elaborado para ser executado em computadores quânticos, que possuem um desempenho nada comparado aos computadores clássicos; a sua total eficiência jamais poderá ser avaliada por máquinas tradicionais em se tratando de números muito grandes. Isto foi evidenciado no erro de estouro de memória apresentado na simulação, porque os computadores tradicionais não possuem memória suficiente para fatoração de grandes números. Agradecimentos A realização deste trabalho foi concretizada graças à participação de muitas pessoas em minha vida. Em especial àqueles que acreditaram no meu potencial. Agradeço ao meu orientador, Dr. Paulo Henrique Alves Guimarães, pela disponibilidade e orientações. Ao meu marido Rafael, que me auxiliou e ajudou nos conhecimentos de computação clássica. Aos meus professores da Universidade que me auxiliaram na evolução dos meus conhecimentos da física. E a Deus que me deu sabedoria e saúde para realizar este trabalho. 27

8 Bibliografia CARTER, Nicholas. Teoria e Problemas de Arquitetura de Computadores. Porto Alegre: Bookman, 2003. GUIMARÃES, Paulo Henrique Alves. Portas Lógicas Quânticas em Pares de Cadeias Acopladas de Poliacetileno, Universidade de Brasília Instituto de Física, Brasília, 2004. Tese (Doudorado em Física), Universidade Católica de Brasília LINS, Vagner Vieira. O Computador Quântico de Oscilador Harmônico, Universidade de Brasília Pró-Reitoria de Graduação Curso de Física Trabalho de Conclusão de Curso, Brasília-DF 2010. PREISS, Bruno R. Estrutura de Dados e Algoritmos. Rio de Janeiro: Rio de Janeiro, Editora Campus Ltda, 2001. NIELSEN, Michael. A; CHUANG, Isaac. L. Computação Quântica e Informação Quântica. Porto Alegre: Bookman, 2005. RODRIGUES, Wilton Alburquerque. O Computador Quântico óptico, Universidade de Brasília Pró-Reitoria de Graduação Curso de Física Trabalho de Conclusão de Curso, Brasília-DF 2011. NETO, Luiz Ferrz. O gato de Schrödinger, Disponível em: <www.feiradeciencias.com.br/sala23/23_ma14.asp> Acesso em: 05/10/2011. ROLIM, Eduardo. Algoritmo de Shor Explicado - Fatorando Grandes Números. Disponível em: <http://www.tocadoelfo.com.br/2009/12/algoritmo-de-shorexplicado-fatorando.html> Acesso em 10/12/2010. 28

Computador Quântico. Disponível em: <http://pt.wikipedia.org/wiki/computador_qu%c3%a2ntico> Acesso em 04/04/2011. 29

ANEXO 1 Código Fonte do Simulador Os processos de cálculos dos Algoritmos de Fermat e Shor desenvolvidos no Simulador utilizado neste trabalho foram feitos sob a forma de Classes (orientadas a objetos) da linguagem VB.NET, estando integralmente reproduzidos neste anexo. Os demais objetos dizem respeito apenas à formatação do Formulário único onde estão dispostos os botões e listas de resultados, não sendo de relevância para a inclusão neste anexo. 1A - CLASSE ALGORITMO DE FERMAT Public Shared Function fatoracao_fermat(byval num_n As Long) As Integer() Application.DoEvents() Dim variavel_x, variavel_y As Double Dim raiz_n, xy_fermat, x2 As Double Dim v_total As Double ' Mostra a informação dividida em Horas, Minutos, Segundo e Milisegundos. frmprincipal.lst1.items.clear() frmprincipal.lst1.items.add("calculando...") frmprincipal.lst1.refresh() 'calcular a parte inteira da raiz quadrada de n raiz_n = Math.Sqrt(num_n) variavel_x = Int(raiz_n) frmprincipal.lst1.items.add("parte inteira da raiz quadrada de " & Format(num_n, "##,##0") & " = " & Format(variavel_x, "##,##0")) frmprincipal.lst1.items.add(format(variavel_x, "##,##0") & " é o valor inicial de X") 'se variavel_x ao quadrado for menor que n, soma-se 1 If variavel_x * variavel_x < num_n Then frmprincipal.lst1.items.add("se o quadrado de X é " & Format(variavel_x * variavel_x, "##,##0") & " (menor que " & Format(num_n, "##,##0") & "), soma-se 1 ao X") variavel_x = variavel_x + 1 End If frmprincipal.lst1.items.add("") frmprincipal.lst1.items.add("novo VALOR INICIAL DE X: " & Format(variavel_x, "##,##0")) frmprincipal.lst1.items.add("")

'calcula a parte inteira da raiz quadrada do (quadrado da variavel_x - num_n) x2 = variavel_x * variavel_x 'quadrado da variavel_x frmprincipal.lst1.items.add("quadrado de X: " & variavel_x & "^2=" & x2) 'quadrado da variavel_x - num_n frmprincipal.lst1.items.add("quadrado de X menos N: " & x2 & " - " & Format(num_n, "##,##0") & " = " & x2 - num_n) 'raiz de X^2 - N v_total = Math.Sqrt(x2 - num_n) frmprincipal.lst1.items.add("raiz de: " & x2 - num_n & " = " & Format(v_total, "##.##,#0")) 'parte inteira de v_total (variavel_y) variavel_y = Int(v_total) frmprincipal.lst1.items.add("parte inteira deste resultado é: " & Format(variavel_y, "##,##0")) frmprincipal.lst1.items.add("") frmprincipal.lst1.items.add("valor INICIAL DE Y: " & Format(variavel_y, "##,##0")) frmprincipal.lst1.items.add("") If variavel_y <> v_total Then frmprincipal.lst1.items.add("procurar Y até que sua Raiz seja exata.") End If 'enquanto variavel_y for diferente de v_total, calcula v_total e atribui valor a variavel_y Dim cont As Integer cont = 0 Do While variavel_y <> v_total v_total = Math.Sqrt((variavel_x * variavel_x) - num_n) variavel_y = Int(v_total) If variavel_y <> v_total Then variavel_x = variavel_x + 1 cont = cont + 1 Loop 'quando o v_total for igual a variavel_y, encontrou o Y final frmprincipal.lst1.items.add("quantidade de interações (loop) para determinar o Y: " & Format(cont - 1, "##,##0")) 'calcula o x e y de Fermat xy_fermat = (variavel_x + variavel_y) * (variavel_x - variavel_y) frmprincipal.lst1.items.add("")

frmprincipal.lst1.items.add("x e Y encontrados: " & Format(variavel_x, "##,##0") & " e " & Format(variavel_y, "##,##0")) frmprincipal.lst1.items.add(" ") frmprincipal.lst1.items.add("fatores:") frmprincipal.lst1.items.add("x + Y : " & Format(Int(variavel_x) + variavel_y, "##,##0")) frmprincipal.lst1.items.add("x - Y : " & Format(Int(variavel_x) - variavel_y, "##,##0")) frmprincipal.lst1.items.add(" ") frmprincipal.lst1.items.add("cálculo do X e Y de Fermat: (X + Y) * (X- Y)") frmprincipal.lst1.items.add("(" & Format(variavel_x, "##,##0") & "+" & Format(variavel_y, "##,##0") & ") * (" & Format(variavel_x, "##,##0") & "-" & Format(variavel_y, "##,##0") & ") = " & Format(Int(xy_fermat), "##,##0")) Application.DoEvents() frmprincipal.crono1.stop() End Function 1B - CLASSE ALGORITMO DE SHOR Public Shared Function fatoracao_shor(byval num_n As Decimal) As Integer() Dim Y_aleatorio, Y_aleatorio_ant, R_corresp_Y, X_corresp_Y As Decimal Dim resto As Decimal Dim fator1, fator2 As Decimal Dim primo As Decimal Dim rnd As New Random() Dim Caminho As String Application.DoEvents() frmprincipal.lst2.items.clear() frmprincipal.lst2.items.add("calculando...") frmprincipal.lst2.refresh() Caminho = Application.ExecutablePath If frmprincipal.chkarquivo.checked Then FileOpen(1, "shor_fat_" & num_n & ".txt", OpenMode.Output, OpenAccess.Write) 'Print(1, "texto") FileClose(1) 'PASSO 1: ACHAR OS Y QUE SÃO COPRIMOS DO ESCOLHIDO E SEUS MENORES (QUANDO SO EXISTE O 1 COMUM ENTRE OS DIVISORES DELES). 'EX: SE n=15: Y=2,4,7,8,11,13,14 'Chamamos de números primos entre si (ou coprimos), um conjunto de números onde o único divisor comum a todos eles for o número 1. 'Ex: Divisores de 20: 1, 2, 4, 5, 10 e 20. Divisores de 21: 1, 3, 7 e 21. O 1 é o único comum; então, 20 e 21 são coprimos.

'Não é necessário escolher todos os coprimos. Escolhe um y aleatorio entre 2 e N e verifica se é coprimo. Selec_Y: 'a) Escolha aleatória de um número entre 2 e N: (escolha de Y) Y_aleatorio = rnd.next(2, num_n - 1) If Y_aleatorio = Y_aleatorio_ant Then GoTo Selec_Y If Y_aleatorio > 1000000 Then GoTo Selec_Y frmprincipal.lst2.items.add("") frmprincipal.lst2.items.add("etapa 1 - determinar o Y") frmprincipal.lst2.items.add("número menor que " & num_n & " escolhido (aleatório): " & Y_aleatorio) 'b) Verificar se é int_aleatorio é coprimo de N primo = mdc_primos(num_n, Y_aleatorio) If primo = 1 Then frmprincipal.lst2.items.add(num_n & " e " & Y_aleatorio & " são coprimos? SIM") Else frmprincipal.lst2.items.add(num_n & " e " & Y_aleatorio & " são coprimos? NÃO - selecionar outro...") Y_aleatorio_ant = Y_aleatorio GoTo Selec_Y End If 'PASSO 2: ACHAR O R CORRESPONDENTE AO Y 'EX: para n=15: Y=2,4,7,8,11,13,14 e R=4,2,4,4,2,4,2. --- Temos um R para cada Y 'Pegar cada Y e elevar de 1 a 60(limite aleatório). Cada resultado dessa potência, fazer o MOD com o N. Ex: Y=2 elevar 2^1 e fazer 2^1 MOD N. 'Se der Resto 1, achou o R, ou seja, o R é a primeira vez que aparece resto 1 da divisão de Y^R (R de 1 a 10) por N. E R é o próprio período da sequência. 'Quando achar o y^r=1 mod n então encontrou o um posivel r, se for par segue; se for impar retorna a escolha de outro Y. 'Elevar Y iniciando com 1, calculando Y^r MOD N até achar Resto 1. R_corresp_Y = 0 For a = 1 To frmprincipal.limiter resto = Y_aleatorio ^ a Mod num_n

If resto = 1 Then 'Achou um R (=a) com resto 1 frmprincipal.lst2.items.add("") frmprincipal.lst2.items.add("etapa 2 - determinar o R") frmprincipal.lst2.items.add("testando R= " & a & " para a equação: " & Y_aleatorio & "^" & a & " MOD " & num_n & " = OK") If (a Mod 2 = 0) Then 'verifica se R é par frmprincipal.lst2.items.add("r é par? SIM") R_corresp_Y = a Exit For Else frmprincipal.lst2.items.add("r é par? NÃO... reiniciar o processo com escolha de outro Y aleatório") GoTo Selec_Y End If End If Next If R_corresp_Y = 0 Then frmprincipal.lst2.items.add("") frmprincipal.lst2.items.add("não foi encontrado o R correspondente que atenda a equação: " & Y_aleatorio & "^r MOD " & num_n) frmprincipal.lst2.items.add("o processo será reiniciado com escolha de outro Y aleatório") GoTo Selec_Y End If 'PASSO 3: ACHAR O X CORRESPONDENTE AO Y 'A PARTIR DOS Y, ACHA OS X: x=y^r/2, no exemplo acima ficaria: x={2^2=4,4^1=4,7^2=49,8^2=64,11^1=11,13^2=169,14^1=14} 'SE X^2= 1 MOD N SE FOR MOD 1 CONTINUA, SE NÃO VOLTO PARA O INICIO. 'PARA QUALQUER Y O X CORRESPONDENTE TEM OS MESMOS FATORES DIVISORES DO N. X_corresp_Y = Y_aleatorio ^ (R_corresp_Y / 2) frmprincipal.lst2.items.add("") frmprincipal.lst2.items.add("etapa 1 - determinar o X") frmprincipal.lst2.items.add("cálculo do X correspondente ao Y: " & Y_aleatorio & "^ (" & R_corresp_Y & "/2) = " & X_corresp_Y) resto = X_corresp_Y ^ 2 Mod num_n If resto = 1 Then 'X é válido frmprincipal.lst2.items.add("validação do X pela equação: " & X_corresp_Y & "^2 MOD " & num_n & " = OK") Else

frmprincipal.lst2.items.add("validação do X pela equação: " & X_corresp_Y & "^2 MOD " & num_n & " = INVÁLIDO...reiniciar o processo com escolha de outro Y aleatório") GoTo Selec_Y End If 'PASSO 4: PEGA o encontrado X E ACHA OS FATORES, USANDO X+1 e X-1 (todos os X devem dar os mesmos fatores) 'Para qualquer Y, pega o X correspondente e faz ele +1 e -1, e cada resultado faz o MOD com o 15: ASSIM achamos os 2 fatores de 15 'EX: Para y=7 (pega x+1=50 e x-1=48) então: n1 = M.D.C.(48,15)=3 e n2 = M.D.C.(50,15)=5; 'OBS: SE ENCONTRAR A SOLUÇÃO TRIVIAL RETORNA AO INICIO. Trivial significa os fatores ser 1 e o proprio N frmprincipal.lst2.items.add("") frmprincipal.lst2.items.add("etapa 4 (final) - determinar os Fatores de " & num_n) frmprincipal.lst2.items.add("") fator1 = mdc(x_corresp_y - 1, num_n) frmprincipal.lst2.items.add("fator 1 calculado por M.D.C(X-1," & num_n & "): MDC(" & X_corresp_Y - 1 & "," & num_n & ") = " & fator1) fator2 = mdc(x_corresp_y + 1, num_n) frmprincipal.lst2.items.add("fator 2 calculado por M.D.C(X+1," & num_n & "): MDC(" & X_corresp_Y + 1 & "," & num_n & ") = " & fator2) If (fator1 = 1 And fator2 = num_n) Or (fator1 = num_n And fator2 = 1) Then frmprincipal.lst2.items.add("solução TRIVIAL...reiniciar o processo com escolha de outro Y aleatório") Else frmprincipal.lst2.items.add("") frmprincipal.lst2.items.add("resumo GERAL:") frmprincipal.lst2.items.add("fatores de " & num_n & " calculados pelo Algoritmo de SHOR: " & fator1 & " e " & fator2) End If Application.DoEvents() frmprincipal.crono2.stop() End Function