The New Sudoku Players' Forum

[MythJellies]

The Pattern Overlay Method (or POM) is a different way of solving sudoku puzzles. It is often referred to as a technique of last resort, which is fair considering how difficult it is to initiate, especially in the early stages of a puzzle. What is not fair is calling it a trial and error type of method, since these overlaid patterns can be arrived at without any unwarranted presumptions. Instead of breaking the puzzle up into candidate components for each digit and working to eliminate them until only the solution remains, POM breaks the puzzle up into labeled solution patterns, or rasters, for each digit and eliminates them until only the correct solutions remain. Each solution pattern for a digit has its own unique label. Each label is placed in every cell in which it occurs. In the following tables, an asterisk means that a digit can assume all of its possible values, while a bracket means that all of the numbers within could be used for that digit. As an example, lets consider a case where the solution has been given for the number 9 in cells r1c1, r6c2, r7c3, r8c4, and r9c9. Thus the unsolved cells for 9 are in r2345c5678. There are 16 different solution patterns or rasters for that number that could still possibly be part of the final solution. The labels for the 16 remaining rasters are shown below using two digits that range from 1 to 4. If a digit is replaced with an asterisk then that digit can be any number from 1 to its max. Thus, cell r2c5 contains the rasters labeled 11, 12, 13, and 14. If a digit is replaced with some numbers in brackets, then that digit can be any of those numbers. Thus, r2c8 contains the rasters labeled 31, 33, 41, and 43. The solution pattern labeled 11 shows up in all of its cells, in this case that is r2c5, r3c8, r5c6, and r4c7.

Code: Select all

---------+-------------------------------+------------------------
         |                               |
9  X  X  |  X        X         X         |  X         X         X         
         |                               |
X  X  X  |  X        1*        2*        |  [34][24]  [34][13]  X
         |                               |
X  X  X  |  X        3*        4*        |  [12][24]  [12][13]  X
         |                               |
---------+-------------------------------+------------------------
         |                               |
X  X  X  |  X        [24][34]  [13][34]  |  *1        *2        X
         |                               |
X  X  X  |  X        [24][12]  [13][12]  |  *3        *4        X     
         |                               |
X  9  X  |  X        X         X         |  X         X         X         
         |                               |
---------+-------------------------------+------------------------
         |                               |
X  X  9  |  X        X         X         |  X         X         X         
         |                               |
X  X  X  |  9        X         X         |  X         X         X         
         |                               |
X  X  X  |  X        X         X         |  X         X         9         
         |                               |
---------+-------------------------------+------------------------


Of course, once you've reduced the number of possible solutions to something manageable, you could substitute these digit labels for letters or any other unique symbols, giving the more familiar...

Code: Select all

9abcd  9efgh  |  9jlnp  9ikmo
              |
9ijkl  9mnop  |  9bdfh  9aceg
--------------+------------------
9ghop  9cdkl  |  9aeim  9bfjn
              |
9efmn  9abij  |  9cgko  9dhlp


Now lets expand this to a 6-cell pattern. You would get something like this if you solved for a digit in boxes 1, 5, and 9. Now you have 64 different ways to finish up the solution for that digit, which is nicely represented by a label containing 3 digits that can range from 1 to 4. Lets say the solved cells were in r1c1, r4c4, and r7c7. In that case, pattern 111 would be in r2c5, r3c9, r5c8, r6c3, r8c2, and r9c6. Cell r2c5 contains all sixteen patterns that have a 1 as the first digit.

Code: Select all

-----------------------+------------------------+------------------------
                       |                        |
                       |                        |
                       | 1**         2**        | [34][24]*   [34][13]*
                       |                        |
                       | 3**         4**        | [12][24]*   [12][13]*
                       |                        |
-----------------------+------------------------+------------------------
                       |                        |
                       |                        |
*[34][24]   *[34][13]  |                        | *1*         *2*
                       |                        |
*[12][24]   *[12][13]  |                        | *3*         *4*
                       |                        |
-----------------------+------------------------+------------------------
                       |                        | 
                       |                        |
**1         **2        | [24]*[34]   [13]*[34]  |
                       |                        |
**3         **4        | [24]*[12]   [13]*[12]  |
                       |                        |
-----------------------+------------------------+------------------------


