The New Sudoku Players' Forum

[200e200w]

Code: Select all

. 1 .|. 2 .|9 . .
. 3 .|. . 4|. . 6
7 . .|1 . .|4 . .
-----+-----+-----
. . .|. . .|. 8 4
. 6 8|4 . 5|2 1 .
4 5 .|. . .|. . .
-----+-----+-----
. . 5|. . 3|. . 1
6 . .|7 . .|. 4 .
. . 1|. 6 .|. 2 .


200e200w

[Sudtyro2]

Code: Select all

+----------------+------------------+---------------+
| 5   1    4     | 36    2     67   | 9    37  8    |
| 289 3    29    | 589   5789  4    | 1    57  6    |
| 7   89*  6     | 1     35    89*  | 4    35  2    |
+----------------+------------------+---------------+
| 1   29   2379  | 2369  379   267  | 5    8   4    |
| 39  6    8     | 4     379   5    | 2    1   379  |
| 4   5    2379  | 2389  13789 127  | 367  69  379  |
+----------------+------------------+---------------+
| 289 7    5     | 289#  4     3    | 68   69  1    |
| 6   289* 239   | 7     1589* 12   | 38#  4   359  |
| 389 4    1     | 589#  6     9*-8 | 378  2   3579 |
+----------------+------------------+---------------+

In 8s, there's a simple 5-link Oddagon(*) having only three Guardians(#):

Code: Select all

8r79c4      - 8r9c6;
8r8c7 - ??? - 8r9c6; stte.

Now, as I understand Oddagon theory, a chain should exist for 8r8c7, but it's not at all obvious to me. I also believe that Cenoman's amazing network code could find one, so that code is eliminated (temporarily) from the competition.

Any other takers?

SteveC

[SpAce]

Okay, this is not a normal submission. I was just experimenting with nr/nc spaces and used this puzzle as a test bed. I have no idea if anything below is even close to correct, as I was just playing around and seeing if normal solving can even be done in one of those spaces without maintaining a normal rc-grid as well. Seems like it can be done, as I didn't even begin to solve the puzzle normally at all. I just mapped it into nr-space (not rn, which seems useless to me) and solved directly there. To be honest I don't really know what I did because I haven't tried to convert anything back into rc-space. Everything's done manually (except for checking the backdoor) so there can be mistakes of all kinds. Anyway, here goes nothing.

So, this is in nr-space, meaning that rows represent numbers (n), columns represent rows (r), and candidates represent columns (c).

Code: Select all

     r1    r2     r3     r4     r5     r6       r7    r8    r9
   .-------------------.----------------------.-------------------.
n1 | 2     7      4    | 1      8      56     | 9     56    3     |
n2 | 5     13     9    | 2346   7      346    | 14    236   8     |
n3 | 48    2      58   | 345   *159    34579  | 6     379   179   |
   |                   |                      |                   |
n4 | 3     6      7    | 9      4      1      | 5     8     2     |
n5 | 1     458    58   | 7      6      2      | 3     59    49    |
n6 | 46    9      3    | 46     2      78     | 78    1     5     |
   |                   |                      |                   |
n7 | 68    58     1    | 356    59     35679  | 2     4     79    |
n8 | 9     145   x6-2  | 8      3      45     | 147   257   1467  |
n9 | 7     1345   26   | 2345   159    34589  | 148   2359  1469  |
   '-------------------'----------------------'-------------------'

Kraken "cell": n3r5 (3s in row 5 in rc) => -c2 n8r3 (i.e. -8 r3c2):

Code: Select all

(1)n3r5-(1=79)n37c9-(9=4)n5r9-(4=85)n57r2-(5)n8r2
 ||                                        ||
 ||                                       (1)n8r2-(2)n8r3 x
 ||                                        ||
 ||                                       (4)n8r2-(4=5)n8r6-(5=6)n1r6-n1r8=n2r8-(4=1)n2r7
 ||                                              |                                 |
 ||                                             (1)n8r2===========================(1)n8r7
 ||                                                                       ||
 ||                                                                      (1-6)n8r9=(6-2)n8r3 x
 ||                                             
