The experiments described involve the prediction of short sequences of bits, where the bits represent the four digit numbers produced by the Massachusetts lottery, as part of the Daily Numbers Game.  Beginning perhaps sixty years ago, AI researchers looked at Chess, working to build programs that could beat world-class human experts.  This took about forty years, though much of this time wasn’t a consequence of poor understanding of the problem, but waiting for sufficiently capable hardware.

I assume most of the visitors here have had the opportunity to download and run my C demo, (I’ve been distributing it for about two years, it’s free.)  The program predicts, one byte-at-a-time, data values in an unseen compressed file image.  I discuss this program in more detail below.  My point is that the system builds guess-values that work (if you doubt this, don’t argue, just run the demo;) but trying to use the program to predict file content that doesn’t actually exist, fails.

Again, using my original program, predicting an unseen file is easy, but attempting to predict a non-existent file produces nonsense.

Pursuant to this, I’ve developed and tested a second class of C demo’s, not focused on guessing the numeric value of unsigned bytes in unseen files but on reading ‘unavailable’ messages, (eg., the next-day numbers and most particularly, the content of messages not yet written.)  At this stage of my work I’ve had to employ a few ‘cheat’s, such as the use of a reduced character set, but the received messages are real.

Probably, about now I should reinforce my theme;  This is science, I’m a programmer doing computer science and mathematics.  Please don’t imagine anything else.

If you’d like a copy of my file-content predicting system, just send me an email, repeatable_compression@yahoo.com.

My point isn’t so much about this…  It’s that the program, though it does exactly what I claim for it, the unseen file must actually exist.  Trying to predict the contents of a file that doesn’t exist using my original class of  programs is a waste of time.  It won’t work.

My newer systems, based on different methodology can do this.

Neither my original work nor the newer systems are explicitly founded on  quantum mechanics, only based on well understood math and computer science, though of course the training and testing data models are different.  What is the methodology?, (it’s discussed below, but first read the Wikipedia article, the “Redskins Rule,”) here’s why…   One can’t pass information from the future to the present but one can take advantage of discovered correlations that, although not permanent, are expected to endure one more time, which is all that’s necessary.

One very practical note…, I don’t suggest using my programs for gambling. 

My original demo program worked by making a series of “cold” guesses (eg., guesses without corrective feedback.)  In the demo, each guess reduces the usual unknown byte value space of 0 .. 255 by about a bit and is right 75% of the time.  Allowing for the 25% mis-steps, the corrected range reduction was still better than a half bit per guess.

Once I understood why my original demo program didn’t work with forward message data I developed a series of experiments, much of my work of this kind is based on Spear’s GAC, and I have at least a preliminary means for passing several bits backward.

To survive genetically, a test result must be superior to the best result obtained using binomial expectation.

People who follow my work will recognize this:

Given:

int p = r >= d;

Where ‘d’ is a data byte from an unseen ‘client’ file;  Here, the input is a short message which shouldn’t exist at the time the experiment occurs.  ‘r’ is the value produced by a random number generator.

The above assignment, shown using C notation, assigns ‘p’ the value of one or zero.  Except of course, ‘d’ doesn’t exist.  So…

The simple function shown mimics the would-be assignment, without knowing ‘d’.  This function “rGEd” is correct 75% of the time.  The only requirement is that the ‘d’ content, whether a message or a file, be random-appearing, eg., be compressed or (less good, but works) XOR’ed text-type data.

// again, if you want the complete program, email me.

int
rGEd()
{
if ((raw <= 119)) return 0;
if ((raw <= 128) && (newSR >= 106)) return 0;
if ((raw <= 128) && (raw >= 124) && (oldSD >= -35)) return 0;
if ((raw <= 134) && (oldSRoldSD >= -29) && (newSRoldSD <= 100)) return 0;
if ((raw <= 143) && (newSRoldSD >= 108) && (newSR <= 88) && (newSR >= 83) && (oldSRoldSD >= 8)) return 0;
return 1;
}

With the objective that each experiment is expected to produce one guess, a guess that is correct with a probability of 0.75, and which correlates to a byte in some unseen forward message with a reliability of 60%, or so.  (Below that minimum figure-of-merit, why bother…)

For lottery data, testing with the Massachusetts DNG Evening game, (a fourteen bit event,) forward predicting each month produced 85% correct bits, about 10-15% better than my best binomial system.

Though please note, it’s one thing for it to work in the ‘lab’, something else for it to work in the field, as a usable system.

/*

Here’s what this ‘give away’ program does:

It predicts bytes in files which the program doesn’t have access to.

I assume that someone will compile the program and try it, use it.
This is so much better than thinking it’s impossible and doing nothing.

But keep in mind, this demo program was written and intended for
demonstrating that the bytes contained in a compressed file can be
predicted even without access to the file, that’s what this program does,
that’s all this program does.  This program is obsolete, it was built to show
that previously compressed file data can be predicted.

Read the technical notes below, part of ‘rGEd’.
*/

(Some includes deleted by wordpress.  Not important.  This code is easy to make work.)

/////////////////////////////////////////////////////////////////////////////

#define mask(n) ((1<<n)-1) #define rdm(n) ((random() >> 7) & mask(n))
#define rdm8() ((random() >> 20) & 255)

/////////////////////////////////////////////////////////////////////////////

typedef char *stx;

typedef unsigned char cnu;
typedef signed char cns;

typedef unsigned int inu;
typedef signed int ins;

