The New Sudoku Players' Forum

[SpAce]

I'm not sure what to call or how to properly notate my first move on this puzzle. I could break it into two discontinuous nice loops, but that's two steps and not how I thought about it. If I want to keep it as one move, should I notate it as a forcing chain (not very elegant but that would work, I think) or can I use a loop somehow? Or is there possibly some ALS pattern that would explain it away? Details below.

050000903900700080006050000002600010000245000090003200000060400020008001107000090

Code: Select all

+-------------------+-----------------+------------------+
| 2478  5     148   | 148   128 1246  | 9    2467 3      |
| 9     134   134   | 7     123 1246  | 156  8    2456   |
| 23478 13478 6     | 13489 5   1249  | 17   247  247    |
+-------------------+-----------------+------------------+
| 34578 3478  2     | 6     789 79    | 3578 1    4578   |
| 3678  13678 138   | 2     4   5     | 3678 367  9      |
| 45678 9     458   | 18    178 3     | 2    4567 45678  |
+-------------------+-----------------+------------------+
| 358   38    3589  | 1359  6   1279  | 4    2357 2578   |
| 3456  2     3459  | 3459  379 8     | 3567 3567 1      |
| 1     3468  7     | 345   23  24    | 3568 9    2568   |
+-------------------+-----------------+------------------+


Hidden Text: Show

My first move was r1c8, r2c9 <> 4 because it was pretty easy to see that otherwise (4=27)r3c89 forces both 2 and 7 into r1c1. (Btw, is that a hidden ALS (27) in the first box, and if so, could it be used somehow here?). I guess the forcing chain would look something like this:

Code: Select all

r3c89 <> 4 => r3c89 = 27 => r3c1  <> 2 => r1c1 = 2
                         => r3c12 <> 7 => r1c1 = 7 // contradiction
=> r3c89 = 4


That's not how I'd like to notate it, though. I could break it into two discontinuous loops:

(4-7)r1c8 = (7-2)r1c1 = (2)r3c1 - (2=47)r3c89 - (4)r1c8 => r1c8 <> 4
(4)r2c9 - (4=27)r3c89 - (2)r3c1 = (2-7)r1c1 = (7-6)r1c8 = (56-4)r2c79 => r2c9 <> 4

That seems unnecessarily complicated. What I'd really like is a single loop that would prove that r3c89 = 4. I can come up with something like this:

(4=27)r3c89 - (2)r3c1 = (2-7)r1c1 = (7)r1c8 - (7=2)r3c89 => r3c89 = 4
(or the other way: (4=27)r3c89 - (7)r1c8 = (7-2)r1c1 = (2)r3c1 - (2=7)r3c89 => r3c89 = 4)

...but I'm not sure if it's ok. Is it? Could it be made clearer?

Here's my full line, if anyone's interested:

Hidden Text: Show

1. (4=27)r3c89 - (2)r3c1 = (2-7)r1c1 = (7)r1c8 - (7=2)r3c89 => r3c89 = 4
2. = (7)r1c8 - (7=24)r3c89 - (2)r3c1 = (2-7)r1c1 = (7)r1c8 - => r3c7 <> 7, r3c6 <> 2, r1c1 <> 48
3. UR Type 1: r16c45 (18) => r1c4 = 4
4. (3): r4c2 = r4c1 - r3c1 = r3c4 - r2c5 = r9c5 => r9c2 <> 3
5. W-Wing: (8=3)r3c1 - r4c1 = r4c2 - (3=8)r7c2 => r7c1 <> 8

Edit: Added my updated line based on the fruitful discussion in this thread:

Hidden Text: Show

1. AIC Loop (ALS): (2-7)r1c1 = r1c8 - (7=14=2)r3c789 - r3c1 = loop
=> -48 r1c1; -2 r3c6; -1 r2c7, r3c246; -7 r3c7; -4 r1c8, r2c9, r3c1246 (14 eliminations)
2. UR Type 1: r16c45 (18) => 4r1c4
3. X-Chain: (3)r4c2 = r4c1 - r3c1 = r3c4 - r2c5 = (3)r9c5 => -3 r9c2
4. W-Wing: (8=3)r3c1 - r4c1 = r4c2 - (3=8)r7c2 => -8 r7c1

[JC Van Hay]

Code: Select all

+--------------------------+--------------------+--------------------+
| -48(27)   5         148  | 148     128  1246  | 9     267-4  3     |
| 9         134       134  | 7       123  1246  | 156   8      256-4 |
| 38-4(27)  138-4(7)  6    | 1389-4  5    19-24 | 1-7   (247)  (247) |
+--------------------------+--------------------+--------------------+
| 34578      3478      2    | 6       789  79    | 3578  1      4578  |
| 3678      13678     138  | 2       4    5     | 3678  367    9     |
| 45678     9         458  | 18      178  3     | 2     4567   45678 |
+--------------------------+--------------------+--------------------+
| 358       38        3589 | 1359    6    1279  | 4     2357   2578  |
| 3456      2         3459 | 3459    379  8     | 3567  3567   1     |
| 1         3468      7    | 345     23   24    | 3568  9      2568  |
+--------------------------+--------------------+--------------------+

