hi

I was thinking a bit about this, and what a general rule for this elimination might be. I am sure all this has been described many times before, and I do not claim it to be my invention, but I thought I would sum this up for myself, and maybe someone could benefit from it?

Let's first look at the UR type 4 rule...

- Code: Select all
` ab------ab`

| |

| |

| a |

xabx====xabx

so here my symbols are:

- Code: Select all
`ab - the Unique Rectangle`

xabx - to show that there are any number of more candidates present

=== - marks a strong link, here with the a's

So the logic for type 4 goes:

if you place a [b] in either of [xabx]

- Code: Select all
` ab------ab`

| |

| |

| a |

b=====xabx

then that forces the other [xabx] to become an [a] because they are stronly linked:

- Code: Select all
` ab------ab`

| |

| |

| |

b-------a

But this means you get a deadly pattern:

- Code: Select all
` a-------b`

| |

| |

| |

b-------a

and hence we can eliminate [b] from both [xabx]'s:

- Code: Select all
` ab------ab`

| |

| |

| a |

xax=====xax

And this is the UR type 4 rule as we all know it!

If we now look at a scenario with the [xabx]'s in separate corners:

- Code: Select all
` ab-----xabx`

| |

| |

| |

xabx-----ab

it is now actually enough to have just one strong link between two of the cells to be able to make a elimination, lets link two and see:

- Code: Select all
` ab-----xabx`

| |

| |

| a |

xabx=====ab

what would now happen if we put an [a] in the top right xabx:

- Code: Select all
` ab-------a`

| |

| |

| a |

xabx=====ab

Then the bottom right [ab] would become a [b]:

- Code: Select all
` ab-------a`

| |

| |

| a |

xabx======b

...and then, because of the strong link, the bottom left [xabx] would become a [a]:

- Code: Select all
` ab-------a`

| |

| |

| a |

a=======b

...and we would end up with a deadly pattern again:

- Code: Select all
` b-------a`

| |

| |

| |

a-------b

Which means that [a] can NOT go there, and we can eliminate it:

- Code: Select all
` ab------xbx`

| |

| |

| a |

xabx=====ab

And put in more general terms we could then say that:

- Code: Select all
`With a Unique Rectangle with the numbers [ab] that has two cells with "extra candidates" ([xabx]), and these cells are on a diagonal from each other, and you have a strong link between any two of the cells in the Rectangle for candidate [a], then you can eliminate candidate [a] from the cell with extra candidates that is not part of the strong link.`

What is quite handy about this generalisation, is that you only need to concider one strong link. In cases where there are more than one, all the other candidates you might be able to eliminate, will follow as single candidates eliminations because of the strong links!

Let's look at the example given:

- Code: Select all
`.------------.------------.------------. `

| 2 5 1 | 7 4 8 | 9 6 3 |

| 3 9 4 | 6 5 2 | 7 18 18 |

| 6 7 8 | 1 3 9 | 4 5 2 |

:------------+------------+------------:

| 5 26 267| 9 8 3 | 12 4 17 |

| 1 8 3 | 4 2 7 | 5 9 6 |

| 9 4 27 | 5 1 6 | 28 3 78 |

:------------+------------+------------:

| 8 3 *69 | 2 *679 4 | 16 17 5 |

| 4 26 5 | 8 67 1 | 3 27 9 |

| 7 1 *269| 3 *69 5 | 68 28 4 |

'------------'------------'------------'

It is now enough to notice that we have a uniqe rectangle for the 69's, the two cells with "other" candidates in them are diagonaly placed, and that for example the 9's in row 7 are strongly linked, to be able to say that r9c3<> 9. (we could also go: the 9's in column 3 are strongly linked, so r7c6<>9, or the 9's in column 5 are strongly linked, so r9c3<>9, or the 9's in row 9 are strongly linked, so r7c6<>9)

Now because of the other strong links that exists we then get that r7c3=6, and then again that r7c5=9 and then also r9c5=6 and then finally r9c3=9.

In other words no need for a rule that conciders the whole x-wing pattern!

This would also mean that I would disagree slightly with Vidar and call this a variation over the type 4, just because it eliminates the [b]same candidate that are strongly linked, rather then the

opposite candidate of the type 4. Don't you think this would get confusing if you blended the two into one "type" ? However, they both only need one strong link, so there are of course a lot of similarities too...

Any opinions?

Finally I would like to show this little freak:

- Code: Select all
` ab=====xabx`

| a ||

| b||

| ||

xabx----xabx

where this:

- Code: Select all
` ab=====xabx`

| a ||

| b||

| ||

a-----xabx

leads to:

- Code: Select all
` b=====xabx`

| a ||

| b||

| ||

a-----xabx

- Code: Select all
` b-------a`

| ||

| b||

| ||

a-----xabx

- Code: Select all
` b-------a`

| |

| |

| |

a-------b

...and hence you can do this elimination:

- Code: Select all
` ab=====xabx`

| a ||

| b||

| ||

xbx----xabx

enjoy!

Havard