The New Sudoku Players' Forum

[bat999]

Code: Select all

.-----------------.----------------.-------------------.
| 479  18   12489 | 27   6     579 | 1257    3    125  |
| 3    5    29    | 1   b24    9-7 | 8      b467  26   |
| 67   16   12    | 3    245   8   | 1257    147  9    |
:-----------------+----------------+-------------------:
| 2    4    159   | 6    7     3   | 159     8    15   |
| 56   168  1358  | 4    9     2   | 13567   167  1356 |
| 69   7    39    | 8    15    15  | 369     2    4    |
:-----------------+----------------+-------------------:
| 1    23   7     | 5    8     6   | 4       9    23   |
| 8    23   6     | 9   a12    4   | 123     5    7    |
| 45   9    45    | 27   3    a17  | 126    a16   8    |
'-----------------'----------------'-------------------'

(7=26)r8c5,r9c68 - (26=7)r2c58 => -7 r2c6; stte

... your second node, (26=7)r2c58, requires that 26r2c58 both be false to make the AIC work...

But 26r2c58 are both false.
The 2 in r8c5 eliminates the 2 in r2c5 so it is false.
The 6 in r9c8 eliminates the 6 in r2c8 so it is false.

Like I said "The 26 in r8c5,r9c68 eliminate the 26 in r2c58 and forces 7 in r2c58"

[SteveG48]

Thanks, guys. Sorry I've been tied up most of the time lately and haven't been around too much. Yes, my chain had a typo, but was shown correctly on the PM.

Bat, my use of the & and | symbols follows the normal use of those symbols in Boolean algebra. It's been discussed by Danny Jones, David P. Bird, and several others on the forum, but I don't know where it's all summarized in one place. Basically, if two Boolean terms are connected with the & (AND) symbol, then the composite term is true only if both terms are true. For example, (1r1c1)&(2r1c2) is true only if both 1 and 2 are true in the cell pair r1c12. The custom in the forum to often omit the & symbol altogether, so we might write (1r1c1)(2r1c2), or more commonly (12)r1c12, to mean both 1 and 2 are true in the cell pair.

The | (OR) symbol means the composite term is true if either or both of the connected terms are true. Unfortunately, we often get careless in writing these chains and omit this symbol as well, leading, IMO, to some confusion. I've tried to discipline myself to always include the | symbol where it's appropriate. For example, if a chain were to show that cells r1c12 contain the pair 12, and candidates in r1c3 are [1,2,3], we might be tempted to write (12)r1c12 - (12=3)r1c3, but the second term would actually be incorrect. Using the convention 12 to mean 1 AND 2 (1&2), the second term would say that if 12 is incorrect then 3 must be correct. This is wrong, since 12 is incorrect if either 1 or 2 is incorrect. Properly, we should write (12)r1c12 - (1|2=3)r1c3. Now the second term is saying that if neither 1 nor 2 is true in r1c3, then 3 must be true.

[pjb]

Aren't we just avoiding the fact that this approach is just an elegant way of not representing it as a network, not that there is anything wrong with that. I would personally write it as:

Code: Select all

         (1=4)r28c5
        /          \
(7=1)r8c6           (46=7)r2c8
        \          /
         (1=6)r9c8


Phil

[Sudtyro2]

Or write the AALS (2|6|4&7)r2c58 as a Kraken column, but I guess that's also a network of sorts...

Code: Select all

47r2c58                           -7r2c6
   ||
 2r2c5 - (2=1)r8c5 - (1=7)r9c6    -7r2c6
   ||
 6r2c8 - (6=1)r9c8 - (1=7)r9c6    -7r2c6


OK, I'm going to shut up for a while!

SteveC

[bat999]

..The custom in the forum to often omit the & symbol altogether,...
... - (1|2=3)r1c3.... Now the second term is saying that if neither 1 nor 2 is true in r1c3, then 3 must be true.