So this gives us an arrangement for any arbitrary solution given in boxes 1, 5, and 9. Now I am going to show how one can create a POM grid in a non-assumptive fashion by using a magic starting pattern for all nine cells of a standard sudoku grid. For the 9x9 grid, each solution pattern label has six digits. The first three digits range from 1 to 9 and correspond to the solution cell for the pattern in boxes 1, 5, and 9 respectively. The second three digits range from 1 to 4 and correspond to the solutions in boxes 2, 6, and 7 respectively; with a 1 representing the cell that is cyclically to right and below the intersection of the solutions from boxes 1, 5, and 9. The solutions in the remaining boxes, 3, 4, and 8, follow uniquely from the solutions in the other boxes, following a similar format to that of the 6-cell case. Just as with the other cases, you can tell from the label which cells contain that label. For example, pattern 138124 lies in cells r1c1, r4c6, r9c8, r2c4, r5c7, r8c3, r3c9, r6c2, and r7c5. I imagine this sounds a bit complex, but it might be easier to digest if you see the full set. The complete set of 46,656 solution patterns for an empty grid are shown below.

Code: Select all

Block 1:
----------------------+----------------------+---------------------
                      |                      |
1*****                |2*****                |3*****                   
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
4*****                |5*****                |6*****                   
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
7*****                |8*****                |9*****                   
                      |                      |
----------------------+----------------------+---------------------

Block 2:
----------------------+----------------------+---------------------
                      |                      |
[789][369]*1**+       |[789][147]*1**+       |[789][258]*1**+         
[789][258]*2**+       |[789][369]*2**+       |[789][147]*2**+             
[456][369]*3**+       |[456][147]*3**+       |[456][258]*3**+           
[456][258]*4**        |[456][369]*4**        |[456][147]*4**           
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[123][369]*1**+       |[123][147]*1**+       |[123][258]*1**+           
[123][258]*2**+       |[123][369]*2**+       |[123][147]*2**+           
[789][369]*3**+       |[789][147]*3**+       |[789][258]*3**+         
[789][258]*4**        |[789][369]*4**        |[789][147]*4**           
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[456][369]*1**+       |[456][147]*1**+       |[456][258]*1**+         
[456][258]*2**+       |[456][369]*2**+       |[456][147]*2**+             
[123][369]*3**+       |[123][147]*3**+       |[123][258]*3**+         
[123][258]*4**        |[123][369]*4**        |[123][147]*4**           
                      |                      |
----------------------+----------------------+---------------------

Block 3:
----------------------+----------------------+---------------------
                      |                      |
[789]*[369][34][24]*+ |[789]*[147][34][24]*+ |[789]*[258][34][24]*+
[789]*[258][34][13]*+ |[789]*[369][34][13]*+ |[789]*[147][34][13]*+
[456]*[369][12][24]*+ |[456]*[147][12][24]*+ |[456]*[258][12][24]*+
[456]*[258][12][13]*  |[456]*[369][12][13]*  |[456]*[147][12][13]*
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[123]*[369][34][24]*+ |[123]*[147][34][24]*+ |[123]*[258][34][24]*+
[123]*[258][34][13]*+ |[123]*[369][34][13]*+ |[123]*[147][34][13]*+
[789]*[369][12][24]*+ |[789]*[147][12][24]*+ |[789]*[258][12][24]*+
[789]*[258][12][13]*  |[789]*[369][12][13]*  |[789]*[147][12][13]*
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[456]*[369][34][24]*+ |[456]*[147][34][24]*+ |[456]*[258][34][24]*+
[456]*[258][34][13]*+ |[456]*[369][34][13]*+ |[456]*[147][34][13]*+
[123]*[369][12][24]*+ |[123]*[147][12][24]*+ |[123]*[258][12][24]*+
[123]*[258][12][13]*  |[123]*[369][12][13]*  |[123]*[147][12][13]*
                      |                      |
----------------------+----------------------+---------------------

Block 4:
----------------------+----------------------+---------------------
                      |                      |
[369][789]**[34][24]+ |[147][789]**[34][24]+ |[258][789]**[34][24]+     
[258][789]**[34][13]+ |[369][789]**[34][13]+ |[147][789]**[34][13]+                                                                             
[369][456]**[12][24]+ |[147][456]**[12][24]+ |[258][456]**[12][24]+                                                                             
[258][456]**[12][13]  |[369][456]**[12][13]  |[147][456]**[12][13]                                                                             
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[369][123]**[34][24]+ |[147][123]**[34][24]+ |[258][123]**[34][24]+     
[258][123]**[34][13]+ |[369][123]**[34][13]+ |[147][123]**[34][13]+                                                                             
[369][789]**[12][24]+ |[147][789]**[12][24]+ |[258][789]**[12][24]+                                                                           
[258][789]**[12][13]  |[369][789]**[12][13]  |[147][789]**[12][13]                                                                             
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[369][456]**[34][24]+ |[147][456]**[34][24]+ |[258][456]**[34][24]+     
[258][456]**[34][13]+ |[369][456]**[34][13]+ |[147][456]**[34][13]+                                                                             
[369][123]**[12][24]+ |[147][123]**[12][24]+ |[258][123]**[12][24]+                                                                             
[258][123]**[12][13]  |[369][123]**[12][13]  |[147][123]**[12][13]                                                                             
                      |                      |
