You are on page 1of 36

Pr-Reitoria de Graduao

Curso de Fsica
Trabalho de Concluso de Curso

COMPUTAO QUNTICA:

COMPARATIVO DOS ALGORITMOS DE SHOR E DE FERMAT

Autora: Silviane Silva


Orientador: Dr. Paulo Henrique Alves Guimares

Braslia - DF
2011

COMPUTAO QUNTICA: COMPARATIVO DOS


ALGORITMOS DE SHOR E DE FERMAT
(Quantum Computation: Comparison between Shor's and Fermats algorithms)

Silviane Silva 1, Dr. Paulo Henrique A. Guimares2


1

Curso de Fsica - Universidade Catlica de Braslia


2
Departamento de Fsica Universidade de Braslia

Tanto um computador clssico quanto um computador quntico fazem


uso de algoritmos para realizao de suas operaes. Este trabalho se prope
a apresentar de forma simplificada uma breve introduo computao
quntica, compar-la com a computao clssica e mostrar o desempenho do
algoritmo de Shor em um software desenvolvido para este trabalho, para o
clculo dos fatores coprimos de um nmero, em relao ao algoritmo de
Fermat utilizado na computao clssica, demonstrando os resultados
encontrados.
Palavras-chave: Computao quntica, algoritmo de Shor, algoritmo
de Fermat, computao clssica.

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 Shors 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, Shors algorithm, Fermat,
classical computing.

1.

Introduo
A computao quntica atrai o interesse de muitas empresas que

trabalham utilizando processamento de dados (NIELSEN, CHUANG, 2005,


com adaptaes). Ainda no concretizada, mais j avanada em muitas
pesquisas, a computao quntica possui uma estrutura muito parecida com a

computao clssica, mas com a forma de recebimentos e processamento de


dados muito diferente daquela. Por esse motivo est despertando muitas
especulaes na rea de informtica, especialmente nos assuntos de
transmisso de informaes que utilizam processos criptogrficos. Um
algoritmo cujo estudo j demonstra avanos nesta rea o desenvolvido por
Peter Shor, que vem mostrando uma eficincia superior a todos os algoritmos
j utilizados na computao clssica (NIELSEN, CHUANG, 2005, com
adaptaes).
O primeiro assunto deste trabalho ser sobre o incio e evoluo da
computao quntica, seguido de um breve comparativo desta com a
computao clssica. Mais adiante ser demonstrada a importncia do
algoritmo na rea computacional e porque a criptografia tem um papel
fundamental na transmisso de informaes. Na apresentao dos algoritmos
de Fermat e de Shor sero comentadas suas falhas e utilizaes. Por fim, ser
demonstrado o desempenho desses algoritmos em uma mquina clssica,
utilizando um cdigo desenvolvido em um programa de plataforma alta, onde
podero ser observadas as diferenas de processamento.

2.

Inicio da Computao quntica


Imaginar o nosso mundo atualmente sem a tecnologia computacional

seria como regredirmos no tempo. Geralmente resumimos a histria da


computao com o surgimento da primeira mquina de Turing, quando na
verdade a histria da computao iniciou com a evoluo do homem nas
diversas reas da fsica e da matemtica (NIELSEN, CHUANG, 2005, com
adaptaes).
A computao quntica o resultado mais atual da evoluo
computacional. Em meados dos anos 80 Richard Feynman elaborou uma
proposta

de

utilizar

um

fenmeno

quntico

para

executar

rotinas

computacionais. Ele explica que um computador tradicional levaria um tempo


extremamente longo para simular um simples experimento de fsica quntica.
Foi baseada nesta ideia e utilizando as propriedades da mecnica quntica,
que a computao quntica comeou a evoluir. Atualmente j possvel

explicar como funciona um computador quntico. Grandes empresas como IBM


Intel j possuem estudos avanados nesta rea (NIELSEN, CHUANG, 2005,
com adaptaes).
O computador quntico possui uma estrutura muito parecida com um
computador normal, ambos possuem memrias, processador, portas de
entradas e sada de dados, e perifricos. O diferencial de um computador
quntico a forma como ele processa as informaes e como estas so lidas.
As propriedades da mecnica quntica dizem que possvel que uma partcula
esteja em dois ou mais estados ao mesmo tempo, e isso lembra muito a
famosa metfora do Gato de Schrdinger 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 tambm ultilizada para as particulas na mecnica
quntica e superposio das partculas (NETO, Acesso em:
05/10/2011, com adaptaes).
Para entendermos melhor o processamento dessas informaes necessrio
fazer um comparativo da computao clssica com a quntica.

3.

Computao Quntica x Clssica


Um computador quntico possui a mesma arquitetura dos computadores

clssicos, organizada da seguinte forma:

Arquitetura do Computador

Processad
or

Comutador

Barramento de
Memoria

Bloco de
Memria

Barramento de Entrada/sada

Sistema de Entrada/sada

Disco
Rgido

CD - ROM

Placa de
Vdeo

Monitor

Figura 1: Organizao bsica de computadores (CARTER, 2001).

Dentro

da

arquitetura

computacional

podemos

verificar

que

processador est na parte superior da arquitetura, isso porque o processador


o elemento responsvel pela traduo das informaes de entrada para o
computador e pela execuo dos programas que so sequncias de instrues
que dizem o que deve ser feito. O computador comunica-se com o bloco de
memria atravs do barramento de memria que transfere e/ou recebe dados
para o processador e barramentos de entradas e sadas, que seriam os
dispositivos. Da mesma forma os dispositivos enviam dados atravs do
barramento que os transfere para o comutador, o qual enviar dados para o
bloco de memria ou para o processador (CARTER, 2001).
Na computao clssica a entrada de dados realizada da seguinte
forma:

Quando o computador ligado ele recebe sinais eltricos analgicos


(eltrons); dependendo do nvel de tenso do sinal os sistemas digitais do
computador conseguem traduzi-lo para uma tenso baixa, cujo valor ser
representado por 0 (bit), ou para uma tenso alta, cujo valor ser representado
por 1 (bit). Sistemas que mapeiam sinais eltricos so conhecidos por
reconhecerem alteraes de tenses, e so chamados de sistemas binrios,
onde a tenso que cada sinal carrega chamada de BIT (forma abreviada para
Binary digit Dgito binrio) (CARTER, 2001).
A computao quntica consiste basicamente no processamento de
dados de partculas subatmicas e seus estados que podem ser representados
pelos q-bits, que seriam bits qunticos traduzidos em vetores. Com esses
vetores podemos formar combinaes lineares de estados, chamadas de
superposies conforme a equao 1 abaixo:

0 1

(1)

Onde e so nmeros complexos e pode armazenar inmeras informaes


de uma s vez.
Um bit clssico como uma moeda, pode ter 2 estados: cara ou coroa.
Em moedas defeituosas podem existir estados intermedirios, como se ela se
equilibrasse sobre a borda, mas tais situaes podem ser descartadas no caso
ideal. Em contraste, na computao quntica um q-bit pode existir em um
estado contnuo entre 0 e 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
quntico est representado abaixo:
1
2

1
2

(2)

1
, pode-se
Calculando a probabilidade de encontrar os estados,
2

verificar que dar 50% para 0 e 50% para 1.

Um q-bit pode ser encontrado em diferentes estados fsicos como: duas


polarizaes diferentes, polarizaes de um fton; alinhamento de um spin
nuclear em um campo magntico uniforme; ou dois estados de um eltron
orbitando ao redor do tomo;

Figura 2: Dois nveis eletrnicos em um modelo tomo de Bohr representando um qbit.

Podemos reescrever a superposio de estados da seguinte forma


(NIELSEN, CHUANG, 2005):
|

| )

