Copyright: Made with Shalom Help Maker www.danish-shareware.dk/soft/shelpm/


Welcome to WINHunter

Welcome to the newest, most advanced Lottery prediction and forecasting software on the internet to date.  WINHunter is deisgned using the latest ideas and concepts using the Visual Basic® programming language.  WINHunter is released as an Opensource software project, which means it is totally free for you to use and enjoy, as well as for software developers to jointly advance the project further.  Your input is appreciated and desired in this project, WINHunter is what it is today because of users like you.

The WINHunter home can be found on the internet at winhunter.lottotutor.com.  Also, the Project Home can be found at Sourceforge.net.

You can expect to take some time to learn what WINHunter is all about.  Don't expect fast results your first time working with WINHunter.  Simply put, WINHunter is a Filter designer.  You can design simple Filters, or large complex ones.  You can Stack Filters, or Group them together.  How you build your design is totally up to you!


Getting Started

In order to use WINHunter, it is best to understand the basic functionality of WINHunter itself.  To better familiarize you with WINHunter, let's tell you what WINHunter is NOT.

WINHunter is not,
...A Wheel Generator or Wheel/Line Analyzer
...A Statistical Analysis Tool
...A Simple point and click Application

No longer do you have a limited set of Filters with fixed values for Filters like other Lottery software tools.  WINHunter is totally exposed to the user, allowing every setting possible to be adjusted and Optimized using the built in Filter Optimizer.

Via your internet connection, you can download drawing History files and add/update plugins as you so desire.  Also, you can register with a Distribution Server and process Stacks users have submitted for distributed processing.

For a better WINHunter experience, it is best to understand a little about why WINHunter was developed, and why it is designed to eliminate numbers the way it is.  Beyond that, to just jump right in, go ahead and load a History file and poke around!


Loading a History File

To load a history file, simply right click on the WINHunter icon in the treeview and select "Open History".

This will open the file open dialog box (which defaults to the folder).  Select your file and click OK, or just double click the file you want to load.  This will load the history into WINHunter without a Stack.  You must then load, or add a new Stack to the loaded history.

Please notice that a Machine is loaded for each individual Machine that is detected from the History file.

(If this is the first time you are loading a History file, then follow the on screne prompts, as described below.)

When loading a History file for the first time, you will be promted for information regarding the nature of the game the History file represents.  WINHunter will interview you according to how you answer each specific question.

At first, WINHunter will ask you exactly how many Machines does this History file represent.  Cash 3 games usually have 3 Machines, pick 4 have 4 Machines, power/bonus games have two Machines, and typical Lottery and Keno games have just one Machine.  WINHunter makes this Machine distinction because it tracks the draw performance of the Machine design itself.  WINHunter concepts assume that the Machine itself helps dictate the overall outcome possibilities of the game.  Some would argue this point, but so far nothing has been done to prove or disprove this theory.

Once you have specified the number of Machines, WINHunter will ask you more specific details about each Machine.  It will first ask you what the highest ball number is for the Machine FIRST represented in the History file.  The next question is whether or not the 1st or lowest number ball in this Machine is a 1.  The third question is how many draws occur from this Machine.  WINHunter will either be done with the interview, or it will continue with the interview for the next Machine.  If this is a power/bonus ball lottery, WINHUnter will ask you yew/no if it is after it asks you waht the lowest ball number was.  If yes, then it will ask you if the bonus/power ball is required to win the jackpot.
Once you have completed the interview, you will not be promted again for that History file.  Any loads thereafter will load autmoatically based on your input.


History File Machine Representation

The first machine is the first number, or group of numbers that were drawn as read from a single line from left to right.


History File Mistakes

If you make a mistake during your interview, you can go back into the history file and delete the topmost line from the file and try re-loading it again.


Building a Stack

Building a Stack is one of the most important concepts to understand in WINHunter.  To begin to get a grasp on how to do this, you must first understand how to build Groups and Filters.  With the understanding of those two elements, you will then begin to fully understand what a stack is all about.

A Stack is comprised of one, or many Groups of Filters.  This Stack represents a complete Filter design element that can generate output prediction data.  By right clicking on the Stack Icon, you can add a Group element.  Each new Group is added BELOW the bottom most Group element in the tree view.  This new Group element becomes the final output of the Stack.  To start out building a Stack, simply add a single Group element, and begin working with it.  Once you have this Group element add Filters, Triggers, Processors and choose a Selector.  Keep in mind the Selector belongs to the Group element you are working with, and is the final stage of that Group's output, and dictates the input of ANY succeeding Groups in the output path of that Group element.

