Laag hangend fruit factorisatie

Transcriptie

1 Laag hangend fruit factorisatie Tom Slenders Begeleider: Benne de Weger Faculteit Wiskunde en Informatica Technische Universiteit Eindhoven v juni 2012

2 Samenvatting Om natuurlijke getallen te factoriseren zijn verschillende methodes ontwikkeld. De volgende worden in dit verslag behandeld: delen uitproberen, Fermat s verschil in kwadraten methode, Pollard s rho methode, Pollard s p- 1 methode, Kwadratische vorm factorisatie (SQUFOF) en kettingbreuken (CFRAC). Van deze methodes wordt een werking, implementatie, snelheid, en voor- en nadelen gegeven.

3 Inhoudsopgave Inleiding 4 1 Probleemomschrijving 5 2 Oplossingsmethoden Delen uitproberen Fermat s verschil in kwadraten methode Pollard s rho methode Pollard s p-1 methode Kwadratische vorm factorisatie (SQUFOF) Kettingbreuken (CFRAC) Resultaten 31 4 Discussie Keuze van priemgetallen Andere methodes

4 Inleiding Priemgetallen zijn zeer bijzondere getallen. Priemgetallen zijn gehele getallen groter dan één die alleen deelbaar zijn door zichzelf en door één. Ook kan elk natuurlijk getal geschreven worden als een uniek product van priemgetallen. Als men echter een natuurlijk getal neemt, is het lastig om daar alle priemdelers van te bepalen. Als men twee grote priemgetallen neemt en deze met elkaar vermenigvuldigt dan krijgt men een nieuw getal. Als dit laatste getal aan een ander persoon wordt gegeven, zal hij de twee priemgetallen moeilijk kunnen achterhalen. Dit verschijnsel wordt gebruikt in allerlei digitale beveiligingen. Zo is bijvoorbeeld RSA hierop gebaseerd, een zeer bekend encryptie-algoritme. Echter bij bepaalde keuzes van priemen zullen er toch bepaalde methodes zijn waardoor makkelijk achterhaald kan worden welke priemen zijn gebruikt. De vraag is welke priemgetallen dit zijn en welke methode er voor zorgt dat de priemen toch makkelijk ontbonden kunnen worden. In dit verslag zullen verschillende methodes om getallen te factoriseren zowel in de theorie als in de praktijk worden onderzocht. Er zal worden onderzocht hoe, waarom en hoe goed de methodes werken. Daarna worden de methodes met elkaar vergeleken. De onderzochte methodes zullen relatief makkelijk (be)grijpbaar zijn, vandaar de naam voor de verslag Laag hangend fruit factorisatie. Dit kan nuttig zijn bij het opzetten van een digitaal beveiligingssysteem. Bij een beveiligingssysteem zoals RSA moet een getal worden gekozen dat lastig is te factoriseren. Om te voorkomen dat hackers het systeem kraken, kan het getal getest worden door de verschillende methodes om zo te controleren of deze veilig genoeg is. 4

5 Hoofdstuk 1 Probleemomschrijving Neem twee oneven priemgetallen p en q, definieer n = pq. Doelstelling: Vindt uit n de twee priemgetallen p en q terug, waarbij p en q onbekend worden verondersteld. Algemener willen we een willekeurig natuurlijk getal n op kunnen delen in al zijn priemfactoren. Het is voldoende om n = pq te vinden als p en q niet noodzakelijk priemgetallen zijn. Door recursie op p en q kunnen alle delers van n worden gevonden. Er zijn vele methodes om dit probleem op te lossen en er zullen een aantal in dit verslag worden behandeld. De eerste methode is simpelweg het uitproberen van delingen en hopen dat de juiste priemdeler wordt gevonden. De tweede methode is Fermat s verschil in kwadraten methode die de twee priemen beschouwt als pq = (x + y)(x y) = x 2 y 2 en uit de kwadraten de priemgetallen achterhaalt. De derde methode is Pollard s rho methode die door het herhaaldelijk toepassen van een vrijwel willekeurig ogende functie hoopt op het vinden van een prettige cykel. De vierde methode is Pollard s p-1 methode die gebruik maakt van Fermat s kleine stelling en daarmee p kan vinden als p 1 op te delen is in veel kleine priemen. De vijfde methode is SQUFOF die gebruik maakt van gereduceerde kwadratische vormen en de cykelstructuur die zij vormen. De zesde methode is CFRAC die kettingbreuken gebruikt om verschillende vormen x 2 q i (mod n) te berekenen en te combineren tot x 2 y 2 (mod n). Voor elke methode zal een beschrijving gegeven worden. Vervolgens zal uitgelegd worden hoe deze methode werkt, daarna wordt een implementatiemethode gegeven en de snelheid van het algoritme (hierbij wordt uitgegaan dat een optelling O(log n) tijd kost, een vermenigvuldiging O(α(n)) of O((log n) 1,585 ) [6], een deling O((log n) 2 ) en een ggd berekenen O(β(n)) of O(log n(log log n) 2 (log log log n)).) [4]. Vervolgens wordt de snelheid vergele- 5

6 ken met een implementatie van de methode in Mathematica 8.0. Als laatste zal voor elke methode kort de voor- en nadelen van de methode worden genoemd en verklaard. Voor sommige methoden zullen ook één of meerdere varianten worden gepresenteerd. 6

7 Hoofdstuk 2 Oplossingsmethoden 2.1 Delen uitproberen Delen uitproberen is de eerste en eenvoudigste methode om delers van n te vinden. Men gaat simpelweg allerlei factoren uitproberen om zo toevallig een deler van n tegen te komen. Hier is echter wel wat tijdwinst te boeken. Als je geen enkele voorkennis hebt over n is het als eerste slim om te beginnen met delen door 3 en dan telkens te proberen te delen door een getal dat 2 groter is. De kans dat een laag getal een deler is van een willekeurig geheel getal n is immers groter dan de kans bij een groter getal. Tevens hoeft niet verder geprobeerd te worden dan n, omdat de kleinste deler altijd kleiner of gelijk aan n is. Het maximale aantal delingen dat deze methode nodig heeft is n 1. Dit komt neer op een snelheid van O( n(log n) 2 ) Een (grote) priemtabel is aanwezig Het bovenstaande algoritme kan versneld worden door het gebruik van een tabel met alle priemgetallen tot n. Hierdoor hoeven niet alle getallen uitgeprobeerd te worden, maar slechts de getallen die een priemdeler kunnen zijn, namelijk priemgetallen. Het genereren van een tabel als deze kost tijd en het is niet de moeite om deze tabel elke keer dat n wordt berekend te generen en dan te gebruiken, want dan zou deze methode net zo snel zijn als het standaard delen uitproberen. Maar als een priemtabel al aanwezig is, of als er meerdere n moeten worden gesplitst levert deze methode een versnelling op. Het aantal priemgetallen tot a is asymptotisch gezien a log a.[6] Dit betekent 7