(5)n3r5-n3r3=(5-8)n5r3=n5r2-(8=5)n7r2-(5)n8r2 ... (see above)
 ||
(9)n3r5-(1)n3r5=n3r9-----------------------(1)n8r9
       |            |                       ||
       |           (3)n3r8                  ||
       |            ||                      ||
      (9)n3r8======(7)n3r8-(7)n8r8          ||
                            ||              ||
                           (7)n8r7-(1)n8r7=(1)n8r2-(2)n8r3 x
                            ||
                           (7-6)n8r9=(6-2)n8r3 x

[SpAce]

Here's the same converted into normal rc:

Code: Select all

.----------------.------------------.---------------.
| 5    1    4    | 36    2      67  | 9    37  8    |
| 289  3    29   | 589   5789   4   | 1    57  6    |
| 7   x9-8   6   | 1     35     89  | 4    35  2    |
:----------------+------------------+---------------:
| 1    29   2379 | 2369  379    267 | 5    8   4    |
|*39   6    8    | 4    *379    5   | 2    1  *379  |
| 4    5    2379 | 2389  13789  127 | 367  69  379  |
:----------------+------------------+---------------:
| 289  7    5    | 289   4      3   | 68   69  1    |
| 6    289  239  | 7     1589   12  | 38   4   359  |
| 389  4    1    | 589   6      89  | 378  2   3579 |
'----------------'------------------'---------------'

Kraken row (3)r5 => -8 r3c2, stte.

Code: Select all

(3)r5c1-r9c9=HP:(37-5)r9c79=r9c4=HP:(57-8)r2c58
 ||                                     ||
 ||                                    (8)r2c1-(8)r3c2 x
 ||                                     ||
 ||                                    (8)r2c4-r6c4=(8-1)r6c5=r6c6-
 ||                                           |   (1=2)r8c6-(2)r7c4=(2-8)r7c1
 ||                                           |                        ||
 ||                                          (8)r2c1==================(8)r9c1-r9c6=r3c6-(8)r3c2 x
 ||
(3)r5c5-r3c5=(3-5)r3c8=(5-7)r2c8=(7-8)r2c5 ... (see above)
 ||
(3)r5c9-r5c1=r9c1-(8)r9c1==============
       |         |                    ||
       |        (3)r8c3               ||
       |             ||               ||
      (3)r8c9=======(3-8)r8c7         ||
                          ||          ||
                         (8)r7c7-r7c1=(8)r2c1-(8)r3c2 x
                          ||
                         (8)r9c7-r9c6=r3c6-(8)r3c2 x

[Cenoman]

Strange puzzle. S.E. rating is 7.3, not that hard. But I have found no simpler path than the following sequence of AIC's. (@SteveC: the net rationale for the 8s oddagon, as well as the one for a one-step solution are ugly ! )

Code: Select all

 +---------------------+-----------------------+--------------------+
 |  5     1     4      |  36     2       67    |  9     37   8      |
 | e28-9  3     29     | C589   D5789    4     |  1    D57   6      |
 |  7    d89    6      |  1      35     c89    |  4     35   2      |
 +---------------------+-----------------------+--------------------+
 |  1     29    2379   |  2369   379     267   |  5     8    4      |
 | a39x   6     8      |  4      379     5     |  2     1    379    |
 |  4     5     2379   |  2389  E13789   127   |  367   69   379    |
 +---------------------+-----------------------+--------------------+
 |  289y  7     5      |  289    4       3     |  68    69   1      |
 |  6     289z  239z   |  7    AE158-9   12    |  38    4   u359    |
 | a389wy 4     1      | B589    6      b89    |  378v  2    3579v  |
 +---------------------+-----------------------+--------------------+

1. (39=8)r59c1 - r9c6 = r3c6 - r3c2 = (8)r2c1 => -9 r2c1
2. (5)r8c5 = r9c4 - r2c4 = (57-8)r2c58 = (81)r68c5 => -9 r8c5
3. (5)r8c9 = (57-3)r9c79 = r9c1 - (3=9)r5c1 - r79c1 = (9)r8c23 => -9 r8c9; 4 placements

