Home


          BulletProof

Welcome -

Congratulations!   Welcome to BulletProof Random Number Generation Software!

BulletProof is a most fundamental and therefore simple and easily understood random number generation software package.   With this software you can generate as many random numbers as you could ever imagine and they cannot be practicably reproduced without the key.

Although the random number generation process can be described mathematically, it does not use any mathematical formulas to generate the random numbers.   All the processes are unbiased and require true random user input:   the key.   The only way to reproduce the random numbers without the key is by brute-force trial and error.  

No matter how secure any existing random number generation software is today or will be tomorrow, with BulletProof you can always create random numbers that are practicably just as secure or more secure.   This is because the key length with BulletProof is unlimited.

My system:

Intel Core i7 - 3930K CPU @ 3.2GHz (overclocked to 3.8GHz)
ASUS P9X79 WS Motherboard
64GB DDR3 RAM (BulletProof requires 2GB)
NVIDIA Geforce GTX 670 graphics card
2 solid state drives (500GB / 250GB)
2 4TB hard drives

Microsoft Windows 7 Professional 64-bit
Windows Experience Index 7.8 of 7.9

ImDisk Virtual Disk Driver freeware to create a RAM drive

BulletProof is stand-alone software.   That is, it makes no entries in your Registry nor adds or changes any .sys, .inf, .cfg, etc. files.   Simply copy it to your hard drive and run it.   To uninstall simply delete it.   Save and back it up.   Keep two external copies.   You may well be glad you did in the future.

Modules included:

AutoFile Creation
Multi-MixFile(X) Shuffle
Multi-RandOut(X) Shuffle

AutoFile Read and Execute
Auto-Execute AutoFile

Random Number Generation
Random Binary Number Generator

Utility Programs
Multi RandOut(X)s (AutoFile)
ReName File (AutoFile)
Number Binary Files (AutoFile)
File Split
File Split Append
Button Rows Random Number
Two-Array Random Number Scramble
Additional Utility Programs
Read Binary File
BCD to Decimal Array Conversion
Binary to Decimal Conversion
Binary Number String Statistics
Random Binary Number Statistics
Test Files Generation

Help Files
Welcome to BulletProof
The Grand Theory
The Mother of All Tutorials

License Agreement

This software is protected by International Copyright Laws.

2010 All rights reserved.

BULLETPROOF - THE GRAND THEORY

The primary goal of the BulletProof random number generation software is to generate random numbers such that the prediction of any given random number is just as likely to be any of all the random numbers possible.

Imagine a new deck of standard playing cards with four suits Ace through King.   They come out of the box nicely sequenced.  Now shuffle them several times.   It would be difficult to guess their order.   But you might already know that there are a finite number of possibilities for all possible combinations of these cards.   There are 52! (fifty-two factorial) possible orderings for this one deck of fifty-two playing cards.   That is 52! = 8.07E67 or a number beginning with an 8 followed by 67 zeros.   This is a very large number.

The definition of the factorial by example:   3! = 3 * 2 * 1 = 6.   5! = 5 * 4 * 3 * 2 * 1 = 120.   10! = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 = 3,628,800.

Here is proof.   Let's say we use this deck of cards again.   But we just use one card, say, the Ace of diamonds.   There is 1! = 1 possible way to order the sequence of a single card.   Let's use the Ace and 2 of diamonds.   There are 2! = 1 * 2 = 2 possible ways to order two cards:   1,2 and 2,1.   Let's use the Ace, 2, and 3 of diamonds.   There are 3! = 1 * 2 * 3 = 6 possible orderings:   1,2,3 & 1,3,2 & 2,1,3 & 2,3,1 and 3,1,2 and 3,2,1.   Our last example is with the Ace, 2, 3, and 4 of diamonds.   There are 4! = 1 * 2 * 3 * 4 = 24 possible sequences:   1,2,3,4 & 1,2,4,3 & 1,3,2,4 & 1,3 4,2 & 1,4,2,3 & 1,4,3,2 & 2,1,3,4 & 2,1,4,3 & 2,3,1,4 & 2,3,4,1 & 2,4,1,3 & 2,4,3,1 & 3,1,2,4 & 3,1,4,2 & 3,2,1,4 & 3,2,4,1 & 3,4,1,2 & 3,4,2,1 & 4,1,2,3 & 4,1,3,2 & 4,2,1,3 & 4,2,3,1 & 4,3,1,2 & 4,3,2,1.   It will be the same if you have 14 cards or 52 cards.

Now imagine a similar deck but comprised of 3,628,800 unique cards.   Now shuffle these hundreds of times.   There are 3,628,800! = (approx.) 1E22,000,000 possible orderings of the deck or a number beginning with a one followed by twenty-two million zeros.   This is a staggeringly large number.  

Imagine taking three such decks and shuffling each one several hundreds of times.   Then shuffle all three decks together several hundreds of times.   Next, divide all 10,886,400 cards back into three equally large decks and place each deck face down.   Can you guess the order of each stack?   There is well over 1E66,000,000 (or well over a number beginning with a one followed by sixty-six million zeros) possible orderings for all these cards.

Exactly where might these 3,628,800 cards come from and what makes each card unique?   Imagine that I have printed on each card one of the possible ten-digit permutations of the digits 0 - 9 with no repeats.   For instance:   0123456789, 0123456798, 0123456879, etc.   Because there are ten unique digits in each sequence there are 10! possible permutations of the digits 0 - 9 with no repeats:   10! = 3,628,800.

To begin the process that will ultimately generate the BulletProof random numbers, three files containing 3,628,800 ten-digit permutations of the digits 0 - 9 with no repeats are required.   They will be called MixFile101.otp, MixFile102.otp, and MixFile103.otp.   Each of these files must be thoroughly shuffled.   That is to say, the permutation order must be randomly rearranged in each file.

Here is why these three randomly sequenced MixFile10X.otp files are needed.   The following describes the heart of the random number generation process:   the random number generator engine.   (Keep in mind that when this process is completed you are only half way to generating the final useable random numbers.)

(Run two instances of this software.   Examine the table below in one instance while continuing to read the tutorial in the other instance.)

 MixFile101      MixFile102     MixFile103      Set4                 Set5              Num

0473265981    7098345126    6210458397    3679045218    6430185792    5
1349862705    5416732809    1265983074    8923056714    2594736018    5
6342571098    7153062498    8640321957    9620814375    1034296875    0

9021836547    6084795132    6279503481    3685410297    1672893054    8
0765123948    8729036415    4291608753    5793418620    4780291365    9
5241768093    9210873645    2365840791    1632975084    4683709215    1

1207968543    1275369480    9375860412    3746502819    3794201685    7
8472319506    8521370964    9712354680    8517269043    8361270594    6
5879436102    3470298651    0295174683    5160938472    7863154209    5

1368079425    0369785241    1392468057    1287056943    3285107496    6
1968247503    8295613047    3196754820    2905416378    1042978536    9
0814957236    1364502987    8017256934    0762581439    8302459176    2

Columns MixFile101, MixFile102, and MixFile103 are MixFile101.otp, MixFile102.otp, and MixFile103.otp, respectively.   They are shown above containing the first twelve permutations of the digits 0 - 9 from typical thoroughly shuffled MixFile10X.otp files.

It is said that each ten-digit array has ten elements or locations where a single digit is stored.   The elements are numbered from left to right:   0 - 9.   The first element is element zero, the second element is element one, the next is element two, etc.

Let's look just at the first row of ten-digit arrays above.   Set4 is derived by using MixFile102 to index or transform MixFile103.   This is done by taking the digit stored in element zero of MixFile102, which is the digit 7, and using this to index MixFile103 by going to element seven in MixFile103, which is the eighth element from the left in MixFile103.   The digit stored in element seven in MixFile103 is the digit 3.   So element zero in Set4 is made a 3.

Next we take the digit stored in element one of MixFile102, which is the digit 0, and use this to index MixFile103 by going to element zero in MixFile103, which is the first element from the left in MixFile103.   The digit stored in element zero in MixFile103 is the digit 6.   So element one in Set4 is made a 6.

Again we take the digit stored in element two in MixFile102, which is the digit 9, and use this to index MixFile103 by going to element nine of MixFile103, which is the tenth element from the left in MixFile103.   The digit stored in element nine in MixFile103 is the digit 7.   So element two in Set4 is made a 7.   This process is continued until all ten digits are accounted for in Set4.

This same process is used to derive Set5 but by using MixFile101 to index MixFile103 instead of using MixFile102 as was done when MixFile102 was used to index MixFile103 to derive Set4.

This is all very simple.   Just relax and take it one step at a time.   But don't worry.   The computer and software does all this work for you.

Finally, the three digit groups placed vertically in the Num column are derived from Set4 and Set5.   The idea is similar in that Set5 is used to index Set4.   But the process is a little different.   Here is how we will index Set5 as we go down each row.   (Keep in mind that each row is also numbered from 0 - 3,628,799 going from top to bottom.)

In row zero, Set5 is indexed at element zero where we find the digit 6.   In row one, Set5 is indexed at element one and we find the digit 5.   In row two, Set5 is indexed at element two and we find the digit 3. This process continues as we go down the rows incrementing to the right by one the indexing of Set5.   After we have indexed row nine, we then go on to row ten and we then go back and index Set5 at element zero again and proceed across Set5 as before as we go down each row.   It is sort of like a typewriter action at the end of a typed line where we make a carriage return and start back at the beginning of a new line.

Now let's go back to row zero again.   We indexed Set5 at element zero and found the digit 6.   So we then use this digit 6 to index Set4.   Element 6 in Set4 is the digit 5.   This is the first digit in the Num column in row zero.   We indexed Set5 in row one at element one and found the digit 5.   So we then use this digit 5 to index Set4.   Element 5 in Set4 is the digit 5.   This is the second digit down in the Num column in row one.   We indexed Set5 in row two at element two and found the digit 3.   So we then use this digit 3 to index Set4.   Element 3 in Set4 is the digit 0.   This is the third digit down in the Num column in row two.

It is this simple.   And all this tedious work is done by the computer and software.   But if we go down all 3,628,800 rows we only get 3,628,800 digits or 1,209,600 triplets.   So, exactly how can BulletProof generate 1E27 random digits from any three MixFile10X.otp files?

After these 3,628,800 rows have been processed in the above manner, MixFile103 is rotated one row up while MixFile101 and MixFile102 remain fixed.   (See table below)   Then all 3,628,800 rows are processed again as just described.   You can see that entirely different digits are produced in the Num column.   (See table below)

 MixFile101      MixFile102     MixFile103      Set4                 Set5              Num

0473265981    7098345126    1265983074    0147598263    1905638472    1
1349862705    5416732809    8640321957    2361904587    6037514982    2
6342571098    7153062498    6279503481    4209637518    3957042618    3

9021836547    6084795132    4291608753    8456730219    3492518067    5
0765123948    8729036415    2365840791    9761250834    2704365189    1
5241768093    9210873645    9375860412    2739145086    6783401925    2

1207968543    1275369480    9712354680    7165240389    7196048532    8
8472319506    8521370964    0295174683    8792560341    8169523704    3
5879436102    3470298651    1392468057    2401975863    6507428319    4

1368079425    0369785241    3196754820    3640825971    1642380795    2
1968247503    8295613047    8017256934    3145607829    0463129587    3
0814957236    1364502987    8632947510    6279483015    8169045327    2

As you may have already guessed, MixFile103 can be rotated incrementally 3,628,800 times.   So now we can generate (3,628,800)^2 = (approx.) 13 trillion digits.   Imagine that MixFile101, MixFile102, and MixFile103 can each be rotated just like the odometer in an automobile.   We can then generate 3,628,800^4 = approx.  1.73E26 random digits.  

We are using 3 input columns.   These three columns can be arranged in 6 different orderings.   In practice this would be done by appropriately changing the names of the MixFile10X.otp files.   (See below)

MixFile101 MixFile102 MixFile103
MixFile101 MixFile103 MixFile102
MixFile102 MixFile101 MixFile103
MixFile102 MixFile103 MixFile101
MixFile103 MixFile101 MixFile102
MixFile103 MixFile102 MixFile101

By rotating the three MixFile columns and by reordering them, a continuously changing random number stream can be produced using the described process above.   So now we can generate 6 * (3,628,800)^4 = (approx.) 1040 trillion trillion = 1E27 random digits!

All right!   So we can generate about 1E27 random digits or about 3E26 random triplets.   Each triplet is from 000 - 999.   But the software generates binary triplets from 0 - 255 which are 256 numbers.   You can see that 256 does not divide evenly over this range of a thousand numbers.   This means that if all 1000 triplets are used, some of the numbers calculated from these triplets would not occur with approximately equal frequency.   The solution to this problem is simple.