----------------------+----------------------+---------------------

Block 5:
----------------------+----------------------+---------------------
                      |                      |
*1****                |*2****                |*3****                   
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*4****                |*5****                |*6****                   
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*7****                |*8****                |*9****                   
                      |                      |
----------------------+----------------------+---------------------

Block 6:
----------------------+----------------------+---------------------
                      |                      |
*[789][369]*1*+       |*[789][147]*1*+       |*[789][258]*1*+
*[789][258]*2*+       |*[789][369]*2*+       |*[789][147]*2*+
*[456][369]*3*+       |*[456][147]*3*+       |*[456][258]*3*+
*[456][258]*4*        |*[456][369]*4*        |*[456][147]*4*
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*[123][369]*1*+       |*[123][147]*1*+       |*[123][258]*1*+
*[123][258]*2*+       |*[123][369]*2*+       |*[123][147]*2*+
*[789][369]*3*+       |*[789][147]*3*+       |*[789][258]*3*+
*[789][258]*4*        |*[789][369]*4*        |*[789][147]*4*
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*[456][369]*1*+       |*[456][147]*1*+       |*[456][258]*1*+
*[456][258]*2*+       |*[456][369]*2*+       |*[456][147]*2*+
*[123][369]*3*+       |*[123][147]*3*+       |*[123][258]*3*+
*[123][258]*4*        |*[123][369]*4*        |*[123][147]*4*
                      |                      |
----------------------+----------------------+---------------------

Block 7:
----------------------+----------------------+---------------------
                      |                      |
[369]*[789]**1+       |[147]*[789]**1+       |[258]*[789]**1+               
[258]*[789]**2+       |[369]*[789]**2+       |[147]*[789]**2+         
[369]*[456]**3+       |[147]*[456]**3+       |[258]*[456]**3+           
[258]*[456]**4        |[369]*[456]**4        |[147]*[456]**4           
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[369]*[123]**1+       |[147]*[123]**1+       |[258]*[123]**1+               
[258]*[123]**2+       |[369]*[123]**2+       |[147]*[123]**2+           
[369]*[789]**3+       |[147]*[789]**3+       |[258]*[789]**3+           
[258]*[789]**4        |[369]*[789]**4        |[147]*[789]**4           
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[369]*[456]**1+       |[147]*[456]**1+       |[258]*[456]**1+               
[258]*[456]**2+       |[369]*[456]**2+       |[147]*[456]**2+           
[369]*[123]**3+       |[147]*[123]**3+       |[258]*[123]**3+           
[258]*[123]**4        |[369]*[123]**4        |[147]*[123]**4           
                      |                      |
----------------------+----------------------+---------------------

Block 8:
----------------------+----------------------+---------------------
                      |                      |
*[369][789][24]*[34]+ |*[147][789][24]*[34]+ |*[258][789][24]*[34]+
*[258][789][13]*[34]+ |*[369][789][13]*[34]+ |*[147][789][13]*[34]+
*[369][456][24]*[12]+ |*[147][456][24]*[12]+ |*[258][456][24]*[12]+
*[258][456][13]*[12]  |*[369][456][13]*[12]  |*[147][456][13]*[12]
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*[369][123][24]*[34]+ |*[147][123][24]*[34]+ |*[258][123][24]*[34]+     
*[258][123][13]*[34]+ |*[369][123][13]*[34]+ |*[147][123][13]*[34]+
*[369][789][24]*[12]+ |*[147][789][24]*[12]+ |*[258][789][24]*[12]+
*[258][789][13]*[12]  |*[369][789][13]*[12]  |*[147][789][13]*[12]
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*[369][456][24]*[34]+ |*[147][456][24]*[34]+ |*[258][456][24]*[34]+     
*[258][456][13]*[34]+ |*[369][456][13]*[34]+ |*[147][456][13]*[34]+
*[369][123][24]*[12]+ |*[147][123][24]*[12]+ |*[258][123][24]*[12]+
*[258][123][13]*[12]  |*[369][123][13]*[12]  |*[147][123][13]*[12]     
                      |                      |
----------------------+----------------------+---------------------

Block 9:
----------------------+----------------------+---------------------
                      |                      |
