The New Sudoku Players' Forum

[eleven]

... mind putting a picture to your context? as the ... cells don't tell me jack about what it is some random numbers and cell is trying to do.

I hoped, you will clarify, what you mean with " No cell can be reused in chain notation on same digit". Then i know, if my example is adequate or not. If so, i can look for a real world example (there should be many).
(Note: one of them is true and the others false)

[StrmCkr]

when constructing a chain, as a construction rule.
no cell can be reused with the same digit as another node/link in the chain

[eleven]

when constructing a chain, as a construction rule.
no cell can be reused with the same digit as another node/link in the chain

Code: Select all

clear?

No.
Don't know what construction rules you have. But the link "1r1c12=1r1c123" is a reuse of 1 in r1c12, isn't it ?

PS: see a recent example here

[StrmCkr]

i know nice loops use the same cell at start and end to prove a contradiction directly to the starting and end cell as both true and false, i don't do that

{if thats what your getting at? }

as it also relevant in the same chain that the 2nd cell and the last cell are either true for the same candidate and vicariously all peers to those cells are false. {which would exclude the reused cell}

Code: Select all

 something like this instead of a nice loop using elimination cell as a start and end.
     +-------------------+------------------+-------------+
    | 36    168  4      | 7    5     1368  | 29  38  29  |
    | 2(7)  89   29(37) | 29   4     89(3) | 5   6   1   |
    | 5     169  269    | 269  8(3)  169   | 7   38  4   |
    +-------------------+------------------+-------------+
    | 4     5    8      | 3    6     2     | 1   9   7   |
    | 1     3    27     | 5    9     78    | 6   4   28  |
    | 2-7   69   69     | 1    8(7)  4     | 23  5   238 |
    +-------------------+------------------+-------------+
    | 369   4    1      | 69   2     5     | 8   7   39  |
    | 8     7    36     | 4    1     369   | 39  2   5   |
    | 39    2    5      | 8    (37)  379   | 4   1   6   |
    +-------------------+------------------+-------------+

Inverted w-wing: (7) r2c1 = (7-3) r2c3 = r2c6 - r3c5 = (3-7) r9c5 = r6c5 => -7 r6c1;

[eleven]

Didn't see your reply. Please have a look at the link above.

[StrmCkr]

*------------------------------------------------------------------*
| 267 4 2679 | 57 8 157 | 3 79 12 |
| 3 1 27 | e47 9 6 | 248 5 248 |
| 8 5 79 | 3 e14 2 | d14 79 6 |
|----------------------+---------------------+---------------------|
| 1 9 7-4 | f457 fa345 8 | 6 2 fa345 |
| 246 236 5 | 1 234 9 | 7 8 34 |
| 247 23 8 | 6 2345 457 | d45 1 9 |
|----------------------+---------------------+---------------------|
| 9 26 126 | 8 b156 3 | c125 4 7 |
| 2456 7 1246 | 9 1456 145 | 1258 3 1258 |
| 45 8 3 | 2 7 145 | 9 6 15 |
*------------------------------------------------------------------*

(4=5)r4c59-r6c7|r7c5=r7c7-(5=1)r36c7-(1=7)r2c4,r3c5-(7=4)r4c459 => -4r4c3, stte

i really cant even decipher what that is trying to do for those eliminations

do u have a xsudo logic diagram?

[eleven]

what is the | symbol and OR , Else,
i really cant even decipher what that is trying to do

do u have a xsudo logic diagram?

'|' means or. If the 5 is not in r45c9, it must be in one of r6c7 or r7c5. But don't worry, the logic of the chain is correct. It gives a link 4r4c59=4r4c459.That's what i was talking of.
No, i dont't use xsudo.

[StrmCkr]

got it.

Code: Select all