The software only uses the triplets from 000 - 767.   Triplets greater than 767 are discarded.   The calculation divides any triplet from 000 - 767 by 3.   But the computer divide function truncates the remainder.   This is perfect.   Thus the resulting numbers from this division are from 0 - 255.   Thus BulletProof can generate about 2.66E26 random binary numbers from 0 - 255 for any given three MixFile10X.otp files.

So far so good.   But what about the frequency of these calculated numbers from 0 - 255?   Can we be sure that each of these numbers has just as much chance of being calculated as any other?   Well, we know that the calculation itself does not inject any bias.

But what about the process of generating the random digits?   As you have seen, there is no inherent bias entered into the process from the routines of indexing, rotating, or swapping the columns.   So, we are forced to focus our attention on the "randomness" of the orderings of the sequences in each of the MixFile101, MixFile102, and MixFile103 columns themselves.

There is just one process that shuffles MixFile10X.otp files singly or any 2 - 14 together.   This process requires true random user input.   The random input required is a sequence of the numbers from 1 - (any number up to) 14 with no repeats.   Here are two practicable solutions to your random number needs.

Get two decks of standard playing cards.   Each deck has four suits from Ace - King and two Jokers.   Take two jokers from one deck and place them in the other deck.   With a pen assign one of the four suits to each Joker.   So now you have one deck with 56 cards with four suits and 14 cards per suit.

Shuffle this deck several times using several different methods.   Then take each card from the top of the deck and place it in the order revealed according to suit.   This will give you four sequences of the numbers 1 - 14 where the Jack is equivalent to eleven, the Queen is equivalent to twelve, the King is equivalent to thirteen, and the Joker is equivalent to fourteen.   If you need a sequence with less numbers, just ignore the cards that you don't need in each sequence.

My preferred method is to get 14 pennies and number each one from 1 - 14.   Place them is a container and shake them up.   Then withdraw each numbered penny one at a time to obtain the random sequence.

Now, back to the question of determining whether any bias is introduced effecting the frequency or distribution of the generated random digits from the BulletProof shuffling process that randomly orders the ten-digit permutation arrays in each MixFile10X.otp file.  

Here's what's happening when you shuffle a single MixFile10X.otp file.   The file named as input is read seqentially into 14 arrays with 1,296,000 elements in each.   The first array is filled then the next then the next, etc.

The output file is created by taking one BCD permutation from each of the 14 arrays with each permutation taken in the order of the user random input.   Assume this is your random sequence:   7,4,8,1,10,2,14,13,9,3,5,11,12,6.   Array7 would be chosen first then one permutation read from it and written to the output file.   Array4 would be chosen next and one permutation read from it and written to the output file.   Then Array8, Array1, Array10, etc.   Each array is chosen according to the user true random number sequence input and a BCD permutation read and written until all arrays have been read and the shuffled MixFile10X.otp file is generated.

Here's the overall BulletProof method:   with three thoroughly shuffled MixFile10X.otp files, generate RandOut10X.otp random number files.   Then thoroughly shuffle these RandOut10X.otp files.   The RandOut10X.otp random binary number files are shuffled exactly the same way as the MixFile10X.otp files except that they are shuffled on a 1-byte basis whereas the MixFile10X.otp files are shuffled on a 5-byte basis, since each ten-digit permutaion of the digits from 0 - 9 with no repeats are compressed into a 5-byte BCD format.

For your information there are 14! possible combinations of the integers 1 - 14.   That is, fourteen factorial which is defined as:
1 x 2 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x 11 x 12 x 13 x 14 = 87,178,291,200.

This means that since you generated the 14 number sequence randomly that there is no way anyone can reproduce your number sequence.   The best they can do is generate all 14! possible permutation sequences and conclude that they can be certain that one of them is the one you generated.

Las Vegas!   That got your attention.   Here is how to calculate odds or mathematical probabilities.   The game of Craps uses matched die with six sides effectively numbered 1 - 6.   So the odds of any one side coming up is one in six:   1/6.   If two die are considered the odds of, say, two sixes coming up are 1/6 * 1/6 = 1/36 or one in thirty-six.   The idea here is that you determine the odds for a single event then multiply these odds together for the number of occurrences of the single event being considered.

Let's say you shake your pennies and generate another random 14 number sequence and repeat this shuffle process on your output file.   And you do this 100 times in total on each successive output file.   This means that your final MixFile10X.otp file will be just one of a possible (14!)^100.   If 87,178,291,200 is approximately 87E9 then (14!)^100 is about (87E9)^100 or about (87)^100 x 10 ^ 900.   Let's do a back-of-the-napkin approximation and just say that 87 is close to 100 = 10^2, so we have 10^200 x 10^900 which is about 10^1100 or a 1 with 1100 zeros after it.   That means that someone would have to generate this many 14-number sequences and all they would be able to say with certainty is that one of them is the one you generated.   But which one?

Now let's say the fastest computer imaginable let alone in use does 12 trillion trillion flops (floating point operations per second).   That is a 12 with 24 zeros after it.   Let's round that off to 1E25.   That means if you divide this number into (14!)^100 it would take 10^1075 seconds to generate every possiblity.   The universe will have reached Absolute Zero by that time.  (31536000000 secs = 3.13E10 seconds in a thousand years or about 3E13 seconds in a million years or 3E16 seconds in a billion years...)

As you have seen, the shuffle process treats each MixFile10X.otp file (and RandOut10X.otp file) equally and proportionately.   That is, the process performs all manipulations on every aspect of the files with no bias.   The process merely executes the algorithm as programmed with the only variables being the user true random input.

If any bias is to be introduced into the final results, that is, if any bias is to become apparent in the final random number files generated, it would be due strictly and solely to the user true random input.   But if the user inputs truly random number sequences into an unbiased process as I suggested, in general, no bias should be evident in the final output:   the final useable random number files.

Nevertheless, as when shuffling a deck of cards, the cards may bunch up in short series that are not representative of "random" orderings although they may have gotten in this sequence by random processes.   For instance, if you shuffle a deck several times the frequency of certain cards may appear unusually high in a certain location within the deck.   But if you shuffled this deck many different times, in general, this distribution would not appear often at all.

As you now know, the basis for this random number generation software is solely byte manipulation determined by unbiased processes using true random input.   No mathematical equations are used whatsoever in creating "randomness."   Therefore you know that there can be no mathematical transformation of such an equation or a mathematical technique capable of trivializing the reproduction of the random numbers generated using this software.

The object of the BulletProof software is to provide users with the means to generate random numbers that cannot be reproduced without the original key.

BULLETPROOF - THE MOTHER OF ALL TUTORIALS

PART ONE

In this tutorial I will show you not only how to operate the BulletProof Random Number Generator software package in its entirety but also show you how to prove beyond any doubt that the software operates exactly as described.   On the main form of every program module is an Instruction button where you can get specific Help for that module.

My 32-bit OS is Windows XP Professional SP2.   The instructions I give will be compatible with this OS.   2GB of RAM should be enough as long as you don't run too many other programs simultaneously.

Designate a BulletProof work folder.   Place a copy of BulletProof.exe in this folder.   The BulletProof folder should have 5GB of free space available.   I also recommend that this folder be placed in a seperate partition other than your C:\ partition because you may occassionally want to reformat this partition.

As you work through The Mother of All Tutorials, you will probably have your work folder open along side of the running BulletProof software.   In the work folder you will see files being created, deleted, rewritten, etc.   Sometimes it will appear that a file does not have the expected size.   You then need to refresh the folder contents:   View -> Refresh and that will correct the discrepancy.

Whenever any program module from the BulletProof software is used with regard to random binary number generation, any associated files must be in the same folder along with BulletProof.exe.   These files are:   AutoFile.otp, MixFile.otp, MixFile10X.otp, and RandOut10X.otp.

In order to run the Random Binary Number Generator Utility Program, you need to provide it with three thoroughly shuffled MixFile10X.otp files:   MixFile101.otp, MixFile102.otp, and MixFile103.otp.   These files are created by shuffling the original data MixFile.otp file consisting of the 3,628,800 unique permutations of the digits from 0 - 9 with no repeats in ascending order:   0123456789, 0123456798, 0123456879, 0123456897, 0123456978,...   9876543102, 9876543120, 9876543201, 9876543210.

To create the original data MixFile.otp file, start the BulletProof software and go to:   AutoFile Creation -> MixFile Processing.  Check the box directly below the 0-button.   Now click the 0-button.   Now click the Write button.   This operation creates the AutoFile.otp file and writes the instruction to generate the original data MixFile.otp file to it.

All of the Multi-MixFile(X) Shuffle routines are written to this AutoFile.otp file.   When you are through writing all of your instructions this file will constitute your initial key describing the processes to creating your three thoroughly shuffled MixFile10X.otp files.   At that point, you will run the Auto-Execute AutoFile Utility Program that will automatically batch execute sequentially each instruction in the AutoFile.otp file.

Double-click AutoFile.otp.   It should open in NotePad.   All you will see is "15." When this instruction is read by the Auto-Execute AutoFile routine, the function 15 tells it to generate the original data MixFile.otp file.   Close AutoFile.otp.

Back in the Multi-MixFile(X) Shuffle program, click the Continue button.   Check the box directly below the 1-button.   When only the 1-button box is checked, this tells the program that the input file is MixFile101.otp.   If you had checked the box under the 2-button then the input file would have been MixFile102.otp.   Click the 1-button.   This tells the program that you are finished checking boxes.   And in this case you are only inputting a single MixFile10X.otp file and that file is the MixFile101.otp file.

Enter the following true random number sequence by clicking the buttons in this order:   11 1 9 10 14 6 12 5 3 8 2 4 7 13.   Click the Write button.   Here is the one exception:   since we are just beginning the shuffling of the MixFile.otp file for the first time:   beginning from scratch, we need to change the actual input file to MixFile.otp.   Do so at the top of this file picker form by checking the input radio button next to MixFile.otp.   Also check the output radio button next to MixFile101.otp.   Click Close.

Double-click AutoFile.otp, again.   You will see the new line of instructions added beginning with the function "1." When this instruction is read by the Auto-Execute AutoFile routine, the 1 tells it to shuffle MixFile.otp according to the sequence shown and output the file as MixFile101.otp.   Close AutoFile.otp.

You'll do this 24 more times according to the following data.   All you have to do is read each line and check the proper box and click the proper buttons then click the Write button then the Continue button until you're finished.   Then click the Close button on the Multi-MixFile(X) Shuffle Utility Program window.

You have already written the first two lines so continue on from there.   You are going to write this entire key to shuffle the MixFile.otp file once creating MixFile101.otp.   Then you will shuffle MixFile101.otp 8 more times with the final time outputting MixFile102.otp.   Then you will shuffle MixFile102.otp 8 more times with the final time outputting MixFile103.otp.   Then you will shuffle MixFile103.otp 7 more times.   Your final AutoFile.otp should read like this:

15
1 MixFile.otp MixFile101.otp 11 1 9 10 14 6 12 5 3 8 2 4 7 13
1 MixFile101.otp MixFile101.otp 3 13 8 14 7 6 11 2 4 10 9 12 5 1
1 MixFile101.otp MixFile101.otp 6 7 14 9 2 10 5 11 8 3 13 12 4 1
1 MixFile101.otp MixFile101.otp 3 1 8 9 12 10 7 13 4 2 5 14 6 11
1 MixFile101.otp MixFile101.otp 9 11 14 12 4 2 6 5 10 13 1 3 8 7
1 MixFile101.otp MixFile101.otp 10 11 8 2 1 12 6 13 7 9 5 3 4 14
1 MixFile101.otp MixFile101.otp 6 13 8 1 4 3 14 12 7 11 2 9 10 5
1 MixFile101.otp MixFile101.otp 10 8 12 14 9 13 5 7 11 4 1 6 3 2
1 MixFile101.otp MixFile102.otp 2 10 14 9 13 1 6 5 7 8 4 12 11 3
1 MixFile102.otp MixFile102.otp 2 14 10 4 9 3 7 1 5 12 13 11 6 8
1 MixFile102.otp MixFile102.otp 6 3 1 5 7 9 14 10 11 13 4 2 8 12
1 MixFile102.otp MixFile102.otp 4 9 8 3 6 7 12 5 10 14 13 11 1 2
1 MixFile102.otp MixFile102.otp 10 4 11 2 13 1 6 14 3 12 5 8 9 7
1 MixFile102.otp MixFile102.otp 1 14 3 9 4 7 13 2 12 8 5 11 10 6
1 MixFile102.otp MixFile102.otp 8 7 4 12 9 10 6 2 14 13 3 11 1 5
1 MixFile102.otp MixFile102.otp 8 13 5 12 10 4 14 2 11 3 7 1 9 6
1 MixFile102.otp MixFile103.otp 4 1 8 12 5 7 14 13 2 11 10 9 3 6
1 MixFile103.otp MixFile103.otp 11 3 14 6 5 10 2 4 9 1 12 8 13 7
1 MixFile103.otp MixFile103.otp 14 2 11 5 13 6 8 3 1 10 7 12 4 9
1 MixFile103.otp MixFile103.otp 14 4 2 7 10 9 11 8 5 1 3 6 12 13
1 MixFile103.otp MixFile103.otp 6 13 11 4 10 2 1 7 14 3 12 9 5 8
1 MixFile103.otp MixFile103.otp 1 13 12 7 9 11 5 4 2 3 14 6 8 10
1 MixFile103.otp MixFile103.otp 4 8 9 3 6 14 2 1 11 10 5 13 7 12
1 MixFile103.otp MixFile103.otp 11 10 13 8 3 5 7 9 1 4 6 2 12 14