8 dat er slechts n log delingen uitgeprobeerd hoeven te worden. Dit komt neer n op een snelheid van O( n log n) Ggd met veel priemgetallen uitrekenen Een derde methode is om alle priemgetallen tot een zekere T met elkaar te vermenigvuldigen: T i=1 π i = S, waarbij π i het i e priemgetal is. Vervolgens kun je ggd(n, S) berekenen, waaruit eventueel zal blijken dat één of meer priemgetallen delers zijn van n. Als dit geen delers oplevert, neem dan een nieuwe S = T i=t +1 π i, met T > T. Het voordeel van deze methode is dat er in plaats van delingen ggd s worden berekend en bovendien op vele priemgetallen tegelijk werkt. Het uitrekenen van een ggd(s, n) duurt niet lang in verhouding tot het bepalen van S. Het bepalen van S duurt O(T α(t )) of O(T (log T ) ). Dit is bij gebruik van een priemtabel, maar als deze niet aanwezig is duurt het nog langer (De expliciete uitdrukking is ingewikkeld en zal achterwege worden gelaten). Merk op dat als S van te voren wordt berekend, het mogelijk is om zeer snel te bepalen of delen uitproberen snel resultaten zal opleveren. Het is ook mogelijk om geen S te berekenen en de ggd(n, π i ) te bereken. Dan gebruik je als de ggd in plaats van delen. Op die manier kun je ook n in zijn geheel factoriseren door vele priemfactoren te proberen. Zonder een priemtabel levert dit een snelheid van O( nβ(n)) of O( n log n(log log n) 2 (log log log n)). Met een priemtabel is het wederom een beetje sneller: O( n log n β( n log n )) of O( n log n (log log n)2 (log log log n)). 2.2 Fermat s verschil in kwadraten methode Beschrijving Fermat s methode is de op één na oudste methode, op delen uitproberen na.[5] Hij is gebaseerd op het idee dat n te schrijven is als x 2 y 2. Onder die aanname geldt n = x 2 y 2 = (x y)(x + y). Als x en y respectievelijk niet gelijk zijn aan n+1 2 en n 1 2 zal bij het vinden van x en y een partiële ontbinding gevonden worden van n, namelijk p = (x + y) en q = (x y) Werking De reden dat deze methode werkt is te zien in de formule n = x 2 y 2 = (x y)(x+y). Een concrete algoritme is als volgt. Neem x 0 = n en neem 8

9 z 0 = x 2 0 n. Nu controleer je of z 0 een kwadraat is. Het kan zo zijn dat z 0 = 0, dat betekent dat n al een geheel getal was en dat het daarmee een deler is van n. Als dit niet het geval is kunnen we een rij creeëren x n+1 = x n + 1 en z n+1 = x 2 n+1 n. Voor elke z n kunnen we controleren of het een kwadraat is met behulp van een aangepast algoritme van Newton (zie 2.2.3), zodra een kwadraat is gevonden heb je twee delers gevonden. Stel je vindt bij n een kwadraat, neem y = z n = x 2 n n, dan zijn je delers x n y en x n + y. Hier volgt een tabel (Tabel 2.1) met daarin een aantal iteraties van deze methode, dit zal de werking van de methode verduidelijken, neem n = 893 en x = 893 = 30. x t = 2x + 1 x 2 x 2 n = 14 2 Tabel 2.1: Voorbeeld van Fermat s verschil in kwadraten methode met n = 893. Uit de tabel volgt dat x y = 19 en x + y = 47. Dit is inderdaad een factorisatie van Implementatie Hier volgt een implementatie van Fermat s verschil in kwadraten methode. Algoritme 1 Fermat s verschil van kwadraten methode(n) Input: n een geheel getal Output: (a, b) met a n, b n en a b 0 zo klein mogelijk. 1: x := n 2: t := 2x + 1 3: z := x 2 n 4: while not IsSquare(z) do 5: x := x + 1 6: z := z + t 7: t := t + 2 8: end while 9: return (x + z, x z) Merk op dat er gebruik wordt gemaakt van een t die ervoor zorgt dat het berekenen van een kwadraat niet nodig is. 9

10 Merk ook op dat er gebruik wordt gemaakt van een functie IsSquare(r) die aangeeft of z een kwadraat is of niet. In Algoritme 2 is een algoritme voor de IsSquare methode geïmplementeerd. Algoritme 2 IsSquare(r) Input: r > 0 een geheel getal. Output: TRUE als n een geheel getal is, anders FALSE. 1: x := r + 1 2: y := r 3: while y < x do 4: x := y 5: y := (x + r/x )/2 6: end while 7: return (x 2 = r) Dit is een aangepaste versie van het algoritme van Newton [5]. Het begin van het algoritme kan versneld worden. Zo lang in stap 2 voor y een getal groter dan r wordt gekozen werkt het algoritme. Een eenvoudige manier en tevens computertechnisch snelle methode (veelal bit-operaties) is door de vijfde stap te vervangen door y := 2 (log 2 n)/ Snelheid De snelheid van algoritme 1 wordt vooral bepaald door het controleren of de wortel van x 2 n een geheel getal is. De overige bewerkingen gebruiken in vergelijking weinig rekenkracht. (Dit komt mede door het gebruik van de t = 2x + 1 welke in Tabel 2.1 is te zien.) Het controleren op een wortel gebruikt meerdere bewerkingen, terwijl de rest van het algoritme in de whileloop niet meer dan een enkele optelling gebruikt. We berekenen nu het aantal loops dat de while-loop maakt. Neem n = pq waarbij we veronderstellen dat p q. Merk op dat als p = q de loop direct eindigt. Als het algoritme anders eindigt geldt x+y = p en x y = q, hieruit volgt p+q 2 = x en p q 2 = y. Tevens geldt op het eind van het algoritme x = t 1 2, dit betekent dat t = 2x + 1 = p + q + 1 = p + n/p + 1. De variable t begint bij n en gaat per iteratie 2 omhoog. Dit betekent dat er t 2 n = p+n/p+1 2 n iteraties worden gedaan in de while-loop. Als we n afronden tot n kunnen we schrijven p+n/p+1 2 n p+n/p+1 2 n = (p n) 2 2p Aan deze uitkomst is te zien dat het algoritme in het slechtste geval nog O(n) iteraties nodig heeft, maar dat als p en n dicht bij elkaar liggen het algoritme juist erg snel is. Algoritme 2 gebruikt O(log log n) iteraties [5]. 10