You will notice in the above example that this Stack contains three Groups.  The first Group passes it's output information to the second Group, and the second Group passes it's output information to the thrid Group.  By arranging Groups inside of a Stack in this manner enables WINHunter to accomplish series processing.  Also, this series processing is more or less a successive filtration process.  Each Group filters (or eliminates) numbers based on the Filter(s) contained inside that Group, and the Selector processing the total.  For a single stage Stack, just add more and more Filters to a single Group and increase the "Minimum to Select" value for the Selector you have chosen.

Each Group must contain at least one Filter element inside of it.  The main reason you would add more than one Filter is because you need to adjust the "Use/Skip" or "Cycle On/Off/Start" values for each Filter inside that Group.  Any other reason can typically be accomdated by simply adjusting the weight value for the appropriate Processor within the Filter element accordingly.

Once you have settled on a basic Stack design, the you start Optimizing the Filter/Processor setttings within each Group in the Stack you are working on.  Optimization can be a long drawn out process, but is always well worth the time invested.


Single Hit Processor

This Processor is comprised of two individual Rules which derive their scores from a single data source.  This data is derived by counting how many times a number has hit over a set amount of drawing history.  Those two Rules are the Single Hit Count Rule and the Max Hit Count Rule.

The Single Hit Count Rule generates three ranges based on a calculation of the final Highest and Lowest values.  These SingleHit values determine what Single Hit weight value to apply for each individual number's score.

The calculation is as follows:
Range = (Fix(((Highest - Lowest) / 7) * 6) / 2) - 1
If SingleHit < Lowest + Range Then
use LowWeight
ElseIf SingleHit > Highest - Range Then
use AvgWeight
Else
use HighWeight
End If

The Max Hits Count rule increses the score if the SingleHit count is less than the user input MaxHitCount value.


Pair Hit Processor

This Processor is comprised of a single Rule which derives it's score from a single data source.  This data is derived by counting how many times a pair number has hit over a set amount of drawing history.  That Rule is the Pair Hit Count Rule.

The Pair Hit Count Rule generates three ranges based on a calculation of the final Highest and Lowest values.  These PairHit values determine what Pair Hit weight value to apply for each individual number's score as part of the pair..

The calculation is as follows:
Range = (Fix(((Highest - Lowest) / 7) * 6) / 2) - 1
If PairHit < Lowest + Range Then
use LowWeight
ElseIf PairHit > Highest - Range Then
use AvgWeight
Else
use HighWeight
End If

It then Calculates a second range for the scores from the first Range based on the same calculations. Since the total scores generated tend to be rather high, this re-ranging and scoring brings the scale of the scores back into an acceptible level.


Compund Hit Processor

This Processor is comprised of four individual Rules which derive their scores from three data sources.  This data is derived by counting how many times a number has hit over a set amount of drawing history.  Those four Rules are the Overdue Rule, Not Recent Rule, Repeatability Rule and the Under Max Repeats Rule.

The Overdue Rule finds the longest period between two separate hits for each individual number based on the range of draws the user has input, and then checks to see how recently it has hit. If the Longest period of time is greater within that range, then the number is overdue to be hit and it's score will be increased by the weight value.

'how long is too long for a hit NOT to come in?
>Not Recent Rule
Not Recent Weight
Hit Span(Gap) Value
The Not Recent Rule is similar to the Overdue Rule, but allows the user to set a fixed limit for ALL the numbers based on the range of draws the user has input, instead of a variable value for the Longest peroid of time between separate hits. It compares how recently the number hit against the user value, and if the user value is lesser (in other words, the number hit several draws ago), then the number is not recent enough, and is again Overdue to be hit and it's score will be increased by the weight value.

This function would be best suited to find your Cold numbers.

'repeatability is how many times total the number EVER repeated
>Repeatability Rule
Repeatability Weight
Under Total Repeats Value
This function totals up the occurences of a repeat hit of the numbers based on the range of draws the user has input. For example, if a number hit and then hit again the next draw, it would have a repeat value of 1. If it hit, hit again, and hit again for a third time, then the repeat value would be 2. Then the function tests the final repeatabilty values against the user input test values for each occurence of the number in the specified drawing history. If the values are less than the user selected value, then the score is increased.

DEVELOPER NOTE: This function appears to score in a manner that does not make sense. It increases the score for EACH OCCURENCE of the number in the drawing history period as specified by the Use/Skip range. Should this function ONLY look at the last drawing (most recent) in the history to determine if the numbers might repeat again? This would produce more realistic score values for a large span of historical data.