The 24 14-number sequences were created by shuffling a 56-card deck of cards.   They are true random number sequences.   There is no way of recreating them other than by brute-force.

Now that you are finished, compare your AutoFile.otp with that above.   If they are both the same then you made no mistakes and this is proof that the Multi-MixFile(X) Shuffle Utility Program operates exactly as described.   Close AutoFile.otp.

IMPORTANT NOTE - MixFile101.otp, MixFile102.otp and MixFile103.otp used in ALL examples are generated with the AutoFile.otp above.

Now, back at the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click the Auto-Execute AutoFile button.   The AutoFile.otp file will be opened and read and each instruction will be executed automatically line by line.   You can read which line is executing and the instruction data.   When the program has finished, you have thoroughly shuffled MixFile10X.otp files:   MixFile101.otp, MixFile102.otp, and MixFile103.otp.   Click Close.

From the BulletProof start-up window, click the Random Number Generation button.   Check the Digits radio button.   Click Begin.   The program opens the three MixFile10X.otp files and loads them into RAM.   (It also looks for a LoadFile.otp file.   More about that in a moment.) Enter 1000 in the Output editbox.   Leave the other default entries as is.   Click Load.   Output is 1000 and the other entries are all zero so click Start.   When the program is done, click Close.

Right-click the Digits.txt file and select Properties.   Size:   1000 bytes.   Double-click Digits.txt and see its contents.   These are the 1000 random digits generated.   Close Digits.txt and manually change its name to Digits1.txt.

From the BulletProof start-up window, click the Random Number Generation button, again.   Check the Digits radio button.   Click Begin.   Notice that the Offset editbox now contains 1000.

Imagine the three MixFile10X.otp files opened in three columns next to each other.   There are 3,628,800 rows and each row contains the ten-digit permutation from each MixFile10X.otp file.   The offset represents how many rows down each MixFile10X.otp file starts being read from when the program begins.   Since we generated 1000 random digits, the random number generator read each row down to and including row 999.   Remember that the first row number is row zero.   So the next row to read when the program is run again and starts to generate more random digits will be row 1000.

Where did the random number generator get this information?   When the first 1000 random numbers were generated and the program concluded, it created the LoadFile.otp file.   In it is recorded the ending register information from the random number generator.   So when the random number generator is run again and you click the Begin button, the program looks for this file and if it exists, it loads this information back into the input editboxes so the next random numbers generated pick up from where the last random numbers generated ended.   Open LoadFile.otp to see this.   Close LoadFile.otp.

Let's generate another 1000 random digits the same way as before.   Enter 1000 into the Output editbox.   Click Load.   Click Start.   Open and compare Digits1.txt and Digits.txt.   Open LoadFile.otp and see that it now contains a 2000 entry where it had a 1000 entry before.   Close these three files.   Delete Digits1.txt.

Now that we have seen how well the offset works, let's generate more random digits so we can check how well the MixFile103 rotate works.   From the BulletProof start-up window, click the Random Number Generation button, again.   Check the Digits radio button.   Click Begin.   Notice that the Offset editbox now contains 2000.   Leave 18,144,000 in the Output editbox.   Click Load.   Click Start.

When done, you can check the Properties of the Digits.txt file:   Size - 18,144,000 bytes.   Don't bother to open the file because it is too large.   And you don't need to open the LoadFile.otp file because when we run the Random Number Generator again you'll see the LoadFile.otp data already loaded into the editboxes.

From the BulletProof start-up window, click the Random Number Generation button, again.  Check the Digits radio button.   Click Begin.   See in the Rotation editbox for MixFile103 the entry:   5.   And remember that when we started there was 2000 in the Offset editbox and we still see 2000 there.   Let's use Windows Start -> All Programs -> Accessories -> Calculator.   Enter 18144000 into the calculator and divide by 3628800 and you get 5.   We just generated 18,144,000 random digits.   And we started at an Offset of 2000.   And we know that there are 3,628,800 rows in each MixFile10X.otp file.   So if we generated 5 * 3628800 = 18144000 random digits we end up at the same Offset but we had to rotate MixFile103.otp by one row 5 times.   And this is exactly what the LoadFile.otp recorded and now has input as our next starting point.   So we know that the Rotation feature of MixFile103 works as described.   But what about the Rotation feature of the MixFile101 and MixFile102 columns?

Enter 3628799 into the Rotation MixFile103 editbox.   If you didn't realize it, you can manually enter where in the Random Number Generator output range you want to start generating random numbers from.   Click Load.   Click Start.   When done, click Close.

From the BulletProof start-up window, click the Random Number Generation button, again.  Check the Digits radio button.   Click Begin.   We already know that when we output 18144000 random digits we rotate MixFile103 5 times and leave the Offset the same.   You can see that the Offset is still 2000.   And remember that we changed the Rotation MixFile103 editbox to 3628799 which is its maximum value.   So just like the odometer of an automobile it rolls over as it rotates one row 5 times and stops at 4 and Rotation MixFile102 is rotated one row:   thus the 1 in its editbox.   So we know that the Rotation feature of MixFile102 works as described.  

We will do the same test of Rotation MixFile101.   Enter 3628799 into the Rotation MixFile103 editbox.   And enter 3628799 into the Rotation MixFile102 editbox.   Click Load.   Click Start.   When done, click Close.

From the BulletProof start-up window, click the Random Number Generation button, again.  Check the Digits radio button.   Click Begin.   You can see that the Rotation MixFile103 rolled over and went to 4.   The Rotation MixFile102 rolled over and went to 0.   And Rotation MixFile101 rolled over going to 1:   all just as expected.   So we know that the Rotation feature of MixFile101 works as described.  

Here is the final run and it is interesting.   Enter 3628799 in the Rotation MixFile103, Rotation MixFile102, and Rotation MixFile101 editboxes.   Click Load.   Click Start.   "No more random numbers available." "LoadFile.otp will be deleted." Yep.  We ran out of random numbers for these three MixFile10X.otp files:   all 1.73E26 of them.   But don't despair.

You may have already read in The Grand Theory Help file that three MixFile10X.otp files can be arranged in a total of 6 different ways.   You can accomplish this by simply renaming these three files any of six different ways.   So with just these same three MixFile10X.otp files you can still generate another 8.67e26 random digits.

Let's look a little closer at the Random Number Generator output.   If it exists, delete LoadFile.otp.   From the BulletProof start-up window, click the Random Number Generation button, again.  Check the Digits radio button.   Click Begin.   Enter 3000 in the Output editbox.   Click Load.   Click Start.   When done, click Close.   Delete LoadFile.otp.

From the BulletProof start-up window, click the Random Number Generation button, again.   Check the Doublets radio button.   Click Begin.   Enter 1500 in the Output editbox.   Click Load.   Click Start.   When done, click Close.   Delete LoadFile.otp.

From the BulletProof start-up window, click the Random Number Generation button, again.  Check the Triplets radio button.   Click Begin.   Enter 1000 in the Output editbox.   Click Load.   Click Start.   When done, click Close.   Delete LoadFile.otp.

From the BulletProof start-up window, click the Random Number Generation button, again.  Check the Binary Triplets radio button.   Click Begin.   Check the RandOut101.otp raido button.   Click Close.   Enter 1000 in the Output editbox.   Click Load.   Click Start.   When done, click Close.   Delete LoadFile.otp.

Open Digits.txt, Doublets.txt, and Triplets.txt.   Compare digit pairs from Digits.txt to the doublets in Doublets.txt.   Compare digit triplets from Digits.txt to the triplets in Triplets.txt.   Do this at the start and end of the files.   Since we deleted LoadFile.otp at the end of each run, the output from the random number generator is the same in all three files except for the formatting.   This shows that the random number generator is consistent for these three outputs.

Close Digits.txt and Doublets.txt.   From the BulletProof start-up window, go to Utility Programs -> Additional Utility Programs -> Binary to Decimal.   Click Start.   Open RandOut101.otp.   Output RandOut101.txt.   Open RandOut101.txt.   Run Calculator.   We know that the random number generator is consistent over digits, doublets, and triplets.   We also know that the random number generator discards all triplets greater than 767 in the random binary number generation process and that it divides the remaining triplets by 3 and discards any remainders.   We used the Binary to Decimal program to convert the RandOut101.otp random binary number file to a form easily readable so we can compare the output from the triplets random numbers and the binary triplets random numbers.

The data in the Triplets.txt file is the same raw data used in the random binary number triplets program.   Let's take each raw triplet and process it as if it were being run through the random binary number triplets program.   550 is the first triplet.   Using Calculator:   it is less than 768 so we use it and divide it by three and discard any remainder:   550 / 3 = 183, This is the same as the first binary triplet generated.   891 is greater than 767 so it is discarded.   765 is less than 768 so we'll use it.   765 / 3 = 255.   This is the second binary triplet generated.   692 / 3 = 230.   This is the third binary triplet generated.   196 / 3 = 65.   This is the fourth binary triplet generated.   891 & 843 are discarded.   515 / 3 = 171.   This is the fifth binary triplet generated.  And so on...

Finally let's look at the last three useable triplets from Triplets.txt.   They are 325, 283, & 375:   325 / 3 = 108.   283 / 3 = 94.  And 375 / 3 = 125.   Let's find a string of these three numbers:   108, 94, & 125, in the RandOut101.txt random binary number triplets file.   I find them at positions 775, 776, and 777.  

Let's think back.   If these random triplets are truly random and we generate 1000 of them but only use 76.8% of them, we would expect that they would only generate 768 useable random binary triplets.   Well, 778 useable random binary number triplets were generated from the raw triplets in Triplets.txt.   You can see this for yourself.   Our output of useable random binary triplets is only 10 greater.   10 / 768 = 1.3% deviation.   I think this is a rather remarkable observation.   (The numbers might be a little confusing but remember that in the RandOut101.txt file, the first triplet is at position 0.   And when the random binary number triplet process performs its calculations, the lowest number it uses is 000.   So it is using 768 out of a thousand raw triplets.)

We are now going to follow through generating our final useable random binary numbers.   Make sure that any LoadFile.otp is deleted.   From the BulletProof start-up window, click the Random Number Generation button, again.   Check the Binary Triplets radio button.   Click Begin.   Check the RandOut101.otp radio button.   Click Close.   Leave all of the default settings as is.   Click Load.   Click Start.   When done, click Close.

You now have a RandOut101.otp random binary number file containing 18,144,000 bytes.   But these are not the final useable random numbers.   You must process them further.   You will be creating a new AutoFile.otp.   So, manually rename your first AutoFile.otp to something else, like, AutoFile_MixFile_1.otp.   From the BulletProof start-up window, go to:   AutoFile Creation -> RandOut Processing.   RandOut Processing is identical to MixFile Processing except RandOut Processing operates on a 1-byte basis whereas MixFile Processing operates on a 5-byte basis.

Since we only generated a single RandOut10X.otp file, we'll only be shuffling one such file.   Check the box directly below the 1-button.   Remember that when shuffling a single RandOut10X.otp file, the box you check designates the input file.   You will notice that there is no 0-button or checkbox.   That is only needed with the Multi-MixFile(X) Shuffle Utility Program to generate the original data MixFile.otp.

I'll get you started.   Click the 1-button.   Enter the following true random number sequence by clicking the buttons in this order:   14 5 13 1 12 6 2 3 7 8 10 9 4 11.   Click the Write button.   Check the RandOut101.otp radio button.   Click Close.

Open AutoFile.otp if you like.   You should see the same instruction line as the first line below.   Close AutoFile.otp.   Click Continue.   Enter the rest of the data below in exactly the same way.   When you are done, open AutoFile.otp and compare it with the data below.

