Software news in lotto, lottery, horse racing, skips, pairs programs.

Software Updates: Lotto, Lottery, Horse Racing, Pairs Programs, LIE Reversed Strategies

By Ion Saliu, Founder of Mathematical Lottery Strategies

Software for lottery pairings, LIE elimination, combination reduction, reversed lotto strategies.

Published in May 2012; later updates.

I. PairGrid: Lottery Software for Pairings and Grids

The software packages known Bright.exe have been updated. A few quirks were discovered by users and have been fixed by this software author. Also, the updates add the important feature of best / worst pairing reporting and combination generating. Furthermore, such feature leads to some powerful LIE lottery strategies (or reversed lotto strategy).

There are five Bright software packages affected. The filenames are indicative of the game: Bright3.EXE, Bright4.EXE, BrightH3.EXE, Bright5.EXE, Bright6.EXE. BrightH3.EXE refers to horse racing, mostly trifecta generating.

One of the quirks affected the strategy-checking functions. An error was triggered when a particular strategy had a hit in the very last lottery drawing analyzed. The software shows now, correctly, all lottery drawings that recorded a win (hit) for that particular strategy.

I fixed also the reporting for horse racing. I discovered a nuisance for races such as the famous Kentucky Derby. That race is extremely biased: From 3 horses per race to 25 horses (in one year, 84 or 85 years ago). By the way, you should avoid that race (year) in your reporting. That is, you should do the WH/MH reporting for 80 or 82 races. A data file like the Kentucky Derby history has extremely high values for standard deviations or some filters. Strategy-checking should not lead to errors anymore, hopefully. I believe I did my best in this regard.

II. Reversed Pick 3 Lottery Strategy Based on Pairings and Grids

A loyal user of my software (BrianPA) played a very important role in implementing what I call the LIE or reversed lottery strategy. He discovered that the BEST/WORST PAIRS reporting did not work accurately when choosing ranges. For example, the user wanted to generate the reports for the 10 BEST pairings starting at position #5. That is, the user wanted the best pairs with the following ranks: #5, #6, ... #13, #14. By error, the software had always started at position #1 (e.g. from rank #1 to rank #10). The affected function appears as S = Super Utilities in the main menu. The function works accurately now.

The program name is PairGrid.EXE. I had intentionally disabled two functions, but I had not mentioned in the tutorials. I decided to enable all functions in the PairGrid programs, as they play a very good role in devising LIE lottery strategies.

Pair grid software for lottery creates winning lotto strategy systems.

Always start with the function R = Pairing Reports. The main report is named Pair*.REP (e.g. Pair6.REP for 6-number lotto).

Here is a sample for 5-number lotto as reported by a user and incorporated in a LIE strategy.

Line      Num           Num           Num           Num           Num      Lowest Highest
no.        1             2             3             4             5        Pair   Pair

1   11 20 36 41   14 19 26 36    7 28 34 36   10 11 19 40    5  9 14 38    5      41
...
14   6 25 41 42    4 30 35 41    1 25 32 40    2 24 32 41    5 35 39 41    1      42
...
16  28 35 41 42    5 12 27 35   17 21 35 40    1  4 19 35    1  4 23 35      1      42
...
26   5  7  9 40    2 29 37 40   15 18 36 37   29 36 37 38    3 15 27 35      2      40
...

Let's take one line at a time, and I will explain how to make a devastating LIE file from the information.

LINE #1: As you can see, the highest pair rankings from each winning number is magnified. This is what we will be concentrating on for this example.

The lowest pair ranking among ... the highest ranks is 36. So what does this mean? It means we can make a TOP5 file with the top-35 pairs of every number, and using M = Make/Break/Position in S = Super Utilities (in the main menu of Bright.EXE), break that file down using 1 number + 4 pairs, for a devastating LIE file!

You may think that 35 top pairs is a good enough lie file. Well, hold on there!

