The New Sudoku Players' Forum

[eleven]

Code: Select all

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

oops, easier than i thought ...

[Cenoman]

Code: Select all

 +---------------------+---------------------+---------------------+
 |  237   26    8      |  1     9     c67    |  4     5     23     |
 |  279   269   5      |  3     4      8     |  167   679   12     |
 |  39    4     1      | b267  b567    25    | a67    39    8      |
 +---------------------+---------------------+---------------------+
 |  249   1     279    |  8     567    245   |  3     67    5679   |
 |  6     5     2379   |  279   37     1     |  8     4     79     |
 |  49    8     379    |  679   3567   45    |  2     1     5679   |
 +---------------------+---------------------+---------------------+
 |  8     7     6      |  5     1      3     |  9     2     4      |
 |  5     29    29     |  4     8     d67    |  1-67  367   13     |
 |  1     3     4      |  67    2      9     |  5     8     67     |
 +---------------------+---------------------+---------------------+

Remote pair (67)r3c7=r3c45-r1c6=r8c6 => -67 r8c7; ste

Typo corrected.

[SpAce]

Code: Select all

.----------------.-----------------.-------------------.
| 237  26   8    | 1     9     67* |  4     5     23   |
| 279  269  5    | 3     4     8   |  167   679   12   |
| 39   4    1    | 267#  567#  25  | (67)*  39    8    |
:----------------+-----------------+-------------------:
| 249  1    279  | 8     567   245 |  3     67    5679 |
| 6    5    2379 | 279   37    1   |  8     4     79   |
| 49   8    379  | 679   3567  45  |  2     1     5679 |
:----------------+-----------------+-------------------:
| 8    7    6    | 5     1     3   |  9     2     4    |
| 5    29   29   | 4     8     67* |  1-67  367   13   |
| 1    3    4    | 67*   2     9   |  5     8    [67]* |
'----------------'-----------------'-------------------'

Grouped Remote Pair:

(67)r9c9,r9c4,r8c6,r1c6,r3c45,r3c7 => -67 r8c7; stte

Oops. The same as Cenoman's. (Well, almost. Why did I have that extra pair for nothing??)

[SpAce]

Hi Cenoman,

Remote pair (67)r3c7=r4c45-r1c6=r8c6 => -67 r8c7; ste