**1***                |**2***                |**3***
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
**4***                |**5***                |**6***
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
**7***                |**8***                |**9***
                      |                      |
----------------------+----------------------+---------------------


Conceptually, POM works in a similar fashion to working with candidates, allbeit with 46,656 pattern labels per cell instead of 9 candidates. In both cases you can begin with an empty grid starting constant and then, as you place your givens, you can follow some very simple rules to eliminate either candidates or solution patterns. With POM, the initial rules are even simpler than they are with candidates. When you place a given digit in a cell then you can eliminate all patterns for that digit that are not contained in that cell. At the same time, you can eliminate the patterns that do occur in that cell for every other digit. All these eliminations can be made wherever the label occurs in the puzzle. If you eliminate pattern "111111" for nine in r1c1, then you eliminate it in the other 8 cells that it occurs as well. These methods can also work together. If a candidate is eliminated from a cell using typical means then the patterns for that eliminated candidate that exist in that cell can be eliminated as well.

Once the number of patterns is reduced to something manageable, then one can always substitute letters or other symbology for the remaining digit labels.

There are some ancient threads, some of them lost, that explained some of the interesting solving options available to a POM grid.

(0) Just the creation of the POM grid finds all single-digit eliminations from hidden singles to single-digit chains to any manner of frankenfish. Candidates in a cell that has no viable patterns for that candidate can be eliminated

(1) For any set of N cells that contains all of the patterns for a particular digit; if any pattern occupies all of those cells, that pattern must be false

(2) POM gives you a convenient "NOT". NOT a particular set of patterns for a digit equals the remaining patterns for that digit. Every cell contains multiple equations where NOT the set of patterns for one of the digits in the cell equals the patterns of all the other digits in the cell. One can use these equations to substitute into other cells--and if any pattern then gets repeated in a cell, it must be false since the cell can only hold one truth at a time and two would be required for that pattern to be true

(3) Given P patterns that exist in N cells that share a house (box, row, or column); if there exists another set of exactly N other cells that contain all of the P patterns plus extras, then the extras must be false and also any patterns which exist in more that one of the second set of cells must also be false. The N=1 case does happen. The N=2 case is interesting as it shows how the exocet presents itself using a POM grid

(...) There are many other ways you can compare equations to either get further refined equations or show that a particular pattern is false.

[tarek]

Good to see familiar names again!!!

[StrmCkr]

Long time no see myth jellies

Looking forward to advancementa with this, as I've also considered it a trial and error method.
Intresting read that it's alot more in depth explanation on eliminations as massive/simplistic a subset pattern restriction.

I've been tempted to attempt to implement this but I don't see an easy way with limitations of bit set size to 256 characters in pascal.

I'd have to set up each cell as an expanding array representing each 1 possible solution.

For quicker initiation on a loaded grid is it easier to set up the pencil mark grid first:
per-generated all inclusive list of solutions id's : 46,656 of them
Then generate the list of potential solution id's by comparing all active N digits on a grid to the full list of id's saving any active hits.

excluding the id's solutions where a cell in the id is active but it isn't valid in the grids pencil marks
exclude the id's that have cells active but the Grid cell contains a solved digit <> N


edit: added all 46,656 combinations, each line represent a potential Id and listing the active cells that make up that id
{cells listed as 0..80 format =>> left to right =>>top down }

[StrmCkr]

test puzzle:
6.23.915..3.2....6954.16.3.26.5.43.141..235..5.31.....3..4.2.1584..3.6...2....4.3

pm updated based on above string:

Code: Select all

.----------------.-------------------.---------------------.
| 6   78   2     | 3     478    9    | 1     5       478   |
| 17  3    178   | 2     4578   578  | 789   4789    6     |
| 9   5    4     | 78    1      6    | 278   3       278   |
:----------------+-------------------+---------------------:
| 2   6    789   | 5     789    4    | 3     789     1     |
| 4   1    789   | 6789  2      3    | 5     6789    789   |
| 5   789  3     | 1     6789   78   | 2789  246789  24789 |
:----------------+-------------------+---------------------:
| 3   79   679   | 4     6789   2    | 789   1       5     |
| 8   4    1579  | 79    3      157  | 6     279     279   |
| 17  2    15679 | 6789  56789  1578 | 4     789     3     |
'----------------'-------------------'---------------------'

template generation:
"Locked ": Save a list of Cell for each N grid givens
"Delete" save a list Cells of each Grid Given that is not N and Cells that do not have N in pencil-marks

for each "set" of potential id;s in the 46,656 file in previous post.
run the following state check

Code: Select all

(( Set - deleted ) * locked = locked )
 and
( deleted * set = [] )