(3)

em que ,
e so nmeros reais. O termo e no geometricamente
observvel, logo podemos escrever a Equao 3 da seguinte forma (NIELSEN,
CHUANG, 2005):
|

| )

(4)

O argumento e nmero presentes na Equao 4 definem um ponto


sobre a superfcie de uma esfera de raio unitrio chamada de esfera de Block
ilustrada na Figura 2 (NIELSEN, CHUANG, 2005).

Figura 3: Representao de um q-bit na esfera de Block. Fonte: Enciclopdia livre Wikipdia.

A esfera de Block um timo modelo para demonstrao de um q-bit,


mas para mais q-bits este modelo j no pode ser utilizado.
3.1.

Circuitos Computacionais
Fazer uma anlise dos circuitos computacionais interessante para

entender a criao das chaves utilizadas na criptografia.


Um computador clssico constitudo de circuitos eltricos contendo fios
e portas lgicas. Um computador quntico constitudo a partir de um circuito
quntico onde se encontram portas lgicas qunticas que manipulam a
informao quntica e fios que transportam a informao (NIELSEN, CHUANG,
2005).
Na computao clssica podemos tomar como exemplo um computador
com trs bits de memria, onde cada bit pode apenas armazenar dois estados
lgicos (um ou zero); isso significa que os trs bits podem representar oito
estados lgicos (000, 001, 010, 011, 100, 101, 110, 111).
Um computador quntico pode atualmente armazenar dezesseis valores
analgicos em pares para formar oito nmeros complexos conforme mostrado
na tabela 1.