+-------------------+--------------------+-------------------+
| 267   4    269-7  | 57      8      157 | 3       79  12    |
| 3     1    2-7    | 7(4)    9      6   | 28(-4)  5   248   |
| 8     5    9-7    | 3       (14)   2   | (14)    79  6     |
+-------------------+--------------------+-------------------+
| 1     9    -4(+7) | (45-7)  34(5)  8   | 6       2   34(5) |
| 246   236  5      | 1       234    9   | 7       8   34    |
| 24-7  23   8      | 6       2345   457 | (45)    1   9     |
+-------------------+--------------------+-------------------+
| 9     26   126    | 8       16(5)  3   | 12(5)   4   7     |
| 2456  7    1246   | 9       1456   145 | 1258    3   1258  |
| 45    8    3      | 2       7      145 | 9       6   15    |
+-------------------+--------------------+-------------------+


[41,111] 16 Candidates
9 Truths = {1R3 4R3 5R47 7R4 4C47 6N7 4B2}
7 Links = {5c57 7c3 4n34 5b6 7b4}
7 Eliminations, 1 Assignment --> [7R4*7c3*4n3*7b4] => r4c3=7, (7c3) => r1c3<>7, (7c3) => r2c3<>7, (4C7) => r2c7<>4, (7c3) => r3c3<>7, (4n3) => r4c3<>4, (7R4*4n4) =>
r4c4<>7, (7b4) => r6c1<>7

wouldn't it be easier to show that R4C3 = 7 or R4C4 = 7 then a chain shows that R4C7 = 7 and r4c3 cannot be a 4.{by peers}
{R4C4 as 7 reduces R4C59 to "43" }

edit.
ill try writing the chain out later tonight

[David P Bird]

Eleven,

Code: Select all

 *------------------------------------------------------------------*
 |  267    4     2679   |  57    8      157   |  3      79   12     |
 |  3      1     27     | e47    9      6     |  248    5    248    |
 |  8      5     79     |  3    e14     2     | d14     79   6      |
 |----------------------+---------------------+---------------------|
 |  1      9     7-4    | f457 fa345    8     |  6      2  fa345    |
 |  246    236   5      |  1     234    9     |  7      8    34     |
 |  247    23    8      |  6     2345   457   | d45     1    9      |
 |----------------------+---------------------+---------------------|
 |  9      26    126    |  8    b156    3     | c125    4    7      |
 |  2456   7     1246   |  9     1456   145   |  1258   3    1258   |
 |  45     8     3      |  2     7      145   |  9      6    15     |
 *------------------------------------------------------------------*

(4=5)r4c59-r6c7|r7c5=r7c7-(5=1)r36c7-(1=7)r2c4,r3c5-(7=4)r4c459 => -4r4c3, stte

I re-notated this to error check it
(4=5)r4c59 - (5)r6c7|r7c5 ?=? (5)r7c7 - (45=1)r36c7 - (14=7)r2c4,r3c5 - (357=4)r4c459 => r4c3 <> 4

Now the link from (5)r7c5 to (5)r7c7 is indeed strong but the link from (5)r6c7 to (5)r7c7 is weak because there is (5)r8c7.

StrmCkr

when constructing a chain, as a construction rule.
no cell can be reused with the same digit as another node/link in the chain

This is imprecise. I think what you are trying to avoid is a logical contradiction in a chain between either two odd terms, or two even terms, in a chain that contain the same digit in opposite truth states. If the links are sound that should never happen.

DPB



.

[SpAce]