16 RandOut101.otp RandOut101.otp 14 5 13 1 12 6 2 3 7 8 10 9 4 11
16 RandOut101.otp RandOut101.otp 13 12 11 1 3 6 2 4 5 14 10 9 7 8
16 RandOut101.otp RandOut101.otp 4 2 3 10 5 1 11 14 6 13 12 9 7 8
16 RandOut101.otp RandOut101.otp 2 11 5 3 9 7 8 12 1 10 13 14 6 4
16 RandOut101.otp RandOut101.otp 4 8 3 12 7 13 2 9 6 14 5 11 10 1
16 RandOut101.otp RandOut101.otp 14 6 2 10 8 7 3 13 5 1 12 4 11 9
16 RandOut101.otp RandOut101.otp 11 12 4 9 2 14 10 8 3 13 5 1 6 7
16 RandOut101.otp RandOut101.otp 13 14 1 10 8 4 9 11 7 6 3 12 2 5

Close AutoFile.otp.   From the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click the Auto-Execute AutoFile button.   When done, click Close.

In a nutshell, you create three thoroughly shuffled MixFile10X.otp files to generate initial RandOut10X.otp random binary number files.   Then you thoroughly shuffle these files to get your final useable random binary numbers.   This is what BulletProof is designed to do.

I've been describing the final RandOut10X.otp files as useable random binary number files.   Technically this is true but they are not going to be easy to use or very efficient because they are very large files.   Here is a way to make much smaller and more friendly random binary number files from them.

From the BulletProof start-up window, go to:   Utility Programs -> Number Binary Files (AutoFile).   This utility program will create uniquely named random binary number files from the final RandOut10X.otp files.   It uses the AutoFile.otp so manually rename your current AutoFile.otp to something like, AutoFile_RandOut_1.otp.

Each time you run this utility, you can make as many as 9999 files.   But the larger the output file the fewer files you can make.   For instance, if you had 14 thoroughly shuffled RandOut10X.otp files, you could only make 3 files at most if the length were the maximum of 84,672,000 bytes.

You don't have to worry about this because if you enter too many files to output for a given file length the program will catch it and prompt you.   Nevertheless, when you run the AutoFile, if there are not enough random numbers available to create all of your output files, the process will prompt you and not execute the instruction.   The maximum number of useable random binary numbers available to make numbered binary files is when there are 14 thoroughly shuffled RandOut10X.otp files:   254,016,000 bytes.

Leave all the settings at default.   Click Write.   Open the AutoFile.otp file.   Take a look.   Close AutoFile.otp.

From the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click the Auto-Execute AutoFile button.   When done, click Close.

Look in your folder to find five files named:   FA000001 - FA000005.   Right-click on one and select Properties to see that it has 100 bytes.   Now right-click RandOut101.otp and select Properties.   You'll see that it now contains 18,143,500 bytes instead of 18,144,000.   500 bytes have been taken from it in total:   100 bytes for each:   FA000001 - FA000005.  

Change the AutoFile.otp file name to, say, AutoFile_Number_1.otp.   From the BulletProof start-up window, go to:   Utility Programs -> Number Binary Files (AutoFile).   Enter the ASCII character "z" in the top editbox.   Enter 3501 for the beginning file number.   Enter 25 for the number of files.   Enter 10,000 for the file length.   Click Write.   Open the AutoFile.otp file.   Take a look.   Compare its contents with AutoFile_Number_1.otp.   Close AutoFile.otp and AutoFile_Number_1.otp.

From the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click the Auto-Execute AutoFile button.   When done, click Close.

Look in your folder to find 25 files named:   Fz003501 - Fz003525.   Right-click on one and select Properties to see that it has 10,000 bytes.   Now right-click RandOut101.otp and select Properties.   You'll see that it now contains 17,893,500 bytes instead of 18,143,500.   Another 250,000 bytes have been taken from it:   10,000 bytes for each:   Fz003501 - Fz003525.

Delete all files except:   MixFile.otp, MixFile101.otp, MixFile102.otp, MixFile103.otp, AutoFile_MixFile_1.otp, AutoFile_RandOut_1.otp.

End of The Mother of All Tutorials:   Part One

BULLETPROOF - THE MOTHER OF ALL TUTORIALS

PART TWO

From the BulletProof start-up window, go to:   Random Number Generation.   Binary Triplets (0 - 255) is checked.   Click Begin.   Check the RandOut101.otp radio button.   Click Close.   To the right of the Output numbers editbox are two reminders of file lengths that can be useful.   Enter 254,016,000 into the Output numbers editbox.   Enter 0 into each of the other editboxes.   Click Load.   Click Start.   On my computer it took about 5 minutes.   When done, click Close.   Manually change the name of RandOut101.otp to SavedMed_RandOut101.otp.   Manually change the name of LoadFile to SavedMed_LoadFile.

Right-click SavedMed_RandOut101.otp and select Properties.   You'll see that it contains 254,016,000 bytes.   From the BulletProof start-up window, go to:   Utility Programs -> Multi RandOut(X)s (AutoFile).   (Important note:   whenever this utility program is run:   both creating the AutoFile and executing the AutoFile, the input file must be located in the same folder where the BulletProof software that is running is located in.   It most probably will be.) The input file must always be exactly 254,016,000 bytes.   Click Start.   Select SavedMed_RandOut101.otp.   Click Close.   Open the AutoFile.otp file.   Take a look.   Close AutoFile.otp.

When you run this AutoFile, the 254,016,000 byte SavedMed_RandOut101.otp file is first read completely into RAM.   From the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click the Auto-Execute AutoFile button.   When done, click Close.

Look in your folder and you will see that you now have RandOut101.otp - RandOut114.otp.   This operation read the SavedMed_RandOut101.otp file containing 254,016,000 random binary number bytes and split it up into these smaller RandOut10X.otp files containing 18,144,000 bytes each.   You may find this technique useful.   Manually change the name of RandOut101.otp to Saved_ RandOut101.otp.   Delete all of the other RandOut10X.otp files.

From the BulletProof start-up window, go to:   Random Number Generation.   Binary Triplets (0 - 255) is checked.   Click Begin.   Check the RandOut101.otp radio button.   Click Close.   Enter 2,032,128,000 into the Output numbers editbox.   Enter 0 into each of the other editboxes.   Click Load, Click Start.   This may take a while.   On my computer it took about 40 minutes.   When done, right-click RandOut101.otp and select Properties.   You'll see that it contains 2,032,128,000 bytes.

From the BulletProof start-up window, go to:   Utility Programs -> File Split.   Click Begin.   Select RandOut101.otp containing 2,032,128,000 bytes.   Enter 254,016,000 in the Length of files editbox or check the Number of files radio button and enter 8 in the Number of files editbox.   Click Start.   This took 15 minutes on my computer.   Eight SplitFiles are output.   You can now use the Multi RandOut(X)s (AutoFile) Utility Program on these SplitFiles containing 254,016,000 bytes each.   The output from File Split is always into the same folder where you ran the BulletProof software from.   The minimum input file length is 10,000 bytes.   If the input file is greater than 2GB your only option is Length of files.

Manually change the name of RandOut101.otp to SavedBig_RandOut101.otp.   It's easier to save it now than spend the time to generate another one.   Manually change the name of LoadFile to SavedBig_LoadFile.

File Split reads input into RAM in chunks of 350MB.   If the input file is larger, 350MB will be read into RAM, processed, and output then another 350MB will be read into RAM, etc.  until the entire file has been split.   If the file is smaller than 350MB, only that amount of RAM will be allocated and the whole file will be read into RAM at once then processed and output.

Sometimes you need to split a file then recombine it later, such as a home movie that is 9GB long.   You split it into 5 files and make three-DVD sets and give them to your friends.   (5 files because the maximum split file length is 2GB.) Then they can recombine them on their hard drives to watch your movie.

From the BulletProof start-up window, go to:   Utility Programs -> File Split.   Click Begin.   Select your file.   Choose a file less than 350MB.   I chose a movie trailer with a .mov extension that contains 166,246,400 bytes.   Click the Number of files radio button.   Enter 3 in the Number of files editbox.   Click Start.   When done, click Close.   SplitFile0000 & SplitFile0001 are 55,415,467 bytes each and SplitFile0002 is 55,415,466 bytes.

From the BulletProof start-up window, go to:   Utility Programs -> File Split Append.   Click Begin.   Select a new name for output.   Click Save.   You should find that the original file length and the recombined file length are exactly the same.   My recombined .mov file played flawlessly.   You must always run BulletProof from the directory where the split files are located.

Delete all files except:   MixFile.otp, MixFile101.otp, MixFile102.otp, MixFile103.otp, SavedMed_RandOut101.otp, Saved_RandOut101.otp, SavedBig_RandOut101.otp, AutoFile_MixFile_1.otp, AutoFile_RandOut_1.otp, SavedMed_LoadFile, SavedBig_LoadFile.

This will be the last time we discuss the BulletProof random number generator but it will be the most in-depth and enlightening.   From the BulletProof start-up window, go to:   Random Number Generator.   Check the Digits radio button.   Click Begin.   Enter 1000 in the Output numbers editbox.   All other inputs should be 0.   Click Load.   Click Start.   When done, click Close.   You should have a Digits.txt file containing 1000 bytes.

From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Read Binary File.   Click Start.   Select MixFile101.otp for input.   Enter ReadFile101 for output.   Leave Offset bytes 0.   Click Continue.   Enter 65 in the bytes to read editbox.   Click Begin.   When done, click Close.

Click Read Binary File.   Click Start.   Select MixFile102.otp for input.   Enter ReadFile102 for output.   Leave Offset bytes 0, Click Continue.   Enter 65 in the bytes to read editbox.   Click Begin.   When done, click Close.

Click Read Binary File.   Click Start.   Select MixFile103.otp for input.   Enter ReadFile103 for output.   Leave Offset bytes 0.  Click Continue.   Enter 65 in the bytes to read editbox.   Click Begin.   When done, click Close.   You now have three files called:   ReadFile101, ReadFile102, ReadFile103 with each containing
65 bytes.

Click BCD to Decimal.   Click Start.   Open ReadFile101.   Save ReadFile101.txt.   When done, click Close.

Click BCD to Decimal.   Click Start.   Open ReadFile102.   Save ReadFile102.txt.   When done, click Close.

Click BCD to Decimal.   Click Start.   Open ReadFile103.   Save ReadFile103.txt.   When done, click Close.

Open ReadFile101.txt, ReadFile102.txt, ReadFile103.txt and compare them to the first three columns below.

 MixFile101      MixFile102     MixFile103      Set4                 Set5              Num

0473265981    7098345126    6210458397    3679045218    6430185792    5
1349862705    5416732809    1265983074    8923056714    2594736018    5
6342571098    7153062498    8640321957    9620814375    1034296875    0

9021836547    6084795132    6279503481    3685410297    1672893054    8
0765123948    8729036415    4291608753    5793418620    4780291365    9
5241768093    9210873645    2365840791    1632975084    4683709215    1

1207968543    1275369480    9375860412    3746502819    3794201685    7
8472319506    8521370964    9712354680    8517269043    8361270594    6
5879436102    3470298651    0295174683    5160938472    7863154209    5

1368079425    0369785241    1392468057    1287056943    3285107496    6
1968247503    8295613047    3196754820    2905416378    1042978536    9
0814957236    1364502987    8017256934    0762581439    8302459176    2

Open Digits.txt to find:   550891765692...   Compare this to the Num column above.   By determining the random digit output manually using the process outlined in The Grand Theory Help file and comparing that output above with the Digits.txt random number generator output, we just proved that the random number generator is working exactly as described and as it should at the very beginning of the random number generation process.

But there are critical points in the random number generation process that need to be checked so we can be thoroughly confident that all of the random numbers throughout the entire random number generation output range are being generated correctly.   These critical points are where the rotation of the MixFile10X.otp files take place.

We know that in a rotation of MixFile103, all of the ten-digit permutations are shifted up by one row and the formerly top permutation is placed at the bottom.   And Offset rolls over and goes back to 0.   This will change Set4 and Set5 and the random digits output.   Since the first rotation is that of MixFile103, here is the new arrangement at the top rows.  Open ReadFile103.txt and you can see that the MixFile103 column has been shifted up one row.

 MixFile101      MixFile102     MixFile103      Set4                 Set5              Num

0473265981    7098345126    1265983074    0147598263    1905638472    1
1349862705    5416732809    8640321957    2361904587    6037514982    2
6342571098    7153062498    6279503481    4209637518    3957042618    3

9021836547    6084795132    4291608753    8456730219    3492518067    5
0765123948    8729036415    2365840791    9761250834    2704365189    1
5241768093    9210873645    9375860412    2739145086    6783401925    2