Tabela 1: Devido a superposio um computador quntico pode assumir 8


estados simultaneamente para um conjunto de 3 q-bits.
Amplitude
Probabilidade
Estado
*
(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: Enciclopdia livre - Wikipdia
Na primeira coluna da Tabela 1 esto todos os estados possveis para
os trs bits.
No computador clssico ser suportado apenas um estado de cada vez,
mas no computador quntico, devido a superposio, ele pode assumir os oitos
estados simultaneamente. A segunda coluna mostra a "amplitude" para cada
um dos oito estados. Os oito nmeros complexos so uma imagem dos
contedos de um computador quntico num determinado momento. No
processamento estes oito nmeros iro modificar e interagir uns com os outros.
Com isso j se pode concluir que um computador quntico de trs q-bits tem
muito mais memria do que um computador clssico de trs 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 adaptaes).

4.

Criptografia
A criptografia est ligada diretamente com os algoritmos, que seriam as

instrues para executar vrias tarefas, conforme explicaes no item 5. Para


este trabalho a criptografa no ser utilizada, pois no a necessidade de se
ocultar as informaes, mas a explicao deste item necessrio pois os
algoritmos de Shor e Fermat fazem uso da criptografia em rotinhas que
necessitam ocultar informaes de entrada e sada e informaes.

Com o surgimento da internet e com a evoluo da rea computacional


a criptogrfica vem evoluindo com o passar dos anos. Existem vrias formas de
se ocultar uma informao, pode-se ocultar informaes de formas simples ou
mais elaboradas, um exemplo seria a RSA. A sigla RSA originada das iniciais
dos nomes de trs professores do Instituto de Tecnologia de Massachusetts,
seus nomes so Ronald Rivest, Adi Shamir e Leonard Adleman. RSA um
algoritmo de criptografia de dados que cria Chave Privada e Chave Pblica.
Uma chave uma informao codificada atravs de um algoritmo e que
ser decodificada, tambm atravs de um algoritmo.
A Chave Privada uma informao pessoal que permanece em posse
da pessoa - no publicvel, j a Chave Pblica uma informao associada a
uma pessoa que distribuda a todos.
Um exemplo muito conhecido a transmisso de mensagens entre Alice
e Bob que utilizao da chave RSA.
Alice e Bob precisam trocar mensagens seguras sem
interceptao. O algoritmo RSA permite essa troca segura de
mensagens pela utilizao de chaves pblicas e privadas:
Alice cria seu par de chaves (uma pblica e outra privada)
e envia sua chave pblica para todos, inclusive Bob;
Bob escreve sua mensagem para Alice. Aps escrita, Bob
faz a cifragem do texto final com a chave pblica 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 pblica
Se aplicarmos a chave pblica de Alice sobre o texto
critografado no teremos a mensagem original de Bob, mesmo
que a mensagem seja interceptada impossvel decifr-la sem a
chave privada de Alice (NIELSEN, CHUANG, 2005 com
adaptaes).

5.

Algoritmos e as principais aplicaes