11 Dit kost dus door de delingen O((log n) 2 log log n) tijd, de binair geoptimaliseerde versie is sneller: O(log n log log n). Dit betekent dat de snelheid van Fermat s verschil in kwadraten methode O(n log n log log n) is. We kunnen wat preciezer zijn over de snelheid van dit algoritme als p en n dicht bij elkaar liggen. Als p n = n 1 4 +γ voor zekere γ dan kunnen we het aantal iteraties omschrijven: (p n) 2 2p = (n 1 4 +γ ) (n 1 4 +γ +n 1 2 = n γ ) 2(n 1 4 +γ +n ) Als γ 0 dan kost dit O(1) tijd. Als 0 < γ 1 4 dan kost dit O(n2γ ) tijd. Anders kost het O(n 1 4 +γ ) tijd, wat betekent dat als p n duurt het algoritme O(n) tijd Implementatievergelijking Na een implementatie van Fermat s verschil in kwadraten methode in Mathematica 8.0 kon getest worden of de snelheid inderdaad ongeveer O(n) zou zijn. In figuur 2.1 is de uitkomst hiervan te zien. Er zijn voor elk punt 50 verschillende n bepaald, waarbij n kleiner is dan de op de x-as aangegeven waarde en groter dan de op de x-as aangegeven waarde gedeeld door 4. Elke n is een product van 2 willekeurige priemen die kleiner zijn dan de wortel van de op de x-as aangegeven waarde en groter dan de helft daarvan. Voor elk punt wordt het gemiddelde bepaald, over de 50 verschillende n, van de tijd die nodig is om een oplossing te vinden. Als een lineaire trendlijn in de log-log-plot voor deze punten wordt bepaald heeft deze de volgende formule: y = 0, 4926x 7, Doordat 0, kunnen we concluderen dat Fermat s verschil van kwadraten methode ongeveer in O(n 0.5 ) = O( n) tijd loopt. Dit is raar, aangezien dit sneller is dan de verwachte snelheid van O(n). Dit komt waarschijnlijk door de keuze van de priemgetallen voor n = pq. n bestaat uit p en q waarvoor geldt N 2 p N en N 2 q N. Dan geldt p q N 2. Dit betekent dat N van de orde grootte n is omdat N 2 4 n N 2. Dus p q is van orde grootte O( n). Dan volgt γ 1 4, dus is de snelheid van Fermat s verschil in kwadraten methode op deze keuze van n gelijk aan O( n). Dit toont aan dat p en q inderdaad niet te dicht bij elkaar gekozen moeten worden, omdat Fermat s verschil in kwadraten methode dan sneller wordt Voor- en nadelen Er is één duidelijk voordeel van Fermat s verschil in kwadraten methode en dat is de snelheid van de methode als p en n dicht bij elkaar liggen. In tegenstelling tot delen uitproberen begint Fermat s verschil in kwadraten methode te kijken vanaf n en vindt zo erg snel een p die dicht bij n ligt. 11

12 Gemiddelde tijd nodig (s) 16 4 Fermat verschil in kwadraten methode Maximum n Figuur 2.1: De snelheid van Fermat s verschil in kwadraten methode, geïmplementeerd in Mathematica 8.0. De tijd die Fermat s verschil in kwadraten methode kost is veel groter dan delen uitproberen. Maar doordat delen uitproberen juist kleine factoren snel vindt, is het slim om een combinatie van Fermat s verschil in kwadraten methode en delen uitproberen te gebruiken Varianten Multiplier Fermat s verschil in kwadraten methode vindt snel een factor van n als deze uit twee factoren bestaat die dicht bij elkaar liggen. Soms is er niet zo n factor, maar kan deze wel gemaakt worden. Als we kijken naar x 2 an met a = 1, 2, 3, 4,... zien we dat nu snel een deler van an wordt gevonden. Door een slimme keuze van a kan soms zeer snel een factor van n worden gevonden. Merk op dat a = 1 de normale methode is. 12

13 Sneller kwadraten controleren Het controleren of een getal een kwadraat is gaat snel met de methode van Newton, maar er kan wat tijdwinst geboekt worden. We kunnen gaan kijken of r (mod 64) wel een kwadraat kan zijn door 0 2, 1 2, 2 2,..., 63 2 (mod 64) van te voren te berekenen. Daarna kun je voordat je Newton s methode toepast eerst controleren of x 2 i n (mod 64) een kwadraat is door te controleren of hij in je rijtje van mogelijkheden staat. Dit rijtje bestaat uit slechts 12 getallen, dus is de kans dat een willekeurig getal door deze test heen komt. Merk op dat deze toevoeging het algoritme niet asymptotisch beter maakt. Verder is het ook mogelijk een ander getal dan 64 te nemen, zo zou je 720 kunnen nemen die 48 verschillende kwadraten kent en daarmee een kans van heeft dat een willekeurig getal door deze test komt. 2.3 Pollard s rho methode Beschrijving Neem een willekeurige waarde s en neem een functie f(x) die een willekeurige waarde terug lijkt te geven (maar dus wel deterministisch is). Kijk vervolgens naar de rij s, f(s), f(f(s)), f(f(f(s))),... Als we deze rij modulo p nemen, dan moet volgens de verjaardagenparadox na gemiddeld O( p) een dubbele waarde optreden, waarna de rij in een cykel terecht komt. Als we in plaats van modulo p werken, modulo n werken, dan kunnen we zoeken naar twee waardes u en v waarvoor geldt u v (mod p). Dit betekent waarschijnlijk ggd(u v, n) = p Werking We definiëren s 0 = s en s i+1 = f(s i ). Nu moeten we een cykel vinden in de rij (s i ), maar we willen niet voor elk paar ggd(s i s j, n) uitrekenen. Dit kost namelijk veel tijd en ook veel computergeheugen. Dit kan sneller en geheugenefficiënter door Floyd s cykel algoritme [3]. Floyd s cykel algoritme Dit algoritme wordt ook wel het schildpad en haas algoritme genoemd. Dit komt doordat het gebruik maakt van twee pointers waarvan er één twee keer 13

14 Nope Nope Yay! Figuur 2.2: Werking van Floyds cykel algoritme. Merk op dat in deze figuur niet naar ggd s wordt gekeken, maar naar gelijke waardes in de rij. Het algoritme met ggd s werkt analoog. zo snel door de rij (s i ) gaat als de ander. Er wordt een loop over i gestart en telkens wordt ggd(s i s 2i, n) berekend. Zodra ggd(s i s 2i, n) > 1 wordt gevonden is er een cykel en stopt het algoritme. De reden dat dit werkt is als volgt. Na verloop van tijd zal s i in de cykel terecht komen, op dat moment zit s 2i ook in de cykel. Nu wordt bij elke stap s 2i één meer opgehoogd dan s i, dus na maximaal l stappen is een cykel gevonden, waarbij l de lengte van de kleinste cykel is. Dit wordt met een voorbeeld geïllustreerd in Figuur 2.2. De keuze van f(x) is tot op heden nog niet bepaald. Het is de bedoeling dat deze functie willekeurig lijkt, maar ook dat hij snel te berekenen is, want in Floyd s cykel algoritme wordt drie maal f uitgerekend. Het blijkt dat f(x) = x 2 + b mod n een goede keuze is, behalve bij b = 0, 2. [5, p. 147] Implementatie In Algoritme 3 is een implementatie gegeven van het algoritme Snelheid De snelheid van deze methode is niet direct uit te drukken in een specifiek aantal iteraties van de loop. Het probleem is dat in het slechtste geval het algoritme net zo traag is als delen uitproberen. Maar door de verjaardagparadox verwacht je dat na O( p) tijd de factor p wordt gevonden. Aangezien 14