'This Routine only looks to see how many times the ball
'has repeated in the last ? (Max Repeats Value) drawings
'if it is under the maximum repeats, then we give it a score
>Under Max Repeats Rule
Under Max Repeats Weight
Max Repeats Value
This function looks to see if the number in question has exceeded the maximum number of repeats detected within the history range specified. It currently only looks at the last three drawings to count the repeats from the previous draws. It primarilly does this right now because I have not yet seen 4 consecutive repeats. If the number is under the maximum repeats, then increment the score value. Basically, this filter will eliminate numbers that have met or exceeded their maximum repeat values during a given period of history (skip & use history.)

DEVELOPER NOTE: If at user request, a combobox for the Repeat count could be added, with a default to three repeats.


Previous Draws Processor

---Previous Drawings Processor---
>Previous Drawings Rule
Qty of Previous Draws to Test
Previous Drawing Weight (Subtractive)
This function simply subtracts the weight value from the score for each occurence of the number in the Previous Draws from the history the user has specified. The Previous draws are those draws after the SKIP value (from the Skip/Use values).


Match Scan Processor

---Match Scan Processor---
'this rule tests the latest drawing against the other drawings
'and test's for 4of6 to 6of6 matches
'and deducts for higher match counts
>Match Scan Rule
Match Weight (Subtractive)


Sequence Scan Processor

---Sequence Scan Processor---
>Sequence Scan Rule
Sequence Weight (Subtractive)
This function merely looks to see how many sets of sequences it finds, and subtracts the score value for each number in a sequence of 3 or more (i.e. 1/2/3, 2/3/4, 20/21/22/23.) So far, I have not seen very much use of this function, but it is here for use anyway. So, you will rarely ever see it actually perform a calculation, because not very many sequences actually play from draw to draw.

DEVELOPER NOTE: This function could also look for addition sequences, as well as multiplicative sequences, but does not currently do so.


Red Bus Processor

---Red Bus Processor---
'There are 7 buses. There are 7 drivers. There are 3 conductors. There are 9
'passengers in each bus.
'
'In the UK National the latest draw was 667: and these balls were drawn.
'
'4,6,10,19,40,49 BB 10 these are the 'Drivers' of the Bus. The drivers are always the
'latest balls drawn in the uknational.txt file
'
'The conductor is the next occurance of a ball number (each driver) as you look down the
'UK Lottery results table. the uknational.txt file.
'
'There are three conductors for each driver.
'Each conductor is responsible for three passengers.
'These passenger are
'and | and /
'Left diagonal, vertical and right diagonal.
'
'A Red Bus can now be visualised as consisting of a driver, three conductors and 9
'passengers.
>Red Bus Rule
Driver Position Values (String)
Conductor Count Value
'O<^X1 O^X2 O^>X3
'Here is the action legend:
'O - start from Conductor position
'^ - Up one drawing in the history
'<>- move one position left or right in the drawing
'X# - save current position, with # score weight
Passenger Selection String

This processor seems to act more in a random manner for number selection, and even in some instances has a better successful elimination percentage when used in the first stage (group) of a filter design.

DEVELOPER NOTE: This function needs a method for WINHunting the Passenger selection value. Perhaps user settings of "Max Moves" and "Min Moves" would give another function enough information to enable it to generate a range of combinations of moves.


Position Gap Processor

---Position Gap Processor---
'the broader the range, the more likely the numbers at the ends
'of the range are what should be played
'For Example:
'3's and 5's keep being drawn in the first position
'the meanposition value would be 4
'and the position gap would be 3
'so the span would be 3,4,5
>Gap Rule
Gap Weight
Maximum Gap Value

This processor calculates the Gap between the highest and lowest values of the actual number position in the ascending order drawing. It is essential that the user understand that the drawing from the history has been re-ordered into ascending order (1 to X). Then the highest and lowest values are determind for each position, and the numbers within each position Gap are scored.


Perkisize Processor

---Perkisize Processor---
(with permission)
'We write out the numbers from 01 to 53 and from groups
'A and C place a check mark next to the number for each
'time it was drawn. At the end of this step you should
'have exactly 42 check marks.
'Second:
'From the B group, if the number already has a check when
'we get to it, we add the hit to the count with a check,
'but if and this is important, if there is NO check we put
'an "X".
'Third:
'From the E group, we don't add to the count, but if the
'number has NO check we put an "-X".
'Forth:
'This isn't the time, but if you were working with a last
'12 draws system you would add checks from the D group's
'frist two lines to the count of numbers with out "X" and
'"-X" marks.
>Perkisize Rule
Group A Count Value
Group B Count Value
Group C Count Value
Group D Count Value
Group E Count Value
Perkisize Weight