1207968543    1275369480    9712354680    7165240389    7196048532    8
8472319506    8521370964    0295174683    8792560341    8169523704    3
5879436102    3470298651    1392468057    2401975863    6507428319    4

1368079425    0369785241    3196754820    3640825971    1642380795    2
1968247503    8295613047    8017256934    3145607829    0463129587    3
0814957236    1364502987    8632947510    6279483015    8169045327    2

We need to generate another Digits.txt file that starts precisely at the beginning of the first rotation of the MixFile103 column.   From the BulletProof start-up window, go to:   Random Number Generator.   Check the Digits radio button.   Click Begin.   Instead of deleting LoadFile.otp, we'll just enter the required data manually.   Enter 1000 in the Output numbers editbox.   Enter 0 in both MixFile101 and MixFile102 Rotation editboxes.   Enter 1 in MixFile103 Rotation editbox.   And enter 0 in Offset editbox.   Click Load.   Click Start.

Opening the 1000 byte Digits.txt file we see:   123512834232...   This again proves that the random number generator is outputting the exact random digits that we determined manually, above, after the MixFile103 rotation.

Now we'll check immediately after the first MixFile102 rotation.   Again, we know that in a rotation of a MixFile10X column, all of the ten-digit permutations are shifted up one row and the formerly top permutation is placed at the bottom.   Keep in mind that these rotations behave like the odometer in an automobile.

So when the first rotation of the MixFile102 column occurs, as MixFile102 rolls up by one, MixFile103 and Offset both roll over and start at 0 again.   Since Set4 is a function of MixFile102 and MixFile103, it will change completely.   But Set5 is a function of MixFile101 and MixFile103 so it will once again be the same as in our first examination.   Nevertheless, since MixFile102 has rotated up by one and Set4 will be completely different, the random digits output will change completely as well.   Here is the starting column arrangement at the top rows.

 MixFile101      MixFile102     MixFile103      Set4                 Set5              Num

0473265981    5416732809    6210458397    5428301967    6430185792    1
1349862705    7153062498    1265983074    0285136947    2594736018    3
6342571098    6084795132    8640321957    1853972604    1034296875    3

9021836547    8729036415    6279503481    8471693520    1672893054    7
0765123948    9210873645    4291608753    3924571860    4780291365    2
5241768093    1275369480    2365840791    3674501892    4683709215    3

1207968543    8521370964    9375860412    1673549208    3794201685    6
8472319506    3470298651    9712354680    2369108457    8361270594    0
5879436102    0369785241    0295174683    0543687912    7863154209    0

1368079425    8295613047    1392468057    5976832140    3285107496    2
1968247503    1364502987    3196754820    1647539028    1042978536    6
0814957236    2846731905    8017256934    1326970485    8302459176    6

We need to generate another Digits.txt file that starts precisely at the beginning of the first rotation of the MixFile102 column.   From the BulletProof start-up window, go to:   Random Number Generator.   Check the Digits radio button.   Click Begin.   Instead of deleting LoadFile.otp, we'll just enter the required data manually.   Enter 1000 in the Output numbers editbox.   Enter 0 in both MixFile101 and MixFile103 Rotation editboxes.   Enter 1 in MixFile102 Rotation editbox.   And enter 0 in Offset editbox.   Click Load.   Click Start.

Opening the 1000 byte Digits.txt file we see:   133723600266...   This again proves that the random number generator is outputting the exact random digits that we determined manually after this MixFile102 rotation.

Now we'll check immediately after the first MixFile101 rotation.   So when the first rotation of the MixFile101 column occurs, as MixFile101 rolls up by one, MixFile102, MixFile103, and Offset roll over and start at 0 again.   Since Set5 is a function of MixFile101 and MixFile103, it will change completely.   But Set4 is a function of MixFile102 and MixFile103 so it will once again be the same as in our first examination.   Nevertheless, since MixFile101 has rotated up by one and Set5 will be completely different, the random digits output will change completely as well.   Here is the starting column arrangement at the top rows.

 MixFile101      MixFile102     MixFile103      Set4                 Set5              Num

1349862705    7098345126    6210458397    3679045218    2047981365    7
6342571098    5416732809    1265983074    8923056714    3596802147    5
9021836547    7153062498    8640321957    9620814375    7846501239    8

0765123948    6084795132    6279503481    3685410297    6430279158    3
5241768093    8729036415    4291608753    5793418620    0962785431    6
1207968543    9210873645    2365840791    1632975084    3627109485    1

8472319506    1275369480    9375860412    3746502819    1847532690    4
5879436102    8521370964    9712354680    8517269043    5860324791    0
1368079425    3470298651    0295174683    5160938472    2548063197    2

1968247503    0369785241    1392468057    1287056943    3785940612    8
0814957236    8295613047    3196754820    2905416378    3217058964    5
4289357601    1364502987    8017256934    0762581439    2134759680    7

We need to generate another Digits.txt file that starts precisely at the beginning of the first rotation of the MixFile101 column.   From the BulletProof start-up window, go to:   Random Number Generator.   Check the Digits radio button.   Click Begin.   Enter 1000 in the Output numbers editbox.   Enter 1 in MixFile101 Rotation editbox.   Enter 0 in both MixFile102 and MixFile103 Rotation editboxes.   And enter 0 in Offset editbox.   Click Load.   Click Start.

Opening the 1000 byte Digits.txt file we see:   758361402857...   This again proves that the random number generator is outputting the exact random digits that we determined manually after the MixFile101 rotation.

 MixFile101      MixFile102     MixFile103      Set4                 Set5              Num

3982056741    7496238105    6394250718    7280941365    4819650723    9
5603972148    3756219840    0497328651    7628941530    2807169435    3
8460935721    1430568729    6803214759    8236145709    5246931708    1

3154670892    1249378065    9348052716    3406871925    8350279164    3
8493026157    3125769048    5386291407    6389417520    0276581394    1
5967431802    3127965084    0327819546    7325691048    1695873402    0

5367910284    0467591283    0261397845    0378952641    9178520643    0
8579420163    7850146239    3601795482    4893675012    8942703651    5
6875210439    8253176094    7608932145    4038612759    2413067985    5

8127536409    8254071963    3904687215    1086329574    1902847635    2
9605843712    3740596812    1720984635    0691854372    5418390672    5
0649875123    5821493670    4592831067    3695872104    4187603592    6

Now here is a technique that can be used throughout the entire range of all possible 1E27 random digits generated using BulletProof with any given three MixFiles to prove that this freeware operates exactly as described.

We'll need to generate another Digits.txt file using arbitrary rotation and offset input. From the BulletProof start-up window, go to: Random Number Generator. Check the Digits radio button. Click Begin. Instead of deleting LoadFile.otp, we'll just enter the required data manually. Enter 1000 in the Output numbers editbox. Enter 267,839 in the MixFile101 Rotation editbox. Enter 14,789 in the MixFile102 Rotation editbox. Enter 2,627,617 in the MixFile103 Rotation editbox. Enter 0 in the Offfset editbox. Click Load. Click Start.

Upon opening the 1000 byte Digits.txt file, move the cursor three places to the right and hit the enter key and repeat this last step three more times. Compare these four triplets from the Digits.txt file with the ones above: 931 310 055 256. This proves that the random number generator is outputting the exact random digits that we determined manually, above.

But where did these ten-digit permutations above come from? They came from the three MixFiles used in BulletProof to generate this last Digits.txt file. Here is how to determine this.

From the BulletProof start-up window, go to: Utility Programs -> Additional Utility Programs -> Read Binary File. Click Begin. Select MixFile101.otp for input. Enter ReadFile101 for output. Enter 1,339,195 bytes into the offset editbox.

But why? We started with the arbitrary input that was entered into the BulletProof Random Number Generator to output this last Digits.txt file. Each ten-digit permutation is written in the MixFiles as a 5- byte BCD. We must multiply: 267,839 x 5 = 1,339,195 so we can locate and read the exact permutations that gave us the Digits.txt file. Click Continue. Enter 60 in the bytes to read editbox. Click Start. When done, click Close.

Click Read Binary File. Click Begin. Select MixFile102.otp for input. Enter ReadFile102 for output. We multiply: 14,789 x 5 = 73,945. Enter 73,945 bytes into the offset editbox. Click Continue. Enter 60 in the bytes to read editbox. Click Start. When done, click Close.

Click Read Binary File. Click Begin. Select MixFile103.otp for input. Enter ReadFile103 for output. We multiply: 2,627,617 x 5 = 13,138,085. Enter 13,138,085 bytes into the offset editbox. Click Continue. Enter 60 in the bytes to read editbox. Click Start. When done, click Close.

You now have three files called: ReadFile101, ReadFile102, ReadFile103 with each containing 60 bytes.

Click BCD to Decimal. Click Start. Open ReadFile101. Save ReadFile101.txt. When done, click Close.

Click BCD to Decimal. Click Start. Open ReadFile102. Save ReadFile102.txt. When done, click Close.

Click BCD to Decimal. Click Start. Open ReadFile103. Save ReadFile103.txt. When done, click Close.

Open ReadFile101.txt, ReadFile102.txt, ReadFile103.txt and compare them to the first three columns above. This further proves that the random number generator is outputting the exact random digits that we determined manually, above.

And you can carry out this process using the Random Binary Number Generator Utility outputting any Digits.txt file using any Rotation and Offset input as you see fit. There are only slight variations if you also use an Offset other than zero or if the Digits.txt file will involve a rotation as the digits are output.

For instance, in this last Digits.txt we input an Offset of "0" and got this random digit output: 9313100552... If you enter all the same input but enter an Offset of "1" you get this random digit output: 3131005525... If you enter all the same input but enter an Offset of "2" you get this random digit output: 1310055256... Looking at the table above we can say that these changes in Offset merely increment down one row or two rows first before beginning output.

But this has significant implications if you use the above technique to prove that BulletProof operates exactly as described. If you have an Offset other than zero you must add this offset to each of your other Rotation values when you calculate your Read Binary File offset.

For instance, if you have an Offset of "1" then we must multiply: (267,839 + 1) x 5 = 1,339,200 in the above calculation. Or if you have an Offset of "2" then we must multiply: (267,839 + 2) x 5 = 1,339,205. The same will hold true with the other calculations: we multiply: (14,789 + 1) x 5 = 73,950 or We multiply: (14,789 + 2) x 5 = 73,955. And we multiply: (2,627,617 + 1) x 5 = 13,138,090 or (2,627,617 + 2) x 5 = 13,138,095. This way the exact permutations used in the Digits.txt output can be precisely located. This is all well and good and if you think about it, it's what one would expect. And if you like you can use the same procedure above. I did using an Offset of 3. And it is absolutely correct.

But what if the calculated sum of Rotation and Offset is greater than 3,628,800? This means that a MixFile column rotation will take place. Visualize an old-style automobile cylindrical odometer. Take just one wheel and splice it between the digits zero and nine and lay it down flat on a tabletop with the zero at the top, at row zero, and the nine at the bottom, at row nine.

A single rotation means that the one becomes the top, at the first row or row zero, and the zero is at the bottom, at the tenth row or row nine. But the relative orderings or sequence of the digits 0 - 9 remains the same. This same idea applies to MixFile columns.

Two rotations from left to right -

0 1 2
1 2 3
2 3 4
3 4 5
4 5 6
5 6 7
6 7 8
7 8 9
8 9 0
9 0 1

So far this has not become an issue when proving BulletProof operates exactly as described. But there are instances where it can be difficult to make the case. Here is one in particular and I will show you a new technique to prove the point: it does not use the Read Binary File Utility.

Again, we'll need to generate another Digits.txt file using arbitrary rotation and offset input but with one difference. From the BulletProof start-up window, go to: Random Number Generator. Check the Digits radio button. Click Begin. Instead of deleting LoadFile.otp, we'll just enter the required data manually. Enter 1000 in the Output numbers editbox. Enter 267,839 in the MixFile101 Rotation editbox. Enter 14,789 in the MixFile102 Rotation editbox. Enter 2,627,617 in the MixFile103 Rotation editbox. Enter 3,628,790 in the Offset editbox. Click Load. Click Start.

Here are new calculations accounting for this large Offset of 3,628,790 that we will use with this new technique.

MixFile101: 267,839 + 3,628,790 = 3,896,629 then - 3,628,800 = 267,829

MixFile102: 14,789 + 3,628,790 = 3,643,579 then - 3,628,800 = 14,779

MixFile103: 2,627,617 + 3,628,790 = 6,256,407 then - 3,628,800 = 2,627,607