15 Algoritme 3 Pollard s Rho methode(n) Input: n een geheel getal Output: g n of geen factor gevonden 1: Kies willekeurige b en s 2: S := s (De Schildpad) 3: H := s (De Haas) 4: f(x) := x 2 + b mod n 5: repeat 6: S := f(s) 7: H := f(f(h)) 8: g := ggd(s H, n) 9: until g > 1 10: if g < n then 11: return g 12: else 13: return Geen factor gevonden 14: end if p n levert dit een verwacht aantal iteraties van O(n 1 4 ) op. De langzaamste bewerking in de loop is de modulus in f(x), die is namelijk net zo snel als een deling, oftwel O((log n) 2 ). Dus is de totale verwachte snelheid van Pollard s rho methode O(n 1 4 (log n) 2 ) Implementatievergelijking Na een implementatie van Pollard s rho methode in Mathematica 8.0 kon getest worden of de snelheid inderdaad ongeveer O(n 1 4 ) zou zijn. In figuur 2.3 is de uitkomst hiervan te zien. Er zijn voor elk punt 50 verschillende n bepaald, waarbij n kleiner is dan de op de x-as aangegeven waarde en groter dan de op de x-as aangegeven waarde gedeeld door 4. Elke n is een product van 2 willekeurige priemen die kleiner zijn dan de wortel van de op de x-as aangegeven waarde en groter dan de helft daarvan. Voor elk punt wordt het gemiddelde bepaald, over de 50 verschillende n, van de tijd die nodig is om een oplossing te vinden. Als een lineaire trendlijn in de log-log-plot voor deze punten wordt bepaald heeft deze de volgende formule: y = x Doordat kunnen we concluderen dat Pollard s rho methode ongeveer in O(n 0.25 )O(n 1 4 ) tijd loopt. 15

16 Gemiddelde tijd nodig (s) Pollard's rho methode Maximum n Figuur 2.3: De snelheid van Pollard s rho methode, geïmplementeerd in Mathematica Voor- en nadelen De snelheid van Pollard s rho methode is aanzienlijk hoger dan delen uitproberen en Fermat s verschil in kwadraten methode (O(n 1 4 ) tegenover O(n 1 2 )). Bovendien is de snelheid afhankelijk van de kleinste deler p van n. De snelheid is eigenlijk O( p) en dus is Pollard s rho methode nog sneller als p klein is. Een nadeel van Pollard s rho methode is dat de snelheid een verwachte snelheid is en dat afhankelijk van p de snelheid veel lager kan liggen. 2.4 Pollard s p-1 methode Beschrijving Pollard s p-1 methode maakt gebruik van de kleine stelling van Fermat: A p 1 1 mod p met A 0 mod p. Uit de kleine stelling van Fermat volgt tevens A K(p 1) 1 (mod p) voor een zekere K. Hieruit volgt dat p ggd(a K(p 1) 1, n). Het idee is om een L te construeren zodat deze hopelijk alle delers van p 1 bevat, dan levert ggd(a L 1, n) als het goed is p op. 16

17 2.4.2 Werking Als eerste moet er een L worden geconstrueerd. In principe kan L elk willekeurig getal zijn, maar het idee van Pollard was om L = kgv(1, 2, 3,..., B) te nemen, waarbij B een gegeven bovengrens is. L is te schrijven als een product van priemgetallen en dit maakt berekeningen uiteindelijk ook sneller. L = π e i i, waarbij π i het i e priemgetal is en e i = log πi B. A L zal al snel te groot worden, gelukkig is het voldoende om A L (mod n) te berekenen, aangezien we uiteindelijk alleen ggd(a L 1, n) berekenen. Omdat L wordt berekend kun je ook stap voor stap A πe i i (mod n) uitrekenen. Dit levert het volgende rijtje op: A 0 = A, A i+1 A πe i i i (mod n). Met A i de laatste uit het rijtje moet dan alleen nog ggd(a i 1, n) berekend worden Implementatie In Algoritme 4 is een implementatie weergegeven van Pollard s p-1 methode. Algoritme 4 Pollard s p-1 methode(n,b) Input: n en B een geheel getal Output: g n of Geen factor gevonden 1: a := 2 2: i := 1 3: for π i B (met π i het i e priemgetal) do 4: e := log πi B 5: a := a πe i (mod n) 6: i := i + 1 7: end for 8: g := ggd(a 1, n) 9: if 1 < g < n then 10: return g 11: else 12: return Geen factor gevonden 13: end if Merk op dat in het begin van het algoritme A op 2 wordt gezet. Dit zou ook een ander getal kunnen zijn, maar dit maakt voor het algoritme niet uit, zolang het maar niet 1, 0, 1 (mod p) is Snelheid Deze methode geeft niet altijd een oplossing, dit is namelijk afhankelijk van B. De kans dat voor een willekeurige deler p geldt dat p 1 B-glad is, 17

18 daarmee wordt bedoeld dat alle delers π k i i van p 1 kleiner of gelijk aan B zijn, is ρ(log p/ log B) voor ρ(u) = 1 als 0 u 1 en ρ (u) = ρ(u 1)/u voor u > 1. Deze functie is niet expliciet uit te drukken, maar is wel een stijgende lijn.[5] De snelheid van dit algoritme wordt voornamelijk bepaald door de for-loop. In deze for-loop is de zwaarste bewerking een macht berekenen met een modulus. Voor een berekening van a e (mod m) zijn log 2 e vermenigvuldigingen nodig, dus is de snelheid O(α(a) log e) of O((log a) log 2).[6] Toegepast op Pollard s p-1 methode heeft elke stap in de for-loop een snelheid van O(α(n) log(b)) of O((log n) log B). Het complete algoritme gebruikt O(B/ log B) iteraties en heeft dus een totale snelheid van O(α(n)B) of O((log n) B) Implementatievergelijking Na een implementatie van Pollard s p-1 methode in Mathematica 8.0 kon getest worden hoe de snelheid van de methode in verschillende situaties is. In figuur 2.4 is de uitkomst hiervan te zien. Er zijn voor elk punt 1000 verschillende n bepaald, waarbij n kleiner is dan de op de x-as aangegeven waarde en groter dan de op de x-as aangegeven waarde gedeeld door 4. Elke n is een product van 2 willekeurige priemen die kleiner zijn dan de wortel van de op de x-as aangegeven waarde en groter dan de helft daarvan. Voor elk punt wordt het gemiddelde bepaald, over de 1000 verschillende n, van de tijd die nodig is om een oplossing te vinden. Bij Pollard s p-1 methode was het nodig om 1000 verschillende waardes te bepalen, omdat de uitkomsten erg grillig zijn. Dit komt doordat de methode soms zeer snel resultaat heeft en soms juist erg lang nodig heeft om resultaten te genereren. Dit verschijnsel ontstaat door de ietwat aangepaste implementatie in Mathematica 8.0. Deze implementatie is beschreven in Dit proces voert maximaal O(log n) keer Pollard s p-1 methode uit, maar zal zeer verschillende resultaten geven afhankelijk van n. Het lukt niet om een lineaire trendlijn in de log-log-plot te bepalen in figuur 2.4. Dit is ook compleet in lijn met de theorie. De verwachting is dat naarmate n groter wordt de methode steeds slechter wordt. Dit is ook in de grafiek te zien Voor- en nadelen Pollard s p-1 methode is soms snel en soms niet. Asymptotisch gezien is de methode wel erg traag. Echter komt het af en toe voor dat er een factor p 18