The origional perkisize method had set sizes for each group. I think there was 3 draws for group a, and 4 draws for group C, for a regular 6ofX lottery. The groups start in order from the most recent draw (group A), and go down to group C, and the amount of draws used total depends up your history file.

How to Eliminate More Numbers

Sometimes you want to remove more than six numbers from play
at a time.  The following method does this again about 45% of
the time.  It can NOT be used in conjunction with the above
method of eliminating the previous six numbers, in fact it
requires you play them.

Print out the last 20 draws or more, whatever's easiest.

Draw a line after the most recent 3, the next most recent 3,
then most recent 4, and the next two most recent 3.  This
gives us two groups of 3 draws, followed by a group of 4 draws
and finally two more groups of 3 draws.  Like this . . .

Group E
907 10/05/02 Sat 09-15-16-26-28-42
908 10/09/02 Wed 10-20-26-40-41-47
909 10/12/02 Sat 17-20-32-41-50-52
Group D
910 10/16/02 Wed 03-34-36-37-40-51
911 10/19/02 Sat 11-27-30-36-43-52
912 10/23/02 Wed 16-17-30-31-41-49
Group C
913 10/26/02 Sat 11-20-25-37-48-51
914 10/30/02 Wed 05-19-20-23-29-31
915 11/02/02 Sat 01-07-11-29-37-40
916 11/06/02 Wed 05-09-12-21-27-38
Group B
917 11/09/02 Sat 04-15-24-25-36-44
918 11/13/02 Wed 12-22-27-32-38-44
919 11/16/02 Sat 01-02-09-15-23-40
Group A
920 11/20/02 Wed 12-17-21-23-39-44
921 11/23/02 Sat 01-22-23-34-36-39
922 11/27/02 Wed 04-05-17-28-32-37

Write out the numbers in your game, in this case it would be
from 01 to 53.

If the number appears in group A or C make a check next to it.
When done you should have 42 check marks.  Count them.

If the number appears in group B or E and is not already
checked, put an "X" next to it. (ignore those with checks)

Play the numbers with and without check marks, don't play the
numbers with "X" next to them.

Let's see how this works out . . .

01 **   16 X    31 *    46
02 X    17 **   32 *    47 X
03      18      33      48 *
04 *    19 *    34 *    49
05 ***  20 **   35      50 X
06      21 **   36 *    51 *
07 *    22 *    37 ***  52 X
08      23 ***  38 *   53
09 *    24 X    39 **
10 X    25 *    40 *
11 **   26 X    41 X
12 **   27 *    42 X
13      28 *    43
14      29 **   44 *
15 X    30      45

As you can see we have 42 checks [*] and 11 with an "X" so we
eliminated 11 numbers from play.

And the winning draw on 923 11/30/02 Sat was 05-07-12-13-43-49
all from the checked and blank numbers a success!!!

As I said this works about 45% of the time.  When it does as
in this case we eliminated 11 numbers from play taking the
game from a 6/53 at 1 in 22.9 million odds to a 6/42 at 1 in
5.2 million a 17.7 million combination reduction in odds!!!

If this had been a 6/49 at 1 in 13.9 million combinations game
the successful elimination of 11 numbers would make it a 6/38
game for the draw at 1 in 2.8 million and this is before
you've created your first combination!


The WINHunter Concept

When first creating WINHunter, a filter consited of a fixed set of rules (or statistical analysis routines) that could be turned on or off awith adjustable values..  There was only one filter.  In testing this method, it seemed that this filter was not eliminating enough numbers.  So the next question was "What if more filters could be added, and the output of the first filter fed into the input of the second filter..." and there was the first concept of WINHunter born.

This simple "series" filtration seemed to work, but it still was limiting in what it allowed.  Besides that, the interface for adding more filters and adjusting them was cumbersome at best.  Even more troublesome was adding a new rule to the basic filter.  But for the time being, series filtration was it.  Filter Optimization was added, and a concept version of WINHunter was released.

This concept version of WINHunter is still available, and most of the ideas from the core of this project developed into what WINHunter is today.  Filtration started from a simple basic filter with selectable processors (rules), into series(the stack itself) and parallel (the group) filtration.

Here is a basic synopsis of how WINHunter is organized:

-Drawing History is defined by the Machines that produce the Historical data...
-A Machine is defined by the draws from that Machine.
-A Filter Stack is definded by multiple Filter Groups.
-A Filter group is defined by individual Filters. Each group passes its output to the next lower Group in the tree view. The group totals the individual scores of each filter and passes the SUMed results to the group's SELECTOR for inclusion/elimination of numbers.
-A Filter is defined by each Processor/Trigger that is enabled within the Filter. The Filter controls HOW MUCH Historical data is used/skipped. Also, a Filter controls which Processors it contains.
-A Processor analyzes historical data, as defined by the parent filter, and produces score values based on the weight value set by the user. This weight value enables the user to skew a particular processor's results over the other processors for that filter. If no weight value is set, then the processor does not produce a score for that function within the processor. Some processors combine several different Rules for a particular analysis. For example, the SingleHit processor can score High/Avg/Low, and it scan also score based upon Maximum Hit values.
-A Trigger analyzes historical data, as defined by the parent filter, looking for matching criteria based on the Trigger function. The Trigger can activate/deactivate it's parent Filter only. This makes the Filter itself more dynamic, thus the Filter becomes reactive based on the historical data itself.
-A Selector analyzes the Sum'ed scores of the Filters within that group and produces a list of eliminate/include numbers that will be passed to the next subsequent Filter Group in the stack. This group will then SELECT it's numbers based on the score values of the remaining numbers. This also causes the Filter stack itself to become reactive to the drawing history.

Here you see a Florida Lotto History file loaded, with a single Stack loaded.  There are three Groups, each group passes it's results into the next group, which makes it's selection based on the remaining selections of the input.  After the third group in the series, you see the Output icon, which denotes the final output of the Filter Stack.

In the first Group, you also will notice there are two Filters.  These filter operate independant of each other, but their final score output is totaled together and then passed into the Group Selector.

Within each Filter are individual Processors.  These Processors pull their Use/Bypass values from the parent Filter, which allows for parallel filtering capability.  Only one of each type of Processor can exist within a single Filter.  For multiple Processors, just add another Filter with the same parameters and components.


Working with Stacks

Stack: IS simply a collection of Groups. The stack is responsible for passing the output selections from the first group onto the next group in line. The stack is what is actually saved when you want to save a configuration. Stacks themselves are not configurable, only the items contained inside are configurable.  The only option Stacks do have is "Drawing to Stop at", and this option is to allow the user to define a point in a drawing history to stop testing.  This works well for histories with thousands of drawings.


Working with Groups

Group: IS imply a collection of Filters, along with a single Selector to determine the Group's final output selections. The Group is responsible for totaling up each of it's Filter's outputs and passing that output to the Selector. Groups themselves are not configurable either, like the Stack, the items contained within a group are configurable.


Working with Selectors

Selector: IS a unique function which looks at the output score of the Group and applies some type of formula to determine which scores actually are valid, and which scores are thrown out. The selector output's a list of numbers which are either to be used, or ignored based on the selector's function being used. Selectors are plugin upgradeable, only requiring a restart of winhunter when a new one is installed.

Currently, WINHunter only has 1 type of selector. This selector is linear in nature, and uses what I call a waterlevel. Let's say for example that you set the selector for High. This means that the selector will start with the highest scoring number (see the plot graph for the filter... GROUP plotting is to come later in winhunter). The selector then counts up the numbers that are at or above this waterlevel. IF the quantity of numbers is not within the range of the minimum, then the selector moves the water level down one notch, and compares again. It continues to do this until the quantity of numbers above the line are equal or greater than the minimum. The selector then marks these numbers based on the Exclude/Include setting. Either those numbers are marked for Exclusion, or Inclusion.

Now, if you chose LOW, then the water level works in just the opposite manner. The inverted High/Avg/Low work in the same manner as their NON-inverted counter parts. High is the same as inverted low, low is the same as inverted high (maybe I need to eliminate those two). But Inverted Average is not the same as average. This is because the Average setting starts it's waterlevel at the high end of the average range. So, on the inverted average, it is actually starting at the low end of the average range. Also, High/Exclusion is almost the same as Low/Inclusion. Depending on the score ranges of the filters pumping into the selector, they may not be the same at all.


Working with Filters

Filter: Is a collection of Processors/Triggers. The filter first runs the Triggers to determine if the Filter should run or not, if it has no trigger, then it looks to see if it has a cycle, if so, then it calculates the cycle period and turns on or off based on the cycle settings. The filter is responsible for controlling what portion of the history that the Processors and Triggers it contains look at. The filter is also resonsible for running each of it's individual Processors, and totaling up their scores and passing that total back to the Group.


Working with Processors