Right, I can live with that.
Let the AND symbol be implied, use the OR symbol when appropriate.
(This has become apparent now that I'm using AALS etc, need to eliminate more than one candidate at a time so OR symbol is necessary)

I hope this is OK.

Code: Select all

.-----------------.----------------.-------------------.
| 479  18   12489 | 27   6     579 | 1257    3    125  |
| 3    5    29    | 1   b24    9-7 | 8      b467  26   |
| 67   16   12    | 3    245   8   | 1257    147  9    |
:-----------------+----------------+-------------------:
| 2    4    159   | 6    7     3   | 159     8    15   |
| 56   168  1358  | 4    9     2   | 13567   167  1356 |
| 69   7    39    | 8    15    15  | 369     2    4    |
:-----------------+----------------+-------------------:
| 1    23   7     | 5    8     6   | 4       9    23   |
| 8    23   6     | 9   a12    4   | 123     5    7    |
| 45   9    45    | 27   3    a17  | 126    a16   8    |
'-----------------'----------------'-------------------'

(7=26)r8c5,r9c68 - (2|6=7)r2c58 => -7 r2c6; stte

First expression reads to me "NOT(7) in r8c5,r9c68 forces (2 AND 6) in r8c5,r9c68".
Second expression reads to me "NOT(2 OR 6) in r2c58 forces (7) in r2c58".

[SteveG48]

Aren't we just avoiding the fact that this approach is just an elegant way of not representing it as a network, not that there is anything wrong with that. I would personally write it as:

Code: Select all

         (1=4)r28c5
        /          \
(7=1)r8c6           (46=7)r2c8
        \          /
         (1=6)r9c8


Phil

To some extent, yes. However, I'm trying my best to write all of my chains as in-line logic statements that read correctly in both directions. Naturally, I'm not always successful!

[ArkieTech]

Aren't we just avoiding the fact that this approach is just an elegant way of not representing it as a network, not that there is anything wrong with that. I would personally write it as:

Code: Select all

         (1=4)r28c5
        /          \
(7=1)r8c6           (46=7)r2c8
        \          /
         (1=6)r9c8


Phil

I like it

Code: Select all

[ *--------------------------------------------------------------------*
 | 479    18     12489  | 27     6      579    | 1257   3      125    |
 | 3      5      29     | 1     b24     9-7    | 8     c467    26     |
 | 67     16     12     | 3      245    8      | 1257   147    9      |
 |----------------------+----------------------+----------------------|
 | 2      4      159    | 6      7      3      | 159    8      15     |
 | 56     168    1358   | 4      9      2      | 13567  167    1356   |
 | 69     7      39     | 8      15     15     | 369    2      4      |
 |----------------------+----------------------+----------------------|
 | 1      23     7      | 5      8      6      | 4      9      23     |
 | 8      23     6      | 9     b12     4      | 123    5      7      |
 | 45     9      45     | 27     3     a17     | 126   B16     8      |
 *--------------------------------------------------------------------*
           (1=4)r28c5
[(7=1)r9c6{          }-(46=7)r2c8]-7r2c6
           (1=6)r9c8


[bat999]

(7=1)r9c6 - (1=[2r8c5]&[6r9c8]) - (2|6=47)r2c58 => -7 r2c6

(7=26)r8c5,r9c68 - (2|6=7)r2c58 => -7 r2c6; stte

These two do the same job.

Steve asked...
Is there a 7 in r9c6?
If yes then test the trivial stream.
(7)r9c6 - (7)r2c6
If no then test the second stream through the chain.
Both give the same result -7 r2c6.

I asked...
Is there a 7 in r8c5,r9c68?
If yes then test the trivial stream (because the 7 can only be in r9c6).
(7)r9c6 - (7)r2c6
If no then test the second stream through the chain.
Both give the same result -7 r2c6.


Now consider that group of three cells r8c5,r9c68 with four candidates 1267.
If we remove the 7 we can predict accurately where the 126 must be.
This is classic use of an ALS, knock out one candidate to force the remaining candidates into positions that are helpful.

A definition of an ALS is "a group of N cells in a single house with candidates for N+1 digits". ---> http://sudopedia.enjoysudoku.com/Almost_Locked_Set.html
But r8c5,r9c68 don't fit that definition.

A collective noun for a group of Sudoku cells is "set".
Is there a more exact way to describe the group of cells r8c5,r9c68?

[JC Van Hay]

Aren't we just avoiding the fact that this approach is just an elegant way of not representing it as a network, not that there is anything wrong with that. I would personally write it as:

Code: Select all

         (1=4)r28c5
        /          \
(7=1)r8c6           (46=7)r2c8
        \          /
         (1=6)r9c8


Phil

To some extent, yes. However, I'm trying my best to write all of my chains as in-line logic statements that read correctly in both directions. Naturally, I'm not always successful!

What about : 7r2c8=*[(1=*4)r92c8-(4=1)r28c5]-(1=7)r9c6 -> [7r2c8==7r9c6]-(7=9)r2c6; stte

[SteveG48]

Aren't we just avoiding the fact that this approach is just an elegant way of not representing it as a network, not that there is anything wrong with that. I would personally write it as:

Code: Select all

         (1=4)r28c5
        /          \
(7=1)r8c6           (46=7)r2c8
        \          /
         (1=6)r9c8


Phil

To some extent, yes. However, I'm trying my best to write all of my chains as in-line logic statements that read correctly in both directions. Naturally, I'm not always successful!

What about : 7r2c8=*[(1=*4)r92c8-(4=1)r28c5]-(1=7)r9c6 -> [7r2c8==7r9c6]-(7=9)r2c6; stte

I like it. I also like Phil's and Bat's. But I still like mine. However, in retrospect instead of writing

(7=1)r9c6 - (1=[2r8c5]&[6r9c8]) - (2|6=47)r2c58 => -7 r2c6 I would prefer to have written

(7=1)r9c6 - (1=26)r8c5,r9c8 - (2|6=47)r2c58 => -7 r2c6

[David P Bird]

In using fish, deadly patterns etc we already have group nodes that aren't confined to one house so using split group nodes - or more simply a split nodes - with cells in different houses is in my eyes far more acceptable than using memory chains or kraken nodes. They are applicable when everything stays in step and the Boolean state of each node is unambiguous. This means that the chain can still be followed by reading in one direction (either L to R or R to L) in comparison to a branched chain when the different branches have to be followed individually.

A search turned up this <2010 reference> to split nodes.
FWIW Using split nodes I would notate that elimination like this
(7=1)r9c6 - (1#2=46)r28c5,r9c8 - (46#1=7)r2c8 => r2c6 <> 7
This is flawed - see following posts

Occasionally reading some of the notations on this puzzles section reminds me of an apocryphal story from my days in the tournament bridge world:
A pair of experts were playing two LOLs (Little Old Ladies in the bridge world, renowned for being devious). When LOL-1 bid one no-trump, one expert asked LOL-2 'How many high-card points do you need for that bid?' '12 to 14' she said. He therefore entered the bidding and got heavily penalised because LOL-1 had 16 points. But you said you bid 1NT on 12-14 points he complained. 'Yes I do' LOL-2 replied 'but my partner likes to have 15-16.

I covered some of the issues raised here <a year ago>

[SteveG48]

A search turned up this <2010 reference> to split nodes.
FWIW Using split nodes I would notate that elimination like this
(7=1)r9c6 - (1#2=46)r28c5,r9c8 - (46#1=7)r2c8 => r2c6 <> 7

David, I'm sinking again. I thought I understood your # notation to indicate the number of truths, so something like abc#n would be true if n of the listed candidates were true. With that understanding I expect n to be less than the number of listed candidates, as in your term 46#1, but I don't understand what you mean by 1#2.

[David P Bird]

A search turned up this <2010 reference> to split nodes.
FWIW Using split nodes I would notate that elimination like this
(7=1)r9c6 - (1#2=46)r28c5,r9c8 - (46#1=7)r2c8 => r2c6 <> 7

David, I'm sinking again. I thought I understood your # notation to indicate the number of truths, so something like abc#n would be true if n of the listed candidates were true. With that understanding I expect n to be less than the number of listed candidates, as in your term 46#1, but I don't understand what you mean by 1#2.

Oh Bullswuffle! I've dropped myself in it.
The interpretation of (1#2)r28c5,r9c8 is that it's true when these cells hold two instances of (1) and false otherwise.

However I simply translated ArchiTech's version of the branched path into a split node format.
But the path through column 5 he had as (1=4)r28c5 should be (12=4)r28c5 which would have to be combined with (1=6)r9c8 in the split node and it all gets messy.
(7=1)r9c6 - (12=46)r28c5,r9c8 - (46#1=7)r2c8 => r2c6 <> 7
This seems to work but it requires the reader to go through mental gymnastics to work out the permutations of the truths in the r28c5,r9c8 which is not the aim of a good notation.
Breaking it up differently this is far better:
(7=1)r9c6 - (1=26)r8c5,r9c8 - (26#1 =47)r2c58 => r2c6 <> 7
Now checking back I find that this is a more compact version of how you did it originally Steve!

It's long past my bed time now so I hope I haven't boobed again!

[SteveG48]

Thanks, David. I learn a lot from you, and it's appreciated.