19 Gemiddelde tijd nodig (s) 4 1 Pollard's p-1 methode Maximum n Figuur 2.4: De snelheid van Pollard s p-1 methode, geïmplementeerd in Mathematica 8.0. is, waarvoor geldt dat p 1 B-glad is voor een kleine B. In dat geval is de methode erg snel en levert met weinig rekentijd een factor. Ook is de methode erg eenvoudig om te begrijpen. Hij is gebaseerd op de kleine stelling van Fermat en dient als een zeer directe toepassing van deze stelling. Zo zou Pollard s p-1 methode gebruikt kunnen worden voor onderwijs Variant B bepalen Om een deler te vinden mag B niet te groot en niet te klein zijn. Preciezer moet minimaal één deler van n wel B-glad zijn en minimaal één niet. Een praktische waarde van B moeten we eerst bepalen. Het algoritme vindt geen factor als het 1 of n als resultaat geeft. Als het 1 als resultaat heeft, was B te klein, als n het resultaat is, was B te groot. Hiermee kunnen we een uitbreiding van het algoritme formuleren die B aanpast. Als eerste beginnen we met een bovengrens u := 2. Vervolgens voeren we het algoritme uit, is het resultaat 1, dan verdubbelen we u. Dit herhalen we totdat u geen 1 als 19

20 resultaat oplevert. Als het resultaat ook kleiner was dan n zijn we klaar. Zo niet, dan nemen we l := u/2 en nemen B := (u + l)/2. Als het resultaat hiervan niet 1 of n is zijn we klaar. Was het resultaat 1 dan nemen we l := (u + l)/2 en anders u := (u + l)/2. Dit proces blijven we herhalen. 2.5 Kwadratische vorm factorisatie (SQUFOF) Beschrijving SQUFOF maakt gebruik van kwadratische vormen en de structuur van gereduceerde kwadratische vormen om een factor van n te vinden. Kwadratische vormen zijn van de vorm Ax 2 + Bxy + Cy 2 en hebben een discriminant = B 2 4AC. Bij SQUFOF construeren we een gereduceerde kwadratische vorm met = n of = 4n en lopen we door een cykel van gereduceerde vormen, waarbij niet verandert. Zo proberen we een factor van n te vinden Werking Kwadratische vormen Een kwadratische vorm is de uitdrukking Ax 2 +Bxy+Cy 2 waarbij de x en y gehele getallen zijn. Dit is kortweg te schrijven als (A, B, C). De discriminant van een kwadratische vorm is = B 2 4AC. Twee kwadratische vormen zijn equivalent als ze dezelfde discriminant hebben en door een substitutie van de volgende vorm uit elkaar voortkomen: x ax + by en y cx + dy met ad bc = 1. [5] In elke equivalentieklasse wil je graag een gereduceerde vorm aangeven, dat wil zeggen met coëfficiënten zo klein mogelijk. Bij D < 0 kun je deze eenvoudig uniek bepalen en vinden met een algoritme. Bij D > 0 is dit niet mogelijk. Het is wel mogelijk om een eindige verzameling van gereduceerde vormen te definiëren. Dit doen we als volgt: (a, b, c) is gereduceerd als D 2 a < b < D. De gereduceerde vormen van een equivalentieklasse zijn te rangschikken in een cykel en er bestaat een efficiënt algoritme voor het vinden van de volgende gereduceerde vorm in de cykel. Introductie SQUFOF SQUFOF creëert een kwadratische vorm (A, B, C) met D = n of D = 4n. Daarna bestaat SQUFOF uit twee delen. In het eerste deel wordt gezocht 20

21 naar een kwadratische vorm in dezelfde equivalentieklasse met C = c 2. In het tweede deel wordt er net zo lang de cykel afgegaan totdat twee kwadratische vormen worden gevonden met dezelfde middelste coëfficiënt. Dit levert waarschijnlijk een factor van n op. Dit zal nu in meer detail uitgelegd worden. Eerste loop Neem aan dat n oneven is en niet een kwadraat is. Als n 1 (mod 4) dan D = n en b = 2 ( D 1)/2 + 1, anders D = 4n en b = 2 D /2. F = (1, b, (b 2 D)/4). Nu is F een gereduceerde vorm met discriminant D. (Merk op dat als n 3 (mod 4), D niet gelijk kan zijn aan n, omdat dan zou gelden D n b 2 4ac 3 (mod 4) en dat betekent dat b 2 3 (mod 4), wat niet mogelijk is. Merk ook op dat a = 1 de laagst mogelijke a is en dat b het kleinst mogelijke getal is zodat D > 0. Dit laatste is nodig omdat de vorm anders niet gereduceerd zou zijn.) We definiëren ρ(a, b, c) = (c, r( b, c), r( b,c)2 D 4c ) met r( b, c) het unieke gehele getal zodat r b (mod 2 c ) met c < r c als D < c, of D c < r < D als c D. ρ is de functie die een gereduceerde kwadratische vorm in een equivalente gereduceerde kwadratische vorm verandert (met de lineaire coördinaattransformatie x = r( b, c)x + y en y = x) en zo één voor één de gereduceerde kwadratische vormen op de cykel afgaat. De eerste loop is niet meer dan dat: Er wordt telkens een nieuwe F := ρ(f ) berekend en er wordt gekeken of c een kwadraat is. Door de definitie van ρ wordt er alleen gekeken of c een kwadraat is bij elke oneven iteratiestap. Zodra C = c 2 is gevonden begint de tweede loop. Tweede loop Als eerste initialiseren we een nieuwe F = ( ca, b, c). Deze kwadratische vorm is niet equivalent aan de vorige, maar heeft wel dezelfde D. Hier passen we een lineaire transformatie op toe zodat het een gereduceerde vorm wordt. Deze transformatie is als volgt k = b+d 2 ca en F = (a, c 2ka, c+kb+k2 a). (Merk op dat a, b en c uit de zojuist opnieuw gedefiniëerde F komen.) k wordt afgeleid door de positieve waarde van k in ak 2 +bk +c = 0 te bepalen. Nu wordt de tweede loop gestart. Wederom wordt telkens F := ρ(f ) berekend, maar deze keer wordt niet gestopt zodra een kwadraat is gevonden. Nu wordt gestopt zodra twee opeenvolgende gereduceerde vormen dezelfde b hebben. 21