Processor: IS a unique function which applies a score (called a weight inside WINHunter) to each individual drawn number based on the actual processor's function. Weight Values can be between 0 and 9. (Processor Descriptions will follow later.) Only one processor type is allowed per Filter. Some processors can have multiple functions, and thus will have multiple weights that can be adjusted. A zero value for a weight will force the processor not to run that function. A processor is the lowest form of calculation in winhunter, and are plugin upgradeable, only requiring a restart of winhunter when a new processor is installed.


Working with Triggers

Triggers are a unique function which looks for certain criteria based on the Drawing History specified by the parent Filter. It will return a simple True/False to the Filter if the Filter should run or not.

When a Trigger is being used, the parent Filter will not run unless the Trigger activates it, regardless of the cycler settings in use.  the cycler however, does control when the Trigger will be run.  In other words, the Cycler will activate the Trigger, which will then either activate the Filter Processors, or not.

Multiple Triggers can be assigned to a single Filter.

Triggers are plugin upgradeable, only requiring a restart of WINHunter when a new one is installed.


AI - What does she think?

The Artificial Intelligent (Lifeform) is currently activated from within WINHunter, and will not allow WINHunter to respond fully to user input until it is stopped. Down the road, AI will be implemented outside of WINHunter, with WINHunter having the option to check-in with AI and get statistical data, progress, etc.

AI creates a Stack from scratch and assigns fuzzy logical values to the items she adds. She then tests that item against the most recent drawing (attempting to predict the last drawing of the history) and looks for favorable conditions. Those conditions are that all 6 matches are still within the predicted numbers, and that the predicted count is less than the total number of balls in that machine. AI gains confidence as she makes good decisions, and looses confidence as she makes bad decisions. Occasionally, she will decide to save the current Stack she is working on into a directory. When AI starts another new stack, she either starts again from scratch, or loads an already existing stack she saved previously. Once AI has greater than 99 files in her directory, she then goes through each file, and back tests the entire history with that Stack. She then looks again for favorable conditions, and decides based on those conditions whether to toss the file into the dump directory, or to keep it inside her own directory for later processing and manipulation.

Once you load a History, just right click on the Machine icon, and click "Start AI Lifeform". The monitor shows the status of AI while she is running. To load a Stack that AI created, just browse to the WINHunter directory from the load stack dialog box, goto the plugins/Shared/AI directory and load a stack from that directory. Once loaded, run a test of that Stack to review the results.


The Filter Optimizer

The Filter Optimizer is a WINHunter tool (actually, it IS the WINHunter) that tests all the settings defined by user set ranges for a filter and it's child processors (and maybe triggers too.)  The user adjusts the min/max values for each item in the Filter and Processor objects. The user then set's the starting values for these items, and selects what values to optimize during WINHunting.