typedef cns *csx;
typedef cnu *cnx;
typedef int *inx;

/////////////////////////////////////////////////////////////////////////////

FILE *iFILE;

int nCHAR, iDSN;

char DSN[4][99];

int raw, newSR, oldSD, oldSRoldSD, newSRoldSD;

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

int
rGEd()
{
// This predicts whether:
//
// int p = r >= d;
//
// ‘r’ is an unsigned character produced by
// the system random number generator.
//
// If ‘d’, the next byte were accessible.
// it’s better to read it. This program is
// useful in those circumstances where the
// file containing ‘d’ isn’t available.
//
//
// When ‘d’ doesn’t exist, given ‘r’,
// this function will mimic ‘p’, agreeing with
// ‘p’ 75% of the time.
//
// Please remember this is only a demo, production
// system’s, though much more complex, are fully
// accurate, never failing to produce the correct
// value of ‘p’. And my production code doesn’t
// mess around with bytes, but predict bits.
//
// Why is this better?, because bits are one/zero.
// Such values don’t require multiple passes.
//
//////////////////////////////////////////////
//
// And why is this valuable?
//
// Because knowing ‘p’ let’s us compute an estimate
// of ‘d’, a value otherwise unseen and unknown.
// ‘d’ can be a value in a file that doesn’t exist
// at the time the program is run or a byte in a file
// on another computer.
//
// If p == one, then we know that ‘d’ is in the range
// of:
// r .. 255
//
// and if p == zero, then we know that ‘d’ is in the
// range of:
//
// 0 .. r
//
//////////////////////////////////////////////
//
// So without reading the file we have an estimate
// of ‘d’. Not an exact value for ‘d’ but an estimate.
// By repeating this, doing this several times, these
// estimates further constrain the possible range of
// ‘d’.
//
//////////////////////////////////////////////
//////////////////////////////////////////////
//////////////////////////////////////////////

if ((raw <= 119)) return 0;
if ((raw <= 128) && (newSR >= 106)) return 0;
if ((raw <= 128) && (raw >= 124) && (oldSD >= -35))
return 0;
if ((raw <= 134) && (oldSRoldSD >= -29) && (newSRoldSD <= 100))
return 0;
if ((raw <= 143) && (newSRoldSD >= 108) && (newSR <= 88) && (newSR >= 83) && (oldSRoldSD >= 8)) return 0;
return 1;
}

/////////////////////////////////////////////////////////////////////////////

long
sizeofFILE( FILE *f)
{
long current, filesize;
current = ftell(f);
fseek(f, 0L, SEEK_END);
filesize = ftell(f);
fseek(f, current, SEEK_SET);
rewind(f);
return filesize;
}

/////////////////////////////////////////////////////////////////////////////

void
testPartiallyPredictBytes()
{
int i, count=0;

int sr = 0;
int sd = 0;

// just examples of how to open a file in C.
iFILE = fopen(“in”, “rb”);
// iFILE = fopen(“thunderbird-31.3.0.source.tar.bz2”, “rb”);
nCHAR = sizeofFILE(iFILE);

for(i=0;i<nCHAR;i++) { cnu jaz = rdm8(); cnu dat = jaz ^ fgetc(iFILE); int actFLAG, prdFLAG; raw = rdm8(); actFLAG = raw >= dat;

oldSD = sd; oldSRoldSD = sr – sd;
sr += raw; newSRoldSD = sr – sd;
newSR = sr;

prdFLAG = rGEd();

// printf(“%d%d\n”,actFLAG,prdFLAG);
if (actFLAG == prdFLAG) ++count;

sd += rdm8();
sr /= -2;
sd /= -2;
}

fclose(iFILE);

// show single-pass merit, typically about 75%.
printf(“%6.3f%% %d\n” , (100. * count) / nCHAR , nCHAR);
// show single-pass merit, typically about 75%.
}

/////////////////////////////////////////////////////////////////////////////

void
buildPredictedMap(int mCHAR, char *predictedMAP)
{
int i;

int sr = rdm8();
int sd = rdm8();

for(i=0;i<mCHAR;i++) { raw = rdm8(); oldSD = sd; oldSRoldSD = sr – sd; sr += raw; newSRoldSD = sr – sd; newSR = sr; predictedMAP[i] = rGEd(); sd += rdm8(); sr /= -2; sd /= -2; } } ///////////////////////////////////////////////////////////////////////////// void main() { int i, nByteLen; char fileName[128]; char *predictedMAP; char *actualbitMAP; fprintf(stderr,”First, without knowledge of the file to be compared against,\n”); fprintf(stderr,”this program predicts an arithmetic relation (“>=”), comparing\n”);
predictedMAP = (char *)malloc(nByteLen);
buildPredictedMap(nByteLen, predictedMAP);

fprintf(stderr,”Here are the first 60 bits that were predicted.\n”);
for(i=0;i<60;i++) fprintf(stderr,”%d”,predictedMAP[i]);
fprintf(stderr,”\n”);

fprintf(stderr,”Enter the name of an existing file: “);
fscanf(stdin,”%s”,fileName);

fprintf(stderr,”and now it’s length in bytes: “);
fscanf(stdin,”%d”,&nByteLen);

fprintf(stderr,”File %s is %d bytes, right?\n”,fileName,nByteLen);

actualbitMAP = (char *)malloc(nByteLen);
buildPredictedMap(nByteLen, actualbitMAP);

}