Quando pensamos na palavra algoritmo fica difcil 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 ento porque
no utilizamos a palavra algoritmo em nosso dia a dia?
O algoritmo muito conhecido na rea da computao, porque tudo
comeou no no inicio de sculo XX com um desafio proposto pelo matemtico
David Hilbert, questionando a existncia de algum algoritmo que resolvesse
todos os problemas matemticos. Se esse algoritmo existisse seria a soluo
para muitos problemas no s da matemtica, mas principalmente da
computao. Nesta rea j existiam grandes pioneiros que introduziram a
teoria de algoritmos, como Afonzo Church e Alan Turing. devido a eles que
os algoritmos so muito conhecidos na rea computacional (NIELSEN,
CHUANG, 2005).
muito difcil fazer um computador ou qualquer aparelho eletrnico
funcional sem a execuo de um algoritmo, pois os circuitos eletrnicos
funcionam com execuo de um conjunto de tarefas (NIELSEN, CHUANG,
2005).
A computao convencional e a computao quntica fazem uso de
vrios 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 matemtico e cientista Pierre de Fermat (Frana, 1601-1665) e no


possua registros de sua demonstrao. Este teorema se originou a partir de
um estudo sobre o famoso Teorema de Pitgoras, 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 nmeros inteiros. Dado um nmero n ser pesquisado dois nmeros
inteiros que satisfaam a expresso:
n

x2 - y2

(6)

Sendo:
n (x - y)( x

y)

(7)

Onde x e y sero os fatores encontrados pelo algoritmo que pode ser


escrito da seguinte forma:
Dado um nmero n qualquer.
Calcula-se a parte inteira da raiz de quadrada de n x.
Elevando x2

, se R<n ento soma-se 1 a x.

Calcula-se x2 -n y , retira-se a parte inteira de y que ficar y nte ro .


Se o y <> y nte ro acrescntasse 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 ento x

Calcula-se 82 -56 = 2.828427125, parte inteira 2.