The Filter Optimizer then runs tests against the back history defined by the user and calculates success rates based on several factors.  The following formula calculates the running success rate for
((# of Jackpots Matched / # of Drawings) * 100) * ((BallCount - Avg # Predicted that matched the Jackpot #s) / (BallCount - # Balls Drawn))

This will yield an average success rate for a period of draws.  I don't think I am talking about the same success rate as you are.  My single draw success rate is:

((BallCount - Avg # Predicted that matched the Jackpot #s) /
(BallCount - # Balls Drawn))

1> Load the history file of your choosing, preferably the one you want to win!

2> Once loaded, add a stack, group and then a filter. Right Click the Filter object and click ADD PROCESSOR.

3> Select the PERKISIZE processor from the list (you will most likely have to scroll down) and click OK.

4> Right click the filter again and click WINHUNTER.

5> Double click the FILTER & PERKISIZE items in the Optimizer Setup WIndow (tab).

6> Check the boxes (make them checked, not un checked) next to the top 5 options under Perkisize, and Check the box next to Perkisize itself.

7> Double click any of the options under the Perkisize method, and adjust the MAX values to 10 (they are 25 by default) and click OK.

8> Rightclick the PERKISIZE item in the LAYOUT (Overview, on the right side of the WINHunter screen) and click VIEW SETTINGS

9> Now adjust the upper 5 options from their defaults to 0, this is your starting point for the testing, and we want to start out fresh! Now set the Perkisize Weight to 1, and click OK.

10> On the Optimize Window, click RUN WIN Hunter! A new window will popup and show you the performance thus far, you can watch the optimizer window to see what values WINHunter is currently testing with. You can then click the Saved Results Tab to see what the optimizer thinks is the best settings thus far.

There is a third TAB on the optimize form called "Saved Results". This tab shows the best results from the optimization process. Inside each of those saved results is a copy of the stack in it's optimzed state, with the new settings which produced those results. The Picks column on this Tab is the average number of Picks the Stack produced overall for that test pass. The Hits column is the average number of hits that Stack produced for that test pass. The Success column shows the calculated overall Success Rate, and also shows the Prize Success rate respectively.

The first number is the draw number, with #1 being the most recent draw.
The second number is how many numbers were predicted.
Third is how many numbers matched.
Fourth is how many numbers you were trying to match.

The Stats at the top of this window show the running totals of the match counts for each individual pass of the optimizer.

You see above the performance levels of the current settings in use. What WINHunter is looking for, is the most Jackpot hits with the least amount of picks, based on averages of those numbers against the amount drawing history the user specified. This screen only shows you the CURRENT results, as they are happening. Here is a rundown of the items on this tab:

Average Picks:

Processor Count: Self Explanatory

Jackpot Hits: Count of Successful Predictions

Jackpot Picks: Average of the Qty of numbers of the Successful Jackpot Predictions

Average Hits: Average of the Qty of numbers of ALL the Predictions

Performance Ratio: AveragePredicted / AverageHits

Hit/Pick Ratio: ((Drawing Count - 1) / JackpotHits) / AverageHits

The ratios show a trend in the performance level of the filter, thus allowing better optimization of the filter. WINHunter will find the best possible values for a particular filter configuration. Keep in mind, this filter setup is also based upon the Selector of the group. If more than one filter is within the parent group of the filter being optimized, it is recommended that you leave the other non-optimized filters on, that way the test reflects the affects the other filters have on the filter being optimized.

Optimization can take a long time to complete, but in the end will test ALL of the possible filter settings that you configure it to test based on the ranges you set.


back history

Right clicking on a Stack and selecting VIEW SETTINGS,
you can select the number of draws WINHunter should run tests against.


History Files

From the very beginning, History data input was meant to be as simple as possible.  Most lottery historical data is available online for viewing, and even downloading.  A simple text version of a history file with draw dates and draw data is all that is truly needed in order for WINHunter to understand it.

WINHunter read's differing formats semi-intelligently based upon several known listing formats of lottery data.  One of the most important requirements is that the data be in ASCII text format.  Word Processor or Spreadsheet formats are not supported.  The most common formats supported are explain in more detail below.

LEGEND
--------------
Date - Date the actual drawing occured.  This date can be in almost any format, WINHunter tests for most date formats as it reads each line.

Actual - The actual drawing data.  This data MUST be in order by Machine.  The bonus/power machine is always the left most machine in the file.

Erroneous - Data that is not needed for WINHunter to process the history.  This can be anything from Prize details to what machine(s0 were used for that drawing.

Draw# - The actual Draw number as specified by that Lottery's commission.

KNOW SUPPORTED DATA FORMATS:

Date/Actual/Erroneous
Draw#/Date/Actual
Date/Actual
Date/Draw#/Actual

Keep in mind the above formats are available because of a simple loader routine that compares the data it is reading to a few known standard text types.

Also, at this time, WINHunter requires the draw data be in order of Most recent at the top, and oldest draw at the bottom of the file.


Testing Methods

Here is how you can quickly test the previous prediction after you add the latest draw. Add a value of one (1) to the skip value you currently have. This will cause the data WINHunter calculates to look exactly like what it previously ran BEFOER you ran the prediciton. Then set the <Stop At Drawing> value to one (1), this will cause the back testing to stop at the first drawing, thus showing you the graph for the resulting scores for that prediction test. Now, save this screenshot by pressing <ALT> & <PRINTSCREEN>. This will load your clipboard with a screen capture of the WINHunter window ONLY. Save a few of these back tests, and then you can come back and reference them later and compare the initial prediction data with later back test data. Also, the graph shows the selected nubers with green X'x, and the actual draw values in red +'s. Also, you can use this method to compare the score output of your different filter settings. BTW, turn off the different rules and re <RUN> the back test (with the <STOP AT> set to 1) and watch to see If any values shift around much. You might only be affecting values that are below the high line, or your score values are way out of proportion. Hope this helps.


Choosing a Selector Method


Faster Optimizations

Filter Optimizations can be a long and drawn out process.  Given the sheer amount of data that must be processed, it's no wonder why either.  But there are a few obvious, and some not so obvious tricks you can do to increase the performance of WINHunter during Optimization.

These minor options can dramatically increase the speed in which WINHunter performs Filter Optimization.  Ther either reduce or totally eliminate the overhead of data processing WINHunter has to perform in order to display information on the screen for the user.

1>  Minimize WINhunter altogether.

2>  Close the Backtest Result window.

3>  Turn off the Verbose option on the Backtes Result window.

4>  Minimize the Filter Optimizer window.

5>  Change tabs to the "Saved Results" Tab on the Filter Optimizer window.


Complete Optimization

Start by configuring the selector to a good startup value. This will depend on what processor you select first. Most processors will use the HIGH/Exclude setting. For a 6/49 lottery, your best bet for Minimum to eliminate is around 40. Unless you want the initial Filter group to remove a majority of balls, you are (at least this is what I have found) better off to let WINHunter optimize for small ball reductions.

Now, select a processor, and assign weight values to the Rules within that processor of your choosing.

Now, right click on the Filter and select WINHUNTER.

The first screen you will see is the filter setup screen.
Place a check box in the box for each component you will be optimizing. You will most likely click the Filter and the Processor. Now double click the two (or more) items to expand them. For the filter, you will typically check mark the Use/Skip Qty items. Double click them to access the Min/Max setup window. You will want the MIN value to start at 1 for use, and 0 for skip. You will want the Maximum value to start at what ever drawings you want the optimization to look at. This is a key area here, too few drawing use/skip combinations analysed, and you could miss something, too many and the analysis will take forever. Next, double click the items for the processor(s). Edit the min.max values for those items as well. Keep in mind you only want to test the bare minimum of combinations for rules within each processor. Typically, you will not check the box for the weight values for the rules, unless you want to see how well weighting one rule over another would fare.

Now, go back to the treeview, and right click again on the filter. Set the Use/Skip QTYs to 0. BE sure to also set the weight values for the processor(s)!

Once you are done, go click <RUN WINHunter>

While running, WINHunter will save it's best results on the BEST RESULTS tab. These results store the filter design settings for you to save if you like. Either let WINHunter run until completion, or let it run until if possibly finds acceptible levels to you. Once this is done, you can do one of several things:

1> Add another filter, close the optimizer window for this filter, and open an optimizer window for the new filter and do the process over again.

2> Add another group, then repeat the same process above for a new filter

3> Uncheck all the optimizer options, then check the Min/Max options for the cycler On/Off values (2 options only), and one checkbox for the start offset. What this will do is optimize the on/off times for the filter based on it's past performance. By tuning off a filter, it will no longer score good numbers incorrectly and eliminate them.

4> Your done!

At this point, WINHunter has probably found the best settings by utilizing a single filter to eliminate numbers from your lottery. Any subsequent filtering will only eliminate winning numbers, and reduce the amount of winning matches that WINHunter found. But, this is also the direction you want to go. By further reducing down the numbers, you reduce the number of jacpot matches previously found during the testing phase. What WINHunter is doing during the Hunting phase is looking for the best settings the produce WINs. Think of it this way, if you dont produce any wins (all the jackpot matches remain in the final prediction group) then your filter settings are not any good for you. If you maximize (theroretically) the number of wins for each pass, then WINHunter has a greater chance of producing a win for that filter design later down the road, as you add more groups and filters.


Advanced Optimization

Advanced Optimization methods utilize other adjustable settings within WINHunter.  Four of these settings are within the Filter element which are the Cycler settings.  These options allow you to set a point at which the Filter cycles on/off, starting at a shifted point either On or Off.  Using the Fitler Optimizer after you have optimized the Processors and the Filter Use/Skip quantities, you are ready for this stage of optimization.

Start by opening the Filter Optimizer window for the Filter you want to Optimize. Enable the Filter element, and then enable the Cycler items ONLY.  Then double click one of the items and adjust them to reasonable levels.  Once you are done go ahead and start the Optimizer.  When the optimizer is complete, save some of the top best optimizations.

These optimized stacks will have a cycle pattern assigned for that filter, which enables you to assign another filter inbetween those points which the first Filter is cycled OFF.  What this does is gives you another way to pick up the draws in between your initial Filter settings.  You might even find that this second stage parallel Filter will enhance the performance of your first stage Filter when they are both ON at the same time!


WINHunter Will

Will....

-Read most ASCII formatted History files

-Predict numbers for ANY lottery game that uses numbers to determine drawing winners

-Read hundreds to several thousands of draws for a single history

-Load several history files at the same time

-Run on most Windows Platforms starting at or after Windows 95

-Run on any system that meets the minimum hardware requirements for the operating system that exists on the computer

-Predict any game by Machine basis only


WINHunter Won't

Won't....

-Read any spreadsheet, database or word processing formatted history data

-Process data that does not use numbers


Load Errors