No cell can be reused in chain notation on same digit. (as it can't be both true and false at the same time)

I wanted to ask about this too but never got that far as there were more urgent matters to discuss My immediate question would have been: how is it relevant to X-Wings? I don't see how any candidate needs to be reused in that case, whether you use a single continuous loop or multiple discontinuous loops. Also, the question is not interesting if we're talking about the start/end cell of discontinuous nice loops, as it's obviously legal to reuse that candidate and have opposite truth values there. (However, even that case isn't so clear-cut if there are ALSs involved like in eleven's example.)

The only interesting case in non-ALS situations is in the middle of a chain or a loop if it crosses itself or walks back. About that I have more generic questions. First, where is the rule defined that says the reuse is illegal? Also, is the reuse (allegedly) illegal just because of some artificial rule or has someone investigated that it would actually break something? I'd like to see an example when breaking that rule would cause an error.

I've assumed that when traversing a linear chain or a loop we're only looking at one pair of nodes at a time and anything discovered in earlier nodes is ignored. I interpret it so that theoretically we could have different truth values for a reused candidate during the chain because we shouldn't have to know its history. I don't have any practical examples in mind where such an attempt would have been necessary, as when I've encountered such situations it has meant that I've just discovered a smaller discontinuous loop than I was looking for (and then I've used that by cutting the extra starting cells out). I actually asked about this in a certain notorious thread I'd rather forget, but I don't think anyone picked it up then. I repeat my question here:

"More generally, I assume it's "illegal" to walk back in a nice loop, but does it actually break any logic if you do it near the end to return to the starting cell? I've been tempted to do that sometimes when I've started exploring a chain at some cell but the actual loop has formed elsewhere. In those cases I've played it safe and just used the smaller valid loop, but would be it terrible to walk back to the original starting cell using a few starting links backwards (imagine a loop with a tail)? I've never tried it and don't have an example at hand, but if I remember correctly, the inferences I thought I would get have worked out to be correct. Hardly necessary but is it possible if you really want a direct result in the original starting cell?"

[SpAce]

An example related to my previous question (my last step from the topic puzzle):

Code: Select all

+---------------+----------------+----------------+
| 4   267 c279  | 5   1679  169  |gb1-9   3    8  |
| 5  d89   3    | 149 189   2    |  14    7    6  |
| 68  67   1    | 347 367   689  |  2   ha45+9 45 |
+---------------+----------------+----------------+
| 2   1    479  | 6   589   589  |  4579 G459  3  |
| 3  e89   5    | 2   4     7    | f89    6    1  |
| 68  467  479  | 19  159   3    |  45789 2    457|
+---------------+----------------+----------------+
| 9   24   8    | 137 12357 15   |  6     145  457|
| 7   5    24   | 8   126   16   |  3     14   9  |
| 1   3    6    | 79  579   4    |  57    8    2  |
+---------------+----------------+----------------+


My original elimination step can be seen as a chain (c-f) or a discontinuous loop (b-g):

X-Chain (Empty Rectangle): (9)r1c3=r2c2-r5c2=(9)r5c7 => -9 r1c7

Discontinuous X-Cycle Type 1: (9)r1c7-r1c3=r2c2-r5c2=r5c7-(9)r1c7 => -9 r1c7

A little modification would provide a direct placement (a-Gh):

Discontinuous X-Cycle Type 2: (9)r3c8=r1c7-r1c3=r2c2-r5c2=r5c7-r4c8=(9)r3c8 => 9r3c8

I presume all of those are perfectly legal. But what about this (a-gh):

Discontinuous X-Cycle Type 2: (9)r3c8=r1c7-r1c3=r2c2-r5c2=r5c7-r1c7=(9)r3c8 => 9r3c8

That's reusing not only the starting cell (no problem there) but also r1c7 with opposite truths. Doesn't look pretty but is it actually wrong?

Edit: Inspired by StrmCkr's post below, here's an even more questionable way to express the latter loop:

Discontinuous X-Cycle Type 1: (4|5-9)r3c8=r1c7-r1c3=r2c2-r5c2=r5c7-r1c7=(9-4|5)r3c8 => -45 r3c8

Now the chain has three items that have both truth values. Still it works. (I definitely wouldn't use that, though, because there are much cleaner and more efficient ways to do it.)

[eleven]

I re-notated this to error check it
(4=5)r4c59 - (5)r6c7|r7c5 ?=? (5)r7c7 - (45=1)r36c7 - (14=7)r2c4,r3c5 - (357=4)r4c459 => r4c3 <> 4

Now the link from (5)r7c5 to (5)r7c7 is indeed strong but the link from (5)r6c7 to (5)r7c7 is weak because there is (5)r8c7.

Thanks David, in fact i had the feeling, that something is not tough with that notation. So maybe i should write
(4=5)r4c59-r6c7|r7c5=r7c78-(5=1)r36c7 ...
But it does not reflect, what i saw:
Either the 5 is in r4c5 and r7c5 or in r4c9.

[StrmCkr]

something like this?

Code: Select all

+-----------------+------------------+---------------------+
| 4   267   27(9) | 5    1679   169  | 1(-9)  3        8   |
| 5   8(9)  3     | 149  189    2    | 14     7        6   |
| 68  67    1     | 347  367    68-9 | 2      -45(+9)  45  |
+-----------------+------------------+---------------------+
| 2   1     479   | 6    589    589  | 4579   45-9     3   |
| 3   8(9)  5     | 2    4      7    | 8(9)   6        1   |
| 68  467   479   | 19   159    3    | 45789  2        457 |
+-----------------+------------------+---------------------+
| 9   24    8     | 137  12357  15   | 6      145      457 |
| 7   5     24    | 8    126    16   | 3      14       9   |
| 1   3     6     | 79   579    4    | 57     8        2   |
+-----------------+------------------+---------------------+
'

Discontinuous Nice Loop: 4/5 r3c8 =9= r4c8 -9- r5c7 =9= r5c2 -9- r2c2 =9= r1c3 -9- r1c7 =9= r3c8 => r3c8<>4, r3c8<>5

[SpAce]

something like this?
Discontinuous Nice Loop: 4/5 r3c8 =9= r4c8 -9- r5c7 =9= r5c2 -9- r2c2 =9= r1c3 -9- r1c7 =9= r3c8 => r3c8<>4, r3c8<>5

I think that is indeed an example of reusing a candidate with opposite truth values (the 9 in r3c8) but the unexpressive nice loop notation is hiding it. That's why I wouldn't do it like that. If you insist on using nice loop notation, I'd use the Type 2 Discontinuous X-Cycle (=Nice Loop) which proves that r3c8=9 (simpler than proving it's not 4 or 5, and also avoids the reuse issue):

Discontinuous X-Cycle Type 2: r3c8 =9= r4c8 -9- r5c7 =9= r5c2 -9- r2c2 =9= r1c3 -9- r1c7 =9= r3c8 => r3c8=9

That's definitely correct. I'd rather use Eureka anyway, and I can see two legal ways to do it:

1) X-Chain: (9)r3c8=r4c8-r5c7=r5c2-r2c2=r1c3-r1c7=(9)r3c8 => -45 r3c8

2) Discontinuous X-Cycle Type 2: (9)r3c8=r4c8-r5c7=r5c2-r2c2=r1c3-r1c7=(9)r3c8 => 9r3c8