2.828427125 <> 2 ento acrescentasse + 1 para x que assume o valor
de x=9
Calcula-se 92 -56 = 5, parte inteira 5. Como o resultado da raiz igual
a parte inteira, temos: x=9 e y=5
Substituindo os valores na equao (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

matemtica aplicada no Instituto de Tecnologia de Massachusetts (MIT),


famoso por seu trabalho em computao quntica.
Este algoritmo tem como principal caracterstica fatorao de nmeros
muito grandes em computadores qunticos; por trabalhar com funes
probabilsticas, ele mostra-se muito eficiente comparado a todos os algoritmos
da computao clssica para fatorao de nmeros. Um computador quntico
pode executar este algoritmo com muita eficincia, por isso que se consegue
adquirir resultados extraordinrios com este algoritmo.
Existem preocupaes quanto a execuo deste algoritmo processado
em mquinas qunticas, devido a sua velocidade de execuo ele poderia, em
teoria, quebrar muitos dos sistemas criptogrficos em uso atualmente.
O algoritmo de Shor pode ser implementado em computadores
clssicos, mas no ter em nenhum momento um desempenho comparado a
um computador quntico.
Podemos explicar este algoritmo resumindo em quatro passos:
Dado um nmero N, escolhe-se de forma aleatria
y<N tal que y e N sejam nmeros coprimos (primos entre
si), ou seja M.D.C.(y,N)=1.
Em seguida procura-se o nmero r que satisfaa a
equao yr=1 mod N.
Sendo r um nmero mpar volta-se ao passo inicial e
escolhe-se aleatoriamente outro y.
Sendo r um nmero par ento x=yr/2 candidato a
soluo no trivial da equao x2=1 mod N. (a soluo no
tr v al ocorre quando x

a 1). Sendo x uma soluo

trivial volta-se ao passo inicial e escolhe-se aleatoriamente


outro y.
Atendidas as condies acima os candidatos soluo
consistem em encontrar:
n1 = M.D.C.(x-1,N) e n2 = M.D.C.(x+1,N)

12

algoritmo

de

Shor

sendo

um

algoritmo

probabilstico pode no se obter o resultado para a primeira


escolha de y, mas sendo o nmero de possveis y grande,
haver certamente uma convergncia para a soluo em
um tempo polinomial (RODRIGUES, 2004).
Partindo da citao acima, utilizaremos o nmero 56 como exemplo:
Escolhendo um y aleatoriamente:
y=51
Determinando o r:
51r 1 mod 56 tal que r=6
Verifico se r par, caso contrario volto para o incio do algoritmo.
Determinando o x:
6

x 512 =132.651
Verificando se x vlido: 132.651

1 mod 56, caso contrario volto para

o incio 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

Comparativo dos algoritmos de Fermat e Shor


O desempenho dos algoritmos de Fermat e Shor em um computador

clssico foi demonstrado, neste trabalho, atravs de um cdigo de


programao orientado a objeto com o objetivo de apresentar de forma simples
e comparativa alguns resultados.
Foram observados pontos chaves para analisar as diferenas, como o
tempo gasto no processamento e os nveis de utilizao de memria e CPU da
mquina.
Conforme demonstrado no tem 5, as caractersticas e finalidades dos
algoritmos de Fermat e de Shor so diferentes, sobretudo o objetivo a que se
propem. Lembramos, por exemplo, que aplicando o algoritmo de Fermat fica
fcil descobrir seus fatores desde que a diferena entre eles seja pequena. J

13

para o algoritmo de SHOR observamos uma melhor performance para a


fatorao de grandes nmeros.
6.1

O Simulador
Para a construo do simulador dos algoritmos foi utilizada a linguagem

de programao Visual Basic .NET da Microsoft . A tecnologia Microsoft .NET


uma iniciativa da Microsoft que visa ter uma plataforma nica para
desenvolvimento e execuo de sistemas e aplicaes. Todo e qualquer cdigo
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 sees, uma
para demonstrar o clculo com algoritmo Fermat e outra para algoritmo Shor.
Para a medida do tempo gasto no processamento foram inseridos contadores
visuais instantneos.
Importante destacar que a linguagem utilizada orientada a objetos, o
que significa que o software construdo com objetos que tm um
comportamento especifico e interagem entre si, ou seja, baseia-se no conceito
de que o sistema deve ser construdo a partir de componentes reutilizveis. A
execuo realizada por rotinas, uma de cada vez. Portanto, existem dois
botes 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 simulao so apresentados em um painel que


descreve cada passo processado.
O nmero a ser calculado (ou fatorado) inserido em uma caixa de
texto, e a ao cl car sobre o boto Fatorar o clculo 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

medies de

tempo

performance, fundamental descrevermos as caractersticas do ambiente em


que as operaes e simulaes ocorreram.
Os resultados obtidos por este simulador variam entre si sob o aspecto
de uso de memria e recursos consumidos pela CPU. Porm so
absolutamente dependentes do ambiente computacional no qual esto sendo
executados.
As

caractersticas

do

hardware

so

pontos

cruciais

serem

considerados, pois interferem diretamente no software e seu desempenho,


alm do que variam de computador para computador.
Neste trabalho utilizamos para testes uma mquina com as seguintes
caractersticas:
Processador: ntel Core 3 CPU M380
Velocidade de Processamento: 2,53GHz
Memria instalada (RAM): 4GB (utilizvel: 3,80GB)
Sistema Operacional: Microsoft Windows 7 64 Bits
Os resultados obtidos num ambiente de 64 bits so muito superiores, em
desempenho, aos do ambiente de 32 bits, visto que a diferena a capacidade
de processamento que cada um deles suporta. O Windows 64 capaz de
gerenciar quantidades grandes de memria RAM de maneira mais eficiente do
que o Windows 32. Os bits de um processador no se referem sua
velocidade, mas sim quantidade de informao que ele leva em cada viagem,
logo, necessrio mais memria RAM para potencializar essa capacidade.

15

6.3

Resultados
Para tentar demonstrar os resultados obtidos nas simulaes pelo

aplicativo foram realizados testes aleatrios de valores, desde os mais simples


aos mais complexos.
Segue abaixo alguns exemplos, com as devidas observaes acerca
dos passos realizados pelos algoritmos.
O objetivo aqui demonstrar que o algoritmo de Fermat possui uma
nica linha de execuo, variando seu tempo de resposta em funo da
quantidade de interaes que o algoritmo faz em loop para encontrar o fator y.
Os nmeros de Fermat so todos os que tm a forma:
n

n 22 1

(8)

Como os nmeros de Fermat crescem muito rapidamente em funo de


n, torna-se muito laborioso testar a sua primalidade. Alguns exemplos curiosos
destas variaes sero explanados adiante.
J para o algoritmo de Shor, os resultados so muito variados. A cada
processamento de um mesmo nmero podemos ter clculos mais rpidos ou
no, pois a escolha do nmero aleatrio y pelo algoritmo o que ir determinar
a complexidade dos clculos subsequentes.
Para a determinao de r foi definido 60 como limite mximo de
interaes, para evitar que a exponenciao de grandes nmeros gerando um
travamento no computador, ou estourando memria, devido capacidade de
armazenamento das variveis de programao.
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 possveis at que o mais provvel seja eleito. Esta foi
uma das caractersticas mais marcantes observada na simulao do algoritmo
de Shor.

6.3.1 Exemplo Comparativo 1


Iniciamos a demonstrao com um nmero inteiro pequeno: 15 (no
primo). Para fatorar utilizando o algoritmo de Fermat tivemos um resultado

16

quase instantneo: em apenas 11 centsimos 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 centsimos de
segundo, observada a escolha do nmero 7 como o y aleatrio (menor que 15),
e respectivos r=4 e x=7.
Abaixo figura 5 ilustra o resultado do simulador utilizando o nmero 15:

Figura 5: Imagem do simulador utilizando o nmero 15

6.3.2 Exemplo Comparativo 2


Demonstrao com um nmero inteiro pequeno: 56
Importante

observar

que

no

algoritmo

Shor

escolha

de

aleatoriamente afeta toda a sequncia de clculo, uma vez que o y pode ser
recusado vrias vezes, ou ento o r pode no ser aceito dentro do limite
proposto, forando a reincio do processo.
Neste caso possvel observar na figura 6 que sua primeira escolha de
y foi 42, como este nmero no um coprimo o simulador escolheu outro y=51.
Isso fez com que o algoritmo levasse um tempo maior para execuo, mas com
o tempo de sete centsimos 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 nmero 56:

Figura 6: Imagem do simulador utilizando o nmero 56

6.3.3 Exemplo Comparativo 3


Utilizando o nmero inteiro 134.
Ao fatorar o nmero 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 clculo foi de 24,663 segundos. O que mais chamou a
ateno foi o elevado nmero de iteraes para determinar o y=759.250.714, o
que significa que x foi incrementado mais de 759 milhes de vezes at que a
x2 -134 fosse encontrada.
O valor inicial 12 foi atribudo a x, sendo calculado 3 para o y inicial.
Como a raiz quadrada de 12 menos o 134 resulta em 10 e 10 no tem raiz
exata, deflagrou-se um processo de incremento de x at que o simulador
obtivesse um valor com raiz exata em relao ao n (134). O objetivo era obter
uma raiz exata de (x2 -n).
Ao iniciar com x=12, o primeiro clculo do simulador do algoritmo de Fermat
obteve:
Para 122 -134 = 3,162

18

Ento 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 no eficiente para
algumas fatoraes, devido natureza do processo, que, dependendo do valor
a ser fatorado, pode incorrer em um loop que esgota o limite de clculo de x e
y. Outro ponto observado devido ao loop contnuo 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 simulao do nmero 134 pelo algoritmo de


Shor.
O tempo gasto para realizar a fatorao foi de apenas 10 centsimos de
segundo. O consumo de CPU foi insignificante para este tempo de execuo.
Os fatores obtidos como resultado foram 2 e 134.
O processo iniciou-se com a escolha aleatria de y como sendo 123
coprimo de 134 e, portanto, aceito. Porm, ao tentar determinar o r, no houve

19

nenhum que atendesse o requisito de ser par, dentro do limite de 60 tentativas


justificado no incio do tem 6.3. Consequentemente o simulador reiniciou o
processo com a escolha de outro y aleatrio, desta vez o nmero 133,
devidamente aceito.
Na sequncia 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 no
so valores corretos para o numero 134. O que foi possvel verificar que
quando o algoritmo de Shor no consegue encontrar os fatores de um nmero,
ele d como resposta dois nmeros que multiplicados entre si d o dobro do
valor inicial e este tipo de resposta foi verificada com alguns nmeros pares e
no primos.
Abaixo a figura 8 ilustra o resultado do simulador utilizando o nmero
134:

Figura 8: Imagem do simulador utilizando o nmero 134, pela primeira vez.

Apenas para demonstrar a enorme gama de possibilidades de clculo do


algoritmo de Shor, devido s escolhas aleatrias de y, observamos na figura 9

20

um clculo ainda mais rpido, onde todas as etapas foram feitas uma nica vez
com sucesso, resultando em apenas 8 centsimos de segundo.

Figura 9: imagem do simulador utilizando o nmero 134, pela segunda vez.

6.3.4 Exemplo Comparativo 4


Utilizando o nmero inteiro 523.176.328
Ao tentar fatorar o nmero 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 clculo 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 equao (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 nmero inicial a ser fatorado.
A simulao do nmero 523.176.328 pelo algoritmo de Shor no foi
possvel de ser executada pelo aplicativo, devido aos seguintes motivos:

21

a) a regra inicial do algoritmo de Shor escolher aleatoriamente um


nmero y menor que n. No caso o sistema escolheu o nmero 506.315.
b) At o valor de r=54 todos os r calculados no foram aceitos, devido a
no haver resultado igual a 1 na equao anterior. E ao tentar elevar o y
exponencial de 54, d como resultado um nmero extremamente
grande, que supera toda a capacidade de armazenamento em memria
da varivel no cdigo, ou seja, ocorre um evento chamado estouro de
memr 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 clculo de r realizar diversas sequncias
exponenciais crescentes, o valor tende a ser extremamente elevado e passa a
no ser suportado pela estrutura clssica de um computador.
Em consequncia, o algoritmo de Shor para fatorao de grandes
nmeros torna-se de difcil execuo em um computador clssico. Caso
soubssemos antecipadamente um nmero primo pequeno do n a fatorar
poderamos tentar forar o cdigo a tomar ele como y e da seguir o
processamento. Porm, isso no 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 nmero 523.176.328