Like the old-style automobile odometer, when you get to the end you start over again from the beginning: this is why we subtract 3,628,800 when the calculated sum is 3,628,800 or greater. So this will allow us to the locate exactly the MixFile permutation locations to verify this new Digits.txt file output.

From the BulletProof start-up window, go to: Utility Programs -> Additional Utility Programs -> BCD to Decimal. Click Start. Select MixFile101.otp for input. Enter MixFile101otp.txt for output. When done, click Close.

From the BulletProof start-up window, go to: Utility Programs -> Additional Utility Programs -> BCD to Decimal. Click Start. Select MixFile102.otp for input. Enter MixFile102otp.txt for output. When done, click Close.

From the BulletProof start-up window, go to: Utility Programs -> Additional Utility Programs -> BCD to Decimal. Click Start. Select MixFile103.otp for input. Enter MixFile103otp.txt for output. When done, click Close.

When we used the Read Binary File Utility we extracted only a few BCD permutations. What we have just done here is extracted all of the BCD permutations in each MixFile. Open MixFile101otp.txt in NotePad. It took about 35 seconds on my machine. The left column is the line number that starts at zero and ends at 3,628,799. That's 3,628,800 lines or rows. In the right column is the extracted ten- digit permutation of the digits 0 - 9 with no digit repeated.

Row zero of each MixFile is set by the MixFile Rotation input. The row at which each MixFile starts to generate the random digit output is set by the Offset from row zero. Row zero in MixFile101 is 267,839, row zero in MixFile102 is 14,789 and row zero in MixFile103 is 2,627,617. And the offset from row zero in each MixFile is 3,628,790.

Using the Rotation and Offset sum and calculations above for this new technique, I can locate the exact starting position in each MixFile where the random digit output will begin. We know where each MixFile column rotation has been adjusted and we know how many rows down each MixFile we offset. So the calculation tells us exactly what line number to Find in each extracted text MixFile to begin the manual determination of the digit output to see if BulletProof operates exactly as described.

According to the calculations we know that the random digit output will begin at an offset to row zero in MixFile101 at line 267,829, at an offset to row zero in MixFile102 at line 14,779, and at an offset to row zero in MixFile103 at line 267,829. See the table below. Finding the line number: open the MixFileotp.txt file in Notepad. Select Find. Entering the calculated row number with two trailing spaces "267829 " will go almost immediately to that line.

Several random digits output from the start of this new Digits.txt file (spaces added for readability) - 936 948 343 340 827 242...

To get started manually outputting the random digits just remember that Set5 is used to index Set4. And the first digit output is made by using the zeroth element of Set5 which is the first digit in Set5 which is the digit 6. Element 6 in Set4 is the digit 9, and so on.

Line #     MixFile101      Line #       MixFile102       Line #      MixFile103       Set4                  Set5               Num

267829   4239087651         14779   9640285317     2627607   8502693471     1368079254     6021874395     9
267830   4610735892         14780   6837049512     2627608   4356028917     8169407235     0834962175     3
267831   8401379265         14781   4017923568     2627609   8945316702     3897245160     0389572461     6

267832   5974130862         14782   9421086375     2627610   8916372504     4319802657     7453968021     9
267833   4725638019         14783   4163895072     2627611   1896325074     3856742109     3092567184     4
267834   0832615479         14784   7360145298     2627612   9786421053     0619742835     9568172403     8

267835   9281367405         14785   7948251063     2627613   9746580123     1352487906     3427601598     3
267836   9867520341         14786   1536270894     2627614   7361840952     3410697528     2509467183     4
267837   4718352906         14787   2134069758     2627615   8607931524     0679814532     9562730481     3

267838   2947138560         14788   7980123465     2627616   3028765491     4193028756     2174089653     3
267839   3982056741         14789   7496238105     2627617   6394250718     7280941365     4819650723     9 ??
267840   5603972148         14790   3756219840     2627618   0497328651     7628941530     2807169435     3 ??

What's the problem? Remember, the offset was 3,628,790. After ten digits are output MixFile103 has reached the last permutation in its column. So a rotation must take place. In the table above I did not take this into account.

Once the MixFiles are finalized they do not change. But internally in RAM they are rotated and offsets are made in accordance with user input and the program. This is all behind the scenes. But in this technique we must work with the MixFiles we can access. So in the table above, immediately after the tenth digit is output MixFile103 must be rotated upwards one row.

Let me explain: we know that MixFile103 row zero is at line # 2627617. See it in the table directly above. Therefore we also know that the last permutation in MixFile103 is at line # 2627616. Again, we have to work with the MixFiles we can access. Imagine MixFile103 spliced between line # 2627616 and line # 2627617, stretched out and laid flat on a tabletop. Permutation 6394250718 would be at the top of the column at row zero and permutaion 3028765491 would be way down 3,628,799 rows at the bottom of the column, here at line # 2627616.

We also know that the Offset is 3,628,790. Our calculations using this new technique determines that the random digits are generated beginning at line # 2627607. This is the offset from row zero. And we know that only ten digits can be output before the end of MixFile103 is reached and a rotation takes place.

Immediately after the tenth digit is output MixFile103 rotates upward one row. Originally the MixFile103 Rotation set row zero to 2627617 so when the Offset goes past 3,628,799 a MixFile103 rotation occurs and row zero goes from 2627617 to 2627618. Examine the corrected table below. Note that MixFile101 and MixFile102 do not rotate. When the next random digit is to be generated the next row is accessed. But the MixFile103 row zero has moved up one row relative to MixFile101 and MixFile102.

Line #     MixFile101      Line #       MixFile102       Line #      MixFile103       Set4                  Set5               Num

267829   4239087651         14779   9640285317     2627608   4356028917
267830   4610735892         14780   6837049512     2627609   8945316702
267831   8401379265         14781   4017923568     2627610   8916372504

267832   5974130862         14782   9421086375     2627611   1896325074
267833   4725638019         14783   4163895072     2627612   9786421053
267834   0832615479         14784   7360145298     2627613   9746580123

267835   9281367405         14785   7948251063     2627614   7361840952
267836   9867520341         14786   1536270894     2627615   8607931524
267837   4718352906         14787   2134069758     2627616   3028765491

267838   2947138560         14788   7980123465     2627617   6394250718
267839   3982056741         14789   7496238105     2627618   0497328651     6318975402     7159028634     4
267840   5603972148         14790   3756219840     2627619   6803214759     3714089526     1463970825     0

267841   8460935721         14791   1430568729     2627620   9348052716     3089521746     1029685743     8
267842   3154670892         14792   1249378065     2627621   5386291407     3827640519     6392145078     2
267843   8493026157         14793   3125769048     2627622   0327819546     7321596084     4867029315     7

267844   5967431802         14794   3127965084     2627623   0261397845     1268579043     9578312406     2
267845   5367910284         14795   0467591283     2627624   3601795482     3754926081     9154263087     4
267846   8579420163         14796   7850146239     2627625   7608932145     1437692085     4315907628     2

Look at the MixFile103 line numbers. They have all moved up one row. The rotation takes place exactly where the 11th digit is generated. Now continue comparing the random digits that were generated manually above with the ones in the Digits.txt file. Once again this proves beyond any doubt that BulletProof works predictably exactly as described.

Keep in mind that the Doublets.txt, Triplets.txt and RandOut files all use the same code as Digits.txt. What has been shown here applies equally to those processes as well.

End of The Mother of All Tutorials: Part Two

BULLETPROOF - THE MOTHER OF ALL TUTORIALS

PART THREE

The Multi-MixFile(X) Shuffle Utility Program and the Multi-RandOut(X) Shuffle Utility Program process files exactly the same except that Multi-MixFile(X) Shuffle processes MixFile10X.otp files on a BCD ten-digit permutation 5-byte basis while Multi-RandOut(X) Shuffle processes RandOut10X.otp files on a 1-byte basis.

Run the BulletProof software.   From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Create Test Files.   Click TestFile_1.   A 18,144,000 byte file called, TestFile_1, is created.   The first 1,296,000 bytes are all 1's, the next 1,296,000 bytes are all 2's, the next 1,296,000 bytes are all 3's, etc....  the next to the last 1,296,000 bytes are all D's's, and the last 1,296,000 bytes are all E's.   Manually rename this file MixFile104.otp.

From the BulletProof start-up window, go to:   AutoFile Creation -> MixFile Processing.   Check the box directly under the 4-button.   Click the 4-button.   Click each button in this sequence order:   14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1.   Click Write.   Check the MixFile105.otp output radio button.   Click Close.

From the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click Auto-Execute AutoFile.   When done, click Close.

From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Read Binary File.   Click Start.   Select MixFile105.otp to open.   Save as ReadFileMix105.txt to output.   Leave Offset 0.   Click Continue.   Enter 7000 for bytes to read.   Click Begin.   Open the ReadFileMix105.txt file.   Size the window to 70 characters wide.   You will see that every line is:   EEEEEDDDDDCCCCCBBBBBAAAAA999998888877777666665555544444333332222211111.

What you did was shuffle or interleave TestFile_1, renamed MixFile104.otp, according to the input sequence order.   Since Multi-MixFile(X) Shuffle operates on a 5-byte basis you get 5-byte strings of each character.   You can rerun this test changing the sequence order and the output will change accordingly.   Manually change the name of MixFile104.otp to RandOut104.otp.  Delete AutoFile.otp, MixFile105.otp, ReadFileMix105.txt.

From the BulletProof start-up window, go to:   AutoFile Creation -> RandOut Processing.   Check the box directly under the 4-button.   Click the 4-button.   Click each button in this sequence order:   1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14.   Click Write.   Check the RandOut105.otp output radio button.   Click Close.

From the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click Auto-Execute AutoFile.   When done, click Close.

From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Read Binary File.   Click Start.   Select RandOut105.otp to open.   Save as ReadFileRand105.txt.   Leave Offset 0.   Click Continue.   Enter 7000 for bytes to read.   Click Begin.   Open the ReadFileRand105.txt file.   Size the window to 14 characters wide.   You will see that every line is:   123456789ABCDE.

What you did was shuffle or interleave TestFile_1, renamed RandOut104.otp, according to the input sequence order.   Since Multi-RandOut(X) Shuffle operates on a 1-byte basis you get 1-byte strings of each character.   You can rerun this test changing the sequence order and the output will change accordingly.   Delete AutoFile.otp, RandOut104.otp, RandOut105.otp, ReadFileRand105.txt.

You can shuffle 2 - 14 MixFile10X.otp files together.   From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Create Test Files.   Click TestFile_2.   14 files are created:   TestFile_2_1 - TestFile_2_E.   Each TestFile is 18,144,000 bytes long and contains a single character:   1 - E, according to the last character in the TestFile's name.  

Make copies of TestFile_2_A, TestFile_2_B, TestFile_2_C, TestFile_2_D, TestFile_2_E and place them in another folder because these files will be permanently changed after the following processing.   In your working directory, manually change the name of the following files:   TestFile_2_A to MixFile110.otp, TestFile_2_B to MixFile111.otp, TestFile_2_C to MixFile112.otp, TestFile_2_D to MixFile113.otp, TestFile_2_E to MixFile114.otp.

From the BulletProof start-up window, go to:   AutoFile Creation -> MixFile Processing.   Check the boxes directly under the 10-button, 11-button, 12-button, 13-button, 14-button.   Click each button in this sequence order:   14, 13, 12, 11, 10.   Click Write.   Click Close.

From the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click Auto-Execute AutoFile.   When done, click Close.

Each of the MixFile110.otp - MixFile114.otp files will look exactly the same so we will look at a small representative section of one of these files.   From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Read Binary File.   Click Start.   Select MixFile112.otp to open.   Save as ReadFileMix112.txt to output.   Enter Offset 9,000,000.   Click Continue.   Enter 7000 for bytes to read.   Click Begin.

Open the ReadFileMix112.txt file.   Size the window to 25 characters wide.   You will see that every line is:   EEEEEDDDDDCCCCCBBBBBAAAAA.   What you did was shuffle or interleave these 5 TestFiles, renamed MixFile110.otp - MixFile114.otp, according to the input sequence order.   Since Multi-MixFile(X) Shuffle operates on a 5-byte basis you get 5-byte strings of each character.   You can rerun this test changing the number of files, which files, and the sequence order and the output will change accordingly.

You can shuffle 2 - 14 RandOut10X.otp files together.   Delete MixFile110.otp - MixFile114.otp, ReadFileMix112.txt, and AutoFile.otp.   Move your copies of TestFile_2_A - TestFile_2_E back into your working directory.   Manually change the name of the following files:   TestFile_2_A to RandOut110.otp, TestFile_2_B to RandOut111.otp, TestFile_2_C to RandOut112.otp, TestFile_2_D to RandOut113.otp, TestFile_2_E to RandOut114.otp.