22 Als twee opeenvolgende vormen (a, b, c) en (a, b, c ) zijn gevonden met b = b dan geldt c D. Dit is als volgt in te zien: (a, b, c ) = ρ(a, b, c) = (c, r( b, c), r( b,c)2 D 4c ) met r b (mod 2 c ). Echter b b r b (mod 2 c ), dus c b. D = b 2 4ac, dus c D. Als c 0 dan is een deler van n gevonden Implementatie In de implementatie zitten nog enkele extra variabelen die in de gaten houden of het algoritme nog wel een oplossing kan geven. Het kan bijvoorbeeld voorkomen dat de cykel compleet doorlopen is, zonder een resultaat te krijgen. In dat geval moet het algoritme wel stoppen. Voor een duidelijk overzicht van de werking van het algoritme, zullen we deze achterwege laten. Het algoritme is te zien in algoritme Snelheid Een analyse van de snelheid is te complex om hier uit te leggen, maar er zijn verschillende publicaties te vinden die dit wel doen. Het algoritme heeft O(n 1 4 ) iteraties nodig. [2] Het controleren op een kwadraat is de langzaamste operatie in het algoritme. In is te zien dat dit O((log n) 2 log log n) tijd kost. Dus de totale snelheid is O(n 1 4 (log n) 2 log log n) Implementatievergelijking Na een implementatie van SQUFOF in Mathematica 8.0 kon getest worden of de snelheid inderdaad ongeveer O(n 1 4 ) zou zijn. In figuur 2.5 is de uitkomst hiervan te zien. Er zijn voor elk punt 50 verschillende n bepaald, waarbij n kleiner is dan de op de x-as aangegeven waarde en groter dan de op de x-as aangegeven waarde gedeeld door 4. Elke n is een product van 2 willekeurige priemen die kleiner zijn dan de wortel van de op de x-as aangegeven waarde en groter dan de helft daarvan. Voor elk punt wordt het gemiddelde bepaald, over de 50 verschillende n, van de tijd die nodig is om een oplossing te vinden. Als een lineaire trendlijn in de log-log-plot voor deze punten wordt bepaald heeft deze de volgende formule: y = 0.337x Doordat blijkt deze implementatie van SQUFOF niet zo snel te zijn als uit de theorie zou moeten blijken. Deze implementatie lijkt een snelheid van O(n 1 3 ) te hebben in plaats van de verwachte O(n 1 4 ). De grafiek lijkt echter ook een kleine kromming te vertonen, dus misschien is de getrokken trendlijn niet correct. 22

23 Algoritme 5 SQUFOF(n) Input: n oneven en geen kwadraat Output: c n mits het algoritme eindigt 1: {Initialisatie} 2: if n 1 (mod 4) then 3: D := n 4: b := 2 ( D 1)/ : else 6: D := 4n 7: b := 2 D /2 8: end if 9: F := (1, b, (b 2 D)/4) 10: 11: {Eerste loop} 12: i := 2 13: while c van F is geen kwadraat of i is even do 14: if c = 1 en i is oneven then 15: return Er is geen deler gevonden. 16: end if 17: F := ρ(f ) 18: i := i : end while 20: 21: {Tweede loop} 22: F := ( c, b, a c) 23: k = b+d 2 ca 24: F = (a, c 2ka, c + kb + k 2 a) 25: while b b do 26: b := b 27: F := ρ(f ) 28: end while 29: return c 23

24 Gemiddelde tijd nodig (s) SQUFOF Maximum n E+09 1E+12 1E+15 1E+18 Figuur 2.5: De snelheid van SQUFOF, geïmplementeerd in Mathematica 8.0. Tijdens het uitvoeren van de methode op allerlei getallen bleek SQUFOF regelmatig te crashen. Bij elke 50 tests bleken ongeveer 3 gevallen te crashen. Helaas is hier geen oplossing of verklaring voor gevonden. Deze situaties zijn verwijderd uit de berekening van de gemiddelde waardes Voor- en nadelen Volgens de theorie zou SQUFOF net zo snel moeten zijn als Pollard s rho methode. Het verschil is dat Pollard s rho methode afhankelijk is van de kleinste p en daarmee soms sneller is dan SQUFOF. Echter zou SQUFOF bij een geode implementatie zeer kleine constantes hebben. Dit betekent dat in het algemeen SQUFOF beter zou moeten presteren dan Pollards p-1 methode. Asymptotisch met willekeurige n zijn beide methodes even snel, maar door de prettige implementatiemogelijkheden van SQUFOF kan deze makkelijk op bijvoorbeeld zakrekenmachines worden geïmplementeerd.[5] 24

25 2.6 Kettingbreuken (CFRAC) Beschrijving De kern van deze methode berust op het zoeken van x en y zodat x 2 y 2 (mod n). Als n is op te delen in minimaal twee priemfactoren, dan is de kans dat x 2 y 2 (mod n) met x en y willekeurig een deler van n oplevert minimaal 1 2 [5]. Bij CFRAC worden verschillende relaties x2 i Q i (mod n) gemaakt, waarbij Q i relatief klein is. Daardoor kunnen deze Q i s worden opgesplitst in priemfactoren. Vervolgens worden een aantal van deze relaties met elkaar vermenigvuldigd zodanig dat alle verschillende priemfactoren een even aantal keer voorkomen. Dan zijn x en y gevonden en is er mogelijk een factor gevonden Werking De kern van deze methode is het genereren van x i en q i waarbij x i willekeurig lijkt en q i makkelijk is te ontbinden in factoren. Dit gaan we doen met behulp van kettingbreuken. Kettingbreuken zijn breuken in de vorm van: C C C C Elk reëel getal D kan geschreven worden als een kettingbreuk. Daardoor kan een kettingbreuk gebruikt worden als een benadering van dit getal. Kettingbreuken hebben verschillende handige eigenschappen, zo is een kettingbreuk van een rationaal getal eindig en een irrationaal getal oneindig. De C i s van een wortel van een niet-kwadratisch geheel getal gaan zich vanaf een bepaalde i > N herhalen. Een deel van de kettingbreuk met C 1 tot C i is weer te schrijven in de vorm A i B i, daarvoor geldt D A i B i < 1, tevens geldt voor Bi 2 wortels van niet kwadratische gehele getallen dat D A i B i alternerend positief en negatief is.[6] We gaan bij CFRAC kijken naar de kettingbreuk van n. Concreet gaan we kijken naar n A i B i n A i B i < ( 1) i ( n A i B i )B 2 i ( n + A i B i ) < 1 B 2 i 1 B 2 i B 2 i ( n + A i B i ) ( 1) i (nb 2 i A 2 i ) < n + A i B i 2 n 25