22

Na figura 11 podemos observar o momento em que ocorre o erro de


estouro de memria, paralisando o processamento:

Figura 11: imagem da parada do simulador utilizando o nmero 523.176.328 pelo


algoritmo de Shor.

Observamos que o clculo de r est tentando achar o resto da diviso de


(506.31555 523.176.328) . A primeira parte da expresso resulta no erro
apontado.

6.3.5 Exemplo Comparativo 5


Para este caso foram realizados vrias simulao com valores
diferentes, para se fazer um comparativo quanto ao tempo de execuo dos
algoritmos.

Figura 12: Imagem da parada do simulador utilizando o nmero 1.200

23

Figura 13: Imagem da parada do simulador utilizando o nmero 67.893

Figura 14 : Imagem da parada do simulador utilizando o nmero 100.000

Analisando as figuras 12, 13 e 14 possvel verificar o que tempo de


execuo 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 no satisfatrias para os nmeros

24

apresentados, mas se executarmos o programa vrias vezes para o mesmo


nmero, teremos outros resultados de fatores e tambm de tempo de execuo
devido a forma probabilstica 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 nmero 1.200

Figura 16: Imagem da parada do simulador utilizando o nmero 1.200

25

Figura 17: Imagem da parada do simulador utilizando o nmero 1.200