Code: Select all

 +-----------------+-------------------+-------------------+
 |  5    1    4    |  36    2     67   |  9     37   8     |
 | d28   3    29   |  589   578   4    |  1     57   6     |
 |  7   c89   6    |  1     35   b89   |  4     35   2     |
 +-----------------+-------------------+-------------------+
 |  1    2    37   |  36    9     67   |  5     8    4     |
 |  9    6    8    |  4     37    5    |  2     1    37    |
 |  4    5    37   |  28    18    12   |  367   69   379   |
 +-----------------+-------------------+-------------------+
 | e28   7    5    |  28-9  4     3    |  68    69   1     |
 |  6    89   29   |  7     158   12   |  38    4    35    |
 |  3    4    1    |  589   6    a89   |  78    2    579   |
 +-----------------+-------------------+-------------------+

4. (9=8)r9c6 - r3c6 = r3c2 - (8=2)r2c1 - r7c1 = (2)r7c4 => -9 r7c4; 4 placements

Code: Select all

 +-----------------+------------------+-----------------+
 |  5    1    4    |  36   2     67   |  9    37   8    |
 |  28   3    29   |  59  a78+5  4    |  1    57   6    |
 |  7    89   6    |  1    35    89   |  4    35   2    |
 +-----------------+------------------+-----------------+
 |  1    2    37   |  36   9     67   |  5    8    4    |
 |  9    6    8    |  4   b37    5    |  2    1    3-7  |
 |  4    5    37   |  28   18    12   |  37   6    9    |
 +-----------------+------------------+-----------------+
 |  28   7    5    |  28   4     3    |  6    9    1    |
 |  6    89   29   |  7   A15+8  12   |  38   4    35   |
 |  3    4    1    |  59   6    B89   | C78   2   D57   |
 +-----------------+------------------+-----------------+

5. BUG+2
(5-7)r2c5 = (7)r5c5
(8)r8c5 - r9c6 = (8-7)r9c7 = r9c9
=> -7 r5c9; stte

[Sudtyro2]

Special thanks and kudos to SpAce and Cenoman for their determined efforts to solve this challenging puzzle. I had initially started [what I thought, incorrectly, was] a manual 3D Medusa on the grid but gave up at six levels deep. After seeing SpAce's network, continued coloring later revealed the Kraken 3s at level ten. I strongly suspect that if someone worked up a puzzle rating system for single-step stte eliminations it might very well be the Medusa depth level.

SteveC

[David P Bird]

Sudtyro2,
This is the (8) map for the grid.

Code: Select all

 *-------------------*-------------------*-------------------*
 | .     .     .     | .     .     .     | .     .     8     |
 | 8#    .     .     | 8 PE  8#    .     | .     .     .     |
 | .     8#    .     | .     .     8#    | .     .     .     |
 *-------------------*-------------------*-------------------*
 | .     .     .     | .     .     .     | .     8     .     |
 | .     .     8     | .     .     .     | .     .     .     |
 | .     .     .     | 8     8 Fin .     | .     .     .     |
 *-------------------*-------------------*-------------------*
 | 8 Fin .     .     | 8     .     .     | 8     .     .     |
 | .     8#    .     | .     8#    .     | 8 PE  .     .     |
 | 8#    .     .     | 8 PE  .     8#    | 8 PE  .     .     |
 *-------------------*-------------------*-------------------*

The cells marked 8# are members of an impossible fish r2389c1256, impossible because it produces a contradiction when the cells are coloured.
Therefore this fish cannot be true and at least one fin cell (and one Potential Elimination cell) must be true.
As there are only two fin cells there is a derived strong link (8)r6c5 = (8)r7c1 from which various elimination AICs can be found.

The impossible fish contains multiple oddagons of which r2c5-r8c5-r8c2-r9c1-r2c1 has the two fin cells as guardians. However I like the impossible fish approach. It is easy to spot if you look for three boxes with candidates in one diagonal direction and the fourth box with the candidates in the other diagonal direction.

As this is a 200e200w Nightmare puzzle, I think the aim is to find any solution, not a single-stepper.
.

