## Almost Nice Loops

Advanced methods and approaches for solving Sudoku puzzles

### Almost Nice Loops

Almost Nice Loops: definiton, examples, and identification

In solving a Sudoku puzzle a human often looks at more or less easily recognizable patterns in order to make progress: we call these patterns “Techniques”. Examples are naked pairs, triples, and quads; X-Wings, Swordfishes (and “higher” fishes”), and Unique Rectangles. Although harder to identify, a Nice Loop can also be considered a pattern: a combination of strong and/or weak links. However, there are puzzles whose hardness does not allow us to solve them using only the previously mentioned techniques. So, more advanced techniques were discovered in order to overcome that, and some of them use what can be viewed as “almost patterns”: for example, we now are aware of the usefulness of Almost X-Wings, Almost Swordfishes, Almost Locked Sets, and Almost Unique Rectangles. These techniques make use of patterns that are very closely related to first ones but still can be used to make deductions. Now, if we can consider that a Nice Loop is a pattern, then what might be his correspondent “almost pattern” technique? The answer of this question is a technique that I decided to call the “Almost Nice Loops”, that I will start to describe next.

Part 1. Almost Nice Loops: definition and examples

Let´s start by defining an Almost Nice Loop (which from now on I will
abreviate as ANL) in the following way:

Almost Nice Loop: a set C of cells that, if one (or more) of them does not have specific candidates “x”, “y”, …, then in the cells of C (or in the remaining cells of C) a nice loop sets up, which eliminates or includes a candidate “z” (z = x,y,… or z not = x,y,…) in a cell belonging to C.

Naturaly, such an ANL can be used “inside” another nice loop, typically a multiple implication nice loop, or inside a single implication network. The definition above might appear confusing, but instead of using a lot of words to explain it I will present some representative examples. Let’s begin with a simple example of this concept. Consider the following puzzle:

Code: Select all
` . . 2 | 6 . . | . . . . 9 . | . . . | 4 . . . 1 . | . . 9 | . . 7-------+-------+------- . . . | . 4 6 | . . 5 . . 4 | . 9 . | . 8 . . . . | 7 1 . | 3 . 4-------+-------+------- 8 . . | . 3 1 | . . . 3 . . | 9 8 . | . . . . . . | 4 . . | . 3 2`

and after the basic steps we get:

Code: Select all
` 57   38   2    | 6   57  4   | 19   19    38      6    9    57   | 1   257 38  | 4    25    38      4    1    38   | 38  25  9   | 256  256   7      ----------------+-------------+--------------- 1279 378  1389 | 238 4   6   | 1279 1279  5       1257 3567 4    | 235 9   235 | 1267 8     16      259  568  89   | 7   1   258 | 3    269   4      ----------------+-------------+--------------- 8    24   567  | 25  3   1   | 567  4567  9       3    24   567  | 9   8   257 | 1567 14567 16      19   57   19   | 4   6   57  | 8    3     2`

Just as a matter of comparision, Simple Sudoku continues with coloring, X-Wing, naked triple, locked candidates, coloring again and then gets stuck. However, please note that we have an Almost Turbot Fish (a simple example of a nice loop) in the set C of cells {r6c2|r6c3|r6c6|r4c4|r3c4|r3c3}, in the sense that, if r6c2 is not “8” then a Turbot Fish sets up in the remaining cells of C that eliminates a “8” from r3c3. This observation can be used in the following multiple implication loop:

[r9c6]=7=[r9c2]-7-[r1c2|r4c2]-8-[r6c2]-{Turbot Fish: [r3c3]-8-[r6c3]=8=
[r6c6]-8-[r4c4]=8=[r3c4]-8-[r3c3]}-8-[r3c3]-3-[r3c4]-8-[r2c6](-3-[r5c6])
=8=[r6c6]-8-[r6c3](-9-[r4c2|r4c3])-9-[r9c3]-1-[r4c2|r4c3]-3,8-[r4c4]-2-
[r5c6]-5-[r9c6],

which implies r9c6<>5 => r9c6=7 and that solve the puzzle.

Let’s see another example of an Almost Turbot Fish, this time in a considerably harder puzzle:

Code: Select all
` . . 3 | 4 . . | 6 . . . 5 . | . . 9 | . . . . . . | 2 . . | . . 5-------+-------+------- 2 6 . | . 7 . | 1 3 . . . . | 8 . . | . 6 7 9 . . | 3 . . | . . .-------+-------+------- 5 . . | . . . | . . 8 . . 4 | . 2 . | . . . . 1 . | . . 3 | 7 . .`

(this is the puzzle posted by Gsf in the thread “Simple example of a POM

Code: Select all
` 178   2789 3    | 4   158  1578  | 6    12789 129     14678 5    1267 | 167 1368 9     | 2348 12478 1234    14678 4789 1679 | 2   1368 1678  | 3489 14789 5      -----------------+----------------+----------------- 2     6    8    | 59  7    45    | 1    3     49      134   34   15   | 8   149  124   | 2459 6     7       9     47   157  | 3   146  1246  | 2458 2458  24     -----------------+----------------+----------------- 5     2379 2679 | 167 1469 1467  | 2349 1249  8       3678  3789 4    | 167 2    15678 | 359  159   1369    68    1    29   | 59  4589 3     | 7    2459  2469  `

Here we have an Almost Turbot Fish in cells {r1c8|r1c2|r7c2|r9c3|r9c8|r9c9}: if r9c9 is not “2” then a Turbot Fish emerges that eliminates a “2” from r1c8. This can be used in a loop to demonstrate that r1c2 must be “2”:

[r9c4]=9=[r4c4]-9-[r4c9]-4-[r6c9](-2-[r1c9])-2-[r9c9]-{Turbot Fish:
[r1c8]-2-[r1c2]=2=[r7c2]-2-[r9c3]=2=[r9c8]-2-[r1c8]}-2-[r1c8]=2=
[r1c2]=2=[r7c2]
-2-[r9c3]-9-[r9c4], => r1c2=2.

I have not begun the notation from the node where the discontinuity arises in order for the reader appreciates better the Almost Turbot Fish in action.

Let’s see now a different example of an Almost Nice Loop. The initial grid:

Code: Select all
` . 2 . | . 4 8 | . . 3 4 6 8 | 3 . 1 | . 7 . 3 . . | 7 . . | . . .-------+-------+------- . 8 4 | 1 . . | 6 . . 2 1 6 | 8 . . | . . 9 . . . | . . . | . . .-------+-------+------- 8 3 . | 6 . . | 5 9 . . 7 . | . . . | . . . 6 . 9 | 2 8 . | 7 . .`

and after the basic steps we get:

Code: Select all
` 159  2   7    | 59   4     8   | 19     6      3       4    6   8    | 3    259   1   | 29     7      25      3    59  15   | 7    2569  269 | 12489  12458  2458   ---------------+----------------+--------------------- 579  8   4    | 1    2359  239 | 6      25     257     2    1   6    | 8    57    47  | 3      45     9       579  59  3    | 459  2569  269 | 1248   12458  24578  ---------------+----------------+--------------------- 8    3   12   | 6    17    47  | 5      9      24      15   7   125  | 49   139   39  | 248    248    6       6    4   9    | 2    8     5   | 7      3      1  `

In this case we have an Almost Nice Loop in the set of cells {r6c4|r6c2|r3c2|r1c1|r1c4}: please note that, if r6c4 is not “4” then we can write [r6c4]=9=[r6c2]=5=[r3c2]=9=[r1c1]=5=[r1c4]=9=[r6c4], => r6c4=9. We can use this information to prove that r5c5<>7:

[r5c5]-7-[r5c6](-4-[r6c2|r6c4]-5,9-[r6c5|r6c6])-4-[r6c4]={Nice Loop:
[r6c4]=9=[r6c2]=5=[r3c2]=9= [r1c1]=5=[r1c4]=9=[r6c4]}=9=[r6c4](-9-
[r6c2]-5-[r3c2])-9-[r1c4]-5-[r3c5]={Almost Unique Rectangle:
r6c5|r6c6|r3c5|r3c6}=5|9=[r3c5|r3c6]-9-[r3c2],

which means that, if r5c5=7 then r3c2 would be an empty cell. Hence, r5c5<>7 and that solves the puzzle.

Some Almost Unique Rectangles and Almost Almost Unique Rectangles allow some interesting aplications of Almost Nice Loops. Consider the following grid:

Code: Select all
` . 4 7 | . . 8 | 5 . 3 . 1 . | . . . | . . . 2 8 . | 3 . . | 9 . .-------+-------+------- . . 6 | 4 8 9 | . . . . 9 . | . . . | 4 5 8 . . . | . . . | 6 . .-------+-------+------- . . . | . 2 4 | 7 . 5 . . . | 5 9 6 | . 3 . . . . | 1 . . | . . .`

After the basic steps and using Uniqueness to eliminate “2” from r8c9 we get:

Code: Select all
` 69    4     7   | 269    16     8     | 5    126    3       369   1     39  | 2679   4567   257   | 28   24678  267     2     8     5   | 3      1467   17    | 9    1467   167    -----------------+---------------------+-------------------- 157   257   6   | 4      8      9     | 3    127    127     137   9     123 | 267    1367   1237  | 4    5      8       48    237   48  | 27     1357   12357 | 6    1279   1279   -----------------+---------------------+-------------------- 139   36    139 | 8      2      4     | 7    69     5       78    27    28  | 5      9      6     | 1    3      4       459   56    49  | 1      37     37    | 28   2689   269    `

In this grid we have an Almost Nice Loop in the set C of cells {r9c5|r9c6|r5c5|r5c6|r1c5|r3c6} that takes advantage of the Almost Almost Unique Rectangle present in cells {r9c5|r9c6|r5c5|r5c6}. Please note the following: if r5c5/r5c6 are not “1”, then an AUR sets up and we have now in C the nice loop [r5c6]=2|6=[r5c5]-6-[r1c5]-1-[r3c6](-7-
[r5c6])-7-[r9c6]-3-[r5c6], => r5c6<>3,7 => r5c6=2. Now, we can use this Almost Nice Loop in the following multiple implication chain:

[r7c2](=3=[r6c2]-3-[r5c1|r5c3])(-6-[r7c8]-9-[r7c3|r9c9])-6-[r9c2]-5-
[r4c2|r5c1|r5c3]-1-[r5c5|r5c6]={Nice Loop: [r5c6]=2|6=[r5c5]-6-[r1c5]-
-1-[r3c6](-7-[r5c6])-7-[r9c6]-3-[r5c6]}=2=[r5c6](-2-[r5c4|r6c4]-6,7-
[r2c4])-2-[r5c3](-1-[r5c1]-7-[r4c2]-2-[r4c9])-1-[r7c3]-3-[r2c3]-9-[r2c4](-
-2-[r2c9])-2-[r2c7]-8-[r9c7]-2-[r9c9](-6-[r3c9])-6-[r2c9](-7-
-[r3c9]
)-7-[r4c9]-1-[r3c9].

This chain means that, if r7c2=6 then r3c9 would be an empty cell. So we must have r7c2<>6 and that solves the puzzle.

Until now, we have seen examples where, for a nice loop to emerge in a set C of cells, a candidate “x” must be first “removed” from a cell (or two) of C. Now, let’s see an example where for a nice loop to emerge we have to “remove” first two different candidates “x” and “y” from two cells of a set C. Consider the following good looking grid

Code: Select all
` . . . | . . . | . . . 6 . 2 | . . . | 8 . 1 3 . . | 7 . 4 | . . 6-------+-------+------- . . 7 | 6 . 1 | 2 . . . . . | 3 5 2 | . . . . . 6 | 4 . 7 | 9 . .-------+-------+------- 9 . . | 2 . 3 | . . 4 7 . 1 | . . . | 3 . 5 . . . | . . . | . . .`

which after the basic steps becomes

Code: Select all
` 15   1579  459 | 18    126   68   | 47   3       29       6    47    2   | 59    3     59   | 8    47      1        3    189   89  | 7     12    4    | 5    29      6       ----------------+------------------+------------------ 45   3     7   | 6     9     1    | 2    45      8        18   189   489 | 3     5     2    | 146  16      7        125  125   6   | 4     8     7    | 9    15      3       ----------------+------------------+------------------ 9    568   58  | 2     167   3    | 167  1678    4        7    2468  1   | 89    46    689  | 3    2689    5        248  2468  3   | 1589  1467  5689 | 167  126789  29   `

Here we have an AUR in cells {r3c2|r3c3|r5c2|r5c3} and, if the reader looks carefully, we also have an Almost Nice Loop in the set C of cells {r5c1|r5c2|r5c3|r9c1|r4c1|r3c2|r3c3}: if r3c2 is not “1” and r9c1 is not “2” then we could write [r5c3]=4|1=[r5c2]-1-[r5c1]-8-[r9c1]-4-[r4c1]
=4=[r5c3], => r5c3=4. But the two conditions {r3c2 not “1” and r9c1 not “2”} are precisely met with r3c5=1, and we have the following SIN:

[r3c5]{=2=[r3c8]-2-[r1c9]=2=[r9c9](-2-[r9c1])-2-[r8c8]}(-1-
[r1c4]-8-[r1c6]-6-[r8c4|r8c6]-8,9-[r8c8])-1-[r3c2]={Nice Loop:
[r5c3]=4|1=[r5c2]-1-[r5c1]-8-[r9c1]-4-[r4c1]=4=[r5c3]}=4=[r5c3](-4-
[r4c1]=4=[r4c8]-4-[r2c8]-7-[r7c8])=9=[r5c2]-9-[r3c2]-8-[r3c3]=8=
[r7c3]-8-[r5c8|r7c8]-6-[r8c8]

which means that, if r3c5=1 then r8c8 would be an empty cell. So, r3c5<>1 and it solves the puzzle.

Let’s now see another example of an Almost Turbot Fish and an example of an Almost Grouped Nice Loop. Consider the following puzzle:

Code: Select all
` 6 . . | . 3 5 | . . . . 8 9 | . . . | . . . . 5 2 | 1 . . | . 8 .-------+-------+------- . . . | . . . | 7 . 3 . . . | 9 . . | 4 . . 4 1 . | . . . | . . 6-------+-------+------- . 9 8 | 3 . . | . . . . . . | . 7 . | 9 . . . . 3 | . 5 . | 1 . .`

which can be advanced with basic steps to here:

Code: Select all
` 6    47   14  | 8     3    5    | 2    17     9       137  8    9   | 2467  46   2467 | 356  14567  1457    37   5    2   | 1     9    467  | 36   8      47     ---------------+-----------------+------------------ 9    2    56  | 456   8    146  | 7    15     3       8    3    567 | 9     16   167  | 4    125    125     4    1    57  | 57    2    3    | 8    9      6      ---------------+-----------------+------------------ 257  9    8   | 3     146  1246 | 56   24567  2457    125  46   14  | 246   7    8    | 9    3      245     27   467  3   | 246   5    9    | 1    2467   8      `

Let’s start by noting that we have an Almost Turbot Fish in the set C of cells {r7c7|r3c7|r3c6|r2c5|r5c5|r7c5}. If r5c5 is not “6” then the following loop emerges in C: [r7c7]-6-[r3c7]=6=[r3c6]-6-[r2c5]=6=[r7c5]-6-
-[r7c7], => r7c7<>6 => r7c7=5. We could then use this observation in the following way:

-6-[r5c5](r5c5=1)-{Nice Loop: [r7c7]-6-[r3c7]=6=[r3c6]-6-[r2c5]=6=
[r7c5]-6-[r7c7]}-6-[r7c7]-5-[r7c1]=5=[r8c1]=1=[r8c3]-1-[r1c3]=1=
[r1c8]-1-[r4c8]=1=[r4c6]-1-[r5c5],

which means that r5c5=1 implies r4c6=1: a contradiction, and so r5c5<>1.
Let’s now look at the same puzzle, particularly to candidates “4” in column 6: it can be seen that, if “4” weren’t in r7c6 then we would be able to write the following grouped nice loop: [r4c6]=4=[r2c6|r3c6]-4-[r2c5]-6-
-[r5c5]-1-[r4c6], => r4c6<>1. Thus, we have an Almost Grouped Nice Loop in the set of cells {r7c6|r4c6|r3c6|r2c6|r2c5|r5c5}, which can be used in the following single implication network:

-4-[r7c6]-{Nice Loop: [r4c6]=4=[r2c6|r3c6]-4-[r2c5]-6-[r5c5]-1-[r4c6]}-
-1-[r4c6]=1=[r4c8]-1-[r1c8](-7-[r9c8])=1=[r1c3]=4=[r8c3]=1=
[r8c1]=5=[r7c1](=2=[r9c1]-2-[r9c8])-5-[r7c7](-6-[r9c8])-6-
[r3c7]=6=[r3c6]-6-[r2c5]-4-[r7c5]=4=[X-Wing between boxes 7/8]-4-
[r9c8]

which means that if r7c6 is not “4” then r9c8 would be an empty cell. So r7c6 must be “4” and it solves the puzzle.

Let’s now see an example of a longer ANL:

Code: Select all
` 5    1     278 | 2678  678   3    | 9    678   4       279  4     278 | 2678  6789  5    | 268  3     1       6    279   3   | 1     4     2789 | 5    78    278    ----------------+------------------+------------------ 8    3     1   | 2567  67    267  | 4    569   69      24   25    9   | 3     1     46   | 7    568   68      47   57    6   | 58    89    489  | 1    2     3      ----------------+------------------+------------------ 3    679   4   | 678   2     1    | 68   6789  5       1    8     27  | 9     5     67   | 3    4     267     279  2679  5   | 4     3     678  | 268  1     26789  `

In this grid, let’s start by noting that in row 7 candidate “7” is present in the three cells r7c2/r7c4/r7c8: now, if “7” is not in r7c4 then we would have a strong link between r7c2 and r7c8 and we would be able to write [r5c9]=8=[r5c8]=5=[r4c8]-5-[r4c4]=5=[r6c4]-5-[r6c2]-7-[r7c2]=7=
[r7c8]
=9=[r9c9]-9-[r4c9]-6-[r5c8|r5c9], => r5c8/r5c9<>6. This observation can be used in the following deduction (note the Almost Locked Set in cells r7c4/r7c7):

-7-[r7c4|r7c8]-6-[r7c2]=6=[r9c2]-{Nice Loop: [r5c9]=8=[r5c8]=5=
[r4c8]-5-[r4c4]=5=[r6c4]-5-[r6c2]-7-[r7c2]=7=[r7c8]=9=[r9c9]-9-
[r4c9]-6-[r5c8|r5c9]}-6-[r5c8|r5c9]-5-[r5c2]=5=[r6c2]-5-[r6c4]-8-
[r6c5]-9-[r2c5]=9=[r2c1]-9-[r9c1]=9=[r9c9]-9-[r4c9]-6-[r8c9]=6=[r8c6]-
6-[r5c6]-4-[r5c1]-2-[r5c2],

which means that, if r7c4 is not “7” then the nice that stes up implies that r5c2 would be an empty cell. So, r7c4 must be “7” and it solve the puzzle.

Let’s look at a final example. Consider the following puzzle:

Code: Select all
` . . . | . 7 . | 9 4 .   . . . | . 9 . | . . 5   3 . . | . . 5 | . 7 .  -------+-------+-------  . . 7 | 4 . . | 1 . .   4 6 3 | . . . | . . .   . . . | . . 7 | . 8 .  -------+-------+-------  8 . . | . . . | . . .   7 . . | . . . | . 2 8   . 5 . | 2 6 . | . . .  `

which was considered until recently as the toughest known puzzle. After some steps we arrive at the following grid:

Code: Select all
` 1256  12     1258  | 1368  7     1236  | 9      4     1236    126   7      1248  | 1368  9     12346 | 2368   136   5       3     1249   12489 | 168   124   5     | 268    7     126    --------------------+-------------------+-------------------- 259   8      7     | 4     235   2369  | 1      3569  2369    4     6      3     | 159   8     129   | 257    59    279     1259  129    1259  | 3569  235   7     | 23456  8     23469  --------------------+-------------------+-------------------- 8     12349  12469 | 7     1345  1349  | 456    1569  1469    7     1349   146   | 1359  145   1349  | 456    2     8       19    5      149   | 2     6     8     | 347    139   13479  `

In this grid we have two ANLs that sets up with the same condition: r7c5 not “4”. First, we have an Almost Turbot Fish in the set of cells {r8c5|r7c5|r3c5|r2c6|r2c3|r8c3}: if r7c5 is not “4” then a new strong link emerges that allow us to write [r8c3]-4-[r8c5]=4=[r3c5]-4-[r2c6]=4=
[r2c3]-4-[r8c3], => r8c3<>4. Second, we have another ANL (an Almost Grouped X-Cycle) in the set of cells {r8c5|r7c5|r3c5|r2c6|r2c3|r9c3|r9c7|r9c9|r8c7}: again, if r7c5 is not “4” then we can write [r8c7]-4-[r8c5]=4=[r3c5]-4-[r2c6]=4=[r2c3]-4-[r9c3]
=4=[r9c7|r9c9]-4-[r8c7], => r8c7<>4. These two pieces of information can be put together in the following deduction:

[r7c5](-3-[r7c6])(-3-[r7c2]=3=[r8c2])-3-[r46c5](-2,5-[r5c46]){-5-
[r56c4]=5=[r8c4](-5-[r8c7])=9=[r8c6](-9-[r7c6])-9-[r5c6]-1-
[r7c6]
}-{Nice Loop: [r8c3]-4-[r8c5]=4=[r3c5]-4-[r2c6]=4=[r2c3]-4-
[r8c3]}-4-[r8c3]-{Nice Loop: [r8c7]-4-[r8c5]=4=[r3c5]-4-[r2c6]=4=
[r2c3]-4-[r9c3]=4=[r9c79]-4-[r8c7]}-4-[r8c7]-6-[r8c3]-1-[r8c5]-4-
[r7c6]
,

which means that, if r7c5=3 then r7c6 would be an empty cell. So, r7c5<>3. This deduction might look completely useless, but in my solution of this puzzle it turns out to play an important role (in conjunction with the previous deduction r8c5<>3).

Part 2. The Two Incompatible Nice Loops Rule (TIL).

The techniques used to solve Sudoku puzzles are based in avoiding some contradiction situation: two candidates “x” in the same unit, no candidate “x” in a given unit, more than one solution for the puzzle, empty cell. However, there are also other contradictions situations that, although more complex and so harder to find, can be exploited in the solving process. One of such situations can be expressed by the following rule:

The Two Incompatible Nice Loops Rule (TIL). If we have a situation in which, considering a given candidate “x” and a certain cell “A”, we can construct a nice loop that proves that “A” cannot be “x” but, at the same time, we can also construct another nice loop that proves that “A” must be “x”, then these two nice loops are in conflict with each other and we have a contradiction situation: so, the hypothesis that originated this conflicting situation must be false.

The better known example of this rule is the Turbot Fish with five strong sides on ”x”: we can write two nice loops for any cell of it, one that forces “x” to be in that cell and another that eliminate “x” from the same cell, which is a contradiction (I call this contradiction – a Turbot Fish with five strong sides – a Deadly Turbot Fish). However, we can have more complex situations where this same rule applies, and it is in these situations where the ANLs can help. Consider the following puzzle:

Code: Select all
` *-----------------------* | . . . | 2 . 3 | 9 . . | | . 5 . | 4 . 7 | . 8 . | | . . . | . 6 . | 4 . . | |-------+-------+-------| | 1 8 . | . . . | . . 6 | | 4 . . | . 1 . | . . 8 | | 3 . . | . . . | . 1 2 | |-------+-------+-------| | . . 8 | . 3 . | . . . | | . 4 . | 6 . 9 | . 3 . | | . . 3 | 5 . 2 | . . . | *-----------------------*`

which after some basic steps becomes:

Code: Select all
` *-------------------------------------------------* | 8      167   4    | 2    5    3  | 9    67  17  | | 26     5     126  | 4    9    7  | 126  8   3   | | 279    3     279  | 18   6    18 | 4    25  57  | |-------------------+--------------+--------------| | 1      8     79   | 379  2    5  | 37   4   6   | | 4      27    257  | 37   1    6  | 357  9   8   | | 3      679   5679 | 789  47   48 | 57   1   2   | |-------------------+--------------+--------------| | 25679  2679  8    | 17   3    14 | 26   25  49  | | 257    4     127  | 6    78   9  | 128  3   157 | | 679    1679  3    | 5    478  2  | 168  67  49  | *-------------------------------------------------*`

From here, this grid can be easily solved with colors, locked candidates, and colors again (considering a type-1 Unique Rectangle as a trivial last step). However, I have decided to study this puzzle in order to find a just one step solution. So, I have noted the presence of an ANL in the set of cells {r1c2|r2c1|r2c3|r2c7|r9c1|r9c2|r9c7|r9c8}: if the three cells r2c7/r9c7/r9c8 are not “6” then we could write [r9c2]=6=[r9c1]-6-[r2c1]
=6=[r2c3]=1=[r1c2]-1-[r9c2], => r9c2<>1. But, at the same time, we could also write another nice loop that proves that r9c2 must be “1”. Also, the condition {r2c7/r9c7/r9c8 not “6”} is precisely met if we consider r7c7=6. So, we could write in chain notation:

[r7c7](-6-[r2c7])-6-[r9c7|r9c8]-{TILA: [r9c2]=6=[r9c1]-6-[r2c1]=6=
[r2c3]=1=[r1c2]-1-[r9c2], => r9c2<>1; [r9c2]=1=[r9c7]-1-[r8c9]=1=
[r1c9]-1-[r1c2]=1=[r9c2], => r9c2=1}.

and we have two loops at the same time, one that proves that r9c2 cannot be “1” and another that proves that r9c2 must be “1”. Here, the hypothesis that originated the conflicting situation is r7c7=6. So, we must have r7c7<>6 and after that we get

Code: Select all
` *------------------------------------------------* | 8    6    4    | 2    5    3    | 9    7    1  | | 2    5    1    | 4    9    7    | 6    8    3  | | 79   3    79   | 18   6    18   | 4    2    5  | |----------------+----------------+--------------| | 1    8    79   | 379  2    5    | 37   4    6  | | 4    2    5    | 37   1    6    | 37   9    8  | | 3    79   6    | 789  47   48   | 5    1    2  | |----------------+----------------+--------------| | 6    79   8    | 17   3    14   | 2    5    49 | | 5    4    2    | 6    8    9    | 1    3    7  | | 79   1    3    | 5    47   2    | 8    6    49 | *------------------------------------------------*`

From here the puzzle is solved with the Type-1 Unique Rectangle. Alternatively, this grid can also be solved from here with an Almost Two Incompatible Loops Argument. The reader is invited to identify it as an exercise.

Part 3. How to identify Almost Nice Loops?

If nice loops are already hard to find, almost nice loops are naturally even harder to identify. However, there are some good starting points. For example, if we have an almost almost unique rectangle (or even an AUR) then there is a very good chance that we are able to construct an ANL with it. A simplified bilocation/bivalue plot is also a natural good start, where an important “pattern” plays a decisive role: units that contain a candidate “x” distributed by exactly three cells (or even four), which in turn can be distributed by two or three units. Obviously, by considering that one of those cells is not “x” we thus have a new strong link that, in conjunction with the already existing b/b plot, can be used in an ANL.

Carcul
Last edited by Carcul on Thu Jun 29, 2006 1:30 pm, edited 3 times in total.
Carcul

Posts: 724
Joined: 04 November 2005

### Re: Almost Nice Loops

Carcul, Congratulations and thank you for sharing this technique; impressive stuff. ANLs were often found while I was looking for nice lops. With this technique, I can save all these ANLs for further deductions.
Jeff

Posts: 708
Joined: 01 August 2005

Thanks Jeff.
Carcul

Posts: 724
Joined: 04 November 2005