26 Nu definiëren we Q i := ( 1) i (nbi 2 A2 i ). Voor Q i geldt Q i 2 n, tevens geldt Q i ±A 2 i (mod n). Nu hebben we een serie van Q i s die niet te groot zijn. Dit is prettig want we willen nu deze Q i s gaan factoriseren. We gaan niet alle Q i s factoriseren, want Q i mag dan kleiner zijn dan n, het is nog steeds een getal met ongeveer de helft van het aantal cijfers van n. We gaan alleen maar de Q i s factoriseren die G-glad zijn, dat wil zeggen dat alle priemfactoren van Q i kleiner of gelijk aan G zijn. Als G niet groot is, kunnen we simpelweg door delen uitproberen alle priemfactoren vinden. Alle gegenereerde Q i s die we hebben ontbonden in factoren kunnen we schrijven als volgt: Q i = π e i,1 1 π e i, π e i,k k waarbij π j alle priemfactoren kleiner gelijk aan G zijn. Nu kunnen we combinaties van Q i s maken, met {i j } een selectie uit alle i: Π J j=1a 2 i j Π K k=1 πσj j=1 e i j,k k (mod n) (2.1) Het doel is om de (i j ) zo te kiezen dat de machten van alle priemgetallen aan de rechterkant van de vergelijking 2.1 allemaal even zijn. Dan zijn x en y gevonden zodat x 2 y 2 (mod n). Het is nu nog mogelijk dat deze x en y geen factoren van n opleveren. Dan moeten er meer Q i s gegenereerd worden, dan kunnen er andere combinaties worden gemaakt en daardoor andere x en y die hopelijk wel een factorisatie opleveren. De vergelijking 2.1 is geïmplementeerd een stuk eenvoudiger. Alle e s worden namelijk opgeslagen in een matrix. Deze matrix is I bij K groot en bevat e i,k op elk veld. Tijdens het uitvoeren van deze methode wordt er telkens een nieuwe Q i uitgerekend, deze wordt vervolgens toegevoegd aan de matrix en vervolgens kan er door vegen modulo 2 bepaald worden of een mogelijke combinatie {i j } bestaat en wat deze combinatie is. Dit proces wordt herhaald totdat een factorisatie van n is gevonden. Er moet nog wel een kleine aanpassing aan de matrix worden gedaan voor dit echt werkt. We hebben namelijk nog geen rekening gehouden met de factor ( 1) i. Deze moet ook positief zijn. Maar deze kunnen we eenvoudig toevoegen aan de matrix, aangezien ook deze factor een even macht moet hebben. In tabel 2.2 is een voorbeeld te zien van de factorisatie van n = Uit tabel 2.2 kunnen we een factorisatie van n vinden. Wat we eigenlijk zoeken is een afhankelijkheid tussen de rijen in tabel 2.3. De eerste meest eenvoudige afhankelijkheid is te zien bij i = 9, want deze rij is al afhankelijk. We kunnen nu een factorisatie proberen te vinden: (mod n), hieruit volgt ggd( , n) = 1 en ggd( , n) = 1. We hebben pech, want i = 9 levert helaas geen factorisatie op. Ook i = 8, 9, 19 levert geen factorisatie op. Maar i = 19, 22, 23 wel:

27 i A i ( 1) i Q i priemen , 5, 5, , 3, 3, 3, 5, 5, , , 3, 5, , 3, 3, 5, , 3, 5, , 17, 67 Tabel 2.2: CFRAC uitgevoerd op n = i Tabel 2.3: De matrix van hoe vaak een priem voorkomt modulo 2 uitgevoerd op n =

28 ( ) 2 (mod n), hieruit volgt ggd( , n) = 3851 en ggd( , n) = Implementatie Hieronder is een implementatie van CFRAC in Mathematica 8.0 te zien. Merk op dat er geen controle in zit die als nog een factor vindt mocht de eerste equivalentierelatie geen factorisatie opleveren. Deze is eenvoudig toe te voegen, maar is voor de duidelijkheid hier weggelaten. Algoritme 6 CFRAC(n,G) Input: n,g een geheel getal en n geen kwadraat. Output: R n 1: i := 0 2: while true do 3: Bereken A i en B i (met behulp van een kettingbreukalgoritme) 4: Q := ( 1) i A i nb i 5: if Q s grootste priemfactor is hoogstens G then 6: P (i, j) := # keren dat Q een priem j heeft 7: Veeg S := (P I) modulo 2 8: if j : P (i, j) = 0 then 9: Lees uit de rechterkolom van S af welke A i en Q i samen de laatste rij van S vormen. 10: A := ΠA i (mod n) 11: Q := ΠQ i (mod n) 12: R := (ggd(a Q, n), ggd(a + Q, n)) 13: if R is een oplossing then 14: return R 15: end if 16: end if 17: end if 18: end while In regel 3 van Algoritme 6 worden A i en B i berekend zonder uitleg. Het bereken hiervan is niet lastig, maar introduceert verschillende nieuwe variabelen die voor eenvoud van het algoritme weg zijn gelaten. Zie voor een concrete uitleg [6, p. 71] Snelheid Een analyse van de snelheid is te complex om hier uit te leggen, maar er zijn verschillende publicaties te vinden die dit wel doen. De snelheid is O(exp(( 2 + o(1)) log n log log n)). [5] 28

29 Gemiddelde tijd nodig (s) 16 4 CFRAC Maximum n E+09 1E+12 1E+15 Figuur 2.6: De snelheid van CFRAC, geïmplementeerd in Mathematica 8.0 met twee mogelijke trendlijnen, één exponentieel en één subexponentieel Implementatievergelijking Na een implementatie van CFRAC in Mathematica 8.0 kon getest worden of de snelheid inderdaad minder dan exponentieel zou zijn. In figuur 2.6 is de uitkomst hiervan te zien. Er zijn voor elk punt 100 verschillende n bepaald, waarbij n kleiner is dan de op de x-as aangegeven waarde en groter dan de op de x-as aangegeven waarde gedeeld door 4. Elke n is een product van 2 willekeurige priemen die kleiner zijn dan de wortel van de op de x-as aangegeven waarde en groter dan de helft daarvan. Voor elk punt wordt het gemiddelde bepaald, over de 100 verschillende n, van de tijd die nodig is om een oplossing te vinden. Als een lineaire trendlijn in de log-log-plot voor deze punten wordt bepaald blijkt deze niet goed te kloppen. Zoals te zien is aan de rode lijn in Figuur 2.6. De groene lijn in Figuur 2.6 doet het beter. Deze lijn is bepaald door een lijn van de vorm a+b x log x in de log-log-plot te berekenen met behulp van Mathematica 8.0. Daar bleek het volgende uit te komen: a en b De lijn volgt dus de volgende formule: f(x) = exp( log x log log x). Het is dus aannemelijk dat deze implementatie van CFRAC inderdaad subexponentieel is. Wat wel raar is is dat b ongeveer 2 zou moeten zijn volgens de theorie, maar dat deze kleiner uitvalt. Helaas is 29

30 hier geen verklaring voor gevonden. CFRAC bleek net als SQUFOF af en toe te crashen. Hoewel het minder vaak was dan bij SQUFOF, bleek ongeveer 2 van de 100 gevallen te crashen. Hiervoor is geen verklaring gevonden Voor- en nadelen CFRAC is langzaam als het gaat om kleine getallen, maar wordt in verhouding steeds sneller als n groter wordt. Dit komt omdat CFRAC subexponentieel is en dat is daarmee ook direct de grootste kracht van CFRAC in vergelijking met de andere beschreven methodes. Als je de trendlijnen van de twee beste methodes, Pollard s rho methode en CFRAC, met elkaar vergelijkt kun je bepalen wanneer de geïmplementeerde CFRAC beter wordt dan die van Pollard s rho methode. Dat blijkt te zijn bij een n van 165 bits. Waarschijnlijk kan de implementatie van CFRAC nog veel worden verbeterd, waardoor deze eerder Pollard s rho methode zal inhalen. 30