[200e200w]

As this is a 200e200w Nightmare puzzle, I think the aim is to find any solution, not a single-stepper.

Yes. My Nightmare puzzles are not designed to be solved using a one non-basic step (unless it is a Kraken, a net or more advanced technique). SE rates them from 7.1 to 8.1, sometimes slightly higher. All Nightmares so far were generated using SudoCue software, but this will change with Nightmare #62 (which I believe it will be in March/April).

200e200w

[SpAce]

My "normal" solution would be:

1. Skyscraper: (8)r8c2 = r3c2 - r3c6 = (8)r9c6 => -8 r9c1, r8c5
2. AIC-2: (6)r7c7 = (6-9)r7c8 = r7c4 - r9c6 = (9-8)r3c6 = r3c2 - r8c2 = (8)r8c7 => -8 r7c7
3. AIC-Loop: (2=8)r7c4 - r6c4 = (8-1)r6c5 = r6c6 - (1=2)r8c6 - loop => -8 r29c4, -379 r6c5
4. BUG+1: -78 r2c5

[SpAce]

I had initially started a manual 3D Medusa on the grid but gave up at six levels deep. After seeing SpAce's network, continued coloring later revealed the Kraken 3s at level ten. I strongly suspect that if someone worked up a puzzle rating system for single-step stte eliminations it might very well be the Medusa depth level.

Can you explain what this means and how you did it? I understand 3D Medusa but what do you mean by its depth levels? Is it something like multi-coloring using several Medusa clusters?

I arrived at my horrible net solution by cheating, i.e. knowing the backdoors and thus what candidates should produce a contradiction. Then I drew a half-GEM analysis by assuming one of those candidates (I ignored the other parity because I knew it wasn't important), which ended up emptying the nr-cell (rc-row). In other words it was just t & (guaranteed) e. Then I worked it out in reverse to turn the contradiction into a verity, but it was just cosmetics (looks a bit more legit, doesn't it? ).

The interesting question is how one could find the backdoor(s) manually without cheating. In this case I think it's quite likely to find a backdoor with a powerful enough coloring approach, as you demonstrated with your Medusa approach. Full GEM (using both parities) should also do the trick here relatively easily, as I already did half of it -- you just have to hit the right seeds, but it's not that unlikely here.

[Sudtyro2]

Can you explain what this means and how you did it? I understand 3D Medusa but what do you mean by its depth levels? Is it something like multi-coloring using several Medusa clusters?

In response to SpAce's questions, I have worked up a tutorial of sorts from my scattered notes describing what I assumed (incorrectly) was a Medusa-like approach for solving some of the tougher problems. All comments are welcomed regarding the hidden text below...

Hidden Text: Show

Given foreknowledge of a suitable elimination digit (ED), here's a simple iterative technique (not 3D Medusa) that can quickly and easily generate multi-digit network solutions using only pencil and paper and any two distinguishing marks. Somewhat analogous to multi-coloring, the method uses a preceding star (*) to "color" one type of digit. The second type of digit is colored with a preceding dot (.). The star and dot are simply text characters that can be printed along with the digits in a matrix. In practice, the multi-coloring itself is done manually with pencil and paper, with the star being a circled digit, and the dot being placed just above a digit. A more advanced 4-color technique simply uses an additional red dot and circle on paper, but cannot be printed as such in coded text.

In the procedure described below, a Strong-Inference Set (SIS) is defined as a set of digits having exactly one truth. The set can comprise a row, column, box or cell. The term “peers” refers to multiple occurrences of the same digit in a single row, column or box.

Basic Coloring Procedure:
1. Select an elimination digit (ED).
2. Mark with a star all peers of the ED. Also mark its cellmate(s). Iterations now begin at Step 3.
3. Find in the grid all cells having only one unstarred digit. Mark those digits with a dot. If any two dot-digits also happen to be peers, then change either dot to a star and skip to Step 6, which will also exit the procedure.
4. Mark with a star all the peers of each new dot-digit.
5. The key point to realize after each iteration through Steps 3 and 4 is that every starred digit in the grid can “see” (weakly link to) the ED either directly or via a simple network of interlinked cell SIS having a dot-digit (examples to follow).
6. Next, examine the entire grid for a set of starred digits that forms a SIS in any row, column, box or cell. This is called a Kraken unit. Such a SIS automatically guarantees elimination of the ED, since exactly one of its digits must be true, and since all starred digits can already see the ED. If no SIS is found, simply return to Step 3, and begin the next iteration from there.