save any set that hits true

here is my list:
{note my code eliminates listing the Grid Givens from the set}

Code: Select all

Digit 1
9 65 77
9 68 74
11 68 72


Code: Select all

Digit 2
24 52 71
24 53 70
26 51 70
 

Code: Select all

Digit 3

Code: Select all

Digit 4
4 16 53
8 13 52
 

Code: Select all

Digit 5
13 65 77
14 65 76
13 68 74

Code: Select all

Digit 6
39 52 56 76
43 49 56 75
39 52 58 74

Code: Select all

Digit 7
4 9 24 29 39 53 55 68 79
4 9 26 29 39 51 55 68 79
8 9 21 31 38 51 55 68 79
4 9 24 29 44 50 55 66 79
4 9 24 34 39 46 56 71 77
4 9 24 29 39 52 55 71 77
4 9 24 29 39 53 55 70 77
4 9 26 29 39 51 55 70 77
8 9 21 31 38 51 55 70 77
8 9 21 31 43 46 60 65 77
4 9 26 34 39 46 60 65 77
4 9 24 29 43 50 55 71 75
4 9 24 34 38 50 55 71 75
4 9 24 29 44 50 55 70 75
8 9 21 31 43 46 60 68 74
4 9 26 34 39 46 60 68 74
1 14 24 29 39 52 58 71 72
1 15 21 29 43 50 58 71 72
1 15 21 34 38 50 58 71 72
1 14 24 29 39 53 58 70 72
1 14 26 29 39 51 58 70 72
1 15 21 29 44 50 58 70 72
1 16 21 31 38 53 60 68 72
1 13 26 29 39 52 60 68 72
1 16 21 29 44 49 60 68 72
8 11 21 31 43 46 60 68 72
4 11 26 34 39 46 60 68 72
1 14 26 31 38 52 60 66 72
1 13 26 29 43 50 60 66 72
1 13 26 34 38 50 60 66 72
1 14 26 29 43 49 60 66 72
1 14 26 34 38 49 60 66 72

Code: Select all

Digit 8
1 14 24 29 39 53 58 79
1 14 26 29 39 51 58 79
1 15 21 29 44 50 58 79
1 16 21 31 38 53 60 77
1 13 26 29 39 52 60 77
1 16 21 29 44 49 60 77
8 11 21 31 43 46 60 77
4 11 26 34 39 46 60 77
1 14 26 29 39 52 60 76
1 16 21 29 44 50 60 76
1 14 26 31 38 52 60 75
1 13 26 29 43 50 60 75
1 13 26 34 38 50 60 75
1 14 26 29 43 49 60 75
1 14 26 34 38 49 60 75

Code: Select all

Digit 9
15 31 44 46 56 66 79
15 31 38 53 55 66 79
15 29 44 49 55 66 79
15 34 39 46 56 71 76
15 29 39 52 55 71 76
16 29 39 51 55 71 76
15 29 39 53 55 70 76
15 31 43 46 56 71 75
15 31 38 52 55 71 75
16 31 38 51 55 71 75
15 29 43 49 55 71 75
15 34 38 49 55 71 75
15 31 44 46 56 70 75
15 31 38 53 55 70 75
15 29 44 49 55 70 75
16 31 44 46 60 65 75
15 34 39 46 58 71 74
16 31 44 46 60 66 74

elimination steps 1:
for each N digit "sum" all cells used in all of the potential id
(

Code: Select all

 [0..80] - locked - deleted  ) - sum

if any digit is left in the initial set of [0..80] cells then that number may be excluded as it is never used in any of the potential solutions.

elimination:
digit 7 @ cell 76
...

Naked Triple: Cells 66, 70,71 on digits 2,7,9
step 1:
in each digit 2,7,9 mark "x" each potential solution that contains cells 65,70,71
all unmarked solutions may be deleted.

Code: Select all

Digit 2
24 52 71 x
24 53 70 x
26 51 70 x

Code: Select all