Figura 18 - Imagem da parada do simulador utilizando o nmero 1.200

O algoritmo de Fermat obteve os mesmos resultados para todos os


tempos execues, 6 centsimos de segundos. J o algoritmo de Shor se
mostrou mais lento em trs escolhas e mais eficiente em uma, isso fica
evidente devido escolha aleatria do y utilizado para a fatorao.

26

7.

Concluso
O objetivo deste trabalho foi atingido com xito. Nas simulaes

realizadas foi possvel 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 fatorao. Outro aspecto observado para
este algoritmo foi o excelente desempenho dele para fatorao de nmeros
pequenos, e tambm foi possvel verificar que quanto maior o nmero a ser
fatorado, maior o seu tempo de execuo.
O algoritmo de Shor apresentou uma eficincia muito superior para
encontrar os fatores de um nmero, a forma probabilista de se encontrar
fatores ficou muito evidente nas vrias execues do simulador com o mesmo
valor. Pelas simulaes, verificamos que este algoritmo foi elaborado para ser
executado em computadores qunticos, que possuem um desempenho nada
comparado aos computadores clssicos; a sua total eficincia jamais poder
ser avaliada por mquinas tradicionais em se tratando de nmeros muito
grandes. Isto foi evidenciado no erro de estouro de memria apresentado na
simulao, porque os computadores tradicionais no possuem memria
suficiente para fatorao de grandes nmeros.