The 6 solutions of the set of 4 constraints P={2C1, 7B1, (247)L3C89} are
a. 2r1c1, 7r3c12, (24)r3c89 [4 solutions]
b. 2r3c1, (47)r3c89, 7r1c1 [2 solutions]
They exclude the set of 10 candidates X={(48)r1c1, 7r3c7, 4r3c1246, 2r3c6, 4r1c8, 4r2c9},
because of the following derived constraints :
{2r1c1, 7r1c1}, {7r3c12, 7r3c89}, {2r3c89, 2r3c1}, {4r3c89}

They are seen in the following loop :
Loop[2r3c1=(2-7)r1c1=7r3c12-(7=4=2)r3c89] => -X

[SpAce]

Thanks! I don't understand much about constraint sets, but should I conclude that I could have combined my first two steps and achieved the same result with a single continuous nice loop? If so, that makes me feel stupid I'm not that confident about the eliminations in continuous ALS loops, so please correct me if there's something wrong with this logic:

= (2-7)r1c1 = (7)r1c8 - (7=24)r3c89 - (24)r3c1 = (2-7)r1c1 = => r1c1 <> 4,8, r3c7 <> 7, r3c6 <> 2, r3c1246 <> 4

Specifically, can I safely eliminate the 4 from r3c1 even though that cell (but not the candidate) is part of the loop?

The other direction gives us different eliminations:

= (2)r3c1 - (2=47)r3c89 - (47)r1c8 = (7-2)r1c1 = (2)r3c1 - => r1c1 <> 4,8, r3c6 <> 2, r3c7 <> 7, r1c8, r2c9 <> 4

The same question: can I eliminate the 4 from the loop cell r1c8?

Also, can I simply combine the results from both directions and get: r1c1 <> 4,8, r3c7 <> 7, r3c6 <> 2, r3c1246 <> 4, r1c8, r2c9 <> 4 ? I don't really have to, of course, because in the first case we have a box-line-reduction and in the second case a pointing pair, which end up with the same result, but what about the general case?

I have a feeling that I'm not understanding something here...

[Leren]

Wtihdrawn

Leren

[SpAce]

Leren, what takes care of the 4 in r2c9 in your chain? I don't see how you can force 4 into r3c89 if you still have that possibility. (There's a fair chance that I'm simply blind, though. I still have serious gaps in this ALS stuff. Almost all of your chains have made me see things I hadn't seen before, which is a great learning opportunity. PS. Note that I used a W-Wing here for the first time knowingly -- thanks to you as well! )

[eleven]

Code: Select all

+---------------------+-----------------+--------------------+
| c2478   5     148   | 148   128 1246  | 9     2467  3      |
|  9      134   134   | 7     123 1246  | 156   8     2456   |
|db23478 d13478 6     | 13489 5   1249  | 17  ea247 ea247    |
+---------------------+-----------------+--------------------+
|  34578  3478  2     | 6     789 79    | 3578  1     4578   |
|  3678   13678 138   | 2     4   5     | 3678  367   9      |
|  45678  9     458   | 18    178 3     | 2     4567  45678  |
+---------------------+-----------------+--------------------+
|  358    38    3589  | 1359  6   1279  | 4     2357  2578   |
|  3456   2     3459  | 3459  379 8     | 3567  3567  1      |
|  1      3468  7     | 345   23  24    | 3568  9     2568   |
+---------------------+-----------------+--------------------+

(4=2)r3c89-r3c1=(2-7)r1c1=r3c12-(7=4)r3c89 => 4r3c89
[Edited type, thanks to SpAce]

[Leren]

Leren, what takes care of the 4 in r2c9 in your chain? I don't see how you can force 4 into r3c89 if you still have that possibility. (There's a fair chance that I'm simply blind, though. I still have serious gaps in this ALS stuff. Almost all of your chains have made me see things I hadn't seen before, which is a great learning opportunity. PS. Note that I used a W-Wing here for the first time knowingly -- thanks to you as well! )

You are right, my mistake. Eleven's chain looks OK, Leren

[SpAce]

Thanks, eleven! That seems to be exactly what I was looking for. I assume it means my original attempt also works if I correct its faulty bits:

(4=2)r3c89 - r3c1 = (2-7)r1c1 = r1c8 - (7=4)r3c89 => r3c89 = 4

Like that it has the same effect as your chain, correct? (Perhaps a bit simpler too without the group node.)

PS. A bit of a typo in your chain: should be "=r3c12", right?

[SpAce]

Now that my original question seems to be settled, what about the follow-up prompted by JC's reply? Can I combine my first two steps into a single continuous loop and get all of those ten eliminations at once? That seems a bit hazardous to me but is that a valid move? If so, what would be the correct notation for it? Like I said, I'm not very confident with continuous loop eliminations, especially with ALS nodes around.