While that's very intuitive and easy to understand, I wouldn't write it as an AIC (for the same reasons I wouldn't write an SK-Loop as one). A correct single AIC would be quite a bit more complicated.

[Cenoman]

Hi Cenoman,

Remote pair (67)r3c7=r4c45-r1c6=r8c6 => -67 r8c7; ste

While that's very intuitive and easy to understand, I wouldn't write it as an AIC (for the same reasons I wouldn't write an SK-Loop as one). A correct single AIC would be quite a bit more complicated.

Typo (r3c45) corrected.
The most logical writing would be two chains, one for th 6s, the other for the 7s (especially here, with groups 6r3c45 and 7r3c45...) Is there a standard for writing remote pairs ?

[SpAce]

The most logical writing would be two chains, one for th 6s, the other for the 7s (especially here, with groups 6r3c45 and 7r3c45...)

Indeed. Of course it's possible to write as a single AIC, but it's not as intuitive to understand. For example:

(6,7)r8c6,r3c7 = r8c6|r3c45 - (7=6)r1c6 - r3c45|r8c6 = (6,7)r3c7,r8c6 => -67 r8c7; stte

Is there a standard for writing remote pairs ?

I don't think so. I think it's one of those patterns where the simplest approach is just to name it and then list the cells, because most people know what a Remote Pair is and how it works. However, this case wasn't a standard Remote Pair because of the group, so calling it just that surely throws off beginners. It's not that long ago that I would have been confused by it (and in fact was when I first saw it used here).

That's why I'd like to call it "Grouped Remote Pair" so the reader knows to expect something different from normal. I don't think grouped examples are shown in any common sources under the name of "Remote Pair", so it's probably not a commonly known variant (for example Hodoku doesn't see it as such). It's also clearly a much harder pattern to spot than the standard (trivial) case, so I think it deserves its own prefix.

[SpAce]

Hi Cenoman (and others),

I'd like to return to this good question of yours (whenever you have time):

Is there a standard for writing remote pairs ?

As I said, I don't think so. However, I'd like to suggest one, as none of the previously mentioned options seem very good. As a recap of them:

1. AIC look-alike: (67)r3c7 = r3c45 - r1c6 = (67)r8c6
   
   good: readable and intuitive (if you know RPs), short
   bad: no hint it's not a real AIC (thus incorrect, confusing), depends on knowing the RP-pattern
   
2. List of cells: (67)r3c7,r3c45,r1c6,r8c6
   
   good: correct, short
   bad: poorly readable, ugly, no logic flow, depends on knowing the RP-pattern
3. Two X-Chains: (6)r3c7 =...= (6)r8c6 + (7)r3c7 =...= (7)r8c6
   
   good: correct, easiest to understand, no RP-dependence
   bad: not a single step, can't be used as an embedded pattern, long
   
4. Single AIC: (6,7)r8c6,r3c7 = r8c6|r3c45 - (7=6)r1c6 - r3c45|r8c6 = (6,7)r3c7,r8c6
   
   good: correct, full logic shown, no RP-dependence
   bad: long and complicated, hard to read and write

As usual, I'd like to have the best of all worlds, at least as much as possible. I'm ready to ignore RP-dependence, because most players know what RP is so it's not a real problem. Thus, the first option, i.e. Cenoman's original, seems clearly the best in all other aspects except correctness. Unfortunately, that single fault rules it out in my books, unless it's somehow made different enough from normal AICs. I suggest using the '/' for that purpose:

(6/7)r3c7 = r3c45 - r1c6 = (6/7)r8c6 => -67 r8c7; stte

The '/' is not a standard symbol in normal AICs or fishes, so it shouldn't be confused with anything else. Here it would give a hint that the chain should not be interpreted as a normal AIC but as two interwoven X-Chains using both digits separately (as in option 3) -- in other words a (Grouped) Remote Pair. To make it clearer, the pattern name should usually be mentioned nearby (preferably with the Grouped-prefix if needed).

One caveat. I have already suggested the '/' should be used with SK-Loops as well (which aren't correct AICs either if written in the common style), and David has suggested the same much earlier. However, I don't think it would be a real problem if it were used in both, even though the suggested semantics are slightly different. In both cases we have two interwoven chains or loops, so they share a context, and the purpose of the '/' is to hint that they should be interpreted accordingly -- as either (Grouped) Remote Pairs or SK-Loops instead of normal AICs. The context (and the also suggested SK-Loop postfix) should make it very clear which interpretation and semantics are to be used, so I don't see much room for confusion.

PS. I just tried the suggested style here.

Any objections or counter-suggestions? To me the most important thing is that non-AICs aren't knowingly presented as AIC-lookalikes without any hint to their real nature. That hint needs to be within the chain notation itself, not just in the form a pattern name (though that's good to have too).

PPS. There's of course one more possibility which also happens to be the shortest: a double-digit fish:

(67)R3C6\r8c7b2 => -67 r8c7

That might in fact be my personal favorite, but I doubt it's very popular otherwise. It does have clear benefits though: shortest by far (especially with longer chains), no RP-dependence, standard notation, no new symbols needed, easy to embed as an almost-pattern (as in my August 3 solution, linked above).

[StrmCkr]

Xy chain that's limited to 2 digits, is usually how a remote pair is coded.

Added grouped nodes. Between the bivavle cell or the bilocation is also possible and these would look more like an AIC chain the a remote pair which usually are restricted to bivavle cells.

[SpAce]

Hi StrmCkr,

Thanks for commenting!

Xy chain that's limited to 2 digits, is usually how a remote pair is coded.

That's not how I would do it. Sure, it's a simple check if you already have all XY-Chains mapped, but that seems inefficient if you end up not needing any XY-Chains. Remote Pairs are much simpler to detect than generic XY-Chains, and should be way before them in a default hierarchy, so I might even search them separately (just like I do manually -- they're one of the easiest patterns to see with a glance). Those findings could be used to check for W-Wings too. X-Chains should also come before XY-Chains, so you could just as well check if you have two parallel X-Chains to find Remote Pairs. That would also reveal the grouped variants (if you search for grouped X-Chains), which doesn't happen with the xy-check at all.

Besides, this is not about detection algorithms but how to express Remote Pairs formally. XY-Chain is the dumbest option for that. You still need two of them, just like with X-Chains, but the number of strong links, digits, and candidates is doubled for no reason. The only correct options to eliminate both digits at once is with a complex (split-node) AIC or a double-digit fish. No simple chains can do that. The notation I just suggested doesn't change that fact -- it's just a simple facade hiding the more complex reality.

For example:

Code: Select all

.----------.--------------.------------------.
| 8   6  1 | 4   2     7  |  35     35   9   |
| 9   3  4 | 6  a18*   5  | b18*    7    2   |
| 2   5  7 | 3   9     18 |  4      6   c18* |
:----------+--------------+------------------:
| 4   9  3 | 8   6     2  |  7      1    5   |
| 7   2  5 | 1   4     3  |  9      8    6   |
| 1   8  6 | 5   7     9  |  2      4    3   |
:----------+--------------+------------------:
| 36  7  2 | 9   5-18  4  |  13568  35  d18* |
| 36  1  9 | 7   58    68 |  3568   2    4   |
| 5   4  8 | 2   3     16 |  16     9    7   |
'----------'--------------'------------------'

Possible single-step expressions:

Remote Pair: (1/8)r2c5 = r2c7 - r3c9 = (1/8)r7c9 => -18 r7c5 (not a real AIC of any kind!)

AIC: (1,8)r2c5,r7c9 = r2c5|r3c9 - (8=1)r2c7 - r2c5|r3c9 = (1,8)r7c9,r2c5 => -18 r7c5

Double-digit 2x3-fish: (18)R2C9\r7c5b3 => -18 r7c5

Pairs of steps:

1. X-Chain: (1)r2c5 = r2c7 - r3c9 = (1)r7c9 => -1 r7c5
2. X-Chain: (8)r2c5 = r2c7 - r3c9 = (8)r7c9 => -8 r7c5
-> 2x2 strong links

1. W-Wing: (1=8)r2c5 - r2c7 = r3c9 - (8=1)r7c9 => -1 r7c5
2. W-Wing: (8=1)r2c5 - r2c7 = r3c9 - (1=8)r7c9 => -8 r7c5
-> 2x3 strong links

1. XY-Chain: (1=8)r2c5 - (8=1)r2c7 - (1=8)r3c9 - (8=1)r7c9 => -1 r7c5
2. XY-Chain: (8=1)r2c5 - (1=8)r2c7 - (8=1)r3c9 - (1=8)r7c9 => -8 r7c5
-> 2x4 strong links

As you can see, there are lots of options to express those eliminations, but all the simple chain variants need two steps. Of those X-Chain is clearly the best, and XY-Chain is the worst. The longer the chain, the more dramatic the difference, because an XY-Chain always needs twice as many of almost everything.

Added grouped nodes. Between the bivavle cell or the bilocation is also possible and these would look more like an AIC chain the a remote pair which usually are restricted to bivavle cells.

Even then the simplest and the most efficient option is to see them as a parallel pair of grouped X-Chains. There's no need for intracellular links at all in any form of Remote Pair, if it's seen as two chains, so you never need XY-Chains or generic AICs to either detect or to express them. Using those more complex chain types won't give you a single-step chain anyway (without split-nodes), so there's no upside. (I do agree with you that the grouped variants look very different from the normal types, so that's why I've suggested they should have the "Grouped" prefix in the name. They're a very different beast to spot for a manual solver.)

If you want to express a Remote Pair (simple or grouped) as a single AIC, then you really need split-nodes like in my examples, which puts the complexity into another ballpark entirely. I bet few people (and even fewer software solvers) would even know how to write it as a correct AIC, because they've probably never really thought about it. It seems much simpler than it is.

[StrmCkr]

Only need 1 xy chain as a remote pair to have both eliminations.. Any cell that sees start and end cant be any of the common digits of those cells. (2 digit xy Chan is the way most people coded solvers to find these and the easiest figured I'd mention it as it was asked)

When Start and end see each other it's a loop...

Notations for these has always been wonky

Usually they start with the elimination cells and end with them which show that both 6,7 for the cells are false based on the direction of reading the chain.

Some fun with grouped nodes for remote pairs from way back...
http://forum.enjoysudoku.com/remote-triples-t6405-15.html?hilit=Remote%20triple
double-digit fish
Which is where that thread ended off noting lol

[SpAce]

Only need 1 xy chain as a remote pair to have both eliminations.. Any cell that sees start and end cant be any of the common digits of those cells.

Let me repeat what I just said:

I bet few people (and even fewer software solvers) would even know how to write it as a correct AIC, because they've probably never really thought about it. It seems much simpler than it is.

In other words, if you think that a Remote Pair can be accurately expressed with a single XY-Chain, you haven't thought it through. You need two to eliminate both digits. A single XY-Chain can only eliminate candidates of a single digit, and that's it. Reversing the chain doesn't change anything. You need to actually swap the digits, which makes it a new chain. Thus two, not one. (However, see * for a kludgy way to do it with just one XY-Loop.)

If you attempt to use a single XY-Chain to eliminate two digits, you must be looking at the whole chain to know it's comprised of just those two digits, and you must also know that it means they can be swapped. In other words, you're actually seeing two different chains even if you don't write it out. Such clairvoyance and implicit swapping are not AIC logic. Since an XY-Chain is an AIC you can only use AIC logic with it, or otherwise you need to call it something else and declare what logic you're using.

(2 digit xy Chan is the way most people coded solvers to find these and the easiest figured I'd mention it as it was asked)

Like I also explained, it's not the easiest or the smartest way to do it. I'm a bit surprised if most people have coded their solvers like that.

When Start and end see each other it's a loop...

Yeah, but a (classic) Remote Pair loop is actually a useless concept because it's just naked pairs all the way through. No need to think in terms of chains at all.

Notations for these has always been wonky. Usually they start with the elimination cells and end with them

That would be a discontinuous nice loop (DNL) which is no longer a common way of expressing chains, for good reasons.

which show that both 6,7 for the cells are false based on the direction of reading the chain.

The reading direction doesn't change anything. By definition, an AIC (including DNLs) has the same result no matter how you read it. That's why a single XY-Chain is capable of eliminating a single digit only (possibly multiple candidates of it, though). Valid AIC eliminations can always be read just by looking at the end points and what they both see (even in a loop -- it just has many end point pairs). What's between the end points is irrelevant, as long as it proves there's a derived strong link between them.

For example, you have an XY-Chain with these two cells at the ends:

(1=2)r1c1 - ... - (2=1)r3c5 => -1 r1c456,r3c123

What are the end points? Answer: 1r1c1 and 1r3c5, nothing else. The chain proves that at least one of them must be true, so any 1 that sees both can be eliminated. It doesn't prove anything about the 2s, no matter what's in the dotted section (unless it contains subchains with their own end points). If you want to eliminate with the 2 as well, you need to build another chain with the 2 as the end point digit:

(2=1)r1c1 - ... - (1=2)r3c5 => -2 r1c456,r3c123

That's a completely different chain, even if it uses the same cells.

If you want to eliminate with both digits at the same time, then you need a chain which proves that the end points must contain both 1 and 2 together. Its end points would look something like this (conceptually; my previous examples show the real deal):

(12)r1c1,r3c5 = ... = (12)r1c1,r3c5 => -12 r1c456,r3c123

That can't be done with an XY-Chain, or any other simple chain. If you wish to disagree, I can only quote my good friend Dr House: "You could think I'm wrong, but that's no reason to stop thinking." I kind of dig to write chains capable of such multi-eliminations (latest example Aug 4), so I should hopefully have a decent grasp of what it actually takes.

(*) Added. [After some contemplating I can actually imagine a way to do it with a backpedaling XY- (or preferably AIC-) Loop. (Proof that I don't stop thinking even if I think I'm right ). I guess some would count that as a "simple chain". I don't, because it depends on spotting subchains which are worse than split-nodes.

(1=8)r2c5 - (8=1)r2c7 - (1=8)r3c9 - (8=1)r7c9 - (1=8)r3c9 - (8=1)r2c7 - (1=8)r2c5 - loop => -18 r7c5

In other words it's just an amalgam of these two XY-Chains:

(1=8)r2c5 - (8=1)r2c7 - (1=8)r3c9 - (8=1)r7c9 => -1 r7c5
(8=1)r2c5 - (1=8)r2c7 - (8=1)r3c9 - (1=8)r7c9 => -8 r7c5

It doesn't have any normal chain or loop eliminations at all (assuming naked pair eliminations have already been handled). However, if you look hard enough, it does contain two subchains which prove both 1r2c5==1r7c9 and 8r7c9==8r2c5. Another way of seeing it is that, as a loop, it proves that either all left hand terms or all right hand terms are true together, including 1r2c5&8r7c9 == 1r7c9&8r2c5.

So yeah, technically a Remote Pair can be written as a single, very weird, XY-Loop. That's not a normal XY-Chain, though, except in appearance. Are those subchains or the advanced loop logic easy to see? No, unless they're clearly marked. Is it any better than writing two chains? Not really. Does it need to be an XY-Chain? No. Here's the same as a a much shorter, smarter, and more readable AIC (two connected X-Chains, really):

(1)r2c5 = r2c7 - r3c9 = (1-8)r7c9 = r3c9 - r2c7 = (8)r2c5 - loop => -18 r7c5

The same logic applies to that, but it's much less cluttered. Still, it's a complete kludge just as well. In general, subchains are among my least favorite features. AICs relying on them don't count as simple chains either, even though they might look deceptively simple -- until you start to wonder how the eliminations work. I prefer chains/loops where the normal end points (or adjacent loop nodes) justify all eliminations, because they're much easier to read -- even if the nodes are more complex.]

Some fun with grouped nodes for remote pairs from way back... link

Thanks for that! Very interesting. It's the first time I actually see any discussion about the "general" type of Remote Pair. Seems that it has been covered here too, with a slightly different POV. Keith's example doesn't even have any group links. So, I guess we have at least General, Grouped, and Classic Remote Pairs then. All of them can be described as a pair of (grouped) X-Chains, which Keith fails to mention. I guess in the most general form the two X-Chains could even take completely different routes as long as they join in the same end point cells. An even more general form could use more complicated chain pairs as well. A new can of worms. Fun.

double-digit fish
Which is where that thread ended off noting lol

Yeah. However, as ronk points out in that thread, the double elimination needs too many cover sets, so it's no more possible with a single fish than with a single (simple) chain. In other words, this is in fact a shorthand for two fishes, not one:

(67)R3C6\r8c7b2 => -67 r8c7

If seen as a single fish, it has 4 base sets and 6 cover sets, i.e. Rank 2. The eliminations are only covered twice, which obviously isn't enough. Thus, it needs to be seen as two fishes (one for each digit) to have Rank 1 logic (2 bases, 3 covers) enabling the eliminations. Just like the chains.

[StrmCkr]

A short point

Two weak links between cells using 2 digits turns the weak link to a strong link

Code: Select all

 
(1)   Cell - (1) cell
 =.              =
(8) cell. - (8) cell


Means
(1=8) CELL = ( 1=8) cell

So the first and last =1 & 8 as a pair.
Which is applicable to xy chains, aics etc and is mentioned in some of the threads
Hence my comment that all common digits of the first and last are excluded from peers of the first and last cell
xy chains only use bivavles
You can expand the = sign with other link types not nesseisary to be bivavle.s and they still function but aren't xy chains any more.

So yes 1 chain is only needed for both eliminations under xy chain rules for a standard remote pair.

Yes reading direction does effect the common. Outcome for eliminations with out digit swapping

(1=8)r2c5 - (8=1)r2c7 - (1=8)r3c9 - (8=1)r7c9 => -1 r7c5
(8=1)r2c5 - (1=8)r2c7 - (8=1)r3c9 - (1=8)r7c9 => -8 r7c5

R2c5=1 then r7c9 =8
Backwards
R7c9=1 then R2c5 =8 thus the eliminations are 1&8 (and others are applicable but usually picked up by blr and baked pairs etc)

Your thinking that xy chains only examine 1 digit at a time from pathing when they do not.
It's easier to write the path out for 1 digit path then both at once.

[SpAce]

Sorry, I don't understand anything of your last post. Can you show with a concrete example what you mean?

[StrmCkr]

1 =2 = 1 =2

Cell. 1 has 2. Options
Cell 2 has 2 options
Cell. 1 and. 2 have the same ab options

Cell. 1 A implies B in cell 2
Cell 1 B implies A in cell 2

Both cells are double linked weakly which is a strong link.

All We are doing is expanding the middle link between a naked pair.
It will take me a lot of digging to find the history of that. Like I mentioned above in the edited post it's easier for the writing part of xy chains to list each individually following 1 path then what they are capable of under their construction rules.
Hodoku should print both eliminations but Im not on my desk top to check to see if he enabled that feature as we did discuss it in the past.
Probably not easy test is to see how an xy chain for a naked pair is handled.

[SpAce]

Hodoku should print both eliminations but Im not on my desk top to check to see if he enabled that feature as we did discuss it in the past.

Hodoku uses two XY-Chains for both Remote Pairs and Naked Pairs, one for each digit. As it should. I'd stop using it if otherwise.

It should, however, be able to show the Naked Pair as a loop (with both eliminations), but it doesn't.

Yes reading direction does effect the common

Are you seriously saying that you think AICs can produce different results depending on whether read from left-to-right or right-to-left? I hope you don't really mean that, so what exactly do you mean?