Constructing the Network:
Having found a fully starred SIS, start a network with a Kraken column by extending a weak link from each SIS digit (treated as true) to its parent dot-digit (treated as false). There is always a parent dot-digit available for each starred SIS digit. This should be clear from Step 4 of the coloring procedure, since each new dot-digit (the parent) marks with a star all of its peers (the children).

By design, the parent dot-digit is itself one element of a separate cell SIS whose other elements are starred digits. Simply write the dotted cell SIS as a new Kraken column and then extend a weak link from each starred digit to its own parent dot-digit, which belongs to yet another dotted cell SIS. This backtracking process continues until every path in the network converges on a final weak link to the ED.

Note that the simplest dotted cell SIS is a 2-element bivalue cell with one star and one dot. Bivalue cells are not normally written as Kraken columns, but rather as linear X-Y Chain elements of the form, (a = b)rxcy, where (a) is the dot-digit, and (b) is the starred digit. All other cell SIS are written in column format.

Now, a couple of examples taken from Puzzle Forum grids will illustrate the iterative network approach.

Example 1.
This starting grid, after coloring with stars and dots, is from the Puzzles Topic entry for August 6, 2014.

Code: Select all

*--------------------------------------------------------------*
| 4     .5*6   8      |.1*5   3     2      | 9     7    *1.6   |
|*5.6    2     7      | 8    *1.5   9      | 4    .1*6   3     |
| 9      3     1      | 7     4     6      | 8     2     5     |
|---------------------+--------------------+-------------------|
|*6.8   .6*8   2      |*1*45  1*5   14     | 7     3     9     |
| 7      9     5      | 3     2     8      | 6    *14    14    |
| 1      4     3      | 9     6     7      | 5     8     2     |
|---------------------+--------------------+-------------------|
| 2      1     4      | 6     8     5      | 3     9     7     |
| 35*8   7     6      | 2     9     3*4    | 1     45    48    |
| 35*8  *5-8   9      |*1.4   7     13*4   | 2     456   *4*6*8|
*--------------------------------------------------------------*

Examples from the coloring procedure follow.
Step 1: Select the ED to be 8r9c2 and mark with a (-).
Step 2: Star all peers of the ED (four stars total) plus one additional star for cellmate 5r9c2.
Step 3: Mark 6r4c2 with a dot in the cell having only one unstarred digit.
Step 4: Star all peers of 6r4c2 (two stars total) for 6r4c1 and 6r1c2.
Return to Step 3 for iteration 2.
Step 3: Mark two digits with a dot, 8r4c1 and 5r1c2.
Step 4: Star all peers of the two new dot-digits.
Return to Step 3 and perform two more iterations.
Step 6: After four iterations, we find a fully starred SIS at (468)r9c9 and can now construct the network beginning with that SIS. The completed network follows:

Code: Select all

4r9c9 - (4=1)r9c4  - (1=5)r1c4 - (5=6)r1c2 - (6=8)r4c2 – ED
  ||              /                                   /
6r9c9 – (6=1)r1c9                                    /
  ||                                                /
8r9c9 –---------------------------------------------

The network construction process starts with the Kraken column for (468)r9c9. Concentrating on the first line, starred SIS digit 4r9c9 must weakly link to its parent dot-digit, 4r9c4, marked in cell r9c4, which becomes the next SIS to process in the chain. The dot-digit strongly links to its (only) starred digit, 1r9c4. The starred digit, in turn, weakly links to its own parent dot-digit at 1r1c4, as marked in cell r1c4, which becomes the next SIS to process in the chain. This backtracking continues until reaching the ED. The whole process is then repeated for each additional digit in the starting Kraken column.

