Random-Getallen Tristan Demont en Mark van der Boor 0768931 en 0772942 18 januari 2013 Begeleider: Relinde Jurrius Opdrachtgever: Berry Schoenmakers Modelleren B, 2WH02 Technische Universiteit Eindhoven 1
Samenvatting Random-numbers are important for simulations nowadays. Random-numbers are generated using a seed and an algorithm. The seed has to be unpredictable and must have a reasonable length. Our goal is to create that seed. First, we have to collect enough data. Then, we have to combine the data so that it gets more compact, but also more random. This gives us a seed. The last part is to verify if this seed is indeed random. Inhoudsopgave 1 Inleiding 3 2 Probleemomschrijving 3 3 Aanpak 3 4 Fase 1: Verkrijgen van gegevens 4 4.1 Gebruikers-input.................................. 4 4.1.1 Aanpak................................... 4 4.1.2 Resultaat.................................. 5 4.2 Systeem-eigenschappen............................... 6 4.2.1 Aanpak................................... 6 4.2.2 Resultaat.................................. 6 4.3 Conclusie...................................... 7 5 Fase 2: Verwerken tot startwaarde 8 5.1 Aanpak....................................... 8 5.1.1 Multiplicatie................................ 8 5.1.2 XOR.................................... 8 5.2 Resultaat...................................... 9 6 Fase 3: Controleren op willekeurigheid 9 6.1 Controle 1...................................... 9 6.2 Controle 2...................................... 10 6.2.1 Aanpak................................... 10 7 Conclusie 11 A Resultaten controle 2 13 2
1 Inleiding In de wiskunde zijn er veel vergelijkingen of problemen die niet theoretisch opgelost kunnen worden. Neem als voorbeeld een wachtrij in een supermarkt. Stel dat er een aantal bedienden zijn, met ieder een eigen rij. Hoe snel moeten deze bedienden werken om de rijen af te werken? Hoe snel moeten zij werken om de rijen kleiner te laten worden, om zo te voorkomen dat de rijen als maar groter worden? Wanneer kunnen de bediende het beste pauze nemen? De theorie voor deze wachtrijen kan al snel erg moeilijk worden. Hiervoor zijn simulaties zeer geschikt. Met een simulatie kan de realiteit snel nagebootst worden, om te achterhalen wat bijvoorbeeld de invloed is van verschillende aantallen kassa s. Een belangrijk element om een goede simulatie te kunnen maken, is willekeurigheid. Zo moet elke mogelijke situatie aan bod kunnen komen in de simulatie, zonder onwaarschijnlijke gebeurtenissen te vaak voor te laten komen. Hier zijn willekeurige getallen voor nodig, die door middel van algoritmes uit een startwaarde worden gegenereerd. Deze startwaarde moet als eigenschap hebben dat hij onvoorspelbaar is; hij moet dus ook een zekere vorm van willekeurigheid hebben. Dit verslag is gericht op het verkrijgen van deze startwaarde. Om deze startwaarde (ook wel seed ) te verkrijgen, zijn gegevens nodig. Deze gegevens worden vervolgens omgevormd tot de benodigde startwaarde. Tenslotte is het belangrijk om te verifiëren of de startwaarde geschikt is. Deze drie aspecten worden uitgebreid behandeld in dit verslag. 2 Probleemomschrijving Het doel van de opdracht is om een voldoende willekeurige startwaarde te kunnen genereren door middel van een applicatie of algoritme. Dit dient op een softwarematige manier gedaan te worden, zoals informatie halen uit type-snelheid, muisbewegingen of de systeemklok. Deze startwaarde dient enkele tientallen bits lang te zijn en mag niet voorspelbaar zijn. Zodra een startwaarde gevonden is, moet er gecontroleerd worden of deze startwaarde willekeurig genoeg is. 3 Aanpak In dit verslag wordt het probleem opgedeeld in drie stappen: Het verkrijgen van gegevens; het verwerken van de gegevens in een startwaarde; het controleren van de gevormde startwaarde. De eerste stap is het verkrijgen van gegevens. Een manier om willekeurige gegevens te verkrijgen is het telkens opwerpen van een munt. Met deze gegevens kan een willekeurige rij bits gevormd worden. Het nadeel van het telkens gooien van een munt is de tijd die ervoor nodig is; er moet een andere manier gevonden worden om snel willekeurige gegevens te verkrijgen. Dit kan op 3
twee manieren. De eerste manier is om de input van de gebruiker te benutten. Dit kan actief, door bijvoorbeeld een getal tussen de 1 en 10 te vragen, maar ook passief, door de bewegingen van de muis te gebruiken. De tweede manier is om gegevens te halen uit de processen van de computer zelf. Zo kan mogelijk de temperatuur of snelheid van de processor op verschillende tijdstippen gebruikt worden. De tweede stap is het omzetten van de verkregen gegevens naar een code. Een mogelijkheid is om de gegevens achter elkaar te plaatsen, om zo één lange rij te creëren. Een andere mogelijkheid is om de gegevens bij elkaar op te tellen of met elkaar te vermenigvuldigen. Ook is het mogelijk om de gegevens te combineren met een zogenaamde exclusive-or functie (XOR functie). Hierbij is het voordeel dat de gegevens gecomprimeerd worden, waardoor er informatie verdwijnt. Dit heeft een goede invloed op de onvoorspelbaarheid. De derde stap is het controleren van de code die in de vorige twee stappen gevormd is. Aangezien de willekeurigheid lastig te controleren is, is hier veel aandacht voor nodig. Beschouw bijvoorbeeld tien muntworpen van een eerlijke munt: als deze tien keer achter elkaar op kop is gevallen, wil dit niet zeggen dat de munt oneerlijk is. Daarom wordt er in fase 3 gekeken of het aannemelijk is dat de verkregen code willekeurig is. Tevens worden de delen van de code die minder willekeurig lijken nog een keer grondig bekeken. 4 Fase 1: Verkrijgen van gegevens In fase 1 wordt getracht om gegevens te verkrijgen. Dit wordt op twee manieren gedaan: door middel van gebruikers-input en door middel van systeem-eigenschappen. 4.1 Gebruikers-input 4.1.1 Aanpak Voor gebruikers-input is gekozen om de gebruiker lijnen te laten tekenen. Vooralsnog wordt dat door middel van een apart programma gedaan. Mocht deze methode toegepast worden, dan is het mogelijk om dit programma op de achtergrond te laten lopen, om zo de gebruiker onbewust gegevens te laten creëren. Zo zou het verplaatsen van een map of het maken van een tekening equivalent zijn met het herhaald tekenen van verschillende lijnen. Een voorbeeld van lijnen die met het programma gemaakt kunnen worden, is te zien in figuur 1 op pagina 5. Hierbij zijn de rode lijnen verbindingslijnen tussen twee getekende lijnen. In het tekenprogramma is het de bedoeling dat de gebruiker drie lijnen tekent. Alvorens de eerste lijn wordt getekend, kan de muis al bewogen worden. Er worden dus zes lijnen opgeslagen: drie lijnen waarbij de muis niet is ingedrukt en drie lijnen waarbij de muis wel is ingedrukt. De lijn waarin de muis niet is ingedrukt wordt telkens samengevoegd met de lijn waarbij de muis wel is 4
Figuur 1: Voorbeeld van een te tekenen lijn. ingedrukt. Uit deze lijnen kunnen veel gegevens gehaald worden. Hieronder staat een overzicht van de eigenschappen die hiervoor zijn gebruikt: Het totaal aantal pixels bewogen tussen het loslaten van de muis; het aantal pixels bewogen tussen het indrukken en loslaten van de muis; de lengte van de rechte lijn tussen het punt waarop de muis is ingedrukt en het punt waar de muis is losgelaten; de totale tijd om een lijn te tekenen in milliseconden; de tijd waarin de muis ingedrukt was in milliseconden; de hoek waarmee de muis is vertrokken na het indrukken van de muis. Elke type gegevens kan drie keer bepaald worden, aangezien er drie verschillende lijnen getekend worden. Naast deze eigenschappen zijn er nog veel meer mogelijkheden om gegevens te verzamelen. Zo zouden de lijnen opgedeeld kunnen worden in zogenaamde splines: lijnstukjes die een benadering geven van de getekende lijn. Deze hebben zelf weer verschillende eigenschappen. 4.1.2 Resultaat Een voorbeeld van de resultaten is te zien in de code op de volgende pagina. 5
Pixels bewogen : 2274 1146 1528 Pixels gesleept: 884 965 1176 Netto bewogen : 301 459 433 Totale tijd : 3130660633 1673360745 2270461696 Tijd ingedrukt : 1196963806 1471054963 1953298799 Hoek na klik : 6209 6408 8071 Hierbij representeren de eerste, tweede en derde kolom getallen respectievelijk de verkregen waarden van de eerste, tweede en derde getekende lijn. 4.2 Systeem-eigenschappen Naast het verkrijgen van gegevens door middel van gebruikers-input, is het ook mogelijk om systeem-eigenschappen te gebruiken. Een voordeel hiervan is dat de gebruiker geen actie hoeft te ondernemen. 4.2.1 Aanpak Het idee is om door middel van een programma de computer een moeilijke berekening of actie te laten ondernemen, waarbij gemeten wordt hoe lang dit duurt. Er wordt verwacht dat de gemeten tijd niet of nauwelijks varieert en dat hier dus nauwelijks pseudo-willekeurige gegevens uit gehaald kunnen worden. Het programma laat de computer 1.000 keer de cijfers 1 tot en met 10.000.000 optellen. Hierbij berekent de computer dus eigenlijk 1.000 keer deze som: 10.000.000 i=0 i (1) Er wordt gemeten hoe lang de computer erover doet om de sommen te bepalen. Bij de berekeningen wordt er gebruik gemaakt van meerdere threads in java, die ervoor zorgen dat alle processoren in de computer gebruikt worden. In figuur 2 is te zien hoe elke processor afzonderlijk zich gedraagt bij het herhaaldelijk uitvoeren van het programma. Hierbij zijn de toppen tijdens de berekeningen en de dalen tijdens de pauzes. Deze pauzes zijn er om de processoren te laten rusten, zodat de vorige berekening minder invloed heeft op de volgende berekening. 4.2.2 Resultaat In figuur 3 is een histogram te zien van de duur van de berekeningen. De verdeling lijkt in eerste instantie op een normale verdeling, waarbij het mogelijk is om de verkregen getallen om te zetten naar een uniforme verdeling. Er zijn echter een aantal problemen die dit moeilijk maken. Zo lijkt het namelijk alsof het gemiddelde (wat ongeveer op 5 seconden ligt) minder vaak voorkomt. Ook 6
Figuur 2: Overzicht van het processorgebruik. Figuur 3: Histogram van de duur van de berekeningen in nanoseconden. valt op dat er drie resultaten zijn die enorm afwijken ten opzichte van de rest. Dit komt wellicht door het verkeerd uitvoeren van berekeningen, waardoor de duur van deze drastisch verminderd zijn. 4.3 Conclusie Er zijn twee manieren genoemd om gegevens te verkrijgen: de eerste manier is het tekenen van lijnen, de tweede manier is de computer berekeningen laten doen. Hoewel beide manieren geschikt zijn om startwaarden te creëren, is er gekozen om enkel de eerste manier te gebruiken. Een andere reden om de eerste manier te gebruiken, naast de complicaties die de tweede methode geeft, is de mogelijkheid om na te gaan wat er is gebeurd. Bij 1000 berekeningen in 5 seconden 7
is dit een stuk lastiger. 5 Fase 2: Verwerken tot startwaarde 5.1 Aanpak In deze fase wordt aangenomen dat de gegevens die nodig zijn al verkregen zijn. Neem als voorbeeld de gegevens op pagina 6. Om deze gegevens om te zetten naar een geschikte startwaarde, is een goed werkend algoritme nodig. We behandelen twee algoritmes om de gegevens samen te voegen. De eerste is multiplicatie en de twee is het gebruik van de exclusive-or operatie (XOR operatie). 5.1.1 Multiplicatie Het eerste idee is om alle gegevens met elkaar te vermenigvuldigen. Hierbij worden alle niet-0 gegevens met elkaar vermenigvuldigd, zodat één groot getal ontstaat. Dit getal kan vervolgens weer omgezet worden naar een binair getal. Deze methode brengt veel nadelen met zich mee. Ten eerste bevat het uiteindelijke getal veel factoren 2. Hierdoor wordt de binaire code minder willekeurig, aangezien er dan evenveel 0 en achter de code staan als het aantal factoren 2. Als hiermee rekening gehouden moet worden, dan zouden telkens de 0 en aan het eind van de code verwijderd moeten worden. Ten tweede is vermenigvuldiging niet goed voor de onvoorspelbaarheid. Zo is bijvoorbeeld 91 het product van 5 en 13. In het algemeen is elk getal een product van priemfactoren, waardoor de startwaarde onbedoeld geraden kan worden. Deze twee nadelen zorgen er onder andere voor dat de multiplicatiemethode zeer ongeschikt is om gegevens te combineren. 5.1.2 XOR Bij de exclusive-or operatie worden twee bits omgezet naar één bit. Zodra een van beide bits een 1 is en de ander een 0, dan is de output een 1. Zodra beide bits 1 of 0 zijn, dan is de output 0. Beschouw hiervoor de volgende waarheidstabel: Input A Input B Output 0 0 0 0 1 1 1 0 1 1 1 0 Als één van beide bits willekeurig is, maar de andere bit niet, dan is het resultaat toch willekeurig. Dit wordt getoond aan de hand van een voorbeeld: Beschouw twee codes A en B. Neem aan dat A willekeurig is, bijvoorbeeld 1100010, en neem aan dat B niet willekeurig is en bestaat uit 1111111, onafhankelijk van A. Het resultaat van de XOR operatie is dan ook willekeurig, zoals te zien in de tabel op de volgende bladzijde. 8
5.2 Resultaat A 1 1 0 0 0 1 0 B 1 1 1 1 1 1 1 A XOR B 0 0 1 1 1 0 1 De exclusive-or operatie wordt vervolgens toegepast op de gegevens die verkregen zijn na uitvoering van fase 1. Neem hiervoor weer als voorbeeld de gegevens op pagina 6. Ten eerste worden de gegevens omgezet naar binaire getallen, waarna ieder eerste cijfer wordt weggehaald. Dit levert zes keer drie binaire getallen, waarbij ieder eerste getal (A) hoort bij de eerst getekende lijn, ieder tweede getal (B) bij de tweede lijn, en ieder laatste getal (C) bij de laatste lijn. Vervolgens worden A, B en C gecombineerd met de XOR operatie met behulp van de functie (A XOR B) XOR C. De zes verkregen resultaten worden tenslotte achter elkaar gezet om de startwaarde te creëren. Het resultaat van het voorbeeld is hieronder te zien. Pixels bewogen : 011110111 Pixels gesleept: 10010111 Netto bewogen : 0111110 Totale tijd : 11111001001010110000100100101 Tijd ingedrukt : 01010110000001100111100011010 Hoek na klik : 11010001010 Startwaarde : 0111101111001011101111101111100100101011000010-01001010101011000000110011110001101011010001010 6 Fase 3: Controleren op willekeurigheid In de laatste fase worden de gegenereerde startwaarden getest op willekeurigheid. Het doel van deze test is om de aannemelijkheid te verifiëren dat de verkregen startwaarde uit fase 2 willekeurig genoeg is. Hierbij worden er twee controlemethodes toegepast op de startwaarden. De eerste methode heeft als doel om aan te tonen dat de gegenereerde startwaarden willekeurig lijken. De tweede methode dient ervoor om eventuele onwillekeurigheden op te sporen en toe te lichten wat hiervan de oorzaak is. 6.1 Controle 1 Bij de eerste controlemethode wordt er een grafische weergave getoond van 200 startwaarden. De startwaarden worden achter elkaar gezet. Elke 1 wordt een zwart stipje en elke 0 wordt een wit stipje. Op deze manier wordt het plaatje in figuur 4 op pagina 10 verkregen. In deze figuur zijn geen opmerkelijkheden te zien. Zo is geen van de twee kleuren in de meerderheid of is er een herhalend patroon te zien. Deze methode is echter enkel om merkwaardigheden op te sporen; niet alle patronen zijn immers te herkennen in een plaatje. 9
6.2 Controle 2 Figuur 4: Grafische weergave van de startwaarden. De tweede controlemethode maakt gebruik van betrouwbaarheidsintervallen. Met deze methode is het eenvoudig om afhankelijkheden tussen verschillende startwaarden te ontdekken. 6.2.1 Aanpak Voor deze controlemethode zijn 60 verschillende startwaarden gegenereerd van lengte 77, ofwel met 77 indexen. Vervolgens wordt op iedere index gekeken hoeveel enen en nullen er voorkomen. Het 90% betrouwbaarheidsinterval voor een binomiale verdeling voor n = 60 en p = 1/2 is [24, 36]. Uit het histogram van figuur 5 is af te lezen dat van de 77 resultaten, er 71 binnen het betrouwbaarheidsinterval liggen. Aangezien dit dicht bij de 90% ligt, is het aannemelijk dat het aantal nullen en enen in de startwaarden goed verdeeld is. Naast enkel naar de 0 en en 1 en apart te kijken, wordt er ook gekeken hoe vaak een bepaalde combinatie voorkomt. Als voorbeeld wordt de combinatie 10 genomen, waarvoor het histogram van figuur 6 wordt verkregen. In deze situatie is het 90% betrouwbaarheidsinterval [10, 21]. Hierbij bevinden zich 68 van de 76 resultaten binnen het interval, hetgeen ook dicht bij de 90% ligt. In de appendix op bladzijde 13 staan alle resultaten van dit onderzoek. 10
Figuur 5: Aantal indexen waarop i keer een 0 voorkwam. 7 Conclusie Figuur 6: Aantal indexen waarop i keer de combinatie 10 voorkwam. In de eerste fase van het verslag is geprobeerd om veel pseudo-willekeurige gegevens te verzamelen. Hoewel de systeemeigenschappen problemen vertoonden, verschafte de gebruikers-input 11
voldoende gegevens. Vervolgens werden de gegevens gecombineerd. Dit is allereerst geprobeerd met behulp van multiplicatie, maar bleek geen goed idee te zijn. Een betere manier om gegevens te combineren is door middel van exclusive-or operaties. Hiermee werd een uiteindelijke startwaarde gegenereerd die willekeurig genoeg was. Als laatste is er een controle uitgevoerd. Allereerst is er geprobeerd om een controlemethode te bedenken die zou beslissen of een startwaarde wel of niet willekeurig was. Hieraan waren twee dingen onjuist: ten eerste bestaat er geen manier om uit te sluiten dat een startwaarde wel of niet willekeurig is, ten tweede is het beter om het algoritme te testen die de startwaarden genereert. Daarom is de controlemethode veranderd, waarbij nu het algoritme wordt getest en gezocht wordt naar vreemde eigenschappen van de gegenereerde startwaarden. Zo zal de controlemethode bijvoorbeeld direct herkennen wanneer er in het algemeen meer 0 en dan 1 en voorkomen. De algemene conclusie is dat het genereren van een startwaarde goed mogelijk is met behulp van gebruikersinput. Verder is het omzetten van de gegevens naar een startwaarde niet moeilijk. Het lastige deel van de opdracht is de controle, aangezien het niet mogelijk is om met zekerheid willekeurigheid vast te stellen. 12
A Resultaten controle 2 Tabel 1: Aantal keer dat een index buiten het interval ligt. Combinatie Aantal indexen Betrouwbaarheidsinterval Aantal buiten interval 0 77 [24,36] 6 1 77 [24,36] 6 00 76 [10,21] 5 01 76 [10,21] 7 10 76 [10,21] 8 11 76 [10,21] 5 000 75 [4,12] 7 001 75 [4,12] 6 010 75 [4,12] 4 011 75 [4,12] 5 100 75 [4,12] 6 101 75 [4,12] 8 110 75 [4,12] 8 111 75 [4,12] 8 0000 74 [1,7] 1 0001 74 [1,7] 3 0010 74 [1,7] 6 0011 74 [1,7] 9 0100 74 [1,7] 4 0101 74 [1,7] 5 0110 74 [1,7] 5 0111 74 [1,7] 4 1000 74 [1,7] 2 1001 74 [1,7] 3 1010 74 [1,7] 2 1011 74 [1,7] 3 1100 74 [1,7] 4 1101 74 [1,7] 2 1110 74 [1,7] 6 1111 74 [1,7] 1 *Deze tabel gaat door op de volgende pagina 13
Combinatie Aantal indexen Betrouwbaarheidsinterval Aantal buiten interval 00000 73 [0,4] 1 00001 73 [0,4] 5 00010 73 [0,4] 3 00011 73 [0,4] 4 00100 73 [0,4] 4 00101 73 [0,4] 6 00110 73 [0,4] 5 00111 73 [0,4] 3 01000 73 [0,4] 1 01001 73 [0,4] 2 01010 73 [0,4] 1 01011 73 [0,4] 4 01100 73 [0,4] 2 01101 73 [0,4] 3 01110 73 [0,4] 1 01111 73 [0,4] 3 10000 73 [0,4] 3 10001 73 [0,4] 3 10010 73 [0,4] 4 10011 73 [0,4] 5 10100 73 [0,4] 3 10101 73 [0,4] 2 10110 73 [0,4] 4 10111 73 [0,4] 3 11000 73 [0,4] 4 11001 73 [0,4] 1 11010 73 [0,4] 4 11011 73 [0,4] 0 11100 73 [0,4] 6 11101 73 [0,4] 2 11110 73 [0,4] 4 11111 73 [0,4] 0 14