Digit 7
4 9 24 29 39 53 55 68 79
4 9 26 29 39 51 55 68 79
8 9 21 31 38 51 55 68 79
4 9 24 29 44 50 55 66 79 x
4 9 24 34 39 46 56 71 77 x
4 9 24 29 39 52 55 71 77 x
4 9 24 29 39 53 55 70 77 x
4 9 26 29 39 51 55 70 77 x
8 9 21 31 38 51 55 70 77 x
8 9 21 31 43 46 60 65 77
4 9 26 34 39 46 60 65 77
4 9 24 29 43 50 55 71 75 x
4 9 24 34 38 50 55 71 75 x
4 9 24 29 44 50 55 70 75 x
8 9 21 31 43 46 60 68 74
4 9 26 34 39 46 60 68 74
1 14 24 29 39 52 58 71 72 x
1 15 21 29 43 50 58 71 72 x
1 15 21 34 38 50 58 71 72 x
1 14 24 29 39 53 58 70 72 x
1 14 26 29 39 51 58 70 72 x
1 15 21 29 44 50 58 70 72 x
1 16 21 31 38 53 60 68 72
1 13 26 29 39 52 60 68 72
1 16 21 29 44 49 60 68 72
8 11 21 31 43 46 60 68 72
4 11 26 34 39 46 60 68 72
1 14 26 31 38 52 60 66 72 x
1 13 26 29 43 50 60 66 72 x
1 13 26 34 38 50 60 66 72 x
1 14 26 29 43 49 60 66 72 x
1 14 26 34 38 49 60 66 72 x


Code: Select all

Digit 9
15 31 44 46 56 66 79 x
15 31 38 53 55 66 79 x
15 29 44 49 55 66 79 x
15 34 39 46 56 71 76 x
15 29 39 52 55 71 76 x
16 29 39 51 55 71 76 x
15 29 39 53 55 70 76 x
15 31 43 46 56 71 75 x
15 31 38 52 55 71 75 x
16 31 38 51 55 71 75 x
15 29 43 49 55 71 75 x
15 34 38 49 55 71 75 x
15 31 44 46 56 70 75 x
15 31 38 53 55 70 75 x
15 29 44 49 55 70 75 x
16 31 44 46 60 65 75
15 34 39 46 58 71 74 x
16 31 44 46 60 66 74 x

apply step1.
eliminations:
Digit 7 @ 11,65,68,74
Digit 9 @ 65

Hidden Pair:
Cells 65,68 digits 1,5
delete all potential solutions that contain cells 65,68 in all other numbers
{direct inverse of above step all non x cells are deleted}
apply step 1
eliminations:
Digit 7 @ 11,65,68,74
Digit 9 @ 65


more complicated:
Almost Locked Set XY-Wing: A=r8c4689 {12579}, B=r7c2,r9c1 {179}, C=r269c6 {1578}, X,Y=1,5, Z=7,9 => r8c3<>7, r8c3<>9

for each Cell on each digit used in the als-xy, mark every rasters that has that cell.
delete all unmarked rasters for each digit

apply step 1:
eliminations:
Digit 7 @ 65,
Digit 9 @ 65

[StrmCkr]

i know this one is off topic to this but it is directly related:

a brute force method based off templates lists raster .