From the BulletProof start-up window, go to:   AutoFile Creation -> RandOut Processing.   Check the boxes directly under the 10-button, 11-button, 12-button, 13-button, 14-button.   Click each button in this sequence order:   10, 11, 12, 13, 14.   Click Write.   Click Close.

From the BulletProof start-up window, go to:   AutoFile Read and Execute.   Click Auto-Execute AutoFile.   When done, click Close.

Each of the RandOut110.otp - RandOut114.otp files will look exactly the same so we will look at a small representitive section of one of these files.   From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Read Binary File.   Click Start.   Select RandOut113.otp to open.   Save as ReadFileRand113.txt to output.   Enter Offset 6,000,000.  Click Continue.   Enter 7000 for bytes to read.   Click Begin.

Open the ReadFileRand113.txt file.   Size the window to any multiple of 5 characters wide.   You will see that every line is:   ABCDEABCDEABCDE....   What you did was shuffle or interleave these 5 TestFiles, renamed RandOut110.otp - RandOut114.otp, according to the input sequence order.   Since Multi-RandOut(X) Shuffle operates on a 1-byte basis you get 1-byte strings of each character.   You can rerun this test changing the number of files, which files, and the sequence order and the output will change accordingly.   So this proves that Multi-MixFile(X) Shuffle and Multi-RandOut(X) Shuffle operate on a single file and multi-file basis exactly as described.

Delete all files except:   MixFile.otp, MixFile101.otp, MixFile102.otp, MixFile103.otp, SavedMed_RandOut101.otp, Saved_RandOut101.otp, Saved_RandOut102.otp, SavedBig_RandOut101.otp, AutoFile_MixFile_1.otp, AutoFile_RandOut_1.otp, SavedMed_LoadFile, SavedBig_LoadFile.

Also included in the BulletProof software package are Button Rows Random Number Utility Program and Two-Array Random Number Scramble Utility Program.   These two programs together can be very useful in the random number generation process as I'll explain soon.

From the BulletProof start-up window, go to:   Utility Programs -> Button Rows.   Click on the numbered buttons in the order that corresponds to your random 256-number sequence.   As each button is clicked, it will disable so you cannot enter the same number again.   When all 256 buttons are disabled, the Write buttons will enable.

Click Write to file:   Binary, to output a random number file in binary format containing the sequence order in which you clicked the buttons.   To confirm that the binary file represents the 256-number sequence you entered, click Write to file:   Decimal, to output this same file in a readable decimal character format.

If you click the buttons in a true random order then the file will contain a true random sequence of the numbers from 0 - 255 with no repeats.

I have 256 pennies each uniquely numbered from 0 - 255.   I place them in a small bag and shake them up.   I remove them one by one reading the number on each and clicking the same numbered button in the Button Rows Random Number Utility Program.   Then I output a binary file of this numbered sequence.   I do this twice.   So now I have two entirely different binary random number sequences.   There are 256! = approx.  3.4E508 possible ways to arrange these 256 numbers.   So there are (3.4E508)^2 = approx.  1.17E1017 ways to arrange two 256-number sequences successively.

Index sequence #1 - Random_Binary_1

33 189 20 100 107 118 63 233 196 219 9 213 191 136 131 170 236 217 143 174 122 69 88 6 7 245 247
207 167 77 163 10 22 231 70 200 11 40 116 252 94 129 169 67 211 34 197 89 225 2 178 80 195 93 21
190 202 186 65 140 182 183 150 45 199 31 234 52 112 38 177 95 239 229 50 126 124 132 29 108 187
47 144 253 101 57 201 198 60 216 209 175 152 149 241 240 205 85 83 92 8 179 208 134 18 56 137
214 171 162 130 248 164 17 82 64 127 228 44 86 3 51 222 103 19 73 242 250 61 84 125 157 160 172
243 54 25 141 146 48 26 223 180 90 193 79 147 148 165 23 12 99 117 71 221 37 1 235 98 206 237
161 249 123 210 42 27 142 119 36 96 111 166 215 138 114 74 159 102 192 218 14 156 39 220 168
181 53 109 105 16 24 13 188 104 238 55 35 121 68 115 255 49 113 173 133 32 203 194 227 251 139
230 91 0 185 97 106 128 66 154 145 246 244 81 76 75 28 158 15 151 226 212 110 59 78 120 176 5 41
204 87 224 72 58 153 62 30 155 232 254 135 43 4 184 46

Source sequence #2 - Random_Binary_2

231 21 196 167 205 113 76 175 232 116 129 9 114 19 100 236 103 39 160 241 105 151 57 161 83 244
249 3 24 89 159 77 147 235 165 201 168 144 164 170 217 155 150 32 91 210 149 148 181 203 101
179 78 242 189 4 187 200 169 37 123 61 111 43 192 216 250 228 233 2 121 72 142 133 53 31 197 224
194 135 80 26 176 185 108 154 208 137 229 84 42 213 211 65 146 16 15 130 227 38 25 50 195 8 156
49 94 177 54 1 20 198 27 186 75 110 162 93 136 218 67 58 47 212 18 60 117 102 182 6 33 120 81 106
64 96 173 174 223 243 56 62 245 95 45 79 44 131 82 55 141 234 7 153 247 73 180 41 183 68 97 13
246 10 191 63 87 22 219 230 158 122 206 128 214 5 193 199 178 252 59 90 115 88 119 204 209 188
46 254 14 71 23 51 215 92 251 139 226 85 17 239 125 163 145 98 34 255 112 36 40 138 86 220 221
248 172 171 134 124 207 184 28 166 30 0 237 69 104 48 253 152 222 238 29 126 52 11 140 240 35
109 107 190 202 157 127 74 132 118 66 12 225 99 70 143

Output sequence #3 - Random_Binary_3

235 254 105 25 177 136 43 238 251 124 116 220 71 173 120 158 52 171 95 214 47 2 229 76 175 157
74 255 22 224 10 129 57 152 121 17 9 217 162 225 146 6 230 228 138 165 139 84 0 196 178 80 92 65
151 14 125 209 216 56 115 88 141 210 85 77 29 78 27 164 199 16 240 48 101 117 18 81 89 54 188
148 45 99 50 200 239 226 123 172 36 5 7 55 109 35 98 154 185 211 232 252 112 64 160 187 174 221
122 246 33 132 191 39 176 192 102 104 91 208 167 179 28 8 241 133 107 66 61 108 60 41 97 206 190
189 244 62 44 181 249 166 59 42 51 135 131 82 63 161 114 38 93 72 184 144 21 126 227 34 11 13
118 212 40 150 3 245 218 168 15 198 87 248 223 75 53 68 195 23 134 100 180 170 207 219 90 242 1
49 103 83 19 46 156 140 4 201 58 233 110 143 203 186 128 106 147 163 215 69 12 243 253 213 231
204 130 94 182 250 247 79 127 202 26 197 31 24 183 236 234 237 86 20 37 194 67 193 113 155 145
137 30 142 169 153 111 159 73 222 70 96 32 205 119 149

Enter sequence #1 above.   Click Write to file:   Binary, and output Random_Binary_1.   When done, click Write to file:   Decimal, and output Random_Binary_1.txt.   Click Close.

Click Button Rows, again.   Enter sequence #2 above.   Click Write to file:   Binary, and output Random_Binary_2.   When done, click Write to file:   Decimal, and output Random_Binary_2.txt.   Click Close.

Open Random_Binary_1.txt and Random_Binary_2.txt.   Compare Random_Binary_1.txt with sequence #1, above.   Compare Random_Binary_2.txt with sequence #2, above.   If you did not make any mistakes, each of your files should match one of the sequences above.   This proves that Button Rows operates exactly as described.   Close both .txt files.  

From the BulletProof start-up window, go to:   Utility Programs -> Two Array Scramble.   This program uses Random_Binary_1 to index Random_Binary_2 and outputs the result:   Random_Binary_3.  

Click Start.   Open Random_Binary_1 for your index file.   Open Random_Binary_2 for your source file.   Click the Write to file:   Binary button.   Save as Random_Binary_3.   When done, click the Write to file:   Decimal button.   Save as Random_Binary_3.txt.   Click Close.

Click Two-Array Scramble, again.   Check the Create RandOut10X.otp file box.   Click Start.   Open Random_Binary_1 for your index file.   Open Random_Binary_2 for your source file.   Save as RandOut101.otp.   When done, click Close.

Checking the Create RandOut10X.otp file box writes the same 256-number sequence #3, above, to the output file just like when the box is unchecked.   But at that point, the previous source sequence becomes the next index sequence and the last output sequence, in this case, sequence #3, becomes the next source sequence.   Then using these different index and source, a new output sequence is written to the output file.   This process is continued until 18,144,000 bytes have been output.   RandOut101.otp contains 70,875 completely different 256-byte random number sequences.

From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Read Binary File.   Click Start.   Enter RandOut101.otp for the input file.   Enter ReadFile_1_Rand101 for the output file.   Leave 0 in the Offset editbox.   Click Continue.   Enter 256 in the bytes to read editbox.   Click Begin.   When done, click Close.

We're going to do the same thing three more times.   Click Read Binary File.   Click Start.   Enter RandOut101.otp, again for the input file.   Enter ReadFile_2_Rand101 for the output file.   Enter 256 in the Offset editbox.   Click Continue.   Enter 256 in the bytes to read editbox.   Click Begin.   When done, click Close.

Click Read Binary File.   Click Start.   Enter RandOut101.otp, again for the input file.   Enter ReadFile_3_Rand101 for the output file.   Enter 512 in the Offset editbox.   Click Continue.   Enter 256 in the bytes to read editbox.   Click Begin.   When done, click Close.

Click Read Binary File.   Click Start.   Enter RandOut101.otp, again for the input file.   Enter ReadFile_4_Rand101 for the output file.   Enter 768 in the Offset editbox.   Click Continue.   Enter 256 in the bytes to read editbox.   Click Begin.   When done, click Close.

Click Binary to Decimal.   Click Start.   Enter ReadFile_1_Rand101 for the input file.   Enter ReadFile_1_Rand101.txt for output.   When done, click Close.

We're going to do the same thing three more times.   Click Binary to Decimal.   Click Start.   Enter ReadFile_2_Rand101 for the input file.   Enter ReadFile_2_Rand101.txt for output.   When done, click Close.

Click Binary to Decimal.   Click Start.   Enter ReadFile_3_Rand101 for the input file.   Enter ReadFile_3_Rand101.txt for output.   When done, click Close.

Click Binary to Decimal.   Click Start.   Enter ReadFile_4_Rand101 for the input file.   Enter ReadFile_4_Rand101.txt for output.   When done, click Close.

Open ReadFile_1_Rand101.txt, ReadFile_2_Rand101.txt, ReadFile_3_Rand101.txt, ReadFile_4_Rand101.txt.   These four files are the first, second, third, and fourth 256-byte sequences from the RandOut101.otp file.   RandOut101.otp is the chained output from the Two-Array Scramble program where sequence #1 and sequence #2, above, were input.

When the Create RandOut10X.otp file box was unchecked, Two-Array Scramble only output sequence #3, above.   Looking at ReadFile_1_Rand101.txt, we see that the first 256-byte sequence from the chained RandOut101.otp file is the same sequence #3.   Knowing how the chained Two-Array Scramble Utility Program works and knowing that the input used in both runs of Two-Array Scramble was the same, we would expect this to be true.

We would also expect ReadFile_2_Rand101.txt to be the output of sequence #2 above indexing the new source sequence #3 that is ReadFile_1_Rand101.txt.   Let's see if this is true.

If you look at sequence #2 above, the first 5 numbers are:   231, 21, 196, 167, 205.   This tells us that if we index ReadFile_1_Rand101.txt using these numbers we should get the first 5 numbers in ReadFile_2_Rand101.txt.   If we look at #231 in the left column of ReadFile_1_Rand101.txt we find the number 237.   And this is the first number in ReadFile_2_Rand101.txt.   Continuing this process, looking at the numbers 21, 196, 167, 205 in the left column of ReadFile_1_Rand101.txt we get the numbers 21 -> 2, 196 -> 4, 167 -> 245, 205 -> 106 or 2, 4, 245, 106.   These are the same numbers that come after 237 at the beginning of ReadFile_2_Rand101.txt.   Continuing this procedure, you can verify all of the numbers in ReadFile_2_Rand101.txt are exactly as expected.