31 Hoofdstuk 3 Resultaten De vele methodes hebben allemaal hun voor en nadelen. In Figuur 3 hier een overzicht van weergegeven. Methode Snelheid Gericht op p Specialiteit Uitproberen O( n) ja Zeer kleine factoren vinden Fermat O(n) nee p q klein Rho O(n 1 4 ) ja Kleine factoren vinden p-1 O((log n) B) gedeeltelijk p-1 is B-glad SQUFOF O(n 1 4 ) nee Kleine factoren vinden zonder kans CFRAC O(exp(( 2+o(1)) nee Grote factoren vinden log n log log n)) Tabel 3.1: Overzicht van de verschillende methodes. De implementatie in Mathematica 8.0 van de methodes gaf soms andere resultaten dan de theorie voorspelde. De resultaten hiervan staan in Figuur 3.1. Duidelijk is te zien dat Pollard s rho methode het uitzonderlijk goed doet ten opzicht van de andere methodes. Fermat s verschil in kwadraten methode doet het in het begin ook erg goed, maar deze zal uiteindelijk veruit de langzaamste methode worden. Pollard s p-1 methode doet het ook goed, maar aan de kromming van de lijn is te zien dat de snelheid snel zal afnemen. SQUFOF is helaas langzamer dan uit de theorie zou moeten blijken. Ook heeft SQUFOF een grote constante, waardoor de methode als één van de slechtste uit de test komt. CFRAC is ook niet snel op de geteste waarden, maar het lijkt er op dat voor hogere waarden CFRAC het zal gaan winnen. CFRAC haalt al snel alle methodes in behalve Pollard s rho methode. Dit 31

32 Fermat Rho P-1 SQUFOF CFRAC Figuur 3.1: De resultaten van het implementeren van alle methodes behalve delen uitproberen in Mathematica 8.0. komt door de zeer kleine constante van Pollard s rho methode, maar de verwachting is dat CFRAC ook dit uiteindelijk zal winnen. 32

33 Hoofdstuk 4 Discussie 4.1 Keuze van priemgetallen Tijdens de verschillende tests die in Mathematica 8.0 zijn uitgevoerd, is er gekozen om n te genereren door twee willekeurige priemen binnen een bepaald interval te nemen en vervolgens deze twee te vermenigvuldigen. Dit had ook op een andere manier gekund. Zo had ook een willekeurig geheel getal genomen kunnen worden. Eventueel kan dan met behulp van een priemtest bepaald worden of dit getal een priem is. Het nadeel van deze methode is dat er regelmatig een zeer kleine factor in n zal zitten en dat sommige methoden dan zeer snel klaar zijn en andere er juist erg lang over doen. Een andere methode is door te kijken naar getallen van de vorm n = a b ± 1 met a een kleine priem en b een zeker geheel getal. Van vele van deze getallen zijn factorisaties bekend en er kan dan snel worden gekeken waarom n wel of geen factorisatie oplevert (Zogenaamde Cunningham tables). Deze methode zal eerder geschikt zijn om verschillende methodes uitgeprobeerd op wat grotere n te onderzoeken. Maar zal in het algemeen minder goed werken om de snelheid van implementaties te bepalen. 4.2 Andere methodes Er zijn verschillende andere methodes ontwikkeld door de jaren heen. Zo heeft Williams een methode ontwikkeld die eenvoudig factoren vindt als p+1 B-glad is en dus sterk lijkt op Pollard s p-1 methode. Lenstra heeft een methode ontwikkeld die lijkt op Pollard s Rho methode, maar die gebruik maakt van Elliptische krommen en daardoor veel sneller is, maar ook veel 33

34 ingewikkelder. Verder zijn er ook de kwadratische zeef en de getallenlichamenzeef. Deze lijken wat op CFRAC omdat ze ook zoeken naar factoren van de vorm x 2 y 2 (mod n). De getallenlichamenzeef is tot nu toe asymptotisch de snelste methode bekend Elliptische Krommen De Elliptic Curve Methode (ECM) is een methode ontwikkeld door H. Lenstra en lijkt wat op Pollard s rho methode. Hij maakt gebruik van Elliptische krommen en genereert ook getallen waarvan de ggd met n wordt berekend. ECM is asymptotisch veel sneller dan Pollard s rho methode, ECM heeft namelijk een snelheid van O(exp(( 2 + o(1)) log p log log p)). Dit is dezelfde snelheid als CFRAC, maar het verschil is dat ECM afhankelijk is van de kleinste priemfactor p.[5][1] Zeven De kwadratische zeef (QS) lijkt sterk op CFRAC. QS genereert ook getallen in de vorm x y (mod n) met x al een kwadraat en y relatief klein. Het verschil is de manier waarop deze getallen worden gegenereerd. De snelheid van QS is wat sneller dan CFRAC, want de snelheid van QS is O(exp((1 + o(1)) log n log log n)).[1] De getallenlichamenzeef (GNFS) is asymptotisch de snelste methode die nu bekend is. Ook deze methode genereert getallen van de vorm x y (mod n), maar het verschil met CFRAC en QS is dat x nu niet een kwadraat hoeft te zijn. Op zowel x als y wordt nu lineaire algebra toegepast om x 2 y 2 (mod n) te generen. De snelheid van GNFS is O(exp(( o(1))(log n) 1 3 (log log n) 2 3 )) 34

35 Bibliografie [1] Richard Crandall en Carl Pomerance. Prime numbers. Springer, New York, [2] Jason Gower and Samuel S Wagstaff Jr. Square form factorization. Mathematics of Computation, 77: , [3] Donald E. Knuth. The Art of Computer Programming, vol. II: Seminumerical Algorithms 2nd edition. Addison-Wesley, [4] Niels Möller. On Schönhage s algorithm and subquadratic integer gcd computation. Mathematics of Computation, 77: , [5] Samuel S. Wagstaff, Jr. Cryptanalysis of number theoretic ciphers. Chapman & Hall/CRC, Florida, [6] Draisma, J. & Weger, B. Discrete wiskunde Mathematica 8.0 code Op de volgende pagina s is de code van de implementaties in Mathematica 8.0 weergegeven. Het daadwerkelijke programma is iets groter, maar hieronder zijn slechts de relevante functies weergegeven. 35

36 (Debug) In[94]:= (Debug) In[95]:= (Debug) In[96]:= (Debug) In[97]:= FermatSquareMethod a_,b_:1,m_:0,squares_:6 : Module x,y,t,r,i,n, If m 0, n a b;,n m; ; x Ceiling Sqrt a b ; t 2x 1; r x^2 a b; i 0; While IsSquareFast r,squares && i n, r r t; t t 2; i ; ; x t 1 2; y Floor Sqrt r ; If IsSquareFast r,squares, GCD x y,a,gcd x y,a,"not found" IsSquare r_ : Module x,y, If r 0,False, x 2^Ceiling Log 2,r 2 ; y Floor x Floor r x 2 ; While y x, x y; y Floor x Floor r x 2 ; ; x^2 r IsSquareFast r_,n_:6 : Module x,y, If Length SquareList 2^n, GenerateSquareList n ; ; If SquareList Mod r,2^n, x 2^Ceiling Log 2,r 2 ; y Floor x Floor r x 2 ; While y x, x y; y Floor x Floor r x 2 ; ; x^2 r, False GenerateSquareList n_ : Module i,j, j 3; i 1; SquareList ConstantArray False,2^n ; While i 4^n, SquareList Mod i,2^n True; i i j; j 2; ; ; Printed by Mathematica for Students