Agradecimentos
A realizao deste trabalho foi concretizada graas participao de
muitas pessoas em minha vida. Em especial queles que acreditaram no meu
potencial. Agradeo ao meu orientador, Dr. Paulo Henrique Alves Guimares,
pela disponibilidade e orientaes. Ao meu marido Rafael, que me auxiliou e
ajudou nos conhecimentos de computao clssica. Aos meus professores da
Universidade que me auxiliaram na evoluo dos meus conhecimentos da
fsica. E a Deus que me deu sabedoria e sade para realizar este trabalho.

27

8 Bibliografia

CARTER, Nicholas. Teoria e Problemas de Arquitetura de Computadores.


Porto Alegre: Bookman, 2003.

GUIMARES, Paulo Henrique Alves. Portas Lgicas Qunticas em Pares de


Cadeias Acopladas de Poliacetileno, Universidade de Braslia Instituto de
Fsica, Braslia, 2004.
Tese (Doudorado em Fsica), Universidade Catlica de Braslia

LINS, Vagner Vieira. O Computador Quntico de Oscilador Harmnico,


Universidade de Braslia Pr-Reitoria de Graduao Curso de Fsica Trabalho
de Concluso de Curso, Braslia-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. Computao Quntica e Informao


Quntica. Porto Alegre: Bookman, 2005.

RODRIGUES, Wilton Alburquerque. O Computador Quntico ptico,


Universidade de Braslia Pr-Reitoria de Graduao Curso de Fsica Trabalho
de Concluso de Curso, Braslia-DF 2011.

NETO, Luiz Ferrz. O gato de Schrdinger, Disponvel em:


<www.feiradeciencias.com.br/sala23/23_MA14.asp> Acesso em: 05/10/2011.

ROLIM, Eduardo. Algoritmo de Shor Explicado - Fatorando Grandes Nmeros.


Disponvel em: <http://www.tocadoelfo.com.br/2009/12/algoritmo-de-shorexplicado-fatorando.html> Acesso em 10/12/2010.

28

Computador Quntico. Disponvel em:


<http://pt.wikipedia.org/wiki/Computador_qu%C3%A2ntico> Acesso em
04/04/2011.

29

ANEXO 1 Cdigo Fonte do Simulador


Os processos de clculos 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 formatao do Formulrio
nico onde esto dispostos os botes e listas de resultados, no sendo de
relevncia para a incluso 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 informao 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 interaes (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("Clculo do X e Y de Fermat: (X + Y) * (XY)")
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 SO 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 nmeros primos entre si (ou coprimos), um conjunto de
nmeros onde o nico divisor comum a todos eles for o nmero 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; ento, 20 e 21 so coprimos.

'No necessrio escolher todos os coprimos. Escolhe um y aleatorio


entre 2 e N e verifica se coprimo.

'a) Escolha aleatria de um nmero entre 2 e N: (escolha de Y)


Selec_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("Nmero menor que " & num_n & " escolhido
(aleatrio): " & 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 & " so
coprimos?

SIM")

Else
frmPrincipal.lst2.Items.Add(num_n & " e " & Y_aleatorio & " so
coprimos?

NO - 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 aleatrio). Cada resultado dessa
potncia, 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 diviso de Y^R (R de 1 a 10) por N. E R o prprio perodo da
sequncia.
'Quando achar o y^r=1 mod n ento 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
equao: " & 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? NO... reiniciar o
processo com escolha de outro Y aleatrio")
GoTo Selec_Y
End If
End If
Next
If R_corresp_Y = 0 Then
frmPrincipal.lst2.Items.Add("")
frmPrincipal.lst2.Items.Add("No foi encontrado o R correspondente
que atenda a equao: " & Y_aleatorio & "^r MOD " & num_n)
frmPrincipal.lst2.Items.Add("O processo ser reiniciado com escolha
de outro Y aleatrio")
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 NO 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("Clculo 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 vlido

frmPrincipal.lst2.Items.Add("Validao do X pela equao: " &


X_corresp_Y & "^2 MOD " & num_n & " = OK")
Else

frmPrincipal.lst2.Items.Add("Validao do X pela equao: " &


X_corresp_Y & "^2 MOD " & num_n & " = INVLIDO...reiniciar o processo com escolha
de outro Y aleatrio")
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) ento: n1 = M.D.C.(48,15)=3 e n2 =
M.D.C.(50,15)=5;

'OBS: SE ENCONTRAR A SOLUO 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("SOLUO TRIVIAL...reiniciar o processo
com escolha de outro Y aleatrio")
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