The New Sudoku Players' Forum

[ravel]

Back to RW's explanation of the BUG-lite above. So this is a deadly pattern, where lines 1-3, lines 4-6, lines 7-9 and columns 1-3 or 4-7 may be switched (and bands and stacks) and digits may be missing:

Code: Select all

 ab  ab   .   |
  .   .   .   |
  .   .   .   |
--------------|-----------
 ac   .   ac  |
  .   .   .   |
  .   .   .   |
--------------|-----------
abc   .   .   | abc  .  .
 .   abc  .   | abc  .  .
 .    .  abc  | abc  .  .

[ronk]

As I couldn't decide ifI should describe this as a layered BUG-lite or a BUG-lite+1 after 2 eliminations, I just showed it the way I see it. I don't really make any difference between layered and ordinary BUG-lites, they all work in the same way.

I still haven't wrapped my head around the "layered BUG-Lite" ... so I've no useful comment there. But I think we should stick with the definition of a non-layered BUG-Lite having exactly two occurrences of a candidate in each row, column, and box.

[ravel]

In this case i think it is easier to see the 3 candidates. The pattern i showed above is just a variation of this one (in 2 boxes):

Code: Select all

abc abc abc
-----------
abc abc abc


[RW]

Back to RW's explanation of the BUG-lite above. So this is a deadly pattern, where lines 1-3, lines 4-6, lines 7-9 and columns 1-3 or 4-7 may be switched (and bands and stacks) and digits may be missing:

Code: Select all

 ab  ab   .   |
  .   .   .   |
  .   .   .   |
--------------|-----------
 ac   .   ac  |
  .   .   .   |
  .   .   .   |
--------------|-----------
abc   .   .   | abc  .  .
 .   abc  .   | abc  .  .
 .    .  abc  | abc  .  .

I wouldn't bet my head on that. An easy way to check if something is a deadly patern or not is simply to make a full grid with those values in the cells and remove them all. If it is an deadly pattern, the puzzle has multiple solutions. A grid with values 1,2,3 into the cells as you showed could give:

Code: Select all

 *-----------*
 |..3|674|958|
 |964|582|137|
 |875|913|642|
 |---+---+---|
 |.2.|465|789|
 |658|729|413|
 |497|831|526|
 |---+---+---|
 |.86|.47|395|
 |7.9|.58|264|
 |54.|.96|871|
 *-----------*