Verify the subsequent 256-number sequence in ReadFile_3_Rand101.txt by using ReadFile_1_Rand101.txt to index ReadFile_2_Rand101.txt.   And verify the subsequent 256-number sequence in ReadFile_4_Rand101.txt by using ReadFile_2_Rand101.txt to index ReadFile_3_Rand101.txt.   Etc.   Etc.   So this proves that Two-Array Scramble operates exactly as described.   Manually change the name of the chained RandOut101.otp file to SavedChained_RandOut101.otp.

Button Rows / Two-Array Scramble can be useful in the production of the BulletProof final useable random binary numbers.   Let's say you have generated 14 RandOut10X.otp files then delete one of them.   If you create one additional chained RandOut10X.otp file using the Button Rows / Two-Array Scramble programs with true random number sequences for input, you can replace the missing RandOut10X.otp file.   If you then thoroughly shuffle all 14 files together, you will have added an external level of security not easily accounted for into the final useable random numbers.

Delete all files except:   MixFile.otp, MixFile101.otp, MixFile102.otp, MixFile103.otp, SavedMed_RandOut101.otp, Saved_RandOut101.otp, Saved_RandOut102.otp, SavedBig_RandOut101.otp, AutoFile_MixFile_1.otp, AutoFile_RandOut_1.otp, SavedMed_LoadFile, SavedBig_LoadFile, SavedChained_RandOut101.otp.

Here is why you saved those RandOut10X.otp files.   From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Random Number Statistics.   Click Start.   Open SavedBig_RandOut101.otp containing 2,032,128,000 bytes.   Save as SavedBig_RandOut101_RStats.txt.   This process took nine minutes on my computer.   When done, click Close.   Here is a short excerpt from the output.

File Name:   SavedBig_RandOut101.otp
File Length:   2032128000
Ideal number of occurrences:   7938000

Binary number:    0    -    occurrences:    7931973    deviation:    -6027      0%
Binary number:    1    -    occurrences:    7937432    deviation:    -568        0%
Binary number:    2    -    occurrences:    7936313    deviation:    -1687      0%
Binary number:    3    -    occurrences:    7941120    deviation:    3120       0%
Binary number:    4    -    occurrences:    7944249    deviation:    6249       0%
Binary number:    5    -    occurrences:    7939983    deviation:    1983       0%
Binary number:    6    -    occurrences:    7939117    deviation:    1117       0%
Binary number:    7    -    occurrences:    7939666    deviation:    1666       0%
Binary number:    8    -    occurrences:    7938282    deviation:    282         0%
Binary number:    9    -    occurrences:    7939370    deviation:    1370       0%
Binary number:    10    -    occurrences:    7936756    deviation:    -1244    0%
Binary number:    11    -    occurrences:    7940552    deviation:    2552     0%
Binary number:    12    -    occurrences:    7931576    deviation:    -6424    0%

At the top you see the file name and file length.   The ideal number of occurrences means that ideally in a random process you would expect from a file of this size that any given number would be present as much as any other.   Therefore, if that in fact did occur, each number would appear equally and since there are 256 numbers, each would appear (file size / 256) = Ideal number of occurrences.   In this case:   7,938,000.

Each line from top to bottom details a number from 0 - 255:   how many times it actually appeared in the file, how much this deviated from the ideal and the percentage deviation.   The larger the random number file the more it should tend to have zero deviation and vice versa.   In this case every number, although some deviation did occur, was always less than 1%.   Only five numbers exceeded a deviation of 9999 and the largest was 13,012.   Note that a 1% deviation would be 79,380.

Click Random Number Statistics.   Click Start.   Open SavedMed_RandOut101.otp containing 254,016,000 bytes.   Save as SavedMed_RandOut101_RStats.txt.   This process took about one minute on my computer.   When done, click Close.   Here is a short excerpt from the output.

File Name:   SavedMed_RandOut101.otp
File Length:   254016000
Ideal number of occurrences:   992250

Binary number:    0    -    occurrences:    991792    deviation:    -458      0%
Binary number:    1    -    occurrences:    991099    deviation:    -1151    0%
Binary number:    2    -    occurrences:    992908    deviation:    658       0%
Binary number:    3    -    occurrences:    992645    deviation:    395       0%
Binary number:    4    -    occurrences:    993539    deviation:    1289     0%
Binary number:    5    -    occurrences:    990457    deviation:    -1793    0%
Binary number:    6    -    occurrences:    992159    deviation:    -91        0%
Binary number:    7    -    occurrences:    992787    deviation:    537       0%
Binary number:    8    -    occurrences:    992269    deviation:    19         0%
Binary number:    9    -    occurrences:    991763    deviation:    -487      0%
Binary number:    10    -    occurrences:    992698    deviation:    448     0%
Binary number:    11    -    occurrences:    993116    deviation:    866     0%
Binary number:    12    -    occurrences:    992566    deviation:    316     0%

Click Random Number Statistics.   Click Start.   Open Saved_RandOut101.otp containing 18,144,000 bytes.   Save as Saved_RandOut101_RStats.txt.   When done, click Close.   Here is a short excerpt from the output.

File Name:   Saved_RandOut101.otp
File Length:   18144000
Ideal number of occurrences:   70875

Binary number:    0    -    occurrences:    71079    deviation:    204           0%
Binary number:    1    -    occurrences:    70660    deviation:    -215          0%
Binary number:    2    -    occurrences:    71140    deviation:    265           0%....
....
Binary number:    164    -    occurrences:    70958    deviation:    83         0%
Binary number:    165    -    occurrences:    70754    deviation:    -121      0%
Binary number:    166    -    occurrences:    70111    deviation:    -764    -1%
Binary number:    167    -    occurrences:    71150    deviation:    275       0%
Binary number:    168    -    occurrences:    71297    deviation:    422       0%...
....

Remember that each of these saved RandOut10x.otp files came directly from the Random Number Generator Utility Program using the same MixFile10X.otp files with all Rotate and Offset inputs set at 0.   For the 2,032,128,000 byte file, I also calculated the average magnitude of the twenty-two largest deviations and found that it was 0.111%.   For the 254,016,000 byte file, I also calculated the average magnitude of the fifteen largest deviations and found that it was 0.248%.   For the 18,144,000 byte file, I also calculated the average magnitude of the sixteen largest deviations and found that it was 0.822%.   You can see that as the files get smaller that this percentage goes up.

We saved the LoadFiles for the 2,032,128,000 byte file and the 254,016,000 byte file.   They are SavedBig_LoadFile.otp and SavedMed_LoadFile.otp, respectively:   1343295 2187 0 0 and 1565220 273 0 0.   The first integer is the Offset.   The next integer is the MixFile103 Rotation.   And for your information, the next is the MixFile102 Rotation and the last is MixFile101 Rotation.

For SavedBig_RandOut101.otp there were (2187 * 3628800) + 1343295 = 7,937,528,895 digits generated to get the 2,032,128,000 random binary triplets.   7,937,528,895 / 3 = 2,645,842,965 raw triplets.   And we know that approximately 76.8% are used.   So we would expect about 0.768 * 2,645,842,965 = 2,032,007,397 binary triplets.   So we actually got a little bit better efficiency from this particular true random input driven process.

For the 254,016,000 byte SavedMed_RandOut101.otp file the numbers work out to be (273 * 3628800) + 1565220 = 992,227,620 digits generated.   992,227,620 / 3 = 330,742,540 raw triplets..  about 0.768 * 330,742,540 = 254,010,271 binary triplets.

From the BulletProof start-up window, go to:   Utility Programs -> Additional Utility Programs -> Binary Number String Statistics.   Check the 3 radio button.   I reached into my bag of pennies and withdrew a 12, 159, and 55, so enter 12 in the 1 editbox, 159 in the 2 editbox, and 55 in the 3 editbox.   Click Start.   Open the 254,016,000 byte SavedMed_RandOut101.otp file.   My result was 14 hits.   To the right of the 3 editbox it says that ideally you should get 1 hit for every 16,777,216 bytes.  Since my file is 254,016,000 bytes I should get 254,016,000 / 16,777,216 = 15.14 hits.

I reached into my bag of pennies, again, and got 244, 22, 214.   Click Again.   Check the 3 radio button.   Enter 244 in the 1 editbox, 22 in the 2 editbox, and 214 in the 3 editbox.   Click Start.   Open the 254,016,000 byte SavedMed_RandOut101.otp file.   My result was 19 hits.

I reached into my bag of pennies, again, and got 145, 99, 132.   Click Again.   Check the 3 radio button.   Enter 145 in the 1 editbox, 99 in the 2 editbox, and 132 in the 3 editbox.   Click Start.   Open the 254,016,000 byte SavedMed_RandOut101.otp file.   My result was 18 hits.

We know that sequence #3, above, is the first 256-number sequence in the SavedChained_RandOut101.otp file.   We'll use several 2-byte, 3-byte, and 4-byte strings from the beginning of sequence #3 and open SavedChained_RandOut101.otp for input.   Let's see if the sequences in the chained file are really very different from each other.   Then I'll try to put the results into perspective.

Referring to the table below:   each row is numbered at the left from 0 - 19.   Starting at row 0 in column two are the first 20 numbers from sequence #3:   235, 254, 105...   Now, let's say I wanted to run the Binary Number String Statistics program and input a 2-byte string.   Starting at row 0, I'd choose 235 then go down and choose 254.

Click Again.   Check the 2 radio button.   Enter 235 in the 1 editbox and 254 in the 2 editbox.   Click Start.   Open SavedChained_RandOut101.otp.   My result was 274 hits.   So column three is for 2-byte string results.

Now, let's say I wanted to input a 3-byte string.   Click Again.   Check the 3 radio button.   Starting at row 0, I'd choose 235 then go down and choose 254 then go down and choose 105.   Enter 235 in the 1 editbox, 254 in the 2 editbox, and 105 in the 3 editbox.   Click Start.   Open SavedChained_RandOut101.otp.   My result was 2 hits.   So column four is for 3-byte string results.

Now, let's say I wanted to input a 4-byte string.   Click Again.   Check the 4 radio button.   Starting at row 0, I'd choose 235 then go down and choose 254 then go down and choose 105 then go down and choose 25.   Enter 235 in the 1 editbox, 254 in the 2 editbox, 105 in the 3 editbox, and 25 in the 4 editbox.   Click Start.   Open SavedChained_RandOut101.otp.   My result was 1 hit.   So column five is for 4-byte string results.   Thus, each row of results is for 2-byte, 3-byte, and 4-byte strings that start at that row and they are found in columns three, four, and five, respectively.

From this table, it is clear that the longer the string, the more likely it is that the string will appear just once, in our case, or with randomly chosen strings, not at all, in general, because there are 256! unique possible 256-number sequences and any chained file you could possibly produce would be too small to contain a specific string of even 5, 6, or 7 bytes.   Although a couple of the 3-byte strings just tested showed a high number of hits, this is not unreasonable for any random process.   But once you get to 3-byte strings and greater the results immediately fall into line.

What this proves is that the 70,875 256-number sequences in a chained RandOut10X.otp file generated by the combined Button Rows / Two-Array Scramble programs using true random input are very different from one another.   Therefore a chained RandOut10X.otp file could be useful within the larger BulletProof random binary number generation process.

0    235    274    2    1
1    254    269    2    1
2    105    277    1    1
3      25    270    5    1
4    177    311    2    1
5    136    268    3    1
6      43    277    1    1
7    238    255    2    1
8    251    251    1    1
9    124    283    2    1
10      11    275    1    1
11    220    254    2    1
12      71    290    2    1
13    173    267    2    1
14    120    290    4    1
15    158    248    1    1
16      52    259    1    1
17    171    260    2    1
18      95    272    2    1
19    214    302    2    1

End of The Mother of All Tutorials.

We have finally finished.   You have endured and survived The Mother of All Tutorials:   "What doesn't kill me makes me stronger."

I don't say that the random numbers generated from the recommended operation of BulletProof are, in my opinion, secure.   I say that they can be absolutely secure with an appropriately long true random key and I prove it:   there is no question that this is fact.

If it were me considering some other random number generator or encryption software, I would not rely upon an "expert's" determination.   I wouldn't be persuaded by a proselytizer.   I wouldn't act on some converts opinion.   I would not trust any security product that I did not completely understand and knew was secure.   You shouldn't either.

BulletProof gives you the tools.   Use your imagination to maximize their usefulness.

Here is the secret to calculating the approximate value of very large factorials:   it's called the Stirling Approximation or Stirling's Formula, by Scottish mathematician James Stirling, circa 1730.   n! = (Sqrt(2pn)) * (n/e)^n, where p = 3.141592...  and e = 2.7182818...

The BulletProof source code is available on a non-exclusive basis but requires, along with a non-disclosure agreement, a rather large sum of money.

Cheers. 

 TOP       


Latest page update:   20 Jul '16
Page first published:   17 Jan '10