The New Sudoku Players' Forum

[Jeff]

I am wondering if there is a simple rule that can be stated about such configurations.

Surely this grid can be solved by BUG. Is BUG simple enough? What kind of simple rule are you looking for?

[MadOverlord]

I am wondering if there is a simple rule that can be stated about such configurations.

Surely this grid can be solved by BUG. Is BUG simple enough? What kind of simple rule are you looking for?

Well, we know the simple run for a 1-polysquare BUG - the polysquare has to be the non-BUG value.

But finding the reductions for multi-polysquare BUGs can be difficult (see earlier in the thread when I was playing around with some possible shortcut rules).

So I was interested to see if there was a shortcut rule for this kind of BUG that might apply - one that could be simply expressed.

[Myth Jellies]

Code: Select all

+-------------+-------------+-------------+
| 3   4   7   | 6   1   2   | 8   5   9   |
| 9   6   8   | 5   7   3   | 1   2   4   |
| 5   12  12  | 4   9   8   | 7   3   6   |
+-------------+-------------+-------------+
| 8   9   5   | 12  3   14  | 24  6   7   |
| 124 12  6   | 7   24  9   | 5   8   3   |
| 7   3   24  | 8   5   6   | 24  9   1   |
+-------------+-------------+-------------+
| 6   8   3   | 12  24  7   | 9   14  5   |
| 124 7   124 | 9   6   5   | 3   14  8   |
| 14  5   9   | 3   8   14  | 6   7   2   |
+-------------+-------------+-------------+


This is not really a BUG grid, however setting r8c1 = 2 would make it a BUG. Therefore, r8c1 <> 2. We used to have a rule to cover this.

[Jeff]

Well, we know the simple run for a 1-polysquare BUG - the polysquare has to be the non-BUG value.

But finding the reductions for multi-polysquare BUGs can be difficult (see earlier in the thread when I was playing around with some possible shortcut rules).

So I was interested to see if there was a shortcut rule for this kind of BUG that might apply - one that could be simply expressed.

Hi MadOverlord, I have no idea for a shortcut rule for this BUG configuration. However, once the BUG grid is worked out, 2 deductions can be observed by inspection.

Code: Select all

+----------------+--------------+--------------+
| 3     4   7    |  6   1   2   |  8   5   9   |
| 9     6   8    |  5   7   3   |  1   2   4   |
| 5     12  12   |  4   9   8   |  7   3   6   |
+----------------+--------------+--------------+
| 8     9   5    |  12  3   14  |  24  6   7   |
| 14+2  12  6    |  7   24  9   |  5   8   3   |
| 7     3   24   |  8   5   6   |  24  9   1   |
+----------------+--------------+--------------+
| 6     8   3    |  12  24  7   |  9   14  5   |
| 2+14  7   14+2 |  9   6   5   |  3   14  8   |
| 14    5   9    |  3   8   14  |  6   7   2   |
+----------------+--------------+--------------+

r8c1=2 implies r5c1<>2 and r8c3<>2 => BUG
To avoid BUG, r8c1<>2 => r5c1=2 and r8c3=2

[MadOverlord]

This is not really a BUG grid, however setting r8c1 = 2 would make it a BUG. Therefore, r8c1 <> 2.

yep, on second look, you are absolutely right.

However, it does demonstrate a nice extension to the simple BUG rule I have in the Susser, which I will have to implement.

[Jeff]

This is not really a BUG grid, however setting r8c1 = 2 would make it a BUG. Therefore, r8c1 <> 2. We used to have a rule to cover this.

I think the rule for this case is:

Corollary 3: Any placement of a candidate which removes all non-BUG candidates is an invalid move.

[ronk]

I am wondering if there is a simple rule that can be stated about such configurations. Note that the two polyvalue squares that are in a single-polyvalue group (R5C1 in R5/B4 and R8C3 in C3/B7) both solve to the extra value, 2.

Even when three tri-valued cells having the same three candidates are arranged rectangularly, my guess is ... one can only conclude that a placement can be made in the tri-valued cell at the row-col intersection of the other two tri-valued cells.

Whether it's the 1, 2, or 4 (in this case) depends upon the contents of other cells ... so there's really no advantage gained by knowing the above AFAICT.

Ron

[Myth Jellies]

Jeff,

You are right, I read through the rules too quickly. I also forgot that you all are allowing single cell reductions to be part of the BUG grid, rather than the typical reduction to a bivalue cell.

[gir]

I'd like to preface this is my "First post", so I haven't read up as much as I'd like on other people's methods. Not too familiar with BUG.