for each N digit there is z potential "raster". {index's}

an engine could cycle each z{1..9} for each N digit
starting with the shortest list size and increasing

1[z], 2[z2],3[z3],4[z4],5[z5],6[z6],7[z7].8[z8].9[z9] = [0..80];

updating subset list of id's per z placed in previous step
if it leaves no id's for next subset back to previous state and select a different id

this could be able to identify if its muti,single or zero solution grid.

[MythJellies]

[deleted repeat]

[MythJellies]

A little off topic, but in POMs initial step for StrmCkr's test puzzle

Code: Select all

.----------------.-------------------.---------------------.
| 6   78   2     | 3     478    9    | 1     5       478   |
| 17  3    178   | 2     4578   578  | 789   4789    6     |
| 9   5    4     | 78    1      6    | 278   3       278   |
:----------------+-------------------+---------------------:
| 2   6    789   | 5     789    4    | 3     789     1     |
| 4   1    789   | 6789  2      3    | 5     6789    789   |
| 5   789  3     | 1     6789   78   | 2789  246789  24789 |
:----------------+-------------------+---------------------:
| 3   79   679   | 4     6789   2    | 789   1       5     |
| 8   4    1579  | 79    3      157  | 6     279     279   |
| 17  2    15679 | 6789  56789  1578 | 4     789     3     |
'----------------'-------------------'---------------------'

POM finds an elimination for 7r9c5. This means that there must be a funky fish or an AIC involving only the digit 7 which results in this elimination. The problem is that even knowing the elimination via POM, the "normal" candidate based pattern can be difficult to find. Here is the simplest one, well the only one, that I came up with.

Code: Select all

.----------------.-------------------.---------------------.
| .   7b'   .B    | .     7B     .    | .     .B      7B    |
| 7A  .    7     | .     7      7A   | 7     7       .     |
| .   .    .     | 7     .      .    | 7     .       7     |
:----------------+-------------------+---------------------:
| .   .    7B    | .     7B     .    | .     7B      .B    |
| .   .    7B    | 7b    .B     .    | .     7B      7B    |
| .   7    .     | .     7      7a   | 7     7      7     |
:----------------+-------------------+---------------------:
| .   7    7     | .     7      .    | 7     .       .     |
| .   .    7B    | 7#    .B     7#   | .     7B      7B    |
| 7A  .    7     | 7    -7-     7A   | .    7       .     |
'----------------'-------------------'---------------------'

A => 7 r29/c16 x-wing
a => 7 r6c6 is a fin of the x-wing that does not see r9c5
B => 7 r1458/c3589 jellyfish
b => 7 r5c4 is a fin of the jellyfish that does not see r9c5
b' => 7 r1c2 is another fin of the jellyfish that does not see r9c5
# => fins of the x-wing and/or the jellyfish that do see r9c5

Thus, we can make the AIC net

Code: Select all

7#    7#
||    ||
7A    7B
||    ||
7a -- 7b
      ||
      7b' -- 7r2c1 = 7r9c1 => at least one of the AIC net endpoints (7#, 7A, 7B, 7r9c1) must be true,
                               therefore r9c5 <> 7

It might be interesting the see how few holes it takes for POM to make a deduction such as this, and if that minimum set of interesting holes makes a recognizable pattern.

[tarek]

Hi All,

The Fish that could make that elimination must very fancy indeed.

Hodoku is decent fish catcher but up to Fish size 7 Fins number 7 there is none to be found.

There could be as simpler Broken Wings style one but the fish catchers out there need to sharpen their tools and go hunting!!!

Tarek

[StrmCkr]

big fish indeed, i also ran it through xsudo and it found no reduced complex fish.

i wonder if blues complex {can reuse sectors} obiwans N x n+K fish finder can do the job.

[David P Bird]

'MythJellies' let me start by saying that I'm convinced that you aren't the same person as Myth Jellies (with a space included in the name) and I think it is bad form to appropriate his title.

However, to address your post:

Repeated

Code: Select all

.----------------.-------------------.---------------------.
| .   7b'   .B   | .     7B     .    | .     .B      7B    |
| 7A  .    7     | .     7      7A   | 7     7       .     |
| .   .    .     | 7     .      .    | 7     .       7     |
:----------------+-------------------+---------------------:
| .   .    7B    | .     7B     .    | .     7B      .B    |
| .   .    7B    | 7b    .B     .    | .     7B      7B    |
| .   7    .     | .     7      7a   | 7     7       7     |
:----------------+-------------------+---------------------:
| .   7    7     | .     7      .    | 7     .       .     |
| .   .    7B    | 7#    .B     7#   | .     7B      7B    |
| 7A  .    7     | 7    -7-     7A   | .    7        .     |
'----------------'-------------------'---------------------'

A => 7 r29/c16 x-wing
a => 7 r6c6 is a fin of the x-wing that does not see r9c5
B => 7 r1458/c3589 jellyfish
b => 7 r5c4 is a fin of the jellyfish that does not see r9c5
b' => 7 r1c2 is another fin of the jellyfish that does not see r9c5
# => fins of the x-wing and/or the jellyfish that do see r9c5

Using a forcing chain approach:
If (7)r9c5 is true then
a) one of r6c6,r8c6 must be true as the X wing can only hold 1 digit
b) at least one of r1c2,r5c4,r8c4,r8c6 must be true as the JellyFish can only hold 3 digits
However r8c4,r8c6 are in sight of r9c5 so these reduce to a) r6c6 and b) r1c2,r5c4
With r6c6 the only possibility for the XWing this eliminates r5c4 as a candidate for b) so b=r1c2
But b=1c2 forces the true XWing cell to r2c6 which would eliminate r6c6 (which has already been asserted) to produce a contradiction.

It is the box1 and box5 constraints that aren't represented in the fish model.

In writing the 'Pattern Transformations' section of the <Fish Bones> thread, it became apparent to me that Obi-Wahn's techniques always maintained two constraints. Therefore, to handle this situation I think you would need to contrive two overlapping fish transformations.

DPB

[JC Van Hay]

Code: Select all

+--------------------+------------------------+-----------------------+
| 6     8(7)   2     | 3       478     9      | 1       5       478   |
| 1(7)  3      178   | 2       4578    58(7)  | 89(7)   4789    6     |
| 9     5      4     | 8(7)    1       6      | 28(7)   3       278   |
+--------------------+------------------------+-----------------------+
| 2     6      789   | 5       789     4      | 3       789     1     |
| 4     1      789   | 689(7)  2       3      | 5       6789    789   |
| 5     89(7)  3     | 1       6789    8(7)   | 289(7)  246789  24789 |
+--------------------+------------------------+-----------------------+
| 3     9(7)   679   | 4       6789    2      | 89(7)   1       5     |
| 8     4      1579  | 9(7)    3       15(7)  | 6       279     279   |
| 1(7)  2      15679 | 689(7)  5689-7  158(7) | 4       789     3     |
+--------------------+------------------------+-----------------------+