[Leren]

Having goofed on my first attempt I might as well have another go. Looks like two moves to me.

1. Eleven's discontinuous loop : (4=2) r3c89 - r3c1 = (2-7) r1c1 = r3c12 - (7=4) r3c89 => - 4 r1c8, r2c9, r3c1246; 6 eliminations

2. JC's Continuous loop : (2) r3c1 = (2-7) r1c1 = r3c12 - (7=2) r3c89 loop => - 48 r1c1, - 2 r3c6, - 7 r3c7: 4 eliminations

Leren

[SpAce]

So I don't have to feel stupid for using those (or effectively same) two moves? That's a relief Then again, it would be cool if it could be done in one step.

Is there a good document somewhere that explains in detail what exactly can and can't be eliminated with a continuous ALS loop? I know that you can eliminate along the weak links but the ALSs seem to complicate things. Specifically, what digits of the ALS can be used for eliminations (if only some participate in the loop) and in which houses (if the ALS is on a box-line and thus sees two houses)?

The second "Group Nodes and ALS" example here has quite a few ALS eliminations (in both of its houses):

http://hodoku.sourceforge.net/en/tech_chains.php

[SpAce]

The more I look at the Hodoku example, the more I think it could all be done with a single loop here as well. The 4s get locked in r3c89 either way we travel the loop and thus can be eliminated elsewhere from the box and the row. Can someone explain why not?

One direction:

-(2)r3c1=(2-7)r1c1=(7)r1c8-(7=24)r3c89-(24)r3c1=

The other direction:

=(2)r3c1-(2=47)r3c89-(47)r1c8=(7-2)r1c1=(2)r3c1-

(JC's version of the same should do the trick as well.)

In other words I think we can get all of these in one step: -48 r1c1, -2 r3c6, -7 r3c7, -4 r1c8, r2c9, r3c1246. I guess the first four eliminations are uncontested, but I'm claiming the six 4s too, unless someone explains why it can't be done.

[eleven]

Thanks for spotting the typo.

Written this way, my chain is a loop too (with the link (24-47)r3c89), and you can conclude all eliminations from it:
(47=2)r3c89-2r3c1=(2-7)r1c1=7r3c12-(7=24)r3c89, loop => 4r3c89
On the other hand, you could also derive 4r3c89 from the smaller loop's link 2r3c1=7r3c12 => (2|7)r3c12, 247r3c89.

AIC's are more or less vaguely defined as alternating inference chains. There are different personal styles, which are common sense or not.
Many people only use chains with the same digit at the endpoints, eliminating digits, which see both. Next step is, if one has digit x, the other y and the cells are in one unit (eliminating the digits in the other cell).
It is getting more complex to enumerate the eliminations of a loop, see above. I don't think, that there are simple rules for that.
It is also possible to keep a chain simpler, while putting more complexity in the final deduction.

PS: For manual solvers this is of secondary interest. As long as they can proceed, they probably would not look for hidden additional eliminations.

[SpAce]

Written this way, my chain is a loop too (with the link (24-47)r3c89), and you can conclude all eliminations from it:
(47=2)r3c89-2r3c1=(2-7)r1c1=7r3c12-(7=24)r3c89, loop => 4r3c89

I agree. I saw your first chain as a (Type 2, confirming) discontinuous nice loop (even though the discontinuity was a two-cell node and I'm not sure if I've seen examples of that before). This change turns it into a continuous loop that can do more and be "started" anywhere. I'm just wondering about the notation in the first node. Shouldn't that be "7=24" as well?

On the other hand, you could also derive 4r3c89 from the smaller loop's link 2r3c1=7r3c12 => (2|7)r3c12, 247r3c89.

Yes. That's kind of like my forcing chain (nishio?) logic backwards, isn't it? I like the loop solution best, but it's good to be able to confirm your deductions in multiple ways.

[SpAce]

Many people only use chains with the same digit at the endpoints, eliminating digits, which see both.

I guess that's AIC Type 1 (in Hoduko terms), and also a Discontinuous Nice Loop Type 1 if the elimination happens in one cell (or node) only. This is the most intuitive type, I think. Can also be pretty effective as you can get multiple eliminations in different houses.

Next step is, if one has digit x, the other y and the cells are in one unit (eliminating the digits in the other cell).

That's AIC Type 2, or Discontinuous Nice Loop Type 3, I think. This seems to be the most common type, and they're pretty easy to find once you grasp the idea. Most of the AIC/Nice Loop eliminations I find are these. Not so intuitive at first, though, nor very effective most of the time.

The Type 2 (confirming) Discontinuous Nice Loops and Continuous Nice Loops seem to be rarest, which is unfortunate as they're usually the most effective ones (as we saw in this example). I'm the least confident with these types because they're relatively uncommon finds.