However, in reference to finding a simple method for the doku above, I'd draw your attention to r9c1 which is linked to each of the polyvalued squares.

Letting r9c1 == 4 creates a "naked pair" (I believe it's called) on r5(b4), thus r5c5 == 4.
On the other hand, r4c6 must have the same value as r9c1 so r9c1 == 1 implies r5c5 == 4 again.

Trivial solution after that.

[Jeff]

Following the description of BUG-Light by MJ, is there any objection against updating/adjusting the first post? Proposed additions as follows:

A BUG-Light or BUG Cycle is a "continuous cycle" that exhibits similar properties of a BUG where all nodes in the cycle are bivalue and if a candidate exists in a row, column, or box, it shows up exactly twice. (example)

Corollary 5: All corollaries applied to a BUG can be applied to a BUG-Light or BUG cycle.

[Myth Jellies]

Here is a cool one for BUG-Lite...

Code: Select all

+----------------+----------------+----------------+
| 6    47   3    | 5    1    47   | 2    8    9    |
| 8   *57+2 27   | 6    9    3    | 4   *57   1    |
|*57+4 1    9    | 28   27   478  | 6    3   *57   |
+----------------+----------------+----------------+
| 1    8    6    | 9    3    5    | 7    2    4    |
| 47   247  5    | 28   6    78   | 1    9    3    |
| 9    3    27   | 4    27   1    | 5    6    8    |
+----------------+----------------+----------------+
|*25   9    8    | 7    4    6    | 3    1   *25   |
| 3   *57   4    | 1    8    2    | 9   *57   6    |
|*27   6    1    | 3    5    9    | 8    4   *27   |
+----------------+----------------+----------------+


...a BUG-Lite+2 pattern where the base 5's, 7's, and 2's in the starred cells all appear exactly twice in their groups (consider just the starred cells). Therefore, r2c2 = 2 and/or r3c1 = 4. Since the 5's are locked in box 1, we can eliminate the 7's from the starred cells in box 1. This results in a BUG+2 grid with the either of the tri-value cells in r3c6 and r5c2 having to equal 7. Thus r5c6 <> 7 => r5c6 = 8 which should solve the puzzle.

Not sure that the definition requires "continuous cycle", though it may work out that way, and that may be a convenient way for some to envision things and to refer to the cells/candidates that form the base.

[aeb]

Proposed additions as follows:

A BUG-Light or BUG Cycle is a "continuous cycle" that exhibits similar properties of a BUG where all nodes in the cycle are bivalue and if a candidate exists in a row, column, or box, it shows up exactly twice. (example)

Corollary 5: All corollaries applied to a BUG can be applied to a BUG-Light or BUG cycle.

There is nothing cycle-like, I would say. On my website I formulated my Local BUG Principle as

Theorem Suppose one writes some (more than 0) candidate numbers in some of the initially open cells of a given Sudoku diagram, 0 or 2 in each cell, such that each value occurs 0 or 2 times in any row, column, or box. Then this Sudoku diagram has an even number of completions that agree with at least one of the candidates in each cell where candidates were given. In particular, if the Sudoku diagram has a unique solution, then that unique solution differs from both candidates in at least one cell.

By the way, I cannot interpret your Corollary 4 - what does it say?

[Myth Jellies]

Looks like aeb also derived this "BUG-lite" concept--props to you, aeb .

The main thing is to describe it in enough ways, with enough examples, so that people can latch onto it as an extension of something they already know. Up until now, I don't think very many people have attempted to find and use these deadly patterns that encompass more than 2 different candidates, aside from the full-blown BUG. Some people are into cycles, and a cycle reference might provide a helpful connection. Others may be anti-cycle, yet okay with uniqueness. I wouldn't want to drive them away with cycles being a central part of the definition.

[Jeff]

Thanks for the feed back, MJ & Aeb.

In fact, every BUG-Lite is a continuous cycle. However, I think this piece of information can be omitted since it is all that helpful in identification of the pattern. So, here is the revised version.

A BUG-Lite is a partial BUG pattern that exhibits similar properties of a BUG where all nodes in the pattern are bivalue and if a candidate exists in a row, column, or box, it shows up exactly twice. (example)

Corollary 5: All corollaries applied to a BUG can be applied to a BUG-Lite.

Aeb, I don't disagree with your definition. However, I am just trying to make this BUG-Lite definition similar to the BUG definition that people have already got used to.

[hopeforestcom]

my solver can handle it.
Hi, I am Robin from montreal,Canada
I wrote a free sudoku solver.
Please try it.
http://www.hopeforest.com/download/download.html