Some additional comments and caveats may help:
1. “Memory” is not a separate consideration in these networks. The angled weak links shown above simply point to shared chain segments in order to avoid repeated typing.
2. The rote backtrack network, as promised, comprises only interlinked cell SIS, which in this grid are all bivalue cells.
3. Following the (1=5)r1c4 node, there appear to be two possible parent dotted 5-digits to choose from, 5r1c2 and 5r2c5, for the next weak link. But, only the former is actually the parent. One foolproof way to determine this is simply to record by each dot-digit its iteration number when first created. Then, whenever a conflict later appears during the backtracking process, the correct parent digit will be the one having the smaller iteration number. The same issue arises following the (6=1)r1c9 node, where there are two dotted 1-digits available. The correct parent is 1r1c4 rather than 1r2c8.
4. As previously mentioned, the coloring procedure sometimes results in two dot-digits that are also peers. When this happens, simply change either dot to a star and exit the procedure, having now produced one fully starred SIS (Kraken unit). As an exercise one can add two more iterations to the above grid to watch this happen.

Numerous other solving methods are available for this particular puzzle, but the iterative network remains a viable option for the manual solver. The network also helps one to visually inspect all the interacting digits, which often leads to significant shortcuts or alternate paths. For example, the network's chain segment, (5=6)r1c2 – (6=8)r4c2, is equivalent to the ALS, (5=68)r14c2. One can also readily spot the bilocal 5s in r19c2. Hence, the same chain segment can be replaced with the simpler X-Chain segment, 5r1c2 = 5r9c2. In this case, the network shortens to:

Code: Select all

4r9c9 - (4=1)r9c4  - (1=5)r1c4 – 5r1c2 = 5r9c2  – ED       
  ||              /                            /
6r9c9 – (6=1)r1c9                             /
  ||                                         /
8r9c9 –--------------------------------------

Interestingly, the simplified network above appears equivalent to a single AIC that uses the exact same digits:
(8=4|6)r9c9 – (46=15)r19c4,r1c49 - 5r1c2 = 5r9c2 => -8r9c2
The (|) symbol in the first node is the logical XOR operator. The second node is Myth's CoALS rule applied to the two overlapping ALS, (145)r19c4 and (156)r1c49.

Example 2.
In some puzzles the iteration procedure stalls out before it develops a Kraken unit. When this happens, one can usually continue by looking for any starred digit (maybe grouped) that has a conjugate link with a single unmarked peer (bilocals are easiest). If found, that peer can then be marked as a special dot-digit (I use a red dot), and all of its cellmates can be starred red as well. The red dot-digit then looks for and normally marks (with a star) any peer digits, and the iteration procedure continues from there. The only difference in the later construction routine is that the red dot-digit's parents are not its cellmates, but rather its conjugate starred parent. The red dot-digit is also the parent of its red cellmates, in case one of the cellmates becomes part of an eventual Kraken unit. In total, the iterative procedure uses at most four "colors" comprising red/black dots and stars. Note that a black dot-digit is reserved only for cell SIS, while a red dot-digit signifies use in a row/column/box SIS.

Even without an iteration-procedure stall, the use of red-dot peers typically does speed up and shorten the later network construction process, but in turn it also takes longer to complete each iteration because one must pause to manually check for those conjugate peers.

The image below is a scan of the manual iteration worksheet for the Nightmare#25 puzzle grid, starting with the ED at 8r9c6. Note that stars are replaced by circles, and each dot-digit is dotted and numbered just above the digit with the current iteration count.

The Kraken 3s in row 5 develop in iterations 9 and 10. Their dot-parents are: 3r9c1 for 3r5c1, 3r3c5 for 3r5c5, and 3r8c9 for 3r5c9. The raw network construction would begin as something like:

Code: Select all

        8r9c1...
         ||
3r5c1 - 3r9c1
 ||      ||
 ||     9r9c1...    8r2c4...
 ||                  ||
3r5c5 - (3=5)r3c5 - 5r2c4   
 ||                  ||
 ||                 9r2c4...