"Analysis" of the 7s leads to a unique exclusion : -7r9c5.

Interpretation :
r9c5 -> r2c1, r6c6, r3c4, r7c7 : C2={} => "Starfish"{C12467} -> -{r9c5}
In details, we have the following exclusion matrix :

Code: Select all

r9c5
r9c1  r2c1
r89c6 r2c6 r6c6
r89c4      r5c4 r3c4
      r2c7 r6c7 r3c7 r7c7
      r1c2 r6c2      r7c2 => [r9c1==r89c6==r89c4]-r9c5


Note : C46 can be replaced by B25

Interpretation in terms of "fish + remote fins" :
Valid Starfish C12467/R23569 [3 solutions]
||
r1c2-r2c1=r9c1
||
r5c4-r6c6=*XWing[r9c1=r2c1-r2c6=*r89c6]
||
r8c46
where the fins imply [r9c1==r89c6==r8c46]-r9c45.
Conclusion : the starfish and the fins exclude 7r9c5.

[tarek]

That is great way of showing how a fin can SEE the exclusion. a bit complex but still valid. Maybe a bigger more convoluted fish will result in easy fin to exclusion relationship!!!

tarek

[JC Van Hay]

... . Maybe a bigger more convoluted fish will result in easy fin to exclusion relationship!!!

tarek

What about this starfish ?

Code: Select all

+--------------------+----------------------+-----------------------+
| 6     8(7)   2     | 3     48(7)   9      | 1       5       48(7) |
| 1(7)  3      178   | 2     4578    58(7)  | 89(7)   4789    6     |
| 9     5      4     | 78    1       6      | 28(7)   3       278   |
+--------------------+----------------------+-----------------------+
| 2     6      789   | 5     789     4      | 3       789     1     |
| 4     1      789   | 6789  2       3      | 5       6789    789   |
| 5     89(7)  3     | 1     6789    8(7)   | 289(7)  246789  24789 |
+--------------------+----------------------+-----------------------+
| 3     9(7)   679   | 4     6789    2      | 89(7)   1       5     |
| 8     4      1579  | 79    3       15(7)  | 6       279     279   |
| 1(7)  2      15679 | 6789  5689-7  158(7) | 4       789     3     |
+--------------------+----------------------+-----------------------+

r9c5 -> r2c1, r1c9, r6c6, r7c7, C2={} => "Starfish"{R1C1267} -> -{r9c5}

Exclusion matrix :

Code: Select all

r9c5
r9c1  r2c1
r1c5  r1c2 r1c9
r89c6 r2c6       r6c6
           r23c7 r6c7 r7c7
      r1c2       r6c2 r7c2 => [r9c1==r1c5==r89c6]-r9c5


Finned Starfish {R1C1267} :
Valid Finned Starfish R1C1267/R2679B3 fins r1c5, r8c6
||
endofin r1c2-r2c1=r9c1 => [r9c1==r9c6=r1c5==r8c6]-r9c5

[pjb]

I developed my strategy for POMs after reading the POM section in Andrew Stuart's book (The Logic of Sudoku). It involves generating all valid patterns for a particular digit, then listing the cells that these patterns pass through. Then it is simple to check for any cell containing this digit not included in the cells derived from the patterns. The digit can be deleted from these cells. Alternatively, one can check for a cell that all patterns for a digit pass through, and this cell can be set equal to the digit. With StrmCkr's puzzle my solver gives: "No pattern of 7 includes r2c38, r9c35 so 7 can be deleted from r2c38, r9c35".

Then If all of the patterns for a number pass through one or the other of two cells, then one (or both) of these cells must contain the number. Then when all the patterns for a different number are inspected to see if they go through both of the cells, those patterns that do pass through both must be invalid and can be eliminated. The remaining patterns for the number are then tested as above to see if there are any numbers which are not part of any of the remaining patterns, or if all remaining patterns pass through a single cell. With StrmCkr's puzzle, POM the delivers the following: "Between them r3c7 and r8c8 include all patterns of 2, so patterns of 7 which include both cells can be deleted. As a result, no pattern of 7 includes r6c9 so 7 can be deleted from r6c9". Continuing on, POM eliminates 5 7's, 2 8's and 3 9's.

Phil