Look at line #14. You will see that the lowest High Ranking is 40. So now you can use a TOP5 file with 39 pairs for a LIE file. THAT is HUGE!!!

Please NOTE: The numbers in the report do not reflect actual lottery numbers. They only reflect the ranking of a number's pairing frequency in relation to a main number. When using the above method for lie files, you must use filter ID5 (for 5 of 5 numbers elimination).

The TOP5 file is created also in S = Super Utilities, function F = Frequency Reporting by Number. For TOP5 select Number of pairs = 35 and Starting position = 1.

Super Utilities, function F = Frequency Reporting by Number also creates two more important files: BEST and WORST. Now, the LIE lotto strategy is implemented differently. We apply Screen_0 in the combination generating programs (e.g. Lexico.EXE, Combine.EXE, Wheel.EXE).

As an example, we create BEST and WORST for 1 pairing each, starting at position #1 and position #42 (last for 5/43 lotto), respectively. Each file will have 43 lines (numbers in the lotto game). We concatenate BEST and WORST to, say LEAST5 (with 86 lines). We recreate D5 with LEAST5 on top of Data-5. Use Super Utilities, function M = Make/Break/Position, then 2 = Make D5 with LEAST5.

Next, in Screen_0, we enable the filter named Enter LEAST-PAIRINGS = 86. The software will generate a number of lotto combinations far lower than total number of combinations in the game. The output file will make a good LIE strategy candidate. Explanation: We will miss either the best pair rank (#1) or the worst pair rank (#42) on several occasions (marked by *).

 Line      Num           Num           Num           Num           Num      Lowest Highest
 no.        1             2             3             4             5        Pair   Pair

    1   1  7 23 30   24 26 30 36    3  4 14 41    4 18 30 35   12 15 18 39     1     41 *
    2  12 13 15 16    8 11 25 31    7 15 16 25    9 13 14 31   10 17 25 29     7     31
    3   5  8 26 34   16 17 20 26    7 15 19 34   12 27 33 34   14 19 23 27     5     34
....
   10   9 25 27 32    2  3 20 30    2 13 22 37    5 15 20 30    1  5 18 19     1     37 *
   11   1 38 40 42    9 27 37 42    1 39 40 42    3 34 38 42   31 33 38 41     1     42 *
   12   5 17 18 31    2 21 27 31    8 27 31 32   12 18 27 28   13 20 24 39     2     39
   13  11 16 28 36   14 19 20 35    7 11 13 15    4  8 28 35    2  7  9 24     2     36
   14   7 29 34 42    5 17 32 42   20 29 37 42    4  6 16 42   21 27 33 35     4     42 *
   15  21 23 32 41   32 36 41 42   28 29 32 36   17 24 25 42    8 15 24 42     8     42 *
   16   5  8 24 39    1 16 24 34    4 22 31 39    4 12 20 39   14 20 31 32     1     39 *
   17  10 16 22 36    4 13 27 33    5 13 21 34    7  8 12 33    5 16 32 35     4     36
   18   6 17 27 38   26 28 31 38    1 26 28 38    4  6 27 29    2 27 30 32     1     38 *
   19  15 23 27 28    8 22 27 34   22 24 28 34   12 22 28 34    8 24 28 29     8     34
   20   4  7 37 42    1 10 11 29    6 21 39 41    1  3 22 41    1  4 32 38     1     42 *
   21  12 15 30 36    4 20 23 40    5  7 20 25    4  5 20 25    1 19 21 24     1     40 *
   22  11 15 17 39   10 16 18 39   16 22 36 39    1 16 33 39   17 31 33 37     1     39 *

We can increase the winning frequency if we create BEST and WORST files for 2 pairs each (i.e. ranks #1 & #2, #42 & #41).

Another report created by PairGrid.EXE is Pair.WS.

 Line                        Four
 no.

 Median:                     250

 Average:                    243

    1     2  7  8 14 31      250
    2    17 25 26 29 32      250
    3     8 14 23 27 35      250
    4    33 34 35 40 43      250
    5    13 17 21 25 41      250
    6     9 17 26 32 41      250
    7     6 24 28 32 41      250
    8     3 24 30 31 33      250
    9     3  7 17 39 43       82
   10     6  8 11 18 31      250
....
   35     5  7 33 39 42      250
   36     8 11 14 23 42      250
   37     6 16 19 22 35      250
   38     3 19 32 33 41      250
   39    10 14 15 30 43        0 *
   40     3  5 14 30 33      250

The Four filter is frequently between 250-500 (around 95% of the time). That is, if we set MAX_Four = 250, we will be wrong frequently. Therefore, the output file makes for a good LIE (with hundreds of lotto combinations sometimes).

But look at line #39: It is a case of direct lottery strategy (as opposed to LIE or reversed strategy. If we set MAX_Four = 1, the function P = Create File of Missing Pairs will generate one line (with the 4 pairing ranks that repeated from the previous lotto drawing). Output file name: Pair5.OUT. We then run the function G = Generate Combosnations from Missing Pairs, with Pair5.OUT as the input file. Total combinations generated: 43, evidently. Such a lotto strategy hits very rarely (long skips), so we can wait many lotto drawings until we play the strategy.

I noticed an extraordinary case in the Pick-3 lottery software (PairGrid3.EXE). The Two filter can be between 10-20 some 15-20% of the time. I set Min_Two = 10 and MAX_Two = 20. The output file has some 400 pick 3 straight sets. But the file is wrong (LIE) around 80% of the time!

III. Direct Pick 3 Lottery Strategy Based on Pairings and Grids

Axiomatic one, the pairs are always a good direct lottery strategy. That is, we generate combinations to play, not combinations for LIE elimination. The function in this type of software only works for pic lotteries and horse racing trifectas. The lotto programs deal with way too many top pairings necessary to constucting a lotto grid. For example, a 5/43 lotto set requires C(42, 4) = 111930 pairings to build the basic lotto wonder-grid (each lotto number plus its top-4 pairings).

We work with PairGrid3.EXE for pick-3 lotteries. There is one additional report: PAIR3.SK. It is created by the function R = Pairing Report. The report shows the frequency of all 55 pairings in pick-3. The pairings consist of 2 elements, as the pick 3 wonder grid consists, at minimum, of each digit plus 2 of its pairings.

                   PICK-3 String Pairing Frequency and Skips
                   Draws Analyzed:  1000 
                   Pairings Draw-Range (Parpaluck):  24 


       Pair:  1 - 1 

Skips:  37  28  37  7  53  59  46  6  83  71  16  61  3  55  7  9  10  22  9  21  20  34  33  63  40  44  60  13 
Sorted Skips:  3  6  7  7  9  9  10  13  16  20  21  22  28  33  34  37  37  40  44  46  53  55  59  60  61  63  71  83 
* Median Skip:  33 
* Total Hits:  28  =  2.8%

       Pair:  1 - 2 

Skips:  11  2  11  2  4  24  5  4  2  31  63  53  21  5  0  17  4  12  10  81  8  0  0  14  24  126  6  44  13  25  9  27  9  13  6  104  0  8  38  26  9  23  23  11  2  0  0  0  1 
Sorted Skips:  0  0  0  0  0  0  0  1  2  2  2  2  4  4  4  5  5  6  6  8  8  9  9  9  10  11  11  11  12  13  13  14  17  21  23  23  24  24  25  26  27  31  38  44  53  63  81  104  126 
* Median Skip:  10 
* Total Hits:  49  =  4.9%
....

       Pair:  9 - 10 

Skips:  35  3  43  68  26  9  52  40  8  11  38  26  6  26  30  2  42  7  2  13  1  36  4  31  18  4  12  26  41  18  23  47  5  2  17  35  34  10  67  11  28 
Sorted Skips:  1  2  2  2  3  4  4  5  6  7  8  9  10  11  11  12  13  17  18  18  23  26  26  26  26  28  30  31  34  35  35  36  38  40  41  42  43  47  52  67  68 
* Median Skip:  23 
** Total Hits:  41  =  4.1%

       Pair:  10 - 10 

Skips:  42  37  26  10  19  63  36  45  57  56  78  84  32  66  47  31  28  0  2  14  2  13  38  16  28  31  12 
Sorted Skips:  0  2  2  10  12  13  14  16  19  26  28  28  31  31  32  36  37  38  42  45  47  56  57  63  66  78  84 
* Median Skip:  31 
* Total Hits:  27  =  2.7%

We can see that the pairings register a variety of frequencies. Evidently, the double pairings (from 1 - 1 to 10 - 10) show the lowest frequencies. We look for pairings with the highest frequency and the lowest median skip. Usually, such pairings can be found somewhere in the middle region of the PAIR3.SK report.

       Pair:  5 - 8 

Skips:  3  1  4  10  26  0  21  4  7  23  11  16  11  27  9  3  44  12  41  6  3  4  45  0  14  3  3  30  4  6  7  26  51  29  0  7  16  33  10  8  10  3  8  10  33  3  0  0  10  5  66  20  24  6  9  4  19  5  7  9  18  1  0  5  26  1  2 
Sorted Skips:  0  0  0  0  0  0  1  1  1  2  3  3  3  3  3  3  3  4  4  4  4  4  5  5  5  6  6  6  7  7  7  7  8  8  9  9  9  10  10  10  10  10  11  11  12  14  16  16  18  19  20  21  23  24  26  26  26  27  29  30  33  33  41  44  45  51  66 
* Median Skip:  8 
* Total Hits:  67  =  6.7%

       Pair:  6 - 8 

Skips:  3  75  3  0  8  10  43  24  1  22  10  6  0  10  3  0  1  29  4  6  13  26  29  16  0  32  1  3  3  7  32  3  4  7  9  27  3  17  44  71  5  31  7  22  11  3  11  0  2  35  19  13  25  27  5  5  23  18  4  2  24  2  24  11 
Sorted Skips:  0  0  0  0  0  1  1  1  2  2  2  3  3  3  3  3  3  3  3  4  4  4  5  5  5  6  6  7  7  7  8  9  10  10  10  11  11  11  13  13  16  17  18  19  22  22  23  24  24  24  25  26  27  27  29  29  31  32  32  35  43  44  71  75 
* Median Skip:  9 
* Total Hits:  64  =  6.4%

The 5 - 8 and 6 - 8 pairs show high frequency and low median skip values. The current skips are below the median (3 and 3 in this case). Let's say I choose the 6 - 8 pair. I PairGrid3.EXE again, function U = Make Custom Grid from User Pairs. The program will build a grid with pairing rank #5 and pairing rank #8 named TopGrid3.

Pair grid software for lottery creates winning lotto strategy systems.

I select generating function 1 = 1 Digit + 2 Pairs. The program generates 54 straight sets. Evidently, I need to reduce further the amount of tickets to play. There are plenty of choices to do that effectively and safely, including LIE elimination options presented above.

If I want a higher winning frequency, I combine the two pairings above. I'll create now a TopGrid3 consisting of each pick-3 digit and the 3 pairings: 5, 6, 8. The function 1 = 1 Digit + 2 Pairs generates now some 150 straight sets. Again, I Purge the amount generated by using several elimination methods in my hugely comprehensive software. (Let's just not get intimidated by the sheer amount of choices!)

Missing lotto pairs can reduce drastically total combinations to play.

Resources in Lotto, Lottery Software, Wheeling

It lists the main pages on the subject of lottery, lotto, software, systems, strategies, lotto wheels.

The lottery software groups pick lotteries, horse racing, jackpot lotto games.

Book on the most powerful lottery software worldwide.

| Home | Search | New Writings | Odds, Generator | Contents | Forums | Sitemap |

Get source code to generate lotto combinations from 3 groups of numbers.