3r5c9 - 3r8c9                           8r8c2 - (8=9)r3c2 - (9=8)r3c6 - ED
         ||                              ||                          /
        5r8c9...                        8r8c5 -----------------------
         ||                              ||
        9r8c9 - (9=6)r7c8 - (6=8)r7c7 - 8r8c7

The completed network is subject to simplification or modification as in Example 1.

SteveC

[SpAce]

SteveC, thanks for that example! If I understand it correctly, I think it's actually very similar to what I did with the "half-GEM" approach. I just got confused when you called it 3D Medusa. I think it's a misnomer, because the real 3D Medusa uses two parities and only colors strongly-linked clusters, and neither of them is true here. Full GEM also uses two parities, but it follows weak links too (like your system), which is why I call it "3D Medusa on steroids". When you have foreknowledge of the elimination digit, only one parity is interesting because you're looking for contradictions resulting from that particular assumption, instead of eliminations resulting from the combo of both parities. That's why I only used half-GEM here, which seems to be pretty much what you did as well (I just use a different mark-up).

Have you looked at GEM? It's a very powerful coloring technique which makes it trivial to find most linear and network-based eliminations (caused by both parities) and/or contradictions (within just one parity), or in this case to find a network proof (through a contradiction) for a known ED. It's also very easy and quick to use for a pencil-and-paper solver -- if you have an intuitive graphical mark-up for it (not included in the original, but not that hard to create). Personally I think David's original spreadsheet-based approach makes GEM look much more complicated than it really is (not to even mention his unfortunate choice of non-keyboard characters for parity markers).

http://sudopedia.enjoysudoku.com/Graded_Equivalence_Marks.html
http://forum.enjoysudoku.com/post249854.html

[Sudtyro2]

Thanks are due again for additional constructive comments by SpAce and also by DPB (since withdrawn) regarding both terminology and advanced methods available for this puzzle. I was only vaguely aware of GEM, and not much better with 3D Medusa. Accordingly, I will correct some of the nomenclature in my previous writeup. I can fault DPB for only one thing...his old post here was my introduction to the Oddagon, and that, afterall, is what initiated the lead post.

SteveC

[SpAce]

Btw, no matter which of these two ways we use to find the contradiction network, isn't it simply an application of Nishio? Turning it into its Kraken counterpart doesn't really change that or make the process less t&e, even if the end result looks somewhat nicer. The question is: why do we bother making that transformation? Why don't we just use the original Nishio and leave it at that? It's an equally logical proof for the same elimination. Is it somehow more palatable if presented as a Kraken? (I guess I thought so, which is why I did it, but in the end it's just a different wrapping for the same ugly beast.)

What would interest me is figuring out a manually applicable way to find Kraken eliminations directly. GEM or other coloring techniques I know don't really help there, as they can only track two strongly-linked starting assumptions at the same time. Tracking three or more on the same grid manually seems pretty hard, but that's exactly what one would need to use a SIS > 2 as the starting point.

[David P Bird]

Sudtyro2,
After critically reviewing my second post I pulled it because keeping it succinct had caused it to be somewhat distorted, the example was poor, and regarding what you seemed to be aiming to achieve it didn't help much. A major factor was that, unlike you, I won't use branched networks until I've exhausted all other options.

The same factor also bears on the use of oddagons and fish. The more complex fish require too much case by case analysis to be acceptable for me or most manual solvers – but where the dividing line should be placed is a moot point. In comparison, checking for oddagons can be done quite easily and is worth trying first. However, as you found, for one to be of use, a minimum set of guardians must provide suitable ongoing links to produce a useable deduction.

The impossible fish pattern I identified is a bit of an odd ball exception to the above as it provides a series of overlapping oddagons to use. It's relatively easy to spot and it allows the two potential guardian sets for all of them to be identified simultaneously: the external candidates in either the same rows (set A) or the same columns (set B) as the fish. As each of these sets must contain at least one truth, the linking opportunities are easier to identify (but they may not kill the puzzle which was what you were aiming for).

From a quick review of the grid in the post you referenced (well remembered!), it didn't have a simple impossible fish. The situation seemed far more complicated to analyse and included potential rival fish, whereas there was a simple oddagon available that produced the same elimination.

DPB
.