(They're obviously the same exact chain, but the perspective is different.)

If you really want to use the eliminating discontinuous loop type, then it's not only more complicated but possibly incorrect because of the reuse (though it may not matter because it happens in one cell). Anyway, this is how I would notate it:

3.1) Discontinuous Nice Loop Type 1: ((4|5)-9)r3c8=r4c8-r5c7=r5c2-r2c2=r1c3-r1c7=(9-(4|5))r3c8 => -45 r3c8

or this way to see more clearly the reuse problem with (9)r3c8:

3.2) Discontinuous Nice Loop Type 1: (4|5)r3c8-(9)r3c8=r4c8-r5c7=r5c2-r2c2=r1c3-r1c7=(9)r3c8-(4|5)r3c8 => -45 r3c8

Regardless of the notation, the Discontinuous Nice Loop Type 1 is the most complicated, so why would we want to do it that way? I'd use Discontinuous Nice Loop (X-Cycle) Type 2 here, because it's simplest and avoids any conflicts (the only discontinuity is in the start/end cell, which is legal for sure). To be more exact, the discontinuity is only in the start/end cell in both loops, but there are two of them in the eliminating loop type. Not sure if that's a problem (not in practice here anyway, because it yields a correct result).

[eleven]

You can reuse candidates as often as you want. If the links are correct, the chain will always be correct. So the question is just, why should you ?
Apart from ALS eliminations i only see a reason to longer the chain in order to avoid a contradiction (which should be possible in another way too) or to make additional eliminations (which could be done in a later step also).