StrmCkr wrote: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:

SpAce wrote: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:

SpAce wrote:(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.