which has an unique solution... The deadly pattern I used can be seen in the end of this slightly altered version of wapatis puzzle (I'm actually very proud of this, only one given value changed ).

Code: Select all

 *-----------*
 |8..|.4.|7..|
 |9.2|.36|...|
 |5..|8.1|..3|
 |---+---+---|
 |19.|4..|65.|
 |...|.6.|.91|
 |...|..8|2..|
 |---+---+---|
 |..8|...|.4.|
 |.5.|..2|...|
 |...|..4|532|
 *-----------*

So what's the difference here? The difference is that by solving a few more cells, ravels pattern can be reduced to:

Code: Select all

 ab  ab   .   |
  .   .   .   |
  .   .   .   |
--------------|-----------
 ac   .   ac  |
  .   .   .   |
  .   .   .   |
--------------|-----------
ab    .   .   | ab   .  . | C
 .   ac   .   | ac   .  . | B
 .    .  bc   | bc   .  . | A

which doesn't fit the definition of a BUG-lite (candidate 'b' appears only once in columns 2 and 3, 'a' only once in column 3 and 'c' only once in column 2).

I haven't quite figured out yet how to safely use layered BUG-lites with oher than bivalue cells in the corners (boxes were the cells are diagonal instead of just vertical/horizontal). I've only noticed that it sometimes works, sometimes not. So to stay on the safe side I only layer the BUG-lites when the three cells are horizontal or vertical.

RW

[RW]

Hmm, on second thought, this pattern isn't always a valid BUG-lite either:

Code: Select all

.  ab ab |
---------+
bc bc .  |
---------+
bc .  .  | abc
.  .  ab | abc
.  ac .  | abc

It could be reduced to

Code: Select all

.  ab ab |
---------+
bc bc .  |
---------+
c  .  .  | ac  | B
.  .  b  | bc  | A
.  a  .  | ab  | C

or

.  ab ab |
---------+
bc bc .  |
---------+
b  .  .  | ab  | C
.  .  a  | ac  | B
.  c  .  | bc  | A

However, in wapati's puzzle it was already reduced to

Code: Select all

.  ab ab |
---------+
bc bc .  |
---------+
bc .  .  | abc |
.  .  ab | abc |
.  ac .  | ac  | B

which made both of the unique options impossible... So be careful if you use layered BUG-lites in patterns that have three cells in a corner box.

I think I've got a technique definition coming up that explains BUG-lites with three cells in a corner box a bit better. Need to refine it a bit and double check it, then I'll post it in the techniques section.

RW

[ronk]

No matter which is selected, the strong links on <8> are going to force [r2c8]=8 and [r8c7]=8. To the purists, I believe eliminations are actually performed. I'm just not sure which cells/eliminations.

Agreed. The strong inference of the UR (if r2c7<>4 then r8c8=6) and one strong link in a UR digit is sufficient for one exclusion.

r2c7=4|6=r8c8=8=r2c8-8-r2c7, implies r2c7<>8

The placements r2c8=8 and r8c7=8 follow via hidden singles. However, it is often fruitful to look for other exclusions before the UR is "destroyed".

[daj95376]

Thanks ronk for the explanation and advice that multiple eliminations can be performed inside the same UR. I also find your chain of interest. It describes which eliminations are performed and why. Very handy!

[wapati]

I don't see any elimination from the UR you mentioned.
Please, shed me some light!

Looking at the UR cells:

Code: Select all

    8
148----18


    8
18-----168

Here we have srong links on the 8s for each pair, meaning one of the cells must be an 8 both in row 2 and row 8. So if r2c7=8, then r8c8=8 and obviously the two remaining cells have to be 1, which completes the deadly pattern. Therefore r2c7<>8. Same goes for r8c8<>8. Hope this helped.

If you look carefully, you could also see that even without strong links, if r2c7=1 => r8c8=1 and if r8c8=1 => r2c7=1, and you can eliminate candidate 1 from both those cells also.

RW

It may be as plain as day for you.

What ONEs, what cells?

I am obtuse, sorry, I still don't understand where you eliminated what.

I am trying to learn.

[daj95376]

After a review of Keith's thread on the Fundamentals of Unique Rectangles, I came to the conclusion that we have a UR Type 6 -- an overlap of a UR in <18> and an X-Wing in <8>. Using Keith's example: [r2c7]<>8, [r8c8]<>8, [r2c8]<>1, and [r8c7]<>1. This is equivalent to my assignments: [r2c8]=8 and [r8c7]=8. As pointed out by others, additional/concurrent eliminations are supported as well in this puzzle.

[RW]

What ONEs, what cells?

I am obtuse, sorry, I still don't understand where you eliminated what.

Ok, so the basic idea is that this pattern

Code: Select all

A . . | B . .
B . . | A . .

cannot exist in an unique puzzle, unless one of the cells are a given clue.

Let's bring back the puzzle:

Code: Select all

 *--------------------------------------------------*
 | 8    137  13   | 2    4    57   | 9    16   567  |
 | 9    14   2    | 57   3    6    |*148 *18   57   |
 | 5    47   6    | 8    9    1    | 47   2    3    |
 |----------------+----------------+----------------|
 | 1    9    7    | 4    2    3    | 6    5    8    |
 | 2    8    4    | 57   6    57   | 3    9    1    |
 | 36   36   5    | 9    1    8    | 2    7    4    |
 |----------------+----------------+----------------|
 | 36   2    8    | 136  5    9    | 17   4    67   |
 | 4    5    13   | 136  7    2    |*18  *168  9    |
 | 7    16   9    | 16   8    4    | 5    3    2    |
 *--------------------------------------------------*

It should be obvious that if r2c7 or r8c8 = 1 or 8, then both r2c8 and r8c7 has to have the other value of the two. That's three corners of the UR in place. Now look at the 8s. What happens if r2c7=8? That's right, the only cell left in row 8 that can have that value is r8c8, which would complete the UR, therefore r2c7<>8. You can see in the same way that if r8c8=8 then r2c7=8 => r8c8<>8. Now what about the ones? There's more cells in both r1 and r8 that can have that value, but: in box 9 the only cells that can have the value 1 are in column 7 or r8c8. In box 3 the only cells that can have the value 1 are in column 8 or r2c7. So if r2c7=1 => r8c8=1, and the other way around, if r8c8=1 => r2c7=1. Both of those options would also complete the UR, so you can eliminate candidate 1 from both cells also. You can read more about different URs here.

Btw. I think the type of UR that eliminates candidates 1 should be defined as an UR with grouped strong links. I remember that I wrote about this kind of URs somewhere, but I couldn't find this correct word for them then.

RW

[ravel]

Oops, my 3-digit BUG-lite pattern was no good idea Thanks for pointing that out, RW.

To go "over the edge" with 3 digits, you would need 2 "blockers" on each side, like this.

Code: Select all

--
abc  abc  abc |
 .    .    .  |
 .    .    .  |
-------------
abc  abc  abc |
 .    .    .  |
 .    .    .  |
-------------
abc   .    .  | abc  .  .  | abc  .  .
 .   abc   .  | abc  .  .  | abc  .  .
 .    .   abc | abc  .  .  | abc  .  .


Then the conditions are met for a deadly pattern:

1. there are at least 2 ways to place the digits in the pattern
2. outside placements must not be able to fix them to 1 (or no) possibility

Taking this, the pattern in wapatis puzzle also is not deadly before making the eliminations Ron suggested (r7c4<>1 and r8c4<>6), because a 6 in r7c9 or a 1 in r8c78 would fix it (not to 1, but 0 possibilities).

Code: Select all

*--------------------------------------------------*
 | 8   *13+7*13   | 2    4    57   | 9    16   567  |
 | 9    14   2    | 57   3    6    | 148  18   57   |
 | 5    47   6    | 8    9    1    | 47   2    3    |
 |----------------+----------------+----------------|
 | 1    9    7    | 4    2    3    | 6    5    8    |
 | 2    8    4    | 57   6    57   | 3    9    1    |
 |*36  *36   5    | 9    1    8    | 2    7    4    |
 |----------------+----------------+----------------|
 |*36   2    8    |*136  5    9    | 17   4    67   |
 | 4    5   *13   |*136  7    2    | 18   168  9    |
 | 7   *16   9    |*16   8    4    | 5    3    2    |
 *--------------------------------------------------*


[RW]

To go "over the edge" with 3 digits, you would need 2 "blockers" on each side, like this.

Code: Select all

--
abc  abc  abc |
 .    .    .  |
 .    .    .  |
-------------
abc  abc  abc |
 .    .    .  |
 .    .    .  |
-------------
abc   .    .  | abc  .  .  | abc  .  .
 .   abc   .  | abc  .  .  | abc  .  .
 .    .   abc | abc  .  .  | abc  .  .

Perhaps, but there's already deadly patterns in r14c123 and r789c47, so I don't think we'll ever see one of those. I think it's quite impossible to find a useful application with 3-candidate per cell in the corner box, but I'm working on it.

Taking this, the pattern in wapatis puzzle also is not deadly before making the eliminations Ron suggested (r7c4<>1 and r8c4<>6), because a 6 in r7c9 or a 1 in r8c78 would fix it (not to 1, but 0 possibilities).

Yes, also true. But the eliminations are quite obvious. I was wondering if this pattern should be examined more, or is it just some kind of ALS?

Code: Select all

ab .  .  |*abc .   .
.  bc .  | .  #abc .
.  .  ac | .   .   ac

Eliminate 'c' from *abc and 'a' from #abc

RW

[ravel]

Perhaps, but there's already deadly patterns in r14c123 and r789c47.

Yes, thats what was confusing me: This pattern is deadly, though it can be influenced by outside placements (but always 2 possibilities remain).

Code: Select all

abc abc abc
-----------
abc abc abc


I was wondering if this pattern should be examined more, or is it just some kind of ALS?

Code: Select all

ab .  .  |*abc .   .
.  bc .  | .  #abc .
.  .  ac | .   .   ac

Eliminate 'c' from *abc and 'a' from #abc

I would say this is a variation of xyz-wing (dont know, if it has a name):

Code: Select all

.  .  .  | .  .   .
.  bc .  | .  abc .
.  .  ac | .   .  ac


r3c3=a => r3c6=c
r3c3=c => r2c2=b => pair ac in r2c5|r3c6
=> eliminate c from the rest of box 2.

[Edit:] Similar here:

Code: Select all

ab .  .  | abc  .   .
 .  .  . | .    .   .
 .  . ac | .    .  ac


r1c1=a => r3c3=c => r3c6=a
r1c1=b => pair ac in r2c5|r3c6.

[wapati]

Thanks RW, I follow it now. <whew>

[ronk]

But the eliminations are quite obvious. I was wondering if this pattern should be examined more, or is it just some kind of ALS?

Code: Select all

ab .  .  |*abc .   .
.  bc .  | .  #abc .
.  .  ac | .   .   ac

Eliminate 'c' from *abc and 'a' from #abc

I've been wondering the same thing. Keep thinking there should be an explanation based on uniqueness (or unavoidable sets) but that's not my forte.